tags rather than markdown images due to the need to set the width of the image explicitly.\n\ndev \nGraphics device to use for figure output (defaults to png)\n\ndf_print \nMethod to be used for printing data frames. Valid values include \"default\", \"kable\", \"tibble\", and \"paged\". The \"default\" method uses a corresponding S3 method of print, typically print.data.frame. The \"kable\" method uses the knitr::kable function. The \"tibble\" method uses the tibble package to print a summary of the data frame. The \"paged\" method creates a paginated HTML table (note that this method is only valid for formats that produce HTML). In addition to the named methods you can also pass an arbitrary function to be used for printing data frames. You can disable the df_print behavior entirely by setting the option rmarkdown.df_print to FALSE. See Data frame printing section in bookdown book for examples.\n\nincludes \nNamed list of additional content to include within the document (typically created using the includes function).\n\nmd_extensions \nMarkdown extensions to be added or removed from the default definition or R Markdown. See the rmarkdown_format for additional details.\n\npandoc_args \nAdditional command line options to pass to pandoc\n\next \nExtention of the output document (defaults to \".md\").\n\nDetails\n\nSee the online documentation for additional details on using the md_document format.\n\nR Markdown documents can have optional metadata that is used to generate a document header that includes the title, author, and date. For more details see the documentation on R Markdown metadata.\n\nValue\n\nR Markdown output format to pass to render\n## metadata\n\n`metadata` stores the YAML metadata of the current R Markdown document as a list, which you may use in the R code chunks, e.g. `rmarkdown::metadata$title` (the title of the document), `rmarkdown::metadata$author`, and `rmarkdown::metadata$foo` (if you have a YAML field named `foo`), etc.\n\n### Format\n\nAn object of class `list` of length 0.\n\n### Examples\n\n```r\nrmarkdown::metadata\n```\n\n---\n\n## odt_document\n\n`odt_document` is a function for converting from R Markdown to an ODT document.\n\n### Usage\n\n```r\nodt_document(\n number_sections = FALSE,\n fig_width = 5,\n fig_height = 4,\n fig_caption = TRUE,\n template = \"default\",\n reference_odt = \"default\",\n includes = NULL,\n keep_md = FALSE,\n)```\n```r\nmd_extensions = NULL,\npandoc_args = NULL\n)\n\nArguments\n\nnumber_sections\n TRUE to number section headings\n\nfig_width\n Default width (in inches) for figures\n\nfig_height\n Default height (in inches) for figures\n\nfig_caption\n TRUE to render figures with captions\n\ntemplate\n Pandoc template to use for rendering. Pass \"default\" to use the rmarkdown package default template; pass NULL to use pandoc’s built-in template; pass a path to use a custom template that you’ve created. See the documentation on pandoc online documentation for details on creating custom templates.\n\nreference_odt\n Use the specified file as a style reference in producing an odt file. For best results, the reference odt should be a modified version of an odt file produced using pandoc. Pass \"default\" to use the rmarkdown default styles.\n\nincludes\n Named list of additional content to include within the document (typically created using the includes function).\n\nkeep_md\n Keep the markdown file generated by knitting.\n\nmd_extensions\n Markdown extensions to be added or removed from the default definition or R Markdown. See the rmarkdown_format for additional details.\n\npandoc_args\n Additional command line options to pass to pandoc\n\nDetails\n\nSee the online documentation for additional details on using the odt_document format.\n\nR Markdown documents can have optional metadata that is used to generate a document header that includes the title, author, and date. For more details see the documentation on R Markdown metadata.\n\nR Markdown documents also support citations. You can find more information on the markdown syntax for citations in the Bibliographies and Citations article in the online documentation.\n\nValue\n\nR Markdown output format to pass to render\n\nExamples\n\n```r\n## Not run:\nlibrary(rmarkdown)\n\n# simple invocation\nrender(\"input.Rmd\", odt_document())\n\n# specify an option for syntax highlighting\n```\noutput_format\n\nDefine an R Markdown output format based on a combination of knitr and pandoc options.\n\nUsage\n\n```r\noutput_format(\n knitr,\n pandoc,\n keep_md = FALSE,\n clean_supporting = TRUE,\n df_print = NULL,\n pre_knit = NULL,\n post_knit = NULL,\n pre_processor = NULL,\n intermediates_generator = NULL,\n post_processor = NULL,\n on_exit = NULL,\n file_scope = NULL,\n base_format = NULL\n)\n```\n\nArguments\n\n- **knitr**: Knitr options for an output format (see `knitr_options`)\n- **pandoc**: Pandoc options for an output format (see `pandoc_options`)\n- **keep_md**: Keep the markdown file generated by knitting. Note that if this is `TRUE` then `clean_supporting` will always be `FALSE`.\n- **clean_supporting**: Cleanup any supporting files after conversion see `render_supporting_files`.\n- **df_print**: Method to be used for printing data frames. Valid values include \"default\", \"kable\", \"tibble\", and \"paged\". The \"default\" method uses a corresponding S3 method of `print`, typically `print.data.frame`. The \"kable\" method uses the `knitr::kable` function. The \"tibble\" method uses the `tibble` package to print a summary of the data frame. The \"paged\" method creates a paginated HTML table (note that this method is only valid for formats that produce HTML). In addition to the named methods you can also pass an arbitrary function to be used for printing data frames. You can disable the `df_print` behavior entirely by setting the option `rmarkdown.df_print` to `FALSE`. See Data frame printing section in bookdown book for examples.\n\nDescription\n\nDefine an R Markdown output format.\noutput_format\n\npre_knit \nAn optional function that runs before knitting which receives the input (input filename passed to render) and ...(for future expansion) arguments.\n\npost_knit\nAn optional function that runs after knitting which receives the metadata, input_file, runtime, and ...(for future expansion) arguments. This function can return additional arguments to pass to pandoc and can call knitr::knit_meta_add to add additional dependencies based on the contents of the input_file or on other assets side by side with it that may be used to produce html with dependencies during subsequent processing.\n\npre_processor\nAn optional pre-processor function that receives the metadata, input_file, runtime, knit_meta, files_dir, and output_dir and can return additional arguments to pass to pandoc.\n\nintermediates_generator\nAn optional function that receives the original input_file, and the intermediates directory (i.e. the intermediates_dir argument to render). The function should generate and return the names of any intermediate files required to render the input_file.\n\npost_processor\nAn optional post-processor function that receives the metadata, input_file, output_file, clean, and verbose parameters, and can return an alternative output_file.\n\non_exit\nA function to call when rmarkdown::render() finishes execution (as registered with a on.exit handler).\n\nfile_scope\nA function that will split markdown input to pandoc into multiple named files. This is useful when the caller has concatenated a set of Rmd files together (as bookdown does), and those files may need to processed by pandoc using the --file-scope option. The function should return a named list of files w/ name and content for each file.\n\nbase_format\nAn optional format to extend.\n\nValue\n\nAn R Markdown output format definition that can be passed to render.\n\nSee Also\n\nrender, knitr_options, pandoc_options\n\nExamples\n\n### Not run:\noutput_format(knitr = knitr_options(opts_chunk = list(dev = 'png')),\n pandoc = pandoc_options(to = \"html\"))\n\n### End(Not run)\noutput_metadata The output metadata object\n\nDescription\n\nThis object provides a mechanism for users to attach metadata as an attribute (named rmd_output_metadata) of the returned value of render(). The initial value of the metadata comes from in the rmd_output_metadata field of the YAML frontmatter of an R Markdown document. The metadata can be queried via the output_metadata$get() method, and modified via the output_metadata$set() method.\n\npaged_table Create a table in HTML with support for paging rows and columns\n\nDescription\n\nCreate a table in HTML with support for paging rows and columns\n\nUsage\n\npaged_table(x, options = NULL)\n\nArguments\n\nx a data frame to be rendered as a paged table.\noptions options for printing the paged table. See details for specifics.\n\nDetails\n\nBelow are the recognized table pagination options.\n\n<table>\n<thead>\n<tr>\n<th>Option</th>\n<th>Description</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>max.print</td>\n<td>The number of rows to print.</td>\n<td>1000</td>\n</tr>\n<tr>\n<td>sql.max.print</td>\n<td>The number of rows to print from a SQL data table.</td>\n<td>1000</td>\n</tr>\n<tr>\n<td>rows.print</td>\n<td>The number of rows to display.</td>\n<td>10</td>\n</tr>\n<tr>\n<td>cols.print</td>\n<td>The number of columns to display.</td>\n<td>10</td>\n</tr>\n<tr>\n<td>cols.min.print</td>\n<td>The minimum number of columns to display.</td>\n<td>-</td>\n</tr>\n<tr>\n<td>pages.print</td>\n<td>The number of pages to display under page navigation.</td>\n<td>-</td>\n</tr>\n<tr>\n<td>paged.print</td>\n<td>When set to FALSE turns off paged tables.</td>\n<td>TRUE</td>\n</tr>\n<tr>\n<td>rownames.print</td>\n<td>When set to FALSE turns off row names.</td>\n<td>TRUE</td>\n</tr>\n</tbody>\n</table>\n\nNote: There is a hard cap of 10,000 rows to ensure that pandoc will not fail when rendering the document.\nFunctions for generating pandoc command line arguments\n\nDescription\n\nFunctions that assist in creating various types of pandoc command line arguments (e.g. for templates, table of contents, highlighting, and content includes).\n\nUsage\n\npandoc_variable_arg(name, value)\npandoc_metadata_arg(name, value)\npandoc_include_args(in_header = NULL, before_body = NULL, after_body = NULL)\npandoc_highlight_args(highlight, default = \"tango\")\npandoc_latex_engine_args(latex_engine)\npandoc_toc_args(toc, toc_depth = 3)\npandoc_citeproc_args()\npandoc_lua_filter_args(lua_files)\n\nArguments\n\nname Name of template variable to set.\nvalue Value of template variable (defaults to true if missing).\nin_header One or more files with content to be included in the header of the document.\nbefore_body One or more files with content to be included before the document body.\nafter_body One or more files with content to be included after the document body.\nhighlight The name of a pandoc syntax highlighting theme.\ndefault The highlighting theme to use if \"default\" is specified.\nlatex_engine LaTeX engine for producing PDF output. Options are \"pdflatex\", \"lualatex\", \"xelatex\", and \"tectonic\".\ntoc TRUE to include a table of contents in the output.\ntoc_depth Depth of headers to include in table of contents.\nlua_files Character vector of file paths to Lua filter files. Paths will be transformed by pandoc_path_arg.\nDetails\n\nNon-absolute paths for resources referenced from the in_header, before_body, and after_body parameters are resolved relative to the directory of the input document.\n\nValue\n\nA character vector with pandoc command line arguments.\n\nAbout Pandoc citeproc\n\nFor Pandoc version before 2.11, a pandoc filter 'pandoc-citeproc' is used. Since Pandoc 2.11, the feature is built-in and activated using '--citeproc' flag. 'pandoc_citeproc_arg' will return the correct switches depending on the Pandoc version in use.\n\nExamples\n\n## Not run:\nlibrary(rmarkdown)\npandoc_include_args(before_body = \"header.htm\")\npandoc_include_args(before_body = \"header.tex\")\npandoc_highlight_args(\"kate\")\npandoc_latex_engine_args(\"pdflatex\")\npandoc_toc_args(toc = TRUE, toc_depth = 2)\n## End(Not run)\n\n---\n\npandoc_available Check pandoc availability and version\n\nDescription\n\nDetermine whether pandoc is currently available on the system (optionally checking for a specific version or greater). Determine the specific version of pandoc available.\n\nUsage\n\npandoc_available(version = NULL, error = FALSE)\npandoc_version()\n\nArguments\n\n- **version**: Required version of pandoc\n- **error**: Whether to signal an error if pandoc with the required version is not found\nThe system environment variable ‘PATH’ as well as the version of pandoc shipped with RStudio (its location is set via the environment variable ‘RSTUDIO_PANDOC’ by RStudio products like the RStudio IDE, RStudio Server, Shiny Server, and RStudio Connect, etc) are scanned for pandoc and the highest version available is used. Please do not modify the environment variable ‘RSTUDIO_PANDOC’ unless you know what it means.\n\npandoc_available returns a logical indicating whether the required version of pandoc is available. pandoc_version returns a numeric_version with the version of pandoc found.\n\nExamples\n\n```r\n## Not run:\nlibrary(rmarkdown)\n\nif (pandoc_available())\n cat(\"pandoc\", as.character(pandoc_version()), \"is available!\n\"\n\nif (pandoc_available(\"1.12.3\"))\n cat(\"required version of pandoc is available!\n\"\n\n## End(Not run)\n```\n\n### pandoc_citeproc_convert\n\n**Convert a bibliography file**\n\n**Description**\n\nConvert a bibliography file (e.g. a BibTeX file) to an R list, JSON text, or YAML text\n\n**Usage**\n\n```r\npandoc_citeproc_convert(file, type = c(\"list\", \"json\", \"yaml\"))\n```\n\n**Arguments**\n\n- **file** - Bibliography file\n- **type** - Conversion type\n\n**Value**\n\nFor ‘type = \"list\"’, and R list. For ‘type = \"json\"’ or ‘type = \"yaml\"’, a character vector with the specified format.\n**pandoc_convert** \nConvert a document with pandoc\n\n---\n\n**Description**\n\nConvert documents to and from various formats using the pandoc utility.\n\n**Usage**\n\n```r\npandoc_convert(\n input, \n to = NULL, \n from = NULL, \n output = NULL, \n citeproc = FALSE, \n options = NULL, \n verbose = FALSE, \n wd = NULL\n)\n```\n\n**Arguments**\n\n- `input` \n Character vector containing paths to input files (files must be UTF-8 encoded)\n- `to` \n Format to convert to (if not specified, you must specify `output`)\n- `from` \n Format to convert from (if not specified then the format is determined based on the file extension of `input`).\n- `output` \n Output file (if not specified then determined based on format being converted to).\n- `citeproc` \n TRUE to run the pandoc-citeproc filter (for processing citations) as part of the conversion.\n- `options` \n Character vector of command line options to pass to pandoc.\n- `verbose` \n TRUE to show the pandoc command line which was executed\n- `wd` \n Working directory in which code will be executed. If not supplied, defaults to the common base directory of `input`.\n\n**Details**\n\nSupported input and output formats are described in the pandoc user guide.\n\nThe system path as well as the version of pandoc shipped with RStudio (if running under RStudio) are scanned for pandoc and the highest version available is used.\nExamples\n\n## Not run:\nlibrary(rmarkdown)\n\n# convert markdown to various formats\npandoc_convert(\"input.md\", to = \"html\")\npandoc_convert(\"input.md\", to = \"latex\")\n\n# process citations\npandoc_convert(\"input.md\", to = \"html\", citeproc = TRUE)\n\n# add some pandoc options\npandoc_convert(\"input.md\", to = \"latex\", options = c(\"--listings\"))\n\n## End(Not run)\n\npandoc_exec\n\nGet the path of the pandoc executable\n\nDescription\n\nReturns the path of the pandoc executable used by functions in the \\pkg{rmarkdown} package. This is the most recent version of pandoc found in either the system path or shipped with RStudio.\n\nUsage\n\npandoc_exec()\n\nDetails\n\nSee the \\pkg{pandoc} manual for pandoc commands.\n\npandoc_options\n\nPandoc options for an output format\n\nDescription\n\nDefine the pandoc options for an R Markdown output format.\nUsage\n\npandoc_options(\n to,\n from = rmarkdown_format(),\n args = NULL,\n keep_tex = FALSE,\n latex_engine = c(\"pdflatex\", \"lualatex\", \"xelatex\", \"tectonic\"),\n ext = NULL,\n lua_filters = NULL\n)\n\nArguments\n\nto Pandoc format to convert to\nfrom Pandoc format to convert from\nargs Character vector of command line arguments to pass to pandoc\nkeep_tex Keep the intermediate tex file used in the conversion to PDF (applies only to 'latex' and 'beamer' target formats)\nlatex_engine LaTeX engine to producing PDF output (applies only to 'latex' and 'beamer' target formats)\next File extension (e.g. \".tex\") for output file (if NULL chooses default based on to). This is typically used to force the final output of a latex or beamer conversion to be .tex rather than .pdf.\nlua_filters Character vector of file paths to Lua filters to use with this format. They will be added to pandoc command line call using --lua-filter argument. See vignette(\"lua-filters\",package = \"rmarkdown\") to know more about Lua filters.\n\nDetails\n\nThe from argument should be used very cautiously as it's important for users to be able to rely on a stable definition of supported markdown extensions.\n\nValue\n\nAn list that can be passed as the pandoc argument of the output_format function.\n\nSee Also\n\noutput_format, rmarkdown_format\n**pandoc_path_arg**\n\n_Transform path for passing to pandoc_\n\n**Description**\nTransform a path for passing to pandoc on the command line. Calls `path.expand` on all platforms. On Windows, transform it to a short path name if it contains spaces, and then convert forward slashes to backslashes (as required by pandoc for some path references).\n\n**Usage**\n```\npandoc_path_arg(path, backslash = TRUE)\n```\n\n**Arguments**\n- **path**: Path to transform\n- **backslash**: Whether to replace forward slashes in `path` with backslashes on Windows.\n\n**Value**\nTransformed path that can be passed to pandoc on the command line.\n\n**pandoc_self_contained_html**\n\n_Create a self-contained HTML document using pandoc_\n\n**Description**\nCreate a self-contained HTML document by base64 encoding images, scripts, and stylesheets referred by the input document.\n\n**Usage**\n```\npandoc_self_contained_html(input, output)\n```\n\n**Arguments**\n- **input**: Input html file to create self-contained version of.\n- **output**: Path to save output.\n\n**Value**\n(Invisibly) The path of the generated file.\npandoc_template Render a pandoc template.\n\nDescription\nUse the pandoc templating engine to render a text file. Substitutions are done using the metadata list passed to the function.\n\nUsage\npandoc_template(metadata, template, output, verbose = FALSE)\n\nArguments\n- metadata: A named list containing metadata to pass to template.\n- template: Path to a pandoc template.\n- output: Path to save output.\n- verbose: TRUE to show the pandoc command line which was executed.\n\nValue\n(Invisibly) The path of the generated file.\n\nparse_html_notebook Parse an HTML Notebook\n\nDescription\nParse an HTML notebook, retrieving annotation information related to generated outputs in the document, as well as the original R Markdown source document.\n\nUsage\nparse_html_notebook(path)\n\nArguments\n- path: The path to an R Notebook file (with extension .nb.html).\n\nDetails\nSee the online documentation for additional details on using the html_notebook format.\n**pdf_document**\n\nConvert to a PDF/LaTeX document\n\n**Description**\n\nFormats for converting from R Markdown to a PDF or LaTeX document.\n\n**Usage**\n\n```r\npdf_document(\n toc = FALSE,\n toc_depth = 2,\n number_sections = FALSE,\n fig_width = 6.5,\n fig_height = 4.5,\n fig_crop = \"auto\",\n fig_caption = TRUE,\n dev = \"pdf\",\n df_print = \"default\",\n highlight = \"default\",\n template = \"default\",\n keep_tex = FALSE,\n keep_md = FALSE,\n latex_engine = \"pdflatex\",\n citation_package = c(\"default\", \"natbib\", \"biblatex\"),\n includes = NULL,\n md_extensions = NULL,\n output_extensions = NULL,\n pandoc_args = NULL,\n extra_dependencies = NULL\n)\nlatex_document(...)\nlatex_fragment(...)\n```\n\n**Arguments**\n\n- **toc**\n TRUE to include a table of contents in the output\n- **toc_depth**\n Depth of headers to include in table of contents\n- **number_sections**\n TRUE to number section headings\n- **fig_width**\n Default width (in inches) for figures\n- **fig_height**\n Default height (in inches) for figures\nfig_crop Whether to crop PDF figures with the command `pdfcrop`. This requires the tools `pdfcrop` and `ghostscript` to be installed. By default, `fig_crop = TRUE` if these two tools are available.\n\nfig_caption TRUE to render figures with captions\n\ndev Graphics device to use for figure output (defaults to pdf)\n\ndf_print Method to be used for printing data frames. Valid values include \"default\", \"kable\", \"tibble\", and \"paged\". The \"default\" method uses a corresponding S3 method of print, typically `print.data.frame`. The \"kable\" method uses the `knitr::kable` function. The \"tibble\" method uses the `tibble` package to print a summary of the data frame. The \"paged\" method creates a paginated HTML table (note that this method is only valid for formats that produce HTML). In addition to the named methods you can also pass an arbitrary function to be used for printing data frames. You can disable the `df_print` behavior entirely by setting the option `rmarkdown.df_print` to FALSE. See Data frame printing section in bookdown book for examples.\n\n\ntemplate Pandoc template to use for rendering. Pass \"default\" to use the `rmarkdown` package default template; pass NULL to use pandoc’s built-in template; pass a path to use a custom template that you’ve created. See the documentation on pandoc online documentation for details on creating custom templates.\n\nkeep_tex Keep the intermediate tex file used in the conversion to PDF\n\nkeep_md Keep the markdown file generated by knitting.\n\nlatex_engine LaTeX engine for producing PDF output. Options are \"pdflatex\", \"lualatex\", \"xelatex\" and \"tectonic\".\n\ncitation_package The LaTeX package to process citations, `natbib` or `biblatex`. Use default if neither package is to be used, which means citations will be processed via the command `pandoc-citeproc`.\n\nincludes Named list of additional content to include within the document (typically created using the `includes` function).\n\nmd_extensions Markdown extensions to be added or removed from the default definition or R Markdown. See the rmarkdown_format for additional details.\n\noutput_extensions Pandoc extensions to be added or removed from the output format, e.g., \"-smart\" means the output format will be `latex-smart`.\n\npandoc_args Additional command line options to pass to pandoc\n\nextra_dependencies A LaTeX dependency `latex_dependency()`, a list of LaTeX dependencies, a character vector of LaTeX package names (e.g. `c(\"framed\",\"hyperref\")`), or a named list of LaTeX package options with the names being package names (e.g. `list(hyperref = c(\"unicode=true\",\"breaklinks=true\"), lmodern = NULL)`). It can be used to add custom LaTeX packages to the .tex header.\n\n... Arguments passed to `pdf_document()`.\nDetails\n\nSee the online documentation for additional details on using the pdf_document format.\n\nCreating PDF output from R Markdown requires that LaTeX be installed.\n\nR Markdown documents can have optional metadata that is used to generate a document header that includes the title, author, and date. For more details see the documentation on R Markdown metadata.\n\nR Markdown documents also support citations. You can find more information on the markdown syntax for citations in the Bibliographies and Citations article in the online documentation.\n\nMany aspects of the LaTeX template used to create PDF documents can be customized using metadata. For example:\n\n```yaml\n---\ntitle: \"Crop Analysis Q3 2013\"\nfontsize: 11pt\ngeometry: margin=1in\n---\n```\n\nAvailable metadata variables include:\n\n- `lang` Document language code (e.g. \"es\", \"fr\", \"pt-BR\")\n- `fontsize` Font size (e.g. 10pt, 11pt, 12pt)\n- `documentclass` LaTeX document class (e.g. article)\n- `classoption` Option for `documentclass` (e.g. `oneside`); may be repeated\n- `geometry` Options for `geometry` class (e.g. `margin=1in`); may be repeated\n- `mainfont, sansfont, monofont, mathfont` Document fonts (works only with xelatex and lualatex, see the `latex_engine` option)\n- `linkcolor, urlcolor, citecolor` Color for internal, external, and citation links (red, green, magenta, cyan, blue, black)\n- `linestretch` Options for line spacing (e.g. 1, 1.5, 3)\n\nValue\n\nR Markdown output format to pass to `render`\n\nExamples\n\n```r\n## Not run:\nlibrary(rmarkdown)\n\n# simple invocation\nrender(\"input.Rmd\", pdf_document())\n```\n\n```r\n# specify an option for latex engine\nrender(\"input.Rmd\", pdf_document(latex_engine = \"lualatex\"))\n```\n\n```r\n# add a table of contents and pass an option to pandoc\n```\npkg_file_lua\n\nGet the full paths of Lua filters in an R package\n\n**Description**\n\nLua filters stored in a source package in the `inst/rmarkdown/lua` directory will be installed to the `rmarkdown/lua` directory in the package path. This function finds the full paths of the Lua filters in the installed packages.\n\n**Usage**\n\n```r\npkg_file_lua(filters = NULL, package = \"rmarkdown\")\n```\n\n**Arguments**\n\n- `filters`: A character vector of filenames for Lua filters to be retrieved in `rmarkdown/lua` folder of the package. By default (NULL), if none is provided, it returns all filters in that folder.\n- `package`: The name of the package in which to look for the filters.\n\n**Value**\n\nA character vector of absolute file paths for the Lua filter from the package. The returned paths have been processed by `pandoc_path_arg()`, so they are ready to be used by Pandoc.\n\n**Examples**\n\n```r\n# list all Lua filters stored in the rmarkdown package\npkg_file_lua()\n# get a specific filter\npkg_file_lua(c(\"pagebreak.lua\", \"latex_div.lua\"))\n```\n\n**powerpoint_presentation**\n\n*Convert to a PowerPoint presentation*\n\n**Description**\n\nFormat for converting from R Markdown to a PowerPoint presentation. Pandoc v2.0.5 or above is required.\nUsage\n\n```r\npowerpoint_presentation(\n toc = FALSE,\n toc_depth = 2,\n number_sections = FALSE,\n fig_width = 5,\n fig_height = 4,\n fig_caption = TRUE,\n df_print = \"default\",\n keep_md = FALSE,\n md_extensions = NULL,\n slide_level = NULL,\n reference_doc = \"default\",\n pandoc_args = NULL\n)\n```\n\nArguments\n\n- **toc** `TRUE` to include a table of contents in the output\n- **toc_depth** Depth of headers to include in table of contents\n- **number_sections** `TRUE` to number section headings\n- **fig_width** Default width (in inches) for figures\n- **fig_height** Default height (in inches) for figures\n- **fig_caption** `TRUE` to render figures with captions\n- **df_print** Method to be used for printing data frames. Valid values include \"default\", \"kable\", \"tibble\", and \"paged\". The \"default\" method uses a corresponding S3 method of print, typically `print.data.frame`. The \"kable\" method uses the `knitr::kable` function. The \"tibble\" method uses the `tibble` package to print a summary of the data frame. The \"paged\" method creates a paginated HTML table (note that this method is only valid for formats that produce HTML). In addition to the named methods you can also pass an arbitrary function to be used for printing data frames. You can disable the df_print behavior entirely by setting the option `rmarkdown.df_print` to FALSE. See Data frame printing section in bookdown book for examples.\n- **keep_md** Keep the markdown file generated by knitting.\n- **md_extensions** Markdown extensions to be added or removed from the default definition or R Markdown. See the `rmarkdown_format` for additional details.\n- **slide_level** The heading level which defines individual slides. By default this is the highest header level in the hierarchy that is followed immediately by content, and not another header, somewhere in the document. This default can be overridden by specifying an explicit slide_level.\n- **reference_doc** Path to a PowerPoint template.\n- **pandoc_args** Additional command line options to pass to pandoc\nValue\n\nR Markdown output format to pass to render\n\n**publish_site** \n*Publish an R Markdown Website*\n\nDescription\n\nPublish a website to RStudio Connect\n\nUsage\n\n```r\npublish_site(\n site_dir = \".\",\n site_name = NULL,\n method = c(\"rsconnect\"),\n server = NULL,\n account = NULL,\n render = TRUE,\n launch_browser = interactive()\n)\n```\n\nArguments\n\n- **site_dir**: Directory containing website. Defaults to current working directory.\n- **site_name**: Name for the site (names must be unique within an account). Defaults to the 'name' provided by the site generator (or to the name of the site_dir if there is no 'name' specified).\n- **method**: Publishing method (currently only \"rsconnect\" is available)\n- **server**: Server name. Required only if you use the same account name on multiple servers.\n- **account**: Account to deploy application to. This parameter is only required for the initial deployment of an application when there are multiple accounts configured on the system.\n- **render**: 'TRUE' to render the site locally before publishing.\n- **launch_browser**: If 'TRUE', the system's default web browser will be launched automatically after the site is deployed. Defaults to 'TRUE' in interactive sessions only.\n\nExamples\n\n```r\n## Not run:\nlibrary(rmarkdown)\npublish_site()\n```\n\n## End(Not run)\nrelative_to Relative path utility function\n\nDescription\nGiven a directory and a file, return a relative path from the directory to the file, or the unmodified file path if the file does not appear to be in the directory.\n\nUsage\nrelative_to(dir, file)\n\nArguments\ndir Directory\nfile File\n\nValue\nRelative path from the directory to the file (or the unmodified file path if the file does not appear to be in the directory).\n\nrender Render R Markdown\n\nDescription\nRender the input file to the specified output format using pandoc. If the input requires knitting then knit is called prior to pandoc.\n\nUsage\nrender(\n input,\n output_format = NULL,\n output_file = NULL,\n output_dir = NULL,\n output_options = NULL,\n output_yaml = NULL,\n intermediates_dir = NULL,\n knit_root_dir = NULL,\n runtime = c(\"auto\", \"static\", \"shiny\", \"shinyrmd\", \"shiny_prerendered\"),\n clean = TRUE,\n params = NULL,\n knit_meta = NULL,\nenvir = parent.frame(),\nrun_pandoc = TRUE,\nquiet = FALSE,\nencoding = \"UTF-8\"\n)\n\nArguments\n\ninput The input file to be rendered. This can be an R script (.R), an R Markdown\ndocument (.Rmd), or a plain markdown document.\n\noutput_format The R Markdown output format to convert to. The option \"all\" will render\nall formats defined within the file. The option can be the name of a format (e.g.\n\"html_document\") and that will render the document to that single format. One\ncan also use a vector of format names to render to multiple formats. Alternatively,\nyou can pass an output format object (e.g. html_document()). If using\nNULL then the output format is the first one defined in the YAML frontmatter in\nthe input file (this defaults to HTML if no format is specified there). If you pass\nan output format object to output_format, the options specified in the YAML\nheader or _output.yml will be ignored and you must explicitly set all the op-\ntions you want when you construct the object. If you pass a string, the output\nformat will use the output parameters in the YAML header or _output.yml.\n\noutput_file The name of the output file. If using NULL then the output filename will be\nbased on filename for the input file. If a filename is provided, a path to the\noutput file can also be provided. Note that the output_dir option allows for\nspecifying the output file path as well, however, if also specifying the path, the\ndirectory must exist. If output_file is specified but does not have a file exten-\nsion, an extension will be automatically added according to the output format.\nTo avoid the automatic file extension, put the output_file value in I(), e.g.,\nI('my-output').\n\noutput_dir The output directory for the rendered output_file. This allows for a choice\nof an alternate directory to which the output file should be written (the default\noutput directory of that of the input file). If a path is provided with a filename in\noutput_file the directory specified here will take precedence. Please note that\nany directory path provided will create any necessary directories if they do not\nexist.\n\noutput_options List of output options that can override the options specified in metadata (e.g.\ncould be used to force self_contained or mathjax = \"local\"). Note that this\nis only valid when the output format is read from metadata (i.e. not a custom\nformat object passed to output_format).\n\noutput_yaml Paths to YAML files specifying output formats and their configurations. The first\nexisting one is used. If none are found, then the function searches YAML files\nspecified to the output_yaml top-level parameter in the YAML front matter,\n_output.yml or _output.yaml, and then uses the first existing one.\n\nintermediates_dir Intermediate files directory. If a path is specified then intermediate files will be\nwritten to that path. If NULL, intermediate files are written to the same directory\nas the input file.\n**knit_root_dir** The working directory in which to knit the document; uses knitr’s root.dir knit option. If NULL then the behavior will follow the knitr default, which is to use the parent directory of the document.\n\n**runtime** The runtime target for rendering. The static option produces output intended for static files; shiny produces output suitable for use in a Shiny document (see run). The default, auto, allows the runtime target specified in the YAML metadata to take precedence, and renders for a static runtime target otherwise.\n\n**clean** Using TRUE will clean intermediate files that are created during rendering.\n\n**params** A list of named parameters that override custom params specified within the YAML front-matter (e.g. specifying a dataset to read or a date range to confine output to). Pass “ask” to start an application that helps guide parameter configuration.\n\n**knit_meta** (This option is reserved for expert use.) Metadata generated by knitr.\n\n**envir** The environment in which the code chunks are to be evaluated during knitting (can use new.env() to guarantee an empty new environment).\n\n**run_pandoc** An option for whether to run pandoc to convert Markdown output.\n\n**quiet** An option to suppress printing during rendering from knitr, pandoc command line and others. To only suppress printing of the last “Output created: ” message, you can set rmarkdown.render.message to FALSE.\n\n**encoding** Ignored. The encoding is always assumed to be UTF-8.\n\n### Details\n\nNote that the **knitr** error option is set to FALSE during rendering (which is different from the **knitr** default value of TRUE).\n\nFor additional details on rendering R scripts see Compiling R scripts to a notebook.\n\nIf no **output_format** parameter is specified then the output format is read from the YAML front-matter of the input file. For example, the following YAML would yield a PDF document:\n\n```yaml\noutput: pdf_document\n```\n\nAdditional format options can also be specified in metadata. For example:\n\n```yaml\noutput:\n pdf_document:\n toc: true\n highlight: zenburn\n```\n\nMultiple formats can be specified in metadata. If no **output_format** is passed to render then the first one defined will be used:\n\n```yaml\noutput:\n pdf_document:\n toc: true\n highlight: zenburn\n html_document:\n toc: true\n theme: united\n```\nFormats specified in metadata can be any one of the built in formats (e.g. `html_document`, `pdf_document`) or a format defined in another package (e.g. `pkg::custom_format`).\n\nIf there is no format defined in the YAML then `html_document` will be used.\n\n**Value**\n\nWhen `run_pandoc = TRUE`, the compiled document is written into the output file, and the path of the output file is returned. When `run_pandoc = FALSE`, the path of the Markdown output file, with attributes `knit_meta` (the `knitr` meta data collected from code chunks) and `intermediates` (the intermediate files/directories generated by `render()`).\n\n**R Markdown**\n\nR Markdown supports all of the base pandoc markdown features as well as some optional features for compatibility with GitHub Flavored Markdown (which previous versions of R Markdown were based on). See `rmarkdown_format` for details.\n\n**See Also**\n\n`knit`, `output_format`, `https://pandoc.org`\n\n**Examples**\n\n```r\n## Not run:\nlibrary(rmarkdown)\n\n# Render the default (first) format defined in the file\nrender(\"input.Rmd\")\n\n# Render all formats defined in the file\nrender(\"input.Rmd\", \"all\")\n\n# Render a single format, using parameters for `html_document` from\n# the YAML header parameters.\nrender(\"input.Rmd\", \"html_document\")\n\n# Render a single format, ignoring parameters for `html_document` in\n# the YAML header. Any parameters not passed as arguments to\n# `html_document()` will be assigned to their default values, regardless\n# of anything in the YAML header\nrender(\"input.Rmd\", html_document(toc = TRUE, toc_depth = 2))\n\n# Render multiple formats\nrender(\"input.Rmd\", c(\"html_document\", \"pdf_document\"))\n\n## End(Not run)\n```\nDescription\n\nIn a Shiny document, evaluate the given expression after the document has finished rendering, instead of during render.\n\nUsage\n\n`render_delayed(expr)`\n\nArguments\n\n- `expr` The expression to evaluate.\n\nDetails\n\nThis function is useful inside Shiny documents. It delays the evaluation of its argument until the document has finished its initial render, so that the document can be viewed before the calculation is finished.\n\nAny expression that returns HTML can be wrapped in `render_delayed`.\n\nValue\n\nAn object representing the expression.\n\nNote\n\n`expr` is evaluated in a copy of the environment in which the `render_delayed` call appears. Consequently, no side effects created by `expr` are visible in succeeding expressions, nor are changes to the environment after the call to `render_delayed` visible to `expr`.\n\n`expr` must be an expression that produces HTML.\n\nExamples\n\n```r\n## Not run:\n# Add the following code to an R Markdown document\n\ndiv(Sys.time())\n\nrender_delayed({\n Sys.sleep(3) # simulate an expensive computation\n div(Sys.time())\n})\n\ndiv(Sys.time())\n\n## End(Not run)\n```\nrender_site \n\nRender multiple documents as a website\n\nDescription\n\nRender all of the R Markdown documents within a directory as a website.\n\nUsage\n\nrender_site:\n\n- input: Website directory (or the name of a file within the directory).\n- output_format: R Markdown format to convert to (defaults to \"all\").\n- envir: The environment in which the code chunks are to be evaluated during knitting (can use new.env to guarantee an empty new environment).\n- quiet: TRUE to suppress messages and other output.\n- encoding: Ignored. The encoding is always assumed to be UTF-8.\n- preview: Whether to list the files to be removed rather than actually removing them. Defaulting to TRUE to prevent removing without notice.\n- output_format_filter: An optional function which is passed the input file and the output format, and which returns a (potentially modified) output format.\n- ...: Currently unused.\n\nArguments\n\n- input: Website directory (or the name of a file within the directory).\n- output_format: R Markdown format to convert to (defaults to \"all\").\n- envir: The environment in which the code chunks are to be evaluated during knitting (can use new.env to guarantee an empty new environment).\n- quiet: TRUE to suppress messages and other output.\n- encoding: Ignored. The encoding is always assumed to be UTF-8.\n- preview: Whether to list the files to be removed rather than actually removing them. Defaulting to TRUE to prevent removing without notice.\n- output_format_filter: An optional function which is passed the input file and the output format, and which returns a (potentially modified) output format.\n- ...: Currently unused.\n\nDetails\n\nThe render_site function enables you to render a collection of markdown documents within a directory as a website. There are two requirements for a directory to be rendered as a website:\n\n1. It must contain either an \"index.Rmd\" or \"index.md\" file.\n2. It must contain a site configuration file (\"_site.yml\").\n\nThe most minimal valid website is an empty \"index.Rmd\" and an empty \"_site.yml\". With this configuration a single empty webpage would be generated via a call to `render_site`. If you add additional markdown documents to the directory they will also be rendered. By default a site is rendered in the following fashion:\n\n1. R Markdown (.Rmd) and plain markdown (.md) files in the root directory are rendered. Note however that markdown files beginning with \"_\" are not rendered (this is a convention to designate files that are included by top level documents).\n2. All output and supporting files are copied to a \"_site\" subdirectory of the website directory (this is configurable, see discussion below).\n3. The following files are not copied to the \"_site\" sub-directory:\n - Files beginning with \".\" (hidden files).\n - Files beginning with \"_\"\n - Files known to contain R source code (e.g. \".R\", \".s\", \".Rmd\"), R data (e.g. \".RData\", \".rds\"), configuration data (e.g. \".Rproj\", \"rsconnect\") or package project management data (e.g. \"packrat\", \"renv\").\n \n Note that you can override which files are included or excluded via settings in \"_site.yml\" (described below).\n4. Normally R Markdown renders documents as self-contained HTML. However, `render_site` ensures that dependencies (e.g. CSS, JavaScript, images, etc.) remain in external files. CSS/JavaScript libraries are copied to a \"site_libs\" sub-directory and plots/images are copied to \".files\" sub-directories.\n\nYou can remove the files generated by `render_site` using the `clean_site` function.\n\n**Value**\n\n`render_site` returns the name of the site output file (relative to the input directory). `clean_site` returns the names of the generated files removed during cleaning. `site_config` returns the contents of _site.yml as an R list. `default_site_generator` returns the default site generator for R Markdown websites.\n\n**Configuration**\n\nA \"_site.yml\" file can be used to configure the behavior of site generation. Here is an example configuration file:\n\n```yaml\nname: my-website\noutput_dir: _site\ninclude: [\"demo.R\"]\nexclude: [\"docs.txt\", \"*.csv\"]\nnavbar:\n title: \"My Website\"\n left:\n - text: \"Home\"\n href: index.html\n```\nThe name field provides a suggested URL path for your website when it is published (by default this\nis just the name of the directory containing the site). The output_dir indicates which directory to\ncopy site content into (\"_site\" is the default if none is specified). Note that this can be \".\" to keep\nall content within the root website directory alongside the source code.\n\nThe include and exclude fields enable you to override the default behavior vis-a-vis what files are\ncopied into the \"_site\" directory (wildcards can be used as in the above example).\n\nThe navbar field can be used to define a navigation bar for websites based on the html_document\nformat.\n\nFinally, the output field enables you to specify output options that are common to all documents\nwithin the website (you can also still provide local options within each document that override any\ncommon options).\n\n**Custom Site Generation**\n\nThe behavior of the default site generation function (rmarkdown::default_site) is described\nabove. It is also possible to define a custom site generator that has alternate behavior. A site\ngenerator is an R function that is bound to by including it in the \"site:\" field of the \"index.Rmd\" or\n\"index.md\" file. For example:\n\ntitle: \"My Book\"\noutput: bookdown::gitbook\nsite: bookdown::bookdown_site\n\nA site generation function should return a list with the following elements:\n\nname: The name for the website (e.g. the parent directory name).\n\noutput_dir: The directory where the website output is written to. This path should be relative to\nthe site directory (e.g. \".\" or \"_site\"\n\nrender: An R function that can be called to generate the site. The function should accept the\ninput_file, output_format, envir, and quiet arguments.\n\nclean: An R function that returns relative paths to the files generated by render_site (these files\nare the ones which will be removed by the clean_site function.)\nsubdirs (optional): A logical flag that indicates if the generator supports nested source files in subdirectories of the project (TRUE) or only at the project root (FALSE). (e.g. blogdown::blogdown_site())\n\nNote that the `input_file` argument will be NULL when the entire site is being generated. It will be set to a specific file name if a front-end tool is attempting to preview it (e.g. RStudio IDE via the Knit button).\n\nWhen `quiet = FALSE` the render function should also print a line of output using the `message` function indicating which output file should be previewed, for example:\n\n```r\nif (!quiet)\n message(\"\\nOutput created: \", output)\n```\n\nEmitting this line enables front-ends like RStudio to determine which file they should open to preview the website.\n\nSee the source code of the `rmarkdown::default_site` function for an example of a site generation function.\n\n---\n\n**render_supporting_files**\n\nRender supporting files for an input document\n\n---\n\n**Description**\n\nRender (copy) required supporting files for an input document to the _files directory that is associated with the document.\n\n**Usage**\n\n`render_supporting_files(from, files_dir, rename_to = NULL)`\n\n**Arguments**\n\n- `from`: The directory from which the files should be copied.\n- `files_dir`: The directory that will receive the copied files.\n- `rename_to`: An option to rename the source directory after the copy operation is complete.\n\n**Value**\n\nThe relative path to the supporting files. This path is suitable for inclusion in HTML `href` and `src` attributes.\nresolve_output_format Resolve the output format for an R Markdown document\n\nDescription\n\nRead the YAML metadata (and any common output YAML file) for the document and return an output format object that can be passed to the render function.\n\nUsage\n\n```r\nresolve_output_format(\n input,\n output_format = NULL,\n output_options = NULL,\n output_yaml = NULL\n)\n```\n\nArguments\n\n- `input` Input file (Rmd or plain markdown)\n- `output_format` Name of output format (or NULL to use the default format for the input file).\n- `output_options` List of output options that should override the options specified in metadata.\n- `output_yaml` Paths to YAML files specifying output formats and their configurations. The first existing one is used. If none are found, then the function searches YAML files specified to the output_yaml top-level parameter in the YAML front matter, _output.yml or _output.yaml, and then uses the first existing one.\n\nDetails\n\nThis function is useful for front-end tools that need to modify the default behavior of an output format.\n\nValue\n\nAn R Markdown output format definition that can be passed to render.\n\nrmarkdown_format R Markdown input format definition\n\nDescription\n\nCompose a pandoc markdown input definition for R Markdown that can be passed as the from argument of pandoc_options.\n**Usage**\n\n```r\nrmarkdown_format(extensions = NULL)\n```\n\n```r\nfrom_rmarkdown(implicit_figures = TRUE, extensions = NULL)\n```\n\n**Arguments**\n\n- `extensions` Markdown extensions to be added or removed from the default definition of R Markdown.\n- `implicit_figures` Automatically make figures from images (defaults to `TRUE`).\n\n**Details**\n\nBy default R Markdown is defined as all pandoc markdown extensions with the following tweaks for backward compatibility with the markdown package (+ features are added, - features are removed):\n\n- `+autolink_bare_uris`\n- `+tex_math_single_backslash`\n\nFor more on pandoc markdown see the pandoc online documentation.\n\n**Value**\n\nPandoc markdown format specification\n\n**See Also**\n\n`output_format`, `pandoc_options`\n\n**Examples**\n\n```r\n## Not run:\nrmarkdown_format(\"-implicit_figures\")\n## End(Not run)\n```\n\n---\n\n**rmd_metadata**\n\n### R Markdown Metadata\n\n**Description**\n\nRmd files include a metadata section (typically located at the top of the file) that can specify (among other things) the title, author, and date of the document. Metadata adheres to the YAML format and is delimited by lines containing three dashes (---). Here is an example metadata section:\n---\n\ntitle: \"Crop Analysis Q3 2013\"\nauthor: Martha Smith\ndate: October 23rd, 2013\n---\n\nNote that the title field is quoted. This is because titles often contained embedded colons (:) and colons followed by a space need to be quoted in YAML.\n\nDetails\n\nWhen title, author, and date metadata is provided it’s used to automatically create a title section within output documents. If you don’t want this section included in your document then you should remove the corresponding metadata fields.\n\nWhen generating PDF and Beamer output there are also a number of other metadata fields that can be included to customize the appearance and theme of PDF output. For more details see the documentation for pdf_document and beamer_presentation.\n\n---\n\n**rtf_document**\n\n*Convert to an RTF document*\n\n---\n\n**Description**\n\nFormat for converting from R Markdown to an RTF document.\n\n**Usage**\n\n```r\nrtf_document(\n toc = FALSE,\n toc_depth = 3,\n number_sections = FALSE,\n fig_width = 5,\n fig_height = 4,\n keep_md = FALSE,\n md_extensions = NULL,\n pandoc_args = NULL\n)\n```\n\n**Arguments**\n\n- **toc**\n - TRUE to include a table of contents in the output\n- **toc_depth**\n - Depth of headers to include in table of contents\n- **number_sections**\n - TRUE to number section headings\n- **fig_width**\n - Default width (in inches) for figures\n- **fig_height**\n - Default height (in inches) for figures\n### Description\n\nStart a Shiny server for the given document, and render it for display.\n\n### Usage\n\n```r\ncode\n```\nArguments\n\n- **file**: Path to the R Markdown document to launch in a web browser. Defaults to `index.Rmd` in the current working directory, but may be `NULL` to skip launching a browser.\n- **dir**: The directory from which to read input documents. Defaults to the parent directory of `file`.\n- **default_file**: The file to serve at the Shiny server’s root URL. If `NULL` (the default), a sensible default is chosen (see Details).\n- **auto_reload**: If `TRUE` (the default), automatically reload the Shiny application when the file currently being viewed is changed on disk.\n- **shiny_args**: Additional arguments to `runApp`.\n- **render_args**: Additional arguments to `render`.\n\nDetails\n\nThe `run` function runs a Shiny document by starting a Shiny server associated with the document. The `shiny_args` parameter can be used to configure the server; see the `runApp` documentation for details.\n\nOnce the server is started, the document will be rendered using `render`. The server will initiate a render of the document whenever necessary, so it is not necessary to call `run` every time the document changes: if `auto_reload` is `TRUE`, saving the document will trigger a render. You can also manually trigger a render by reloading the document in a Web browser.\n\nThe server will render any R Markdown (.Rmd) document in `dir`; the `file` argument specifies only the initial document to be rendered and viewed. You can therefore link to other documents in the directory using standard Markdown syntax, e.g. `[Analysis Page 2](page2.Rmd)`.\n\nIf `default_file` is not specified, nor is a file specified on the URL, then the default document to serve at `/` is chosen from (in order of preference):\n\n- If `dir` contains only one `.Rmd`, that `.Rmd`.\n- The file `index.Rmd`, if it exists in `dir`.\n- The first `.Rmd` that has `runtime: shiny` in its YAML metadata.\n- The file `index.html` (or `index.htm`), if it exists in `dir`.\n\nIf you wish to share R code between your documents, place it in a file named `global.R` in `dir`; it will be sourced into the global environment.\n\nValue\n\nInvisible `NULL`.\n\nNote\n\nUnlike `render`, `run` does not render the document to a file on disk. In most cases a Web browser will be started automatically to view the document; see `launch.browser` in the `runApp` documentation for details.\nWhen using an external web browser with the server, specify the name of the R Markdown file to view in the URL (e.g. `http://127.0.0.1:1234/foo.Rmd`). A URL without a filename will show the default_file as described above.\n\n### Examples\n\n```r\n## Not run:\n# Run the Shiny document \"index.Rmd\" in the current directory\nrmarkdown::run()\n\n# Run the Shiny document \"shiny_doc.Rmd\" on port 8241\nrmarkdown::run(\"shiny_doc.Rmd\", shiny_args = list(port = 8241))\n\n## End(Not run)\n```\n\n### shiny_prerendered_chunk\n\n*Add code to a shiny_prerendered context*\n\n#### Description\n\nProgrammatic equivalent to including a code chunk with a context in a runtime: shiny_prerendered document.\n\n#### Usage\n\n```r\nshiny_prerendered_chunk(context, code, singleton = FALSE)\n```\n\n#### Arguments\n\n- **context**: Context name (e.g. \"server\", \"server-start\")\n- **code**: Character vector with code\n- **singleton**: Collapse multiple identical versions of this chunk into a single chunk.\n\n### shiny_prerendered_clean\n\n*Clean prerendered content for the specified Rmd input file*\n\n#### Description\n\nRemove the associated html file and supporting _files directory for a shiny_prerendered document.\n\n#### Usage\n\n```r\nshiny_prerendered_clean(input)\n```\n\n#### Arguments\n\n- **input**: Rmd input file to clean content for\nsite_resources\n\nDetermine website resource files for a directory\n\nDescription\n\nDetermine which files within a given directory should be copied in order to serve a website from the directory. Attempts to automatically exclude source, data, hidden, and other files not required to serve website content.\n\nUsage\n\nsite_resources(site_dir, include = NULL, exclude = NULL, recursive = FALSE)\n\nArguments\n\nsite_dir Site directory to analyze\ninclude Additional files to include (glob wildcards supported)\nexclude Files to exclude (glob wildcards supported)\nrecursive TRUE to return a full recursive file listing; FALSE to just provide top-level files and directories.\n\nValue\n\nCharacter vector of files and directories to copy\n\nslidy_presentation\n\nConvert to a slidy presentation\n\nDescription\n\nFormat for converting from R Markdown to a slidy presentation.\n\nUsage\n\nslidy_presentation(\n number_sections = FALSE,\n incremental = FALSE,\n slide_level = NULL,\n duration = NULL,\n footer = NULL,\n font_adjustment = 0,\n fig_width = 8,\n fig_height = 6,\n fig_retina = 2,\n fig_caption = TRUE,\n)\nArguments\n\nnumber_sections TRUE to number section headings\nincremental TRUE to render slide bullets incrementally. Note that if you want to reverse the\ndefault incremental behavior for an individual bullet you can precede it with >.\nFor example: > - Bullet Text\nslide_level The heading level which defines individual slides. By default this is the highest\nheader level in the hierarchy that is followed immediately by content, and not\nanother header, somewhere in the document. This default can be overridden by\nspecifying an explicit slide_level.\nduration Duration (in minutes) of the slide deck. This value is used to add a countdown\ntimer to the slide footer.\nfooter Footer text (e.g. organization name and/or copyright)\nfont_adjustment Increase or decrease the default font size (e.g. -1 or +1). You can also manu-\nally adjust the font size during the presentation using the 'S' (smaller) and 'B'\n(bigger) keys.\nfig_width Default width (in inches) for figures\nfig_height Default height (in inches) for figures\nfig_retina Scaling to perform for retina displays (defaults to 2, which currently works for\nall widely used retina displays). Set to NULL to prevent retina scaling. Note that\nthis will always be NULL when keep_md is specified (this is because fig_retina\nrelies on outputting HTML directly into the markdown document).\nfig_caption TRUE to render figures with captions\ndev Graphics device to use for figure output (defaults to pdf)\ndf_print Method to be used for printing data frames. Valid values include \"default\",\n\"kable\", \"tibble\", and \"paged\". The \"default\" method uses a corresponding S3\nmethod of print, typically print.data.frame. The \"kable\" method uses the\nknitr::kable function. The \"tibble\" method uses the tibble package to print\na summary of the data frame. The \"paged\" method creates a paginated HTML\ntable (note that this method is only valid for formats that produce HTML). In\naddition to the named methods you can also pass an arbitrary function to be\nused for printing data frames. You can disable the df_print behavior entirely\nby setting the option rmarkdown.df_print to FALSE. See Data frame printing\nsection in bookdown book for examples.\n\nself_contained\n\nProduce a standalone HTML file with no external dependencies, using data:\nURLs to incorporate the contents of linked scripts, stylesheets, images, and\nvideos. Note that even for self contained documents MathJax is still loaded\nexternally (this is necessary because of its size).\n\nhighlight\n\nSyntax highlighting style. Supported styles include \"default\", \"tango\", \"pygments\",\n\"kate\", \"monochrome\", \"espresso\", \"zenburn\", and \"haddock\". Pass\nNULL to prevent syntax highlighting.\n\nmathjax\n\nInclude mathjax. The \"default\" option uses an https URL from a MathJax CDN.\nThe \"local\" option uses a local version of MathJax (which is copied into the out-\nput directory). You can pass an alternate URL or pass NULL to exclude MathJax\nentirely.\n\ntemplate\n\nPandoc template to use for rendering. Pass \"default\" to use the rmarkdown pack-\nage default template; pass NULL to use pandoc’s built-in template; pass a path to\nuse a custom template that you’ve created. See the documentation on pandoc\nonline documentation for details on creating custom templates.\n\ncss\n\nOne or more css files to include.\n\nincludes\n\nNamed list of additional content to include within the document (typically cre-\nated using the includes function).\n\nkeep_md\n\nKeep the markdown file generated by knitting.\n\nlib_dir\n\nDirectory to copy dependent HTML libraries (e.g. jquery, bootstrap, etc.) into.\nBy default this will be the name of the document with _files appended to it.\n\nmd_extensions\n\nMarkdown extensions to be added or removed from the default definition or R\nMarkDown. See the rmarkdown_format for additional details.\n\npandoc_args\n\nAdditional command line options to pass to pandoc\n\nextra_dependencies\n\nA LaTeX dependency latex_dependency(), a list of LaTeX dependencies, a\ncharacter vector of LaTeX package names (e.g. c(\"framed\",\"hyperref\")), or\na named list of LaTeX package options with the names being package names\n(e.g. list(hyperref = c(\"unicode=true\",\"breaklinks=true\"),lmodern =\nNULL)). It can be used to add custom LaTeX packages to the .tex header.\n\n... Additional function arguments to pass to the base R Markdown HTML output\nformatter html_document_base\n\nDetails\n\nSee the online documentation for additional details on using the slidy_presentation format.\n\nFor more information on markdown syntax for presentations see the pandoc online documentation.\n**tufte_handout**\n\n**Value**\n\nR Markdown output format to pass to `render`\n\n**Examples**\n\n```r\n## Not run:\nlibrary(rmarkdown)\n\n# simple invocation\nrender(\"pres.Rmd\", slidy_presentation())\n\n# specify an option for incremental rendering\nrender(\"pres.Rmd\", slidy_presentation(incremental = TRUE))\n\n## End(Not run)\n```\n\n---\n\n**tufte_handout** \n*Tuft handout format (PDF)*\n\n**Description**\n\nThis function has been moved to the **tufte** package. Please use tufte::tufte_handout instead. See the online documentation for additional details.\n\n**Usage**\n\n```r\ntufte_handout(\n fig_width = 4,\n fig_height = 2.5,\n fig_crop = TRUE,\n dev = \"pdf\",\n highlight = \"default\",\n keep_tex = FALSE,\n citation_package = c(\"default\", \"natbib\", \"biblatex\"),\n includes = NULL,\n md_extensions = NULL,\n pandoc_args = NULL\n)\n```\n\n**Arguments**\n\n- **fig_width** \n Default width (in inches) for figures\n\n- **fig_height** \n Default height (in inches) for figures\n\n- **fig_crop** \n Whether to crop PDF figures with the command pdfcrop. This requires the tools pdfcrop and ghostscript to be installed. By default, `fig_crop = TRUE` if these two tools are available.\n\n- **dev** \n Graphics device to use for figure output (defaults to pdf)\n**highlight** \n\n**keepTex** \nKeep the intermediate tex file used in the conversion to PDF.\n\n**citation_package** \nThe LaTeX package to process citations, natbib or biblatex. Use default if neither package is to be used, which means citations will be processed via the command pandoc-citeproc.\n\n**includes** \nNamed list of additional content to include within the document (typically created using the includes function).\n\n**md_extensions** \nMarkdown extensions to be added or removed from the default definition or R Markdown. See the `rmarkdown_format` for additional details.\n\n**pandoc_args** \nAdditional command line options to pass to pandoc.\n\n---\n\n**word_document** \nConvert to an MS Word document\n\n---\n\n**Description**\n\nFormat for converting from R Markdown to an MS Word document.\n\n**Usage**\n\n```r\nword_document( \ntoc = FALSE, \ntoc_depth = 3, \nnumber_sections = FALSE, \nfig_width = 5, \nfig_height = 4, \nfig_caption = TRUE, \ndf_print = \"default\", \nhighlight = \"default\", \nreference_docx = \"default\", \nkeep_md = FALSE, \nmd_extensions = NULL, \npandoc_args = NULL\"\n)\n```\n\n**Arguments**\n\n- **toc** \n TRUE to include a table of contents in the output\n- **toc_depth** \n Depth of headers to include in table of contents\n- **number_sections** \n TRUE to number section headings\n- **fig_width** \n Default width (in inches) for figures\nfig_height Default height (in inches) for figures\nfig_caption TRUE to render figures with captions\ndf_print Method to be used for printing data frames. Valid values include \"default\", \"kable\", \"tibble\", and \"paged\". The \"default\" method uses a corresponding S3 method of print, typically print.data.frame. The \"kable\" method uses the knitr::kable function. The \"tibble\" method uses the tibble package to print a summary of the data frame. The \"paged\" method creates a paginated HTML table (note that this method is only valid for formats that produce HTML). In addition to the named methods you can also pass an arbitrary function to be used for printing data frames. You can disable the df_print behavior entirely by setting the option rmarkdown.df_print to FALSE. See Data frame printing section in bookdown book for examples.\nreference_docx Use the specified file as a style reference in producing a docx file. For best results, the reference docx should be a modified version of a docx file produced using pandoc. Pass \"default\" to use the rmarkdown default styles.\nkeep_md Keep the markdown file generated by knitting.\nmib_extensions Markdown extensions to be added or removed from the default definition or R Markdown. See the rmarkdown_format for additional details.\npandoc_args Additional command line options to pass to pandoc\n\nDetails\n\nSee the online documentation for additional details on using the word_document format.\n\nR Markdown documents can have optional metadata that is used to generate a document header that includes the title, author, and date. For more details see the documentation on R Markdown metadata.\n\nR Markdown documents also support citations. You can find more information on the markdown syntax for citations in the Bibliographies and Citations article in the online documentation.\n\nValue\n\nR Markdown output format to pass to render\n\nExamples\n\n```r\n## Not run:\nlibrary(rmarkdown)\n\n# simple invocation\nrender(\"input.Rmd\", word_document())\n\n# specify an option for syntax highlighting\nrender(\"input.Rmd\", word_document(highlight = \"zenburn\"))\n\n## End(Not run)\n```\nIndex\n\n* datasets\n metadata, 46\nall_output_formats, 5\nAnchor Sections Customization section, 20\nbeamer_presentation, 4, 5, 76\nbslib::bs_theme(), 19, 21, 25, 26, 29\nclean_site(render_site), 70\ncompile_notebook, 8\nCompiling R scripts to a notebook, 67\ncontext_document, 9\nclean_site(render_site), 20\nhtml_document, 4, 19, 26, 27, 31, 32, 68, 72\nhtml_document_base, 21, 24, 29, 30, 36, 82\nhtml_fragment, 26\nhtml_notebook, 28\nhtml_notebook_metadata, 30\nhtml_notebook_output, 29, 30, 30\nhtml_notebook_output_code\n(html_notebook_output), 30\nhtml_notebook_output_html\n(html_notebook_output), 30\nhtml_notebook_output_img\n(html_notebook_output), 30\nhtml_notebook_output_png\n(html_notebook_output), 30\nhtml_vignette, 31\nhtmlDependency, 26\nI, 66\nincludes, 7, 10, 18, 21, 27, 29, 33, 36, 45, 47, 60, 82, 84\nincludes_to_pandoc_args(includes), 33\nioslides_presentation, 34\nknit, 65, 68\nknit_hooks, 41\nknit_params_ask, 42\nknitr spin, 9\nknitr::kable, 6, 10, 17, 20, 27, 32, 35, 45, 48, 60, 63, 81, 85\nknitr_options, 40, 41, 42, 48, 49\nknitr_options_html, 41\nknitr_options_pdf, 42\nlatex-dependencies, 43\nlatex_dependency, 44\n\nhtml_dependency_pagedtable\n(html-dependencies), 18\nhtml_dependency_tocify\n(html-dependencies), 18\nhtml_document, 4, 19, 26, 27, 31, 32, 68, 72\nhtml_document_base, 21, 24, 29, 30, 36, 82\nhtml_fragment, 26\nhtml_notebook, 28\nhtml_notebook_metadata, 30\nhtml_notebook_output, 29, 30, 30\nhtml_notebook_output_code\n(html_notebook_output), 30\nhtml_notebook_output_html\n(html_notebook_output), 30\nhtml_notebook_output_img\n(html_notebook_output), 30\nhtml_notebook_output_png\n(html_notebook_output), 30\nhtml_vignette, 31\nhtmlDependency, 26\n\nI, 66\nincludes, 7, 10, 18, 21, 27, 29, 33, 36, 45, 47, 60, 82, 84\nincludes_to_pandoc_args(includes), 33\nioslides_presentation, 34\nknit, 65, 68\nknit_hooks, 41\nknit_params_ask, 42\nknitr spin, 9\nknitr::kable, 6, 10, 17, 20, 27, 32, 35, 45, 48, 60, 63, 81, 85\nknitr_options, 40, 41, 42, 48, 49\nknitr_options_html, 41\nknitr_options_pdf, 42\nlatex-dependencies, 43\nlatex_dependency, 44\n\n86\nINDEX\n\nlatex_dependency_tikz (latex-dependencies), 43\nlatex_document (pdf_document), 59\nlatex_fragment (pdf_document), 59\n\nmd_document, 44\nmessage, 73\nmetadata, 7, 11, 22, 45, 46, 47, 61, 77, 85\n\nnew.env, 67, 70\nnumeric_version, 53\n\nodt_document, 46\non.exit, 49\nopts_chunk, 41\nopts_hooks, 41\nopts_knit, 41\nopts_template, 41\noutput_format, 24, 30, 41, 42, 48, 56, 68\noutput_metadata, 50\n\npaged_table, 50\npandoc_args, 51\npandoc_available, 52\npandoc_citeproc_args (pandoc_args), 51\npandoc_citeproc_convert, 53\npandoc_convert, 54\npandoc_exec, 55\npandoc_highlight_args (pandoc_args), 51\npandoc_include_args (pandoc_args), 51\npandoc_latex_engine_args (pandoc_args), 51\npandoc_lua_filter_args (pandoc_args), 51\npandoc_metadata_arg (pandoc_args), 51\npandoc_options, 48, 49, 55, 74, 75\npandoc_path_arg, 51, 57, 62\npandoc_self_contained_html, 57\npandoc_template, 58\npandoc_toc_args (pandoc_args), 51\npandoc_variable_arg (pandoc_args), 51\npandoc_version (pandoc_available), 52\nparse_html_notebook, 58\npath.expand, 57\npdf_document, 4, 5, 7–9, 11–13, 18, 22, 27, 32, 36, 45, 47, 49, 50, 61, 64, 65, 74, 77, 78, 83, 85\nrender, 4, 5, 7–9, 11–13, 18, 22, 27, 32, 36, 45, 47, 49, 50, 61, 64, 65, 74, 77, 78, 83, 85\nrender_delayed, 69\nrender_site, 70\nrender_supporting_files, 48, 73\nresolve_output_format, 74\nrmarkdown (rmarkdown-package), 4\nrmarkdown-package, 4\nrmarkdown_format, 7, 10, 18, 21, 27, 29, 36, 45, 47, 56, 60, 63, 68, 74, 77, 82, 84, 85\nrmd_metadata, 75\nrtf_document, 76\nrun, 67, 77\nrunApp, 43, 78\n\nshiny_prerendered_chunk, 79\nshiny_prerendered_clean, 79\nsite_config (render_site), 70\nsite_generator (render_site), 70\nsite_resources, 80\nslidy_presentation, 80\ntufte_handout, 83\n\nword_document, 4, 84\n\nrelative_to, 65"}}},{"rowIdx":152,"cells":{"id":{"kind":"string","value":"0092c5f3f5fd0164fcbb8bc929e8749e22c28250"},"text":{"kind":"string","value":"Experimental study of performance of minimum spanning tree algorithms\n\nAlec Berenbaum\n\nFollow this and additional works at: http://scholarworks.rit.edu/theses\n\nRecommended Citation\nRochester Institute of Technology\nDepartment of Computer Science\n\nExperimental Study of\nPerformance of Minimum Spanning Tree Algorithms\n\nby\n\nAlec Berenbaum\n\nA thesis, submitted to\nthe Faculty of the Department of Computer Science\nin partial fulfillment of the requirements for the degree of\nMaster of Science in Computer Science\n\nApproved by:\n\n_____________\nProfessor Stanisław Radziszowski\nDepartment of Computer Science, RIT\n\n_____________\nProfessor Peter Anderson\nDepartment of Computer Science, RIT\n\n_____________\nProfessor Rayno Niemi\nDepartment of Information Technology, RIT\n\nAugust 26, 1998\nExperimental Study of\nPerformance of Minimum Spanning Tree Algorithms\n\nI, Alec Berenbaum prefer to be contacted each time a request for reproduction is made. If permission is granted, any reproduction will not be for commercial use or profit. I can be reached at the following address:\n\nRochester Institute of Technology\nDepartment of Information Technology\nBuilding 10\n1 Lomb Memorial Drive\nRochester, NY 14623\n(716) 475 - 7927\n\nDate: 8/4/98\nSignature of the Author ____________________\n## CONTENTS\n\nACKNOWLEDGEMENTS. ................................................................. 1\n\nABSTRACT. .................................................................................. ii\n\n1. **INTRODUCTION.** ................................................................. 1\n\n2. **ALGORITHMS.** ................................................................. 8\n\n3. **EXPERIMENT.** ................................................................. 31\n\n4. **RESULTS.** ........................................................................ 39\n\n5. **ANALYSIS OF RESULTS.** ................................................ 59\n\n6. **CONCLUSIONS.** .............................................................. 73\n\n7. **FURTHER WORK.** ............................................................ 75\n\n8. **BIBLIOGRAPHY.** .............................................................. 76\nACKNOWLEDGEMENTS\n\nI would like to thank Dr. Stanisław Radziszowski for all the help, guidance, and encouragement without which this thesis would not have been finalized. I also wish to thank Dr. Peter Anderson for the help and encouragement he provided throughout my graduate studies in Computer Science at the Rochester Institute of Technology. I extend special thanks to Dr. Rayno Niemi for taking the time out of his busy schedule to serve on my thesis committee.\nABSTRACT\n\nThroughout the study of various theories of algorithms much work has been done in the area of traversal and solving optimization problems on graphs. Some of this work includes studies of finding the Minimal-Cost Spanning Trees (MST) in directed and undirected connected graphs. Several algorithms have been developed for such task. These algorithms tend to differ in performance based on various factors, such as graph density, size of problem spaces, range of weights that can be assigned to the edges of the graphs, edge weight distributions, etc. The data structures used by an algorithm can have a significant impact on algorithm’s performance, for each of the aforementioned factors. This thesis presents the results of the experimental study of the impact the data structures have on performances of Kruskal’s and Prim’s algorithms for finding Minimum-Cost Spanning Trees in connected undirected graphs.\n\nThe goal of this study is to compare performance of the practical implementations of Kruskal’s and Prim’s algorithms to their theoretical counterparts, as well as to measure and compare the differences in performances for various implementations of one algorithm, with respect to different implementation of the essential data structures. Performances of different algorithms are studied with respect to each-other for several variations of the types of data. As a result, a table depicting a schedule for use of the various implementations of either of the algorithms, as related to the type of graph used, is presented.\n\nThe algorithms are implemented and executed on a single Sun UltraSparc workstation, in order to eliminate the discrepancies, which may result from the differences in the processor speeds and variable CPU loads on multiple test machines. The following implementations are studied:\n\n- Kruskal’s Algorithm with heapsort, and disjoint-sets using union-by-rank and path-compression heuristic\n- Kruskal’s Algorithm with counting sort and disjoint-sets using union-by-rank and path-compression heuristic\n- Prim’s Algorithm with brute force implementation of priority queues\n- Prim’s Algorithm with priority queue implemented using a proper implementation of binary heap with “bubble-up” performed each time a decrease-key operation is performed for a vertex\n- Prim’s Algorithm with priority queue implemented using a \"lazy\" implementation of binary heap with “bubble-up” performed after all decrease-key operations are performed for a vertex\n- Prim’s Algorithm with priority queue implemented using a binomial heap\n- Prim’s Algorithm with priority queue implemented using a Fibonacci heap\n\nUpon the conclusion of the experiment, the best results were obtained from the implementation of Prim’s algorithm using the “lazy” heap implementation of a priority queue. For sparse graphs, Kruskal’s algorithm with counting sort performed very well, while for higher density graphs, Prim’s algorithm with binomial heap performed very well.\n1. INTRODUCTION\n\nThe problem of finding minimum spanning trees in connected graphs has a wide range of applications. These include the design of computer and communication networks, power and leased-line telephone networks, wiring connections, links in transportation network, piping in a flow network, network reliability, surface homogeneity tests, image processing, speech recognition, clustering, classification, etc. [1]. The challenge has always been to find the minimum spanning tree (MST) as efficiently as possible in the graphs with a large number of vertices. This thesis studies and compares various methods of accomplishing this task, using variations of the algorithms developed by J.B. Kruskal [2] and R.C. Prim [3] to find the most practical method for solving the minimum spanning tree problem. The graphs vary in densities, sizes, and ranges of the edge weights. Most theoretical implementations of these algorithms disregard some issues that are inherent in the use of a digital computer. Issues such as various overheads associated with memory allocation/deallocation, use of disks, processor speeds, bus speeds, etc. may have significant impact on the expected performance of the theoretical implementation of the algorithm. The goal is to develop a table, which depicts a schedule of various implementations of Kruskal’s and Prim’s algorithms for diverse types of data.\n\n1.1 Basics of Trees\n\nA tree is a non-linear structure that is frequently used in the implementation of computer algorithms. Such structure implies a “branching” relationship between the nodes, much like the branching found in the trees in nature [4]. Donald E. Knuth defines a tree formally as a finite set $T$ of one or more nodes, such that\n\na) There is one especially designated node called a root of the tree, $root(T)$ [4].\n\nb) The remaining nodes (excluding the root) are partitioned into $m \\geq 0$ disjoint sets $T_1, ..., T_m$, and each of these sets in turn is a tree. The trees $T_1, ..., T_m$, are called subtrees of the root [4].\nA tree can be viewed as an acyclic, connected, undirected graph, or likewise defined as an undirected graph in which there exists exactly one path between any two nodes [5]. The three most important properties of trees are:\n\n1. A tree with \\( n \\) nodes has exactly \\( n - 1 \\) edges [5].\n\n2. When a single edge is added to a tree, the resulting graph contains exactly one cycle [5], which is a violation of the property 1. Because the graph with \\( n \\) vertices now contains \\( n \\) edges, according to the basic property of a tree, that it is an acyclic, connected, undirected graph, introducing a cycle results in the graph no longer holding the tree property.\n\n3. Removal of a single edge from a tree results in a graph that is no longer connected [5], thus resulting in the violation of the property 1, since the graph with \\( n - 1 \\) edges now contains \\( n - 1 \\) vertices. According to the basic properties of a tree, that it is an acyclic, connected, undirected graph, detaching one of the vertices from the graph, eliminates the path between that vertex and any other vertex in the graph, resulting in two separate trees.\n\nFigure 1 illustrates several examples of trees of 5 nodes.\n\n\n\n### 1.2 Spanning Trees\n\nSeymour Lipschutz and Marc Lipson define a spanning tree of a graph \\( G \\) as a subgraph \\( T \\), if \\( T \\) is a tree and \\( T \\) includes all the vertices of \\( G \\) [6]. Thus, every connected graph contains at least one spanning tree. If a graph with \\( n \\) vertices contains \\( E > n - 1 \\) edges, then it is possible to remove \\( E - (n - 1) \\) edges in a manner, such that the connectivity of the graph is preserved, thus eliminating all cycles and resulting in a spanning tree. According to the definition provided by Brassard and Bratley [5], a tree has a property that exactly one unique path exists between any two vertices. If the two adjacent vertices \\( v \\) and \\( u \\) are a part of a subgraph, where there exist \\( p \\) paths from \\( v \\) to \\( u \\) and \\( p > 1 \\), removing the edge \\( \\{v, u\\} \\) will result in \\( p - 1 \\) paths from \\( v \\) to \\( u \\). This process can be repeated for\nall adjacent vertices, \\( u' \\) and \\( v' \\), in the path from \\( v \\) to \\( u \\), if more than one path is available from \\( u' \\) to \\( v' \\), until exactly one path from \\( v \\) to \\( u \\) remains.\n\n### 1.3 Minimum Spanning Trees\n\nWe can see that at least one spanning tree can be found in a connected, undirected graph. If the graph is weighted, i.e. a weight \\( w(u, v) \\) is assigned to every edge \\( \\{u, v\\} \\), we then state that the total weight of the spanning tree \\( T \\) within the graph \\( G \\) is expressed as the total weight of all edges connecting the vertices of \\( T \\) [7]\n\n\\[\nw(T) = \\sum_{(u,v) \\in T} w(u, v)\n\\]\n\nThe problem of finding a spanning tree in a connected graph with lowest possible \\( w(T) \\) is known as a minimum spanning tree problem [7].\n\n### 1.4 Historical Perspective\n\n#### 1.4.1 O. Borůvka\n\nThe study of minimum spanning tree problem can be dated back as far as 1926, relating to the work of Otakar Borůvka, who became aware of the problem during the rural electrification of Southern Moravia [1]. He has formulated the statement of minimum spanning tree problem as follows [1]:\n\nGiven a matrix \\( M \\) of numbers \\( r(x, y) \\) \\( (x, y = 1, 2, ..., n; n \\geq 2) \\), all positive and pairwise different, with the exception of \\( r(x, x) = 0 \\) and \\( r(x, y) = r(y, x) \\), find a subset of entries, pairwise different and nonzero, such that\n\n1. for any \\( p_1, p_2 \\), different natural numbers \\( \\leq n \\), the subset contains some \\( r(p_1, c_2), r(c_2, c_3), r(c_3, c_4), ..., r(c_{q-2}, c_{q-1}), r(c_{q-1}, p_2) \\)\n\n2. the sum of its members is smaller than the sum of members of any other set of numbers pairwise different and nonzero satisfying condition 1 [8].\n\nBorůvka then proceeds with a solution, the summary of which is presented in [1] in modern terms:\n1. Choose a vertex $v$ and the shortest incident edge $vw_i$. If there exist edges $w_ix$ shorter than $vw_i$, choose the shortest such edge $w_iw_2$. Continue in this way, as long as possible, constructing a simple path $vw_i, w_iw_2, \\ldots, w_{k-1}w_k$, where each $w_iw_{i+1}$ is the shortest edge incident with $w_i$ and is shorter than $w_{i-1}w_i$ [8].\n\n2. Begin at a new vertex $p$ and construct as in 1 another simple path $pq_1, q_1q_2, \\ldots, q_{l-1}q_l$, with $l$ as large as possible, under the constraint that $pq_1, q_1q_2, \\ldots, q_{l-1}q_l$ are disjoint from the previous path or paths (as well as the constraint that each $q_iq_{i+1}$ is the shortest edge incident with $q_i$ and shorter than $q_{i-1}q_i$) [8].\n\nRepeat until all vertices have been included on some such path [8].\n\nThese paths form fragments, and it is easy to see that an edge $ab$ is in the resulting forest $G$ if and only if it is the shortest edge at $a$ or $b$. Hence the forest $G$ is the same as the one obtained by joining each vertex to its nearest neighbor [1].\n\nGraham and Hell [1] summarize Borůvka's method by providing a description of the process. There it is stated, that one forms the distance matrix for the set of fragments of $G$ and repeats the process, producing another forest $G_1$, then $G_2$, and so on, until the forest is just one tree $G_{n-1}$, the solution. An implementation of Borůvka's algorithm would run in time $O(\\text{Elg}V)$, where $E$ is the number of edges and $V$ is the number of vertices [1]. Each time the rule, which defines the algorithm is applied, the number of fragments decreases by at least one half [1].\n\n1.4.2 J. B. Kruskal\n\nKruskal attributes the formulation of the problem to Borůvka. In his paper [2] he considers distinct and positive sets of edge lengths. The primary interest is in establishing uniqueness under these conditions [3]. He provides three different constructions, or algorithms, for finding the minimum spanning trees, which we will discuss further. To summarize Kruskal's algorithm: [1]\n\n1. Sort the edges by weight.\n\n2. Examine each edge in the order of increasing weight.\n\n3. If the edge inclusion does not create a cycle with the edges in the current forest, it is added to the forest; otherwise, it is discarded.\nKruskal provides this in the form of a construction: [2]\n\n**Construction A** – Perform the following step as many times as possible:\nAmong the edges of \\( G \\) not yet chosen, choose the shortest edge which does not form any loops [cycles] with those edges already chosen [2].\n\nThe efficient implementation of Kruskal’s algorithm can be attributed to the efficiency in sorting of edges by weight, and in finding the fragment containing a given vertex (find-set), and in the merge of two fragments into one(find-union) [1], which is studied in this paper by experimentation. The best implementation of Kruskal’s algorithm is known to run in \\( O(E \\lg V) \\) time [1]. \\( O(E) \\) time can be achieved if the edge weights are small integers and the radix sorting can be used, or if the edges are in sorted order [9].\n\nIn [2], he viewed his construction A as a special case of a more general construction [1]. Kruskal wrote as follows:\n\n**Construction B** – Let \\( V \\) be an arbitrary but fixed (nonempty) subset of the vertices of \\( G \\). Then perform the following step as many times as possible:\nAmong the edges of \\( G \\) which are not yet chosen, but which are connected either to the vertex of \\( V \\) or to an edge already chosen, pick the shortest edge which does not form any loops with the edges already chosen [2].\n\nKruskal states that when \\( V \\) is a set of all vertices of \\( G \\), construction B reduces to construction A [1]. When \\( V \\) consists of a single vertex \\( v \\) construction B reduces to the algorithm which was later attributed to Prim [3]. Graham and Hell describe Kruskal’s algorithm as follows:\n\nSort the edges by weight. Given a fragment \\( F \\) containing \\( v \\), examine the unused edges in order of increasing weight until an edge is found joining a vertex in \\( F \\) to the vertex outside of \\( F \\). Add that edge. At the same time, edges that are found to join two vertices of \\( F \\) may be discarded [1].\n\n### 1.4.3 R. C. Prim\n\nIn 1957 R. C. Prim submitted a manuscript on “Shortest Connection Networks and Some Generalization” for publication in *Bell System Technical Journal*. Prim’s main concern was that problem of inherent interest in the planning of large-scale communication, distribution, and transportation networks also arises in connection with the current rate structure for Bell System leased-line service [3]. Prim gave the following problem statement:\nGiven a set of (point) terminals, connect them by a network of direct terminal-to-terminal links having the smallest possible total length (sum of the link length). (A set of terminals is “connected”, of course, if and only if there is an unbroken chain of links between every two terminals in the set.) [3]\n\nPrim provides two construction principles for the shortest connection networks:\n\n**Principle 1** – Any isolated terminal\\(^\\text{i}\\) can be connected to a nearest neighbor [3].\n\n**Principle 2** – Any isolated fragment\\(^\\text{ii}\\) can be connected to a nearest available neighbor by a shortest available link [3].\n\nPrim states that since each application of either P1 or P2 reduces the total number of isolated terminals and fragments by one, it is evident that an N – terminal network is connected by \\(N - 1\\) applications [3]. Prim later provides the validation of principles P1 and P2. He states that the validity of these principles depends on the establishment of two necessary conditions (NC1 and NC2) for a shortest connection network (SCN):\n\n**Necessary Condition 1** – Every terminal in an SCN is directly connected to at least one nearest neighbor [3].\n\n**Necessary Condition 2** – Every fragment in an SCN is connected to at least one nearest neighbor by a shortest available path [3].\n\nIn [3] Prim provides the justification of these conditions. He later goes on to generalize the problem statement. Since the initial discussion has been in terms of the points on a distance-true map, the principles P1 and P2 could be based on visual judgements of relative distances [3]. Prim exchanges the visual distances for numerical values. The application of P1 and P2 goes through as before, where the relevant nearest neighbor is determined by a comparison of numerical labels [3]. Prim provides more conventional terminology of the Graph Theory:\n\n<table>\n<thead>\n<tr>\n<th>Term</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Terminal</td>\n<td>vertex</td>\n</tr>\n<tr>\n<td>Possible Link</td>\n<td>edge</td>\n</tr>\n<tr>\n<td>Length of Link</td>\n<td>length or weight of edge</td>\n</tr>\n<tr>\n<td>Connection Network</td>\n<td>spanning subgraph</td>\n</tr>\n<tr>\n<td>(Without closed loops)</td>\n<td>(spanning subtree)</td>\n</tr>\n<tr>\n<td>Shortest connection network</td>\n<td>shortest spanning subtree</td>\n</tr>\n</tbody>\n</table>\n\n\\(^{\\text{i}}\\) Prim refers to the terminal to which at a given stage of the construction, no connections have been made as an isolated terminal.\n\n\\(^{\\text{ii}}\\) Prim refers to the fragment to which, at a given stage of the construction, no external connection has been made as an isolated fragment. According to Prim’s definition, a fragment is a terminal subset connected by direct links, between members of the subset.\nPrim then goes on to generalize the original problem by seeking shortest spanning subtrees for arbitrarily connected labeled graphs, thus providing a computational technique, presenting the algorithm to be discussed and studied in greater detail in further sections.\n2. ALGORITHMS\n\nIn order to proceed with the experiment and detailed analysis of the results, we first analyze the Kruskal's [2] and Prim's [3] algorithms, in order to predict the possible outcomes and to be able to interpret results. To understand and predict a performance of a particular algorithm, we must not only account for the complexities associated with the flow of the algorithm itself; we must account for potential complexities of each step, that may appear less obvious initially. For example, as was mentioned earlier [9], sorting has a significant impact on the performance of Kruskal's algorithm, in some instances. If the implementation of the algorithm is to be targeted for a specific computing platform, we can even take into consideration complexities associated with the implementation of basic operations (steps) on that platform. In this thesis, we examine the complexities associated with the issues that are more abstract than those involved when using a specific computing platform, and thus common among the general majority of the computing environments.\n\n2.1 Greedy Algorithms\n\nThe implementations of Kruskal’s and Prim’s algorithm studied in this thesis are presented by Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest, in their book Introduction to Algorithms [7]. They introduce a notion of a generic algorithm for solving the minimum spanning tree problem, which is a generalization of both, Kruskal’s and Prim’s methods. Both methods are considered to use a “greedy” strategy, which advocates the best possible choice at the time the choice is to be made [7]. One can say that a greedy algorithm does not have an overall strategy, but rather picks the best option possible at any given time.\n\n2.2 Matroids\n\nCormen, Leiserson, and Rivest (to be referred to as CLR) state that the greedy algorithms yield optimal solutions when a combinatorial structure known as “matroid” is used [7]. The definition presented in [7] is as follows:\n\nA matroid is an ordered pair $M = (S, I)$ such that\n1. $S$ is a finite nonempty set [7].\n2. $I$ is nonempty family of subsets of $S$, called the independent subsets of $S$, such that if $B \\in I$ and $A \\subseteq B$, then $A \\in I$. $I$ is said to be hereditary if it satisfies this property. The empty set $\\emptyset$ is necessarily a member of $I$ [7].\n3. If \\( A \\in I \\), \\( B \\in I \\), and \\(|A| < |B|\\), then there exists some element \\( x \\in B - A \\) such that \\( A \\cup \\{x\\} \\in I \\). Thus, \\( M \\) satisfies the exchange property [7].\n\nCLR illustrate a graphic matroid \\( M_G = (S_G, I_G) \\), which they define in terms of an undirected graph \\( G = (V, E) \\) as follows:\n\n- The set \\( S_G \\) is defined to be \\( E \\), the set of edges of \\( G \\) [7].\n- If \\( A \\) is a subset of \\( E \\), then \\( A \\in I_G \\) if and only if \\( A \\) is acyclic. A set of edges is independent if and only if it forms a forest [7].\n\nThus, we can see that a graphical matroid is closely related to a minimum spanning tree [7].\n\nCLR present the following theorem, which they prove by contradiction [7]:\n\n**Theorem 1:**\nAll maximal independent subsets in a matroid have the same size.\n\n**Proof:** Suppose to the contrary that \\( A \\) is a maximal independent subset of \\( M \\) and there exists another larger maximal independent subset \\( B \\) of \\( M \\). Then, the exchange property implies that \\( A \\) is extendible to a larger independent subset \\( A \\cup \\{x\\} \\) for some \\( x \\in B - A \\), contradicting the assumption that \\( A \\) is maximal [7].\n\nLet \\( M_G \\) be a free\\(^1\\) tree with exactly \\( V - 1 \\) edges that connect all vertices of \\( G \\). If \\( M_G \\) is a graphic matroid for a connected, undirected graph \\( G \\), \\( M_G \\) is a spanning tree of \\( G \\). If the \\( M_G \\) is weighted, where there is a weight function \\( w(x) \\) that assigns a positive weight to each element \\( x \\in S \\), the weight function \\( w(x) \\) can be extended to subsets of \\( S \\) by:\n\n\\[\nw(A) = \\sum_{x \\in A} w(x)\n\\]\n\nfor any \\( A \\subseteq S \\) [7], which is essential weight function for a spanning tree:\n\n\\[\nw(T) = \\sum_{(u,v) \\in T} w(u,v)\n\\]\n\nwhere \\((u,v)\\) is the edge that connects vertices \\( u \\) and \\( v \\).\n\n\\(^1\\) A free tree is a connected graph \\( G \\), which has no cycles, with no vertex designated as a root of \\( G \\).\n2.2.1 Use of Greedy Approach for Graph Optimization Problems\n\nStudying the optimization problem in a weighted matroid, as defined below, one can see how the greedy approach can be applied to produce optimal results. As demonstrated by V. K. Balakrishnan [10], the greedy approach to solve the matroid optimization problem is reminiscent of the Kruskal’s and Prim’s algorithms to be discussed in the next two sections [10].\n\nLet \\( w \\) be a nonnegative weight function defined on the ground set \\( E \\) of an independent system. If \\( A \\) is a subset of \\( E \\), the weight of \\( A \\), denoted by \\( w(A) \\), is the sum of weights of all elements in \\( A \\). An optimization problem associated with the independent system is the problem of finding the independent set with the maximum weight [10]:\n\n1. Choose \\( x(k) \\) distinct from \\( x(1), x(2), \\ldots, x(k-1) \\) such that\n a) the set \\{\\( x(1), x(2), \\ldots, x(k-1), x(k) \\)\\} is an independent set\n b) if \\{\\( x(1), x(2), \\ldots, x(k-1), x \\)\\} is an independent set, the weight of \\( x \\) does not exceed the weight of \\( x(k) \\).\n2. Stop if no such \\( x \\) exists.\n\nThis can be demonstrated by the following theorem [10]:\n\n**Theorem 2:**\n\nA solution of the problem of finding a maximum weight independent set in an independent system can be obtained by using the greedy algorithm for every nonnegative weight function defined on its ground set if and only if the independent system is a matroid [10].\n\n**Proof:**\n\n1. If \\( I \\) and \\( J \\) are two independent sets in an independent system, with \\( p \\) and \\( (p+1) \\) elements, respectively, let \\( w(e) = (p+2) \\) for all \\( e \\) in \\( I \\), \\( w(e) = (p+1) \\) for all \\( e \\) in \\( (J-I) \\), and \\( w(e) = 0 \\) for all other nodes \\( e \\) in the ground set. Then \\( w(J) \\geq (p+1)(p+1) > p(p+2) = w(I) \\); hence, \\( I \\) is not a solution. By the greedy procedure, \\( I \\) and then an element is taken from \\( (J-I) \\). Thus, there exists an element \\( e \\) in the set \\( (J-I) \\) such that \\( I + e \\) is an independent set. Therefore the independent system is a matroid [10].\n2. Suppose that by applying the greedy algorithm, an independent set \\( I = \\{e_1, e_2, \\ldots, e_r\\} \\) is obtained (in a matroid) in which the elements are arranged in nondecreasing order by weight. If \\( J = \\{f_1, f_2, \\ldots, f_r\\} \\) is an independent set in a matroid, it can be proved by induction that \\( w(f_i) \\leq w(e_i) \\) for every \\( i \\). It is true for \\( i = 1 \\). Assumption: the condition\nholds for \\(i = 1, 2, \\ldots, (m-1)\\). Thus, the proof is required for \\(i = m\\). Suppose \\(w(f_m) > w(e_m)\\). Let \\(D = \\{e_1, e_2, \\ldots, e_{m-1}\\}\\) and \\(A = \\{e : w(e) \\geq w(f_m)\\}\\). Then \\(D\\) is an independent set and, by induction hypothesis, is subset of \\(A\\). If \\(D\\) is not maximal in \\(A\\), there exists \\(e\\) in \\(A\\) such that \\(D + e\\) is independent. But if \\(e\\) is in \\(A\\), \\(w(e) \\geq w(f_m) > w(e_m)\\), which implies that after picking \\(e_{m-1}\\), the greedy algorithm would have selected \\(e\\) and not \\(e_m\\).\n\nThus, \\(D\\) is maximal in \\(A\\). Since \\(D\\) has \\((m-1)\\) elements, any independent subset of \\(A\\) cannot have more than \\((m-1)\\) elements. But \\(\\{f_1, f_2, \\ldots, f_m\\}\\) is an independent subset of \\(A\\). The contradiction shows that \\(w(f_m) \\leq w(e_m)\\) [10].\n\nHence, the greedy approach is the optimal approach for solving the minimal-spanning-tree-problem, since the spanning trees are closely related to matroids, and the greedy approach proves to be the optimal approach for matroid optimization problem.\n\n2.2.2 Greedy Approach for the Minimum spanning tree problem\n\nCormen, Leiserson, and Rivest present a generalization of Kruskal’s and Prim’s Algorithms, which clearly illustrates the greedy approach. The generalization presented is as follows [7]:\n\n\\[\n\\text{GENERIC-MST}(G,w) \\\\\n1 \\quad A \\leftarrow \\emptyset \\\\\n2 \\quad \\text{while } A \\text{ does not form a spanning tree} \\\\\n3 \\quad \\text{do} \\quad \\text{find an edge } (u,v) \\text{ that is safe for } A \\\\\n4 \\quad \\quad A \\leftarrow A \\cup \\{(u,v)\\} \\\\\n5 \\quad \\text{return } A\n\\]\n\nAlgorithm 1 – Generalization of Kruskal’s and Prim’s Algorithms\n\nThis algorithm grows the minimum spanning tree one edge at a time. The set \\(A\\) is always a subset of some minimum spanning tree. With each step a test is performed to ensure that it is “safe” to add an edge \\((u,v)\\), ensuring that \\(A \\cup \\{(u,v)\\}\\) is a subset of the minimum spanning tree [7].\n\nThe invariant is “trivially” satisfied in line 1 of the algorithm. It is maintained in lines 2 through 4. The challenge is to find the edge that is safe for \\(A\\), as done in line 3 [7]. The existence of such edge is dictated by the invariant that there is a spanning tree \\(T\\) such that \\(A \\subseteq T\\); if there exists an edge \\((u,v) \\in T\\) such that \\((u,v) \\notin A\\), then it is safe to add\n(u,v) to A [7]. CLR provide a rule, in the form of a theorem, for recognizing safe edges, which they proceed to prove:\n\n**Definitions:**\n\n- **cut:** A cut \\((S, V-S)\\) of an undirected graph \\(G = (V, E)\\) is a partition of \\(V\\) [7], as shown in Figure 2.\n\n- **crossing:** It is said that an edge \\((u,v) \\in E\\) crosses the cut \\((S,V-S)\\) if one of its endpoints is in \\(S\\) and the other is in \\(S-V\\) [7].\n\n- **respect:** A cut respects the set \\(A\\) of edges if no edge in \\(A\\) crosses the cut [7].\n\n- **light edge:** An edge that crosses the cut with the weight minimum of any edge crossing the cut [7]. More than one light edge can exist.\n\n**Theorem 3:**\n\nLet \\(G = (V, E)\\) be a connected, undirected graph with a real-valued weight function \\(w\\) defined in \\(E\\). Let \\(A\\) be the subset of \\(E\\) that is included in some minimum spanning tree for \\(G\\), and let \\((S,V-S)\\) be any cut of \\(G\\) that respects \\(A\\), and let \\((u,v)\\) be a light edge crossing \\((S,V-S)\\). Then, edge \\((u,v)\\) is safe for \\(A\\) [7].\n\n**Proof:**\n\nLet \\(T\\) be a minimum spanning tree that includes \\(A\\), and assume that \\(T\\) does not contain the light edge \\((u,v)\\). If it does, the proof is complete. Another minimum spanning tree \\(T'\\) that includes \\(A \\cup \\{(u,v)\\}\\) is constructed by using the cut-and-paste technique, thus showing that \\((u,v)\\) is a safe edge for \\(A\\) [7]. The edge \\((u,v)\\) forms a cycle with the edges on the path \\(p\\) from \\(u\\) to \\(v\\) in \\(T\\) as shown below [7].\n\n---\n\n*Figure 2 – Cut \\((S, V-S)\\) [7]*\nBecause \\( u \\) and \\( v \\) are on the opposite sides of the cut \\( (S, S-V) \\), there is at least one edge in \\( T \\) on the path \\( p \\) that also crosses the cut. Let \\( (x, y) \\) be such edge. The edge \\( (x, y) \\) is not in \\( A \\), because the cut respects \\( A \\). Since \\( (x, y) \\) is on the unique path from \\( u \\) to \\( v \\) in \\( T \\), removing \\( (x, y) \\) breaks \\( T \\) into two components. Adding \\( (u, v) \\) reconnects them to form a new spanning tree \\( T' = T - \\{(x, y)\\} \\ Y \\{(u, v)\\} \\) [7].\n\nIt can now be shown that \\( T' \\) is a minimum spanning tree. Since \\( (u, v) \\) is a light edge, crossing \\( (S, S-V) \\) and \\( (x, y) \\), also crosses this cut, \\( w(u, v) \\leq w(x, y) \\). Therefore, \\( w(T') = w(T) - w(x, y) + w(u, v) \\leq w(T) \\). Since \\( T \\) is a minimum spanning tree, so that \\( w(T) \\leq w(T') \\), \\( T' \\) must be a minimum spanning tree also.\n\n\\[ A \\subseteq T', \\text{ since } A \\subseteq T \\text{ and } (x, y) \\notin A; \\text{ thus, } A \\ Y \\{(u, v)\\} \\subseteq T'. \\] Consequently, since \\( T' \\) is a minimum spanning tree, \\( (u, v) \\) is safe for \\( A \\) [7].\n\nBecause each of the \\( V-1 \\) edges is successfully determined, the loop in lines 2–4 of the GENERIC-MST is executed \\( V-1 \\) times. Initially \\( A = \\emptyset \\). There are \\( V \\) trees in \\( G_A \\). This number is reduced by 1 during each iteration. The algorithm terminates when the forest contains a single tree [7].\n2.3 Kruskal’s Algorithm\n\nKruskal’s algorithm falls perfectly into the greedy paradigm. Since Kruskal’s algorithm is essentially a specialization of the GENERIC-MST [7] presented by CLR, it proceeds with the same approach. The approach taken by Kruskal is to pick the edge with the smallest weight value such that both vertices of the edge are not present in the set $T$ and add that edge to the set $T$. The process of picking the edge with the smallest weight value is characteristic of the greedy approach taken by the algorithm. The following implementation is provided by CLR [7]:\n\n$$\\text{MST-KRUSKAL}(G,w)$$\n1. $A \\leftarrow \\emptyset$\n2. for each vertex $v \\in V[G]$\n3. do MAKE-SET($v$)\n4. sort the edges of $E$ by nondecreasing weight $w$\n5. for each edge $(u,v) \\in E$, in order by nondecreasing weight\n6. do if $\\text{FIND-SET}(u) \\neq \\text{FIND-SET}(v)$\n7. then $A \\leftarrow A \\cup \\{(u,v)\\}$\n8. UNION($u,v$)\n9. return $A$\n\nAlgorithm 2 – Implementation of Kruskal’s Algorithm\n\nCLR [7] claim that this implementation is the asymptotically fastest implementation known today. They attribute this to the use of the disjoint-set data structures to maintain several disjoint-sets of elements (trees in the forest), which results in the running time $O(E\\alpha(E,V))$, excluding the sorting time, where $\\alpha$ is the functional inverse of the Ackerman’s function [7]. We will study this implementation in more detail. By simple examination of the algorithm, we can easily see that the complexity of the algorithm itself, excluding the MAKE-SET, FIND-SET, UNION, and sorting operations is $O(E)$ where $E$ is the number of edges in the graph $G$. The implementation of these operations may have a significant impact on the performance of the algorithm. We will study the results produced by variations of implementation of sorting. The two implementations to be studied here are the heapsort and the counting sort. To observe the effect of sorting on the performance, we can observe the change in the performance by eliminating the sorting entirely. This can be achieved by measuring the performance of the algorithm minus the time required for sorting the edges. Hence, one can observe the performance of the algorithm based strictly on the implementation of the disjoint-set data structure. We will present the experiment setup and the results in the next chapter. Since the use of the disjoint-set data structure yields the most efficient implementation of Kruskal’s algorithm known today, the main focus of the experiment is on sorting, which can result in severe degradation of performance.\n2.4 Prim’s Algorithm\n\nPrim’s algorithm is a specialization of the GENERIC-MST [7], similarly to Kruskal’s algorithm. Unlike Kruskal, where multiple trees in the forest are joined until a single spanning tree is formed, Prim maintains a single tree in the set $A$. The tree starts from an arbitrary root vertex $r$ and grows until it spans all vertices in the set $V$. With each iteration, a light edge connecting a vertex in $A$ to a vertex in $V - A$ is added to the tree; adding only the edges that are safe for $A$. When the algorithm terminates, the edges in $A$ form a minimum spanning tree [7]. The augmentation of the tree with each step with the edge that has a minimum weight renders this strategy “greedy”. The efficiency of the algorithm depends on the strategy used for selecting a new edge to be added to the tree.\n\nCLR provide the implementation of the algorithm which uses the priority queue $Q$ which is based on a key field [7]:\n\n```plaintext\nMST-PR1M(G,w,r)\n1 Q ← V[G]\n2 for each u ∈ Q\n3 do key[u] ← ∞\n4 key[r] ← 0\n5 π[r] ← NIL\n6 while Q ≠ ∅\n7 do u ← EXTRACT-MIN(Q)\n8 for each v ∈ Adj[u]\n9 do if v ∈ Q and w(u,v) < key[v]\n10 then π[r] ← u\n11 key[v] ← w(u,v)\n```\n\nAlgorithm 3 - Implementation of Prim’s Algorithm\n\nFor each vertex $u$, $key[u]$ is the minimum weight of any edge connecting $u$ to a vertex in the tree. If no such edge exists, $key[u] = ∞$. The field $π[v]$ specifies the parent of $v$ in the tree [7]. While the algorithm is running, the set of edges $A$ is:\n\n$$A = \\{(v,π[v]) : v ∈ V - \\{r\\} - Q\\}$$\n\nUpon termination, when the priority queue is empty, the set of edges $A$ is [7]:\n\n$$A = \\{(v,π[v]) : v ∈ V - \\{r\\}\\}.$$\nTo reiterate, the performance of Prim’s algorithm depends on the implementation of the priority queue. Next chapter describes the study of the performance obtained as the result of experimentation with various implementations of the priority queue $Q$.\n\n2.5 Areas of “Weakness”\n\nThe main goal of the thesis is to test the performance of the Kruskal’s and Prim’s algorithms using various implementations of the data structures that can have a significant effect on the algorithm’s performance. The basic analysis of the algorithms can reveal the areas where the implementation of the data structure can have a significant impact.\n\n2.5.1 Areas of “weakness” in Kruskal’s Algorithm\n\nExamining the implementation of Kruskal’s Algorithm shown in Algorithm 2 one can easily identify the complexity of the overall algorithm, excluding the complexities inherent in some of the basic steps. One can easily see that the lines 1, 4, and 9 are executed once; the lines 2 and 3 are executed $\\Theta(V)$ times; and the lines 5 – 8 are executed $O(E)$ times. Thus, ignoring the time complexities, which might be inherent in some of the basic steps, the initial observation suggests that the algorithm runs in $O(E)$ time. However, lines 3, 4, and 6 – 8 involve calls to other procedures. Hence, the implementation of these procedures may significantly affect the overall performance of the algorithm. Since the implementation of the Kruskal’s algorithm in this experiment uses the disjoint-set data structure with path-compression heuristic, it shall remain a constant factor, and thus will not be considered an area of “weakness”. It is, however necessary to examine the running time of the Kruskal’s Algorithm with disjoint-sets and path-compression heuristic in order to understand their contribution to the overall complexity of the algorithm. The disjoint-set data structure used in this implementation of the Kruskal’s Algorithm supports the following operations: MAKE-SET($x$), UNION($x,y$) and FIND-SET($x$), where $x$ and $y$ denote the objects that are the members of the sets. The MAKE-SET($x$) operation creates a set where $x$ is the only object. FIND-SET($x$) returns a pointer to some representative of the set which contains $x$. UNION($x,y$) merges two sets, each containing $x$ and $y$ objects into one set containing both $x$ and $y$ objects. The implementation used in this experiment is provided by CLR [7], which uses the union by rank with path compression. The union by rank yields the $O(m \\log n)$ running time, where $\\Omega(n)$ lower bound is denoted by $m$ [11]. The path compression heuristic yields the worst-case running time of $\\Theta(f \\log_{(1+f/n)} n)$ if $f \\geq n$ and $\\Theta(n + f \\log n)$ if $f < n$, where $f$ is the number of FIND-SET operations [11]. The worst case running time when both, union by rank and path compression are used is $O(m \\alpha(m,n))$. The $\\alpha(m,n)$ is the inverse of the Ackerman’s function [11], and is defined as follows:\n\\[\nA(l,j) = 2^j \\quad \\text{for} \\quad j \\geq 1 \\\\\nA(i,1) = A(i-1,2) \\quad \\text{for} \\quad i \\geq 2 \\\\\nA(i,j) = A(i-1,A(i,j-1)) \\quad \\text{for} \\quad i, j \\geq 2\n\\]\n\nAccording to CLR [7] in any conceivable application of the disjoint-set data structure, the running time can be viewed as \\( m \\) in most practical situations, since \\( \\alpha(m,n) \\leq 4 \\) for \\((m,n)\\). CLR introduce a slightly weaker upper bound on the running time, \\( O(m \\log^* n) \\). They use the aggregate method of amortized analysis to prove the \\( O(m \\log^* n) \\) time bound [7]. CLR present and prove the following theorem:\n\nA sequence of \\( m \\) MAKE-SET, LINK, and FIND-SET operations, \\( n \\) of which are MAKE-SET operations, can be performed on a disjoint-set forest with union by rank and path compression in worst-case time \\( O(m \\log^* n) \\) [7].\n\nThe proof is provided in [7] on pp. 455 – 457.\n\nThe concern still lies with sorting. Since the disjoint-set operations with path compression heuristics allow the algorithm to run in practically linear time, it appears that most of the complexity is attributed to sorting. Hence this is the area studied in greater detail through experimentation.\n\n### 2.5.2 Areas of “weakness” in Prim’s Algorithm\n\nExamining the implementation of Prim’s Algorithm shown in Algorithm 3 following complexities of basic operations become obvious. Line 1 is executed in \\( \\Theta(V) \\) time, since every vertex in the graph has to be enqueued. Lines 2 and 3 are executed in \\( \\Theta(V) \\) time as well. Lines 4 and 5 are executed once. The lines 6 and 7 are executed \\( V \\) times; the lines 8 and 9 are executed \\( \\frac{1}{2}(V^2 - V) \\) times\\(^{ii} \\); and lines 10 and 11 are executed \\( \\frac{1}{2}e(V^2 - V) \\) times. This yields the \\( O(E) \\) running time. The area of concern is the implementation of the priority queue \\( Q \\). It is therefore anticipated that it is a major factor in the overall performance of the algorithm. Thus, the implementation of the priority queue to be used in Prim’s algorithm is studied in a great detail through experimentation.\n\n---\n\n\\(^{ii}\\) The \\textbf{LINK} procedure is called by \\textbf{UNION} procedure. It takes to two roots as inputs, and links them such that the root with the higher rank becomes a parent of the root with the lower rank. If both ranks are equal, then the rank of the parent is incremented by 1.\n\n\\(^{ii}\\) The adjacent edges are sought in the adjacency matrix, which was provided as input data to the function. The edges are located by iterating from the edge \\( e(x, y) \\) of the matrix, until \\( x = y \\), for each row.\n2.6 Expected Results\n\nPrior to performing the experiment, we conduct a detailed analysis of all implementations used, in order to be able to predict the performance of each. The complexities associated with the \"areas of weakness\" of each implementation are expected to be the major contributors to the running time of the algorithms, and therefore are candidates for optimization. To predict the performance of each implementation studied in this thesis, we proceed with thorough analysis of the implementation of each algorithm.\n\n2.6.1 Analysis of Kruskal's Algorithm\n\nBoth implementations of Kruskal's algorithm used in this experiment consist of two phases, sorting and growing a forest. Each phase can be potentially a dominating factor in the total running time of the algorithm. We therefore need to identify and predict the area where most of the time will be spent. The total running time of the algorithm can be expressed as\n\n\\[ T = T_M + T_F + T_U + T_S. \\]\n\nWe first determine the contribution that the operations associated with disjoint-set data structure make to the total running time of the algorithm. Looking at the implementation of the algorithm below, we note the number of times each line is expected to execute:\n\n```plaintext\nMST-KRUSKAL(G,w)\n 1 A <- 0 1 time\n 2 for each vertex v in V[G] V times\n 3 do MAKE-SET(v) V times\n 4 sort the edges of E by nondecreasing weight w 1 time\n 5 for each edge (u,v) in E, in order by nondecreasing weight E times\n 6 do if FIND-SET(u) != FIND-SET(v) E times\n 7 then A <- A U {(u,v)} V-1 times\n 8 UNION(u,v) V-1 times\n 9 return A\n```\n\nSince all disjoint-set operations with union by rank and path compression run in \\( O(m \\lg^* n) \\) time, we first determine the values of \\( n \\) and \\( m \\). Since \\( m \\) is the total of all MAKE-SET, FIND-SET, and UNION operations, \\( m = T_M + T_F + T_U \\). Thus,\n\n\\[ T_M - \\text{total time of all MAKE-SET operations}, \\quad T_F - \\text{total time of all FIND-SET operations}, \\quad T_U - \\text{total time of all UNION operations}, \\quad T_S - \\text{total time spent sorting edges} \\]\n\\[ m = V + 2E + V - 1 = 2V + 2E - 1 \\]\n\nGiven that \\[ E = \\frac{V^2 - V}{2} \\times \\epsilon \\], where \\( \\epsilon = p \\) is the density of the graph \\( G \\),\n\n\\[\nm = 2V + V^2 \\epsilon - V \\epsilon - 1 = V^2 \\epsilon + V(2 - \\epsilon) - 1\n\\]\n\nand given that \\( \\lg^* V \\equiv 4 \\), because the number of MAKE-SET operations is equal to \\( V \\) and \\( 100 \\leq V \\leq 1700 \\)[7],\n\n\\[\nm \\lg^* V = 4 \\epsilon V^2 + (4 - 4 \\epsilon)V - 4 = O(V^2)\n\\]\n\nfor fixed density \\( \\epsilon \\). We therefore state that the total running time of each implementation is\n\n\\[ O(V^2) + O(T_s) \\]\n\nThe implementations of Kruskal’s algorithm used in this experiment differ only in the method used to sort the edges of the graph. We therefore look at the time required by each sorting method, and use that to determine which is the dominating factor in the algorithm’s total running time.\n\n**Counting Sort (kcs).**\n\nThe counting sort runs in linear time \\( O(n) \\)[7]. The sort determines for each input element \\( x \\), the number of elements less than \\( x \\). Then each element is placed directly into its position in the output array. The input is an array \\( A[1..n] \\), of length \\( n \\). Two other arrays are used, \\( B[1..n] \\) to store the sorted output, and \\( C[1..k] \\) to be used as working storage, where \\( k \\) is the value of the largest element \\( x \\) in \\( A \\). All values in \\( C \\) are initially 0. The values of each input element are then inspected. If the value of the input element is \\( i \\), the \\( C[i] \\) is incremented, resulting in \\( C[i] \\) containing the number of input elements equal to \\( i \\) for each integer value of \\( i = 1, 2, ..., k \\). Then the number of elements less than or equal to \\( i \\) is determined, by keeping a running sum of the array \\( C \\). Finally, each element of \\( A \\) is placed in its correct sorted position in the output array \\( B \\)[12]. We can therefore see that the counting sort runs in \\( O(E) = O(V^2) \\) time. Hence, the total running time of the algorithm is:\n\n\\[\nO(V^2) + O(V^2) = O(V^2)\n\\]\nfor fixed density ε. From this we cannot conclude which phase of the implementation dominates the total running time. Thus, we make an assumption that both phases contribute equally. This is to be verified through experimentation.\n\n**Heapsort (khp).**\n\nThe running time of the heapsort is $O(n \\log n)$ steps. The sort requires one call to the procedure to build the heap, which is done on $O(n)$ time, and $n - 1$ calls to procedure to restore the heap property, each taking $O(\\log n)$. We therefore say that the heapsort runs in $O(n \\log n)$ time. Given that we are sorting the edges of the graph, using the heapsort the sorting time is\n\n$$T_s = O(E \\log E) = O(V^2 \\log V)$$\n\nThe total running time of the algorithm is then,\n\n$$O(V^2) + O(V^2 \\log V) = O(V^2 \\log V)$$\n\nHence, for the implementation of Kruskal’s algorithm using the heapsort, sorting is the dominating factor in the total running time. We can therefore anticipate the implementation of Kruskal’s algorithm that uses the heapsort to perform worse than the implementation of Kruskal’s algorithm that uses the counting sort.\n\nKruskal’s algorithm is performed in two phases. In the first phase the edges are sorted in a nondecreasing order. In the second phase, a forest is grown until $V$ vertices are connected to form a minimum spanning tree. The “areas of weakness” are self-contained, which renders the analysis of the running times attributed to the implementations of various sections of the algorithm simple.\n\n### 2.6.2 Analysis of Prim’s Algorithm\n\nIn Prim’s algorithm, the “area of weakness” is in the implementation of the priority queue, which is tightly integrated into several steps of the algorithm. We therefore concentrate on the overall running time of the algorithm, rather than looking at it in phases, as was done in Kruskal’s algorithm. This algorithm uses total of three operations, **Build-Queue**, **Extract-Min**, and **Decrease-Key**, times for which we will denote as\n\\( T_B, T_E, \\) and \\( T_D, \\) respectively. The worst case total running time of Prim’s algorithm can be expressed as\n\n\\[\nT = T_B + \\sum_{v \\in G} T_E + \\sum_{(u,v) \\in G} T_D = T_B + VT_E + E\\varepsilon T_D\n\\]\n\nMST-PRIM(G,w,r)\n1 \\( Q \\leftarrow V[G] \\) \\hspace{3cm} V times\n2 \\text{for each} \\ u \\in Q \\hspace{2cm} V \\text{times}\n3 \\hspace{0.5cm} \\text{do} \\ key[u] \\leftarrow \\infty \\hspace{2cm} V \\text{times}\n4 \\ key[r] \\leftarrow 0 \\hspace{2cm} 1 \\text{time}\n5 \\pi[r] \\leftarrow \\text{NIL} \\hspace{1cm} 1 \\text{time}\n6 \\text{while} \\ Q \\neq \\emptyset \\hspace{1cm} V \\text{times}\n7 \\hspace{0.5cm} \\text{do} \\ u \\leftarrow \\text{EXTRACT-MIN}(Q) \\hspace{1cm} V \\text{times}\n8 \\hspace{1cm} \\text{for each} \\ v \\in \\text{Adj}[u] \\hspace{1cm} \\frac{1}{2} (V^2 - V) \\text{times}\n9 \\hspace{1.5cm} \\text{do if} \\ v \\in Q \\text{ and} \\ w(u,v) < key[v] \\hspace{1cm} \\frac{1}{2} (V^2 - V) \\text{times}\n10 \\hspace{2.5cm} \\text{then} \\ \\pi[r] \\leftarrow u \\hspace{1cm} \\frac{1}{2} \\varepsilon (V^2 - V) \\text{times}\n11 \\hspace{3.5cm} key[v] \\leftarrow w(u,v) \\hspace{1cm} \\frac{1}{2} \\varepsilon (V^2 - V) \\text{times}\n\nWe can see that the performance of the algorithm is affected by the running time of the priority queue operations. We now look at each of the implementations of Prim’s algorithm studied in this thesis.\n\n**Brute Force (pbf).**\n\nThis implementation does not have a build cost associated with the use of priority queue. The edges and their keys are stored in an array. To perform an \\text{EXTRACT-MIN} operation, the array is searched for the element with minimum key, which is then returned. The location where the element with the minimum key is stored, is set to \\( \\infty \\). \\text{EXTRACT-MIN} operation will always be done in \\( \\Theta(V) \\) time. Since no heap is used in this implementation, we do not need to worry about maintaining any heap properties. The \\text{DECREASE-KEY} operation will therefore be always done in \\( \\Theta(1) \\) time. The total running time of the “brute force” implementation of Prim’s algorithm is\n\n\\[ T_B - \\text{time to build the heap; } T_E - \\text{time to perform } \\text{EXTRACT-MIN} \\text{ operation; } T_D - \\text{time to perform } \\text{DECREASE-KEY} \\text{ operation.} \\]\n\\[ T = \\Theta(V) + \\Theta(V^2) + O(E) \\]\n\\[ = V + V^2 + \\frac{1}{2} \\varepsilon V^2 + \\frac{1}{2} \\varepsilon V \\]\n\\[ = (1 + \\frac{1}{2} \\varepsilon + 1)V^2 + (1 + \\frac{1}{2} \\varepsilon + 1)V \\]\n\\[ = \\Theta(V^2) \\]\n\nThus, the complexity of the implementation of Prim’s algorithm using “brute force” for priority queues appears to be very tightly bound. This tight bound is attributed to the asymptotic complexity of the EXTRACT-MIN operation. Since precisely \\( V \\) EXTRACT-MIN operations are to be performed, and given that each operation takes \\( \\Theta(V) \\) time, we can expect a very consistent performance of this algorithm. In general, the performance is expected to be worse than that of other implementation, however for dense graphs, it may perform as well as the other implementations studied in this experiment.\n\n**Binary Heap – “Proper Implementation” (\\( \\text{php}_a \\)).**\n\nWhen analyzing the performance of algorithms that make use of heaps, we consider the cost of maintaining a heap property in EXTRACT-MIN and DECREASE-KEY operations. Each time a minimum element is extracted the last element on the heap is moved in the place of the minimum element. The element that was placed in the place of the minimum element is “sifted down”, until the heap invariant is restored. The element that is “sifted down” will “travel” the maximum length of \\( \\lceil \\lg n \\rceil \\) vertices, since the height of a binary heap of \\( n \\) elements is \\( \\lceil \\lg n \\rceil \\). We then conclude that the EXTRACT-MIN operation is performed in \\( O(\\lg V) \\) time. The DECREASE-KEY operation (Algorithm 3, line 11, page 15) requires that heap invariant is maintained. When a key is decreased, the new value is “percolated up” until the heap invariant is satisfied. In the worst case, this percolation is done in \\( \\lceil \\lg n \\rceil \\) swaps, for the heap of \\( n \\) elements. The DECREASE-KEY operation is therefore performed in \\( O(\\lg V) \\) time. Another factor that we need to consider is the cost to build the heap upon initialization. In this implementation of Prim’s algorithm, the heap is build with all elements having the key value, which is equal to \\( \\infty \\). This eliminates the requirement of satisfying the heap invariant upon BUILD. Nevertheless, the key value of each element must be set to \\( \\infty \\), thus requiring the iteration over the entire array on which the heap is implemented. The running time of the build operation is therefore \\( \\Theta(V) \\) for the graph with \\( V \\) vertices. We can therefore say that \\( T_B = \\Theta(V) \\), \\( T_E = O(\\lg n) \\), and \\( T_D = O(\\lg n) \\). The total running time of the implementation of Kruskal’s algorithm with priority queue implemented on a binary heap is\n\\[ T = \\Theta(V) + O(V \\lg V) + O(E \\lg V) \\]\n\\[ = \\Theta(V) + O(V \\lg V) + O(V^2 \\lg V) \\]\n\\[ = O(E \\lg V) \\]\n\nfor fixed density \\( \\varepsilon \\).\n\nFor dense graphs, where \\( \\varepsilon \\) approaches 1, we can expect the asymptotic bound to approach \\( O(V^2 \\lg V) \\), given that \\( E = \\frac{1}{2} \\varepsilon (V^2 - V) \\).\n\nFrom this we can expect performance better than that of the implementation that uses the \"brute force\" implementation of the priority queue.\n\n**Binomial Heap (pbinh).**\n\nBinomial heap is a collection of binomial trees. The \\( i \\)-th binomial tree \\( B_i \\), \\( i \\geq 0 \\) is defined recursively. It consists of a root node and \\( i \\) children. The \\( j \\)-th child, \\( 1 \\leq j \\leq i \\), is the root of the binomial tree \\( B_{j-1} \\) [5].\n\n\n\nFigure 4 illustrates the binomial heap consisting of five binomial trees, \\( B_0 \\) through \\( B_4 \\). CLR provide the following lemma:\n\n**Lemma:**\n\n1. The binomial tree \\( B_k \\) contains \\( 2^k \\) nodes.\n2. \\( B_k \\) has a height \\( k \\).\n3. There are exactly \\( \\binom{k}{i} \\) nodes of depth \\( i = 0,1,K,k \\).\n4. The root has a degree \\( k \\), which is greater than that of any other node. If the children of that root are numbered from left to right, by \\( k-1, k-2, K, 0 \\), child \\( i \\) is the root of the subtree \\( B_i \\) [7].\n\n**Proof:**\n\nThe basis of the proof is \\( B_0 \\); the inductive step is \\( B_{k-1} \\).\n\n1. Binomial tree \\( B_k \\) consists of two trees \\( B_{k-1} \\), therefore, has \\( 2^{k-1} + 2^{k-1} = 2^k \\) nodes [7].\n2. Because of the way two \\( B_{k-1} \\) trees are linked to form \\( B_k \\), the maximum depth of a node in \\( B_k \\) is one greater than the maximum depth of a node in \\( B_{k-1} \\). By inductive hypothesis, the maximum depth is \\( (k-1) + 1 = k \\) [7].\n3. Let \\( D(k, i) \\) be the number of nodes at depth \\( i \\) of a binomial tree \\( B_k \\). Because \\( B_k \\) is two linked \\( B_{k-1} \\) trees, a node at the depth \\( i \\) in \\( B_{k-1} \\) appears in \\( B_k \\) once at depth \\( i \\), and once at depth \\( i + 1 \\). Thus, the number of nodes at depth \\( i \\) in \\( B_k \\) is the number of nodes at the depth \\( i \\) in \\( B_{k-1} \\) plus the number of nodes at depth \\( i - 1 \\) in \\( B_{k-1} \\) [7]. Then,\n\n\\[\nD(k, i) = D(k-1, i) + D(k-1, i-1)\n\\]\n\n\\[\n= \\binom{k-1}{i} + \\binom{k-1}{i-1} = \\binom{k}{i}\n\\]\n\n4. The only node with greater degree in \\( B_k \\) than \\( B_{k-1} \\) is the root, which has one more child than \\( B_{k-1} \\). Because the root of \\( B_{k-1} \\) has a degree \\( k-1 \\), the root of \\( B_k \\) has a degree \\( k \\). By inductive hypothesis, the children of \\( B_{k-1} \\) are \\( B_{k-2}, B_{k-3}, K, B_0 \\). When \\( B_{k-1} \\) is linked to \\( B_{k-1} \\), the resulting root are the roots of \\( B_{k-1}, B_{k-2}, B_{k-3}, K, B_0 \\) [7].\n\n**Corollary:**\n\nThe maximum degree of any node in an \\( n \\)-node binomial tree is \\( \\lg n \\) [7].\n\n**Proof:**\n\nProperties 1 and 4 of lemma.\n\nA binomial heap is a collection of binomial trees, where each tree must be different in size. Each tree must also satisfy the heap invariant, thus ensuring that the element with the minimum key value is stored in one of the roots of the trees. The trees are stored in the order of increasing size. The trees may be organized as a linked list, however in the implementation used in this experiment, the trees were stored in an array of pointers.\nGiven that the size of a binomial tree $B_k$ is the sum of sizes of all trees $B_0, B_1, K, B_{k-1}$ plus 1, thus $|B_k| = 2^k$, the total number of elements in a binomial heap with $k$ trees is $\\sum_{i=0}^{k} 2^i$. Since there is at most one binomial tree with a given root in a binomial heap, we can see that there is at most $\\lfloor \\lg n \\rfloor + 1$ binomial trees in any binomial heap.\n\nThus, from these properties we see that the minimum element can be located in the worst case in $O(\\lg n)$ time. The \\texttt{DECREASE-KEY} operation would also be performed in $O(\\lg n)$ time, since only the tree in which the key has been decreased needs to have the heap invariant restored. The \\texttt{EXTRACT-MIN} operation is not as straight-forward as in the binary heap. When an \\texttt{EXTRACT-MIN} is performed, one of the roots is detached. Detaching a root from a binomial tree $B_k$ results in a formation of a set of binomial trees $\\{B'_0, B'_1, K B'_{k-1}\\}$. Since the trees of the degrees 0,1,K,k−1 are already present in the binomial heap, the newly formed trees must be linked with the existing trees. \\{B'_0, B'_1, K B'_{k-1}\\} can be viewed as forming a binomial heap as well. Hence, performing an \\texttt{EXTRACT-MIN} operation on a binomial heap $H$, results in the formation of two binomial heaps, $H$ and $H'$, which must be merged to form a single heap. Prior to merging the two heaps, the trees of $H'$ must be joined to form the binomial heap, which is done in $O(\\lg n)$ time. Once we have two heaps, we link the trees of equal degrees with one another. The link is done in $O(1)$ by making the root of $B_{k-1}$ the child of $B'_{k-1}$, thus resulting in $B_k$. However, this may result in the formation of more than one tree of the same degree. The trees with the same degrees are linked again, to form the tree with a degree one higher. This is repeated for all pairs of trees in both heaps. Since this process is analogous to the bitwise addition with carry, the process of merging two binomial heaps is done in $O(\\lg n)$ time. We can therefore conclude that the \\texttt{EXTRACT-MIN} operation takes $O(\\lg n)$ time. We also need to consider the time to build the binomial heap. This is done in once. However, when used in Prim's algorithm we need to start with the binomial heap containing $V$ elements. The insert operation involves merging of two heaps, thus taking $O(\\lg n)$. Thus, insertion of $n$ elements is done in $O(n \\lg n)$, which we will consider the build time for our purposes. We then conclude, that\n\n\\[\nT_B = O(V \\lg V) \\\\\nT_E = O(\\lg V) \\\\\nT_D = O(\\lg V)\n\\]\n\nThe total running time of Prim's algorithm with the priority queue implemented as a binomial heap is\n\\[ T = O(V \\lg V) + O(V \\lg V) + O(E \\lg V) \\\\\n= O(E \\lg V) \\]\n\nWe then expect performance similar to that of binary heap with proper implementation. For the dense graphs, as with proper heap implementation, we can expect the asymptotic upper bound approach \\( O(V^2 \\lg V) \\). However, given the nature of the data structure used to implement the binomial heap, an array of multiple trees, we can expect higher overhead, hence worse performance.\n\n**Fibonacci Heap (pfibh).**\n\nLike binomial heap, Fibonacci heap is a collection of heap-ordered trees. The sizes of these trees grow according to the Fibonacci sequence defined by the recurrence:\n\n\\[\nF_k = \\begin{cases} \n0 & \\text{if } k = 0 \\\\\n1 & \\text{if } k = 1 \\\\\nF_{k-1} + F_{k+1} & \\text{if } k \\geq 2 \n\\end{cases}\n\\]\n\nThe trees in the Fibonacci heap are not constrained like the trees with binomial heap. They are rooted, but not ordered by size.\n\n\n\nThe Fibonacci heap is implemented as a circular doubly linked list of roots. Each root points to only one child. The children of each root are also linked in a circular doubly linked list. Each child has a pointer to its parent. The advantages of using the circular doubly linked lists is that a node can be removed in \\( O(1) \\) time, and two such lists can be concatenated \"spliced\" together in \\( O(1) \\) time. Each node has two attributes, a degree, and a marked flag. The degree indicates the number of children the node has; the marked flag indicate whether a given node has lost a child, since the last time that node was made a child of another node. The node becomes unmarked whenever it is made a child of another node, or it is newly created. The pointer \\( min[H] \\) indicates the tree whose root has\nthe minimum key value of all other roots in the heap. When the Fibonacci heap is created, like binomial heap it is created empty. To store all vertices on the heap, they must be inserted one at a time. When a node is inserted into the heap, it is added to the root list of the heap. Since this is a concatenation operation, it is done in $O(1)$. \\textsc{Find-Min} is performed in $O(1)$ as well, since there is a pointer to the root node with the minimum key value. \\textsc{Decrease-Key} operation results in assignment of a new key value to a node. If the new key value of the node is not less than that of its parent, no changes are made to the heap. If the new value is less than the parent, a \\textsc{Cut} is performed, followed by a \\textsc{Cascading-Cut}. The \\textsc{Cut} operation “cuts” the node from its parent and adds it to the root list. The parent’s degree is decremented, and the node that has been cut is “unmarked”. The \\textsc{Cascading-Cut} checks if the parent of the node cut is marked. If it is not, the parent is marked. If the parent is marked, a \\textsc{Cut} is performed on the parent, followed by a \\textsc{Cascading-Cut}. This process is performed recursively, moving the nodes out into the root list, until an unmarked node or a root is reached. When all \\textsc{Cascading-Cuts} are completed, the $\\min[H]$ pointer is updated, if necessary. The time to perform \\textsc{Decrease-Key} operation is amortized to $O(1)$ [13]. The actual cost to perform the \\textsc{Decrease-Key} operation is $O(1)$ plus the time to perform the \\textsc{Cascading-Cuts}. If \\textsc{Cascading-Cut} is recursively called $c$ times, given that the cost of decreasing the key is $O(1)$, the actual cost of performing the \\textsc{Decrease-Key} plus the cost of cascading cuts is $O(c)$. \\textsc{Decrease-Key} operation does not result in the ordered list of trees. The ordered list property is restored when the \\textsc{Extract-Min} operation is performed. The cost of the \\textsc{Decrease-Key} operation is therefore amortized. To determine the amortized cost of the \\textsc{Decrease-Key} operation, we perform the amortized analysis. We first compute the change in potential. $H$ denotes the Fibonacci heap prior to the \\textsc{Decrease-Key} operation. Each recursive call to the \\textsc{Cascading-Cut}, except for the last one, cuts a marked node and clears its mark flag. This results in $c$ more trees in the root list than there was initially. If $t(H)$ denotes the number of trees in the root list prior to \\textsc{Decrease-Min} operation, then upon completion there are $t(H) + c$ trees in the root list upon completion. There are at most $m(H) - c + 2$ marked nodes. $c - 1$ nodes are unmarked by cascading cuts, and the last call to \\textsc{Cascading-Cut} may have marked a node. The change in potential, is then,\n\n\\[\n(t(H) + c) + 2(m(H) - c + 2) - (t(H) + 2m(H)) = 4 - c\n\\]\n\nThe amortized cost of \\textsc{Decrease-Key} is at most\n\n\\[\nO(c) + 4 - c = O(1)\n\\]\n\n\\textsc{Extract-Min} operation is more complicated. This is where the trees of the root list are consolidated, the work that was delayed when \\textsc{Insert} and \\textsc{Extract-Min} operations were performed. When the root with the minimum key value is extracted, each one of its\nchildren is made a root. The minimum node is removed from the root list. The CONSOLIDATE operation links the roots of equal degrees until at most, one root of each degree remains. The LINK operation removes a root from the list of roots, and then making it a child of another node, unmarking the node removed. The amortized time for extracting a node with the minimum key value from the Fibonacci heap is $O(D(n))$. The minimum node has at most $D(n)$ children. When CONSOLIDATE is called, the size of the root list is at most $D(n) + t(H) - 1$. $t(H)$ denotes the original root list of $H$. Since one node is extracted, we subtract 1. We also consider $D(n)$ children of the extracted node. Thus, the total actual work is $O(D(n) + t(H))$. The potential before extracting the minimum node is $t(H) + 2m(H)$, and the potential afterwards is at most $(D(n) + 1) + 2m(H)$. The amortized cost is at most\n\n$$O(D(n) + t(H)) + ((D(n) + 1) + 2m(H)) - (t(H) + 2m(H)) = O(D(n)) + O(t(H)) - t(H) = O(D(n))$$\n\nThe cost of performing each link is defrayed by reduction in potential when the link reduces the number of roots by one. These operations do not preserve the property that all trees in the Fibonacci heap are unordered binomial trees. But these trees are close enough that the maximum degree $D(n)$ can be bound by $O(\\lg n)$. Thus, EXTRACT-MIN operation is performed in $O(\\lg n)$ amortized time.\n\nWe therefore conclude the time to build the heap to be used in the implementation of Prim's algorithm with priority queue implemented as a Fibonacci heap is\n\n$$T_B = O(V),$$\n\nwhich accounts for the time to build the heap, which is $O(1)$, and the time to insert $V$ elements onto the heap, each done in $O(1)$. The time to DECREASE-KEY is\n\n$$T_D = O(1)$$\n\namortized time, and the time to EXTRACT-MIN is\n\n$$T_E = O(\\lg V)$$\n\namortized time. We can therefore expect the total running time of the implementation of Prim's algorithm that uses the Fibonacci heap, to be\n\\[ T = O(V) + O(\\log V) + O(E) \\\\\n = O(E) \\]\n\namortized time, which for dense graphs can approach \\( O(V^2) \\). The Fibonacci heap implementation promises a very good performance because the priority queue operations execute in the amortized time.\n\n**Binary Heap – “lazy implementation” (php).**\n\nThis implementation of the binary heap is somewhat similar to the implementation of Fibonacci heap in the sense that the maintenance of the heap invariant is delayed until absolutely necessary. In the proper implementation of the binary heap, the heap property is restored immediately after the DECREASE-KEY operation has been performed on one of the nodes. In “lazy” implementation, the heap property is restored prior to performing the EXTRACT-MIN operation. “Lazy” implementation provides an “unstable” heap. This heap can only be used in the implementation of Prim’s algorithm used in this experiment. For more general purpose, the “lazy” implementation may not be suitable. We have taken the advantage that between two EXTRACT-MIN operations, a key of any node will be decreased at most once. Hence, no keys are percolated until the EXTRACT-MIN is to be performed. Prior to performing EXTRACT-MIN, all nodes whose keys have been decreased are “percolated up” if necessary. We now use this information to determine the running time of the implementation of Prim’s algorithm with priority queue implemented using the “lazy” heap. Like in the proper implementation, the time to build the heap is \\( T_B = \\Theta(V) \\). The time to perform EXTRACT-MIN now requires the heap property to be restored, prior to performing the operation. We also restore the heap immediately after the EXTRACT-MIN is performed. We then say that EXTRACT-MIN is performed in \\( 2 \\log V \\) time, hence \\( T_E = O(\\log V) \\). The time to perform DECREASE-KEY operation is then done in \\( \\Theta(1) \\) time. The running time of this implementation is:\n\n\\[ T = \\Theta(V) + O(V \\log V) + O(V_1 \\cdot V_2) \\\\\n = O(E) \\]\n\nwhere \\( V_1 \\) is the number of operations required to perform EXTRACT-MIN operation, and \\( V_2 \\) is the number of operations required to rebuild the heap to restore its property after the DECREASE-KEY operation has been performed.\n\nAs with Fibonacci heap, \\( O(E) \\) will approach \\( O(V^2) \\) for the higher density graphs.\n3. EXPERIMENT\n\nThe main goal of the experiment is to test the performance of the Kruskal’s and Prim’s algorithms using various implementations of the data structures that can have a significant effect on the algorithm’s performance. Seven implementations were tested:\n\n- Kruskal’s Algorithm with heapsort, and with Path-Compression algorithms\n- Kruskal's Algorithm with counting sort and with Path-Compression algorithms\n- Prim’s Algorithm with brute force implementation of priority queues\n- Prim’s Algorithm with priority queue implemented using a proper implementation of binary heap with “bubble-up” performed each time a decrease-key operation is performed for a vertex\n- Prim’s Algorithm with priority queue implemented using a \"lazy\" implementation of binary heap with “bubble-up” performed after all decrease-key operations are performed for a vertex\n- Prim’s Algorithm with priority queue implemented using a binomial heap\n- Prim’s Algorithm with priority queue implemented using a Fibonacci heap\n\nThe experiment was conducted on a Sun Ultra 1 SBus (UltraSPARC 143 MHz) workstation. Each implementation was tested on nine different types of graphs. The graphs used for the experiment ranged from 100 to 1700 vertices and were generated at random. Hence nine graphs of each size were used. The graphs types varied in density, three were used for each, $p = 0.2$, $p = 0.5$, and $p = 0.8$, where $p$ is the probability of an edge being found between any two vertices. For each density $p$ three ranges of the edge weight $w$ were used, $1 - 10$, $1 - 100$, and $1020 - 1022$, with all weights $w$ having positive integer values.\n\n3.1 Graph Representation\n\nThe graphs used in the experiment are stored in compressed text files. Each file contains an adjacency matrix representation of the graph, preceded by an integer, which specifies the number of vertices in the input graph. Each row and each column position represent a vertex of the graph. The values in the adjacency matrix represent the weights of the edges joining the two vertices represented by the row and the column of each value; 0 indicates no edge. Since the graphs used in this experiment are bi-directional, the adjacency matrices used to represent these graphs have a reflexive and symmetric property with respect to the $(0,0)\\ldots(n,n)$ diagonal, where $n$ is the number of vertices of the graph. Figure 6 illustrates such representation. No edges originating from, and ending at the same vertex are to be present in the input graphs, therefore the diagonal is always contains zero values. The grayed area of the input matrix is a reflection of the white area.\nHence, only one half of the matrix is needed to represent the connected graph to be used in the experiment.\n\nThe adjacency matrix is represented by an array of arrays of integers. An array of integers is allocated to store the values of each row of the matrix with pointers to these arrays stored in a pointer array. Thus, the array indexes of the integer arrays represent the matrix columns, and the array indexes of the pointer array represent the matrix rows.\n\nUpon the startup of the program that implements the algorithm being tested, the first integer in the data file, which indicates the number of vertices in the graph, is immediately read. This value is used to determine the size of memory to be allocated to accommodate the adjacency matrix to be read. Once the memory is allocated the rest of the data file is read. The values are stored in the corresponding locations in the matrix representation described above. When the entire adjacency matrix is read, a function that implements the minimum spanning tree algorithm is invoked, with the adjacency matrix as one of its input arguments. Upon exit, one of the output arguments from the function is a similar adjacency matrix, which contains the representation of the minimum spanning tree. The output matrix is written to a specified output file, the memory is released, and the program is terminated.\n\nThe data files used in the experiment were generated using the genegraph program, written specifically for this purpose. The genegraph program accepts as command line arguments the number of vertices, graph density, minimum edge weight, maximum edge weight, and the name of file in which the graph is to be stored. The genegraph program was used to generate the random graphs that were used in the experiment. Each graph generated, was used with all, seven, algorithm implementations studied, in order to compare the performances of the algorithms in one set of data. Table 1 summarizes the types of data used in this experiment. The column that contains the values for the number of vertices indicates a range. A separate data file was generated for every 100 vertices in that range, with the total of 153 data files.\nTable 1 – Summary of data files used in the experiment.\n\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>Density</th>\n<th>Minimum Edge Weight</th>\n<th>Maximum Edge Weight</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100 – 1700</td>\n<td>0.2</td>\n<td>0</td>\n<td>10</td>\n</tr>\n<tr>\n<td>100 – 1700</td>\n<td>0.2</td>\n<td>0</td>\n<td>100</td>\n</tr>\n<tr>\n<td>100 – 1700</td>\n<td>0.2</td>\n<td>1020</td>\n<td>1022</td>\n</tr>\n<tr>\n<td>100 – 1700</td>\n<td>0.5</td>\n<td>0</td>\n<td>10</td>\n</tr>\n<tr>\n<td>100 – 1700</td>\n<td>0.5</td>\n<td>0</td>\n<td>100</td>\n</tr>\n<tr>\n<td>100 – 1700</td>\n<td>0.5</td>\n<td>1020</td>\n<td>1022</td>\n</tr>\n<tr>\n<td>100 – 1700</td>\n<td>0.8</td>\n<td>0</td>\n<td>10</td>\n</tr>\n<tr>\n<td>100 – 1700</td>\n<td>0.8</td>\n<td>0</td>\n<td>100</td>\n</tr>\n<tr>\n<td>100 – 1700</td>\n<td>0.8</td>\n<td>1020</td>\n<td>1022</td>\n</tr>\n</tbody>\n</table>\n\n3.2 Program\n\nThe program was written in C and ran on the UltraSPARC with a 143 MHz processor. Eight algorithms are implemented, although only seven are used in this experiment. The algorithms implemented. The one algorithm that is not used, is one of the worst implementations of Kruskal’s algorithm, which uses the insertion sort and a recursive heuristic to determine if adding an edge will result in a cycle. This implementation was used to demonstrate the severity of the effect of using an inefficient data structure in the areas of “weakness”. The references to the algorithm implementations used in the experiment are summarized in the Table 2. Hence, the khs reference indicates the Kruskal’s with heap sort.\n\n<table>\n<thead>\n<tr>\n<th>Reference</th>\n<th>Algorithm Implementation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>khs</td>\n<td>Kruskal with Heap Sort</td>\n</tr>\n<tr>\n<td>kcs</td>\n<td>Kruskal with Counting Sort</td>\n</tr>\n<tr>\n<td>pbf</td>\n<td>Prim Using Brute Force for Queue Implementation</td>\n</tr>\n<tr>\n<td>php_a</td>\n<td>Prim with Queue Implemented on Heap (proper)</td>\n</tr>\n<tr>\n<td>php</td>\n<td>Prim with Queue Implemented on Heap (lazy)</td>\n</tr>\n<tr>\n<td>pbinh</td>\n<td>Prim with Queue Implemented on Binomial Heap</td>\n</tr>\n<tr>\n<td>pfibh</td>\n<td>Prim with Queue Implemented on Fibonacci Heap</td>\n</tr>\n</tbody>\n</table>\n\nTable 2 – References to Algorithms Used in the Experiment\nEach algorithm is implemented as an individual function, which is invoked by the main program. The main program reads the data file, sets up the input and the output matrices, and runs the algorithms based on the parameters specified by the user. The user of the program specifies the algorithm to use for obtaining a minimum spanning tree and the number of iterations of the algorithm. The multiple iterations of the algorithm allow for more accurate timing results, and thus, for higher precision of measurements. Five iterations were used for each algorithm. The average of the times produced was used as the final running time of the algorithm.\n\n3.2.1 Time Measurements\n\nThe time measurements were taken using the `getrusage()` system call. This system call returns a structure `struct rusage`, from the members of which the time in seconds is assembled. The running time was measured prior to the beginning of the algorithm’s execution, and immediately upon termination. The timings were taken in the algorithm function. Only the execution of the code, which implements the algorithm, was timed. I/O, allocation of data structures, and matrix manipulations were ignored. Hence, the running time of the algorithm tested that was obtained using this method represents the actual algorithm execution time as accurately as possible. When the function, which implements the algorithm exits, the time is returned to the main program.\n\n3.2.2 Data Representation\n\nOne of the goals in implementing the algorithms studied in this experiment is to use the most efficient, yet “fair” representation of data. The use of pointers and dynamic memory allocation was avoided as much as possible, unless the actual data structure used by the algorithm dictated such. Much effort was placed into maintaining a high degree of consistency when implementing the data structures for all algorithms, in order to prevent the results from being obscured by various overheads that might be associated with maintaining the data structures. Much use was made of the arrays, however, the implementation of the binomial heap and Fibonacci heap does require the use of pointers and dynamic allocation. To defray the cost of the overhead that might be associated with dynamic allocation, all heap nodes are allocated at once, prior to start of the algorithm’s execution, and thus prior to initial timing. The pointers to the nodes allocated are stored on the stack, which is implemented as an array. The pointers to the nodes are dispensed upon request, thus reducing the memory allocation overhead to a minimum. The disjoint-sets and binary heaps are implemented as arrays of records, eliminating the use of pointers entirely.\n\nFor Kruskal’s algorithm, the set of edges is representing using an array of structures, each containing the vertex u, the vertex v, and the weight w of the edge. The following structure definition is used to represent such:\nstruct _tagEdges_\n{\n int u; /* Vertex u */\n int v; /* Vertex v */\n int weight; /* Weight w */\n}\n\nThe sets of the disjoint-set structure are implemented as arrays of integers, where each integer represents a vertex. The sorting is performed on the array of edges represented by the struct _tagEdges_.\n\nThe priority queue used in Prim's algorithm is implemented as a structure which contains an array to store the vertices, a member for a head of the queue, a member for a tail of the queue, and the size length counters. Following structure definition implements such:\n\nstruct _tagPriQueue_\n{\n int* vertices; /* Array of vertices */\n int head; /* Head of the queue */\n int tail; /* Tail of the queue */\n int size; /* Capacity of the queue */\n int length; /* Number of elements */\n}\n\nThe key and the parent of the vertex are each stored in the array of integers, where each cell stores a vertex. Each vertex stored on the priority queue can locate reference its parent \\(\\pi\\) or its key using the index reference. For example, the entry for the parent \\(\\pi\\) of vertex 6, is located in the \\(\\Pi[6]\\), where \\(\\Pi\\) is the variable that contains the array of \\(\\pi\\).\n\nThe implementation of the priority queue using \"brute force\", the EXTRACT-MIN operation is performed by iterating over the entire, thus finding the vertex with the minimum key value. Once such vertex is found, a NIL value is inserted in its place, and the vertex is returned. Hence, the vertex is extracted in \\(\\Theta(\\sqrt{V})\\) time.\n\nThe binary heap operations, used with Prim's algorithm, are performed on the array field \\texttt{vertices} of the struct _tagPriQueue_. The parent, left, and right references are implemented using macros, thus reducing the overhead associated with the function calls.\n\nThe vertex representation for the implementation of the priority queue using the binomial and Fibonacci heaps has been altered. Since both implementations require the representation of vertices in multiple ordered trees, much of the vertex information was moved from arrays into the nodes. Binomial heap is a collection of binomial trees, each\ncontaining at least one key value. The following structure defines a single node of the binomial tree:\n\n```c\nstruct _tagBinNode_\n{\n /***\n *** Binomial Tree attributes\n ***/\n struct _tagBinNode_* pParent; /* Pointer to parent */\n struct _tagBinNode_* pLeftChild;\n struct _tagBinNode_* pSibling;\n\n /***\n *** Graph vertex attributes\n ***/\n int nKey;\n int unVert;\n}\n```\n\nTo allow direct access to any of the nodes in the binomial heap, an array of pointers is used, where the index of each array cell represents the vertex. In addition an array of Boolean values is used to indicate if the vertex is in the queue. These attributes are stored in the structure that represents the entire binomial queue. The definition of the structure is as follows:\n\n```c\nstruct __tagCollection__\n{\n int nCapacity;\n int nTrees; /* Number of trees */\n int nCurrentSize; /* Vertex count */\n struct _tagBinNode_* aTrees; /* Array of trees */\n int* aInQueue; /* Array of flags */\n /* to indicate if */\n /* vertex is in the*/\n /* queue */\n struct _tagBinNode_* apVertexNodes;/* Node references */\n}\n```\n\nAll nodes are allocated ahead of time, and are stored in an array. The pointers to the nodes are dispensed upon request. This process replaces the dynamic allocation to reduce the overhead, as mentioned earlier. The following structure implements the store containing the nodes of the binomial heap:\n\n```c\nstruct __tagBinHeapMemMgt__\n{\n struct _tagBinNode_* aNodes; /* Array of Nodes */\n struct _tagBinNode_** apNodes; /* Array of pointers to*/\n```\nunsigned unUnused; /* Nodes available */\nunsigned unTop; /* Stack Pointer */\n\nSimilar representation is used for the priority queue implementation using the Fibonacci heap. The memory management and the collection are implemented in the same manner. The information about each vertex is stored in a node. The key for the vertex is stored in the node, as well. In addition, nodes contain the attributes of the Fibonacci heap. The following structure defines a single node of the Fibonacci heap:\n\n```c\nstruct __tagFibNode__\n{\n /*\n ** Tree attributes\n */\n struct __tagFibNode__* pParent; /* Parent of the node */\n struct __tagFibNode__* pChild; /* One child of node */\n struct __tagFibNode__* pLeft; /* Left sibling */\n struct __tagFibNode__* pRight; /* Right sibling */\n int nDegree; /* Degree of the node */\n int bMark; /* Marks the node if */\n /* node loses a child */\n\n /*\n ** Vertex attributes\n */\n int nKey; /* Key of the vertex */\n unsigned int unVert; /* Vertex */\n}\n```\n\nThe collection is implemented as follows:\n\n```c\nstruct __tagFibCollection__\n{\n struct __tagFibNode__* pRootList; /* List of roots */\n int nCurrentSize;\n struct __tagFibNode__* pMin; /* Pointer to node with the minimum key value */\n struct __tagFibNode__* aInQueue; /* Array of flags to indicate if vertex is in the queue */\n struct __tagFibNode__* apVertexNodes; /* Node references */\n int nMaxSize;\n}```\nstruct __tagFibNode__* A; /* Consolidation array*/\nint Dn; /* Number of trees */\n}\n\nThe memory management for the Fibonacci heap is implemented in the manner identical to that of the binomial heap. The following structure is used for the memory store:\n\nstruct __tagFibHeapMemMgt__\n{\n struct __tagFibNode__* aNodes; /* Array of Nodes */\n struct __tagFibNode__* apNodes; /* Array of pointers to nodes */\n unsigned unUnused; /* Nodes available */\n unsigned unTop; /* Stack Pointer */\n}\n\nThe memory required to implement the data structure for all implementations is allocated ahead of time and is not considered in the time measurements. Since the memory allocation may contribute significantly to the amount of time required to run the algorithm, the entire process is performed in one step, thus yielding the run time of \\( \\Theta(1) \\), which is eliminated from the test entirely.\n\n3.3 Running the Experiment\n\nThe experiment was run using the computing facilities of the Computer Science department of Rochester Institute of Technology. Nine UltraSPARC\\(s \\) were used simultaneously. The graphs were generated on the local disks in order not to use space on the file server. A shell script was used to launch the program multiple times in order to test each algorithm with all variations of the data. The resulting timings were captured and written to a file using Unix's standard I/O redirection. Upon completion, shell scripts were used to remove the graphs from the local disks.\n4. Results\n\nTo reiterate, the experiment was conducted using three sets of graphs; each set is of different graph density. The densities of graphs used are defined in terms of the probability \\( p \\) of an edge existing between any two vertices \\( u \\) and \\( v \\). The densities of the graphs are \\( p = 0.2 \\), \\( p = 0.5 \\), and \\( p = 0.8 \\). Each set of graphs consists of three subsets. Each subset contains 17 graphs, which range in the number of vertices from 100 to 1700. The subsets are categorized by the range of weights \\( w \\) that are assigned to an existing edge \\((u,v)\\) at random. The weight ranges used are 1 through 10, 1 through 100, and 1020 through 1022. Hence, total of 153 graphs was used in the experiment. The data set can be represented graphically as shown in Figure 7.\n\nAfter the results have been tabulated, it became apparent that the implementation of Prim's algorithm with priority queue implemented on a heap, using the \"lazy\" implementation of the heap (khs), has outperformed all other implementations in all tests with consistent results with respect to the range of weights \\( w \\). A slight degradation in performance was observed with the increase of graph density. Relatively consistent performance, with respect to range of the edge weights, was also observed for Prim's algorithm with priority queue implemented on a heap with the \"proper\" heap implementation (php_a), with slight degradation in performance observed with the increase of graph density. Prim's algorithm with priority queue implemented on a binomial heap (pbinh), displayed similar consistency to the other two implementations php and php_a, although its overall performance was relatively poor. Prim's algorithm with priority queue implemented using brute force (pbf), which was originally intended to be used as an example of a pathological case, provided the same consistency as the other\nimplementations of the Prim's algorithm, although it has outperformed the pbinh implementation in every case, as well as the implementation of Kruskal's algorithm, where the heapsort is used to sort the edges (khs). For the higher density graphs, pbf has even outperformed the implementation of Kruskal's algorithm that uses the counting sort (kcs). Hence, the observations reveal that the range of values for the range of weights has little or no impact on the performance of the implementations of Prim's algorithm used in this experiment. The slight degradation in performance that was observed with the increase in graph density, has shown a high degree of consistency for all implementations of Prim's algorithm.\n\nThe implementations of Kruskal's algorithm have shown far less consistency than the implementations of Prim's algorithm. Kruskal's algorithm with heapsort (khs) had the worst performance in every case. Some degree of degradation was observed with the increase in the range of weights $w$. Severe degradation was observed with the increase of density of the graphs. Kruskal's algorithm with counting sort (kcs) displayed a level of consistency similar to that of khs. Although higher than that of Prim's algorithm's implementation's, the degradation with respect to the graph density appears to be far less severe than that of the khs implementation.\n\nOverall, the best performance in all cases was observed in php. kcs produced the results close to those of php for sparse graphs. In the medium to high density graphs, pfibh produced the results that are close to the results produced by php. php_a in all cases ran slower than pfibh, however the difference in performance of the two appears to be consistent. pbf performed worse than php_a, but likewise, maintained the same consistency in the difference in run times. pbinh maintained the same consistency in performance, although its runtime is substantially slower that that of the rest of the implementations of Prim's algorithm. khs had the worst performance of all, in every case. For dense graphs with $w = 0.8$, kcs ran slightly faster than khs. For the sparse graphs with $w = 0.2$, kcs ran slightly slower than php.\n\nThese results are summarized in the Table 3 through Table 11 and accompanying charts in Figure 8 through Figure 16 on the following pages:\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pbinh</th>\n<th>pfibh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0147</td>\n<td>0.0031</td>\n<td>0.0066</td>\n<td>0.0058</td>\n<td>0.0038</td>\n<td>0.0141</td>\n<td>0.0066</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.0709</td>\n<td>0.0114</td>\n<td>0.0258</td>\n<td>0.0205</td>\n<td>0.0117</td>\n<td>0.0432</td>\n<td>0.0212</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.1831</td>\n<td>0.0254</td>\n<td>0.0595</td>\n<td>0.0454</td>\n<td>0.0241</td>\n<td>0.0892</td>\n<td>0.0388</td>\n</tr>\n<tr>\n<td>400</td>\n<td>0.3467</td>\n<td>0.0451</td>\n<td>0.1030</td>\n<td>0.0833</td>\n<td>0.0458</td>\n<td>0.1484</td>\n<td>0.0656</td>\n</tr>\n<tr>\n<td>500</td>\n<td>0.5619</td>\n<td>0.0706</td>\n<td>0.1612</td>\n<td>0.1194</td>\n<td>0.0611</td>\n<td>0.2214</td>\n<td>0.0963</td>\n</tr>\n<tr>\n<td>600</td>\n<td>0.8487</td>\n<td>0.1021</td>\n<td>0.2322</td>\n<td>0.1713</td>\n<td>0.0867</td>\n<td>0.3170</td>\n<td>0.1338</td>\n</tr>\n<tr>\n<td>700</td>\n<td>1.1899</td>\n<td>0.1395</td>\n<td>0.3190</td>\n<td>0.2333</td>\n<td>0.1164</td>\n<td>0.4199</td>\n<td>0.1772</td>\n</tr>\n<tr>\n<td>800</td>\n<td>1.5936</td>\n<td>0.1823</td>\n<td>0.4121</td>\n<td>0.3015</td>\n<td>0.1494</td>\n<td>0.5362</td>\n<td>0.2283</td>\n</tr>\n<tr>\n<td>900</td>\n<td>2.0922</td>\n<td>0.2320</td>\n<td>0.5220</td>\n<td>0.3809</td>\n<td>0.1878</td>\n<td>0.6708</td>\n<td>0.2853</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>2.6412</td>\n<td>0.2870</td>\n<td>0.6439</td>\n<td>0.4692</td>\n<td>0.2308</td>\n<td>0.8428</td>\n<td>0.3517</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>3.2705</td>\n<td>0.3466</td>\n<td>0.7803</td>\n<td>0.5680</td>\n<td>0.2782</td>\n<td>0.9863</td>\n<td>0.4190</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>4.0365</td>\n<td>0.4132</td>\n<td>0.9299</td>\n<td>0.6803</td>\n<td>0.3304</td>\n<td>1.1661</td>\n<td>0.4969</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>4.7130</td>\n<td>0.4851</td>\n<td>1.0939</td>\n<td>0.7945</td>\n<td>0.3879</td>\n<td>1.3594</td>\n<td>0.5801</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>5.5150</td>\n<td>0.5627</td>\n<td>1.2700</td>\n<td>0.9225</td>\n<td>0.4479</td>\n<td>1.5735</td>\n<td>0.6650</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>6.4591</td>\n<td>0.6467</td>\n<td>1.4749</td>\n<td>1.0734</td>\n<td>0.5143</td>\n<td>1.7837</td>\n<td>0.7591</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>7.4359</td>\n<td>0.7387</td>\n<td>1.6651</td>\n<td>1.2249</td>\n<td>0.5863</td>\n<td>2.0561</td>\n<td>0.8660</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>8.6536</td>\n<td>0.8346</td>\n<td>1.8706</td>\n<td>1.3646</td>\n<td>0.6575</td>\n<td>2.2849</td>\n<td>0.9370</td>\n</tr>\n</tbody>\n</table>\n\nTable 3 – Performances for sparse graphs with $1 \\leq w \\leq 10$, with times in CPU seconds\nFigure 8 – Performances for sparse graphs with $1 \\leq w \\leq 10$ (see Table 3)\nGraph Density: 0.2\nRange of Edge Weights: 1 – 100\n\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pbinh</th>\n<th>pfibh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0158</td>\n<td>0.0031</td>\n<td>0.0065</td>\n<td>0.0061</td>\n<td>0.0043</td>\n<td>0.0140</td>\n<td>0.0068</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.0771</td>\n<td>0.0115</td>\n<td>0.0251</td>\n<td>0.0218</td>\n<td>0.0137</td>\n<td>0.0437</td>\n<td>0.0203</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.2038</td>\n<td>0.0254</td>\n<td>0.0580</td>\n<td>0.0485</td>\n<td>0.0283</td>\n<td>0.0909</td>\n<td>0.0407</td>\n</tr>\n<tr>\n<td>400</td>\n<td>0.3733</td>\n<td>0.0452</td>\n<td>0.1006</td>\n<td>0.0816</td>\n<td>0.0466</td>\n<td>0.1516</td>\n<td>0.0671</td>\n</tr>\n<tr>\n<td>500</td>\n<td>0.6168</td>\n<td>0.0710</td>\n<td>0.1574</td>\n<td>0.1262</td>\n<td>0.0709</td>\n<td>0.2288</td>\n<td>0.1003</td>\n</tr>\n<tr>\n<td>600</td>\n<td>0.9265</td>\n<td>0.1021</td>\n<td>0.2255</td>\n<td>0.1784</td>\n<td>0.0977</td>\n<td>0.3265</td>\n<td>0.1404</td>\n</tr>\n<tr>\n<td>700</td>\n<td>1.3015</td>\n<td>0.1415</td>\n<td>0.3099</td>\n<td>0.2430</td>\n<td>0.1308</td>\n<td>0.4323</td>\n<td>0.1860</td>\n</tr>\n<tr>\n<td>800</td>\n<td>1.7522</td>\n<td>0.1897</td>\n<td>0.4002</td>\n<td>0.3111</td>\n<td>0.1651</td>\n<td>0.5526</td>\n<td>0.2385</td>\n</tr>\n<tr>\n<td>900</td>\n<td>2.2851</td>\n<td>0.2443</td>\n<td>0.5059</td>\n<td>0.3928</td>\n<td>0.2064</td>\n<td>0.7412</td>\n<td>0.2971</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>2.9086</td>\n<td>0.3010</td>\n<td>0.6263</td>\n<td>0.4823</td>\n<td>0.2509</td>\n<td>0.8465</td>\n<td>0.3699</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>3.5995</td>\n<td>0.3647</td>\n<td>0.7598</td>\n<td>0.5837</td>\n<td>0.2996</td>\n<td>1.0157</td>\n<td>0.4345</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>4.5098</td>\n<td>0.4345</td>\n<td>0.9069</td>\n<td>0.6943</td>\n<td>0.3529</td>\n<td>1.1996</td>\n<td>0.5151</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>5.2311</td>\n<td>0.5110</td>\n<td>1.0658</td>\n<td>0.8095</td>\n<td>0.4124</td>\n<td>1.4260</td>\n<td>0.5999</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>6.1445</td>\n<td>0.5923</td>\n<td>1.2423</td>\n<td>0.9344</td>\n<td>0.4739</td>\n<td>1.6142</td>\n<td>0.6886</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>7.1988</td>\n<td>0.6805</td>\n<td>1.4202</td>\n<td>1.0760</td>\n<td>0.5400</td>\n<td>1.8346</td>\n<td>0.7829</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>8.2506</td>\n<td>0.7768</td>\n<td>1.6287</td>\n<td>1.2313</td>\n<td>0.6140</td>\n<td>2.0870</td>\n<td>0.8917</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>9.6819</td>\n<td>0.8765</td>\n<td>1.8304</td>\n<td>1.3793</td>\n<td>0.6866</td>\n<td>2.3454</td>\n<td>1.0021</td>\n</tr>\n</tbody>\n</table>\n\nTable 4 – Performances for sparse graphs with 1 ≤ \\( w \\) ≤ 100, with times in CPU seconds\nFigure 9– Performances for sparse graphs with $1 \\leq w \\leq 100$ (see Table 4)\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pbindh</th>\n<th>pfibh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0115</td>\n<td>0.0035</td>\n<td>0.0068</td>\n<td>0.0053</td>\n<td>0.0032</td>\n<td>0.0137</td>\n<td>0.0063</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.0543</td>\n<td>0.0119</td>\n<td>0.0262</td>\n<td>0.0195</td>\n<td>0.1020</td>\n<td>0.0423</td>\n<td>0.0183</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.1386</td>\n<td>0.0257</td>\n<td>0.0603</td>\n<td>0.0442</td>\n<td>0.0224</td>\n<td>0.0875</td>\n<td>0.0366</td>\n</tr>\n<tr>\n<td>400</td>\n<td>0.2578</td>\n<td>0.0455</td>\n<td>0.1044</td>\n<td>0.0767</td>\n<td>0.0382</td>\n<td>0.1450</td>\n<td>0.0620</td>\n</tr>\n<tr>\n<td>500</td>\n<td>0.4263</td>\n<td>0.0711</td>\n<td>0.1625</td>\n<td>0.1190</td>\n<td>0.0586</td>\n<td>0.2194</td>\n<td>0.0934</td>\n</tr>\n<tr>\n<td>600</td>\n<td>0.6282</td>\n<td>0.1023</td>\n<td>0.2334</td>\n<td>0.1694</td>\n<td>0.0837</td>\n<td>0.3164</td>\n<td>0.1310</td>\n</tr>\n<tr>\n<td>700</td>\n<td>0.8994</td>\n<td>0.1397</td>\n<td>0.3211</td>\n<td>0.2312</td>\n<td>0.1134</td>\n<td>0.4359</td>\n<td>0.1737</td>\n</tr>\n<tr>\n<td>800</td>\n<td>1.1921</td>\n<td>0.1824</td>\n<td>0.4147</td>\n<td>0.2989</td>\n<td>0.1461</td>\n<td>0.5331</td>\n<td>0.2244</td>\n</tr>\n<tr>\n<td>900</td>\n<td>1.5563</td>\n<td>0.2320</td>\n<td>0.5249</td>\n<td>0.3803</td>\n<td>0.1843</td>\n<td>0.6742</td>\n<td>0.2795</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>1.9937</td>\n<td>0.2866</td>\n<td>0.6472</td>\n<td>0.4687</td>\n<td>0.2269</td>\n<td>0.8197</td>\n<td>0.3445</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>2.4258</td>\n<td>0.3468</td>\n<td>0.7832</td>\n<td>0.5652</td>\n<td>0.2736</td>\n<td>0.9816</td>\n<td>0.4136</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>2.9752</td>\n<td>0.4133</td>\n<td>0.9339</td>\n<td>0.6768</td>\n<td>0.3259</td>\n<td>1.1618</td>\n<td>0.4890</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>3.4941</td>\n<td>0.4851</td>\n<td>1.0971</td>\n<td>0.7920</td>\n<td>0.3823</td>\n<td>1.4264</td>\n<td>0.5729</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>4.1360</td>\n<td>0.5622</td>\n<td>1.2743</td>\n<td>0.9168</td>\n<td>0.4430</td>\n<td>1.5676</td>\n<td>0.6563</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>4.7967</td>\n<td>0.6461</td>\n<td>1.4588</td>\n<td>1.0966</td>\n<td>0.5126</td>\n<td>1.7764</td>\n<td>0.7538</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>5.4759</td>\n<td>0.7384</td>\n<td>1.6698</td>\n<td>1.2138</td>\n<td>0.5809</td>\n<td>2.0251</td>\n<td>0.8568</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>6.3664</td>\n<td>0.8335</td>\n<td>1.8733</td>\n<td>1.3595</td>\n<td>0.6520</td>\n<td>2.3088</td>\n<td>0.9662</td>\n</tr>\n</tbody>\n</table>\n\nTable 5 – Performances for sparse graphs with $1020 \\leq w \\leq 1022$, with times in CPU seconds\nFigure 10 – Performances for sparse graphs with $1020 \\leq w \\leq 1022$ (see Table 5)\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pblbh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0401</td>\n<td>0.0070</td>\n<td>0.0069</td>\n<td>0.0058</td>\n<td>0.0038</td>\n<td>0.00139</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.1903</td>\n<td>0.0272</td>\n<td>0.0270</td>\n<td>0.0257</td>\n<td>0.0249</td>\n<td>0.01919</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.5006</td>\n<td>0.1097</td>\n<td>0.1072</td>\n<td>0.1088</td>\n<td>0.1043</td>\n<td>0.09003</td>\n</tr>\n<tr>\n<td>400</td>\n<td>0.8109</td>\n<td>0.1715</td>\n<td>0.1676</td>\n<td>0.1768</td>\n<td>0.1843</td>\n<td>0.14933</td>\n</tr>\n<tr>\n<td>500</td>\n<td>1.5010</td>\n<td>0.2480</td>\n<td>0.2410</td>\n<td>0.2310</td>\n<td>0.2428</td>\n<td>0.21627</td>\n</tr>\n<tr>\n<td>600</td>\n<td>2.6352</td>\n<td>0.3379</td>\n<td>0.3330</td>\n<td>0.3210</td>\n<td>0.3263</td>\n<td>0.28630</td>\n</tr>\n<tr>\n<td>700</td>\n<td>3.6263</td>\n<td>0.4143</td>\n<td>0.4120</td>\n<td>0.4056</td>\n<td>0.4056</td>\n<td>0.35841</td>\n</tr>\n<tr>\n<td>800</td>\n<td>5.0571</td>\n<td>0.5598</td>\n<td>0.5425</td>\n<td>0.5369</td>\n<td>0.5396</td>\n<td>0.48685</td>\n</tr>\n<tr>\n<td>900</td>\n<td>6.9574</td>\n<td>0.8619</td>\n<td>0.8565</td>\n<td>0.8686</td>\n<td>0.8696</td>\n<td>0.80501</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>10.0000</td>\n<td>1.4260</td>\n<td>1.4120</td>\n<td>1.4210</td>\n<td>1.4263</td>\n<td>1.38853</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>14.5237</td>\n<td>1.3661</td>\n<td>1.3530</td>\n<td>1.3659</td>\n<td>1.3569</td>\n<td>1.3530</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>18.5526</td>\n<td>1.1961</td>\n<td>1.1859</td>\n<td>1.2126</td>\n<td>1.2162</td>\n<td>1.2126</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>24.8104</td>\n<td>1.0756</td>\n<td>1.0676</td>\n<td>1.0805</td>\n<td>1.1056</td>\n<td>1.0605</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>29.8104</td>\n<td>1.0194</td>\n<td>1.0120</td>\n<td>1.0256</td>\n<td>1.0431</td>\n<td>1.0256</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>34.9526</td>\n<td>0.9396</td>\n<td>0.9330</td>\n<td>0.9426</td>\n<td>0.9426</td>\n<td>0.9396</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>40.5526</td>\n<td>0.8194</td>\n<td>0.8120</td>\n<td>0.8256</td>\n<td>0.8256</td>\n<td>0.8194</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>46.1526</td>\n<td>0.7288</td>\n<td>0.7230</td>\n<td>0.7356</td>\n<td>0.7356</td>\n<td>0.7288</td>\n</tr>\n</tbody>\n</table>\n\nTable 6 - Performances for medium density graphs with $1 \\leq w \\leq 10$, with times in CPU seconds.\nFigure 11 – Performances for medium density graphs with $1 \\leq w \\leq 10$ (see Table 6)\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pbinh</th>\n<th>pfibh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0436</td>\n<td>0.0070</td>\n<td>0.0068</td>\n<td>0.0063</td>\n<td>0.0047</td>\n<td>0.0165</td>\n<td>0.0086</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.2147</td>\n<td>0.0273</td>\n<td>0.0261</td>\n<td>0.0225</td>\n<td>0.0147</td>\n<td>0.0449</td>\n<td>0.0217</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.5585</td>\n<td>0.0616</td>\n<td>0.0603</td>\n<td>0.0499</td>\n<td>0.0301</td>\n<td>0.0930</td>\n<td>0.0436</td>\n</tr>\n<tr>\n<td>400</td>\n<td>0.9993</td>\n<td>0.1091</td>\n<td>0.1041</td>\n<td>0.0837</td>\n<td>0.0491</td>\n<td>0.1556</td>\n<td>0.0731</td>\n</tr>\n<tr>\n<td>500</td>\n<td>1.6661</td>\n<td>0.1780</td>\n<td>0.1631</td>\n<td>0.1306</td>\n<td>0.0747</td>\n<td>0.2398</td>\n<td>0.1202</td>\n</tr>\n<tr>\n<td>600</td>\n<td>2.4838</td>\n<td>0.2621</td>\n<td>0.2349</td>\n<td>0.1840</td>\n<td>0.1022</td>\n<td>0.3339</td>\n<td>0.1514</td>\n</tr>\n<tr>\n<td>700</td>\n<td>3.4783</td>\n<td>0.3577</td>\n<td>0.3239</td>\n<td>0.2504</td>\n<td>0.1373</td>\n<td>0.4437</td>\n<td>0.2012</td>\n</tr>\n<tr>\n<td>800</td>\n<td>4.6982</td>\n<td>0.4661</td>\n<td>0.4190</td>\n<td>0.3220</td>\n<td>0.1747</td>\n<td>0.5683</td>\n<td>0.2580</td>\n</tr>\n<tr>\n<td>900</td>\n<td>6.1086</td>\n<td>0.5903</td>\n<td>0.5308</td>\n<td>0.4065</td>\n<td>0.2174</td>\n<td>0.7081</td>\n<td>0.3310</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>7.7067</td>\n<td>0.7303</td>\n<td>0.6568</td>\n<td>0.4995</td>\n<td>0.2656</td>\n<td>0.8679</td>\n<td>0.3971</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>9.5028</td>\n<td>0.8841</td>\n<td>0.7977</td>\n<td>0.6034</td>\n<td>0.3189</td>\n<td>1.0441</td>\n<td>0.4741</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>11.9055</td>\n<td>1.0768</td>\n<td>0.9501</td>\n<td>0.7232</td>\n<td>0.3776</td>\n<td>1.2346</td>\n<td>0.5627</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>13.6841</td>\n<td>1.2354</td>\n<td>1.1190</td>\n<td>0.8427</td>\n<td>0.4413</td>\n<td>1.4683</td>\n<td>0.6559</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>16.0854</td>\n<td>1.4419</td>\n<td>1.2987</td>\n<td>0.9749</td>\n<td>0.5098</td>\n<td>1.6574</td>\n<td>0.7534</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>18.8288</td>\n<td>1.6544</td>\n<td>1.4870</td>\n<td>1.1228</td>\n<td>0.5841</td>\n<td>1.8760</td>\n<td>0.8591</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>21.5607</td>\n<td>1.8884</td>\n<td>1.7049</td>\n<td>1.2850</td>\n<td>0.6647</td>\n<td>2.1367</td>\n<td>0.9801</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>25.2302</td>\n<td>2.1301</td>\n<td>1.9153</td>\n<td>1.4441</td>\n<td>0.7508</td>\n<td>2.4498</td>\n<td>1.1613</td>\n</tr>\n</tbody>\n</table>\n\nTable 7 – Performances for medium density graphs with $1 \\leq w \\leq 100$, with times in CPU seconds\nMedium density graphs (p = 0.5) with edge weights 1 - 100\n\nFigure 12 – Performances for medium density graphs with 1 ≤ w ≤ 100 (see Table 7)\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pbinh</th>\n<th>pfbh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0313</td>\n<td>0.0073</td>\n<td>0.0070</td>\n<td>0.0053</td>\n<td>0.0032</td>\n<td>0.0135</td>\n<td>0.0063</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.1490</td>\n<td>0.0278</td>\n<td>0.0272</td>\n<td>0.0201</td>\n<td>0.0109</td>\n<td>0.0426</td>\n<td>0.0191</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.3857</td>\n<td>0.0618</td>\n<td>0.0717</td>\n<td>0.0461</td>\n<td>0.0240</td>\n<td>0.0915</td>\n<td>0.0390</td>\n</tr>\n<tr>\n<td>400</td>\n<td>0.6841</td>\n<td>0.1009</td>\n<td>0.1078</td>\n<td>0.0796</td>\n<td>0.0411</td>\n<td>0.1482</td>\n<td>0.0657</td>\n</tr>\n<tr>\n<td>500</td>\n<td>1.1420</td>\n<td>0.1721</td>\n<td>0.1680</td>\n<td>0.1234</td>\n<td>0.0637</td>\n<td>0.2259</td>\n<td>0.1000</td>\n</tr>\n<tr>\n<td>600</td>\n<td>1.6992</td>\n<td>0.2492</td>\n<td>0.2415</td>\n<td>0.1764</td>\n<td>0.0908</td>\n<td>0.3223</td>\n<td>0.1404</td>\n</tr>\n<tr>\n<td>700</td>\n<td>2.3797</td>\n<td>0.3390</td>\n<td>0.3321</td>\n<td>0.2414</td>\n<td>0.1237</td>\n<td>0.4299</td>\n<td>0.1883</td>\n</tr>\n<tr>\n<td>800</td>\n<td>3.1604</td>\n<td>0.4430</td>\n<td>0.4325</td>\n<td>0.3132</td>\n<td>0.1603</td>\n<td>0.5653</td>\n<td>0.2436</td>\n</tr>\n<tr>\n<td>900</td>\n<td>4.1703</td>\n<td>0.5614</td>\n<td>0.5636</td>\n<td>0.3978</td>\n<td>0.2025</td>\n<td>0.6927</td>\n<td>0.3058</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>5.2069</td>\n<td>0.6934</td>\n<td>0.6694</td>\n<td>0.4899</td>\n<td>0.2492</td>\n<td>0.8463</td>\n<td>0.3747</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>6.3499</td>\n<td>0.8401</td>\n<td>0.8099</td>\n<td>0.5934</td>\n<td>0.3013</td>\n<td>1.0249</td>\n<td>0.4611</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>7.9240</td>\n<td>0.9995</td>\n<td>0.9663</td>\n<td>0.7106</td>\n<td>0.3596</td>\n<td>1.2236</td>\n<td>0.5635</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>9.3117</td>\n<td>1.1728</td>\n<td>1.1354</td>\n<td>0.8324</td>\n<td>0.4219</td>\n<td>1.4489</td>\n<td>0.6269</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>10.7743</td>\n<td>1.3621</td>\n<td>1.3199</td>\n<td>0.9657</td>\n<td>0.4904</td>\n<td>1.6257</td>\n<td>0.7244</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>12.4001</td>\n<td>1.5644</td>\n<td>1.5121</td>\n<td>1.1116</td>\n<td>0.5621</td>\n<td>1.8579</td>\n<td>0.8392</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>14.3191</td>\n<td>1.7913</td>\n<td>1.7267</td>\n<td>1.2743</td>\n<td>0.6427</td>\n<td>2.1243</td>\n<td>0.9525</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>16.7918</td>\n<td>2.0175</td>\n<td>1.9417</td>\n<td>1.4319</td>\n<td>0.7251</td>\n<td>2.3949</td>\n<td>1.0694</td>\n</tr>\n</tbody>\n</table>\n\nTable 8 – Performances for medium density graphs with $1020 \\leq w \\leq 1022$, with times in CPU seconds\nMedium density graphs (p = 0.5) with edge weights 1020 - 1022\n\nFigure 13 – Performances for medium density graphs with 1020 ≤ w ≤ 1022 (see Table 8)\n### Graph Density: 0.8\n*Range of Edge Weights: 1 – 10*\n\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pbinh</th>\n<th>pfibh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0682</td>\n<td>0.0108</td>\n<td>0.0070</td>\n<td>0.0059</td>\n<td>0.0038</td>\n<td>0.0140</td>\n<td>0.0069</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.3294</td>\n<td>0.0429</td>\n<td>0.0277</td>\n<td>0.0210</td>\n<td>0.0121</td>\n<td>0.0438</td>\n<td>0.0207</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.8385</td>\n<td>0.0968</td>\n<td>0.0639</td>\n<td>0.0477</td>\n<td>0.0265</td>\n<td>0.0917</td>\n<td>0.0421</td>\n</tr>\n<tr>\n<td>400</td>\n<td>1.5404</td>\n<td>0.1746</td>\n<td>0.1101</td>\n<td>0.0828</td>\n<td>0.0450</td>\n<td>0.1525</td>\n<td>0.0720</td>\n</tr>\n<tr>\n<td>500</td>\n<td>2.5484</td>\n<td>0.2741</td>\n<td>0.1716</td>\n<td>0.1275</td>\n<td>0.0694</td>\n<td>0.2340</td>\n<td>0.1084</td>\n</tr>\n<tr>\n<td>600</td>\n<td>3.7630</td>\n<td>0.3946</td>\n<td>0.2469</td>\n<td>0.1825</td>\n<td>0.0986</td>\n<td>0.3328</td>\n<td>0.1547</td>\n</tr>\n<tr>\n<td>700</td>\n<td>5.2957</td>\n<td>0.5371</td>\n<td>0.3396</td>\n<td>0.2496</td>\n<td>0.1338</td>\n<td>0.4434</td>\n<td>0.2049</td>\n</tr>\n<tr>\n<td>800</td>\n<td>7.0743</td>\n<td>0.7012</td>\n<td>0.4389</td>\n<td>0.3241</td>\n<td>0.1733</td>\n<td>0.5696</td>\n<td>0.2654</td>\n</tr>\n<tr>\n<td>900</td>\n<td>9.2075</td>\n<td>0.8895</td>\n<td>0.5555</td>\n<td>0.4104</td>\n<td>0.2186</td>\n<td>0.7184</td>\n<td>0.3337</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>11.5917</td>\n<td>1.0985</td>\n<td>0.6846</td>\n<td>0.5054</td>\n<td>0.2693</td>\n<td>0.8783</td>\n<td>0.4108</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>14.2646</td>\n<td>1.3391</td>\n<td>0.8291</td>\n<td>0.6645</td>\n<td>0.3282</td>\n<td>1.0556</td>\n<td>0.4957</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>17.6639</td>\n<td>1.5826</td>\n<td>0.9891</td>\n<td>0.7329</td>\n<td>0.3882</td>\n<td>1.2538</td>\n<td>0.5808</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>20.6639</td>\n<td>1.8575</td>\n<td>1.1623</td>\n<td>0.8591</td>\n<td>0.4546</td>\n<td>1.4923</td>\n<td>0.6869</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>23.9797</td>\n<td>2.1588</td>\n<td>1.3493</td>\n<td>0.9953</td>\n<td>0.5275</td>\n<td>1.6834</td>\n<td>0.7978</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>27.8348</td>\n<td>2.4826</td>\n<td>1.5447</td>\n<td>1.1479</td>\n<td>0.6058</td>\n<td>1.9195</td>\n<td>0.9337</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>32.0384</td>\n<td>2.8346</td>\n<td>1.7676</td>\n<td>1.3158</td>\n<td>0.6924</td>\n<td>2.2692</td>\n<td>1.0410</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>37.4164</td>\n<td>3.1890</td>\n<td>1.9893</td>\n<td>1.4811</td>\n<td>0.7829</td>\n<td>2.4799</td>\n<td>1.1652</td>\n</tr>\n</tbody>\n</table>\n\nTable 9 – Performances for dense graphs with $1 \\leq \\nu \\leq 10$, with times in CPU seconds\nFigure 14 – Performances for dense graphs with $1 \\leq w \\leq 10$ (see Table 9)\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pbinh</th>\n<th>pfibh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0738</td>\n<td>0.0108</td>\n<td>0.0069</td>\n<td>0.0064</td>\n<td>0.0048</td>\n<td>0.0146</td>\n<td>0.0076</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.2359</td>\n<td>0.0430</td>\n<td>0.0266</td>\n<td>0.0229</td>\n<td>0.0151</td>\n<td>0.0465</td>\n<td>0.0226</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.2928</td>\n<td>0.0970</td>\n<td>0.0621</td>\n<td>0.0507</td>\n<td>0.0311</td>\n<td>0.0947</td>\n<td>0.0451</td>\n</tr>\n<tr>\n<td>400</td>\n<td>1.6901</td>\n<td>0.1811</td>\n<td>0.1075</td>\n<td>0.0859</td>\n<td>0.5080</td>\n<td>0.1659</td>\n<td>0.0770</td>\n</tr>\n<tr>\n<td>500</td>\n<td>2.7794</td>\n<td>0.2688</td>\n<td>0.1684</td>\n<td>0.1320</td>\n<td>0.0759</td>\n<td>0.2394</td>\n<td>0.1143</td>\n</tr>\n<tr>\n<td>600</td>\n<td>4.2202</td>\n<td>0.4176</td>\n<td>0.2425</td>\n<td>0.1871</td>\n<td>0.1055</td>\n<td>0.3455</td>\n<td>0.1603</td>\n</tr>\n<tr>\n<td>700</td>\n<td>5.8406</td>\n<td>0.5668</td>\n<td>0.3339</td>\n<td>0.2560</td>\n<td>0.1428</td>\n<td>0.4540</td>\n<td>0.2162</td>\n</tr>\n<tr>\n<td>800</td>\n<td>7.8653</td>\n<td>0.7396</td>\n<td>0.4324</td>\n<td>0.3297</td>\n<td>0.1816</td>\n<td>0.5950</td>\n<td>0.2758</td>\n</tr>\n<tr>\n<td>900</td>\n<td>10.2333</td>\n<td>0.9385</td>\n<td>0.5476</td>\n<td>0.4168</td>\n<td>0.2278</td>\n<td>0.7305</td>\n<td>0.3441</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>12.8628</td>\n<td>1.1590</td>\n<td>0.6759</td>\n<td>0.5134</td>\n<td>0.2783</td>\n<td>0.8665</td>\n<td>0.4253</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>15.7993</td>\n<td>1.4029</td>\n<td>0.8196</td>\n<td>0.6191</td>\n<td>0.3356</td>\n<td>1.0770</td>\n<td>0.5096</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>19.7110</td>\n<td>1.6724</td>\n<td>0.9767</td>\n<td>0.7412</td>\n<td>0.3994</td>\n<td>1.2881</td>\n<td>0.6162</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>22.9228</td>\n<td>1.9649</td>\n<td>1.1531</td>\n<td>0.8676</td>\n<td>0.4682</td>\n<td>1.5077</td>\n<td>0.7033</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>26.6568</td>\n<td>2.2788</td>\n<td>1.3379</td>\n<td>1.0060</td>\n<td>0.5401</td>\n<td>1.7072</td>\n<td>0.8096</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>30.8877</td>\n<td>2.6208</td>\n<td>1.5322</td>\n<td>1.1597</td>\n<td>0.6193</td>\n<td>1.9407</td>\n<td>0.9321</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>35.8009</td>\n<td>2.9895</td>\n<td>1.8616</td>\n<td>1.3248</td>\n<td>0.7103</td>\n<td>2.2323</td>\n<td>1.0511</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>41.5835</td>\n<td>3.3666</td>\n<td>1.9668</td>\n<td>1.4885</td>\n<td>0.7938</td>\n<td>2.5511</td>\n<td>1.2263</td>\n</tr>\n</tbody>\n</table>\n\nTable 10 – Performances for dense graphs with $1 \\leq w \\leq 100$, with times in CPU seconds\nDense graphs (p = 0.8) with edge weights 1 - 100\n\nFigure 15 – Performances for dense graphs with 1 ≤ w ≤ 100 (see Table 10), with times in CPU seconds\nGraph Density: 0.8\nRange of Edge Weights: 1020 – 1022\n\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs</th>\n<th>kcs</th>\n<th>pbf</th>\n<th>php_a</th>\n<th>php</th>\n<th>pbinh</th>\n<th>pfibh</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0525</td>\n<td>0.0562</td>\n<td>0.0071</td>\n<td>0.0054</td>\n<td>0.0032</td>\n<td>0.0138</td>\n<td>0.0065</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.2452</td>\n<td>0.2170</td>\n<td>0.0277</td>\n<td>0.0209</td>\n<td>0.0113</td>\n<td>0.0436</td>\n<td>0.0198</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.6237</td>\n<td>0.4881</td>\n<td>0.0639</td>\n<td>0.0473</td>\n<td>0.0252</td>\n<td>0.0914</td>\n<td>0.0403</td>\n</tr>\n<tr>\n<td>400</td>\n<td>1.1482</td>\n<td>0.8768</td>\n<td>0.1101</td>\n<td>0.0815</td>\n<td>0.0436</td>\n<td>0.1518</td>\n<td>0.0694</td>\n</tr>\n<tr>\n<td>500</td>\n<td>1.9403</td>\n<td>1.3727</td>\n<td>0.1718</td>\n<td>0.1269</td>\n<td>0.0674</td>\n<td>0.2324</td>\n<td>0.1053</td>\n</tr>\n<tr>\n<td>600</td>\n<td>2.7999</td>\n<td>1.9819</td>\n<td>0.2475</td>\n<td>0.1824</td>\n<td>0.0963</td>\n<td>0.3381</td>\n<td>0.1475</td>\n</tr>\n<tr>\n<td>700</td>\n<td>3.9653</td>\n<td>2.7812</td>\n<td>0.3394</td>\n<td>0.2494</td>\n<td>0.1316</td>\n<td>0.4442</td>\n<td>0.2016</td>\n</tr>\n<tr>\n<td>800</td>\n<td>5.2624</td>\n<td>3.5189</td>\n<td>0.4387</td>\n<td>0.3239</td>\n<td>0.1702</td>\n<td>0.5688</td>\n<td>0.2595</td>\n</tr>\n<tr>\n<td>900</td>\n<td>6.8018</td>\n<td>4.4565</td>\n<td>0.5551</td>\n<td>0.4101</td>\n<td>0.2154</td>\n<td>0.7154</td>\n<td>0.3272</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>8.6712</td>\n<td>5.5038</td>\n<td>0.6849</td>\n<td>0.5059</td>\n<td>0.2651</td>\n<td>0.8739</td>\n<td>0.4026</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>10.5708</td>\n<td>6.6648</td>\n<td>0.8303</td>\n<td>0.6134</td>\n<td>0.3209</td>\n<td>1.0603</td>\n<td>0.4818</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>12.9411</td>\n<td>7.9342</td>\n<td>0.9886</td>\n<td>0.7350</td>\n<td>0.3829</td>\n<td>1.2528</td>\n<td>0.5730</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>15.0497</td>\n<td>9.3148</td>\n<td>1.1636</td>\n<td>0.8613</td>\n<td>0.4504</td>\n<td>1.4629</td>\n<td>0.6703</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>17.9377</td>\n<td>10.8058</td>\n<td>1.3494</td>\n<td>0.9968</td>\n<td>0.5216</td>\n<td>1.7059</td>\n<td>0.7770</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>20.7476</td>\n<td>12.4265</td>\n<td>1.5450</td>\n<td>1.1484</td>\n<td>0.6003</td>\n<td>1.9234</td>\n<td>0.8810</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>23.6403</td>\n<td>14.2014</td>\n<td>1.7680</td>\n<td>1.3169</td>\n<td>0.6853</td>\n<td>2.1915</td>\n<td>1.0054</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>27.3645</td>\n<td>15.9829</td>\n<td>2.0573</td>\n<td>1.4789</td>\n<td>0.7751</td>\n<td>2.4779</td>\n<td>1.1341</td>\n</tr>\n</tbody>\n</table>\n\nTable 11 – Performances for dense graphs with 1020 ≤ w ≤ 1022, with times in CPU seconds\nDense graphs \\((p = 0.8)\\) with edge weights 1020 - 1022\n\n![Graph showing running time vs number of vertices for different algorithms.]\n\nFigure 16 – Performances for dense graphs with \\(1020 \\leq w \\leq 1022\\) (see Table 11)\n5. **Analysis of Results**\n\nThree sets of graphs were used in the experiment. The densities of graphs used are defined in terms of the probability $p$ of an edge existing between any two vertices $u$ and $v$, hence $p = \\varepsilon$. Three densities used in this experiment, one for each set of graphs, are $p = 0.2$, $p = 0.5$, and $p = 0.8$. Each set of graphs consists of three subsets. Each subset contains 17 graphs, which range in the number of vertices from 100 to 1700, within one of the tree ranges of edge weights, 0 – 10, 0 – 100, and 1020 – 1022. The weights are randomly assigned to any existing edge $(u,v)$. The total of 153 graphs with uniform distribution in these intervals was used in the experiment. The data set can be represented graphically as shown in Figure 7.\n\n### 5.1 Kruskal’s Algorithm\n\nAs we showed earlier, sorting edges by weight can be the most contributing factor to the run time of implementation of Kruskal’s algorithm used in this experiment. To confirm that, a performance measurement of Kruskal’s algorithm was made on seven graphs with 100 – 700 vertices and density $p = 0.2$, for which the algorithm performed well. The results are displayed Table 12.\n\nFigure 17 displays the comparison of the Kruskal’s algorithm with sorting not timed versus the khs ad kcs implementations with sorting timed.\n\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>khs (Heapsort)</th>\n<th>kcs (Counting Sort)</th>\n<th>sort not timed</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>0.0525</td>\n<td>0.0562</td>\n<td>0.0026</td>\n</tr>\n<tr>\n<td>200</td>\n<td>0.2452</td>\n<td>0.2170</td>\n<td>0.0094</td>\n</tr>\n<tr>\n<td>300</td>\n<td>0.6237</td>\n<td>0.4881</td>\n<td>0.0210</td>\n</tr>\n<tr>\n<td>400</td>\n<td>1.1482</td>\n<td>0.8768</td>\n<td>0.0350</td>\n</tr>\n<tr>\n<td>500</td>\n<td>1.9403</td>\n<td>1.3727</td>\n<td>0.0570</td>\n</tr>\n<tr>\n<td>600</td>\n<td>2.7999</td>\n<td>1.9819</td>\n<td>0.0818</td>\n</tr>\n<tr>\n<td>700</td>\n<td>3.9653</td>\n<td>2.7812</td>\n<td>0.1124</td>\n</tr>\n</tbody>\n</table>\n\n**Table 12** – Performance of Kruskal’s Algorithm excluding the sorting time\nWe can see the differences in growth rates of each implementation by finding the ratios of performance for several graphs with a number of vertices $V$. Table 13 contains the ratios of time spent by Kruskal’s algorithm performing the disjoint-set operations and the time spent sorting. We arrive at the results by dividing time spent sorting by the time spent performing disjoint set operations $R = \\frac{T - T_S}{T_S}$.\n\n<table>\n<thead>\n<tr>\n<th>Number of Vertices</th>\n<th>$R_{HS}$</th>\n<th>$R_{CS}$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>100</td>\n<td>19.1923</td>\n<td>20.6154</td>\n</tr>\n<tr>\n<td>200</td>\n<td>25.0851</td>\n<td>22.0851</td>\n</tr>\n<tr>\n<td>300</td>\n<td>28.7000</td>\n<td>22.2429</td>\n</tr>\n<tr>\n<td>400</td>\n<td>31.8057</td>\n<td>24.0514</td>\n</tr>\n<tr>\n<td>500</td>\n<td>33.0404</td>\n<td>23.0825</td>\n</tr>\n<tr>\n<td>600</td>\n<td>33.2286</td>\n<td>23.2286</td>\n</tr>\n<tr>\n<td>700</td>\n<td>34.2785</td>\n<td>23.7438</td>\n</tr>\n</tbody>\n</table>\n\nTable 13 – Growth ratio of two implementations of Kruskal’s algorithm\n\nWe can see that the rate of growth of the ratio for the implementation of Kruskal’s algorithm using the heapsort is higher than that of the implementation using the counting sort. Figure 18 illustrates the same graphically. The ratio obtained from the heapsort\nimplementation appears to be logarithmic, while the ratio obtained from the counting sort implementation appears to be linear.\n\n\n\n**Figure 18 – Growth ratio of two implementations of Kruskal’s algorithm**\n\nHence, the complexity of khs is determined by the heapsort. The complexity of kcs is determined by both, the counting sort and the disjoint-set operations. Since the counting sort runs in linear time, the kcs outperformed the khs, which uses the heapsort that runs in logarithmic time.\n\nLooking at the results, we observe that the performance of Kruskal’s algorithm is strongly affected by the density of the graph. Figure 19 through Figure 21 illustrate the differences in growth, of the running time as a function of number of vertices. Heapsort appears to be affected the most by the increase in density. This is due to the complexity of the implementation of Kruskal’s algorithm, which uses the heapsort. Since the time spent sorting edges is \\( O(E \\log E) \\), given the implication of higher density meaning a larger number of edges, a drop in performance is a result. The performance of the implementation of Kruskal’s algorithm that uses a counting sort does not appear to be affected too severely by the increase in graph density. However, it appears that the magnitude of the edge weights had a strong impact on the performance of the implementation that uses the counting sort. The counting sort determines the size of the array that stores the intermediate information (Page 19) to be the magnitude of the largest value to be sorted. Given that the counting sort runs in linear time, the performance of the sort is determined by the largest of the values to be sorted.\nWe observe that when $1020 \\leq w \\leq 1022$. In this weight range, the implementation that uses the heapsort even outperforms the implementation that uses the counting sort for the sparse graphs.\n\nWe can therefore conclude that in the cases when the highest edge weight value is in the low numbers, we can expect a very good performance from the implementation of Kruskal’s algorithm where the counting sort is used.\n\nFigure 19 – Effect of density on performance of Kruskal’s algorithm for graphs with $1 \\leq w \\leq 10$. \n\n\nComparison of performances of implementations of Kruskal’s algorithm for graphs of various densities with a weight range $w = 1 - 100$\n\n\n\nFigure 20 – Effect of density on performance of Kruskal's algorithm for graphs with $1 \\leq w \\leq 100$.\n\nComparison of performances of implementations of Kruskal's algorithm for graphs of various densities with a weight range $w = 1020 - 1022$\n\n\n\nFigure 21 – Effect of density on performance of Kruskal's algorithm for graphs with $1020 \\leq w \\leq 1022$. \n5.2 Prim’s Algorithm\n\nWhen analyzing the implementations of Prim’s algorithm, we obtained three different asymptotic run-time bounds. The implementation with priority queue implemented using “brute force” was estimated to run in \\( O(EV) = O(V^2) \\) time. The implementation that uses a proper implementation of binary heap for the priority queue and the implementation that uses a binomial heap to implement the priority queue were estimated to run in \\( O(E \\lg V) = O(V^2 \\lg V) \\) time. The implementation that uses the “lazy” binary heap and the implementation that uses the Fibonacci heap were estimated to run in \\( O(E) = O(V^2) \\) time for the fixed density \\( \\varepsilon \\).\n\nThe first step is to verify that the ratio of the performance curves of the implementations that are within the same time bound is constant. We will use the implementation of Prim’s algorithm where the priority queue is implemented using the proper binary heap as the base, against which all other implementations are to be compared. The ratio is calculated using\n\n\\[\nR_I = \\frac{T_I}{T_{php_a}}\n\\]\n\nwhere \\( I \\) is the implementation whose ratio is measured against the php_a implementation. Table 14 through Table 16 show the results obtained for all densities and the vertex ranges:\n\n<table>\n<thead>\n<tr>\n<th>( V )</th>\n<th>( p = 0.2 )</th>\n<th>( p = 0.5 )</th>\n<th>( p = 0.8 )</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>( R_{php} )</td>\n<td>( R_{php} )</td>\n<td>( R_{php} )</td>\n<td>( R_{php} )</td>\n</tr>\n<tr>\n<td>100</td>\n<td>1.1379</td>\n<td>0.6552</td>\n<td>2.4310</td>\n</tr>\n<tr>\n<td>200</td>\n<td>1.2585</td>\n<td>0.5707</td>\n<td>2.1073</td>\n</tr>\n<tr>\n<td>300</td>\n<td>1.3106</td>\n<td>0.5308</td>\n<td>1.9648</td>\n</tr>\n<tr>\n<td>400</td>\n<td>1.3265</td>\n<td>0.5498</td>\n<td>1.7815</td>\n</tr>\n<tr>\n<td>500</td>\n<td>1.3501</td>\n<td>0.5117</td>\n<td>1.6543</td>\n</tr>\n<tr>\n<td>600</td>\n<td>1.3552</td>\n<td>0.5061</td>\n<td>1.5806</td>\n</tr>\n<tr>\n<td>700</td>\n<td>1.3673</td>\n<td>0.4889</td>\n<td>1.7968</td>\n</tr>\n<tr>\n<td>800</td>\n<td>1.3668</td>\n<td>0.4955</td>\n<td>1.7784</td>\n</tr>\n<tr>\n<td>900</td>\n<td>1.3704</td>\n<td>0.4930</td>\n<td>1.7611</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>1.3723</td>\n<td>0.4919</td>\n<td>1.7962</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>1.3738</td>\n<td>0.4896</td>\n<td>1.7364</td>\n</tr>\n<tr>\n<td>1200</td>\n<td>1.3699</td>\n<td>0.4857</td>\n<td>1.7141</td>\n</tr>\n<tr>\n<td>1300</td>\n<td>1.3798</td>\n<td>0.4882</td>\n<td>1.7110</td>\n</tr>\n<tr>\n<td>1400</td>\n<td>1.3757</td>\n<td>0.4855</td>\n<td>1.7057</td>\n</tr>\n<tr>\n<td>1500</td>\n<td>1.3740</td>\n<td>0.4791</td>\n<td>1.6817</td>\n</tr>\n<tr>\n<td>1600</td>\n<td>1.3594</td>\n<td>0.4787</td>\n<td>1.6786</td>\n</tr>\n<tr>\n<td>1700</td>\n<td>1.3708</td>\n<td>0.4818</td>\n<td>1.6744</td>\n</tr>\n</tbody>\n</table>\n\nTable 14 – Ratios obtained for all implementations of Prim’s algorithm and the implementation that uses a proper implementation of binary heap (php_a) for \\( 1 \\leq w \\leq 10 \\)\n### Table 15 – Ratios obtained for all implementations of Prim’s algorithm and the implementation that uses a proper implementation of binary heap (php_a) for $1 \\leq w \\leq 100$\n\n<table>\n<thead>\n<tr>\n<th>$V$</th>\n<th>$p = 0.2$</th>\n<th>$p = 0.5$</th>\n<th>$p = 0.8$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n</tr>\n<tr>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n</tr>\n<tr>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n</tr>\n</tbody>\n</table>\n\n### Table 16 – Ratios obtained for all implementations of Prim’s algorithm and the implementation that uses a proper implementation of binary heap (php_a) for $1020 \\leq w \\leq 1022$\n\n<table>\n<thead>\n<tr>\n<th>$V$</th>\n<th>$p = 0.2$</th>\n<th>$p = 0.5$</th>\n<th>$p = 0.8$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n</tr>\n<tr>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n</tr>\n<tr>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n<td>$R_{php}$</td>\n</tr>\n</tbody>\n</table>\n\nPage 65\nRunning Time ratios of implementations of Prim's algorithm and implementation that uses proper implementation of binary heap for weights 1 - 10\n\nFigure 22 – Ratios obtained for all implementations of Prim's algorithm and the implementation that uses a proper implementation of binary heap (php_a) for 1 \\leq w \\leq 10\n\nRunning Time ratios of implementations of Prim's algorithm and implementation that uses proper implementation of binary heap for weights 1 - 100\n\nFigure 23 – Ratios obtained for all implementations of Prim's algorithm and the implementation that uses a proper implementation of binary heap (php_a) for 1 \\leq w \\leq 100\n\nPage 66\nRunning Time ratios of Implementations of Prim’s algorithm and implementation that uses proper implementation of binary heap for weights 1020 - 1022\n\n\n\n**Figure 24** – Ratios obtained for all implementations of Prim’s algorithm and the implementation that uses a proper implementation of binary heap (php_a) for 1020 ≤ w ≤ 1022\n\n**Brute Force Implementation (pbf)**\n\nFigure 22 through Figure 24 show that the ratios obtained for the graphs of different densities for all ranges of edge weights are fairly consistent. The ratio for the “brute force” implementation displays a slight growth in magnitude for all graphs used. Looking at the numbers we can see that the ratio is fairly constant, although it displays a fairly small growth. The asymptotic upper bound for the “brute force” implementation of Prim’s algorithm is estimated to remain consistent regardless of the value of e. The running time of the algorithm is dominated by the EXTRACT-MIN operation, which iterates over the entire array of vertices precisely V times for very iteration of the algorithm. Each implementation has a potential to perform $V^2$ iterations over all vertices for each adjacent edge, however in the case of the “brute force” force implementation of Prim’s algorithm, $V^2$ complexity is assured, in order to perform all EXTRACT-MIN operations necessary to complete the task.\n\nFigure 25 shows that regardless of the density of the graph, or the range of weights w, the “brute force” implementation of Prim’s algorithm will provide very consistent performance. According to Figure 14, Figure 15, and Figure 16, the implementation of Prim’s algorithm with priority queue implemented using “brute force” has outperformed the implementation with priority queue implemented using binomial heap. This can be attributed to the results of the analysis of the binomial heap, which revealed that as the density of the graph approaches 1, the asymptotic complexity of the implementation of\nPrim’s algorithm that uses the binomial heap approaches $O(V^2)$, the asymptotic bound of the “brute force” implementation of the algorithm.\n\n\n\n**Figure 25** – Change in performance of “brute force” implementation of Prim’s algorithm for different data sets.\n\n**Proper Binary Heap Implementation (php_a)**\n\nBecause we use the performance of the implementation of Prim’s algorithm that uses a proper binary heap as the value against which performances of other implementations are measured, we examine the change density and change in the range of weights $w$, that affect the performance of that implementation.\n\nFigure 26 displays a change in performance similar to that shown in Figure 25. The curves in Figure 26 display a higher degree of divergence with respect to graph density, as the number of vertices increases. Thus, the performance appeared to drop slightly for the more dense graphs. This suggests that for the graphs with number of vertices larger than 1700 the change in performance will be more visible for more dense graphs. We can also speculate that if very sparse graphs, $0 < p \\leq 0.2$, had been used in the experiment, we would have been able to see a more significant change in performance with the change in graph density. Nevertheless, according the performance ratio obtained, we see that the implementation of Prim’s algorithm, which uses a binary heap implementation of priority\nqueue outperforms the implementation of where the priority queue is implemented using \"brute force\".\n\n\\[\n\\begin{array}{c}\n\\text{Change in performance of Prim's algorithm which uses proper \"binary heap\" implementation of priority queue} \\\\\n\\text{Figure 26 – Change in performance of “binary heap” implementation of Prim's algorithm for different data sets.}\n\\end{array}\n\\]\n\n**Binomial Heap Implementation (pbinh)**\n\nThe implementation where the priority queue is implemented as a binomial heap had the worst performance of all implementations of Prim's algorithm. Although its asymptotic upper bound is the same as the binary heap implementation, the poor performance can be attributed to the implementation of the binomial heap data structure. The binomial heap is a list of binomial trees, where every tree is implemented as a list of individually allocated nodes linked using pointers. EXTRACT-MIN, which results in a large number of MERGE and UNION operations, performs a significantly more work than do other implementations used in this experiment. The overhead associated with the use of binomial heap results in a constant value large enough to result in a performance that is worse than some of the implementations with higher upper bound produced in this experiment. We speculate that if the number of vertices is large enough, the implementation that uses the binomial heap will eventually perform as well as the other implementations with the same asymptotic upper bound. Looking at Figure 27 we see that for the most part the performance of the algorithm appears to be fairly consistent, regardless of the graph density or the range of edge weights. As with other\nimplementation, the curves begin to diverge as the number of vertices becomes large. We observe a slight drop in performance as the number of vertices increases. As with the implementation, where the binary heap is used for the priority queue implementations, we can speculate here that at some large $V$ the drop in performance will be very significant. We can also speculate that we can observe drastic shifts in performance for very sparse graphs, where $0 < p \\leq 0.2$.\n\n\n\n**Figure 27** – Change in performance of “binomial heap” implementation of Prim’s algorithm for different data sets.\n\n**Fibonacci Heap Implementation (pfibh).**\n\nThe implementation where the priority queue is implemented as a Fibonacci heap, has shown a performance better than other implementations, with the exception of the implementation where a “lazy” version of binary heap was used. The ratio of the performance of Fibonacci heap implementation and that of the implementation where the proper binary heap is used is fairly constant, although we can still observe the slight decrease in the curve. As with the other implementations, we speculate that more visible results can be seen with graphs with larger number of vertices and lower graph densities. According to Figure 28 we see that the performance curves begin to diverge much earlier than the performance curves produced by other implementations. This is attributed to the density of the graph. Since the estimated asymptotic complexity of the implementation is $O(E)$ in amortized time, $\\varepsilon$ becomes a significant factor in algorithm’s performance. Hence, for low values of $\\varepsilon$, the performance of the algorithm that uses a Fibonacci heap\nas a priority queue is significantly better. We also note that the graphs with a narrower range of edge weights yield slightly better performance than the graphs with the wider range of weights. We can attribute this to the fact that the running time is amortized. If the range of weights is small, the potential for spending time to restore the heap invariant of the trees within the Fibonacci heap is lower than it would be if the range of weights is wide. We can therefore conclude, that this implementation provides a very good performance for the sparse graphs with small range of edge weights. We can therefore speculate that for sparse graphs with a very large number of vertices the implementation of Prim’s algorithm that uses the Fibonacci heap implementation of the priority queue will be one of the best performers.\n\n\n\nFigure 28 – Change in performance of “Fibonacci heap” implementation of Prim’s algorithm for different data sets.\n\n\"Lazy\" Binary Heap Implementation (php)\n\nThe ratio of the “lazy” implementation of binary heap and the proper implementation of the binary heap, appears fairly constant as shown in Figure 22, Figure 23, and Figure 24. Looking at the corresponding tables, we can see a slight decrease in the ratio with respect to the number of vertices, for every graph density and the range of edge weights w. Thus, we can see a slight difference in the asymptotic complexity of the “lazy” heap and the\nproper heap implementations of Prim’s algorithm. Since the “lazy” heap implementation runs in $O(E)$, we can expect to see better performance for sparse graphs. The performance divergence based on the graph density can be seen in Figure 29. We can also note that the performance tends to drop slightly for the graphs with wider range of edge weights. This behavior is analogous to that of the Fibonacci heap. By delaying the process of restoring the heap invariant until the EXTRACT-MIN operation is to be performed, we are amortizing the running time of the algorithm. Thus, we obtain the results similar to those of the Fibonacci heap. However, the “lazy” heap implementation outperforms the Fibonacci heap implementation. We will attribute this to the lower overhead involved in implementing a binary heap. Like binomial heap, Fibonacci heap is a collection of trees. Each three is implemented as individually allocated nodes linked together using pointers. Hence the run-time constant is expected to be higher for the Fibonacci heap implementation than that of the “lazy” heap implementation.\n\n\n\n**Figure 29** – Change in performance of “lazy heap” implementation of Prim’s algorithm for different data sets.\n\nGiven the obtained results, we can state that the implementation of Prim’s algorithm that uses the “lazy” heap as a priority queue demonstrated the best performance in all cases. Although its performance tends to fluctuate slightly with the graph density and the range of edge weights, this fluctuation is not significant enough for the graph sizes used in this experiment. For larger graphs, we speculate that the performance curves will display more divergence.\n6. CONCLUSIONS\n\nFrom the results we obtained we can conclude that the best performance is obtained from the use of Prim’s algorithm with priority queue implemented as a “lazy” heap. This version of Prim’s algorithm outperformed all other algorithms used in this experiment because the operations that maintain the heap invariant were delayed until the EXTRACT-MIN operation. Thus, the cost associated with maintaining the heap invariant was reduced from $O(E \\lg V)$ to $O(V \\lg V)$. This resulted in the lower amortized run time with respect to its counterpart, where the heap is implemented properly. In the case of lazy heap, the dominating term in the equation is $E$, hence the running time of the algorithm is $O(E)$. The good performance is also attributed to the simplicity of the data structure used to implement the “lazy” heap. Since it was implemented as an array, there was very little overhead associated with the implementation. For that reason the Prim’s algorithm with priority queue implemented as a “lazy” heap has outperformed its counterpart where the priority queue is implemented as a Fibonacci heap.\n\nOne word of caution, however. Although the implementation of Prim’s algorithm has outperformed all other implementations of Prim’s algorithm and all implementations of Kruskal’s algorithm, “lazy” heap implementation violates the heap data type abstraction. It is only useful as a priority queue used in Prim’s algorithm or in other areas where the DECREASE-KEY operation is performed more frequently than other operations. In some instance the “lazy” heap can even be expected to offer worse performance than its proper counterpart. For example, if the application that uses the binary heap performs many PEEK (look at the minimum value, but don’t extract it) operations, the time to perform such operation will be increased from $\\Theta(1)$ to $O(\\lg n)$, since the heap invariant must be ensured. We can therefore look at the priority queue being tightly integrated into the algorithm implementation where the “lazy” heap is used.\n\nOverall, we can conclude that the implementations of algorithms perform differently on different sets of data. Kruskal’s algorithm that sorts the edges using the counting sort performs exceptionally well on sparse graphs. It showed very good performance, second to the implementation of Prim’s algorithm using the “lazy” heap, on all graphs where $p = 0.2$. In some of the real world applications such as the telephone line routing problems, where $p$ is expected to be much lower than 0.2, Kruskal’s algorithm with the counting sort will be more than adequate. For the graphs with $p > 0.2$ Prim’s algorithm with priority queue implemented as a Fibonacci heap, performed second to the implementation of Prim” algorithm that uses the “lazy” heap implementation of priority queue.\nWe can therefore conclude making the following recommendation of the best algorithm implementations for various types of data, see Table 17.\n\n<table>\n<thead>\n<tr>\n<th>Weight range</th>\n<th>$0 < p \\leq 0.2$</th>\n<th>$p \\equiv 0.5$</th>\n<th>$0.8 \\leq p < 1$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Narrow weight</td>\n<td>1. Prim with "lazy" heap</td>\n<td>1. Prim with "lazy" heap</td>\n<td>1. Prim with "lazy" heap</td>\n</tr>\n<tr>\n<td></td>\n<td>2. Kruskal with counting sort</td>\n<td>2. Prim with Fibonacci heap</td>\n<td>2. Prim with Fibonacci heap</td>\n</tr>\n<tr>\n<td>Medium weight</td>\n<td>1. Prim with "lazy" heap</td>\n<td>1. Prim with "lazy" heap</td>\n<td>1. Prim with "lazy" heap</td>\n</tr>\n<tr>\n<td></td>\n<td>2. Kruskal with counting sort</td>\n<td>2. Prim with Fibonacci heap</td>\n<td>2. Prim with Fibonacci heap</td>\n</tr>\n<tr>\n<td>High weight</td>\n<td>1. Prim with "lazy" heap</td>\n<td>1. Prim with "lazy" heap</td>\n<td>1. Prim with "lazy" heap</td>\n</tr>\n<tr>\n<td></td>\n<td>2. Kruskal with counting sort</td>\n<td>2. Prim with Fibonacci heap</td>\n<td>2. Prim with Fibonacci heap</td>\n</tr>\n</tbody>\n</table>\n\nTable 17 – Recommended algorithms for finding minimum spanning trees in different types of graphs.\n\nAlthough these recommendations have been made, the results are not as conclusive as were intended. It appears that using graphs with 1700 vertices are not large enough to see a significant shift in performance for various implementations of Prim’s algorithm. Also the density of 0.2 appeared to be too high to show its impact on the performance of the implementations of Prim’s algorithm used in this experiment. However, we can easily eliminate the poor performers, Kruskal’s algorithm with heap sort and Prim’s algorithm with “brute force” implementation of the priority queue. The implementation of Prim’s algorithm using the binomial heap, displayed very poor performance, however we will not discard it until we test on graphs with the number of vertices far larger than 1700.\n7. FURTHER WORK\n\nThe further work of will involve repeating the tests on graphs with much larger number of vertices and much lower density. Thus we will be able to tell better if the performance of the algorithms reflects their asymptotic bounds, since number of speculations was made, and several questions, such as where will binomial heap implementation of Prim's algorithm converge with the proper binary heap implementation, are unanswered.\n\nThe implementation of the binomial heap is to be reevaluated. Some overhead might be reduced with elimination of some use of pointers.\n\nWe believe that performance of the implementation of Prim's algorithm that uses the \"lazy\" implementation of binary heap can be improved even further with the use of flag to indicate whether any keys have been decreased, and whether the heap invariant was broken. The further work will involve the implementation of this algorithm and tested against the data obtained in this experiment.\nBIBLIOGRAPHY\n\n\nMST.mak\n\nBinHeap.o: MST.h BinHeap.h\nprimh.o: MST.h PrimHeap.h\nPrimHeap.o: MST.h PrimHeap.h\n\n# Housekeeping\n\nArchive: $(SOURCEFILES) Makefile\nls $(SOURCEFILES) Makefile | cpio -o cv | compress > Archive\n\nclean:\n/bin/rm -rf $(OBJFILES) MSt.o gengraph.o ptreepository Templates.DB .sh core\n\n# Main targets\n\nall: MST gengraph\n\nMST: MSt.o $(OBJFILES)\n$(CC) $(CFLAGS) -o MSt.o $(OBJFILES) $(LIBFLAGS)\n\ngengraph: gengraph.o $(OBJFILES)\n$(CC) $(CFLAGS) -o gengraph gengraph.o $(OBJFILES) $(LIBFLAGS)\n\n# Dependencies\n\nMSt.o: MSt.h\ngengraph.o: MSt.h\nheap.o: MSt.h\n#heapest.o: MSt.h\nmtx.o: MSt.h\nprimh.o: MSt.h\nprinb.o: MSt.h\nkrusk_un.o: MSt.h\nkrusk_cs.o: MSt.h\nkrusk_bf.o: MSt.h\nprimb.o: MSt.h BinHeap.h\n/*\n#define __DEBUG__\n\ntypedef enum { FALSE = 0, TRUE = 1 } BOOL;\n\n**** Definitions for method specification\n****\n#define KRUSKAL_INSRT \"kis\"\n#define KRUSKAL_HEAPRT \"knr\"\n#define KRUSKAL_COUNTSORT \"kc\"\n#define PRIM_RF \"prf\"\n#define PRIM_HEAP \"php\"\n#define PRIM_HEAP_1 \"php,a\"\n#define PRIM_BINHEAP \"pbinh\"\n#define PRIM_MAXHEAP \"pmaxh\"\n\n**** Generic Definitions\n****\n#define INFINITY 0xffffffff\n#define NIL -1\n\n**** Error codes\n****\n#define CANNOT_ALLOCATE_MEMORY -10\n#define CANNOT_CREATE_HEAP -11\n#define NOT_ENOUGH_CONNECTED_VERTICES -100\n\n**** STRUCTURES USED IN KRUSKAL'S ALGORITHM WHICH DOESN'T USE HEAPSORT, BUT ****\n**** USES THE INSERTION SORT\n*******************************************************************************/\n\n**** Graph type definition\n****\ntypedef int* GraphRow;\n\n*************************************************************************************\n\n**** PRIORITY QUEUE DEFINITION FOR USE IN PRIM'S ALGORITHM\n*******************************************************************************/\n\n****\ntypedef struct tagPriorityQueue\n{\n int* vertices; /* Array of vertices */\n int head; /* Head of the queue */\n int tail; /* Tail of the queue */\n int size; /* Total size of queue */\n int length; /* Total length of que*/\n} PBBQueue;\n\ntypedef int* KeyArray; /* Array of keys */\ntypedef int* FIAarray; /* Array of PIs */\n\n****\n#define IS_QUEUE_EMPTY(Q) ((Q).length <= 0)\n\nMST.h\n\n/****\n**** HEAP DEFINITIONS FOR USE IN PRIM'S ALGORITHM\n*******************************************************************************/\n\n****\n#define PARENT(I) (((I) - 1) / 2)\n#define LEFT(I) (((I) * 2) + 1)\n#define RIGHT(I) (((I) * 2) + 2)\n\ntypedef PBHashTable HeapStruct; /* Heap structure */\n\n****\n#define VERT_LIST_IMPL_TO_BE_USED_WITH_BINOMIAL_HEAP\n****\ntypedef struct tagVertList\n{\n int u; /* u values */\n BOOLEAN bRemoved;\n} VertList, *FVertList;\n\n/****\n**** RETURN CODE DEFINITIONS\n****\n#define HEAP_ERR_UNDERFLOW -100;\n\n/****\n**** DEFINITIONS FOR KRUSKAL'S ALGORITHM\n*******************************************************************************/\n\ntypedef struct tagEdges\n{\n int u;\n int v;\n int weight;\n} Edge, *FedgeList;\n\n/****\n**** CPU TIMINGS\n****\n*******************************************************************************/\n\n#include <sys/time.h>\n#include <sys/resource.h>\nextern int get_usage();\n#define CPU_TIMES(get_usage(RUSAGE_SELF,&ruse),\n ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec +\n le-6 * (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))\n#ifndef __BINHEAP_H__\n\n/*\n** FILE: BinHeap.h\n**\n** CONTENTS: Definition of data types and function prototypes which\n** implement a Binomial Heap.\n**\n** Structure to define a node of the heap tree. The definition\n** of this structure is also used for the declaration of the\n** binomial trees, as well as the binomial queue\n**\n** typedef struct _tagBinNode_\n** {\n** *** Binomial Tree attributes\n** ***\n** struct _tagBinNode_ * pParent; /* parent node */\n** struct _tagBinNode_ * pLeftChild; /* children node */\n** struct _tagBinNode_ * pSibling; /* sibling node */\n** int nDegree; /* degree */\n** int nKey; /* key value (must be integer) */\n** unsigned int unVert; /* Pointer to index of vertex */\n** } BinNode, *PBinNode, *Position, *BinTree, **BinKeyPtrArray;\n\n** Structure to provide the memory store of all nodes -- to avoid the\n** dynamic allocation, which may be costly.\n**\n**\n*/\n\ntypedef struct _tagBinHeapMemMgr_\n{\n BinNode* aNodes; /* Array of nodes */\n PBinNode* apNodes; /* Array of pointers */\n unsigned numNodes; /* Total nodes */\n unsigned top; /* top of the stack */\n} NodeStore;\n\n/*\n** Prototypes of functions to perform binomial heap operations\n**\n** BOOL NodeStore_destroy(NodeStore* pStore);\n** PBinNode NodeStore_alloc(NodeStore* pStore);\n** void NodeStore_free(PBinNode* node, NodeStore* pStore);\n**\n** PBinQueue BinQueue_make(int nVertices);\n** void BinQueue_Destroy(PBinQueue* ppQueue);\n** BinTree BinQueue_combineTrees(BinTree t1, BinTree t2);\n** PBinQueue BinQueue_merge(PBinQueue h1, PBinQueue h2, int nCapacity,\n** int* pnErrCode);\n** PBinNode BinQueue_extractMin(PBinQueue h);\n** PBinQueue BinQueue_insert(PBinQueue h, PBinNode n, int* pnErrCode);\n** int BinQueue_decreaseKey(PBinQueue h, int unVert, int nKey);\n** int BinQueue_min(PBinQueue h);\n\n** ERROR CODE DEFINITIONS\n**\n*/\ndefine BINQUEUE_SIZE_OVERFLOW -10\n#define BINQUEUE_VERTEX_DUPLICATION -11\n#define BINQUEUE_VERTEX_NOT_IN_QUEUE -12\n#define BINQUEUE_QUEUE_IS_EMPTY -13\n#define BINQUEUE_DECREASE_TO_GREATER_VALUE -14\n#define BINQUEUE_OK 0\n\n#endif\n\nBinHeap.h\n#ifndef __FIBHEAP_H__\n\n#include <stdio.h>\n#include <math.h>\n#include <math.h>\n\n/**\n *** Structure to define a node of the heap tree. The definition\n *** of this structure is also used for the declaration of the\n *** trees which comprise the Fibonacci heap.\n */\ntypedef struct __tagFibNode\n{\n /**\n *** Tree Attributes\n */\n struct __tagFibNode* pParent; /* parent pointer */\n struct __tagFibNode* pChild; /* child pointer */\n struct __tagFibNode* pLeft; /* left sibling */\n struct __tagFibNode* pRight; /* right sibling */\n int nDegree; /* number of children the node */\n /* has in the child list */\n BOOL bMark; /* Indicates if the node has lost*/\n /* a child since the last time */;\n /* the node was made a child of*/\n /* another list */\n int nKey; /* key value (must be integer) */\n unsigned int unVert; /* Pointer to index of vertex */\n} FibNode, *PFibNode, *FibTree, **FibKeyPtrArray;\n\n/**\n *** Structure to define an entire heap. This heap contains a pointer to\n *** the list of nodes, a counter to maintain the number of trees in the\n *** heap, the current size of the heap (total number of nodes), a pointer\n *** to a root of the heap nodes, an array of pointers to insert/extract\n *** pointers to nodes, where an index of the array represents a vertex of\n *** the connected graph with which the Fibonacci heap is used.\n **/\ntypedef struct __tagFibCollection_\n{\n PFibNode pRootList; /* List of roots */\n int nCurrentSize;\n PFibNode pMin; /* Pointer to node with minimum */\n} FibCollection, *PFibCollection;\n\n#define __FIBHEAP_H__\n#endif\n\n/**\n *** Key value\n */\n\nBOOL* aInQueue; /* Array of flags to flag if a*/\n/* node is in the queue */\n\nPFibNode* apVertexNodes; /* Array of pointers to nodes */\n\nint nMaxSize; /* Maximum size of the heap */\n\nPFibNode* A; /* Auxiliary array A for*/\n/* consolidation */\n\nint Dm; /* D(n) */\n\n} FibQueue, *PFibQueue;\n\n/**\n *** Structure to provide the memory store of all nodes -- to avoid the\n *** dynamic allocation, which may be costly.\n **/\n\ntypedef struct __tagFibHeapMemMgr_\n{\n /*\n * FibNode* aNodes; /* Array of nodes */\n * PFibNode* apNodes; /* Array of pointers */\n * unsigned numNodes; /* Total nodes */\n * unsigned top; /* top of the stack */\n */\n FibNodeStore* pStore;\n} FibHeapMemManager, *PFibHeapMemManager;\n\n/**\n *** PROTOTYPES\n **/\n\nBOOL FibNodeStore_create(int size, FibNodeStore* pStore);\nvoid FibNodeStore_destroy(FibNodeStore* pStore);\nPFibNode FibNodeStore_alloc(FibNodeStore* pStore);\nvoid FibNodeStore_free(FibNodeStore* pStore);\n\nPFibQueue FibHeap_make(int nMaxSize);\nvoid FibHeap_destroy(PFibQueue pQue);\n\nPFibNode FibHeap_concatLists(PFibNode pL1, PFibNode pL2);\nPFibNode FibHeap_insert(PFibQueue h, PFibNode pNode);\nPFibQueue FibHeap_union(PFibQueue h1, PFibQueue h2);\nPFibNode FibHeap_extractMin(PFibQueue h);\nPFibNode FibHeap_consolidate(PFibQueue h);\nPFibQueue FibHeap_link(PFibQueue h, PFibNode pY, PFibNode pX);\nPFibQueue FibHeap_decreaseKey(PFibQueue h, unsigned int unVert, int nKey);\nPFibQueue FibHeap_cut(PFibQueue h, PFibNode pX, PFibNode pY);\nPFibQueue FibHeap_cascadingCut(PFibQueue h, PFibNode pY);\n\n#} FibQueue, *PFibQueue;\n\n/*\n *** FibHeap.h\n */\n\n/******\n *** FILE: FibHeap.h\n ****\n *** CONTENTS: Definition of data types and function prototypes which\n *** implement a Fibonacci Heaps.\n ****\n\n***************************************************************************/\n\n*/\n\n07/14/98\n18:41:14\n# gengraph.c\n\nThis function with connections\n\n```c\nint nVertices - number of vertices the graph is to have.\ndouble dProb - probability of an edge being generated.\nint nMinWeight - minimum edge weight\nint nMaxWeight - maximum edge weight\n```\n\n**RETURNS:**\n\n```\nNOTHING\n```\n\n**DESCRIPTION:**\n\nThis function fills the graph with connections based on the probability and the weight range passed via the input arguments.\n\n```c\nvoid GenGraph(GraphRow* pGraph, int nVertices, double dProb, int nMinWeight, int nMaxWeight)\n{\n int i, j; /* Indexes into the graph matrix */\n double dNumGenerated; /* Random number generated */\n int nWeight; /* Weight generated */\n int nRandVal;\n\n srand48(8376761); /* Seed the random number generator */\n for (i = 0; i < nVertices; i++)\n for (j = i + 1; j < nVertices; j++)\n {\n rand();\n nRandVal = rand();\n nRandVal = nRandVal % 100;\n dNumGenerated = (double)nRandVal / (double)90;\n if (dNumGenerated > dProb)\n pGraph[i][j] = 0;\n else\n {\n /* At this point, we will have to generate the edge */\n nWeight = rand();\n nWeight = nWeight % (nMaxWeight - nMinWeight);\n nWeight += nMinWeight;\n pGraph[i][j] = nWeight;\n }\n pGraph[j][i] = pGraph[i][j];\n }\n}\n```\n\n**FUNCTION:**\n\nGenGraph\n\n**INPUT ARGUMENTS:**\n\n```\nGraphRow* sGraph - graph buffer to be filled up by\n```\n---\n\n**07/07/98**\n\n**15:14:49**\n\ngengraph.c\n\n```c\n... 55 RETURNS: NOTHING\n... 60 *** DESCRIPTION: Main function of the program. This function checks\n... 61 *** the command line arguments to make sure that the ***\n... 62 *** parameters specified for the graph generation are ***\n... 63 *** valid. Then this function initiates the graph ***\n... 64 *** generation sequence.\n... 65 ***\nvoid main(int argc, char** argv)\n{\n char c; /* Character extracted from arguments */\n char* sFileName = NULL; /* Name of the file where graph is stored */\n int nVertices = -1; /* Number of vertices the graph is to have*/\n double dProbability = 1.0; /* Probability of edge being generated */\n int nMinWeight = -1; /* Minimum edge weight */\n int nMaxWeight = -1; /* Maximum edge weight */\n GraphRow* sGraph = NULL; /* Pointer to the array that stores graph */\n int rc; /* Return code from the function calls */\n\n /***\n **** Extract the command line arguments with options:\n **** n = number of vertices\n **** p = probability of the edge being present\n **** w = minimum weight\n **** W = maximum weight\n ****\n while ( (c = getopt(argc, argv, \"n:p:w:W:f:\")) != -1 )\n switch (c)\n {\n case 'n': if (nVertices > -1)\n {\n PrintUsageMessage(stderr, argv[0],\n \"Illegal use of command line arguments\");\n if (sFileName != NULL) free(sFileName);\n exit(1);\n }\n else nVertices = atoi(optarg);\n break;\n case 'p': if (dProbability > -1)\n {\n PrintUsageMessage(stderr, argv[0],\n \"Illegal use of command line arguments\");\n if (sFileName != NULL) free(sFileName);\n exit(1);\n }\n else dProbability = atof(optarg);\n break;\n case 'w': if (nMinWeight > -1)\n {\n PrintUsageMessage(stderr, argv[0],\n \"Illegal use of command line arguments\");\n if (sFileName != NULL) free(sFileName);\n exit(1);\n }\n else nMinWeight = atoi(optarg);\n break;\n case 'W': if (nMaxWeight > -1)\n {\n PrintUsageMessage(stderr, argv[0],\n \"Illegal use of command line arguments\");\n if (sFileName != NULL) free(sFileName);\n exit(1);\n }\n else nMaxWeight = atoi(optarg);\n break;\n case 'f': if (sFileName != NULL)\n {\n PrintUsageMessage(stderr, argv[0],\n \"Illegal use of command line arguments\");\n if (sFileName != NULL) free(sFileName);\n exit(1);\n }\n else\n nMaxWeight = atoi(optarg);\n break;\n case 'f': if (sFileName != NULL)\n {\n PrintUsageMessage(stderr, argv[0],\n \"Illegal use of command line arguments\");\n if (sFileName != NULL) free(sFileName);\n exit(1);\n }\n else\n sFileName = (char *)malloc(strlen(optarg));\n strcpy(sFileName, optarg);\n break;\n \n /* Make sure that all required command line argumnets have been entered */\n if ( (nVertices < 0) || (dProbability < 0.0) || (nMinWeight < 0) ||\n (nMaxWeight < 0) )\n {\n PrintUsageMessage(stderr, argv[0],\n \"Illegal use of command line arguments\");\n if (sFileName != NULL) free(sFileName);\n exit(1);\n }\n \n /***\n **** We are now ready to create a graph.\n ****\n if ( ((rc = CreateGraph(nVertices, &sGraph)) == 0)\n {\n fprintf(stderr, \"$s: Cannot allocate memory needed to create graph.\n \n if (sFileName != NULL) free(sFileName);\n exit(0);\n }\n else if (rc == -1)\n {\n fprintf(stderr, \"$s: Illegal number of vertices specified. $s.\n \n if (sFileName != NULL) free(sFileName);\n exit(1);\n }\n else\n GenGraph(sGraph, nVertices, dProbability, nMinWeight, nMaxWeight);\n \n /***\n **** We can now fill the graph with edges\n ****\n GenGraph(sGraph, nVertices, dProbability, nMinWeight, nMaxWeight);\n \n /***\n **** Save the graph to the file\n ****\n if ( ((rc = SaveGraph(sGraph, nVertices, sFileName)) == 0)\n {\n```\n07/07/98\n15:14:49\n\n```c\n fprintf(stderr, \"%s: Cannot open file %s to save the graph.\\n\", \n argv[0], sFileName);\n }\n\n /***\n **** Cleanup before exiting the suste\n ****/\n if (sFileName != NULL) free(sFileName);\n DestroyGraph(&aGraph, nVertices);\n```\n```c\n// Function: CreateGraph\nvoid CreateGraph(int nVertices, GraphRow** pGraph)\n{*\n int i, j;\n /* Indexes into the graph matrix */\n\n **** Make sure the number of vertices specified is legal\n ****\n if (nVertices < 1)\n return -1;\n\n **** Try to allocate memory\n ****\n *pGraph = (GraphRow*)malloc(sizeof(int) * nVertices);\n if (*pGraph == NULL)\n return 0;\n for (i = 0; i < nVertices; i++)\n {\n (*pGraph)[i] = (GraphRow*)malloc(nVertices * sizeof(int));\n if ((*pGraph)[i] == NULL)\n return -1;\n for (j = 0; j < nVertices; j++)\n {*\n (*pGraph)[i][j] = 0;\n return 1;\n }\n }\n\n **** Initialize the graph to all 0's == no edges\n ****\n for (i = 0; i < nVertices; i++)\n for (j = 0; j < nVertices; j++)\n {*\n (*pGraph)[i][j] = 0;\n return 1;\n }\n}**\n```\nelse\n if ((pOutFile = fopen(sFileName, \"w\")) == NULL)\n return 0;\n\n /****\n /** Write the graph to the file\n ****/\n fprintf(pOutFile, \"%d\\n\", nVertices);\n for (i = 0; i < nVertices; i++)\n {\n for (j = 0; j < nVertices; j++)\n fprintf(pOutFile, \"%d\", pGraph[i][j]);\n fprintf(pOutFile, \"\\n\");\n }\n if (sFileName != NULL)\n fclose(pOutFile);\n return 1;\n}\n\n/** ...\n\n*** FUNCTION: ReadGraph\n***\n*** WRITTEN BY: Alec Berenbaum\n***\n*** INPUT ARGUMENTS:\n*** char* sFileName - name of the file from\n*** which the graph data is\n*** read. IF THIS FALSE IS\n*** NULL, stdin is used.\n***\n*** OUTPUT ARGUMENTS:\n*** int* nVertices - number of vertices in the\n*** graph\n***\n*** int** pGraph - pointer to the array where\n*** the graph data is to be held.\n***\n*** RETURNS:\n*** int - 1 = Read successfully\n*** 0 = couldn't open file\n*** -1 = Error on read and/or not enough\n*** data\n*** -2 = Couldn't allocate memory\n***\n*** DESCRIPTION:\n*** This function reads a graph from a specified\n*** file and writes it into the supplied matrix.\n*/\n\nint ReadGraph(char* sFileName, int* nVertices, int** pGraph, int* pnBig)\n{\n int i = 0, j;\n FILE* pFile;\n int stat;\n int rc;\n\n /****\n /** See if the stdin is to be used for input\n ****/\n if (sFileName == NULL)\n pFile = stdin;\n else\n if ((pFile = fopen(sFileName, \"r\")) == NULL)\n return 0;\n\n /****\n /** Now that we got this far, start reading.\n ****/\n if ((stat = fscanf(pFile, \"%d\", nVertices)) == EOF)\n {\n if (sFileName != NULL)\n fclose(pFile);\n return -1;\n }\n\n /****\n /** Allocate space for graph\n ****/\n if ( (rc = CreateGraph(\"nVertices, pGraph)) == 0)\n return -2;\n else if (rc == -1)\n return -1;\n\n *pnBig = 0;\n while (i < *nVertices) && (stat != EOF))\n {\n j = 0;\n while ((j < *nVertices) &&\n ((stat = fscanf(pFile, \"%d\", &(*pGraph[i][j])) == EOF))\n {\n if ((*pGraph)[] > *pnBig)\n *pnBig = (*pGraph)[];\n j++;\n }\n if (stat != EOF) i++;\n }\n\n /****\n /** Now that we are out of the loop, let's see what threw us out\n ****/\n if ((i < *nVertices) || (j < *nVertices))\n {\n /****\n /** Didn't read all of it\n ****/\n if (sFileName != NULL)\n fclose(pFile);\n DestroyGraph(pGraph, *nVertices);\n printf(\"didn't read all of it: i = %d j = %d, nVertices = %d\\n\", i, j, *nVertices);\n return -1;\n }\n\n /****\n /** SUCCESS!!!!! = Return 1\n ****/\n if (sFileName != NULL)\n fclose(pFile);\n return 1;\n}\n\n//***********************************************************************/\n```c\n#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n#include \"MST.h\"\n\nextern char* optarg;\nextern int optind;\n\nvoid PrintUsageMessage(FILE* outFile, char* progName)\n{\n fprintf(outFile, \"USAGE: %s -g <graph file> -m <method> [-o <output file>]\", progName);\n}\n\nvoid main(int argc, char** argv)\n{\n char* sGraphFileName = NULL;\n char* sMethod = NULL;\n char* sOutputFileName = NULL;\n int bGotO = 0, bGotM = 0, bGotI = 0;\n char c;\n int nVertices, nEdges, row, col, nTime;\n double dfTime, dfAccTime = 0;\n int nTotalCost;\n int nTimesToIterate = 1;\n\n int i, j;\n\n /**** Extract the command line arguments ****/\n\n while ((c = getopt(argc, argv, \"g:m:o:i:\")) != -1)\n switch (c)\n {\n case 'i':\n if (bGotI)\n {\n PrintUsageMessage(stderr, argv[0]);\n if (sGraphFileName != NULL) free(sGraphFileName);\n if (sMethod != NULL) free(sMethod);\n if (sOutputFileName != NULL) free(sOutputFileName);\n exit(1);\n }\n break;\n case 'g':\n if (bGotG)\n {\n PrintUsageMessage(stderr, argv[0]);\n if (sGraphFileName != NULL) free(sGraphFileName);\n if (sMethod != NULL) free(sMethod);\n if (sOutputFileName != NULL) free(sOutputFileName);\n exit(1);\n }\n break;\n case 'm':\n if (bGotM)\n {\n PrintUsageMessage(stderr, argv[0]);\n if (sGraphFileName != NULL) free(sGraphFileName);\n if (sMethod != NULL) free(sMethod);\n if (sOutputFileName != NULL) free(sOutputFileName);\n exit(1);\n }\n break;\n case 'o':\n if (bGotO)\n {\n PrintUsageMessage(stderr, argv[0]);\n if (sGraphFileName != NULL) free(sGraphFileName);\n if (sMethod != NULL) free(sMethod);\n if (sOutputFileName != NULL) free(sOutputFileName);\n exit(0);\n }\n break;\n }\n\n /**** Make sure that all required command line arguments have been entered *****/\n\n if (! bGotM)\n {\n PrintUsageMessage(stderr, argv[0]);\n if (sGraphFileName != NULL) free(sGraphFileName);\n if (sMethod != NULL) free(sMethod);\n if (sOutputFileName != NULL) free(sOutputFileName);\n exit(1);\n }\n\n /**** Validate the method entered *****/\n\n if ((strcmp(sMethod, KRUSKAL_INSTSRT) != 0) &&\n (strcmp(sMethod, KRUSKAL_HEAPSR) != 0) &&\n (strcmp(sMethod, KRUSKAL_COUNTSORT) != 0) &&\n (strcmp(sMethod, PRIM_DEF) != 0))\n {\n```\n```c\n\nvoid CreateMST(void)\n{\n int i, j, nVertices, nEdges, n1, n2, n3;\n double distances[1000][1000];\n int adjacency[1000][1000];\n\n // Load graph data\n loadGraphData(&nVertices, &nEdges, distances, adjacency);\n\n // Sort edges by weight\n sortEdges(distances, nEdges);\n\n // Find MST using Prim's algorithm\n findMST(distances, adjacency, nVertices, &n1, &n2, &n3);\n\n // Print MST\n printMST(n1, n2, n3);\n}\n```\n\nMST.c\n\n```c\n\nelse if (strcmp(sMethod, PRIM_HEAP) == 0)\n nTotCost = php_mst(sGraph, nVertices, aOutGraph, &dftime);\nelse if (strcmp(sMethod, PRIM_HEAP_1) == 0)\n nTotCost = php_mst_1(sGraph, nVertices, aOutGraph, &dftime);\nelse if (strcmp(sMethod, PRIM_HEAP_2) == 0)\n nTotCost = php_mst_2(sGraph, nVertices, aOutGraph, &dftime);\nelse if (strcmp(sMethod, PRIM_BF) == 0)\n nTotCost = pb_mst(sGraph, nVertices, aOutGraph, &dftime);\nelse if (strcmp(sMethod, PRIM_BF_1) == 0)\n nTotCost = pb_mst_1(sGraph, nVertices, aOutGraph, &dftime);\nelse if (strcmp(sMethod, PRIM_BF_2) == 0)\n nTotCost = pb_mst_2(sGraph, nVertices, aOutGraph, &dftime);\n```\n# krusk_bf.c\n\n```c\nint nAlertVertex - vertex that signals a cycle\nint nVertices - number of vertices\nGraphRow* pGraph - graph\n\nOUTPUT ARGUMENTS: NONE\n\nRETURNS: int - 1 if there is a cycle / 0 if there is no cycle\n\nDESCRIPTION: This function performs a DFS on a specified vertex to determine if the edge, of which it is part, forms a cycle if added to the graph.\n```\n\n```c\nint kis_findCycle(int nStartVert, int nPrevVert, int nAlertVertex, int nVertices, GraphRow* pGraph)\n{\n int i; /* Index into the graph */\n int bFound = 0; /* Flags if the cycle has been found */\n\n /* See if the \"alert\" vertex has been found */\n if (nStartVert == nAlertVertex)\n return i;\n\n /* See if any out-going vertices lead to the alert vertex */\n i = 0;\n while((i < nVertices) && (!bFound))\n {\n if (((pGraph[nStartVert][i] > 0) && (i != nPrevVert))\n bFound = kis_findCycle(i, nStartVert, nAlertVertex, nVertices, pGraph);\n i++;\n }\n return bFound;\n}\n```\n\n```c\n/**\n **** Begin the sort\n ****/\nfor (j = 1; j < nEdgeCount; j++)\n{\n key.v = E[j].v;\n key.u = E[j].u;\n key.weight = E[j].weight;\n i = j - 1;\n while((i >= 0) && (E[i].weight > key.weight))\n {\n E[i + 1].v = E[i].v;\n E[i + 1].u = E[i].u;\n E[i + 1].weight = E[i].weight;\n i--;\n }\n E[i + 1].v = key.v;\n E[i + 1].u = key.u;\n E[i + 1].weight = key.weight;\n}\n```\nkruskal_bf.c\n\n```c\nint kis_mst(GraphRow* pGraph, int nVertices, GraphRow* pOutGraph,\n double* pdTime)\n{\n int nCost = 0; /* Cost of the tree */\n int u, v, k; /* Vertices examined at one time */\n EdgeList E; /* Edges of the graph */\n int nEdgeCount = 0; /* Number of edges in the graph */\n unsigned short unStartTime; /* Start time milliseconds part */\n unsigned short unEndTime; /* End time milliseconds part */\n time_t tStartStartime; /* Start time seconds part */\n time_t tEndtime; /* End time seconds part */\n struct timeb tp; /* Time structure */\n\n /*************************************************************************/\n /** INITIALIZATION **/ \n /*************************************************************************/\n\n /*************************************************************************/\n /** Count edges in the graph and allocate space for E **/ \n /*************************************************************************/\n\n for (v = 0; v < nVertices; v++)\n for (u = v + 1; u < nVertices; u++)\n if (pGraph[v][u] != 0) nEdgeCount++;\n E = (EdgeList)malloc(nEdgeCount * sizeof(Edge));\n\n /*************************************************************************/\n /** Collect all edges into the list **/ \n /*************************************************************************/\n\n k = 0;\n for (v = 0; v < nVertices; v++)\n for (u = v + 1; u < nVertices; u++)\n if (pGraph[v][u] != 0)\n { \n E[k].u = u; \n E[k].v = v; \n E[k].weight = pGraph[v][u];\n k++;\n }\n\n /*************************************************************************/\n /** Assuming that the output graph is already empty, we will proceed **/ \n /** with the algorithm **/ \n /*************************************************************************/\n\n /*************************************************************************/\n /** Start the timer **/ \n /*************************************************************************/\n\n ftime(&tp);\n tStartStartime = tp.time; /* Get seconds */\n unStartStartime = tp.milli.; /* Get milliseconds */\n\n /*************************************************************************/\n /** Sort the edges of E by non-decreasing weight v **/ \n /*************************************************************************/\n\n kis_insSort(E, nEdgeCount);\n\n /*************************************************************************/\n /** Iterate over the edge list adding edges to the graph such that there **/ \n /** are no cycles - BRUTE force **/ \n /*************************************************************************/\n\n k = 0;\n while (k < nEdgeCount)\n { \n if (! kis_findCycle(E[k].v, E[k].v, E[k].u, nVertices, pOutGraph))\n { \n pOutGraph[E[k].u][E[k].v] = E[k].weight;\n pOutGraph[E[k].v][E[k].u] = E[k].weight;\n nCost += E[k].weight;\n }\n k++;\n }\n\n /*************************************************************************/\n\n /*************************************************************************\n```c\n// PATH COMPRESSION FUNCTIONS\n\n*** FUNCTION: make_set\n***.\n*** INPUT ARGUMENTS: int x - vertex for which the set is made\n*** int* p - array of pointing values\n*** int* rank - array of ranks\n*** OUTPUT ARGUMENTS: NONE\n*** RETURNS: NOTHING\n*** DESCRIPTION: Makes a set of pointers for the vertex of the graph.\n\nvoid make_set(int x, int* p, int* rank)\n{\n p[x] = x;\n rank[x] = 0;\n}\n\n*** FUNCTION: find_set\n***.\n*** INPUT ARGUMENTS: int x - vertex for which the set is made\n*** int* p - array of pointing values\n*** OUTPUT ARGUMENTS: int - pointing value at the X\n*** RETURNS: int\n*** DESCRIPTION: Finds a value pointing at the X\n\nint find_set(int x, int* p)\n{\n if (x != p[x])\n p[x] = find_set(p[x], p);\n return p[x];\n}\n\n*** FUNCTION: link\n***.\n*** INPUT ARGUMENTS: int x - vertex being linked\n*** int y - vertex being linked\n*** int* p - array of pointing values\n*** int* rank - array of ranks for each vertex\n*** OUTPUT ARGUMENTS: NONE\n*** RETURNS: NOTHING\n*** DESCRIPTION: Links two sets together into one.\n\nvoid link(int x, int y, int* p, int* rank)\n{\n if (rank[x] > rank[y])\n p[y] = x;\n else\n {\n p[x] = y;\n if (rank[x] == rank[y])\n rank[y]++;\n }\n}\n```\n\n```c\n*** FUNCTION: kr_union\n***.\n*** INPUT ARGUMENTS: int x - vertex being linked\n*** int y - vertex being linked\n*** int* p - array of pointing values\n*** int* rank - array of ranks for each vertex\n*** OUTPUT ARGUMENTS: NONE\n*** RETURNS: NOTHING\n*** DESCRIPTION: Joins two vertices to form an edge.\n\nvoid kr_union(int x, int y, int* p, int* rank)\n{\n link(find_set(x, p), find_set(y, p), p, rank);\n}\n```\n\n```c\n*** HEAPSORT IMPLEMENTATION\n***.\n#define KRLEFT(I) (((I) * 2) + 1)\n#define KRRIGHT(I) (((I) * 2) + 2)\n```\nvoid edge_swap(Edge* e1, Edge* e2)\n{\n Edge tmp;\n tmp.v = e1->v;\n tmp.u = e1->u;\n tmp.weight = e1->weight;\n e1->v = e2->v;\n e1->u = e2->u;\n e1->weight = e2->weight;\n e2->v = tmp.v;\n e2->u = tmp.u;\n e2->weight = tmp.weight;\n}\n\n gboolean Kr_Heapsort(EdgeList E, int nEdgeCount)\n{\n int i;\n int size;\n kr_build_heap(E, nEdgeCount);\n size = nEdgeCount - 1;\n for (i = size; i > 0; i--)\n edge_swap(&E[0], &E[i]);\n kr_heapify(E, 0, --size);\n return TRUE;\n}\n\n gboolean Kr_Heapify(EdgeList E, int i, int nNumEdges)\n{\n int l; /* index of the left value of node */\n int r; /* index of the right value of node*/\n int largest; /* index of the largest weight edge*/\n int nVertices = E->nVertices;\n int nNumEdges = E->nNumEdges;\n int p = i;\n int k = (i < nNumEdges) && (E[i].weight > E[largest].weight) ? i : largest;\n\n if ((p < nNumEdges) && (E[p].weight > E[k].weight))\n largest = p;\n else\n largest = k;\n\n if ((largest != i) && edge_swap(&E[largest], &E[i]));\n kr_heapify(E, largest, nNumEdges);\n\n gboolean kpc_mst(GraphRow* pGraph, int nVertices, GraphRow* pOutGraph,\n double* pdfTime)\n{\n int* p; /* Array of vertices for compression */\n int* rank; /* Ranks of these vertices */\n int nCost = 0; /* Cost of the tree */\n int u, v, k; /* Vertices examined at one time */\n int flag = TRUE; /* Edge list is not empty */\n int nEdgeCount = 0; /* Number of edges in the graph */\n\n for (int i = 0; i < nVertices; i++)\n for (int j = i; j < nVertices; j++)\n if (pGraph->adj[i][j] > 0)\n \n while (flag)\n \n return TRUE;\n}\n```c\n/**\n **** Allocate space for p and rank\n *****/\np = (int*)malloc(nVertices * sizeof(int));\nr = (int*)malloc(nVertices * sizeof(int));\n\n/**\n **** Count edges in the graph and allocate space for E\n *****/\nfor (v = 0; v < nVertices; v++)\n for (u = v + 1; u < nVertices; u++)\n if (pGraph[v][u] != 0) nEdgeCount++;\nE = (EdgeList*)malloc(nEdgeCount * sizeof(Edge));\n\n/**\n **** Collect all edges into the list\n *****/\nk = 0;\nfor (v = 0; v < nVertices; v++)\n for (u = v + 1; u < nVertices; u++)\n if (pGraph[v][u] != 0)\n { \n E[k].u = u;\n E[k].v = v;\n E[k].weight = pGraph[v][u];\n k++;\n }\n\n/*** Assuming that the output graph is already empty, we will proceed ***/\n**** with the algorithm\n******************************************************************************\n\n/**\n **** Take start time reading\n *****/\nftime(&tp);\ntStart = tp.time;\nunStart = tp.millisec;\n/*\ndfStartCPUtime = CPU_TIME;\n*/\nfor (v = 0; v < nVertices; v++)\n make_set(v, p, rank); /* Make set for every vertex */\n\n/*** Sort the edges by non-decreasing weight\n*****/\nkr_heapsort(E, nEdgeCount);\n```\n#include <stdio.h>\n#include <stdlib.h>\n#include <sys/types.h>\n#include <sys/time.h>\n#include <sys/timeb.h>\n#include \"krusk.h\"\n\n/**\n * COUNTING SORT IMPLEMENTATION\n */\n\nvoid edge_copy(Edge* e1, Edge* e2)\n{\n e1->u = e2->u;\n e1->v = e2->v;\n e1->weight = e2->weight;\n}\n\nvoid countSort(Edge A[], Edge B[], int nLength, int C[], int k)\n{\n int i, j;\n for (i = 0; i < k; i++)\n C[i] = 0;\n for (j = 0; j < nLength; j++)\n C[A[j].weight - 1]++;\n\n /**\n * C now contains the number of elements equal to i\n */\n for (i = 1; i < k; i++)\n C[i] += C[i - 1];\n\n /**\n * C now contains the number of elements less than or equal to i\n */\n for (j = nLength - 1; j >= 0; j--)\n C[A[j].weight - 1]--;\n }\n\n}\n\n/**\n * kcs_mst\n */\n\nint kcs_mst(GraphRow* pGraph, int nVertices, GraphRow* pOutGraph, int nLargest,\n double* pdfTime)\n{\n int* p;\n int* rank;\n int nCost = 0;\n int u, v, k;\n int nEdgeCount = 0;\n\n EdgeList E;\n EdgeList *Etemp;\n\n unsigned short unStarttime;\n unsigned short unEndtime;\n struct timeb tp;\n struct tms ruse;\n double dStartCPUtime;\n double dEndCPUtime;\n\n int* C;\n\n /**\n * Allocate space for p and rank\n */\n p = (int*)malloc(nVertices * sizeof(int));\n rank = (int*)malloc(nVertices * sizeof(int));\n\n /**\n * Count edges in the graph and allocate space for E\n */\n for (v = 0; v < nVertices; v++)\n for (u = v + 1; u < nVertices; u++)\n if (pGraph[v][u] != 0)\n E[nEdgeCount++] = 0;\n Etemp = (EdgeList*)malloc(nEdgeCount * sizeof(Edge));\n E = (EdgeList*)malloc(nEdgeCount * sizeof(Edge));\n\n C = (int*)malloc(nLargest * sizeof(int));\n\n /**\n * Collect all edges into the list\n */\n k = 0;\n for (v = 0; v < nVertices; v++)\n for (u = v + 1; u < nVertices; u++)\n if (pGraph[v][u] != 0)\n { Etemp[k].u = u;\n Etemp[k].v = v;\n Etemp[k].weight = pGraph[v][u];\n k++;\n }\n\n /**\n * Assuming that the output graph is already empty, we will proceed\n */\n\n}\n### krusk_cs.c\n\n```c\n**** with the algorithm\n*****************************/\n\n/****\n**** Take start time reading\n****/\n/*\nftime(&tp);\ntStartTime = tp.time;\nunStartTime = tp.millitm;\n*/\ndfStartCPUTime = CPUTIME;\n\nfor (v = 0; v < nVertices; v++)\n make_set(v, p, rank); /* Make set for every vertex */\n\n/****\n**** Sort the edges by non-decreasing weight\n*****/\ncountSort(E, nEdgeCount, C, nLargest);\n\n/****\n**** Iterate over the edges of E by non-decreasing weight\n*****/\nfor (k = 0; k < nEdgeCount; k++)\n{\n if (find_set(E[k].u, p) != find_set(E[k].v, p))\n {\n nCost += E[k].weight;\n pOutGraph[E[k].u][E[k].v] = E[k].weight;\n pOutGraph[E[k].v][E[k].u] = E[k].weight;\n kr_union(E[k].u, E[k].v, p, rank);\n }\n}\n\n/****\n**** MST is done - stop the timer\n*****/\n/*\nftime(&tp);\ntEndTime = tp.time;\nunEndTime = tp.millitm;\n*pdfTime = ((double)EndTime - (double)tStartTime) +\n ((double)unEndTime - (double)unStartTime) / 1000.0;\n*/\ndfEndCPUTime = CPUTIME;\n*pdfTime = dfEndCPUTime - dfStartCPUTime;\n\n/****\n**** We now completed the MST - release the allocated resources\n*****/\nfree(p);\nfree(rank);\nfree(E);\nfree(C);\nfree(Rtp);\n\nreturn nCost;\n\n******************************************************************************/\n#include \"MST.h\"\n\n******************************************************************************\n*** HEAP FUNCTIONS\n******************************************************************************\n\nFUNCTION: heaphify\n\n*** INPUT ARGUMENTS: HeapStruct* pHeap - pointer to the heap structure\n\n*** int i - index for which the heap is heaphified\n\n*** KeyArray key - array of keys for every vertex on the heap\n\n*** OUTPUT ARGUMENTS: NONE\n\n*** DESCRIPTION: This function ensures the heap property to be maintained on the heap.\n\n******************************************************************************\n\nvoid heaphify(HeapStruct* pHeap, int i, KeyArray key)\n{\n int l;\n /* left index */\n int r;\n /* right index */\n int smallest;\n /* vertex index with the smallest key */\n int tmp;\n /* emporary variable used in swapping values */\n\n l = LEFT(i); \n r = RIGHT(i);\n\n /* Find the vertex with the smallest value around i so it can be made a parent\n */\n smallest = (l < pHeap->size &&\n (key[pHeap->vertices[l]] < key[pHeap->vertices[i]])) ? l : i;\n if ((r < pHeap->size) &&\n (key[pHeap->vertices[r]] < key[pHeap->vertices[smallest]]))\n smallest = r;\n\n /* Make the smalles a parent */\n if (smallest != i)\n {\n tmp = pHeap->vertices[i];\n pHeap->vertices[i] = pHeap->vertices[smallest];\n pHeap->vertices[smallest] = tmp;\n\n /* Heaphify around the smallest to propogate */\n heaphify(pHeap, smallest, key);\n }\n}\n\n******************************************************************************\n\nFUNCTION: heap_sort\n\n*** INPUT ARGUMENTS: HeapStruct* pHeap - pointer to the heap structure\n\n*** KeyArray key - array of keys for every vertex on the heap\n\n*** OUTPUT ARGUMENTS: NONE\n\n*** DESCRIPTION: This function sorts the values of the heap using the heapsort\n\n******************************************************************************\n\nvoid heap_sort(HeapStruct* pHeap, KeyArray key)\n{\n int i;\n /* index into the heap value array */\n int tmp;\n /* temporary variable used in swapping values */\n\n heap_build(pHeap, key); /* build the heap fiirts */\n\n for (i = (pHeap->length - 1); i >= 1; i--)\n {\n tmp = pHeap->vertices[0];\n pHeap->vertices[0] = pHeap->vertices[i];\n pHeap->vertices[i] = tmp;\n heaphify(pHeap, 0, key);\n }\n}\n/* PRIORITY QUEUE FUNCTIONS */\n\n** FUNCTION: ** heap_extract_min\n\n** INPUT ARGUMENTS: **\nHeapStruct* pHeap - pointer to the heap structure\nKeyArray key - array of keys for every vertex on the heap\n\n** OUTPUT ARGUMENTS: **\nNONE\n\n** RETURNS: **\nint - the value with minimal key extracted or\nHEAP_ERR_UNDERFLOW if the heap is empty\n\n** DESCRIPTION: **\nThis function extracts the minimal value from the heap and ensures that the heap property is maintained.\n\nint heap_extract_min(HeapStruct* pHeap, KeyArray key)\n{\n int min; /* minimal value being extracted */\n\n if (pHeap->size < 1)\n return HEAP_ERR_UNDERFLOW;\n\n min = pHeap->vertices[0];\n pHeap->vertices[0] = pHeap->vertices[pHeap->size - 1];\n (pHeap->size)--;\n heapify(pHeap, 0, key);\n\n return min;\n}\n\n/* PRIORITY QUEUE FUNCTIONS */\n#include <stdio.h>\n#include <sys/types.h>\n// *include <sys/time.h>*/\n#include <sys/timeb.h>\n#include \"MST.h\"\n\n/***\n** FUNCTION: pbf_alloc_data_structs\n** INPUT ARGUMENTS: int nVertices - number of vertices\n** OUTPUT ARGUMENTS: PBFQueue* pQ - structure for priority queue\n** KeyArray* pKey - array of keys\n** PIArray* pPi - array of PI values\n** RETURNS: NOTHING\n** DESCRIPTION: This function allocates resources for the Q, PI, and Key arrays used by Prim's algorithm. The initial values are set by the algorithm itself. So the timings consider them as well.\n**\n** void pbf_alloc_data_structs(int nVertices, PBFQueue* pQ, KeyArray* pKey, PIArray* pPi)\n**\n** Allocate space for the priority queue\n**\n/**\n* (pQ) = (PBFQueue *)malloc(sizeof(PBFQueue));\n* (pQ)->nVertices = (int *)malloc(nVertices * sizeof(int));\n/**\n** Allocate space for the KEY array\n**\n/**\n* (pKey) = (int *)malloc(nVertices * sizeof(int));\n/**\n** Allocate space for the PI array\n**\n/**\n* (pPi) = (int *)malloc(nVertices * sizeof(int));\n** for (i = 0; i < nVertices; i++)\n** { ((pQ)->nVertices)[i] = NIL;\n** (pPi)[i] = NIL\n** (pKey)[i] = INFINITY;\n** }\n**\n**/******\n***/\n\n/***\n** FUNCTION: pbf_is_in_que\n** INPUT ARGUMENTS: int vertex - vertex sought in queue\n** PBFQueue* Q - queue in which vertex is sought\n** OUTPUT ARGUMENTS: NONE\n** RETURNS: int - 1 if the specified vertex is in queue; 0 otherwise\n** DESCRIPTION: This function determines if the vertex specified via the argument 'vertex' is in queue specified via the argument 'Q'.\n**\n** int pbf_is_in_que(int vertex, PBFQueue* Q)\n**\n** Index into the queue */\n\n/******\n*/\n\n```c\nvoid pbf_alloc_data_structs(int nVertices, PBFQueue* pQ, KeyArray* pKey, PIArray* pPi)\n{\n int i;\n /* Index into arrays for initialization */\n\n /* Allocate space for the priority queue */\n (*pQ) = (PBFQueue *)malloc(sizeof(PBFQueue));\n (*pQ)->nVertices = (int *)malloc(nVertices * sizeof(int));\n\n /* Allocate space for the KEY array */\n (*pKey) = (int *)malloc(nVertices * sizeof(int));\n\n /* Allocate space for the PI array */\n (*pPi) = (int *)malloc(nVertices * sizeof(int));\n for (i = 0; i < nVertices; i++)\n {\n ((pQ)->nVertices)[i] = NIL;\n (pPi)[i] = NIL\n (pKey)[i] = INFINITY;\n }\n\n /* Index into the queue */\n}\n```\n\n```c\nint pbf_is_in_que(int vertex, PBFQueue* Q)\n{\n int i = 0;\n /* Index into the queue */\n\n /* This function determines if the vertex specified via the argument 'vertex' is in queue specified via the argument 'Q'. */\n```\n# prmbf.c\n\n**** We have now found the minimal vertex. Extract it ****\n\n```c\nif (j := NIL)\n \n min = Q->vertices[j];\n Q->vertices[j] = NIL;\n Q->size--;)\n return min;\n```\n\n****\n\n```c\n\n/**********************************************************************\n\n*** MST\n\n/**********************************************************************\n\n****\n\n```\n08/02/98\n19:13:31\n\nprimef.c\n\n****\n**** Take start time reading\n****/\n/*\nftime(&tp);\ntStart = tp.time;\nunStart = tp.mallitm;\n*/\ndfStartCPUtime = CPUtime;\n\n****\n**** put all vertices onto the queue - Use only connected ones. The size\n**** member of the queue is used to account for the number of vertices\n**** put onto the queue\n****/\nQ->head = 0;\nQ->size = 0;\nu = 0;\nwhile (u < nVertices)\n{\n /*\n **** Search for the first connected vertex to determine if it goes onto\n **** the queue\n ****/\n v = 0;\n while ((v < nVertices) && (pGraph[u][v] == 0))\n v++;\n /*\n **** See what stopped the loop\n ****/\n if (v < nVertices)\n {\n /*\n **** The vertex is connected. put it onto the queue\n ****/\n Q->vertices[Q->head] = u;\n (Q->size)+=\n (Q->head)+=\n }\n u++;\n}\n\n****\n**** Make sure that the number of connected vertices is at least 2.\n****/\nif (Q->size < 2)\n{\n pbf_free_data_structs(&Q, &key, &Pi);\n return NOT_ENOUGH_CONNECTED_VERTICES;\n} else\n Q->length = Q->size;\n\n****\n**** We now have all vertices on the queue - set the key for each vertex to\n**** INFINITY\n****/\nfor (Q->head = 0; Q->head < Q->size; (Q->head)+=)\n { u = Q->vertices[Q->head];\n key[u] = INFINITY;\n }\n\n****\n**** Assume r is the first entry in the Queue - set its key to 0 and its PI\n****\n#include <stdio.h>\n#include <sys/types.h>\n/*#include <sys/time.h>*/\n#include <sys/timeb.h>\n#include \"MST.h\"\n\n***** PRIORITY QUEUE FUNCTIONS *****\n\n\n **** FUNCTION: php_alloc_data_structs ****\n **** INPUT ARGUMENTS: int nVertices - number of vertices ****\n **** OUTPUT ARGUMENTS: PBFQueue* pQ - structure for priority queue ****\n **** RETURNS: NOTHING ****\n **** DESCRIPTION: This function allocates resources for the Q, PI, and Key arrays used by Prims algorithm. The initial values are set by the algorithm itself, so the timings consider them as well.\n\nvoid php_alloc_data_structs(int nVertices, PBFQueue* pQ, KeyArray* pKey, PIArray* pPI)\n{\n int i;\n /* Index into arrays for initialization */\n\n /* Allocate space for the priority queue */\n (*pQ) = (PBFQueue *)malloc(sizeof(PBFQueue));\n (*pQ)->vertices = (int *)malloc(nVertices * sizeof(int));\n\n /* Allocate space for the KEY array */\n (*pKey) = (int *)malloc(nVertices * sizeof(int));\n\n /* Allocate space for the PI array */\n (*pPI) = (int *)malloc(nVertices * sizeof(int));\n for (i = 0; i < nVertices; i++)\n {\n (*pQ)->vertices[i] = NIL;\n (*pPI)[i] = NIL;\n (*pKey)[i] = INFINITY;\n }\n}\n\n\n **** FUNCTION: php_is_in_que ****\n **** INPUT ARGUMENTS: int vertex - vertex sought in queue ****\n **** OUTPUT ARGUMENTS: PBFQueue* Q - queue in which vertex is sought ****\n **** RETURNS: int - 1 if the specified vertex is in queue 0 otherwise ****\n **** DESCRIPTION: This function determines if the vertex specified via the argument 'vertex' is in queue specified via the argument 'Q'.\n\nint php_is_in_que(int vertex, PBFQueue* Q)\n{\n int i = 0;\n /* Index into the queue */\n\n/**\n * Search exhaustively until the vertex is either found or not\n */\nif (Q->size <= 0) \nreturn 0;\nwhile ((i < Q->size) && (vertex != Q->vertices[i])) i++;\n/**\n * See what stopped the loop and return accordingly\n */\nif (i >= Q->size) \nreturn 0;\nreturn (Q->vertices[i] == vertex);\n*/\n\nprimhp.c\n\ndouble dfEndCPUtil;\n\n/*******************************/\n\nMST\n\nFUNCTION:\n\n**\n ***\n *** INPUT ARGUMENTS:\n ***\n *** int nVertices - number of vertices\n ***\n *** OUTPUT ARGUMENTS:\n ***\n *** double* pdfTime - time it took to get MST\n ***\n *** RETURNS:\n ***\n *** DESCRIPTION:\n ***\n *** This function finds a MST in the graph supplied via the pGraph argument. The\n *** Prim's algorithm is used using the BRUTE ***\n *** force to extract the minimum vertex from ***\n *** the priority queue.\n ***\n\nint php_mst(GraphRow* pGraph, int nVertices, GraphRow* pOutGraph, \ndouble* pdfTime)\n{\n PBQueue* Q; /* Priority Queue */\n KeyArray key; /* Keys */\n PAArray p; /* P */\n int u, v, k; /* Vertices examined at one time */\n int nCost = 0; /* Cost of the tree */\n int tmp; /* Temporary storage for swapping */\n int curNode; /* Node currently looked at */\n int i;\n\n unsigned short unStartTime; /* Start time milliseconds part */\n unsigned short unEndTime; /* End time milliseconds part */\n time_t tStart; /* Start time seconds part */\n time_t tEnd; /* End time seconds part */\n struct timeb tp; /* Time structure */\n struct rusage ruse;\n double dfStartCPUtil;\n\n double dfEndCPUtil;\n /* allocate resources for the queue, pi, and key arrays */\n php_alloc_data_structs(nVertices, &Q, &key, &p);\n /*\n * take start time reading\n */\n ftime(&tp);\n tStartTime = tp.time;\n unStartTime = tp.millisim;\n /*\n * dfStartCPUtil = CPUtil;\n */\n /**\n * put all vertices onto the queue - use only connected ones. the size\n * member of the queue is used to account for the number of vertices\n * put onto the queue\n */\n Q->head = 0;\n Q->size = 0;\n u = 0;\n while (u < nVertices)\n {\n /**\n * search for the first connected vertex to determine if it goes onto\n * the queue\n */\n v = 0;\n while ((v < nVertices) && (pGraph[u][v] == 0)) \n v++;\n /**\n * see what stopped the loop\n */\n if (v < nVertices)\n {\n /**\n * the vertex is connected, put it onto the queue\n */\n Q->vertices[Q->size] = u;\n (Q->size)++;\n (Q->head)++;\n }\n u++;\n }\n /**\n * make sure that the number of connected vertices is at least 2.\n * if (Q->size < 2)\n {\n php_free_data_structs(&Q, &key, &p);\n return NOT_ENOUGH_CONNECTED_VERTICES;\n }\n else\n Q->length = Q->size;\n /**\n * we now have all vertices on the queue - set the key for each vertex to\n * infinity\n */\nfor (Q->head = 0; Q->head < Q->size; (Q->head)++)\n{\n u = Q->vertices[Q->head];\n key[u] = INFINITY;\n}\n\n/**\n ** Assume r is the first entry in the Queue - set its key to 0 and its PI\nto NIL:\n**/\n\nu = Q->vertices[0];\nkey[u] = 0;\nPi[u] = NIL;\n\nheap_build(Q, key);\n\n/>**** Begin iteration over the queue looking for edges\n**** /\nwhile (Q->size > 0)\n{\n /*\n ** If there is a retained edge, add it to the graph\n **/\n u = heap_extract_min(Q, key);\n /*\n ** Iterate over all vertices adjacent to u\n **/\n for (k = 0; k < Q->size; k++)\n {\n v = Q->vertices[k];\n if ((u == v) && (pGraph[u][v] != 0) && (pGraph[u][v] < key[v]))\n {\n Pi[v] = u;\n key[v] = pGraph[u][v];\n /*\n ** Fix the heap\n **/\n curNode = k;\n while ( (curNode != 0) && (key[Q->vertices[PARENT[curNode]]]) <\n key[Q->vertices[curNode]])\n {\n tmp = Q->vertices[curNode];\n Q->vertices[curNode] = Q->vertices[PARENT[curNode]];\"\n Q->vertices[PARENT[curNode]] = tmp;\n curNode = PARENT(curNode);\n }\n }\n }\n /*\n ** for (i = (Q->size / 2) - 1; i >= 0; i--)\n ** heapify(Q, i, key);\n */\n /*\n ** heapify(Q, 0, key), */\n }\nunsigned short unEndTime; /* End time milliseconds part */\ntime_t tStartTime; /* Start time seconds part */\ntime_t tEndTime; /* End time seconds part */\nstruct timeb tp; /* Time structure */\ndouble dfStartCPUTime;\ndouble dfEndCPUTime;\nstruct rusage ruse;\n\n/**\n *** Allocate resources for the queue, pi, and key arrays\n /***/\nphp_alloc_data_structs(nVertices, &Q, &key, &pi);\n\n/**\n *** Take start time reading\n /***/\n/*\ntStart_time = tp_time;\nunStart_time = tp.milliitm;\n*/\n/**\n *** Put all vertices onto the queue - Use only connected ones. The size\n *** member of the queue is used to account for the number of vertices\n *** put onto the queue\n /***/\nQ->head = 0;\nQ->size = 0;\nu = 0;\nwhile (u < nVertices)\n{\n /*\n *** Search for the first connected vertex to determine if it goes onto\n *** the queue\n /***/\n v = 0;\n while (((v < nVertices) && (pGraph[u][v] == 0))\n v++;\n /*\n *** See what stopped the loop\n /***/\n if (v < nVertices)\n {\n /*\n *** The vertex is connected, put it onto the queue\n /***/\n Q->vertices[Q->head] = u;\n (Q->size)++;\n (Q->head)++;\n }\n u++;\n}\n\n/**\n *** Make sure that the number of connected vertices is at least 2.\n ***/\nif (Q->size < 2)\n{\n php_free_data_structs(&Q, &key, &pi);\n return NOT_ENOUGH_CONNECTED_VERTICES;\n} else\n Q->length = Q->size;\n\nprimhp.c\n\n/**\n *** We Now have all vertices on the queue - set the key for each vertex to\n *** INFINITY\n ***/\nfor (Q->head = 0; Q->head < Q->size; (Q->head)++)\n{\n u = Q->vertices[Q->head];\n key[u] = INFINITY;\n}\n\n/**\n *** Assume r is the first entry in the Queue - set its key to 0 and its PI\n *** to NIL\n ***/\nu = Q->vertices[0];\nkey[u] = 0;\npi[u] = NIL;\nheap_build(Q, key);\n\n/**\n *** Begin iteration over the queue looking for edges\n ***/\nwhile (Q->size > 0)\n{\n /*\n *** If there is a retained edge, add it to the graph\n ***/\n u = heap_extract_min(Q, key);\n /*\n *** Iterate over all vertices adjacent to u\n ***/\n for (k = 0; k < Q->size; k++)\n {\n v = Q->vertices[k];\n if (((u != v) && (pGraph[u][v] != 0)) && (pGraph[u][v] < key[v]))\n {\n Pi[v] = u;\n key[v] = pGraph[u][v];\n }\n }\n for (i = (Q->size / 2) - 1; i >= 0; i--)\n heapify(Q, i, key);\n /*\n heapify(Q, 0, key); /*\n}\n\n/**\n *** We should now have the MST!!!!\n *** Take the end time reading\n ***/\n/*\ntStart_time = tp_time;\nunEnd_time = tp.milliitm;\n*pdfTime = (double)tEnd_time - (double)tStart_time +\n((double)unEnd_time - (double)unStart_time) / 1000.0;\n*/\ndfEndCPUTime = CfUTIME;\npdfTime = dfEndCPUTime - dfStartCPUTime;\n\n/**\n *** Reconstruct the output tree\n ***/\nfor (u = 0; u < nVertices; u++)\nif (Pi[u] != NIL)\n nCost += pOutGraph[Pi[u]][u] = pOutGraph[u][Pi[u]] = pGraph[u][Pi[u]];\n\n/*\n **** Clean up\n *****/\nphp_free_data_structs(&Q, &key, &Pl);\nreturn nCost;\n}*/\n\nprimhp.c\n```c\n/** DATA STRUCTURE MANAGEMENT FUNCTIONS */\n\nFUNCTION: pbh_alloc_data_structs\nINPUT ARGUMENTS: int nVertices - number of vertices\nOUTPUT ARGUMENTS: short** aInQueFlags - flags if the vertex is in the queue\nBinKeyPtrArray* pKey - array of pointers which contain nodes to heaps\nPIArray* pPi - array of PI values\nNodeStore* pStore - store for the nodes that are to be used for the binomial heap implementation\n\nRETURNS: NOTHING\n\nDESCRIPTION: This function allocates resources for the Binomial Heap, an array of flags which indicates whether the vertex is in the queue, and array of parent nodes, and the actual node store.\n\nvoid pbh_alloc_data_structs(int nVertices, short** aInQueFlags, BinKeyPtrArray* pKey, PIArray* pPi, NodeStore* pStore)\n{\n int i; /* Index into arrays for initialization */\n /* Allocate space for the array of flags */\n *aInQueFlags = (short *)malloc(nVertices * sizeof(short));\n /* Allocate space for the KEY array */\n *pKey = (BinNode*)malloc(nVertices * sizeof(BinNode));\n /* Create the nodes for the binomial heap usage */\n *pStore = (NodeStore*)malloc(sizeof(NodeStore));\n NodeStore_create(nVertices, *pStore);\n /* \n*/\n}\n\nFUNCTION: pbh_free_data_structs\nINPUT ARGUMENTS: NONE\nOUTPUT ARGUMENTS: short** aInQueFlags\nBinKeyPtrArray* pKey - array of pointers which contain nodes to heaps\nPIArray* pPi - array of PI values\nNodeStore* pStore - store for the nodes that are to be used for the binomial heap implementation\n\nRETURNS: NOTHING\n\nDESCRIPTION: This function releases resources used by the datastructures in the Prim's algorithm.\n\nvoid pbh_free_data_structs(short** aInQueFlags, BinKeyPtrArray* pKey, PIArray* pPi, NodeStore* pStore)\n{\n /* Release all array resources */\n free(*aInQueFlags);\n *aInQueFlags = NULL;\n /* \n*/\n /* Destroy the node store */\n NodeStore_destroy(*pStore);\n free(*pStore);\n /* \n*/\n /* Release PI and Key resources */\n free(*pKey);\n free(*pPi);\n *pKey = NULL;\n *pPi = NULL;\n}\n```\nprimbh.c\n\nNodeStore nodeStore; /* Store of pointers */\nPBinQueue pQueue; /* Pointer to binomial queue */\nunsigned short unStartTime; /* Start time milliseconds part */\nunsigned short unEndTime; /* End time milliseconds part */\ntime_t tStart, tEnd; /* Start and end time seconds part */\nstruct timeb tp; /* Time structure */\nint nErrCode; /* User for debugging */\n\nstruct usage ruse;\ndouble dfStartCPUtime;\ndouble dfEndCPUtime;\n\n/*** Allocates data structures */\nNodeStore_create(nVertices, &nodeStore);\npQueue = BinQueue_make(nVertices);\nPI = (PIArray)malloc(nVertices * sizeof(int));\n\n/*** Take start time reading */\n\n*time(&tp);\ntStart = tp.time;\nunStart = tp.milliTime;\n\n/*** dfStartCPUtime = CPUtime; */\n\n/*** Put all vertices onto the queue - Use only connected ones. The size of the queue is used to account for the number of vertices put onto the queue */\n\nfor (u = 0; u < nVertices; u++)\n{\n /* Search for the first connected vertex to determine if it goes onto the queue */\n v = 0;\n while ((v < nVertices) & (pGraph[u][v] == 0))\n {\n v++;\n }\n /* See what stopped the loop */\n if (v < nVertices)\n {\n /* The vertex is connected, queue it up */\n pNode = NodeStore_alloc(&nodeStore);\n pNode->unVert = u;\n if (nVertCount == 0)\n {\n pNode->nKey = 0;\n pRootVertex = pNode;\n }\n pQueue = BinQueue_insert(pQueue, pNode, &nErrCode);\n nVertCount++;\n }\n\n/***/\n\n**** FUNCTION: pnh_mst\n\n**** INPUT ARGUMENTS:\nGraphRow* pGraph - input graph\n***\nint nVertices - number of vertices\n***\n\n**** OUTPUT ARGUMENTS:\nGraphRow* pOutGraph - output graph\n***\n\n**** RETURNS:\nint - Total cost of the MST\n***\n\n**** DESCRIPTION:\nThis function finds a MST in the graph supplied via the pGraph argument. The Prim's algorithm is used using the BRUTE force to extract the minimum vertex from the priority queue.\n\n****\n\nint pnh_mst(GraphRow* pGraph, int nVertices, GraphRow* pOutGraph, double* pdfTime)\n{\n PIArray PI; /* PI's */\n\n int u, v, k; /* Vertices examined at one time */\n int nCost = 0; /* Cost of the tree */\n int tmp; /* Temporary storage for swapping */\n int curNode; /* Node currently looked at */\n int nVertCount = 0; /* Counter of connected vertices */\n PBinNode pNode; /* Node that was extracted */\n PBinNode pRootVertex; /* Root vertex */\n/**\n * Make sure that the number of connected vertices is at least 2.\n */\nif (nVertCount < 2)\n{\n NodeStore_destroy(&nodeStore);\n BinQueue_destroy(&apQueue);\n free(Pi);\n return NOT_ENOUGH_CONNECTED_VERTICES;\n}\n/**\n * Assume r is the first entry in the Queue - set its key to 0 and its PI\nto NIL\n */\nu = pRootVertex->unVert;\nP[0] = NIL;\n/**\n * Begin iteration over the queue looking for edges\n */\nwhile ((pNode = BinQueue_extractMin(pQueue)) != NULL)\n{\n u = pNode->unVert;\n /**\n * Iterate over all vertices adjacent to u\n */\n for (v = 0; v < nVertices; v++)\n {\n if (v != u && (pQueue->lnQueue[v] && (pGraph[u][v] != 0) &&\n (pGraph[u][v] < pQueue->apVertexNodes[v]->nKey))\n {\n P[v] = u;\n BinQueue_decreaseKey(pQueue, v, pGraph[u][v]);\n }\n }\n /**\n * We should now have the MST!!!\n * Take the end time reading\n */\n //\n tStart = tp.time;\n unEndTime = tp.millisecond;\n *pdfTime = ((double)tEndTime - (double)tStartTime) +\n ((double)unEndTime - (double)unStartTime) / 1000.0;\n //\n dfEndCPUTime = CPUTCUTIME;\n *pdfTime = dfEndCPUTime - dfStartCPUTime;\n\n /**\n * Reconstruct the output tree\n */\n for (u = 0; u < nVertices; u++)\n {\n if (P[u] != NIL)\n {\n nCost = pOutGraph[P[u]][u] = pOutGraph[u][P[u]] = pGraph[u][P[u]];\n }\n }\n /**\n * Clean up\n */\n#include \"BinHeap.h\"\n\nFUNCTION: NodeStore_create\n***\n*** INPUT ARGUMENTS: int size - size of the store to be created\n***\n*** OUTPUT ARGUMENTS: NodeStore* pStore - node store created\n***\n*** RETURNS: BOOL - TRUE if successful, FALSE if failed\n***\n*** DESCRIPTION: This function allocates memory necessary for the\n*** nodes of the binomial heap. The allocated\n*** memory is to be used for the \"allocation\" of\n*** nodes.\n***\nBOOL NodeStore_create(int size, NodeStore* pStore)\n{\nint i; /* Array index */\n\n *** First, allocate space for the actual nodes.\n ***\n if ((pStore->aNodes = (PBinNode)malloc(size * sizeof(BinNode))) == NULL)\n return FALSE;\n\n *** Now that the nodes are allocated, we allocate space to hold pointers\n *** to each\n ***\n if ((pStore->aNodes = (PBinNode *)malloc(size * sizeof(PBinNode))) == NULL)\n {\n free(pStore->aNodes);\n return FALSE;\n }\n\n *** Everything is allocated. Now we set pointers and initialize values\n ***\n for (i = 0; i < size; i++)\n {\n pStore->aNodes[i] = &pStore->aNodes[i]; /* set the pointer */\n pStore->aNodes[i].nKey = INFINITY;\n pStore->aNodes[i].pParent = NULL;\n pStore->aNodes[i].pSibling = NULL;\n pStore->aNodes[i].pLeftChild = NULL;\n }\n\n pStore->numNodes = size;\n pStore->top = 0;\n\n *** Done\n return TRUE;\n}\n\nFUNCTION: NodeStore_destroy\n***\n*** INPUT ARGUMENTS: NodeStore* pStore - node store destroyed\n***\n*** OUTPUT ARGUMENTS: NONE\n***\n*** RETURNS: NOTHING\n***\n*** DESCRIPTION: This function releases memory allocated for the\n*** binomial heaps.\n***\nvoid NodeStore_destroy(NodeStore* pStore)\n{\n free(pStore->aNodes);\n free(pStore->aNodes);\n}\n\nFUNCTION: NodeStore_alloc\n***\n*** INPUT ARGUMENTS: NodeStore* pStore - node store from which the\n*** node is to be allocated\n***\n*** OUTPUT ARGUMENTS: NONE\n***\n*** RETURNS: PBinNode - pointer to binomial heap node. NULL\n*** if this operation fails.\n***\n*** DESCRIPTION: This function allocates a node from the store and\n*** returns a pointer to it. If this operation\n*** fails, NULL is returned\n***\nPBinNode NodeStore_alloc(NodeStore* pStore)\n{\n *** Check if nodes are available for allocation\n ***\n if (pStore->top >= pStore->numNodes)\n return NULL;\n\n *** Get the next node and return a pointer to it, move the top down\n ***\n return pStore->aNodes[(pStore->top++)];\n}\nBinHeap.c\n\n/*\n * FUNCTION: NodeStore_free\n * INPUT ARGUMENTS: PBinNode* node - pointer to the pointer that\n * points to node to be freed\n * OUTPUT ARGUMENTS: NONE\n * DESCRIPTION: This function returns the allocated node back to\n * the store.\n */\n\nvoid NodeStore_free(PBinNode* node, NodeStore* pStore)\n{\n pStore->top--; \n pStore->pNodes[pStore->top] = *node; \n *node = NULL;\n}\n\n/*\n * FUNCTION: BinQueue_make\n * INPUT ARGUMENTS: int nVertices\n * OUTPUT ARGUMENTS: PBinQueue pQueue\n * DESCRIPTION: This function creates a new queue.\n */\n\nPBinQueue BinQueue_make(int nVertices)\n{\n int i;\n PBinQueue pQueue; \n pQueue = (PBinQueue)malloc(sizeof(BinQueue)); \n pQueue->nTrees = floor(log2((double)nVertices)) + 1; \n pQueue->nTrees = (BinTree*)malloc(pQueue->nTrees * sizeof(BinTree)); \n for (i = 0; i < pQueue->nTrees; i++) \n pQueue->aTrees[i] = NULL;\n pQueue->aTrees = (PBinNode**)malloc(nVertices * sizeof(PBinNode)); \n pQueue->aQueue = (BOOL*)malloc(nVertices * sizeof(BOOL)); \n for (i = 0; i < nVertices; i++) \n pQueue->aQueue[i] = FALSE; \n pQueue->aQueue = (PBinNode**)malloc(nVertices * sizeof(PBinNode));\n\n pQueue->nCapacity = nVertices; \n pQueue->nCurrentSize = 0; \n pQueue->nMin = BINQUEUE_QUEUE_IS_EMPTY;\n return pQueue;\n}\n\nvoid BinQueue_destroy(PBinQueue* ppQueue)\n{\n free(pQueue->aTrees);\n free(pQueue->aQueue);\n free(pQueue->aVertices);\n free(pQueue);\n}\n\nBinTree BinQueue_combineTrees(BinTree t1, BinTree t2)\n{\n if (t1->nKey > t2->nKey) \n return BinQueue_combineTrees(t2, t1);\n t2->pSibling = t1->pLeftChild;\n t2->pParent = t1;\n t1->pLeftChild = t2;\n return t1;\n}\n\nPBinQueue BinQueue_merge(PBinQueue h1, PBinQueue h2, int nCapacity, \n int* pnErrCode)\n{\n BinTree t1, \n BinTree t2, \n BinTree carry = NULL;\n int i, j;\n if ((*pnErrCode = (h1->nCurrentSize + h2->nCurrentSize > nCapacity) \n ? BINQUEUE_SIZE_OVERFLOW \n : BINQUEUE_OK) != BINQUEUE_OK)\n return h1;\n h1->nCurrentSize += h2->nCurrentSize;\n for (i = 0; j = 1; j <<= h1->nCurrentSize; i++, j *= 2) \n t1 = h1->aTrees[i]; \n t2 = h2->aTrees[i];\n switch (!!t1 + 2 * !!t2 + 4 * !!carry) \n { \n case 0: \n /* No Trees */ \n break;\n case 1: \n /* Only h1 */ \n break;\n case 2: \n /* Only h2 */ \n if ((h1->nMin == -1) \n && (h1->aTrees[h1->nMin]->_key > t2->_key)) \n h1->nMin = i;\n break;\n case 3: \n /* h1 and h2 */ \n carry = BinQueue_combineTrees(t1, t2);\n h1->aTrees[i] = carry;\n break;\n case 4: \n /* Only carry */ \n if ((h1->nMin == -1) \n && (h1->aTrees[h1->nMin]->_key > carry->_key)) \n h1->nMin = i;\n break;\n }\n return h1;\n}\nBinHeap.c\n\nfor (j = nMinInd - 1; j >= 0; j--)\n{\n pDeletedQueue->aTrees[j] = pDeletedTree;\n pDeletedTree = pDeletedTree->pSibling;\n pDeletedQueue->aTrees[j]->pSibling = NULL;\n}\n\nh->aTrees[nMinInd] = NULL;\n\nh->mCurrentSize += pDeletedQueue->mCurrentSize + 1;\n\nh = BinQueue_merge(h, pDeletedQueue, h->mCapacity, &nErrCode);\n\nBinQueue_destroy(&pDeletedQueue);\n\nh->aInQueue[p0ldRoot->unVert] = FALSE;\nh->apVertexNodes[p0ldRoot->unVert] = NULL;\n\nreturn p0ldRoot;\n\n}\n\nPBinQueue BinQueue_insert(PBinQueue h, PBinNode n, int* pnErrCode)\n{\n PBinQueue pTmpQueue;\n\n /**\n *** Make sure that the node is not already in the tree\n *** /\n if (h->aInQueue[n->unVert])\n {\n *pnErrCode = BINQUEU_VERTEX_DUPLICATION;\n else\n {\n pTmpQueue = BinQueue_make(h->mCapacity);\n pTmpQueue->mCurrentSize = 1;\n pTmpQueue->aTrees[0] = n;\n pTmpQueue->apVertexNodes[n->unVert] = n;\n pTmpQueue->aInQueue[n->unVert] = TRUE;\n pTmpQueue->mMin = 0;\n\n h = BinQueue_merge(h, pTmpQueue, h->mCapacity, pnErrCode);\n BinQueue_destroy(&pTmpQueue);\n h->aInQueue[n->unVert] = TRUE;\n }\n return h;\n }\n\n int BinQueue_min(PBinQueue h)\n {\n int i;\n int nMinInd = BINQUEU_QUEUE_IS_EMPTY;\n int nMin = INFINITY;\n\n for (i = 0; i < h->mTrees; i++)\n {\n if ((h->aTrees[i] != NULL) && (h->aTrees[i]->nKey < nMin))\n {\n nMin = h->aTrees[i]->nKey;\n nMinInd = i;\n }\n }\n return nMin;\n }\n\nPBInode BinQueue_extractMin(PBinQueue h)\n{\n int i, j;\n int nMinTree;\n PBinQueue pDeletedQueue;\n Position pDeletedTree;\n Position pOldRoot;\n Position pCurSib;\n PBinNode pMinNode;\n int nErrCode;\n int nMinInd;\n\n if (h->mCurrentSize == 0)\n return NULL;\n\n nMinInd = BinQueue_min(h);\n\n pDeletedTree = h->aTrees[nMinInd];\n pOldRoot = pDeletedTree;\n pDeletedTree = pDeletedTree->pLeftChild;\n\n /**\n *** Make sure the parent pointers of the nodes descending from the node\n *** deleted are all NULL\n *** /\n pCurSib = pDeletedTree;\n while (pCurSib != NULL)\n {\n pCurSib->pParent = NULL;\n pCurSib = pCurSib->pSibling;\n }\n\n pDeletedQueue = BinQueue_make(h->mCapacity);\n pDeletedQueue->mCurrentSize = (1 << nMinInd) - 1;\n```c\nint BinQueue_decreaseKey(BinQueue h, int unVert, int nKey)\n{\n BinNode pCurNode; /* Node being decreased */\n BinNode pParentNode; /* Parent node of node being decreased */\n BinNode pTmp; /* Temporary pointer to nodes */\n int nTmpKey;\n unsigned int unTmpVert;\n int nTmpDegree;\n\n *** Make sure we are working with a valid vertex\n ***\n if (((h->aInQueue[unVert]) || (h->apVertexNodes[unVert] == NULL))\n return BINQUEUE_VERTEX_NOT_IN_QUEUE;\n else if (nKey > h->apVertexNodes[unVert]->nKey)\n return BINQUEUE_DECREASE_TO_GREATER_VALUE;\n\n *** Begin decrease procedure\n ***\n pCurNode = h->apVertexNodes[unVert]; /* Get pointer to node decreased */\n pParentNode = pCurNode->pParent; /* Get pointer to the parent node */\n pCurNode->nKey = nKey; /* Assign new key value to that node */\n\n *** 'Bubble Up'\n ***\n while ((pParentNode != NULL) && (pCurNode->nKey < pParentNode->nKey))\n {\n *** Exchange the key and all satellite fields\n ***\n nTmpKey = pCurNode->nKey;\n pCurNode->nKey = pParentNode->nKey;\n pParentNode->nKey = nTmpKey;\n\n unTmpVert = pCurNode->unVert;\n pCurNode->unVert = pParentNode->unVert;\n pParentNode->unVert = unTmpVert;\n\n nTmpDegree = pCurNode->nDegree;\n pCurNode->nDegree = pParentNode->nDegree;\n pParentNode->nDegree = nTmpDegree;\n\n *** Update the list of vertex pointers\n ***\n\n *** 'Bubble up'\n ***\n pCurNode = pParentNode->pParent;\n pParentNode = pParentNode->pParent;\n }\n return BINQUEUE_OK;\n}\n```\n```c\n08/02/98\n19:19:02\n\n#include <stdio.h>\n#include <sys/types.h>\n#include <sys/time.h>\n#include \"FibHeap.h\"\n\nprimfh.c\n\n/**\n *** Allocate data structures\n ***\n FibNodeStore_create(nVertices, &nodeStore);\nPQueue = FibHeap_make(nVertices);\nPii = (PIArray)malloc(nVertices * sizeof(int));\n/**\n *** Take start time reading\n */\nftime(&tp);\ntStart = tp.time;\nunStart = tp.millisecond;\n/**\ndaStartCPUtime = CPUtime;\n/**\n *** Put all vertices onto the queue - Use only connected ones. The size\n *** member of the queue is used to account for the number of vertices\n *** put onto the queue\n */\nfor (u = 0; u < nVertices; u++)\n{\n *** Search for the first connected vertex to determine if it goes onto\n *** the queue\n ***\nv = 0;\nwhile ((v < nVertices) && (pGraph[u][v] == 0))\n v++;\n/**\n *** See what stopped the loop\n ***/\nif (v < nVertices)\n{\n *** The vertex is connected, queue it up\n ***\npNode = FibNodeStore_alloc(&nodeStore);\npNode->xVert = u;\nif (nVertCount == 0)\n{\n pNode->xKey = 0;\npRootVertex = pNode;\n}\nPQueue = FibHeap_insert(PQueue, pNode);\nnVertCount++;\n}\n/**\n *** Make sure that the number of connected vertices is at least 2.\n ***/\nif (nVertCount < 2)\n{\n FibNodeStore_destroy(&nodeStore);\nFibHeap_destroy(PQueue);\nfree(Pii);\nreturn NOTEnoughCONNECTED_VERTEXES;\n}\n/**\n *** Assume r is the first entry in the Queue - set its key to 0 and its PI\n ***\n...\n08/02/98\n19:19:02\n\nprimfh.c\n\n/**\n * u = pRootVertex->unVert;\n * Pi[u] = NIL;\n */\n\n/*** Begin iteration over the queue looking for edges\n ***/\nwhile ((pNode = FibHeap_extractMin(pQueue)) != NULL) {\n u = pNode->unVert;\n\n /**\n * Iterate over all vertices adjacent to u\n ***/\n for (v = 0; v < nVertices; v++) {\n if ((v != u) && (pQueue->aInQueue[v]) && (pGraph[u][v] == 0) &&\n (pGraph[u][v] < pQueue->aVertices[v]->nKey)) {\n Pi[v] = u;\n FibHeap_decreaseKey(pQueue, v, pGraph[u][v]);\n }\n }\n\n /**\n * We should now have the MST!!!!\n * Take the end time reading\n ***/\n\n /*\n * ftime(&tp);\n * tEndTime = tp.time;\n * unEndTime = tp.millis;\n * pdtTime = ((double)tEndTime - (double)tStartTime) +\n ((double)unEndTime - (double)unStartTime) / 1000.0;\n */\n dEndCPuTime = CPUTime;\n pdtTime = dEndCPuTime - dStartCPuTime;\n\n /**\n * Reconstruct the output tree\n ***/\n for (u = 0; u < nVertices; u++) {\n if (Pi[u] != NIL)\n nCost += pOutGraph[Pi[u]][u] * pOutGraph[u][Pi[u]] = pGraph[u][Pi[u]];\n }\n\n /**\n * Clean up\n ***/\n FibNodeStore_destroy(&nodeStore);\n FibHeap_destroy(&pQueue);\n free(Pi);\n\n return nCost;\n}\n\n**************************************************************************/\n#include \"FibHeap.h\"\n\nFUNCTION: FibNodeStore_create\n\n***\n\nINPUT ARGUMENTS: int size - size of the store to be created\n\nOUTPUT ARGUMENTS: FibNodeStore* pStore - node store created\n\nRETURNS: BOOL - TRUE if successful, FALSE if failed\n\nDESCRIPTION: This function allocates memory necessary for the nodes of the binomial heap. The allocated memory is to be used for the \"allocation\" of nodes.\n\nBOOL FibNodeStore_create(int size, FibNodeStore* pStore)\n{\n int i; /* Array index */\n\n *** First, allocate space for the actual nodes.\n if ((pStore->aNodes = (FFibNode*)malloc(size * sizeof(FFibNode))) == NULL)\n return FALSE;\n\n *** Now that the nodes are allocated, we allocate space to hold pointers to each\n if ((pStore->apNodes = (FFibNode*)malloc(size * sizeof(FFibNode))) == NULL)\n {\n free(pStore->aNodes);\n return FALSE;\n }\n\n *** Everything is allocated. Now we set pointers and initialize values\n for (i = 0; i < size; i++)\n {\n pStore->aNodes[i] = &pStore->aNodes[i]; /* set the pointer */\n pStore->aNodes[i].pLeft = NULL;\n pStore->aNodes[i].pRight = NULL;\n pStore->aNodes[i].pParent = NULL;\n pStore->aNodes[i].pChild = NULL;\n pStore->aNodes[i].nKey = INFINITY;\n pStore->aNodes[i].nVert = 0;\n pStore->aNodes[i].nDegree = 0;\n pStore->aNodes[i].nMark = FALSE;\n }\n\n pStore->numNodes = size;\n pStore->top = 0;\n\n *** Done\n return TRUE;\n}\n\nFUNCTION: FibNodeStore_destroy\n\n***\n\nINPUT ARGUMENTS: FibNodeStore* pStore - node store destroyed\n\nOUTPUT ARGUMENTS: NONE\n\nRETURNS: NOTHING\n\nDESCRIPTION: This function releases memory allocated for the binomial heaps.\n\nvoid FibNodeStore_destroy(FibNodeStore* pStore)\n{\n free(pStore->aNodes);\n free(pStore->apNodes);\n}\n\nFUNCTION: FibNodeStore_alloc\n\n***\n\nINPUT ARGUMENTS: FibNodeStore* pStore - node store from which the node is to be allocated\n\nOUTPUT ARGUMENTS: NONE\n\nRETURNS: FFibNode - pointer to binomial heap node. NULL if this operation fails.\n\nDESCRIPTION: This function allocates a node from the store and returns a pointer to it. If this operation fails, NULL is returned.\n\nFFibNode FibNodeStore_alloc(FibNodeStore* pStore)\n{\n *** Check if nodes are available for allocation\n if (pStore->top >= pStore->numNodes)\n return NULL;\n\n *** Get the next node and return a pointer to it, move the top down\n return pStore->apNodes[pStore->top++];\n}\nFibHeap.c\n\n/**\n *** Function: FibNodeStore_free\n ***\n *** Input Arguments: PFibNode* node - pointer to the pointer that\n *** points to node to be freed\n ***\n *** Output Arguments: FibNodeStore* pStore - node store to which the\n *** node is to be returned.\n ***\n *** Returns: None\n ***\n *** Description: This function returns the allocated node back to\n *** the store.\n ***\n */\n\nvoid FibNodeStore_free(PFibNode* node, FibNodeStore* pStore)\n{\n pStore->top--; \n pStore->apNodes[pStore->top] = *node;\n *node = NULL;\n}\n\nPFibQueue FibHeap_make(int nMaxSize)\n{\n PFibQueue pRetVal; \n int i; \n /* Return value */\n /* Index into the arrays */\n\n /* Allocate the queue itself and set its rootlist to NULL */\n pRetVal = (PFibQueue)malloc(sizeof(PFibQueue));\n pRetVal->pRootList = NULL;\n pRetVal->nCurrentSize = 0;\n pRetVal->pMin = NULL;\n pRetVal->nMaxSize = nMaxSize;\n\n /* Allocate space for the arrays and initialize them */\n pRetVal->apVertexNodes = (PFibNode*)malloc(nMaxSize * sizeof(PFibNode));\n pRetVal->aInQueue = (BOOL*)malloc(nMaxSize * sizeof(BOOL));\n /r\n pRetVal->A = (PFibNode*)malloc(nMaxSize * sizeof(PFibNode));\n /r\n for (i = 0; i < nMaxSize; i++)\n { /r\n }\nFibHeap\n\n*** Create and initialize the resulting heap\n***\n\\[ h = \\text{FibHeap}\\_\\text{make}(h1->nMaxSize); \\quad / \\text{Create the resulting heap} *\\]\n\\[ h->pMin = h1->pMin; \\quad / \\text{Initialize the pointer to min} *\\]\n\n*** Concatenate the root list of H2 with the root list of H\n***\n\\[ h->pRootList = \\text{FibHeap\\_concatLists}(h1->pRootList, h2->pRootList); \\]\n\n*** Adjust the minimum pointer to reflect the min\n***\nif \\((h1->pMin == \\text{NULL}) || (h2->pMin != \\text{NULL}) \\&\\& (h2->pMin->nKey < h1->pMin->nKey))\n\\[ h->pMin = h2->pMin; \\]\n\\[ h->nCurrentSize = h1->nCurrentSize + h2->nCurrentSize; \\]\n\\[ return h; \\]\n\nFibNode\n\n\\[ \\text{FibHeap\\_extractMin}(\\text{FibQueue} h) \\]\n\\{ \\text{FibNode pMinNode = NULL}; \\quad / \\text{Pointer to node with min key} */\n\\text{FibNode pCurChild; } \\quad / \\text{Iteration over child nodes} */\n\\text{BOOL bMadeFullCycle = FALSE; } \\quad / \\text{Flags full cycle over list} */\n\\}\n\nif \\((h->nCurrentSize > 0) \\&\\& (h->pRootList != \\text{NULL}) \\&\\&\n\\text{((pMinNode = h->pMin) != \\text{NULL}))\n\\{ \\quad / \\text{Add all children of the node pointed to by pMinNode to the root list} */\n\\text{if }\\text{pMinNode->pChild} != \\text{NULL} \\}\n\\{ \\quad / \\text{Make sure that the parent of every child is NULL} */\n\\text{pCurChild = pMinNode->pChild; }\nwhile (!bMadeFullCycle)\n\\{ \\text{pCurChild->pParent = NULL; }\n\\text{pCurChild = pCurChild->pRight; }\n\\text{if (pCurChild = pMinNode->pChild)\n\\text{bMadeFullCycle = TRUE; }}\n\\}\n\\}\n\n*** Now for the node itself\n***\n\\text{pCurChild = pMinNode->pChild; }\n\\text{pCurChild->pParent = NULL; }\n\\text{pMinNode->pChild = NULL; }\n\n*** Concatenate the child list with the heap’s root list and set new\n*** minimum\n\nFibQueue\n\n\\[ \\text{FibHeap\\_union}(\\text{FibQueue} h1, \\text{FibQueue} h2) \\]\n\\{ \\text{FibQueue h; } \\quad / \\text{Pointer to the resulting heap} */\n\\}\n\n/**/\n```c\nFibHeap.c\n\n*** Iterate over the nodes in the root\n***/\n\n/**\n * Break the circle to stop\n */\nif (h->nCurrentSize > 1)\n{\n pMinNode->pRight = pMinNode->pLeft;\n pMinNode->pLeft->pRight = pMinNode->pRight;\n if (h->pRootList == pMinNode)\n h->pRootList = pMinNode->pRight;\n h->pMin = pMinNode->pRight;\n FibHeap_consolidate(h);\n}\nelse\n{\n h->pRootList = NULL;\n h->pMin = NULL;\n}\n\n/**\n * h->nCurrentSize--; \n * h->aInQueue[pMinNode->unVert] = NULL;\n * h->aInQueue[pMinNode->unVert] = FALSE;\n */\n\nreturn pMinNode;\n\nFPFibNode FibHeap_consolidate(FPFibQueue h)\n{\n int i; /* Index into the array */\n int D; /* Size of the auxiliary array */\n PPFibNode pw; /* Pointer to the current node */\n PPFibNode px, py; /* Nodes X and Y */\n PPFibNode ptmp; /* Swap pointer */\n int d; /* Degree of the current node */\n BOOL bFullCycle = FALSE; /* Made a full cycle over the list*/\n\n *** Allocate and initialize the auxiliary array A\n ***/\n /* D = (int) ceil(log2((double) h->nCurrentSize)) + 1; */\n /* D = h->nCurrentSize; */ /* For debugging on Borland with no log2 */\n for (i = 0; i < h->D; i++)\n h->A[i] = NULL;\n\n ***\n }\n return h;\n}\nFibHeap.c\n\nif (!!(h->inQueue[unVert]) ||\n ((pX = h->vertexNodes[unVert]) == NULL) ||\n (nKey == h->vertexNodes[unVert]->nKey))\n return h;\n\n /*\n * Set the new key to the vertex\n */\nP->nKey = nKey;\nP = pX->parent;\n\nif ((P != NULL) && (P->nKey < P->nKey))\n FibHeap_cut(h, P, P->nKey);\n FibHeap_cascadingCut(h, P);\n\nif (P->nKey < h->pMin->nKey)\n h->pMin = P;\nreturn h;\n\nFibHeapQueue FibHeap_decreaseKey(FibHeapQueue h, unsigned int unVert, int nKey)\n{\n FibNode pY;\n FibNode pX;\n\n /*\n * Check if the key can be decreased. If not, exit without doing anything\n */\n /*\n * Remove node Y from the root list\n */\n if (P->right != NULL)\n if (P->right->pLeft == P->right)\n if (P->right->pRight == P->right)\n P->right->pLeft = P->right;\n P->right = P->right;\n P->pChild = P->right;\n P->pRight = P->right;\n P->pParent = P;\n else\n P->pRight = P;\n P->pRight->pLeft = P->pLeft;\n P->pRight->pRight = P->pRight;\n P->pRight->pChild = P;\n P->pRight->pDegree = P->pRight;\n P->pRight->pMark = FALSE;\n return h;\n \n P->pDegree = P;\n P->pDegree = P->pDegree;\n P->pDegree = P->pDegree;\n P->pDegree = P->pDegree;\n return h;\n}\nFibHeap.c\n\nPPfibQueue FibHeap_cascadingCut (PPfibQueue h, PPfibNode pY)\n{\n PPfibNode pParent; /* Pointer to parent of node Y */\n if ((pParent = pY->pParent) != NULL)\n if (!pY->bMark)\n pY->bMark = TRUE;\n else\n { FibHeap_cut (h, pY, pParent);\n FibHeap_cascadingCut (h, pParent);\n }\n\n return h;\n}"}}},{"rowIdx":153,"cells":{"id":{"kind":"string","value":"b7bf42a2db1e5d059726f8298055e7a9e99421be"},"text":{"kind":"string","value":"Towards Formalising Erlang Failure and Failure Detection\n\nAudrianne Farrugia\n\nSupervisor: Dr. Adrian Francalanza\n\nFaculty of ICT\n\nUniversity of Malta\n\nMay 2011\n\nSubmitted in partial fulfillment of the requirements for the degree of B.Sc. I.C.T. (Hons.)\nFaculty of ICT\n\nDeclaration\n\nI, the undersigned, declare that the dissertation entitled:\n\nTowards Formalising Erlang Failure and Failure Detection\n\nsubmitted is my work, except where acknowledged and referenced.\n\nAudrianne Farrugia\n\n27 May 2011\nAcknowledgements\n\nMy deepest gratitude goes first and foremost to my supervisor, Dr. Adrian Francalanza who extensively assisted me throughout the course of this dissertation. His unfailing guidance was key in developing an understanding of the subject.\n\nHeartfelt thanks goes to those close to me, especially my family for their moral support throughout my educational experience. Their absolute confidence in me and constant encouragement was greatly needed and appreciated.\nAbstract\n\nLately, more emphasis is being put on building fault-tolerant parallel systems. This fact can be clearly seen from the number of companies that are opting to develop their systems in Erlang; a parallel language which is renowned for its error handling capabilities. A sound understanding of a system’s behaviour when errors occur is the key to developing truly fault-tolerant software.\n\nThis dissertation investigates Erlang’s error handling mechanisms so as to better understand how Erlang behaves in the presence of errors. A formal model is defined in order to provide a precise and unambiguous description of the behaviour of these mechanisms. The correctness of the model is evaluated by considering a number of Erlang programs and comparing the behaviour as described by the model with that of actual Erlang. Ultimately, the defined model is animated through an evaluator.\n# Contents\n\n1. Introduction .......................... 1\n 1.1 Aims and Objectives .................. 4\n 1.2 Methodology .......................... 5\n 1.3 Dissertation Overview ................. 5\n\n2. Background ............................ 6\n 2.1 Introduction .......................... 6\n 2.2 The Need for Parallel Languages ........ 6\n 2.3 Message Passing Languages .............. 7\n 2.4 Mailbox Based Languages ............... 8\n 2.5 Erlang .......................... 9\n 2.5.1 Basic Erlang ..................... 10\n 2.5.1.1 Erlang Values .............. 10\n 2.5.1.2 Single Assignment ............ 10\n 2.5.2 Case Expression .................. 11\n 2.5.2.1 Spawning New Processes ... 11\n 2.5.2.2 Sending and Receiving Messages ... 12\n 2.5.2.3 Process Pid ............... 14\n 2.5.3 Error Handling in Erlang .......... 15\n 2.5.4 Recovering from Errors .......... 15\n 2.5.5 Local Error Handling .............. 17\n 2.5.5.1 Exceptions in Erlang ....... 17\n 2.5.5.2 Try-catch .................... 17\n 2.5.5.3 SumNProduct - Sequential Version ... 17\n 2.5.5.4 SumNProduct - Parallel Version ... 18\n 2.5.6 Remote Error Handling ............ 20\n 2.5.6.1 Monitoring ................... 24\n2.5.6.2 spawn_link, spawn_monitor .................................... 26\n2.5.6.3 Explicit Error Signals ............................................. 26\n2.5.6.4 SumNProduct - Remote Error Handling ....................... 28\n2.6 Conclusion ............................................................. 31\n\n3. Formal Semantics ....................................................... 32\n 3.1 Introduction ......................................................... 32\n 3.2 The need for Formal Semantics in Erlang ............................ 32\n 3.3 Current Formal Semantics in Erlang ................................ 33\n 3.3.1 Differences Between Current Semantics and Defined Model 34\n 3.4 Erlang System .......................................................... 36\n 3.5 Erlang Subset ......................................................... 36\n 3.6 Contextual Rules ....................................................... 38\n 3.7 Erlang Process .......................................................... 39\n 3.8 Case Statement ......................................................... 40\n 3.9 Local Error Handling - try-catch .................................. 43\n 3.9.1 sumNProduct Example(Sequential version) .................... 43\n 3.10 Parallel Erlang ....................................................... 45\n 3.10.1 sumNProduct Example(Parallel Version) ....................... 47\n 3.11 Remote Error Handling ............................................. 49\n 3.11.1 Links and System Processes .................................... 49\n 3.11.2 Error Propagation ............................................. 52\n 3.11.3 Spawn_link ...................................................... 54\n 3.11.4 Explicit error signals ......................................... 58\n 3.11.5 Monitors ......................................................... 64\n 3.11.6 sumNProduct Example(Remote error handling) ................ 67\n 3.12 Conclusion ............................................................. 72\n\n4. Implementation Framework ........................................... 73\n 4.1 Introduction .......................................................... 73\n 4.2 System Design ........................................................ 73\n 4.3 Input ................................................................. 74\n 4.4 Parsing ................................................................. 74\n 4.4.1 Lexer .............................................................. 75\n 4.4.2 Parser Combinators ............................................. 75\n 4.5 Evaluator .............................................................. 78\nList of Figures\n\n1.1 System implemented in 1.2 .............................................. 3\n2.1 SumNProduct System ...................................................... 16\n2.2 Remote Error Handling .................................................... 21\n2.3 Erlang system ............................................................... 22\n2.4 Error propagation .......................................................... 23\n2.5 Error propagation .......................................................... 23\n2.6 Links & Monitors - Process Pid1 terminates ....................... 24\n2.7 Links & Monitors - Process Pid2 terminates ....................... 25\n2.8 Explicit error signals ...................................................... 27\n3.1 Link Failure as described by Current Semantic Definitions .......... 50\n3.2 Exit propagation through links .......................................... 52\n3.3 Exit propagation through explicit error signals ..................... 59\n3.4 Monitor and Links ......................................................... 65\n4.1 System’s design ............................................................. 74\n4.2 Different interleavings ..................................................... 80\n4.3 Different interleavings ..................................................... 81\n4.4 Possible Interleavings of System in 4.2: process B fails to send message ......................................................... 81\n4.5 Possible Interleavings of System in 4.2: process B sends message . 82\n4.6 Possible Interleavings of System 4.2 ..................................... 82\n4.7 Error handling - possible interleavings .................................. 84\n5.1 Evaluation Strategy .......................................................... 87\n5.2 Local error handling - evaluator’s output ............................. 90\n5.3 Remote error handling - Trace list’s output ......................... 93\n5.4 Remote error handling - Evaluator’s output ......................... 95\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>5.5</td>\n<td>Order of signal evaluation</td>\n<td>102</td>\n</tr>\n<tr>\n<td>5.6</td>\n<td>Order of signal evaluation</td>\n<td>104</td>\n</tr>\n<tr>\n<td>5.7</td>\n<td>Order of signal evaluation</td>\n<td>106</td>\n</tr>\n<tr>\n<td>5.8</td>\n<td>Local Error Handling Example</td>\n<td>107</td>\n</tr>\n<tr>\n<td>5.9</td>\n<td>Remote Error Handling Example - System</td>\n<td>109</td>\n</tr>\n<tr>\n<td>5.10</td>\n<td>Remote Error Handling Example - Unexpected Behaviour(1)</td>\n<td>112</td>\n</tr>\n<tr>\n<td>5.11</td>\n<td>Remote Error Handling Example - Unexpected Behaviour(2)</td>\n<td>113</td>\n</tr>\n<tr>\n<td>5.12</td>\n<td>Error signals - Distributed Systems</td>\n<td>116</td>\n</tr>\n</tbody>\n</table>\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>System rules</td>\n<td>36</td>\n</tr>\n<tr>\n<td>3.2</td>\n<td>Erlang’s subset</td>\n<td>37</td>\n</tr>\n<tr>\n<td>3.3</td>\n<td>Contextual rules</td>\n<td>38</td>\n</tr>\n<tr>\n<td>3.4</td>\n<td>Process Termination Rules</td>\n<td>40</td>\n</tr>\n<tr>\n<td>3.5</td>\n<td>Case rules</td>\n<td>40</td>\n</tr>\n<tr>\n<td>3.6</td>\n<td>Rules for local error handling</td>\n<td>43</td>\n</tr>\n<tr>\n<td>3.7</td>\n<td>Process rules</td>\n<td>45</td>\n</tr>\n<tr>\n<td>3.8</td>\n<td>Process rules for linking and system processes</td>\n<td>49</td>\n</tr>\n<tr>\n<td>3.9</td>\n<td>Error propagation</td>\n<td>52</td>\n</tr>\n<tr>\n<td>3.10</td>\n<td>Spawn_link rule</td>\n<td>54</td>\n</tr>\n<tr>\n<td>3.11</td>\n<td>Explicit exit signals</td>\n<td>58</td>\n</tr>\n<tr>\n<td>3.12</td>\n<td>Self-sent exit signals</td>\n<td>58</td>\n</tr>\n<tr>\n<td>4.1</td>\n<td>Actions to be performed when executing program 4.6</td>\n<td>79</td>\n</tr>\n<tr>\n<td>4.2</td>\n<td>Actions to be performed</td>\n<td>81</td>\n</tr>\n<tr>\n<td>4.3</td>\n<td>Actions to be performed when executing program 4.9</td>\n<td>83</td>\n</tr>\n<tr>\n<td>5.1</td>\n<td>Monitors - Behaviour as described by model</td>\n<td>96</td>\n</tr>\n<tr>\n<td>5.2</td>\n<td>Explicit exit signals - Behaviour as described by model</td>\n<td>99</td>\n</tr>\n<tr>\n<td>5.3</td>\n<td>Explicit exit signals - Behaviour as described by model</td>\n<td>99</td>\n</tr>\n<tr>\n<td>5.4</td>\n<td>Soundness & Completeness of Model</td>\n<td>114</td>\n</tr>\n</tbody>\n</table>\n1. Introduction\n\nIn the past few years, there has been considerable interest in concurrent programming languages such as Erlang. This fact is clearly reflected in the increasing number of companies that are opting to use Erlang in their systems. Among such systems one finds Facebook’s chat service, Amazon’s SimpleDB and Yahoo’s bookmarking service Delicious. Undoubtedly, one of the driving factors behind Erlang’s success lies in the fact that it enables developers to build fault-tolerant systems using really simple constructs.\n\nUnderstanding the behaviour of Erlang systems in the presence of errors may not always be an easy feat. This is even more so when considering the fact that due to the parallel nature of Erlang systems the interleaving of processes may result in different outputs even when the same error occurs at consecutive executions of a system. Nonetheless, a sound understanding of a system’s error handling behaviour is the cornerstone to the development of truly reliable software.\n\nExperience has shown that lack of understanding of a system’s behaviour in the presence of errors is one of the contributing factors behind many system failures. One classic example is the Ariane 5 space shuttle which was shredded to pieces due to an unhandled exception[4]. Additionally, [5] claims that 50% of all system failures in telephone switching applications are caused by faults in exception handling algorithms.\n\nIn order to ensure a higher degree of reliability, the computing community has lately started to adopt formal methods for system specification and modelling. The main goal of a model is to faithfully mirror the behaviour of a system. One of the strengths in models stems from the fact that they are able to abstract away from the complex details of a system illustrating only the relevant aspects which\nneed to be checked. For instance, whereas programs are concerned with language syntax and resource allocation, when building models these details are ignored and more emphasis is put on interactions, actions and concurrency[1]. The simpler nature of the model makes it much easier to reason about the behaviour of the system in various situations. Besides that, the reduction in complexity also provides a better understanding of the program’s behaviour.\n\nIdeally a model is specified before a new programming language is implemented since this yields a better language design. In addition, the simplistic nature of the model provides future language learners a clearer definition of what the programming constructs are expected to do. However, in most cases no language models are specified prior to the implementation of a new programming language. Such was the case when Erlang was born.\n\nAs a result, even though Erlang makes use of really simple error handling constructs, sometimes it may not be easy to reason about the behaviour of Erlang systems in the presence of errors. This is mainly due to the fact that Erlang’s error handling mechanisms differ significantly from the ones found in mainstream programming languages.\n\nOne distinct characteristic of Erlang’s error handling behaviour lies in the fact that apart from handling errors locally, Erlang is also able to handle errors remotely. When using Erlang’s local error handling mechanisms, errors are handled by the same process in which they occur. This is done by using the try-catch statement, as shown in the following program:\n\n```erlang\ntry\n %% ****code****\ncatch\n %% error handling code\nend.\n```\n\nListing 1.1: Local Error Handling\n\nWhen using remote error handling, two separate processes are used. One process will be responsible to execute the *** code **** part. If an error occurs, this process would simply fail without attempting to recover from the error. The error would then be handled by another different process. A simple program which makes use of Erlang’s remote error handling constructs is the following:\n%% spawn a new process to handle errors\nspawn_link(?MODULE, errorHandler, [Pid]),\n\n%% *** code ****.\n\nListing 1.2: Remote Error Handling\n\nIn this case, Erlang will first spawn a new process which will be responsible of handling any errors that might occur while executing the *** code **** part. After spawning the “error handling” process, the system continues to execute the rest of the program.\n\n\n\nHere, it is important to note that extra attention must be given when building systems which make use of the remote error handling constructs. This is because the parallel nature of these systems may sometimes yield to unexpected behaviour. For instance, let’s consider the two programs that have been presented so far. At first glance, the program described in Listing 1.1 gives the impression that it should always behave in the exact same way as the one described in Listing 1.2. However, in truth there exist some subtle differences between the two programs.\n\nAt this point, it is nigh on impossible to identify the underlying cause that leads the two programs to behave differently. This problem brings to light the fact that even though both programs make use of really simple constructs understanding the behaviour of such systems in the presence of errors is not as straightforward as it might seem. Hence, defining a model for Erlang’s error handling constructs would definitely provide a valuable tool to correctly understand the behaviour of such systems.\nChapter 1. Introduction\n\n1.1 Aims and Objectives\n\nThe primary aim of this project is to study the mechanisms behind Erlang’s renowned error handling capabilities. Ultimately, a model is defined so as to get a better understanding of Erlang’s distinct error handling mechanisms. The underlying reasons behind defining such model, is that a model is able to:\n\n**Offer a better insight** - The simplistic nature of the defined model makes it easier to reason about the behaviour of Erlang’s error handling constructs. This is because, through the model, it becomes really straightforward to get a detailed step-by-step description of how systems which make use of these constructs might behave. Even though the primary aim of models is to serve as a tool upon which analysis and verification can be performed, even the act itself of defining the model may reveal certain subtleties which may lead to unexpected behaviour.\n\n**Explain the cause of unexpected behaviour** - The model is also capable of describing the cause of why a system behaved in an unexpected way. This is because it enables us to analyse what went wrong through a retracing of the system in execution.\n\n**Predict system’s behaviour** - Through the model it becomes possible to foresee how a particular system will behave. Exhaustive analysis of the model is able to surface any faults that could arise while the system is running. Moreover, since the model is able to provide a step-by-step description of how an Erlang system behaves it enables us to identify those sequences of events that may lead to any faulty behaviour.\n\n**Lay the foundations for a semantic theory** - One of the strengths of a formal model is that it provides an accurate and unambiguous description of the behaviour of specific constructs. Therefore, whereas informal semantics definitions fall short in ensuring that two different syntactic systems behave in the same way, a model is able to ascertain if the two different systems are truly equivalent or not.\n1.2 Methodology\n\nThe main focus of this work is to define a model for Erlang’s error handling constructs. The steps taken to achieve this goal are the following:\n\n1. Obtain a good understanding of Erlang’s error handling mechanisms focusing on the different constructs that are used to build fault-tolerant systems.\n\n2. Define a mathematical model to faithfully describe the different error handling constructs that are incorporated within Erlang.\n\n3. Animate the defined model through an evaluator.\n\n4. Evaluate the correctness of the defined model. This is done by considering a number of different Erlang systems and comparing the behaviour as described by the model with the way the program behaves when run on the Erlang VM.\n\n1.3 Dissertation Overview\n\nThis dissertation is organized as follows:\n\nChapter 2 describes the most basic concepts needed to fully understand the motivation behind this work. Primarily, it outlines those characteristics that make Erlang an ideal language for implementing fault-tolerant systems. It then gives a brief overview of the Erlang language, introducing those constructs for which a formal semantic definition is defined in this project. A number of pairs of simple Erlang programs which seem to have identical behaviour are considered.\n\nChapter 3 presents a formal description of Erlang’s error handling constructs. These formal rules are then used to show if the examples described in the previous chapter are truly equivalent or not.\n\nChapter 4 describes how the formal semantic rules defined in Chapter 3 are ultimately animated through an evaluator. The main design choices that were taken when developing the evaluator are discussed.\n\nChapter 5 illustrates the evaluation strategy used to see to what degree the aims set forth in the beginning of this project have been met. It also mentions the main limitations of the defined semantic rules and of the designed evaluator.\n\nChapter 6 states the results that have been achieved through this project. It also proposes some future work that could be done.\n2. Background\n\n2.1 Introduction\n\nThe scope of this chapter is to present a general overview of some basic concepts which are key in understanding the motivation behind this work. Primarily, it outlines the main reasons why more emphasis is being put on parallel languages. The different models of parallel languages are identified highlighting the strengths and weaknesses of each model. Subsequently, some light is shed on Erlang, the language whose error handling behaviour will be ultimately defined formally.\n\n2.2 The Need for Parallel Languages\n\nThe primary goal of this project is to study the fault recovery mechanisms integrated within a parallel language. Perhaps at this point one might ask: “Why are we considering a parallel language in the first place? Maybe the best way to address this question is to first present some facts describing the situation that we are currently in.\n\nWay back in 1965, Gordon Moore had predicted that the number of transistors on an integrated circuit would double every couple of years[6]. For a long time there seemed to be a direct relationship between the number of transistors and software performance. However, in the last decade, the rate of improvement in software performance has slowed significantly. The whole problem stems from the fact that instead of increasing the clock speed we are now increasing the number of cores. One major downside of this approach is that most software is not capable of fully exploiting the benefits of multi-core processors. Doubling the number of cores in a CPU does not necessary lead to doubling the performance\nas was the case when doubling the clock speed.\n\nTherefore, whereas before all software benefited instantly from the gradual improvement in computer performance, now we are facing a situation where existing software is finding it hard to keep pace with hardware. Nonetheless, the world is still expecting that the computing community continues providing software with improved performance. Consequently, in order to quench the thirst for more powerful software, a shift to parallel computing is required. This is because, by adopting a parallel paradigm, software would be able to improve in performance as a result of the increased number of cores, similar to the way, systems were able to become more efficient due to an increase in clock speed.\n\n2.3 Message Passing Languages\n\nCurrently, the programming languages which support concurrent processes can be categorized into two main classes: those that support interprocess communication through shared memory communication and those that are able to exchange data and information through message passing. The main difference, between these two models is the fact that in the former model, processes communicate by accessing the same instance of data which is physically found in memory. In contrast, when using the message passing model, processes access different instances of the same data, rather than the actual data itself.\n\nThe message passing model, is usually preferred when transferring small amounts of data between processes[7]. This is due to the fact, that when accessing shared memory one has to use locks in order to ensure that no two processes are writing simultaneously at the same memory location, since this may inherently result in a race condition. On the other hand, when using message passing mechanisms, the risk of race conditions is reduced since data is sent directly between processes[10]. Moreover, message-passing systems tend to have a simpler system design since one does not need to include any locks when accessing data.\n\nAnother major benefit of message passing is the fact that it increases the degree of isolation between processes which guarantees that an error which occurs in one process does not propagate to other processes[8]. This is not the case, when using shared memory. A case in point is when a process crashes while updating the shared memory. As a result, incorrect data might be stored in memory, which may subsequently affect the behaviour of other processes accessing this erroneous\ndata. On the other hand, message passing ensures that such cases will never occur.\n\nPerhaps one downside of message passing model is the fact that systems adopting this model tend to be slower since all accesses to memory are implemented using system calls in contrast to shared memory systems[7]. Nonetheless, in some systems it is ideal to trade off efficiency in order to obtain a much simpler system design which is able to handle errors in a much cleaner way.\n\nOne can appreciate even more the benefits of message passing over shared memory through Nyström’s work in [9]. In his paper, Nyström compares the shared memory model adopted by Java threads with Erlang’s message passing model. He argues how Erlang offers much better parallelisation tools when compared to Java and shows how this can be easily seen from the different ways in which Erlang and Java presented their views with respect to the parallelisation mechanisms they offer. He mentions that in one of Sun’s tutorials threads were introduced in the following way:\n\nThe first rule of using threads is this: avoid them if you can. Threads can be difficult to use, and they tend to make programs harder to debug.\n\nConversely, Erlang presented the use of parallel processes to its users in the following way:\n\nUse one parallel process to model each truly concurrent activity in the real world\n\nIf there is a one-to-one mapping between the number of parallel processes and the number of truly parallel activities in the real world, the program will be easy to understand.\n\nThis striking contrast between the two statements seems to hint that Erlang users should be much more confident when building parallel system.\n\n## 2.4 Mailbox Based Languages\n\nThe term message passing embraces both channel and mailbox/actor-model communication. The primary difference between the two is that whilst a mailbox is\nassociated with a particular process, a channel is independent from any process. In a mailbox system, a process is able to send messages to either its own mailbox or to another process’ mailbox. However, it may only read messages from its own mailbox. Another aspect of mailboxes is the fact that once a process terminates, its mailbox will automatically no longer be available to other processes.\n\nWhen using the channel mechanism, all processes in a system are able send and receive to/from the same channel. In contrast to the mailbox mechanism the channel is not associated with the pid of any of the processes. Consequently, if for instance process A terminates, Process B should still be able to send/receive messages from a particular channel. In actual fact, a channel may still be available even when all processes in a system terminate unless it is destroyed by some process.\n\nTherefore, one major benefit of mailboxes over channels is that mailboxes from their very nature guarantee that resources used to store messages are released immediately upon a process failure. On the other hand, when using channels, another process must be responsible of releasing any resources. As a result, mailboxes can be considered as providing a cleaner recovery from errors since redundant resources are released immediately.\n\n2.5 Erlang\n\nThis section will delve deeper into one particular actor-based language, Erlang; the language whose error handling mechanisms will be studied in this project. Firstly, Erlang’s most basic constructs will be introduced. These constructs will serve as the main building blocks to implement simple Erlang systems in later stages of this project. Subsequently, Erlang’s error handling constructs will be described so as to get a clear picture of the constructs for which a formal semantics will be defined later on.\n\nHere it is important to note that for the purpose of this project only a subset of Erlang will be considered. The underlying reason is that defining a formal semantics for all of Erlang’s constructs would be infeasible since this would result in a rather cumbersome semantics. In addition, the chosen subset is close to the one defined in [2] which describes a complete subset of Erlang, and therefore it should be able to represent most of the systems written in Erlang.\n2.5.1 Basic Erlang\n\nHere some light will be shed on a number of different Erlang constructs. Primarily, we will first look at those constructs that are needed to build sequential Erlang systems. Then the constructs needed to build parallel Erlang systems will be outlined.\n\n2.5.1.1 Erlang Values\n\nIn the chosen subset, Erlang values may consist of atoms, integer, variables, pids and lists. A new unique pid can only be assigned to a process once a new process is created i.e. a user cannot assign a specific pid to a process. The pid of a new process will be returned to the parent process once a process creation function such as (spawn or spawn_link) has been evaluated. Communication with a particular process can only take place if its pid is known by the process wishing to establish communication.\n\n2.5.1.2 Single Assignment\n\nThe term single assignment refers to the fact that in Erlang once a variable becomes bound to a value it cannot become bound to a different value. This practice has been adopted in various functional programming languages such as F# and Haskell because of side effects. To better understand what the single assignment term actually refers to let’s consider the following piece of Erlang code:\n\n\\[\n\\begin{align*}\n\\text{Value} & = [0], \\\\\n\\text{Value} & = [\\text{Value},1], \\\\\n... &\n\\end{align*}\n\\]\n\nGiven the fact that variables can be bound only once, the above code will result in a runtime error. This is because when evaluating the second expression (Value = [Value,1]), Value has already been bound to [0] and therefore, the system will fail when it attempts to bind Value to [Value,1]. In Erlang, the correct way to implement to above code is by introducing a fresh new variable name:\n\n\\[\n\\begin{align*}\n\\text{Value} & = [0], \\\\\n\\text{Value1} & = [\\text{Value},1], \\\\\n... &\n\\end{align*}\n\\]\n2.5.2 Case Expression\n\nThe case statement behaves in the same way as in conventional programming languages. A very simple example is:\n\n```plaintext\ncase Number of\n 1 -> hello;\n 2 -> bye\nend.\n```\n\nwhich returns hello if Number is equal to 1 or bye if Number is equal to 2.\n\nIn the chosen subset, the case statement also serves as an alternative to Erlang’s *single assignment*. For instance, let’s consider the assignment statement:\n\n```plaintext\nValue = [0]\n```\n\nWhen evaluating this expression Value will become bound to [0]. The same behaviour can be obtained by using the following expression:\n\n```plaintext\ncase [0] of Value -> ... end\n```\n\nWhen evaluating the above expression, [0] is successfully pattern matched against Value. As a result, Value becomes bound to [0]. Therefore, it is quite clear that the above case statement behaves just like the assignment statement. Here, it is noteworthy the fact that in Erlang the case statement is not a scoping construct and hence any bindings that occur through this construct will hold even after the `end` keyword. Thus, consecutive assignment statements can be expressed in terms of the case statement as shown hereunder:\n\n```plaintext\nValue = [0],\nValue1 = [Value,1], \\implies case [0] of Value -> ok end,\n... case Value1 of [Value,1] -> end\n```\n\n2.5.2.1 Spawning New Processes\n\nThe `spawn(m,f,a)` function is the primary Erlang construct that creates new processes. This function expects three arguments as input - (module name, function name, arguments). The second argument indicates which function the newly created process will start executing once it has been created. The third argument refers to the values that are passed to the functions and the module name indicates the module where the function definition is found. Once the spawn function\nChapter 2. Background\n\nis evaluated it returns the pid of the new process so that the parent process will be able to communicate with its child process. Therefore, when evaluating the following expression:\n\n\\[\n\\text{Pid} = \\text{spawn(math,sum,[[1,2,3]])}\n\\]\na new process will be created and Pid will become bound to the pid of the newly spawned process. This new process will start executing \\( \\text{sum}([1,2,3]) \\). The function definition of \\( \\text{sum} \\) should be found in the math module.\n\n### 2.5.2.2 Sending and Receiving Messages\n\nSending of messages is done by using the infix construct \\(!\\). This construct expects two arguments, the recipient’s pid and the message to be sent. For instance, in order to send a \\([\\text{msg},\\text{hello}]\\) message to a process the following expression is used:\n\n\\[\n\\text{Pid} ! [\\text{msg},\\text{hello}].\n\\]\n\nOnce this construct is evaluated the \\([\\text{msg},\\text{hello}]\\) message is appended to the mailbox of the process identified by Pid. The latter process can then read the message by using the receive construct as shown hereunder:\n\n\\[\n\\begin{align*}\n&\\text{receive} \\\\\n&\\quad [\\text{msg},\\text{Text}] -> \\text{Text} \\\\\n&\\text{end}\n\\end{align*}\n\\]\n\nThe above code will cause the process to block until a message consisting of a two element list, whose first element is the atom \\text{msg} is received. Upon receipt of such message, \\text{Text} will become bound to the second element of the list. For instance, in this case once the \\([\\text{msg},\\text{hello}]\\) message is received, it is successfully pattern-matched against \\([\\text{msg},\\text{Text}]\\), and as a result \\text{Text} will become bound to the atom \\text{hello}.\n\nHere it is worth pointing out that in Erlang, the order of messages between a pair of processes is guaranteed. Therefore, if say a process A sends two consecutive messages to another process, say process B:\n\n\nit may never be the case that process B receives the world message prior to receiving the hello message. However, order of messages can only be guaranteed between a pair of processes. With regards to message ordering between different processes it may not always be possible to guarantee that messages will be received in one specific order. A case in point is the following system.\n\nIn this system, process A sends two messages; it first sends the hello message to process B and then it will send the world message to process C. When process B receives the hello message, it will forward the received message to process C.\n\nThe above diagram illustrates that process C will receive the world message prior to the hello message. However, in this particular system it may also be the case that process C receives the messages in a different order. This may happen if the following sequence of events takes place:\nChapter 2. Background\n\nJust the same in both cases, process C is still able to select which of the two messages to read/remove from the mailbox first. This can be done by using the following coding:\n\n```plaintext\nreceive\n hello -> ...\nend,\n\nreceive\n world -> ....\nend,\n```\n\nIn this code excerpt, the `hello` and `world` atoms are used as patterns against which, messages in the process’ mailbox will be pattern matched. In this case, since the first `receive` statement is only able to read messages consisting solely of the `hello` atom, the process will be suspended until the `hello` message is received in its mailbox. Only then can the process proceed to read the `world` message.\n\n2.5.2.3 Process Pid\n\nThe pid of a process is known by its parent process and by its owner. A parent process will be informed about the pid of its child process, immediately after the creation of its child. For instance, the `spawn` function always returns the pid of the newly created process. A process is able of discovering its own pid by using the `self()` built-in function. One example where the `self()` function may be used is the following:\n\nIn this case process A spawns process B. Process B will act as an echo server, echoing back any messages that it receives. As mentioned in the previous section, in order for a process to send a message, it must know the pid of the recipient. In this particular case, process A will be able to communicate with process B by using the pid that is returned by the `spawn` function. However, since process B does not know A’s pid it is not able to echo back A’s message. In order for\nprocess B to be able to send messages, process A must include its own pid with the messages it sends.\n\n\n\nIn this case, the self() function will evaluate down to PidA. Process B will then be able to send back messages by using the received pid.\n\n### 2.5.3 Error Handling in Erlang\n\nErrors are likely to occur during a system’s runtime. This is even more so when considering the fact that Erlang systems are not statically type checked and therefore type errors have to be handled during runtime. If systems were to be build using solely the constructs described so far, an exception or an error will immediately result in a whole system failure. In this section Erlang’s simple yet powerful error handling constructs will be introduced so as to get acquainted with the constructs for which ultimately a formal semantics will be defined.\n\n### 2.5.4 Recovering from Errors\n\nBefore describing the actual error handling constructs, we will consider a simple system so as to get a clear overview of the different ways Erlang may recover from errors. The considered system accepts as input two lists and returns the sum of the first list, and the product of the second list. Error handling mechanisms are used so as to handle the cases when non-numeric data is found in any of the input lists.\nChapter 2. Background\n\nDiagram 2.1 describes the different ways in which the system may be implemented. It clearly demonstrates that when implementing the system sequentially, each process is made up of coding surrounded by error handling coding. In the second version of the system, the system experiences an improvement in efficiency since the sum and product of the list are being carried out by two separate processes. However, just as in the previous case, the process’ coding is cluttered up with error handling code. This downside is overcome by adopting the design shown in the last version of the system. In this case, thanks to remote error handling the system enjoys a higher degree of separation of concerns since every process is only responsible of carrying out one particular task either calculating the sum or the product or recovering from errors. In the following sections, we will take a closer look into each of the different versions of the system outlining the constructs that are needed to implement them.\n\nFigure 2.1: SumNProduct System\n2.5.5 Local Error Handling\n\n2.5.5.1 Exceptions in Erlang\n\nIn Erlang there are three classes of exceptions:\n\n- error\n- throw\n- exit\n\nExceptions of class error are usually caused due to some unforeseen error such as calling an undefined function or attempting to perform arithmetic operations on non-numeric values. throw exceptions are generated by calling the throw(Reason) built-in function. These types of exceptions are often used within a try-catch blocks. exit exceptions can be generated by using the exit(Reason) built-in function. The purpose of this exception is to terminate the process immediately.\n\n2.5.5.2 Try-catch\n\nThe try-catch construct has a similar behaviour to the one found in mainstream programming languages. As mentioned in the previous section, there are three types of exception classes that can be caught exit, throw and error. When catching exceptions, the name of the exception class precedes the name of the exception (errorClass:errorName). For instance, a divide by zero exception which is of class error or a throw exception can be caught in the following way:\n\n```\ntry\n 10/0\ncatch\n error:badarith-> 'div by 0'\nend.\n```\n\n```\ntry\n throw(stop)\ncatch\n throw:stop -> 'exception caught'\nend.\n```\n\n2.5.5.3 SumNProduct - Sequential Version\n\nThe Erlang constructs that have been introduced so far, enable us to write the sequential version of the sumNProduct system.\nChapter 2. Background\n\nsum([]) -> 0; product([]) -> 1;\nsum([H|T]) -> H + sum(T). product([H|T]) -> H * product(T).\n\nsumNProduct(List1,List2) ->\n Sum = try\n %% calculate sum of given list\n sum(List1)\ncatch\n %% if error occurs return invalid\n error:badarith -> invalid\nend,\n\n Product = try\n %% calculate product of given list\n product(List2)\ncatch\n %% if error occurs return invalid\n error:badarith -> invalid\nend,\n\n [Sum,Product].\n\nListing 2.1: SumNProduct - Sequential Version\n\nIn this case, the try-catch statement will be used so as to recover from errors that might arise if non-numeric data is input. In both cases if an exception is raised, the system will return the atom invalid. Here it is worth pointing out that since the two computations have no side-effect actions it is preferable that they are carried out in parallel. In the next section, the sumNProduct system will be implemented using Erlang’s parallel constructs and the two different implementations will be compared.\n\n2.5.5.4 SumNProduct - Parallel Version\n\nsumNProduct(List1,List2) ->\n %% spawn a process to compute the sum of List1\n spawn(math,sumProcess,[self(),List1]),\n %% spawn another process to compute the sum of List2\n spawn(math,productProcess,[self(),List2]),\n\n %...\nThe above program will spawn two processes; one process will compute the sum and another will compute the product. This is done through the following spawn calls:\n\n```\n%% spawn a process to compute the sum of List1\nspawn(math,sumProcess,[self(),List1]),\n\n%% spawn another process to compute the sum of List2\nspawn(math,productProcess,[self(),List2]),\n```\n\nListing 2.4: Spawning new processes\n\nWhen evaluating these calls, Erlang will first create a new process which will start evaluating the sumProcess function. Subsequently a new process is created which will start evaluating the productProcess function. Here, it is important to note that the sumProcess/productProcess function apart from the list of numbers, will also expect the pid of the parent process(self()) will evaluate down to the parent’s\nChapter 2. Background\n\npid). This pid is needed so that the newly created process will be able to send back the sum or product of the input list once it completes its computation as shown hereunder.\n\n\\[\n\\text{Pid} ! ([\\text{sum}, \\text{Sum}]. \\quad \\text{Pid} ! ([\\text{product}, \\text{Product}].\n\\]\n\nThese are the last statements that are found in the sumProcess/ productProcess function. One point worth pointing out at this point is that the first element of the list to be sent (i.e. either \\text{sum} or \\text{product} atom) acts as a tag, so that the parent process will be able to distinguish between the sum and product result. In fact, when the parent process reads the received results, it will pattern match against a two element list whose first element is either the \\text{sum} or \\text{product} atom.\n\n% receive the sum value\nreceive\n [sum,Value1] ->\n % receive the product value\n receive\n [product,Value2] -> [Value1,Value2]\n end\n end.\n\nListing 2.5: Receiving Results of Sum and Product\n\nWhen comparing the parallel version to its sequential counterpart, surely one major benefit of the parallel one is that it may result in a significant improvement in performance especially if the input lists are considerably large. Yet, in the above implementation, errors are still handled locally and therefore code is still cluttered up with error handling coding. In the next section, we will be introduced to Erlang’s remote error handling constructs which will make it possible to make an external process handle any generated errors.\n\n2.5.6 Remote Error Handling\n\nOn the strength in Erlang when compared to mainstream programming languages lies in the fact that it has adopted the notion of remote error handling. In order to better understand what this term actually refers to let’s consider a very simple system. In this example the system’s task is to compute the sum of two input numbers. Error handling mechanisms need to be used in order to handle errors that might arise due to invalid input data.\nWhen using remote error handling two distinct processes are created:\n\n\n\n**Figure 2.2: Remote Error Handling**\n\nProcess A’s task is to compute the sum of the two input numbers. If invalid data has been input, Process A would simply fail without attempting to recover from the error. Process B’s task is to handle any error which might occur. One here can appreciate how the “let it fail” philosophy adopted by Erlang makes it possible to implement systems having a higher degree of separation of concerns. This is due to the fact that when using this approach the code responsible for computing the sum of input data is not cluttered up with any exception handling code. This yields a much cleaner and thus clearer coding.\n\nThe three main factors behind Erlang’s error handling mechanisms are:\n\n- **links**: these can be seen as bidirectional paths between two processes along which error signals travel. Each Erlang process has a link set which consists of the pids to whom the process is linked. Whenever a process, say process A links to another process say process B, B is added to A’s link set and A is added to B’s link set. Once a process terminates it sends an error signal to all processes found in its link set. Here it is worth noticing that due to their bidirectional nature, two linked processes are guaranteed to be notified about the termination of the other process irrespective of which process created the link.\n\n- **error signals**: these are the signals that are sent along the links. Whenever a process terminates, error signals are sent to all linked processes to notify them about its termination. Apart from being sent upon process termination these signals can also be generated explicitly by using the `exit/2` built-in function. In the latter case these signals are used to fake the termination of the process sending the signal.\n• **system processes**: processes in Erlang can be classified in two distinct categories; system processes and non-system processes. The key difference between the two is how they behave upon receipt of an abnormal error signal. A system process will translate the error signal into a normal message and add it to the processes mailbox. On the other hand, a non-system process will terminate upon receipt of an abnormal error signal. If a process wishes to become a system process it can set its flag by using the expression shown hereafter:\n\n```erlang\nprocess_flag(trap_exit,true)\n```\n\nSimilarly, a process may unset its process_flag as follows:\n\n```erlang\nprocess_flag(trap_exit,false)\n```\n\nBy default, the process_flag is not set and therefore a process will terminate immediately on receipt of a process failure notification. If the process_flag has been set to true, the received notification will be added to the process’ mailbox and the process will be notified about a process’ termination by reading the message from its own mailbox.\n\nLet’s consider a very simple example of how these concepts are actually used. In the following diagrams links are represented as straight lines and system processes are represented as double-lined circles.\n\n\n\nIn the system described in 2.3 process A is linked to both process B and C. Since all three processes are non-system processes, whenever any of them receives an error signal they will terminate. Therefore, if process B terminates abnormally, the following actions will follow.\nChapter 2. Background\n\nNow let’s consider the same system, modifying Process A to a system process. In this case the error signal sent by Process B is translated into an error message and added to Process A’s mailbox. Process C is not notified about Process B’s termination since there is no direct link between Process B and Process C. System processes are highly used when building fault-tolerant systems and recovery actions need to be done upon a process failure. For instance, in the above\ncase, process A could be programmed to restart a copy of Process B again once it receives process B’s error message.\n\n### 2.5.6.1 Monitoring\n\nMonitors are very similar in concept to links. Monitors are created by using the monitor built-in function. For instance, if a process wishes to monitor another process whose pid is bound to Pid then the `monitor(process, Pid)` expression is used. The key difference between monitors and links is that monitors are unidirectional in contrast to links which are bidirectional. In addition, a monitor will never terminate abruptly if the process it is monitoring fails. Instead, upon process termination a message is added to the monitor’s mailbox. To better understand the difference in behaviours between monitors and links let’s consider the following diagrams.\n\n\n\nFigure 2.6 demonstrates the different ways in which the linked/monitored process(i.e. Pid2) behaves when the process creating the link/monitor fails. It clearly illustrates that since links are bidirectional a failure in Pid1 will immediately be propagated to Pid2. On the other hand, in case 3 since monitors are\nunidirectional, Pid2 will not be notified of Pid1’s failure.\n\nNow let’s consider the case when process Pid2 terminates abnormally. As shown in the diagrams below an error in Pid2, will be immediately propagated to Pid1 both in the case when using monitors and links.\n\nWhen comparing the behaviour of linked and monitored processes one question that may spring to mind is if it is possible to define monitors in terms of links as described hereafter:\n\nProcess A\n\n```erlang\nmonitor(process,Pid2),\n....\n%%% error occurs - reason = stop\n```\n\nProcess B\n\n```erlang\n...\n```\n\nProcess A\n\n```erlang\nprocess_flag(trap_exit,true),\nlink(PidB),\n...\n%%% error occurs - reason = stop\n```\n\nProcess B\n\n```erlang\nprocess_flag(trap_exit,true),\n...\n```\n\nListing 2.6: Monitors & Links\nChapter 2. Background\n\nThe previous diagrams show that there is an overlapping behaviour between monitors and links - case 2 and 3 of both figures give the impression that by trapping exit signals, links are able to act just like monitors. However, at this point it is quite impossible to determine if these two behaviours are truly equivalent or not. Most surely this is one problem which the defined semantics will be able to tackle. This is due to the fact that the formal definitions will be able to give us a clear cut answer to this problem.\n\n2.5.6.2 spawn_link, spawn_monitor\n\nThe spawn_link and spawn_monitor functions are used to create and link or monitor the process as one atomic action. Perhaps here one might ask if the spawn_link construct is simply syntactic sugaring for spawn() followed by link().\n\n\\[\n\\text{spawn\\_link(module, function, [args])}, \\quad \\text{\\begin{align*}\n\\equiv & \\quad \\text{Pid} = \\text{spawn(module, function, [args])}, \\\\\n& \\text{link(Pid)},\n\\end{align*}}\n\\]\n\nListing 2.7: spawn_link & spawn() + link ()\n\nThe only possible way to answer such a problem is through a formal semantic definition of these constructs.\n\n2.5.6.3 Explicit Error Signals\n\nSo far, we have seen that the primary source of error signals is the failure of a linked/monitored process. An additional way how error signals can be generated is by using the exit(pid,reason) built-in function (In the following sections, this function will be referred to exit/2 so as to be able to distinguish this function from the exit function described in Section 2.5.5.1). This construct expects two arguments, the Pid to whom the error signal is to be sent and the reason describing the cause of the error. The behaviour of the receiving process depends mainly on two things:\n\n- The reason passed as the second argument\n- The recipient’s process flag\n\nIf the reason is equal to kill, the recipient process will terminate immediately with reason killed, irrespective if it is trapping exit signals or not. Otherwise, the behaviour of the recipient process will be determined by whether or not the\nrecipient is trapping the received exit signals as clearly illustrated in the diagram shown hereafter.\n\n\\[...\n\\text{exit}(\text{Pid2}, \\text{error}),\n\\]\n\\[...\n\\text{Pd1}\n\\]\n\\[...\n\\text{exit}(\text{Pid2}, \\text{error}),\n\\]\n\\[...\n\\text{Pd1}\n\\]\n\nFigure 2.8: Explicit error signals\n\nOne here cannot help noticing the striking similarity between the exit/2 construct and the behaviour of error propagation through links (see Figure 2.5.6.1). Perhaps at this point one might question if it is possible in some cases to implement the link behaviour by using only the exit/2 construct. For instance, in the following case, will the two processes always behave in an identical way?\n\n\\[\n\\begin{array}{l}\n\\text{Process 1} \\\\\n\\text{link(ProcessB),} \\\\\n\\text{link(ProcessC),} \\\\\n\\cdots \\\\\n\\text{exit(badarg),}\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{l}\n\\text{Process 2} \\\\\n\\text{?} \\Rightarrow \\text{exit(ProcessB,badarg),} \\\\\n\\text{exit(ProcessC,badarg),} \\\\\n\\text{exit(badarg),}\n\\end{array}\n\\]\n\nListing 2.8: Links & Explicit Exit Signals\n\nAt the moment it is quite difficult to ensure if the behaviour of these two processes is truly identical or not. This is due to the fact that, even though the definitions given so far seem to hint that these two processes are equivalent, there is no way to guarantee that they will always behave in the same way. Undoubtedly a formal semantic definition of these constructs is key to check if the same behaviour can actually be obtained by using these two different constructs.\n\nApart from sending explicit error signals to other processes, the exit/2 function can also be used to send error signals to the calling process. This can be done by passing the calling process’ pid as a first argument:\nChapter 2. Background\n\nexit(self(), Reason)\n\nThis generated exit signal may cause the calling process to terminate with reason Reason. One question that springs to mind here is if the behaviour of self-sent exit signals is equivalent to the exit(Reason) statement. This is due to the fact that the exit(Reason) expression may also cause the process to terminate with reason Reason (see Section 2.5.5.1).\n\n\\[\n\\begin{array}{c|c}\n\\text{exit(reason)} & \\Leftrightarrow \\text{exit(self(),reason)}\n\\end{array}\n\\]\n\nListing 2.9: exit(Reason) & exit(self(),Reason)\n\nCertainly, this is yet another interesting problem that the formal semantics should be able to solve.\n\n2.5.6.4 SumNProduct - Remote Error Handling\n\n\\[\n\\begin{align*}\n\\text{sumNProduct} & (\\text{List1, List2}) \\rightarrow \\\\\n& \\text{process_flag(trap_exit, true)}, \\\\\n& \\text{SumPid} = \\text{spawn_link(math, sumProcess, [self(), List1])}, \\\\\n& \\text{ProductPid} = \\text{spawn_link(math, productProcess, [self(), List2])}, \\\\\n& \\text{Sum} = \\text{receiveValue(SumPid, sum)}, \\\\\n& \\text{Product} = \\text{receiveValue(ProductPid, product)}, \\\\\n& [\\text{Sum}, \\text{Product}].\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{sumProcess} & (\\text{Pid, List}) \\rightarrow \\text{Pid} ! [\\text{sum, sum(List)}]. \\\\\n\\text{productProcess} & (\\text{Pid, List}) \\rightarrow \\text{Pid} ! [\\text{product, product(List)}].\n\\end{align*}\n\\]\n% check if the linked process terminated normally or not\nreceiveValue(Pid,Tag)->\n receive\n %% if linked process terminated normally\n %% then read result from mailbox\n {'EXIT',Pid,normal} ->\n receive\n [Tag,Value] -> Value\n end;\n%\n %% otherwise if process terminated abnormally\n %% return invalid\n {'EXIT',Pid,{badarith,Stack}} -> invalid\n end.\n\nListing 2.11: SumNProduct - Remote Error Handling\n\nIn this version of the sumNProduct system, Erlang will first set the process_flag to true. This is done so that the process will be able to trap any errors that might occur in any of the processes with whom it will become linked later on. Erlang will then spawn_link two separate processes; one to calculate the sum and the other to calculate the product.\n\n process_flag(trap_exit,true),\n SumPid = spawn_link(math,sumProcess,[self(),List1]),\n ProductPid = spawn_link(math,productProcess,[self(),List2]),\n\nListing 2.12: Parent process\n\nHere, it is worth pointing out that since both processes are linked and the process_flag is set to true, the parent process will receive an exit notification message once the linked processes have terminated. If the linked process completed its task normally, the parent process will receive an {'EXIT',Pid,normal} message. On the other hand, if the linked process terminated abnormally due to non-numeric data it will receive a {'EXIT',Pid,{badarith,Stack}} message. In both cases the Pid, refers to the pid of the terminated process. After creating the two processes, the parent process will then suspend until it receives the results of the two processes.\nChapter 2. Background\n\nreceiveValue(Pid,Tag)->\n receive\n {'EXIT',Pid,normal} ->\n receive\n [Tag,Value] -> Value\n end;\n {'EXIT',Pid,{badarith,Stack}} -> invalid\n end.\n\nListing 2.13: Receiving Results from processes\n\nWhat the receiveValue function essentially does is that it first checks if the process terminated either normally (an {'EXIT', Pid,normal} message was received) or abnormally (an {'EXIT', Pid,{badarith,Stack}} was received). If the linked process terminated normally, then it will read the result of the process’ computation i.e. either the sum or the product. The Tag variable can be either the sum or product atom and is used to indicate which of the two result should be read. If the linked process terminated abnormally, the system will return the atom invalid.\n\nPerhaps one major benefit of adopting the notion of remote error handling lies in the fact that sumProcess function and the productProcess function do not include any error handling code. In fact if we had to compare the sumProcess function with the one used in the parallel version of the system it becomes clear that through remote error handling the system enjoys a higher degree of separation of concerns.\n\n---\n\nLocal Error Handling\n\n\\[\n\\text{sumProcess}(\\text{Pid},\\text{List}) \\rightarrow \\\\\n\\text{Sum} = \\\\\n\\quad \\text{try} \\\\\n\\quad \\text{sum} (\\text{List}) \\\\\n\\quad \\text{catch} \\\\\n\\quad \\quad \\text{error:badarith} \\rightarrow \\text{invalid} \\\\\n\\quad \\text{end}, \\\\\n\\text{Pid} \\rightarrow [\\text{sum},\\text{Sum}].\n\\]\n\nRemote Error Handling\n\n\\[\n\\text{sumProcess}(\\text{Pid},\\text{List}) \\rightarrow \\\\\n\\quad \\text{Pid} \\rightarrow [\\text{sum},\\text{sum} (\\text{List})].\n\\]\n\nListing 2.14: Separation of Concerns\nChapter 2. Background\n\nThrough this simple example it becomes clear how remote error handling enables us to write fault-tolerant systems which are not cluttered up with exception handling coding. As a result, the number of lines related to error recovery within the system has been reduced. Even though the reduction in this simple system was minimal, one can easily imagine the significant reduction that can be achieved when this concept is applied to larger parallel systems. In fact in his book, Cesaroni claimed that a particular system which was formerly implemented in C++ experienced an amazing 85% reduction in code when implemented in Erlang. One of the main contributors to this dramatic reduction was Erlang’s error handling mechanisms since as stated in [12] “27% of the C++ code consisted of defensive programming”. It is a well-known known fact that the number of bugs within a system is directly proportional to the number of lines of code. Therefore, this reduction plays an important role in reducing drastically the presence of bugs within a system.\n\n2.6 Conclusion\n\nThis chapter has taken a closer look at the main constructs incorporated within Erlang. A simple example was used to acquaint us with Erlang’s error handling mechanisms. It was illustrated how Erlang enables us to handle errors locally through the try-catch construct similar to the way other conventional programming languages handle errors. The chosen example, was also implemented using Erlang’s remote handling mechanisms. This helped to bring out certain benefits that remote error handling has over local error handling namely reduction in lines of code and a higher degree of separation of concerns.\n\nHowever, one recurrent dilemma when describing these Erlang constructs was if some constructs could actually be implemented in terms of other constructs. One particular case was for instance that of monitors and trap-exit links. In addition, even though the sumNProduct system was implemented in different ways there was no way one could actually guarantee that the system really maintained its semantic definition. The next chapter attempts to solve these problems by presenting a formal semantic definition for these constructs. These definition will make it possible to indicate if two syntactically different systems have similar behaviour or not.\n3. Formal Semantics\n\n3.1 Introduction\n\nThe main focus of this chapter is to get a better understanding of Erlang’s error handling behaviour by presenting a formal model for Erlang’s error handling constructs. In order to better appreciate the usefulness of this model, a number of Erlang systems are considered and the behaviour of these systems is described in terms of the model.\n\n3.2 The need for Formal Semantics in Erlang\n\nMore often than not, the semantics of a language are more likely to be defined through informal description rather than through a formal one. However, lately more emphasis is being put on formal semantics, mainly due to the number of benefits they offer over their informal counterparts. In this section, the main drawbacks of using informal semantics to describe the behaviour of Erlang’s error handling constructs are discussed so as to better understand the need of a formal model.\n\nOne major downside of using informal descriptions stems from the fact that they leave scope for ambiguity and therefore, as clearly shown in the previous chapter, they are not able to show if two different programs will actually behave in the same way or not. In contrast, formal semantics are able to present an unambiguous and more accurate description of a system’s behaviour. Consequently, when using these semantics it becomes much more straightforward to show if the behaviour of two different programs is actually equivalent or not.\nAnother drawback of informal descriptions is that in certain cases, they may fail short of accurately describing how the different Erlang constructs might interact. As a result, it may become relatively challenging to understand a system’s behaviour through these semantics. This is even more so, when considering the fact that due to the parallel nature of Erlang systems, the interleaving of processes may result in different behaviour at consecutive executions of the same system. Thus, describing how parallel systems may behave by using informal semantics may result in really lengthy and cumbersome descriptions. On the other hand, through formal semantics it becomes much easier to reason about the behaviour of parallel systems. This is because, from their very nature they are able to provide concise but detailed descriptions of how a particular system might behave.\n\n3.3 Current Formal Semantics in Erlang\n\nDue to the fact that Erlang was conceived in industry, it was primarily defined in terms of its implementation[13]. However, given the significant role that formal semantics play in reasoning about the behaviour of systems, it was evident that defining such semantics for Erlang was key in understanding soundly the behaviour of Erlang programs. This is even more so, when considering the fact that Erlang systems are highly dynamic and concurrent and therefore, they tend to become quite challenging to fully reason about their behaviour. Erlang’s current formal semantics can be classified in three categories[16]:\n\n- functional semantics\n- process semantics\n- node semantics\n\nThe functional semantics, as the name itself implies, deals with the functional part of Erlang such as pattern matching and function evaluation whilst the process semantics deals with the process rules for instance, process termination, message passing and links. The semantics defined in these two categories, are used to describe the behaviour of systems found on a single machine[14]. On the other hand, the behaviour of multi-node systems can be described through the node semantics[13]. The term multi-node system refers to the fact that a particular\nChapter 3. Formal Semantics\n\nErlang system may sometimes be composed of multiple runtime systems communicating with each other. In Erlang each of these runtime systems is called a node. Multi-node systems are oftenly used when implementing distributed systems.\n\n3.3.1 Differences Between Current Semantics and Defined Model\n\nOne of the most noticeable difference between the current semantics and the defined model lies in the fact that whereas all current formal semantics of Erlang[14, 13] are defined by using an LTS semantics in this project the formal rules are defined by using a reduction semantics. By adopting this approach, the semantics are able to provide a clearer picture of how communication between processes is carried out. This is because, when using a reduction semantics both the sender and receiver of a signal are included in the rule definition. As a result, it becomes easier to see how a particular action has effected the receiving process. Additionally, the syntax of the reduction semantic definitions is somewhat closer to the way in which these semantics may be implemented through an evaluator.\n\nAnother benefit of reduction semantics is that they enable us to describe some Erlang behaviours through less formal rules. For instance, when defining message delivery through an LTS semantics three different rules are needed:\n\n- one rule describes the behaviour of a process when a message is sent\n\n\\[\n\\begin{align*}\n & i \\neq pid \\\\\n & i[pidl_v, q, l, b] \\xrightarrow{pidlv} i[v, q, l, b]\n\\end{align*}\n\\]\n\n- another rule to describe how the a process behaves on receipt of a message\n\n\\[\n\\begin{align*}\n & pid = i \\\\\n & i[e, q, l, b] \\xrightarrow{pidlv} i[e, q \\oplus v, l, b]\n\\end{align*}\n\\]\n\n- a rule to describe how delivery of messages occurs\n\n\\[\n\\begin{align*}\n & s_1 \\xrightarrow{pidlv} s_1'} \\\\\n & s_2 \\xrightarrow{pidlv} s_2' \\\\\n & s_1 || s_2 \\xrightarrow{\\tau} s_1' || s_2'\n\\end{align*}\n\\]\n\n34\nIn contrast, when describing the delivery of messages through reduction semantics only one rule is used:\n\n\\[ i \\neq pid \\]\n\\[ i[j!v, q, l, b] \\parallel j[e, q_j, l_j, b_j] \\rightarrow \\]\n\\[ i[v, q, l, b] \\parallel j[e, q_j + v, l_j, b_j] \\]\n\nAnother fact worth mentioning with respect to the current Erlang semantics, is that the formal semantic definition of certain mechanisms is somewhat inaccurate since it does not faithfully mirror the behaviour of actual Erlang. A case in point is the way the current semantics defines the behaviour of Erlang when a link failure occurs. According to these semantics whenever a process attempts to link to a terminated process, an exit signal is immediately sent to the process attempting to create the link. However, as clearly described in [18] a link failure may not necessary cause the system to behave in this way. The model presented in this chapter addresses this inaccuracy and defines a more accurate description of how Erlang behaves in the case of link failure.\n\nThe current semantics also fall short of describing the way a process may behave when it sends an explicit exit signal to itself (by using the exit(self(), Reason) expression). In fact, the current semantics are only able to describe soundly the way a system behaves when an explicit exit signal is sent to another different process. In the formal semantics described in this project some rules were defined to faithfully describe the way a process behaves when an explicit exit signal is sent to itself (see section 3.11.4).\n\nAnother improvement over the current semantics is that the presented model is able to describe both the linking and monitoring mechanisms in Erlang whereas the current semantics are only able to describe the linking behaviour. It is important to note that even though in [3] it was claimed that monitors can be implemented in terms of links, in truth there exist some subtle differences between the two mechanisms. As a result, implementing monitors in terms of links may not be as easy as it might seem. This fact is discussed in more depth in section 3.11.5, where a simple example is considered to highlight the main differences that exist between monitoring and linking.\n\nThe next sections presents the formal model defined in this project whose aim is to accurately describe the behaviour of Erlang systems in the presence of errors.\n3.4 Erlang System\n\nHere a formal description of an Erlang system will be given together with some fundamental rules that will be used as the foundation for the defined semantics.\n\nAn Erlang system can be composed of one or more processes. In the defined semantics an Erlang system is represented as a set of processes. A system which is composed of three processes is expressed as:\n\n\\[ P || Q || R \\]\n\nSome important rules within the defined semantics are the following:\n\n\\[\n\\begin{align*}\nP || Q & \\equiv Q || P \\quad \\text{(COMM)} \\\\\nP || (Q||R) & \\equiv (P||Q)||R \\quad \\text{(ASSOC)}\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\nP & \\equiv P' \\quad P \\rightarrow Q \\quad Q \\equiv Q' \\\\\nP' & \\rightarrow Q'\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\ns_1 & \\rightarrow s_1' \\\\\ns_1||s_2 & \\rightarrow s_1'||s_2\n\\end{align*}\n\\]\n\nTable 3.1: System rules\n\nIn this semantics it is assumed that Erlang systems are well-formed and therefore every process in a system has a unique pid. This assumption made it possible to define the following relation:\n\n\\[ \\text{pid} \\times \\text{system} \\rightarrow \\text{process} \\]\n\n3.5 Erlang Subset\n\nErlang has a relatively large number of constructs. Hence, defining a formal semantics for all these constructs would be rather infeasible since this would result in a rather cumbersome semantics. Therefore, for this work a reduced subset of Erlang (Table 3.2) was chosen.\ndigit :: = 0 | · · · | 9\nuppercase :: = A | · · · | Z\nlowercase :: = a | · · · | z\ndigitletter :: = digit|uppercase|lowercase | · | @\n\nnumber :: = digit+\nunquotedatom :: = lowercase digitletter*\nquotedatom :: = '(digitletter|whitespace)+'\natom :: = unquotedatom|quotedatom\nvar :: = uppercase digitletter*\n\nvalue(v) :: = atom\n| int\n| pid\n| []\n\ncompound value (cv) :: = v[ cv1 | cv2 ]\n\nexpression (e) :: = v | [e1|e2]\n| var\n| built-in function\n| e1, e2\n| case e of m end\n| try e catch m end\n| receive m end\n| e1; e2\n\npattern(p) :: = cv | var | [p1|p2]\nmatchPtn (m) :: = p1 → e1; · · · ; pn → en\n\nbuilt-in functions(b) :: = self()\n| spawn(e, e, e)\n| link(e)\n| monitor(e, e)\n| spawn_link(e, e, e)\n| spawn_monitor(e, e, e)\n| process_flag(e, e)\n| error(e)\n| throw(e)\n| exit(e)\n| exit(e, e)\n\nTable 3.2: Erlang’s subset\n\nWhen expressing the formal definitions of Erlang’s constructs some minor syntactic modifications were made to Erlang’s syntax. This was done so as to represent expressions in a neater way. These modifications are primarily the following:\n\n- a sequence of Erlang expressions will be delimited by a · instead of a comma.\nThis is because the comma will act as a delimiter for separating the different elements in the tuple representing an Erlang process.\n\n- the concept of modules will not be present in the defined semantics since the notion of modules does not in any way affect Erlang’s error handling behaviour. As a result, built-in functions such as spawn, spawn_link and spawn_monitor do not expect the module name parameter.\n\n### 3.6 Contextual Rules\n\nThe formal rules presented in this project are only able to describe the behaviour of expressions for the case when all parameters of an expression have already been evaluated down to a value. As a result, the reduction context rules are necessary in order to define the way a subexpression is evaluated with respect to a bigger context.\n\n\\[\n\\begin{align*}\n i[e, m, l, f] & \\rightarrow i[e', m', l', f'] \\quad \\text{CONTEXT}_0 \\\\\ni[c[e], m, l, f] & \\rightarrow i[c[e'], m', l', f'] \\quad \\text{CONTEXT}_0 \\\\\ni[e, m, l, f] & \\rightarrow i[ex, m', l', f'] \\quad \\text{CONTEXT}_1 \\\\\ni[c[e], m, l, f] & \\rightarrow i[ex, m', l', f'] \\quad \\text{CONTEXT}_1\n\\end{align*}\n\\]\n\nTable 3.3: Contextual rules\n\nA reduction context, c[] defines a subexpression position such that, if a subexpression e performs an action and reduces down to e1, than the whole expression can perform the same action and only the subexpression e is changed. For instance, when evaluating the following case statement\n\n\\[\n\\text{case } e \\text{ of } m \\text{ end}\n\\]\n\nthe model will first try to reduce expression e. If e reduces down to e1, then the whole expression reduces down to\n\n\\[\n\\text{case } e_1 \\text{ of } m \\text{ end.}\n\\]\nWhat the \\texttt{c[\\cdot]} definition essentially states is that when reducing a function call Erlang will evaluate the functions parameters from left to right. Elements in a list are also evaluated from left to right. When evaluating a send statement, Erlang will first evaluate the expression on the left hand side, and subsequently it will start evaluating the expression found after the \\texttt{!} operator. The last part of the definition describes the fact that when evaluating a case statement Erlang will first evaluate the expression found between the \\texttt{case} and \\texttt{of} keywords.\n\n### 3.7 Erlang Process\n\nIn this section the notion of an Erlang process is formalised. In this semantics processes may be in one of two states, either alive or terminated. Here, it is worth mentioning the fact that terminated processes cannot be considered as dead or useless processes. This is due to the fact that terminated processes will still have some tasks to carry out such as informing all processes found in their link set about their termination. Additionally, terminated processes are also used when defining the behaviour of the linking mechanism.\n\nA live process is represented as\n\n\\[\np[e, m, l, f]\\\n\\]\n\n- \\texttt{pid(p)} - a unique process identifier\n- \\texttt{expression(e)} - the expression the process is executing\n- \\texttt{mailbox(m)} - a list of received messages that are waiting to be read\n- \\texttt{links(l)} - the set of pids to which the process is linked\n- \\texttt{flag(f)} - a boolean value indicating if a process is trapping exit signals or not\nChapter 3. Formal Semantics\n\nA terminated process is expressed as\n\\[ p[r,l] \\]\n\n\\( \\text{pid}(p) \\) - a unique process identifier\n\\( \\text{reason}(r) \\) - reason describing process termination\n\\( \\text{links}(l) \\) - the set of pids found in the link set\n\nA live Erlang process may terminate either normally or abnormally.\n\n\\[\n\\begin{align*}\n\\text{TERM}_0 & : i[v, m, l, f] \\rightarrow i[\\text{normal}, l] \\\\\n\\text{TERM}_1 & : i[\\text{ex}, m, l, f] \\rightarrow i[\\text{reason}(\\text{ex}), l]\n\\end{align*}\n\\]\n\nTable 3.4: Process Termination Rules\n\n\\( \\text{TERM}_0 \\) states that when a process completes its task, it will terminate with reason \\text{normal}. Otherwise, the reason will describe the error that caused the process to terminate(\\( \\text{TERM}_1 \\)).\n\n### 3.8 Case Statement\n\n\\[\n\\begin{align*}\n\\exists I. ((\\text{result } v \\text{ mt } e) \\land \\forall J. J < I \\Rightarrow \\neg (\\text{matches } v \\text{ mt } J)) & : \\quad i[\\text{case } v \\text{ of mt end}, m, l, f] \\rightarrow i[e, m, l, f] \\quad \\text{CASE}_0 \\\\\n\\forall I. \\neg (\\text{matches } v \\text{ mt } I) & : \\quad i[\\text{case } v \\text{ of mt end}, m, l, f] \\rightarrow i[\\text{error}(:\\text{case}_\\text{clause}, v), m, l, f] \\quad \\text{CASE}_1\n\\end{align*}\n\\]\n\nTable 3.5: Case rules\n\nBefore describing what these rules state, the \\text{matches} and \\text{result} functions will be defined. (The definition of these two function is very similar to the one defined in [14].)\n\nThe \\text{matches} function is defined as:\n\n\\[\n\\text{matches } v \\ (p \\to e) \\triangleq \\exists V. (v = p\\{V/fv(p)\\})\n\\]\n\n40\nThe *matches* function is given two parameters, a value\\( (v) \\) and a \\((pattern \\rightarrow expression)\\). This function returns true if pattern \\( p \\) is identical to value \\( v \\) once the substitution\\( (p\\{\\hat{V}/f_v(p)\\}) \\) is done. Two functions used in this substitution are the:\n\n- \\( \\hat{V} \\): returns all the values found in \\( v \\). For example, if \\( v = [1, 2, 3, 4] \\) then \\( \\hat{V} = 1, 2, 3, 4 \\).\n- \\( f_v(p) \\): returns all the free variables found in pattern \\( p \\). For instance, \\( f_v([a, B, c, D]) = [B, D] \\).\n\nWhat the \\( p\\{\\hat{V}/f_v(p)\\} \\) substitution essentially does is that it replaces variables according to their position in the list. For instance, let’s consider the case when:\n\n\\[\n\\begin{align*}\nv &= [1, 2, 3, 4] \\\\\n\\hat{V} &= 1, 2, 3, 4 \\\\\np &= [a, X, c, Y] \\\\\nf_v(p) &= X, Y\n\\end{align*}\n\\]\n\nIn this case, when evaluating \\( p\\{\\hat{V}/f_v(p)\\} \\), free variable \\( X \\), the second element of \\( p \\), is replaced by 2, the second element of \\( v \\), and free variable \\( Y \\), the fourth element of \\( p \\) is replaced by 4, the fourth element of \\( v \\):\n\n\\[\np\\{\\hat{V}/f_v(p)\\} = [a, 2, c, 4]\n\\]\n\nIf \\( p \\) and \\( v \\) have different arities no replacements are done.\n\nThe *result* function is defined as:\n\n\\[\n\\text{result } v \\ (p \\rightarrow e) \\ e' \\triangleq \\exists \\hat{V}.(v = p\\{\\hat{V}/f_v(p)\\} \\land e' = e\\{\\hat{V}/f_v(p)\\})\n\\]\n\nThe *result* function is very similar to the *matches* function. The only difference is that this function has an extra parameter \\( e' \\). This parameter represents the corresponding body of the pattern which successfully pattern matched against the given value. For instance, in the following case, this predicate will return true:\n\n\\[\n\\begin{align*}\nv &= [text, hello] \\\\\np \\rightarrow e &= [text, Value] \\rightarrow Value\n\\end{align*}\n\\]\n\n\\[\ne' = hello\n\\]\nChapter 3. Formal Semantics\n\nNow let’s move on to describe the behaviour of the case statement as defined in these rules. The first rule states that the system will try to pattern match the value against the patterns found in $mt$($CASE_0$). The patterns in $mt$ are sequentially matched against the value $v$ found between the case and of keywords. The described reduction step is done if\n\n$$\\exists I.((\\text{result } v \\text{ mt } I e) \\land \\forall J. J < I \\Rightarrow \\neg (\\text{matches } v \\text{ mt } J))$$\n\nWhat the above predicate essentially states is that a case statement will return the expression $e$ if\n\n- one of the elements in $mt$, say $(p_1 \\rightarrow e)$, consists of a pattern $p_1$ that can be successfully pattern matched against $v$ and\n- all the elements prior to $(p_1 \\rightarrow e)$ fail to pattern match against $v$\n\nTherefore, if we evaluate the following case statement according to $CASE_0$:\n\n```latex\ncase [a,b,c] of\n [X,Y] \\rightarrow \\text{first};\n [X,Y,Z] \\rightarrow \\text{second};\n X \\rightarrow \\text{third}\nend.\n```\n\nthe system first tries to pattern match $[a,b,c]$ against $[X,Y]$ and it fails. Subsequently, it attempts to pattern match $[a,b,c]$ against $[X,Y,Z]$ and it succeeds. As a result, it returns the atom second. Note that the value $[a,b,c]$ can be also successfully pattern matched against the last pattern $X$. However, the defined rule states that the case statement should always return the body of the first pattern against which $[a,b,c]$ is successfully pattern matched.\n\nThe second rule states that if the value fails to pattern match against any of the patterns in $mt(\\forall I.\\neg (\\text{matches } v \\text{ mt } I))$, then an exception is raised($CASE_1$).\n3.9 Local Error Handling - try-catch\n\n\\[\n\\begin{align*}\n\\text{TRY}_0: & \\quad i[\\text{try } v \\text{ catch } mt \\text{ end}, m, l, f] \\rightarrow i[v, m, l, f] \\\\\n\\text{TRY}_1: & \\quad i[e, m, l, f] \\rightarrow i[e', m', l', f'] \\\\\n\\text{TRY}_2: & \\quad \\exists I.((\\text{result } ex \\text{ mt}_1 \\ e') \\land \\forall J. J < I \\Rightarrow \\neg(\\text{matches } ex \\text{ mt}_J)) \\\\\n\\text{TRY}_3: & \\quad \\forall I. \\neg(\\text{matches } ex \\text{ mt}_1) \\\\\n\\end{align*}\n\\]\n\nTable 3.6: Rules for local error handling\n\nThese rules describe that Erlang will first try to evaluate the expression between the try and catch statement (TRY$_1$). If this expression evaluates down to a value than that value is returned (TRY$_0$). If the expression raises an exception, the system will try to pattern match the exception against the patterns found in $mt$ and if the exception pattern matches, the corresponding error handling code is returned (TRY$_2$). Otherwise, if the exception is not caught the try expression will return the raised exception. (TRY$_3$).\n\n3.9.1 sumNProduct Example (Sequential version)\n\nUsing the rules defined so far it is now possible to get a step-by-step description of how the example explained in section 2.5.5.3 is evaluated. Here, only the reduction steps related to the evaluation of $\\text{sum}(\\text{List1})$ will be shown.\n\n\\[\n\\begin{align*}\n\\text{try } \\text{sum}(\\text{List1}) \\text{ catch } \\text{error:badarith} \\rightarrow 0 \\text{ end},\\ldots\n\\end{align*}\n\\]\n\nThe evaluation of\n\n\\[\n\\ldots \\text{try } \\text{product}(\\text{List2}) \\text{ catch } \\text{error:badarith} \\rightarrow 0 \\text{ end}.\n\\]\nChapter 3. Formal Semantics\n\nis almost identical. First, let’s consider the case when the input list is the numeric list \\([12, 5]\\). By using rule TRY\\(_1\\) the system will first evaluate \\(\\text{sum}([12, 5])\\):\n\n\\[\ni\\text{try } \\text{sum}([12, 5]) \\text{ catch error : badarith } \\rightarrow \\text{invalid end} \\cdot e_1, \\epsilon, \\emptyset, \\text{false}\n\\]\n\n\\[\n\\rightarrow i\\text{try } 12 + \\text{sum}([5]) \\text{ catch error : badarith } \\rightarrow \\text{invalid end} \\cdot e_1, \\epsilon, \\emptyset, \\text{false} \\quad \\text{(TRY\\(_1\\))}\n\\]\n\n\\[\n\\rightarrow i\\text{try } 12 + 5 \\text{ catch error : badarith } \\rightarrow \\text{invalid end} \\cdot e_1, \\epsilon, \\emptyset, \\text{false} \\quad \\text{(TRY\\(_1\\))}\n\\]\n\nwhere \\(e_1 = \\text{try product}([12, 5]) \\text{ catch error : badarith } \\rightarrow \\text{invalid end}: [\\text{Sum, Product}]\\)\n\nSince the expression between the try and catch block evaluated down to a value, by rule TRY\\(_0\\) the whole try-catch construct will evaluate down to 17.\n\n\\[\n\\rightarrow i\\text{try } 17 \\text{ catch error : badarith } \\rightarrow \\text{invalid end} \\cdot e_1, \\epsilon, \\emptyset, \\text{false} \\quad \\text{(TRY\\(_1\\))}\n\\]\n\n\\[\n\\rightarrow i[17 \\cdot e_1, \\epsilon, \\emptyset, \\text{false}] \\quad \\text{(TRY\\(_0\\))}\n\\]\n\n\\[\n\\rightarrow i[e_1, \\epsilon, \\emptyset, \\text{false}] \\quad \\text{(SEQ\\(_1\\))}\n\\]\n\nThe system will then continue to evaluate \\(e_1\\).\n\nOne here can appreciate that the defined rules make it possible to ascertain that the system will always return the sum of the input list whenever valid numbers are input since there does not exist any other possible sequences of steps that may lead to a different result.\n\nNow let’s consider the case where the input list contains a non-numeric value; \\([a, 12]\\). As in the previous case the system will first evaluate the expression found within the try catch block:\n\n\\[\ni\\text{try } \\text{sum}([a, 12]) \\text{ catch error : badarith } \\rightarrow \\text{invalid end} \\cdot e_1, \\epsilon, \\emptyset, \\text{false}\n\\]\n\n\\[\n\\rightarrow i\\text{try } a + \\text{sum}([12]) \\text{ catch error : badarith } \\rightarrow \\text{invalid end} \\cdot e_1, \\epsilon, \\emptyset, \\text{false} \\quad \\text{(TRY\\(_1\\))}\n\\]\n\n\\[\n\\rightarrow i\\text{try } a + 12 \\text{ catch error : badarith } \\rightarrow \\text{invalid end} \\cdot e_1, \\epsilon, \\emptyset, \\text{false} \\quad \\text{(TRY\\(_1\\))}\n\\]\n\nwhere \\(e_1 = \\text{try product}([12, 5]) \\text{ catch error : badarith } \\rightarrow \\text{invalid end}: [\\text{Sum, Product}]\\)\n\n44\nWhen the system attempts to add a to 12 a *badarith* exception is raised:\n\n\\[ \\rightarrow i[\\text{try error badarith catch error badarith} \\rightarrow \\text{invalid end} \\cdot e_1, \\epsilon, \\emptyset, \\text{false}] \\] \n\n(TRY₁)\n\nThe generated exception is caught and therefore the output of this computation will be the atom *invalid*.\n\n\\[ \\rightarrow i[\\text{invalid} \\cdot e_1, \\epsilon, \\emptyset, \\text{false}] \\] \n\n(TRY₂)\n\n\\[ \\rightarrow i[e_1, \\epsilon, \\emptyset, \\text{false}] \\] \n\n(SEQ₁)\n\nThe system will then continue to evaluate \\( e_1 \\).\n\n### 3.10 Parallel Erlang\n\n\\[\n\\text{fresh}(j)\n\\]\n\n\\[\n\\frac{\\text{i}[\\text{spawn}(f, \\text{args}), m, l, f]}{\\text{SPAWN}}\n\\]\n\n\\[\ni[\\text{spawn}(f, \\text{args}), m, l, f] \\rightarrow i[j, m, l, f] || j[f(\\text{args}), \\epsilon, \\emptyset, \\text{false}]\n\\]\n\n\\[\ni = j\n\\]\n\n\\[\ni[j!v, m, l, f] \\rightarrow i[v, m + v, l, f]\n\\]\n\n(i ≠ j)\n\n\\[\ni[j!v, m_i, l_i, f_i] || j[e_j, m_j, l_j, f_j] \\rightarrow i[v, m_i, l_i, f_i] || j[e_j, m_j + v, l_j, f_j]\n\\]\n\n(i ≠ j)\n\n\\[\ni[j!v, m_i, l_i, f_i] || j[\\text{reason}, \\{\\text{pids}\\}] \\rightarrow i[v, m_i, l_i, f_i] || j[\\text{reason}, \\{\\text{pids}\\}]\n\\]\n\n\\[\\exists I.((\\text{result } v \\text{ mt}_I \\epsilon) \\land \\forall J. J < I \\Rightarrow \\neg(\\text{matches } v \\text{ mt}_J))\\]\n\n\\[\ni[?\\text{mt}, m_1 + v + m_2, l_i, f_i] \\rightarrow i[e, m_1 + m_2, l, f]\n\\]\n\nTable 3.7: Process rules\nThe SPAWN rule states that whenever a new process is created, its identifier must be unique($\\text{fresh}(j)$). It also illustrates that the new process will have an empty mailbox and link set. Additionally, by default it will not be trapping any exit signals since its process_flag is set to false.\n\nWith regards to message delivery, it was assumed that all messages arrive in their destination instantaneously. In fact, in actual Erlang when dealing with single-node systems it is guaranteed message delivery is immediate. The instantaneous message delivery is described by the three SEND rules. SEND$_0$ describes the fact that when a process sends a message to itself, the message is immediately appended to the process’ mailbox. When a process sends a message to another process, say process $j$ then this message is appended immediately to process $j$’s mailbox(SEND$_1$). The last send rule describes the fact that when a message is sent to terminated process $j$ then the message is not appended to process $j$’s mailbox(SEND$_2$).\n\nWhat the RCV rule states is that the receive construct will attempt to pattern match sequentially the patterns found in $mt$ with the messages found in the mailbox. The body of the first pattern to pattern match against one of the messages in the mailbox will be returned. This fact is described through the following predicate:\n\n$$\\exists I.((\\text{result } v \\text{ mt } I e) \\land \\forall J. J < I \\Rightarrow \\neg(\\text{matches } v \\text{ mt } J))$$\n\nFor this predicate to hold:\n\n- one of the patterns in $mt$ must pattern match against the message $v$ which is currently found in the process’ mailbox described as $[m_1 + v + m_2]$\n- all messages found in the mailbox prior to $v$ i.e. in $[m_1]$ do not pattern match against any of the patterns found prior to $mt_I$.\n\nOnce a message has been pattern matched it is removed from the mailbox. Note that if no messages pattern match against any of the patterns in $mt$ than the system will block. This is the main reason why there is no reduction rule defined to cater for this particular case.\nChapter 3. Formal Semantics\n\n3.10.1 sumNProduct Example (Parallel Version)\n\nThrough these rules, it is now possible to describe the behaviour of the sumNProduct system (parallel version). In this version, two separate processes are used to calculate the sum and product of the input lists. We will first consider the case when two valid lists are input; for this example both input lists are [12,5].\n\nFirstly, the system will spawn a new process whose task is to calculate the sum of [12,5]. The pid of the newly created process, in this case $j$, will be returned to the parent process $i$.\n\n\\[\ni[\\text{spawn}(\\text{sumProcess}, [i, [12,5]]) \\cdot e_1, \\epsilon, \\emptyset, \\text{false}] \\]\n\n\\[\n\\rightarrow i[j \\cdot e_1, \\epsilon, \\emptyset, \\text{false}] \\parallel j[\\text{sumProcess}(i, [12,5]), \\epsilon, \\emptyset, \\text{false}] \\quad \\text{(SPAWN)}\n\\]\n\n\\[\n\\rightarrow i[e_1, \\epsilon, \\emptyset, \\text{false}] \\parallel j[\\text{sumProcess}(i, [12,5]), \\epsilon, \\emptyset, \\text{false}] \\quad \\text{(SEQ1)}\n\\]\n\nwhere $e_1 = \\text{spawn}(\\text{productProcess}, [i, [12,5]]) \\cdot ?[\\text{sum}, \\text{Value1}] \\rightarrow ?[\\text{product}, \\text{Value2}] \\rightarrow [\\text{Value1}, \\text{Value2}]$.\n\nProcess $i$ will then spawn another process whose task is to calculate the product of [12,5].\n\n\\[\n\\rightarrow i[k \\cdot e_2, \\epsilon, \\emptyset, \\text{false}] \\parallel k[\\text{productProcess}(i, [12,5]), \\epsilon, \\emptyset, \\text{false}] \\parallel\nj[\\text{sumProcess}(i, [12,5]), \\epsilon, \\emptyset, \\text{false}] \\quad \\text{(SPAWN)}\n\\]\n\nwhere $e_2 = ?[\\text{sum}, \\text{Value1}] \\rightarrow ?[\\text{product}, \\text{Value2}] \\rightarrow [\\text{Value1}, \\text{Value2}]$.\n\nOnce the sum of the list has been calculated, the $\\text{sumProcess}$ functions will evaluate the $i![\\text{sum}, 17]$ expression. When evaluating this expression, process $j$ will send a message containing the sum result to process $i$. The sent message will be appended to process $i$’s mailbox.\n\n\\[\n\\equiv j[i![\\text{sum}, 17]), \\epsilon, \\emptyset, \\text{false}] \\parallel i[e_2, \\epsilon, \\emptyset, \\text{false}] \\parallel s_k\n\\]\n\n\\[\n\\rightarrow j[[\\text{sum}, 17], \\epsilon, \\emptyset, \\text{false}] \\parallel i[e_2, [[\\text{sum}, 17]], \\emptyset, \\text{false}] \\parallel s_k \\quad \\text{(SEND1)}\n\\]\n\nwhere $s_k = k[\\text{productProcess}(i, [12,5]), \\epsilon, \\emptyset, \\text{false}]$.\n\nSimilarly, once the product of the list has been calculated, the $\\text{productProcess}$\nfunctions will evaluate the $i!\\text{[product, 60]}$ expression. When evaluating this expression, process $k$ will send the product result to process $i$. This will be also appended to process $i$’s mailbox.\n\n$$\n≡ k[i!\\text{[product, 60]}], \\epsilon, \\emptyset, \\text{false} \\parallel i[e_2, \\epsilon, \\emptyset, \\text{false}] \\parallel s_j\n$$\n\n$$\n→ k[\\text{[product, 60]}, \\epsilon, \\emptyset, \\text{false}] \\parallel\ni[e_2, \\text{[sum, 17, product, 60]}, \\emptyset, \\text{false}] \\parallel s_j\n$$\n\nwhere $s_j = j[\\text{[sum, 17]}, \\epsilon, \\emptyset, \\text{false}]\n\nProcess $i$ will then start reading the received messages. It will first read the sum Value. Once this message is read it will be removed from the mailbox.\n\n$$\n≡ i[?\\text{[sum, Value1]} \\rightarrow ?\\text{[product, Value2]} \\rightarrow, \\text{[sum, 17, product, 60]}, \\emptyset, \\text{false}] \\parallel s_j \\parallel s_k\n$$\n\n$$\n→ i[?\\text{[product, Value2]} \\rightarrow \\text{[17, Value2]}, \\text{[product, 60]}, \\emptyset, \\text{false}] \\parallel s_j \\parallel s_k\n$$\n\n(RCV)\n\nSubsequently, process $i$ reads the received product result. Once this message is read it is also removed from the mailbox. The system will then return a list containing the sum and product of the input lists.\n\n$$\n→ i[\\text{[17, 60]}, \\epsilon, \\emptyset, \\text{false}] \\parallel s_j \\parallel s_k\n$$\n\n(RCV)\n\nThe above steps show only one possible sequence of reductions that leads to the expected output i.e. [17,60]. One fact worth pointing out here is that in truth there are several other possible interleavings which can lead to the same output. For instance, process $j$ could have sent the [sum,17] message before process $i$ spawned process $k$. In fact, even though this system consists only of three processes there are relatively many different possible interleavings. Nonetheless, the defined semantic rules enable us to check that given the same input there does not exist any possible interleaving that may lead to a different output. Here one can appreciate even more how such simple rules have in actual fact paved the way to show such an essential fact.\n\nIn order to check if the parallel version of sumNProduct is semantically equiv-\nalent to the sequential version we will need to check the case when invalid data is passed. Though it will not be illustrated here (since the reduction steps are highly similar to the ones described in the sequential version of the sumNProduct example), through these semantics it is possible to show that in fact the system will always evaluate down to \\([invalid, invalid]\\) when given non-numeric data. Therefore, it can be concluded that the parallel version of sumNProduct is semantically equivalent to its sequential version.\n\n### 3.11 Remote Error Handling\n\n#### 3.11.1 Links and System Processes\n\n\\[\n\\begin{align*}\n\\text{LINK}_0 & : \\quad i[\\text{link}(j), m, l, f_i] \\ || \\ j[e_j, m_j, l_j, f_j] \\rightarrow \\\\\n& \\quad i[\\text{true}, m, l \\cup \\{j\\}, f_i] \\ || \\ j[e_j, m_j, l_j \\cup \\{i\\}, f_j] \\\\\n& \\quad f = \\text{true}\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{LINK}_1 & : \\quad i[\\text{link}(j), m, l, f] \\ || \\ j[v, l] \\rightarrow \\\\\n& \\quad i[\\text{true}, m + \\prime\\text{EXIT}', j, \\text{noproc}], l, f] \\ || \\ j[v, l] \\\\\n& \\quad f = \\text{false}\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{LINK}_2 & : \\quad i[\\text{link}(j), m, l, f] \\ || \\ j[v, l] \\rightarrow \\\\\n& \\quad i[\\text{error: noproc}, m, l, f] || j[v, l]\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{PROC\\_FLAG} & : \\quad i[\\text{process\\_flag}(\\text{trap\\_exit}, \\text{flag}_1), m, l, f_2] \\rightarrow \\\\\n& \\quad i[f_2, m, l, \\text{flag}_1]\n\\end{align*}\n\\]\n\nTable 3.8: Process rules for linking and system processes\n\nAs already described in section 2.5.6 links are the underlying factor behind Erlang’s remote handling mechanisms. These three rules bring to light the fact that the link expression can be also used as a ping. This is because the link(Pid) expression is able to indicate if the process identified by Pid is alive (LINK\\_0) or dead (LINK\\_1 or LINK\\_2). Rule LINK\\_0 describes Erlang’s behaviour when a process successfully links to another process. Here, it is worth mentioning the fact that since in this semantics links are expressed as a set, it is ensured that whenever a process attempts to link to a process which is already found in its link set...\nnothing actually happens. This guarantees that the defined rules are faithful to the behaviour of actual Erlang.\n\nThe last two rules describe Erlang’s behaviour when a process tries to link to a terminated process. LINK\\textsubscript{1} describes link failure when the process calling link is trapping exit signals i.e. the process\\_flag is set to true. In this case a link failure will result in a message to be appended to the calling process’ mailbox. LINK\\textsubscript{2} describes the case when the calling process is not trapping exit signals. In this case a link failure evaluate down to an exception. Interestingly enough all semantics which have attempted to describe Erlang’s error handling mechanisms so far, always describe a link failure in the following way:\n\n\n\nFigure 3.1: Link Failure as described by Current Semantic Definitions\n\nAs shown in the above diagram, according the these semantics a link failure will always trigger the terminated process to send an exit signal with reason noproc. Consequently, since process A is not trapping exit signals, the sent signal will cause process A to terminate with reason \\textit{noproc}.\n\nHowever, according to Erlang’s reference manual [23], a link failure may result in either of the following:\n\n- If the calling process is not trapping exits, and checking Pid is cheap\n - that is, if Pid is local – link/1 fails with reason noproc.\n- Otherwise, if the calling process is trapping exits, and/or Pid is remote, link/1 returns true, but an exit signal with reason noproc is sent to the calling process.\n\nAll previous semantic definitions seem to ignore the fact that a link call may also evaluate down to an exception with reason \\textit{noproc}. Perhaps the reason why this was deemed to be correct was that the generated exception, if uncaught, may\nstill terminate the calling process with reason *noproc*. Nevertheless, this semantic definition is not capable of describing correctly the behaviour of actual Erlang when a link failure occurs within a try-catch block. For instance, let’s consider the following case:\n\n```erlang\ntry\n link(Pid)\ncatch\n error:noproc -> 'process is dead'\nend,\nPid2!hello.\n```\n\nListing 3.1: Link Failure Program\n\nIn the above case, the exception generated due to link failure will be caught. As a result, the process will still be able to send the *hello* message to Pid2. However, if the above coding is evaluated using the previous semantic definitions, the link failure will cause the calling process to terminate immediately with reason *noproc*. This is so, because a try-catch is only capable of catching exceptions (i.e. exit signals cannot be caught by using the try-catch construct). When considering this example it becomes clear that the previous semantic definition of link failure is somewhat inaccurate to the behaviour of actual Erlang.\n\nThe last rule described in Table linkProcFlag is the PROC_FLAG rule. This rule states the behaviour of a system process upon receipt of an exit signal. Once a process receives an exit signal it may either terminate abruptly or else it may translate the received signal into a normal message which is appended it to its own mailbox. One of the main factors which decides which course of actions to take is the process_flag. If the process_flag, (which in our semantics is expressed as the last element of the process tuple) is set to true, then the received exit signal will not cause the process to terminate immediately. Conversely, if the process_flag is set to false, the process may terminate immediately upon receipt of an exit signal. The process_flag function’s second argument is a boolean value which determines if the flag should be set or unset. As stated in the PROC_FLAG rule, once the function is evaluated the previous flag value (i.e. flag₀) will be returned.\n### 3.11.2 Error Propagation\n\n\\[ \\begin{align*}\n&v = \\text{normal} \\land f = \\text{false} \\land j \\in \\text{pids} \\quad \\text{EXIT}_0 \\\\\n&i[v, \\text{pids}] \\parallel j[e, m, l, f] \\rightarrow i[v, \\text{pids} \\setminus \\{j\\}] \\parallel j[e, m, l \\setminus \\{i\\}, f]\n\\end{align*} \\]\n\n\\[ \\begin{align*}\n&v \\neq \\text{normal} \\land f = \\text{false} \\land j \\in \\text{pids} \\quad \\text{EXIT}_1 \\\\\n&i[v, \\text{pids}] \\parallel j[e, m, l, f] \\rightarrow i[v, \\text{pids} \\setminus \\{j\\}] \\parallel j[v, l \\setminus \\{i\\}]\n\\end{align*} \\]\n\n\\[ \\begin{align*}\n&f = \\text{true} \\land j \\in \\text{pids} \\quad \\text{EXIT}_2 \\\\\n&i[v, \\text{pids}] \\parallel j[e, m, l, f] \\rightarrow i[v, \\text{pids} \\setminus \\{j\\}] \\parallel j[e, m + [\\text{EXIT}, i, v], l \\setminus \\{i\\}, f]\n\\end{align*} \\]\n\nTable 3.9: Error propagation\n\nThe above rules state the behaviour of Erlang processes on receipt of an error signal. To better understand the relation between these rules and the behaviour of Erlang’s error propagation let’s consider the following diagram:\n\nFigure 3.2: Exit propagation through links\n\nFigure 3.2 depicts a system which is composed of three processes. Process A is linked to Process B and Process C. When process A terminates, an error signal will be sent to both linked processes. The main difference between the two processes is that process C is a system process (i.e. it is trapping exit signals).\nwhile process B is not. Through this diagram it becomes quite evident that the behaviour of a process on receipt of an error signal depends mainly on two things\n\n- if a process is a system process\n- if the reason of the received exit signal is equal to normal or not\n\nAs clearly illustrated in the diagram a normal termination ($v = \\text{normal}$) will never cause a linked process to terminate immediately. Therefore, if a process which is not trapping exit signals receives an exit signal where reason is equal to normal, the receiving process will ignore this signal (EXIT$_0$). Instant termination of a linked process can only happen as a result of an abnormal termination of a linked process (EXIT$_1$). If a linked process is trapping exit signals, the received exit signal will be translated into a message and appended to the process’ mailbox (EXIT$_2$).\n\nIn our semantics a terminated process is expressed as $\\text{pid} [v, \\text{linkSet}]$. Therefore, in the above case process A will be expressed as $A[v, \\{B, C\\}]$. The receiving process will be able to identify the cause of process termination by reading $v$; if the process has terminated normally the value of $v$ will be equal to normal. Otherwise, $v$ will describe the error which occurred for instance badarith.\n\nHere, it is worth pointing out that the fact, that the group of linked pids are expressed as a set is key. This is mainly due to the fact that sets from their very nature:\n\n- do not determine order between elements\n- do not store duplicates\n\nThe first point guarantees that the sending of error signals in our semantics is not done in any particular order. This ensures that these rules faithfully describe the behaviour error propagation since in actual Erlang the order in which error signals are sent is not determined. For instance, if we consider the following piece of code\n\n```\nlink(Pid1),\nlink(Pid2),\n.......,\n%%error occurs\n```\n\neven though Pid1 is added to the link set prior to Pid2, it is not guaranteed that an error signal will be first sent to Pid1. In actual fact, since the order is not\ndetermined, it may very well be the case that the same system will sometimes first send an error signal to Pid1 and at other times first send an error signal to Pid2. The fact that sets do not store duplicates also plays a crucial role in ensuring that the defined semantics is loyal to the behaviour of actual Erlang. For instance, in the following case:\n\n\\[\n\\begin{align*}\n&\\text{link(Pid1),} \\\\\n&\\text{link(Pid1),} \\\\\n&\\text{.....,} \\\\\n&\\text{%%error occurs}\n\\end{align*}\n\\]\neven though the process attempted to create a link to Pid1 twice, Pid1 will still be found once in the process’ link set. As a result, when sending error signals to all processes found in the link set only one error signal will be sent to Pid1. Additionally, in the defined rules the set of linked processes is updated immediately \\((pids \\setminus \\{j\\})\\) once an error signal has been sent so as to ensure that no duplicate error signals are sent.\n\n### 3.11.3 Spawn_link\n\n\\[\n\\begin{align*}\n&i[sf\\text{paw_n\\_link}(f, args), m, l, f] \\rightarrow \\\\\n&\\quad i[j, m, \\{l \\cup j\\}, f] || j[f(args), \\epsilon, \\{i\\}, false]\n\\end{align*}\n\\]\n\nTable 3.10: Spawn_link rule\n\nAs stated by this rule, the spawn_link primarily consists of a function which creates a new process and links to it as one atomic action. Perhaps one question that may come to mind at this point is whether it is possible to define spawn_link in terms of spawn followed by link. For instance, let’consider the following system:\n\n%% this function will cause the process to terminate\n%% with reason badarith\n\\text{doError(Pid)} \\rightarrow \\text{Pid ! a + a.}\n\n\\text{processA() \\rightarrow} \\\\\n\\text{process_flag(trap_exit, true),} \\\\\n\\text{%% spawn_link new process} \\\\\n\\text{spawn_link(moduleName, doError, [self()]),}\nBy using the defined rules, it is possible to ascertain that the above system will be always return the same result. The below description gives one possible interleaving how this result can be achieved.\n\nThe system will first set its process_flag so as to be able to trap any received exit signals.\n\n\\[\ni \\text{process\\_flag}(\\text{trap} \\_\\text{exit}, \\text{true}) \\cdot e, \\epsilon, \\emptyset, \\text{false}\n\\]\n\n\\[\n\\rightarrow i[\\text{false} \\cdot e, \\epsilon, \\emptyset, \\text{true}] \\quad \\text{(PROC\\_FLAG)}\n\\]\n\nwhere \\( e = \\text{spawn\\_link}(\\text{doError}, [i]) \\):\n\n\\[\n?\\text{[value, Result]} \\rightarrow \\text{Result} ;\n\\]\n\n\\[\n[\\text{EXIT, Pid, badarith}] \\rightarrow '\\text{invalid operation}' .\n\\]\n\nSubsequently, a new process is created and a link between the two processes is set up instantaneously.\n\n\\[\n\\rightarrow i[\\text{spawn\\_link}(\\text{doError}, [\\text{self}()]) \\cdot e_1, \\epsilon, \\emptyset, \\text{true}]\n\\]\n\n\\[\n\\rightarrow i[j \\cdot e_1, \\epsilon, \\{j\\}, \\text{true}] \\parallel j[\\text{doError}(i), \\epsilon, \\{i\\}, \\text{false}] \\quad \\text{(SPAWN\\_LINK)}\n\\]\n\nwhere \\( e_1 = ?\\text{[value, Result]} \\rightarrow \\text{Result} ;\n\\]\n\n\\[\n[\\text{EXIT, Pid, badarith}] \\rightarrow '\\text{invalid operation}' .\n\\]\n\nWhen the new process(process \\( j \\)), attempts to evaluate the \\text{doError()} function it fails. The uncaught exception, will cause the process to terminate with reason \\text{badarith}.\n\n\\[\nj[\\text{error : badarith}, \\epsilon, \\{i\\}, \\text{false}] \\rightarrow j[\\text{badarith}, \\{i\\}] \\quad \\text{(TERM}_1\\text{)}\n\\]\n\nUpon process \\( j \\)'s termination, an error signal is sent to process \\( i \\). This signal is trapped and translated into a normal message. The error notification message,\nChapter 3. Formal Semantics\n\n$[EXIT, j, badarith]$ is appended to process $i$’s mailbox.\n\n$$\\rightarrow j[badarith, \\{i\\}] \\parallel i[e_1, \\epsilon, \\{i\\}, \\text{true}]$$\n\n$$\\rightarrow j[badarith, \\emptyset] \\parallel i[e_1, [[EXIT, j, badarith]], \\emptyset, \\text{true}] \\quad (\\text{EXIT}_2)$$\n\nThe trapped error signal will be read, and the atom ‘invalid operation’ will be returned.\n\n$$\\equiv i[e_1, [[EXIT, j, badarith]], \\emptyset, \\text{true}] \\parallel j[badarith, \\emptyset]$$\n\n$$\\rightarrow i[\\text{invalid operation}', \\epsilon, \\{j\\}, \\text{true}] \\parallel j[badarith, \\emptyset] \\quad (\\text{RCV})$$\n\nNow let’s consider the same system, but replacing $\\text{spawn}$ by $\\text{spawn}$ followed by a $\\text{link}$ as follows:\n\n%% this function will cause the process to terminate\n%% with reason badarith\n\\[\\text{doError}(\\text{Pid}) \\rightarrow \\text{Pid} ! a + a.\\]\n\n\\[\n\\text{processA()} \\rightarrow \\\\\n\\quad \\text{process_flag(trap_exit,true),} \\\\\n\\quad \\% \\% \\text{create new process} \\\\\n\\quad \\text{Pid} = \\text{spawn(moduleName,doError,[self()]),} \\\\\n\\]\n\n\\[\n\\% \\% \\text{link to new process} \\\\\n\\text{link(Pid),} \\\\\n\\]\n\n\\[\n\\text{receive} \\\\\n\\quad [\\text{value,Result}] \\rightarrow \\text{Result} \\\\\n\\quad \\{\\text{EXIT,Pid,badarith}\\} \\rightarrow \\text{'invalid operation'} \\\\\n\\text{end.}\n\\]\n\nListing 3.3: Spawn_link - Example B\n\nEven though the above system may still evaluate down to ‘invalid operation’ it is also possible that the system returns a different result. This may occur if the following sequence of steps occurs.\n\nThe system sets its process flag and creates the new process.\n\n$$i[\\text{process_flag(trap.exit, true)} \\cdot \\text{spawn(doError, \\{i\\})} \\cdot \\text{link(j)} \\cdot e, \\emptyset, \\text{false}]$$\n\\[\n\\rightarrow i[\\text{false} \\cdot \\text{spawn(doError, [i])} \\cdot \\text{link}(j) \\cdot e, \\epsilon, \\emptyset, \\text{true}] \\\\\n\\rightarrow i[\\text{spawn(doError, [i])} \\cdot \\text{link}(j) \\cdot e, \\epsilon, \\emptyset, \\text{true}] \\\\\n\\rightarrow i[j \\cdot \\text{link}(j) \\cdot e, \\epsilon, \\emptyset, \\text{true}] \\mid j[\\text{doError([i]), e, \\emptyset, \\text{false}}]\n\\]\n\nwhere \\( e = \\text{?}[\\text{value, Result}] \\rightarrow \\text{Result}; [\\text{EXIT}, \\text{Pid, badarith}] \\rightarrow \\text{'invalid operation'}. \\)\n\nProcess \\( j \\) will then attempt to evaluate doError and it fails. As a result, process \\( j \\) terminates. Note however, that since there are no pids in its link set no error signals will be sent.\n\n\\[\n\\rightarrow j[\\text{error : badarith, } \\epsilon, \\emptyset, \\text{false}] \\rightarrow j[\\text{badarith, } \\emptyset]\n\\]\n\nSubsequently, process \\( i \\) will attempt to link to process \\( j \\). Since process \\( j \\) has terminated it receives an error signal with reason noproc.\n\n\\[\n\\rightarrow i[\\text{link}(j) \\cdot e, \\epsilon, \\emptyset, \\text{true}] \\mid j[\\text{badarith, } \\emptyset]\n\\]\n\nDue to the fact that the receive construct is only able to read exit message with reason \\text{badarith}, process \\( j \\) will then block indefinitely since no messages in its mailbox pattern match against the provided patterns.\n\nThis really simple example illustrates that by calling a \\text{spawn} followed by a \\text{link}, the system may sometimes evaluate to unwanted results. Perhaps this is one of the main reasons why as mentioned in [17], the link call is rarely used in actual Erlang systems. In fact, Erlang developers more often than not, opt to use solely the \\text{spawn_link} function since this guarantees that the \\text{link} is always carried out instantly, ensuring that no error signals are lost.\n3.11.4 Explicit error signals\n\n\\[\n\\begin{align*}\n&i \\neq j \\land v = \\text{kill} \\quad \\text{EXIT}_3 \\\\\n&i[j(e_j, m_j, l_j, f_j)] \\rightarrow i[\\text{true}, m_i, l_i, f_i] || j[killed, l_j]\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n&i \\neq j \\land v \\neq \\text{kill} \\land v \\neq \\text{normal} \\land f_j = \\text{false} \\quad \\text{EXIT}_4 \\\\\n&i[j(e_j, m_j, l_j, f_j)] \\rightarrow i[\\text{true}, m_i, l_i, f_i] || j[v, l_j]\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n&i \\neq j \\land v = \\text{normal} \\land f_j = \\text{false} \\quad \\text{EXIT}_5 \\\\\n&i[j(e_j, m_j, l_j, f_j)] \\rightarrow i[\\text{true}, m_i, l_i, f_i] || j[e_j, m_j, l_j, f_j]\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n&i \\neq j \\land v \\neq \\text{kill} \\land f_j = \\text{true} \\quad \\text{EXIT}_6 \\\\\n&i[j(e_j, m_j, l_j, f_j)] \\rightarrow i[\\text{true}, m_i, l_i, f_i] || j[e_j, m_j, l_j, f_j] + \\text{EXIT}_i, l_j, f_j]\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n&i[j[v, l_j]] \\rightarrow i[\\text{true}, m_i, l_i, f_i] || j[v, l_j]\n\\end{align*}\n\\]\n\nTable 3.11: Explicit exit signals\n\n\\[\n\\begin{align*}\n&i = j \\land v = \\text{kill} \\quad \\text{EXIT}_8 \\\\\n&i[\\text{exit}(j, v), m, l, f] \\rightarrow i[killed, l]\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n&i = j \\land v \\neq \\text{kill} \\land f = \\text{false} \\quad \\text{EXIT}_9 \\\\\n&i[\\text{exit}(j, v), m, l, f] \\rightarrow i[v, l]\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n&i = j \\land v \\neq \\text{kill} \\land f = \\text{true} \\quad \\text{EXIT}_{10} \\\\\n&i[\\text{exit}(j, v), m, l, f] \\rightarrow i[\\text{true}, m + \\text{EXIT}_i, v, l, f]\n\\end{align*}\n\\]\n\nTable 3.12: Self-sent exit signals\n\nThe above rules state how processes behave on receipt of an error signal which is explicitly sent by another process. The diagram shown hereafter illustrates how these rules relate to the behaviour of actual Erlang.\nIn the above diagram Process A is the process which is generating the explicit error signal by calling the exit(pid,Reason) built-in function. Here note, that process A is calling the exit function twice i.e. exit(B,Reason), exit(C,Reason). The key difference between process B and process C, is that process C is a system process(process_flag is set) while process B is not.\n\nPerhaps the most noticeable difference between explicitly generated error signals and error propagation through links is when the reason of the generated signal is kill. In this case, as stated in rule EXIT₃, the receiving process will terminate immediately with reason killed irrespective of whether it is trapping exit signals or not. Rules EXIT₄ and EXIT₅ describe the way the system behaves whenever an exit signal is sent to a process which is not trapping exit signals. Rule EXIT₄ states that when an exit signal with reason R(where R ≠ to kill or normal) is sent to a process which is not trapping exit signals, the receiving\nprocess will terminate with reason R. Otherwise, if an exit signal with reason *normal* is sent to a process which is not trapping exit signals then this process will not terminate(EXIT\\(_5\\)). Rule EXIT\\(_6\\) states that when an exit signal is sent to a process which is trapping exit signal, then the received signal is translated into an exit message and appended to the process’ mailbox. Rule EXIT\\(_7\\) states that if an exit signal is sent to a terminated process, then the exit signal is ignored.\n\nGiven the high degree of similarity between explicitly generated error signals and error propagation through links, at this point it is worth considering if it is possible to imitate the behaviour of links by sending explicit error signals. For example, can the following two pieces of code be considered as semantically equivalent?\n\n\n\nAt first glance, they seem to have identical behaviour - in both cases an exit signal with reason *badarg* will be sent to process \\(j\\) and process \\(k\\). However, there is one subtle difference. In the first case process \\(i\\) will terminate prior to sending any error signals whereas in the second case process \\(j\\) will send all error signals before its termination. In order to better understand the consequence of such a slight difference let’s consider the case where an external process, say process \\(l\\) sends an exit signal with reason *stop* just after process \\(i\\) has sent an error signal to process \\(j\\).\n\nFirst we will consider the piece of code shown on the left hand side. In this case after linking to process \\(j\\) and process \\(k\\), process \\(i\\) will terminate with reason *badarg*.\n\n\\[\ni[\\text{link}(j) \\cdot \\text{link}(k) \\cdot \\ldots \\text{exit(badarg)}, \\epsilon, \\emptyset, \\text{false}] || j[e_j, \\epsilon, \\emptyset, \\text{false}] || k[e_k, \\epsilon, \\emptyset, \\text{false}] \\\\\n\\rightarrow i[\\text{link}(k) \\cdot \\text{exit(badarg)}, \\epsilon, \\{j\\}, \\text{false}] || j[e_j, \\epsilon, \\{j\\}, \\text{false}] || k[e_k, \\epsilon, \\emptyset, \\text{false}] \\\\\n\\text{(LINK}_0\\text{)}\n\\]\nChapter 3. Formal Semantics\n\n\\[ i[\\text{exit(badarg)}, \\epsilon, \\{j, k\\}, \\text{false}] \\mid j[e_j, \\epsilon, \\{j\\}, \\text{false}] \\mid k[e_k, \\epsilon, \\{k\\}, \\text{false}] \\]\n\n\\( (\\text{LINK}_0) \\)\n\n\\[ i[\\text{badarg}, \\{j, k\\}] \\mid j[e_j, \\epsilon, \\{j\\}, \\text{false}] \\mid k[e_k, \\epsilon, \\{k\\}, \\text{false}] \\]\n\n\\( (\\text{TERM}_1) \\)\n\nAfter its termination, process \\( i \\) will start sending error signals to all processes found in its link set; i.e. process \\( j \\) and process \\( k \\). Here it is worth pointing out that process \\( i \\) may first send an error signal to either process \\( j \\) or \\( k \\) since as mentioned in Section 3.11.2 the order in which error signals are sent upon process termination is undetermined. In the following steps process \\( i \\) will first send an error signal to process \\( j \\). Since process \\( j \\) is not trapping exit signals it will terminate with reason \\text{badarg}.\n\n\\[ i[\\text{badarg}, \\{j, k\\}] \\mid j[e, \\epsilon, \\{i\\}, \\text{false}] \\rightarrow i[\\text{badarg}, \\{k\\}] \\mid j[\\text{badarg}, \\emptyset] \\]\n\n\\( (\\text{EXIT}_2) \\)\n\nAfter the error signal has been sent, another different process \\( l \\), sends an error signal with reason \\text{stop} to process \\( i \\). Since process \\( i \\) has already terminated this error signal will be ignored.\n\n\\[ l[\\text{stop}, \\{i\\}] \\mid i[\\text{badarg}, \\{k\\}] \\rightarrow l[\\text{stop}, \\emptyset] \\mid i[\\text{badarg}, \\{k\\}] \\]\n\n\\( (\\text{EXIT}_7) \\)\n\nProcess \\( i \\), will then continue sending error signals to the remaining processes found in its link set; i.e. process \\( k \\). On receipt of the error signal process \\( k \\) will also terminate with reason \\text{badarg}.\n\n\\[ i[\\text{badarg}, \\{k\\}] \\mid k[e, \\epsilon, \\{i\\}, \\text{false}] \\rightarrow i[\\text{badarg}, \\emptyset] \\mid k[\\text{badarg}, \\{i\\}] \\]\n\n\\( (\\text{EXIT}_2) \\)\n\nNow let’s consider the scenario where no links are used. In this case process \\( i \\) will first send an error signal to process \\( j \\) and just as before process \\( j \\) will terminate with reason \\text{badarg}.\n\n\\[ i[\\text{exit}(j, \\text{badarg}), \\epsilon, \\emptyset, \\text{false}] \\mid j[e, \\epsilon, \\{i\\}, \\text{false}] \\rightarrow i[\\text{true}, \\epsilon, \\emptyset, \\text{false}] \\mid j[\\text{badarg}, \\emptyset] \\]\n\n\\( (\\text{EXIT}_4) \\)\n\nThen process \\( i \\) will receive the error signal from process \\( l \\). Since process \\( i \\) is not trapping exit signals, this will cause process \\( i \\) to terminate immediately.\n\\[\n\\text{l[stop, \\{i\\}] || i[true, \\epsilon, \\emptyset, false] \\rightarrow l[stop, \\emptyset] || i[stop, \\emptyset]}\n\\]\n\n(\\text{EXIT}_2)\n\nAs a result process \\(i\\) would never be able to send the remaining error signal to process \\(k\\). This which may potentially result in a memory leak, if for instance process \\(k\\) is blocked waiting for some message from process \\(i\\). This particular example proves that the behaviour of error propagation through links cannot always be imitated by using explicit error signals.\n\nAnother major difference between links and explicit error signals is that an explicit error signal can be sent to the process generating the signal itself. This is done if the first argument of the exit built-in functions is set to the calling process pid, \\text{exit(self(), Reason)}. In the case of links this behaviour cannot be obtained, a process cannot be linked to oneself. The rules defining the behaviour of processes when exit signals are sent to oneself are described in Table 3.11.4.\n\nWhat these rules essentially state is that when sending error signals to oneself the behaviour of the process will depend mainly on two factors:\n\n\\begin{itemize}\n \\item the reason describing the cause of the error signal\n \\item the process’s process_flag\n\\end{itemize}\n\nIf the reason of the error signal is equal to \\text{kill}, the process will die irrespective of whether it is trapping exit signals or not(\\text{EXIT}_8). Otherwise, if the process is trapping exit signals, the generated error signal will be trapped and a message is appended to the process’ mailbox(\\text{EXIT}_10). If the process is not trapping exit signals, the process will terminate immediately with the reason being the one set by the explicitly generated error signal(\\text{EXIT}_9). Here it is worth highlighting the fact that the process will still terminate even if the reason is set to \\text{normal}.\n\nIn fact this is one minor improvement over Fredlund’s semantic definition of explicitly generated error signals[14]. In his work, Fredlund does not define rules to describe the behaviour of processes when error signals are sent to oneself. Consequently, when trying to evaluate \\text{exit(self(),Reason)} it is impossible to see how the system will behave. For instance, let’s consider the case when the expression \\text{exit(self(),normal)} is evaluated. At first one might think that when evaluating this expression the process will not terminate. This is because non-system processes will only terminate upon receipt of an abnormal error signal (i.e. reason \\(\\neq \\text{normal}\\)). However, in truth when evaluating this expression using actual Erlang the system will terminate immediately with reason \\text{normal}. \n\n62\nChapter 3. Formal Semantics\n\nOne problem mentioned in the previous chapter with respect to self-sent error signals was if the function call `exit(Reason)` can be considered to be semantically equivalent to `exit(self(), Reason)`. Through the above semantics it becomes evident that there are some major difference between the two. For instance, let’s consider the following two code excerpts:\n\n\\[\n\\begin{align*}\n\\text{process_flag(trap_exit, true),} & \\quad \\Rightarrow \\quad \\text{process_flag(trap_exit, true),} \\\\\n\\cdots & \\\\\n\\text{exit(reason),} & \\quad \\Rightarrow \\quad \\text{exit(self(), reason),}\n\\end{align*}\n\\]\n\nListing 3.5: `exit(Reason) & exit(self(), Reason)` - Case A\n\nWhen trying to evaluate the code excerpt found on the left using the defined semantics the `exit(reason)` will be first reduced to an exception. This exception will then cause the process to terminate with reason `reason`.\n\n\\[\ni[\\text{exit : reason, } \\epsilon, \\emptyset, \\text{true}] \\rightarrow i[\\text{reason, } \\emptyset]\n\\]\n\n(\\text{TERM}_{1})\n\nIf we attempt to evaluate the code excerpt found on the right hand side the end process will be different. This is due to the fact that the `exit(self(), reason)` will not cause the process to terminate. Instead an error signal notification is added to its mailbox.\n\n\\[\ni[\\text{exit(self(), reason), } \\epsilon, \\emptyset, \\text{true}] \\rightarrow\n\\]\n\n\\[\ni[\\text{true, [EXIT}, i, \\text{reason}], \\emptyset, \\text{true}]\n\\]\n\n(\\text{EXIT}_{10})\n\nThis scenario shows that the `exit(Reason)` function cannot be considered to be semantically equivalent to `exit(self(), Reason)`. Nonetheless, the above case only illustrates that these two expressions are not equivalent when called from within a system process. What if the `process_flag` is set to false just before calling the `exit(self(), Reason)`? In this case will the two expressions always behave in the same way? In order to be able to tackle this problem let’s consider the following code excerpts:\n\n\\[\n\\begin{align*}\n\\text{try} & \\quad \\text{try} \\\\\n\\text{process_flag(trap_exit, false),} & \\quad \\text{process_flag(trap_exit, false),} \\\\\n\\text{exit(reason),} & \\quad \\Rightarrow \\quad \\text{exit(self(), reason),} \\\\\n\\text{catch} & \\\\\n\\text{exit : reason -> caught} & \\quad \\Rightarrow \\quad \\text{exit : reason -> caught} \\\\\n\\text{end} & \\quad \\text{end}\n\\end{align*}\n\\]\n\nListing 3.6: `exit(Reason) & exit(self(), Reason)` - Case B\nUsing the defined semantics, the exit(reason) will be first reduced to an exception. Since this is found within a try-catch block the generated exception will not cause the process to terminate. As a result, the process will not terminate.\n\n\\[ i[\\text{try exit : reason catch exit : reason } \\rightarrow \\text{caught end}, \\epsilon, \\emptyset, \\text{false}] \\rightarrow i[\\text{caught}, \\epsilon, \\emptyset, \\text{false}] \\quad \\text{(TRY)} \\]\n\nIn the second case, the exit(self(), reason) expression will send an exit signal to itself. Due to the fact that the try-catch block is only capable of catching exceptions, the sent exit signal will immediately cause the process to terminate.\n\n\\[ i[\\text{exit(self(), reason), } \\epsilon, \\emptyset, \\text{false}] \\rightarrow i[\\text{reason}, \\emptyset] \\quad \\text{(EXIT)} \\]\n\nTherefore, even though at first it might seem that exit(self(), Reason) and exit(Reason) will always behave in the same way when used by a non-system process, this case proves that in truth this may not always be the case.\n\n### 3.11.5 Monitors\n\nThese rules state that when a process calls the monitor function, a one directional link is created between the calling process and the specified pid(MON\\(_0\\)). If the process specified by the pid terminates abnormally, a notification message about its termination will be sent. When the calling process, attempts to monitor a terminated process, a notification message is immediately sent to the calling process(MON\\(_1\\)).\n\nOne point worth mentioning here is that these rules have two main limitations:\n\n- In actual Erlang, when a process calls the monitor function consecutive times, multiple monitors are created. For instance, in the following example...\ntwo monitors will be created. As a result when the process terminates, two message notifications will be received. In our semantics, only one message will be received since the link set will only contain one instance of the monitor’s pid. (due to the fact that sets are not able to store duplicates)\n\n- In actual Erlang, when a process calls the `monitor` function it will only be able to trap error signals from the process which it is monitoring. For instance, in the case shown hereafter:\n\n ```erlang\n monitor(process, Pid1),\n link(Pid2)\n ```\n\nthe calling process is only able of trapping error signals from Pid1. If process Pid2 fails abnormally, than the calling process will also fail. However, by using the defined rules, it is not possible to faithfully describe this behaviour. In fact the defined rules assume that there will only be `monitor` calls within one process.\n\nUsing the defined rules, we are now able to tackle another problem mentioned in the previous chapter - Can the monitor behaviour be implemented using links as illustrated in the following diagram?\n\n\n\n**Figure 3.4: Monitor and Links**\n\nThe following two code excerpts, illustrate how the above two systems are implemented in Erlang.\nThe two systems seem to be semantically equivalent. In both cases if process $j$ fails, process $i$ will be notified through an error message. Additionally, a failure in process $i$ should never cause process $j$ to terminate since:\n\n- in the case of monitors, an error signal will not be sent given that process $j$ is not included in process $i$’s links set.\n- in the case of links, process $j$ should be able to trap the received exit signal.\n\nNonetheless, by using the defined rules it is possible to see that this last statement is not entirely true since in reality when using links, process $j$ may actually fail to trap the received exit signal. This occurs, if the following sequence of reductions take place.\n\nAfter setting its process_flag, process $i$ creates a link to process $j$.\n\n$$i[\\text{link}(j) \\cdot \\text{exit}(\\text{stop}), \\epsilon, \\emptyset, \\text{true}] \\mid j[e, \\epsilon, \\{i\\}, \\text{false}]$$\n\n$$\\rightarrow i[\\text{true} \\cdot \\text{exit}(\\text{stop}), \\epsilon, \\{j\\}, \\text{true}] \\mid j[e, \\epsilon, \\{i\\}, \\text{false}] \\quad \\text{(LINK$_0$)}$$\n\nwhere $e = \\text{process_flag(}\\text{trap}_\\text{exit}, \\text{true}) \\cdot ...$\n\nProcess $i$, then terminates abnormally with reason $\\text{stop}$. Upon termination it sends an error signal to process $j$. Since process $j$ has not set its process_flag yet, the sent error signal will cause it to terminate immediately.\n\n$$\\rightarrow i[\\text{stop}, \\{j\\}] \\mid j[e, \\epsilon, \\{i\\}, \\text{true}] \\quad \\text{(TERM$_1$)}$$\nTherefore, this proves that even though at first it might seem that the two\ncode excerpts are equivalent in actual fact they are not. Here one can appreciate\nthe fact, that thanks to the defined rules it was possible to clearly identify the\nsubtle difference between the two mechanisms.\n\n3.11.6 sumNProduct Example (Remote error handling)\n\nUsing this rule it is now possible to describe the behaviour of sumNProduct which\nmakes use of the remote handling mechanisms as described in 3.11.2. Here, it\nis important to note that in the following descriptions only the main reduction\nsteps are described. This is due to the fact that if all the reduction steps were to\nbe mentioned, the system’s description may result in a rather lengthy one.\n\nFirst, we will consider the case when the both input lists consists are set to\n[12,5]. First the parent process sets its flag so that it will be able to trap any\nreceived error signals.\n\n\\[ i[\\text{process\\_flag}(\\text{trap\\_exit}, \\text{true}) \\cdot e_1, \\epsilon, \\emptyset, \\text{false}] \\]\n\n\\[ \\rightarrow i[\\text{false} \\cdot e_1, \\epsilon, \\emptyset, \\text{true}] \\quad \\text{(PROC\\_FLAG)} \\]\n\nwhere \\( e_1 = \\text{spawn\\_link(sumProcess, [i, [12, 5]])} \\cdot \\text{spawn\\_link(productProcess, [i, [12, 5]])}\\):\n\n\\[ ?[\\text{sum, Sum}] \\rightarrow \\text{Sum; [EXIT, j, badarith] \\rightarrow invalid.} \\]\n\n\\[ ?[\\text{product, Product}] \\rightarrow \\text{Product; [EXIT, k, badarith] \\rightarrow invalid.} \\]\n\n\\[ [\\text{Sum, Product}] \\]\n\nTwo separate processes are then created. Since the \\text{spawn\\_link} function is used a\nlink between the child and parent process is set up immediately. First the process\nwhich is responsible to compute the sum is spawned:\n\n\\[ \\rightarrow i[\\text{spawn\\_link(sumProcess, [i, [12, 5]])} \\cdot e_2, \\epsilon, \\emptyset, \\text{true}] \\quad \\text{(SEQ\\_1)} \\]\n\n\\[ \\rightarrow i[j \\cdot e_2, \\epsilon, \\{j\\}, \\text{true}] || j[i![\\text{sum, 12 + 5}]], \\epsilon, \\{i\\}, \\text{false}] \\quad \\text{(SPAWN\\_LINK)} \\]\nwhere \\( e_2 = \\text{spawn\\_link}(\\text{product\\_Process}, [i, [12, 5]]) \\).\n\n\\[\n\\begin{align*}\n?\\text{[sum, Sum]} & \\rightarrow \\text{Sum}; [\\text{EXIT}, j, \\text{badarith}] \\rightarrow \\text{invalid}; \\\\\n?\\text{[product, Product]} & \\rightarrow \\text{Product}; [\\text{EXIT}, k, \\text{badarith}] \\rightarrow \\text{invalid}; \\\\\n& \\quad [\\text{Sum, Product}] \n\\end{align*}\n\\]\n\nSubsequently, another process is spawned to calculate the product of the input list.\n\n\\[\n\\begin{align*}\n\\rightarrow i[\\text{spawn\\_link}(\\text{product\\_Process}, [i, [12, 5]]) \\cdot e_3, i, \\{j\\}, \\text{true}] & || \\\\\n& \\quad k[i!\\text{[product, 12 \\times 5]}, i, \\{i\\}, \\text{false}] || s_j \\quad \\text{(SEQ\\_1)} \\\\\n\\rightarrow i[k \\cdot e_3, j, \\{k\\}, \\text{true}] & || k[i!\\text{[product, 12 \\times 5]}, i, \\{i\\}, \\text{false}] || s_j \\quad \\text{(SPAWN\\_LINK)} \\\\\n\\rightarrow i[e_3, j, \\{k\\}, \\text{true}] & || k[i!\\text{[product, 12 \\times 5]}, i, \\{i\\}, \\text{false}] || s_j \\quad \\text{(SEQ\\_1)} \\\\\n\\end{align*}\n\\]\n\n\\[\n\\text{where } s_j = j[i!\\text{[sum, 12 + 5]}], i, \\{i\\}, \\text{false}\n\\]\n\n\\[\n\\begin{align*}\ne_3 & = ?\\text{[sum, Sum]} \\rightarrow \\text{Sum}; [\\text{EXIT}, j, \\text{badarith}] \\rightarrow \\text{invalid}; \\\\\n& \\quad [\\text{Sum, Product}] \n\\end{align*}\n\\]\n\nProcess \\( j \\), the process calculating the sum will then send its result.\n\n\\[\n\\begin{align*}\n\\equiv j[i!\\text{[sum, 12 + 5]}], i, \\{i\\}, \\text{false} & || i[e_3, \\text{true}] || s_j' \\\\\n\\rightarrow j[i!\\text{[sum, 17]}, i, \\{i\\}, \\text{false}] & || i[e_3, [\\text{sum, 17}], \\{j, k\\}, \\text{true}] || s_j' \\quad \\text{(SEND\\_1)} \\\\\n\\end{align*}\n\\]\n\nSubsequently process \\( k \\) will send the the product of the input list.\n\n\\[\n\\begin{align*}\n\\equiv k[i!\\text{[product, 60]}, i, \\{i\\}, \\text{false}] & || i[e_3, \\text{true}] || s_j' \\\\\n\\rightarrow k[i!\\text{[product, 17]}, i, \\{i\\}, \\text{false}] & || i[e_3, [\\text{sum, 17}, \\text{product, 60}], \\{j, k\\}, \\text{true}] || s_j' \\quad \\text{(SEND\\_1)} \\\\\n\\end{align*}\n\\]\n\n\\[\n\\text{where } s_j' = k[i!\\text{[product, 12 \\times 5]}], i, \\{i\\}, \\text{false} \\\\\ns_j' = j[i!\\text{[sum, 17]}, i, \\{i\\}, \\text{false}]\n\\]\n\nThe two results are then read from the mailbox. First process \\( i \\) will read the sum value.\nThen process \\( i \\) will then read the product value. The two read values i.e. \\([17,60]\\) are then returned.\n\n\\[\n\\rightarrow i[\\sum, \\text{Sum}] \n\\rightarrow \\text{Sum}; [\\text{EXIT}, \\text{badarith}] \n\\rightarrow \\text{invalid} \\cdot e_4,\n\\]\n\n\\[\n[[\\sum, 17], [\\text{product}, 60]], \\{j, k\\}, \\text{true}] \\mid | s'_j \\mid | s''_k\n\\]\n\n\\( (\\text{RCV}) \\)\n\nwhere \\( e_4 = ?[\\text{product}, \\text{Value}] \\rightarrow \\text{Value}; [\\text{EXIT}, \\text{badarith}] \\rightarrow \\text{invalid} \\cdot [17, \\text{Product}] \\)\n\n\\[\ns''_k = k[[\\text{product}, 60], \\epsilon, \\{i\\}, \\text{false}]\n\\]\n\n\\[\ns''_j = j[[\\sum, 17], \\epsilon, \\{i\\}, \\text{false}]\n\\]\n\nThe above reduction steps are only one possible sequence of steps that can lead to the expected output. As mentioned in a previous section, when dealing with a parallel system there may be various different interleavings which still lead to the same output. Nonetheless, through the defined rules it is possible to check that all possible interleavings lead to the same result.\n\nWe will now consider the case when invalid list of data is input - \\([a,12]\\). Note that here only the main reduction steps are highlighted. These will give an idea how the defined rules can be used to describe the behaviour of a system. Similar to the previous case, process \\( i \\) will first set its process flag.\n\n\\[\ni[\\text{process\\_flag}(\\text{trap\\_exit}, \\text{true}) \\cdot e_1, \\epsilon, \\emptyset, \\text{false}]\n\\]\n\n\\[\n\\rightarrow i[\\text{false} \\cdot e_1, \\epsilon, \\emptyset, \\text{true}]\n\\]\n\n\\( (\\text{PROC\\_FLAG}) \\)\n\nwhere \\( e_1 = \\text{spawn\\_link}(\\text{sum\\_Process}, [i, [a,12]]) \\cdot \\text{spawn\\_link}(\\text{product\\_Process}, [i, [a,12]]) \\cdot\n\\]\n\n\\[\n?[[\\sum, \\text{Sum}] \\rightarrow \\text{Sum}; [\\text{EXIT}, \\text{badarith}] \\rightarrow \\text{invalid}\\cdot [\\sum, \\text{Product}] \n\\]\n\nThen it will spawn the two processes, one to calculate the sum and another to calculate the product.\nChapter 3. Formal Semantics\n\n\\[ → i[\\text{spawn}\\_\\text{link}(\\text{sumProcess}, [i, [a, 12]])] \\cdot e_2, \\epsilon, \\emptyset, \\text{true}] \\quad (\\text{SEQ}_1) \\]\n\n\\[ → i[j \\cdot e_2, \\epsilon, \\{j\\}, \\text{true}] || j[i![\\text{sum}, a + 12]], \\epsilon, \\{i\\}, \\text{false}] \\quad (\\text{SPAWN\\_LINK}) \\]\n\nwhere \\( e_2 = \\text{spawn}\\_\\text{link}(\\text{productProcess}, [i, [a, 12]]) \\cdot \\]\n\n\\[ ?[\\text{sum}, \\text{Sum}] \\rightarrow \\text{Sum}; \\text{EXIT}, j, \\text{badarith} \\rightarrow \\text{invalid}; \\]\n\n\\[ ?[\\text{product}, \\text{Product}] \\rightarrow \\text{Product}; \\text{EXIT}, k, \\text{badarith} \\rightarrow \\text{invalid}; \\]\n\n\\[ \\text{[Sum, Product]} \\]\n\nSubsequently, another process is spawned to calculate the product of the input list.\n\n\\[ → i[\\text{spawn}\\_\\text{link}(\\text{productProcess}, [i, [a, 12]])] \\cdot e_3, \\epsilon, \\{j, k\\}, \\text{true}] ||\n\n\\[ k[i![\\text{product}, a \\ast 12]], \\epsilon, \\{i\\}, \\text{false}] || s_j \\quad (\\text{SEQ}_1) \\]\n\n\\[ → i[k \\cdot e_3, \\epsilon, \\{j, k\\}, \\text{true}] || k[i![\\text{product}, a \\ast 12]], \\epsilon, \\{i\\}, \\text{false}] || s_j \\quad (\\text{SPAWN\\_LINK}) \\]\n\n\\[ → i[e_3, \\epsilon, \\{j, k\\}, \\text{true}] || k[i![\\text{product}, a \\ast 12]], \\epsilon, \\{i\\}, \\text{false}] || s_j \\quad (\\text{SEQ}_1) \\]\n\nwhere \\( s_j = j[i![\\text{sum}, a + 12]], \\epsilon, \\{i\\}, \\text{false}] \\)\n\n\\[ e_3 = ?[\\text{sum}, \\text{Sum}] \\rightarrow \\text{Sum}; \\text{EXIT}, j, \\text{badarith} \\rightarrow \\text{invalid}; \\]\n\n\\[ ?[\\text{product}, \\text{Product}] \\rightarrow \\text{Product}; \\text{EXIT}, k, \\text{badarith} \\rightarrow \\text{invalid}; \\]\n\n\\[ \\text{[Sum, Product]} \\]\n\nWhen processes \\( j \\) attempts to calculate the sum of the received list it will fail with reason \\text{badarith}. Afterwards, it will send an error signal to process \\( i \\).\n\n\\[ = j[i![\\text{sum}, a + 12]], \\epsilon, \\{i\\}, \\text{false}] || i[e_3, \\epsilon, \\{j, k\\}, \\text{true}] || s'_k \\]\n\n\\[ → j[\\text{error}: \\text{badarith}, \\epsilon, \\{i\\}, \\text{false}] || i[e_3, \\epsilon, \\{j, k\\}, \\text{true}] || s'_k \\quad (\\text{TERM}_1) \\]\n\n\\[ → j[\\text{badarith}, i] || i[e_3, \\epsilon, \\{j, k\\}, \\text{true}] || s'_k \\quad (\\text{TERM}_1) \\]\n\n\\[ → j[\\text{badarith}, \\emptyset] || i[e_3, [\\text{EXIT}, j, \\text{badarith}]], \\{k\\}, \\text{true}] || s'_k \\quad (\\text{EXIT}_2) \\]\n\nwhere \\( s'_k = k[i![\\text{product}, a \\ast 12]], \\epsilon, \\{i\\}, \\text{false}] \\)\n\nProcess \\( i \\) will then read the received error notification\n\\[\\equiv i[?\\text{sum, Sum}] \\rightarrow \\text{Sum}; [\\text{EXIT, j, badarith}] \\rightarrow \\text{invalid} \\cdot e_4,\\]\n\\[\\quad [[\\text{EXIT, j, badarith}], \\{k\\}, \\text{true}] \\parallel j[\\text{badarith}, \\emptyset] \\parallel s'_k\\]\n\n\\[\\rightarrow i[\\text{invalid} \\cdot e_4, \\epsilon, \\{k\\}, \\text{true}] \\parallel j[\\text{badarith}, \\emptyset] \\parallel s'_k\\] \n(RCV)\n\nwhere \\(e_4 = ?[\\text{product, Value}] \\rightarrow \\text{Value}; [\\text{EXIT, k, badarith}] \\rightarrow \\text{invalid}\\) \n\n\\[::: \\text{invalid, Product}\\]\n\nSimilarly, process \\(k\\) will also terminate with reason \\text{badarith}. The received error notification will be appended to process \\(i\\)'s mailbox.\n\n\\[\\equiv k[i!\\text{product, 12 * 5}], \\epsilon, \\{i\\}, \\text{false}] \\parallel i[\\text{invalid} \\cdot e_4, \\epsilon, \\{k\\}, \\text{true}] \\parallel s'_j\\]\n\n\\[\\rightarrow k[\\text{error:badarith}, \\epsilon, \\{i\\}, \\text{false}] \\parallel i[\\text{invalid} \\cdot e_4, \\epsilon, \\{k\\}, \\text{true}] \\parallel s'_j\\] \n(TERM1)\n\n\\[\\rightarrow k[\\text{badarith}, \\{i\\}] \\parallel i[\\text{invalid} \\cdot e_4, \\epsilon, \\{k\\}, \\text{true}] \\parallel s'_j\\]\n\n\\[\\rightarrow k[\\text{badarith}, \\emptyset] \\parallel i[e_4, [[\\text{EXIT, k, badarith}], \\emptyset, \\text{true}] \\parallel s'_j\\] \n(EXIT2)\n\nwhere \\(s'_j = j[\\text{badarith}, \\emptyset]\\)\n\nProcess \\(i\\) will read the error notification sent from process \\(k\\).\n\n\\[\\rightarrow i[?\\text{product, Product}] \\rightarrow \\text{Product}; [\\text{EXIT, k, badarith}] \\rightarrow \\text{invalid} \\cdot \\text{invalid}, \\text{Product},\\]\n\\[\\quad [[\\text{EXIT, k, badarith}], \\emptyset, \\text{true}] \\parallel s'_k \\parallel s'_j\\]\n\n\\[\\rightarrow i[\\text{invalid, invalid}], \\epsilon, \\emptyset, \\text{true}] \\parallel s'_k \\parallel s'_j\\] \n(RCV)\n\nwhere \\(s'_k = k[\\text{badarith}, \\emptyset]\\)\n\nThe above steps show that in the case of invalid input, this version of sumN-Product will also return \\([\\text{invalid, invalid}]\\) just like its sequential and other parallel version. By using the defined rules it is also possible to show that even by changing the order in which the events happen the system will still return the same output if given the same input. Therefore, it is possible to conclude that this version of sumNProduct is semantically equivalent to its previous versions.\n3.12 Conclusion\n\nThis chapter presented a formal semantic definition of Erlang’s error handling mechanisms. These formal definitions provided us a better insight of how Erlang systems behave in the presence of errors. In fact, by using these rules it became possible to get a step-by-step description of how Erlang systems are executed, bringing to light any unexpected sequences of events that may lead to unwanted results. Additionally, these rules were also able to show that in some cases, two syntactically different systems can actually have semantically equivalent behaviour. However, when dealing with parallel system it was much more challenging to ensure semantic equivalence of two systems. This is due to the fact that the number of possible interleavings is exponential to the size of the given system. This latter fact, is the motivation behind the next chapter. In order to facilitate the task of exhaustively analysing a system’s behaviour, the defined semantic rules will be animated through an evaluator.\n4. Implementation Framework\n\n4.1 Introduction\n\nThe main motivation behind defining a formal semantics for the error handling constructs was to be able to correctly reason about Erlang systems. Through the rules defined in the previous chapter it became possible to give a detailed description of how a particular Erlang system is expected to behave. The aim of this chapter is to give a high-level description of the system which was designed so as to be able to check the behaviour of a system under all possible interleavings in a more efficient way. The main components of the designed system will be outlined highlighting any choices that were taken whilst designing the system.\n\n4.2 System Design\n\nThe system was implemented in Haskell and as illustrated in Figure 4.1, it consists mainly of three main modules. The first module is responsible for parsing the input text. The parsed input is then fed to the evaluator which will describe all possible ways the input system may behave according to the previously defined semantic rules. The last module’s task is to present in an understandable way, a step-by-by description of these different behaviours. In the following sections we will take a deeper look at how each of these modules.\n4.3 Input\n\nThe designed system asks the user to enter three inputs:\n\n1. name of the module file - The module file should contain the function definitions that are called by the Erlang system. Even though in actual Erlang one system can call functions, whose definitions are found within different modules in the designed system, all function definitions have to be found within the same file. The expressions of this file will be parsed according to the BNF described in Table 3.2. The only difference is that the spawn, spawn_link, and spawn_monitor functions do not expect the module name parameter.\n\n2. name of the input file - this file will contain the input expression that in actual Erlang is input into the shell. This expression will be also parsed according to the BNF described in Table 3.2 and as in the previous case the spawn, spawn_link and spawn_monitor functions do not expect the module name parameter.\n\n3. name of the output file - this will determine the name of the file where the results of the evaluator will be stored.\n\n4.4 Parsing\n\nThe first module is composed of two distinct sub-modules; the lexer and the parser. The purpose why the parsing analysis was divided into two stages is that this approach helps in ensuring a less complex design for the parser.\n4.4.1 Lexer\n\nThe lexer used within the system was adapted from the one found in [20]. As input the lexer will be fed text upon which it performs the following tasks:\n\n- remove comments\n- remove white spaces\n- detect any lexical errors\n- recognise any keywords or operators\n- recognise atoms and integers\n\nFor example, if the lexer is given the following input:\n\n```\n%% this is an example\n[1,20,Hello,world]\n```\n\nit will tokenize the input text and return the following list of tokens.\n\n```\n[Tok \"[\" 3 2 Keyword,\nTok \"1\" 3 3 Number,\nTok \",\" 3 4 Keyword,\nTok \"10\" 3 5 Number,\nTok \",\" 3 7 Keyword,\nTok \"Hello\" 3 8 Variable,\nTok \",\" 3 13 Keyword,\nTok \"world\" 3 14 UnquotedAtom,\nTok \"]\" 3 19 Keyword,\nTok \"\" 3 20 EndToken]\n```\n\nEach token has a string containing the exact substring from the source file followed by the line and column where the token is found in source file and the token’s class such as Number or Variable. This tokenized list is then passed to the parser.\n\n4.4.2 Parser Combinators\n\nThe parser was implemented using parser combinators rather than a parser generator. One major benefit of using parser combinators is that one need not generate the whole parser every time a minor modification is done to the parser as is the case when using a parser generator. The fundamental principle behind parser combinators is that a parser is written in bottom-up fashion, similar to the way that one would define a language grammar.\nIn fact, when implementing the parser for this project the most elementary parser were first defined. These parsers were then “joined” together so as to get the main parser which is able to parse all of the expressions found in the chosen subset of Erlang. The most basic parser within the designed system is the token parser.\n\n```\ntoken ([]) = ParseError \"Unexpected eof\"\ntoken (x:xs) = Expression (x,xs)\n```\n\nListing 4.1: Basic Parser\n\nThe task of this simple parser is to return as the parsed expression, the head of the token’s list that is passed to the main parser. Apart from the token parser, several other elementary parsers were defined. These all combined the token parser described above with another function in order to produce a new parser. One such parser is the keyword parser.\n\n```\nkeyword str = token <=> (isKeyword str)\n```\n\nListing 4.2: Keyword parser\n\nHere, the `<=>` combinator, checks if the function given on the right hand side, (isKeyword str), returns true when applied to the parsed expression that is produced when using the parser on the left hand side (token). The keyword parser was then combined to other elementary parsers which are needed to parse the Erlang expressions that are found in the chosen subset. Two such expression parsers are the following:\n\n```\ncaseExp = (keyword \"case\") <+> expression <+> (keyword \"of\") <+> erlangMatch\ntryExp = (keyword \"try\") <+> sequence <+> (keyword \"catch\") <+> exceptionsCatch\n```\n\nListing 4.3: Parser Combinators\n\nThese parsers make use of three different parser combinators. The `<=>` combinator joins two parsers using the ‘and’ type operator. The `<+>` combinator is similar to the `<=>` combinator but does not return the output of the parser on the left hand side of the combinator. On the other hand, the `<>+` combinator does not return the output of the parser defined on the right hand side. For instance,\nChapter 4. Implementation Framework\n\nwhen applying the caseExp parser to a tokenized list representing the following expressions:\n\n```erlang\ncase Value of 1 -> hello; 2 -> bye end\ntry A+B catch error:Desc -> Desc end\n```\nthe Erlang expression parser returns the expression\n\n```erlang\nCase (Var \"Value\") Match [(1,Atom \"hello\"),(2,(Atom \"bye\")]\nTry (Add (Var A) (Var B)) Match [Exception Error (Var Desc)]\n```\n\nIn order to be able to parse all the expressions in the subset, a different simple parser were defined for each Erlang expression. Here, only the tryExp and caseExp parsers were described. However, the other parsers were defined similar to the way in which these two parsers have been defined.\n\nThe main parser then “combined” all of these expression parser by using the `<|>` combinator whose task is to join any two elementary parsers using the ‘or’ type operator.\n\n```haskell\nprefixExp :: Parser ErlangExp\nprefixExp =\n caseExp\n <|> receiveExp\n <|> tryExp\n <|> builtInFun\n <|> functionCall\n <|> list\n <|> atom\n <|> number\n <|> var\n```\n\nListing 4.4: Expressions Parser\n\nThe above parser is used to parse the Erlang expressions found in the chosen subset. Once again, through this example one cannot help noticing the fact parser combinators made it possible to define the parser using really neat syntax. Moreover the parser’s syntax is highly similar to the BNF definition. In fact, by looking at the parser definitions in 4.4 one can immediately understand what expression a particular parser is expected to parse since the parser function is almost identical to the BNF definition.\n\n77\nChapter 4. Implementation Framework\n\nAnother reason why it was opted to implement the parser through parser combinators lies in the fact that this approach allows incremental development. Therefore, if for instance the parser were to be extended so as to be able to parse Erlang tuples it would be relatively easy to carry out such modification. This is because in order to extend the parser one need only define a simple parser to parse Erlang tuples. The simple parser is then “joined” to the main parser as described in Listing 4.5\n\n```haskell\nprefixExp :: Parser ErlangExp\nprefixExp =\n caseExp <|> receiveExp <|> tryExp <|> builtInFun <|> functionCall <|> list <|> atom <|> number <|> var <|> tuple\n```\n\nListing 4.5: Expression Parser Extended\n\nThis simple example brings to light the fact that when using parser combinators, no major modifications need to be done in order to increase the number of expressions that the parser is able to parse. Therefore, with regards to this work, even though the parser was defined for a subset of Erlang, it will be quite straightforward to extend the parser so as to be able to accept an increased subset of Erlang. In fact, if a parser were to be defined to accept a larger subset of Erlang there will not be a need to implement the new parser from scratch as is the case when parser generators are used. This is because the parser implemented for this project may serve as the basis upon which the larger parser is built.\n\n4.5 Evaluator\n\nThe primary aim of the evaluator is to give a clear and accurate description of how a particular Erlang system behaves. This is done by going through all possible sequences of reduction steps that the system might take, possibly revealing any unexpected ways in which an Erlang system might behave. Undoubtedly, one of the major benefits of the designed evaluator is that it makes the task of\nchecking the behaviour of a system under all possible interleavings much more efficient. One here should be aware that the total number of interleavings can be considerably large even when the input system is extremely simple. This can be clearly seen if we consider the following really simple system:\n\n```erlang\nprocessA() ->\n %% create a new process send the value 3\n case spawn_link(processB,[]) of\n %% send the value 3 to the new process\n Pid -> Pid ! 3\n end.\n\nprocessB() ->\n %% bind the sum of 1+2 to Total\n case 1+2 of Total ->\n %% add the received Value to Total\n receive\n Value -> Total + Value\n end\nend.\n```\n\nListing 4.6: Erlang Program\n\nThe following two lists identify all the small subtasks that are carried out by each process when the system is executed. Each of these tasks corresponds to exactly one reduction step.\n\n<table>\n<thead>\n<tr>\n<th>Process A</th>\n<th>Process B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A1: spawn new process</td>\n<td>B1: compute sum of 1+2</td>\n</tr>\n<tr>\n<td>A2: bind Pid to pid of new process</td>\n<td>B2: bind Total to the result</td>\n</tr>\n<tr>\n<td>A3: send message to process B</td>\n<td>B3: receive message</td>\n</tr>\n<tr>\n<td></td>\n<td>B4: add Total to the received Value</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.1: Actions to be performed when executing program 4.6\n\nDiagram 4.2 illustrates the different sequences of reduction steps that this particular system may take before it returns its final output.\nIn the above diagram the actions that are done by process A are indicated by gray coloured boxes, whereas actions that are carried out by process B are indicated by white boxes.\n\nOne here may notice that in all cases, process A will send the message to process B, and process B will always evaluate down to 6. Therefore, all cases can be considered to have identical behaviour even though the sequence of steps that led the system to achieve its final result are slightly different. Through this diagram it becomes clear that one extra reduction step in any of the given process, will increase the number of possible interleavings drastically.\n\nIn order to reduce the number of interleavings that the evaluator needs to go through, it was decided that sequences of reduction steps that do not cause any side effects, such as evaluation of addition followed by binding of variables should be considered as one single operation. This is due to the fact, that the order in which non-side effect reduction steps occurs may never yield to a different system’s behaviour. For instance, let’s consider again the program described in 4.6. In this case, as described in 4.1 the majority of the actions that are carried out by the two processes are non-side effect actions. In fact, the only side-effect action is A3.\n\nTherefore, it does not make any real difference if B1 is computed before A2, or vice versa. This is because, non-side effect actions may only effect the local state of the process. By adopting such a practice, the number of interleavings is reduced substantially. This fact, is quite evident through Diagram 4.3 which shows the reduced number of different interleavings that the evaluator will check when using this approach.\nIn order to better appreciate how this approach made it possible to reduce the number of interleavings but still be able to represent all the different ways in which the system may behave, let’s consider another simple system.\n\n<table>\n<thead>\n<tr>\n<th>Process A</th>\n<th>Process B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A1: spawn new process</td>\n<td>B1: compute sum of 1+2</td>\n</tr>\n<tr>\n<td>A2: bind Pid to pid of new process</td>\n<td>B2: bind Total to the result</td>\n</tr>\n<tr>\n<td>A3: send exit signal to process B</td>\n<td>B3: send Total to process C</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.2: Actions to be performed\n\nIn this case, the different interleavings, may result in a different behaviour. This is because, if action A3 is executed before B3 then the Total message will never reach process C. This may occur if any of these interleavings occur:\n\nBy analysing these interleavings it becomes evident that in actual fact all these interleavings are expressing the same behaviour i.e. the behaviour of the system when the exit signal is received before process B sends the Total message.\nto process C. Here, it is worth highlighting the fact that in Erlang systems once a process dies, all the information stored within local variables is lost. As a result, with regards to this example, it does not really matter if the exit signal is received after executing step B1 or just after executing B2. This is because, upon process B’s termination all information stored in variables is lost.\n\nNow, let’s consider the case when codeCommB3 is evaluated before A3 and therefore the Total message will be successfully sent to process C. As in the previous case, there are several possible different interleavings that may lead process B to eventually send the Total message. These interleavings are described in Figure 4.5.\n\n\n\nThrough this example it became evident that an Erlang system due to its parallel nature may take different interleavings to complete its task. However, the behaviour of a system is really determined by the order in which the side-effect actions take place. For instance, with respect to this system, what really matters is if the exit message is received before or after the Total message is sent to process C. Therefore, all the different behaviours in which this particular system may behave can be represented through the following two interleavings.\n\n\n\nHere, it is important to note that even though the number of interleavings to be checked are reduced substantially, the different interleavings are still able to represent all the possible ways in which a system may behave.\nOne of the major benefits of reducing the number of possible interleavings was that the evaluator experienced a slight improvement in efficiency. Just the same, the number of possible interleavings in some cases is considerably large especially when dealing with systems in which processes may terminate abnormally. This is due the fact that the order in which exit signals are sent is undefined. For instance, if a process is linked to 3 other processes, say process A, process B and process C then there are a total of six different orderings in which the exit signal may be sent. (since the failed process may send its exit signals either to A then to B and then to C, or first to B, then to A and then to C ...) Let’s consider the following example, to better understand how the order in which exit signals are sent may increase significantly the number of possible interleavings:\n\n```\n...% spawn and link to process A\nspawn_link(waitError,[Pid,ProcessB]),\n\n% spawn and link process B\nspawn_link(waitError,[Pid,ProcessC]),\n\n% process terminates abnormally\n% with reason 'error occurred'\nexit('error occurred').\n\nwaitError(Pid,Name) ->\n % start trapping exit signals\n process_flag(trap_exit,true),\n % wait for error message\n receive\n Error -> Pid ! Name\n end.\n```\n\nListing 4.9: Erlang Program using Remote Error Handling Mechanisms\n\nEach process in the above system, needs to execute the following steps:\n\n<table>\n<thead>\n<tr>\n<th>Process A</th>\n<th>Process B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A1: spawn_link process B</td>\n<td>B1: set process flag</td>\n</tr>\n<tr>\n<td>A1: spawn_link process C</td>\n<td>B2: receive error message and send result to Pid</td>\n</tr>\n<tr>\n<td>A3b: send error signal to B</td>\n<td></td>\n</tr>\n<tr>\n<td>A3c: send error signal to C</td>\n<td></td>\n</tr>\n<tr>\n<td>Process C</td>\n<td></td>\n</tr>\n<tr>\n<td>C1: set process flag</td>\n<td></td>\n</tr>\n<tr>\n<td>C2: receive error message and send result to Pid</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTable 4.3: Actions to be performed when executing program 4.9\nIn this case process A is linked to both process B and process C and therefore it needs to send an exit signal to both processes. The evaluator needs to cover both when A sends its exit signal first to process B and when process A sends its exit signal first to process C. This factor, is one major contributor to the increase in the number of sequences that need to be checked by the evaluator. To get a better idea, how large this number can actually get, let’s consider the following diagram which describes the different interleavings that the system described above may take:\n\n\n\nFigure 4.7: Error handling - possible interleavings\n\nGiven the fact, that the number of different sequences may become considerably large, it was decided that in the final output the evaluator only includes the different end result the system might reach and one sequence that may lead to this end result. For instance, in the above system, since the system may end in five different ways in the output file only five sequence of reductions steps are included, even though there are more different interleavings that the system may take.\n\n### 4.6 Building the Output File\n\nOnce the evaluator has gone through all the interleavings, an output file is built describing the different ways in which the input system may behave. The output file consists of a pdf file, which is composed primarily of four sections\n- function definitions\n- shell input\n- different end systems\n- sequence of reduction steps that have led to the above end systems\n\nIn order to build the pdf file, the output of the evaluator is translated into a latex file. This is then parsed by using the pdflatex command. Once the output file has been built, the system will automatically open the file so that the user may view the result of the evaluator.\n\n4.7 Conclusion\n\nThis chapter gave a brief overview of the main components found within the designed system. It also illustrated why parallel systems may go through several different sequences of reduction steps before completing their task. As a result, it became evident that when dealing with parallel systems the use of an evaluator is key in order to identify those sequences of steps that may lead to unexpected behaviour.\n5. Evaluation\n\n5.1 Introduction\n\nThe aim of this chapter is to measure to what degree the objectives set forth in the beginning of this project have been met. These objectives were primarily that the defined model should be able to:\n\n- offer a better insight into Erlang’s error handling mechanisms\n- explain better those circumstances that lead to unexpected results\n- predict a system’s behaviour\n- lay foundations for a semantic theory\n\nIn the first section of this chapter the evaluation strategy that is used is explained. Subsequently, the described evaluation strategy is applied to a number of Erlang systems in order to evaluate to what extent the initial objectives have been achieved. Finally, the results of the evaluation are discussed.\n\n5.2 Evaluation Strategy\n\nSince the semantics were defined post-hoc, it was important to ensure that the presented definitions are loyal to the behaviour of actual Erlang. The correctness of the defined model was measured by adopting the strategy described in Figure 5.1.\nChapter 5. Evaluation\n\nThe correctness of the model was analysed by considering a number of different Erlang programs.\n\n1. Each program was first run on the Erlang VM. In order to get a clearer picture of how a program is evaluated, Erlang’s trace built-in function was used. This function returns a step-by-step description of how a program has been evaluated by Erlang, hence indicating the order in which side-effect actions such as linking and delivery of exit signals took place.\n\n2. The same Erlang program was then translated in terms of the model.\n\n3. Subsequently, the translated Erlang program was input into the evaluator. The evaluator returned sequences of reduction steps describing the different ways the input program may be evaluated according to the defined model.\n\n4. The output generated by Erlang’s tracer and the output of the evaluator are compared to analyse if the defined rules are capable of faithfully describing Erlang’s behaviour.\n\n5.3 Assessing the Defined Model\n\nIn this section, the evaluation strategy is applied to several Erlang programs. The programs were selected in such a way to evaluate all the rules which were defined to describe Erlang’s error handling behaviour.\n\nFigure 5.1: Evaluation Strategy\n5.3.1 Test Case 1: Local Error Handling\n\nIn order to evaluate the correctness of the formal rules describing Erlang’s local error handling mechanisms, several programs which make use of the try-catch expression were considered. Two of the programs which were considered were the following:\n\n**Test case 1A:**\n\n```erlang\nfun1() ->\n try\n hello\n catch\n throw:stop ->\n 'error caught'\n end.\n```\n\n**Test case 1B:**\n\n```erlang\nfun1() ->\n try\n abc + def,\n catch\n error:badarith ->\n 'sum error'\n end.\n```\n\nIn all cases it was found that the model is able to mirror correctly the behaviour of Erlang both when no exceptions were raised within the try-catch block (as in test case 1A), and also when exceptions were raised and needed to be handled by the try-catch statement (as in test case 1B).\n\nOne of the most interesting test cases with regards to local error handling was the following program which consists of two nested try-catch statements.\n\n```erlang\nfun1(Pid, A, B) ->\n try\n try\n Pid ! A + B\n catch\n error:badarith -> Pid ! invalid\n end,\n catch\n error:badarg -> invalidPid\n end.\n end.\n```\n\nListing 5.1: Nested try-catch statements\n\nIn this program, the innermost try-catch can only handle *badarith* exceptions, i.e. exceptions that occur when non-numeric data is passed as the second and\nthird argument. The outermost try-catch statement is used to handle \\textit{badarg} exceptions, i.e. those exceptions which arise if invalid pids are passed to the function.\n\nHere, we will consider the case when the first argument, i.e. the value bound to Pid is not a valid pid. As a result, when evaluating the \\texttt{Pid!A+B} an exception of type \\textit{badarg} is raised. The trace that was generated when evaluating the\n\n\\begin{verbatim}\nfun1(nonPid,1,2)\n\\end{verbatim}\n\nexpression was the following:\n\n\\begin{verbatim}\nln1 : {trace,<0.161.0>,send,3,invalidPid}\nln2 : {trace,<0.161.0>,exit,normal}\n\\end{verbatim}\n\nThe above trace list shows that Erlang will first attempt to send the sum of the two input numbers i.e. 3 (\\texttt{ln1}). Since in this case the first argument is bound to the atom \\texttt{invalidPid} the send expression fails. This can be seen from the fact that in the trace list there is no tuple to show that the message has been received. At this point, it is important to note that the raised \\textit{badarg} exception does not cause the process to terminate abnormally since as shown in \\texttt{ln2} the process will terminate with reason \\textit{normal}. This fact indicates that the generated exception must have been handled by one of the try-catch statements. In fact, when running the program, the system returned the atom \\texttt{invalidPid} which shows that the generated exception was handled by the outermost try-catch statement.\n\nThis program was then evaluated by using to the defined semantics rules. According to the defined rules the system first evaluates the expression found within the try-catch block (which in the following reduction step is represented by \\( e_1 \\)).\n\n\\begin{verbatim}\ni[\\text{try } e_1 \\text{ catch error:badarg } \\rightarrow \\text{ invalidPid end, } \\epsilon, \\emptyset, \\text{ false}]\\end{verbatim}\n\nwhere \\( e_1 = \\text{try } \\text{nonPid}!1+2 \\text{ catch error:badarg } \\rightarrow \\text{ invalidPid end} \\)\n\nWhen evaluating the try-catch statement found in \\( e_1 \\) a \\textit{badarg} exception is raised. Since, the try-catch statement is only able to handle \\textit{badarith} exceptions, \\( e_1 \\) will evaluate down to a \\textit{badarg} exception as shown in the following reduction step:\nEvaluating subexpression $e_1$:\n\n\\[ \\text{i[try nonPid ! 1 + 2 catch error:badarith } \\rightarrow \\text{ Pidinvalid end, } \\epsilon, \\emptyset, \\text{false}] \\]\n\n\\[ \\rightarrow \\text{i[error:badarg, } \\epsilon, \\emptyset, \\text{false}] \\]\n\nThe raised exception is then handled by the outermost try-catch statement and the atom invalidPid is returned.\n\n\\[ \\text{i[try error:badarg catch error:badarg } \\rightarrow \\text{ invalidPid end, } \\epsilon, \\emptyset, \\text{false}] \\]\n\n\\[ \\rightarrow \\text{i[invalidPid, } \\epsilon, \\emptyset, \\text{false}] \\]\n\nSubsequently, since there is no other expression to evaluate after the try-catch statement the process terminates normally.\n\n\\[ \\rightarrow \\text{i[normal, } \\emptyset] \\]\n\nThe same behaviour was described when the program was input into the evaluator:\n\n\\[\n\\begin{array}{l}\n\\text{End System} \\\\\n\\text{i[normal, } \\emptyset] \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{l}\n\\text{TERM}_0 \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{l}\n\\text{SEND}_2 \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{l}\n\\text{TRY}_2 \\hspace{1cm} \\text{TRY}_3 \\\\\n\\end{array}\n\\]\n\nFigure 5.2: Local error handling - evaluator’s output\n\nAs seen in Figure 5.2, the evaluator described the fact that the raised exception is handled by the outermost try-catch statement(TRY\\(_2\\)). Subsequently, the\nprocess terminates with reason \\textit{normal}(\\textit{TERM}_0).\n\nWith regards to the output generated by the evaluator, here it is important to note that the expression in each reduction step only describes the innermost evaluating expression. For instance, in the first reduction step, only the \\texttt{nonPid!13} expression found in process \\textit{i} is shown even though in actual fact this expression is found within a try-catch statement. The main reason why it was opted to only show the innermost evaluating expression was to prevent the reduction steps descriptions from becoming too cumbersome.\n\nHere, it is evident that the reduction steps describe a behaviour which is identical to the one of actual Erlang. Therefore, it is clear that in this particular test case the defined model is able to faithfully describe the behaviour of actual Erlang. We will now move on to see if the behaviour of Erlang’s remote error handling mechanisms as described by the model is completely faithful to the behaviour of Erlang.\n\n5.3.2 Test Case 2 : Remote Error Handling - Links\n\nIn Erlang whenever a process, say process \\textit{A} terminates with reason \\textit{R} then an exit signal is sent to all of \\textit{A}’s linked processes. Upon receipt of this exit signal, the linked process, say process \\textit{B} may behave in either of the following way:\n\n- \\textbf{case A}: if process \\textit{B}’s process\\_flag is set, an exit notification is appended to process \\textit{B}’s mailbox\n- \\textbf{case B}: if process \\textit{B}’s process\\_flag is unset and \\textit{R} is \\textit{normal}, then the process \\textit{B} ignores the received signal\n- \\textbf{case C}: if process \\textit{B}’s process\\_flag is unset and \\textit{R} is not equal to \\textit{normal}, then the receiving process terminates with reason \\textit{R}\n\nIn order to check if the error propagation behaviour as described by the model is correct, the test cases were chosen in such a way to cater for all the three different ways a process might behave on receipt of an exit signal due to the termination of a linked process. Here, only the evaluation of case \\textbf{A} is described since the evaluation carried out for each of the other cases is quite similar to the one described here.\n\nIn the chosen program, one process is used to handle the generated exception whereas another separate process is responsible to compute the summation of the\ntwo input numbers.\n\n```erlang\nfun1(Num1, Num2) ->\n %% set process flag\n process_flag(trap_exit, true),\n\n %% create new process to compute sum of numbers\n Pid = spawn_link(?MODULE, sum, [self(), Num1, Num2]),\n receive\n {'EXIT', Pid, Error} -> invalid;\n Result -> Result\n end.\n\nsum(Pid, Num1, Num2) -> Pid ! Num1 + Num2.\n```\n\nListing 5.2: Remote Error Handling Example\n\nWhen running this test case, the `fun1()` function was passed non-numeric data (`aa,bb`) so as to see how the system will behave when incorrect data is input. The generated trace list was as follows:\n\n```\nln1 : {trace,<0.125.0>,spawn,<0.126.0>,{links,sum,[<0.125.0>,aa,bb]}}\nln2 : {trace,<0.125.0>,link,<0.126.0>}\n\nln3 : {trace,<0.126.0>,exit,{badarith,[[links,sum,3]]]}\nln4 : {trace,<0.125.0>,’receive’,{’EXIT’,<0.126.0>,\n {badarith,[[links,sum,3]]]}}}\nln5 : {trace,<0.125.0>,getting_unlinked,<0.126.0>}\nln6 : {trace,<0.125.0>,exit,normal}\n```\n\nIn the above trace list, each side-effect action is represented by a tuple. The second element of every tuple identifies the Pid of the process performing the action. The third element gives the name of the side effect action that has been done. In the case of spawning the fourth element shows the Pid of the new process, whilst the fifth element shows the arguments passed to the spawn function basically `{moduleName, functionName, arguments}`. In the case of linking, the third element refers to the pid of the process with whom the link will be done.\nChapter 5. Evaluation\n\nWhen the process terminates the third tuple is set to exit and the fourth tuple indicates the reason with which the process terminated.\n\nHere, one can appreciate how the trace list made it possible to get a really clear picture of how this particular program is evaluated. In order to better understand Erlang’s behaviour as described by the trace list let’s consider the following diagram.\n\n\n\nThe trace list describes the fact that the parent process (<0.125.0>) first spawns and links to a new process(<0.126.0>)(ln1 – ln2). The task of the new process is to compute the sum of \\( aa \\) and \\( bb \\). Since the new process fails to compute the sum of \\( aa \\) and \\( bb \\) it terminates with reason `badarith` (ln3). Once process <0.126.0> terminates, an exit message is appended to process <0.125.0>’s mailbox (ln4). The link which was found between the two processes is removed (ln5). Subsequently, process <0.125.0> reads the exit message and terminates normally (ln6).\n\nWhen the same system was input into the evaluator, the following sequence of reductions was described. The parent process(process i), will first set its process_flag to true so as to trap any received exit signals.\nProcess $i$ then starts evaluating $e_1$. It spawn links a process (process $j$) whose task will be to compute the sum of the input parameters i.e. $aa$ and $bb$.\n\n$$\\rightarrow i[\\text{spawn\\_link}(\\text{sum}, [i, aa, bb]) \\cdot e'_1, \\epsilon, \\emptyset, \\text{true}]$$\n\nwhere $e'_1 = ?['EXIT', \\text{Pid}, \\text{Error}] \\rightarrow \\text{invalid}; \\text{Result} \\rightarrow \\text{Result end.}$\n\nWhen process $j$ attempts to calculate the sum of the two input numbers it fails and a $\\text{badarith}$ exception is raised. This causes process $j$ to terminate with reason $\\text{badarith}$.\n\n$$\\rightarrow i[j \\cdot e'_1, \\epsilon, \\{j\\}, \\text{true}] \\parallel j[!aa + bb, \\epsilon, \\{i\\}, \\text{false}]$$\n\nwhere $e'_1 = ?['EXIT', \\text{Pid}, \\text{Error}] \\rightarrow \\text{invalid}; \\text{Result} \\rightarrow \\text{Result end.}$\n\nUpon termination, an error signal is sent to process $i$. Since process $i$ is trapping exit signals, the received signal is translated into an exit notification and appended to process $i$’s mailbox.\n\n$$\\equiv j[\\text{error:badarith}, \\{i\\}] \\parallel i[j \\cdot e'_1, \\epsilon, \\{j\\}, \\text{true}]$$\n\n$$\\rightarrow j[\\text{error:badarith}, \\emptyset] \\parallel i[j \\cdot e'_1, [\"EXIT', j, \\text{badarith}]], \\emptyset, \\text{true}]$$\n\nProcess $i$ then moves on to evaluate expression $e'_1$ which consists of a receive statement. The received exit message is read from the process’ mailbox and process $i$ terminates with reason $\\text{normal}$.\n\n$$\\rightarrow j[\\text{error:badarith}, \\emptyset] \\parallel$$\n\n$$i[!?'EXIT', \\text{Pid}, \\text{Error}] \\rightarrow \\text{invalid}; \\text{Result} \\rightarrow \\text{Result end.} ,$$\n\n$$[\"EXIT', j, \\text{badarith}], \\emptyset, \\text{true}]$$\n\n94\nChapter 5. Evaluation\n\n\\[ \\rightarrow j[\\text{error:badarith}, \\emptyset] \\parallel i[\\text{invalid}, e, \\emptyset, \\text{true}] \\]\n\n\\[ \\rightarrow j[\\text{error:badarith}, \\emptyset] \\parallel j[\\text{normal}, \\emptyset] \\]\n\nThe same behaviour was described by the evaluator:\n\n\n\nFigure 5.4: Remote error handling - Evaluator’s output\n\nThrough this example it becomes evident how Erlang’s trace function made it easier to compare the behaviour of actual Erlang to the one described by the model. This is because, the trace list brings to light the order in which the side effect actions took place and as a result it becomes really straightforward to compare the sequence of reduction steps as described by the model to the sequence of steps as described by the trace list.\n\n### 5.3.3 Test Case 3: Remote Error Handling - Monitors\n\nIn this section, the degree up to which the defined model is able to mirror the behaviour of one-way linking (also known as monitoring) is evaluated. A number\nof different programs were considered to evaluate the correctness of the model. Table 5.1 describes the way monitors are expected to behave according to the defined model.\n\n<table>\n<thead>\n<tr>\n<th>Test case description</th>\n<th>Behaviour according to model</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Process A starts monitoring process B. Process B terminates.</td>\n<td>An exit message is appended to process A’s mailbox.</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.1: Monitors - Behaviour as described by model\n\nOne point worth mentioning here is that when the behaviour as described by the model was compared to the behaviour of actual Erlang only the first two test cases were found to be faithful to Erlang’s behaviour. In the last case the model fell short of describing correctly Erlang’s behaviour. In order to better understand why in the third case the behaviour of the model was found not to be loyal to that of actual Erlang let’s consider the following program:\n\n```erlang\nfun1(Pid) ->\n erlang:monitor(process,Pid),\n erlang:monitor(process,Pid),\n exit(Pid,stop),\n receive\n Msg1 -> '1st msg'\n end,\n receive\n Msg2 -> '2nd msg'\n end.\n```\n\nListing 5.3: Monitor Example\n\nIn this program two monitors are created to monitor the process indentified by \\( Pid \\). An exit signal is then sent to process \\( Pid \\). Subsequently, the program will wait for two messages describing process \\( Pid \\) termination. When evaluating the above program, Erlang returned the following trace list:\nChapter 5. Evaluation\n\nln1: {trace, <0.224.0>, exit, stop} \nln2: {trace, <0.226.0>, 'receive', {'DOWN', #Ref<0.0.0.1065>, process, <0.224.0>, stop}} \nln3: {trace, <0.226.0>, 'receive', {'DOWN', #Ref<0.0.0.1064>, process, <0.224.0>, stop}} \nln4: {trace, <0.226.0>, exit, normal}\n\nThe above trace list indicates that since the monitor function is called twice, the process creating the monitor (process <0.226.0>) receives two exit messages when the monitored process (process <0.224.0>) terminates (ln2 - ln3). In contrast, when the above system is described through the model only one exit message is received.\n\nAccording to the defined rules, this program is evaluated in the following way. In these reduction steps, the process creating the monitors is identified as process $i$ whereas the process which is going to be monitored is process $j$. Process $i$ will first evaluate the first monitor expression.\n\n$$i [\\text{monitor}(\\text{process}, j) \\cdot \\text{monitor}(\\text{process}, j) \\cdot \\text{exit}(j, \\text{stop}) \\cdot e_1, \\epsilon, \\emptyset, \\text{false}] \\parallel j[e, \\epsilon, \\emptyset, \\text{false}]$$\n\n$$\\rightarrow i [\\text{monitor}(\\text{process}, j) \\cdot \\text{exit}(j, \\text{stop}) \\cdot e_1, \\epsilon, \\emptyset, \\text{true}] \\parallel j[e, \\epsilon, \\{i\\}, \\text{false}]$$\n\nwhere $e_1 = ?\\text{Msg}1 \\rightarrow' 1st \\text{msg'} \\text{ end}?\\text{Msg}2 \\rightarrow' 2nd \\text{msg'} \\text{ end}.$\n\nIt then moves on to evaluate the next monitor expression. Note however, that when executing this statement, process $j$’s state is not affected in any way since no links are added to its link set.\n\n$$\\rightarrow i [\\text{exit}(j, \\text{stop}) \\cdot e_1, \\epsilon, \\emptyset, \\text{true}] \\parallel j[e, \\epsilon, \\{i\\}, \\text{false}]$$\n\nAn exit signal is then sent to process $j$. This exit signal causes process $j$ to terminate immediately.\n\n$$\\rightarrow i [e_1, \\epsilon, \\emptyset, \\text{true}] \\parallel j[\\text{stop}, \\{i\\}]$$\n\nProcess $j$ then starts sending exit signals to those processes found in its link\nset, in this case process $i$. Since process $i$ is trapping exit signals, the received signal is translated into an exit message and appended to its mailbox. Here, it is important to note that since process $i$’s pid was only found once in process $j$’s link set, only one exit message is sent to process $i$.\n\n$$\\equiv j[stop, \\{i\\}] \\ || \\ i[e_1, \\epsilon, \\emptyset, \\text{true}]$$\n\n$$\\rightarrow j[stop, \\emptyset] \\ || \\ i[e_1, ['EXIT', j, stop], \\emptyset, \\text{true}]$$\n\nProcess $i$ will then read the exit message it received.\n\n$$\\equiv i[?\\text{Msg1} \\rightarrow '1st msg' \\ | \\ ?\\text{Msg2} \\rightarrow '2nd msg' \\ | \\ ['EXIT', j, stop], \\emptyset, \\text{true}] \\ || \\ j[stop, \\emptyset]$$\n\n$$\\rightarrow i[['EXIT', j, stop], ?\\text{Msg2} \\rightarrow '2nd msg' \\ | \\ \\epsilon, \\emptyset, \\text{true}] \\ || \\ j[stop, \\emptyset]$$\n\nSince only one message was found in process $i$’s mailbox, process $i$ will block indefinitely waiting for the second message.\n\n$$\\rightarrow i[?\\text{Msg2} \\rightarrow '2nd msg' \\ | \\ \\epsilon, \\emptyset, \\text{true}] \\ || \\ j[stop, \\emptyset]$$\n\nTherefore, by analysing the behaviour as described by the model, it becomes clear that with respect to the behaviour of monitors, the model’s description is not completely faithful to the behaviour of actual Erlang.\n\n### 5.3.4 Test Case 4 : Explicit Exit Signals\n\nIn this section, the correctness of the model with respect to the behaviour of explicitly sent exit signal is analysed. During the evaluation stage, a number of Erlang programs which make use of the exit(Pid,R) expression were considered. In the following table, there is a summary of the different behaviours that the model was able to describe when a process, say process A sent an exit signal to another process, say process B.\nChapter 5. Evaluation\n\n<table>\n<thead>\n<tr>\n<th>Reason (R)</th>\n<th>Is process B trapping signals?</th>\n<th>Model’s Result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>normal</td>\n<td>yes</td>\n<td>exit message appended to process B’s mailbox</td>\n</tr>\n<tr>\n<td>normal</td>\n<td>no</td>\n<td>process B ignored the signal</td>\n</tr>\n<tr>\n<td>≠ normal</td>\n<td>yes</td>\n<td>exit message appended to process B’s mailbox</td>\n</tr>\n<tr>\n<td>≠ normal</td>\n<td>no</td>\n<td>process B dies with reason R</td>\n</tr>\n<tr>\n<td>kill</td>\n<td>yes</td>\n<td>process B died with reason killed</td>\n</tr>\n<tr>\n<td>kill</td>\n<td>no</td>\n<td>process B died with reason killed</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.2: Explicit exit signals - Behaviour as described by model\n\nIn all of the above cases, the model was found to be loyal to the behaviour of actual Erlang.\n\nApart from sending explicit signals to external processes, an Erlang process is also able to send explicit exit signals to itself through the following expression exit(self(),R). In order to ensure that the model is also able to describe the behaviour of Erlang when explicit exit signals are sent to the calling process, a number of other programs were considered to cover all possible situations in which an exit(self(),R) may be used. The results obtained are described in the following table.\n\n<table>\n<thead>\n<tr>\n<th>Reason (R)</th>\n<th>Is process trapping signals?</th>\n<th>Model’s Result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>normal</td>\n<td>yes</td>\n<td>exit message is appended to process A’s mailbox</td>\n</tr>\n<tr>\n<td>normal</td>\n<td>no</td>\n<td>process A terminates with reason normal</td>\n</tr>\n<tr>\n<td>≠ normal</td>\n<td>yes</td>\n<td>exit message is appended to process A’s mailbox</td>\n</tr>\n<tr>\n<td>≠ normal</td>\n<td>no</td>\n<td>process A dies with reason R</td>\n</tr>\n<tr>\n<td>kill</td>\n<td>yes</td>\n<td>process A dies with reason killed</td>\n</tr>\n<tr>\n<td>kill</td>\n<td>no</td>\n<td>process A dies with reason killed</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.3: Explicit exit signals - Behaviour as described by model\n\nWhen the model’s behaviour was compared to the one of actual Erlang it was found that in all cases the model was able to faithfully describe the behaviour of Erlang whenever a process sends an explicit exit signals to itself. Therefore, it was concluded that the model is able to correctly describe Erlang’s behaviour whenever explicit exit signals are used.\n5.3.5 Test Case 5: Order of Signal Evaluation\n\nWhen dealing with single-node Erlang systems message delivery is guaranteed to be carried out instantaneously\\(^3\\). In order to check if the order in which received signals are evaluated is loyal to the behaviour of actual Erlang, a number of systems which make use of side effect signals, primarily:\n\n- sending of message e.g. Pid ! hello\n- linking signals e.g. link(Pid)\n- explicit exit signals e.g. exit(Pid,stop)\n\nwere considered. In the initial test cases, consecutive side effect actions of the same type (i.e. either consecutive linking signals or exit signals or ordinary messages) were carried out between a pair of processes. Through these test cases it became clear that in Erlang the receiving process always evaluated the signals in the same order in which they were sent. For instance, if a process, evaluated the following code:\n\n```erlang\nB ! message1,\nB ! message2\n```\n\nthen it was always the case that process B received `message1` prior to `message2`. Similarly, when a process evaluated the following code:\n\n```erlang\nexit(B,stop1),\nextit(B,stop2)\n```\n\nthen it was always the case that process B received the `stop1` exit signal prior to receiving the `stop2` signal. This kind of behaviour was correctly described by the defined model. Therefore, the model was found to be faithful to the behaviour of actual Erlang with regards to the order in which “same-type” signals are evaluated.\n\nAfter checking that the model can correctly describe Erlang’s behaviour when consecutive “same-type” signals are sent between a pair of processes it was checked if the model could also faithfully describe the behaviour of actual Erlang when signals of different types were sent between a pair of processes. One of the considered programs was the following:\nChapter 5. Evaluation\n\n\\[ \\text{init() -> Pid = spawn(?MODULE,wait,[]),} \\]\n\n\\[ \\hspace{1cm} \\text{%% send first signal - an exit signal} \\]\n\n\\[ \\hspace{1cm} \\text{exit(Pid,stop),} \\]\n\n\\[ \\hspace{1cm} \\text{%% send second signal - a link signal} \\]\n\n\\[ \\hspace{1cm} \\text{link(Pid),} \\]\n\n\\[ \\hspace{1cm} \\text{wait().} \\]\n\n\\[ \\text{wait() -> receive} \\]\n\n\\[ \\text{\\hspace{1cm} noMsg -> ok} \\]\n\n\\[ \\text{\\hspace{1cm} end.} \\]\n\nListing 5.4: Order of signal evaluation - test case\n\nIn this program two different signals; an exit signal followed by a link signal are sent to a particular process. The generated trace list when running this program was:\n\n\\[ \\text{ln 1 : \\{trace,<0.806.0>,spawn,<0.807.0>,\\{system3,wait,[]\\}\\}} \\]\n\n\\[ \\text{ln 2 : \\{trace,<0.806.0>,link,<0.807.0>\\}} \\]\n\n\\[ \\text{ln 3 : \\{trace,<0.807.0>,getting_linked,<0.806.0>\\}} \\]\n\n\\[ \\text{ln 4 : \\{trace,<0.807.0>,exit,stop\\}} \\]\n\n\\[ \\text{ln 5 : \\{trace,<0.806.0>,exit,stop\\}} \\]\n\nThe above trace list reveals the fact that although the process creating the link(<0.806.0>), sends the exit signal before sending the link signal, Erlang will actually create the link(ln 2) before the other process terminates due to the received exit signal(ln 4). Consequently, when process <0.807.0> terminates with reason \\text{stop}, it will send an exit signal to its newly linked process. The latter process will then also terminate with reason \\text{stop}(ln 5).\n\nThis example shows that even though in Erlang, all signals between a pair of processes are guaranteed to be ordered, there is no guarantee that all signals will be evaluated in the same order in which they are sent. This is because, whereas link signals were evaluated instantly, other signals such as the exit signals were not. In fact, it seems that the exit signals are evaluated when the system schedules some time for the receiving process. In order to better understand\nthis latter statement let’s consider Figure 5.5 which describes how actual Erlang is evaluating this particular system. The process in green indicates the process which is currently in running state whereas the black process is currently waiting for the scheduler to give it a time slice.\n\n\n\nWhen evaluating this particular system, actual Erlang first sends an exit signal to process \\(j\\). Note how this signal does not cause process \\(j\\) to terminate immediately(1). Instead, the received signal seems to be put into some sort of queue. Subsequently, process \\(i\\) sends a link signal to process \\(j\\). Here, it is important to highlight the fact that the link signal is not put into a queue as was the case with the exit signal. In contrast, this signal is evaluated instantly and a link is created between the two processes(2). When the time scheduler assigns some time to process \\(j\\), this process will first evaluate the received exit signal and terminate(3). Upon termination it will send an exit signal to its linked process, process \\(i\\)(4).\n\nWhen the behaviour of this program was described using the defined rules, it fell short of describing the behaviour of actual Erlang. This is because in the defined semantics all signals are received and evaluated instantaneously. As a result, according to the defined rules, the system will be evaluated in the following way:\nChapter 5. Evaluation\n\nThe parent process (process \\( i \\)) will first spawn its child process (process \\( j \\)).\n\n\\[\ni[\\text{spawn}(\\text{wait}, \\[\\]) \\cdot \\text{exit}(j, \\text{stop}) \\cdot \\text{link}(j) \\cdot \\text{wait}(), \\epsilon, \\emptyset, \\text{false}] \\\n\\rightarrow i[j \\cdot \\text{exit}(j, \\text{stop}) \\cdot \\text{link}(j) \\cdot \\text{wait}(), \\epsilon, \\emptyset, \\text{false}] || j[\\text{wait}(), \\epsilon, \\emptyset, \\text{false}] \n\\]\n\nProcess \\( i \\), will then send an exit signal to process \\( j \\). This will cause process \\( j \\) to terminate with reason \\text{stop}.\n\n\\[\ni[\\text{exit}(j, \\text{stop}) \\cdot \\text{link}(j) \\cdot \\text{wait}(), \\epsilon, \\emptyset, \\text{false}] || j[\\text{wait}(), \\epsilon, \\emptyset, \\text{false}] \n\\rightarrow i[\\text{true} \\cdot \\text{link}(j) \\cdot \\text{wait}(), \\epsilon, \\emptyset, \\text{false}] || j[\\text{stop}, \\emptyset] \n\\]\n\nProcess \\( i \\), then attempts to link to process \\( j \\). However, since process \\( j \\) has terminated, the link call fails and a \\text{nproc} exception is raised.\n\n\\[\ni[\\text{link}(j) \\cdot \\text{wait}(), \\epsilon, \\emptyset, \\text{false}] || j[\\text{stop}] \n\\rightarrow i[\\text{error: nproc} \\cdot \\text{wait}(), \\epsilon, \\emptyset, \\text{false}] || j[\\text{stop}, \\emptyset] \n\\rightarrow i[\\text{error: nproc}, \\emptyset, \\text{false}] || j[\\text{stop}, \\emptyset] \n\\]\n\nThe raised exception causes process \\( i \\) to terminate with reason \\text{nproc}.\n\n\\[\ni[\\text{nproc}, \\emptyset] || j[\\text{stop}, \\emptyset] \n\\]\n\nTherefore, whereas in Erlang both processes terminated with reason \\text{stop}, according to the defined rules the two processes will terminate with different reasons. Perhaps at this point one question that comes to mind is, if it is the case that the defined model has described a behaviour which can never occur in actual Erlang. In order to answer this question a time delay was inserted between the \\text{exit()} and \\text{link()} expression as shown in Listing 5.5. This was done to see if Erlang will evaluate the received signals in the same order in which they are sent.\n\n\\[\n\\text{init()} \\rightarrow \\text{Pid} = \\text{spawn}(\\text{?MODULE}, \\text{wait}, \\[\\]), \\\\\n\\text{exit}(\\text{Pid}, \\text{stop}), \\\\\n\\% 1 second delay \\\\\n\\text{link}(\\text{Pid}), \\\\\n\\text{wait}(). \\\\\n\\text{wait()} \\rightarrow \\text{receive} \\\\\n\\text{noMsg} \\rightarrow \\text{ok} \\\\\n\\text{end}. \n\\]\n\nListing 5.5: Order of signal evaluation - one second delay\nChapter 5. Evaluation\n\nIn this case the generated trace list is as follows:\n\nln1 : {trace,<0.198.0>,spawn,<0.199.0>,{system3,wait,[]}}\n\nln2 : {trace,<0.199.0>,exit,stop}\n\nln3 : {trace,<0.198.0>,link,<0.199.0>}\n\nln4 : {trace,<0.198.0>,exit,{noproc,[{erlang,link,[<0.199.0>]},\n{system3,init,0}]}\\}\n\nAs shown in the trace list, in this case the child process(process<0.199.0>)\nwill terminate before its parent process(process<0.199.0>) attempts to create\nthe link(ln2). In fact, when the link expression is evaluated an exception is raised.\nThis fact is illustrated by the fact that the parent process terminated with reason\nnoproc (ln4). In order to get a clearer picture of what is happening in this case\nlet’s consider Figure 5.6\n\n\n\nThis latter behaviour is identical to the one described by the model and therefore\nit shows that the model did not describe a behaviour which may never occur\nin reality.\n\nNonetheless, through test case 2 it became clear that in actual Erlang signals\nare not delivered and evaluated instantly. This fact was also brought to light\nthrough the following test case. In this case, two different processes, Pid1 and Pid2 are spawned. Subsequently an error signal is first sent to Pid2 and then another exit signal is sent to Pid1.\n\n\\[\n\\text{init}() \\rightarrow \\text{Pid1} = \\text{spawn}(?\\text{MODULE}, \\text{wait}, []), \\\\\n\\text{Pid2} = \\text{spawn}(?\\text{MODULE}, \\text{wait}, []),\n\\]\n\n\\[\n\\text{exit}(\\text{Pid2}, 'first signal'), \\\\\n\\text{exit}(\\text{Pid1}, 'second signal'),\n\\]\n\n\\[\n\\text{wait}().\n\\]\n\n\\[\n\\text{wait}() \\rightarrow \\text{receive} \\\\\n\\text{noMsg} \\rightarrow \\text{ok} \\\\\n\\text{end}.\n\\]\n\nListing 5.6: Order of evaluation of exit signals\n\nThe generated trace list shows that even though an exit signal is first sent to \\textit{Pid2} (in the below trace list indicated by Pid <0.966.0>), the first process to terminate due to received exit signal is the process indicated by \\textit{Pid1} (in the below trace list indicated by Pid <0.964.0>).\n\n\\[\n\\{\\text{trace}, <0.963.0>, \\text{spawn}, <0.964.0>, \\{\\text{system4, wait, []}\\}\\} \\\\\n\\{\\text{trace}, <0.963.0>, \\text{spawn}, <0.965.0>, \\{\\text{system4, wait, []}\\}\\}\n\\]\n\n\\[\n\\{\\text{trace}, <0.964.0>, \\text{exit}, 'second signal'\\} \\\\\n\\{\\text{trace}, <0.965.0>, \\text{exit}, 'first signal'\\}\n\\]\n\nIn order to better understand what is actually happening let’s consider the following diagram. The green processes, represent those processes which are in a running state whereas the black processes are in a waiting state.\nChapter 5. Evaluation\n\nFigure 5.7: Order of signal evaluation\n\nThis diagram shows that even though an exit signal is first sent to process Pid2, the first process to terminate is process Pid1. Conversely, according to the defined semantic rules, the order in which the two processes will terminate is defined by the order in which the exit signals are sent i.e. according to the defined rules process Pid2’s termination will always occur prior to that of Pid1. Therefore, through this case it seems that the defined semantics are not totally faithful to the behaviour of actual Erlang.\n\nNonetheless, it was decided that the defined rules should just the same assume that signals will be evaluated instantly. The main underlying reason, is that this prevents from having a state explosion when going through all possible sequence of states that the system may take. Additionally, in most cases, it is still possible to predict accurately the behaviour of actual Erlang by using the defined semantic rules.\n\n5.3.6 Test Case 6: Handling Errors Locally or Remotely\n\nIn the initial chapter of this dissertation, a simple example was considered so as to illustrate why understanding the behaviour of Erlang’s error handling constructs may not always be as straightforward as it might seem. In fact, even though the two programs described in Chapter 1 seemed to have identical behaviour, when\nthey were run on Erlang it became evident that this was not the case. This is because, whereas the program which handled errors locally was always able to handle the raised exceptions, the one which made use of remote error handling constructs sometimes failed to handle the exceptions which occurred.\n\nIn this section the defined model is applied to both systems so as to see to what degree the defined model is able to provide a better understanding of how these systems behave hopefully revealing the underlying cause of this different behaviour. The first system to be considered is the one in which errors are handled locally:\n\n```erlang\nprocessI(Pid,Num1,Num2) ->\n try\n Pid ! A + B\n catch\n error:badarith -> Pid ! invalid\n end.\n\nprocessJ() ->\n receive\n Result -> Result\n end.\n```\n\nListing 5.7: Local Error Handling Example\n\nIn this example, the system is composed of two different processes.\n\nProcess $i$’s task is to compute the sum of the two input numbers. The result of this computation is then sent to the process $j$. Error handling constructs are used so that if an error occurs when computing the sum of the two numbers, the atom invalid is sent to process $j$.\n\nWhen this program was run by Erlang it gave the expected results both when valid data or invalid data was input. When the behaviour of this system was\ndescribed through the defined model it became evident that this program will always behave as expected. In fact, the model was able to ensure that some value will always reach process $j$ since there does not exist any other possible sequence of reductions they may cause process $j$ to block indefinitely waiting for the result. This is because when valid data is input, the sum of the input numbers is received and when invalid data is input the atom $invalid$ is received.\n\nHere, the case when the pid of process $j$ and non-numeric data 1 and $a$ is passed to the processI() function will be considered so as to be able to better appreciate how the model was able to provide a detailed description of this system’s behaviour in the case when exceptions are raised.\n\nAccording to the defined rules, the system first attempts to calculate the sum of 1 and $a$. This raises a $badarith$ exception.\n\n$$i[try \\ j \\ 1 + a \\ catch \\ error : \\ badarith \\rightarrow \\ j!invalid \\ end, \\ \\epsilon, \\ \\emptyset, \\ \\text{false}] \\ || \\ s_j$$\n\n$$\\rightarrow \\ i[try \\ error : \\ badarith \\ catch \\ error : \\ badarith \\rightarrow \\ j!invalid \\ end, \\ \\epsilon, \\ \\emptyset, \\ \\text{false}] \\ || \\ s_j$$\n\nwhere $s_j = j[Result \\rightarrow \\ Result \\ end]$, $\\epsilon$, $\\emptyset$, $\\text{false}$\n\nThe raised exception is caught by the try-catch block and as a result, the atom $invalid$ is sent to process $j$.\n\n$$\\rightarrow \\ i[j!invalid, \\ \\epsilon, \\ \\emptyset, \\ \\text{false}] \\ || \\ j[Result \\rightarrow \\ Result \\ end, \\ \\epsilon, \\ \\emptyset, \\ \\text{false}]$$\n\n$$\\rightarrow \\ i[invalid, \\ \\epsilon, \\ \\emptyset, \\ \\text{false}] \\ || \\ j[\\text{invalid}, \\ \\epsilon, \\ \\emptyset, \\ \\text{false}]$$\n\nProcess $j$ then reads the received message.\n\n$$\\rightarrow \\ i[\\text{invalid}, \\ \\epsilon, \\ \\emptyset, \\ \\text{false}] \\ || \\ j[\\text{invalid}, \\ \\epsilon, \\ \\emptyset, \\ \\text{false}]$$\n\nThrough these reduction steps it became clear why in this case the system always behaves as expected. Now let’s consider the case when the same system was implemented using remote error handling constructs. In this case the system is composed of three different processes as shown hereunder:\nChapter 5. Evaluation\n\nFigure 5.9: Remote Error Handling Example - System\n\nProcess $i$’s task is to compute the sum of the input numbers. The result is then sent to process $j$. If an error occurs when computing the sum, process $i$ will terminate and the error is expected to be handled by process $k$. The task of process $k$ is to send the atom `invalid` to process $j$ if any errors occur whilst computing the sum of the two numbers. The system described in Figure 5.9 was implemented in the following way:\n\n```erlang\nprocessB(Pid, Num1, Num2) ->\n spawn_link(?MODULE, errorHandler, [Pid]),\n Pid ! Num1 + Num2.\n\nerrorHandler(Pid) ->\n spawn_link(?MODULE, errorHandler, [Pid]),\n receive\n {'EXIT', Pid1, normal} -> ok;\n {'EXIT', Pid1, {badarith, stack}} -> Pid ! invalid\n end.\n```\n\nListing 5.8: Remote Error Handling Example\n\nWhen the system was evaluated according to the defined rules it became clear why in some cases the system was not handling the error which occurs while computing the sum of the two numbers. In fact, the defined rules revealed the fact that due to the different interleavings that the system might take, the system\nChapter 5. Evaluation\n\nmay terminate in either of these two states when invalid data is input.\n\nCase 1: \\( i[badarith, \\emptyset] \\parallel j[normal, \\emptyset] \\parallel k[normal, \\emptyset] \\)\n\nCase 2: \\( i[badarith, \\emptyset] \\parallel j[?Result \\rightarrow Result \\text{ end}, \\epsilon, \\emptyset, \\text{false}] \\parallel k[badarith, \\emptyset] \\)\n\nCase 1 describes the case when the error handling process (process \\( k \\)) successfully handled the generated error. As a result, the atom invalid is successfully sent to process \\( j \\). Process \\( j \\) reads the sent message and terminates normally. This kind of behaviour is identical to the one where local error handling is used since the generated exception was successfully handled by the error handling process.\n\nCase 2 describes the case when the error handling process (process \\( k \\)) failed to handle the error and therefore, no message was sent to process \\( j \\). As a result, process \\( j \\) remains blocked waiting for the result of the computation. In order to better understand the cause of such behaviour let’s consider the trace of execution (as described by the model) that has led the system to behave in this way.\n\nAccording to the defined model the parent process (process \\( i \\)) will first spawn the error handling process (process \\( k \\)).\n\n\\[\ni[\\text{spawn}\\_\\text{link}(\\text{errorHandler}, \\{j\\}) \\cdot j ! 1 + a, \\epsilon, \\emptyset, \\text{false}] \\parallel s_j\n\\]\n\n\\[\n\\rightarrow i[k \\cdot j ! 1 + a, \\epsilon, \\{k\\}, \\text{false}] \\parallel\nk[\\text{process}\\_\\text{flag}(\\text{trap}\\_\\text{exit}, \\text{true}) \\cdot e_1, \\epsilon, \\{i\\}, \\text{false}] \\parallel s_j\n\\]\n\nwhere \\( s_j = j[?Result \\rightarrow Result \\text{ end}, \\epsilon, \\emptyset, \\text{false}] \\)\n\n\\[\ne_1 = ?[\\text{EXIT}', \\text{Pid}, \\text{normal}] \\rightarrow \\text{ok}; [\\text{EXIT}', \\text{Pid}, \\text{badarith}] \\rightarrow \\text{Pid!invalid}\n\\]\n\nSubsequently, when process \\( i \\) attempts to compute the sum of \\( a \\) and 1, a badarith exception is raised.\n\n\\[\n\\rightarrow i[j ! 1 + a, \\epsilon, \\{k\\}, \\text{false}] \\parallel\nk[\\text{process}\\_\\text{flag}(\\text{trap}\\_\\text{exit}, \\text{true}) \\cdot e_1, \\epsilon, \\{i\\}, \\text{false}] \\parallel s_j\n\\]\n\n\\[\n\\rightarrow i[\\text{error} : \\text{badarith}, \\epsilon, \\{k\\}, \\text{false}] \\parallel\nk[\\text{process}\\_\\text{flag}(\\text{trap}\\_\\text{exit}, \\text{true}) \\cdot e_1, \\epsilon, \\{i\\}, \\text{false}] \\parallel s_j\n\\]\n\nThe raised exception will cause process \\( i \\) to terminate with reason badarith.\nChapter 5. Evaluation\n\n\\[ \\rightarrow i[badarith, \\{k\\}] \\parallel k[process\\_flag(trap\\_exit, true) \\cdot e_1, \\epsilon, \\{i\\}, false] \\parallel s_j \\]\n\nUpon termination, process \\( i \\) starts sending exit signals to all its linked processes, in this case process \\( k \\). Note that since process \\( k \\) (the error handling process), has not set its process_flag yet, it will fail to trap the exit signal. As a result, instead of carrying out the needed error handling code process \\( k \\) would terminate immediately upon receipt of the exit signal.\n\n\\[ \\rightarrow i[badarith, \\{k\\}] \\parallel k[process\\_flag(trap\\_exit, true) \\cdot e_1, \\epsilon, \\{i\\}, false] \\parallel s_j \\]\n\n\\[ \\rightarrow i[badarith, \\emptyset] \\parallel k[badarith, \\emptyset] \\parallel s_j \\]\n\nHere it is worth pointing out that process \\( j \\), is still alive waiting to receive the result of the computation.\n\nThrough these reductions it became clear why this system does not have an identical behaviour to the one which uses local error handling. The main reason behind this faulty behaviour lies in the fact that an error might occur before the error handling process has set its process_flag. As a result, it is not able to trap the received exit signal so as to recover from the received signal. The sequence of steps that led to such behaviour are described in Figure 5.10.\nThis example proved that the model is truly capable of providing a better insight into how a system might behave. Moreover, through the model it became much easier to identify the sequence of events that led to this behaviour.\n\nIt is also worth mentioning, that even though the two programs considered in Chapter 1, seemed to have identical behaviour when valid data is input, when the model was applied to this program it revealed that in effect this is not true. This is because, when using remote error handling it may be the case that process $k$ will block indefinitely. This may happen if the sequence of steps described in the Figure 5.11 takes place.\nIn the above diagram, process \\( i \\) terminates before process \\( k \\) has set its process_flag(4). Since the reason is set to *normal*, the received signal is ignored(5). After receiving the signal, process \\( k \\) will set its process_flag to true(6). Given the fact that both process \\( i \\) and process \\( j \\) have terminated, process \\( k \\) will then remain blocked waiting for the message describing the way process \\( i \\) terminates.\n\nThrough this simple case study, it became evident that the defined model is able to provide a better insight into Erlang’s both local and remote error handling constructs. As a result, whereas before it was somewhat difficult to truly reason about Erlang’s behaviour in the presence of errors through the model it became much easier to understand such behaviour. Moreover, the step-by-step description of how Erlang programs are evaluated greatly helped to reveal the cause of unexpected behaviour.\nChapter 5. Evaluation\n\n5.4 Evaluation Results\n\nThis last section, outlines some facts that were observed during the evaluation stage of this project. Primarily, it first gives a summary describing the results that were obtained when measuring to what degree the model is faithful to actual Erlang. Subsequently, the main limitations of the work done in this project are discussed.\n\n5.4.1 Accomplishments\n\nIn this section a table is presented summarizing all the different aspects of the model that have been analysed in this chapter. Primarily it shows, if the model is sound and/or complete with respect to the behaviour of actual Erlang. The term soundness refers to the fact that the model can never describe a behaviour which may never occur in reality. Completeness refers to the fact that the model is able to represent all the possible ways actual Erlang may behave when using that particular mechanism.\n\n<table>\n<thead>\n<tr>\n<th>Erlang mechanism</th>\n<th>Model</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Sound</td>\n</tr>\n<tr>\n<td>Local Error Handling - try-catch</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Error Propagation - linking</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Error Propagation - monitoring</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Explicit Error Signals</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Order of Signal Evaluation</td>\n<td>✓</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.4: Soundness & Completeness of Model\n\nHere, it is important to note that since in this project the evaluation approach was not a formal one, the ✓ symbol does not necessary imply that a particular mechanism is 100% guaranteed to be sound or complete. However, the several examples which were considered during the evaluation stage gave us a good indication if the behaviour of a specific Erlang mechanism as described by the model is sound and/or complete.\n\nThis table shows that the defined model was found to be able to describe soundly the behaviour of all the Erlang mechanisms that were considered. This\nis because when carrying out the evaluation it was never the case that the model described a behaviour which can never occur in actual Erlang.\n\nWith respect to the model’s completeness, in some cases the model fell short to describe all the possible ways an Erlang system may behave. For instance, when using monitors, the model was not able to completely describe the behaviour of actual Erlang when one particular process created multiple monitors of another process. The model was also found not to be complete when it came to describing the ordering in which sent signals are evaluated. This is because, whereas the model assumes that all signals are evaluated in the same order in which they are sent, in reality Erlang may sometimes evaluate the sent signals in a different order.\n\nHowever, even though the model is not complete through the evaluation stage it became evident that by using the model we are now able to get a better insight into how Erlang’s error handling mechanisms behave. In this chapter, this fact became even more clear through the several number of test cases which were carried out. In all these test cases the model was able to give a precise description of how particular constructs behave.\n\nThrough the model it also became possible to get a good indication if two systems are expected to behave in a similar way or not. For instance, in the last case study, the model was able to show that although the program which adopted remote error handling seemed to have an identical behaviour to the one using local error handling, in truth the two programs may behave in a different way.\n\n### 5.4.2 Limitations\n\nEven though, in most cases the defined semantics and designed evaluator are able to faithfully mirror the behaviour of actual Erlang through the evaluation stage it became apparent that they still suffer from some limitations.\n\n#### 5.4.2.1 A Single-node Semantics\n\nOne main limitation of the defined semantics is that they are only able of describing all possible behaviors of single-node systems. If these semantics were to be used to describe the behaviour of distributed Erlang systems, the rules may not be able to describe completely the different ways in which the system might\nbehave. This is because, as claimed by [3], when dealing with distributed Erlang systems, signal delivery is not immediate. In contrast, the defined semantics assumes that all signals are received instantaneously. In order to better understand, the implications of this latter fact let’s consider the following case:\n\n\n\nIn the above system Process A, first sends an explicit exit signal to process C. Subsequently, an error signal is sent to process B. Once process B receives the exit signal it will terminate and an exit signal is sent to process C.\n\nAccording to the defined semantics, process C will always terminate with reason ‘first’ and process B will always terminate with reason ‘second’. This is because in the defined semantics all exit signals are received and evaluated immediately. However, in actual Erlang if all three processes were to be found on different nodes, the exit signal delivery is not guaranteed to be instantaneous. Therefore, even though process A will send the exit signal ‘first’ to process C prior to sending an exit signal ‘second’ to process B, it is not guaranteed that the ‘first’ signal arrives at C prior to the exit signal ‘second’. In actual fact, it may very well be the case that process C terminates with reason ‘second’. This kind of behaviour cannot be described through the presented semantics.\n\n### 5.4.2.2 Simulation Time\n\nPerhaps one of the main limitations of the designed evaluator is that in some cases it may take a considerably long time to produce an output describing the different ways the system may behave. The underlying cause lies in the fact that the number of different interleavings that need to be checked will grow exponentially to the size of the input system. As a result, the designed evaluator\nis only able to simulate the behaviour of small systems in a reasonable amount of time.\n\n5.5 Conclusion\n\nThis chapter evaluated the different aspects of this project. This was done by considering a number of Erlang systems and comparing the behaviour of these programs as described by the model against the way the same programs behaved when run on the Erlang VM. This evaluation strategy gave us a clear indication to what extent the model is able to faithfully mirror the behaviour of actual Erlang. Additionally, it also helped to expose the main benefits and limitations of the defined model and evaluator.\n6. Conclusion and Future Work\n\nIn this final chapter the benefits that have been achieved through this project will be outlined. Subsequently, some improvements that could be done to the work presented in this project are suggested.\n\n6.1 Benefits Achieved\n\nThe following points outline the main results that were accomplished through the defined semantic rules.\n\n**Offer a better insight** - In the initial stage of this project it was not quite clear how Erlang systems, especially those which made use of the remote error handling constructs might behave. For instance, in Chapter 1, it was rather unclear why the program which made use of the remote error handling constructs (Listing 1.2) does not always behave in the same way as the one which uses local error handling constructs (Listing 1.1). The model defined in this work has successfully addressed these type of problems by providing precise and unambiguous description of Erlang’s error handling constructs. As a result, as shown in the Evaluation chapter, by applying the model on a particular Erlang systems it is now possible to understand immediately why a system is behaving in a certain way.\n\n**Explain the cause of unexpected behaviour** - The defined rules are capable of providing a step-by-step description of how a system is evaluated possibly revealing sequences of steps that may lead to unexpected outcomes. For instance, with respect to the example described in Chapter 1, it is now clear why sometimes the system which makes use of remote error handling constructs behaves in an\nunexpected way and thus fails to handle any raised exceptions. This is because through the defined model it is now possible to retrace the sequence of steps that may cause the system to behave in an unexpected way.\n\n**Predict system’s behaviour** - Prior to defining the model, the only way a user could see how an Erlang system might behave was by executing it on the Erlang VM. In fact, in the initial stage of this project, the difference in behaviour between Listing 1.1 and Listing 1.2 could only be noted after the two systems were run on the Erlang VM. Conversely, through the defined rules it has became possible to see that the two systems might behave in different ways, without the need of actually running the systems on the Erlang VM.\n\n**Lay the foundations of a semantic theory** - This model is able to give a good indication of whether or not a pair of systems are expected to have identical behaviour. For instance, even though the pair of systems described in Chapter 1 seemed to have identical behaviour, the model was able to show that in actual fact this was not the case. In fact, when the model was applied to the pair of programs, it was able to bring to light the subtle difference that existed between them. This fact indicates that the defined rules can act as a basis for defining notions of equivalence such as testing equivalence[26] and reduction barbed congruence, which can later be justified through labelled transition systems and bisimulations[24, 25].\n\n### 6.2 Suggestions for Future Work\n\nEven though the main objectives of this project have been met, there is still room for improvement. In this section a number of suggestions that may be considered for future work are presented.\n\n#### 6.2.1 Distributed-node Semantics\n\nFollowing up this work, it would be interesting to study the behaviour of Erlang’s error handling mechanisms when used in distributed systems. The rules defined in this project are only able to accurately describe the behaviour of single-node systems. Therefore, when considering the fact that in these days more emphasis is being put on building distributed systems it would be quite beneficial to extend\nthe semantic rules defined here so as to be able to cater also for distributed systems.\n\n### 6.2.2 Extend chosen Erlang Subset\n\nAnother improvement that could be done to the semantics, is to modify Erlang’s chosen subset so as to accept all constructs found in Core Erlang[2]. As claimed in [3], Core Erlang represents a complete core fragment of Erlang. Therefore, if the semantics is modified to operate on Core Erlang, it would be a great step towards defining a complete semantics for Erlang. In addition, since there already exists a compiler (HiPE compiler) which can automatically translate Erlang programs in terms of Core Erlang, it will become possible to modify the designed evaluator to accept ordinary Erlang programs instead of programs consisting only of constructs found in the chosen subset. This is because the HiPE compiler could then be used to translate the input fed to the evaluator in terms of Core Erlang prior to simulating Erlang’s behaviour according to the defined semantics.\n\n### 6.2.3 Improve Evaluator’s Efficiency\n\nOne major downside of the designed evaluator is that it may be rather slow when simulating the behaviour of input systems. Even though some techniques have already been adopted in order to improve its efficiency, it would be ideal to further explore other modifications that could be made to make it more efficient. Perhaps, one possible improvement would be that given the fact that the simulation of different traces is independent of each other, they could easily be carried out in parallel.\n\n### 6.2.4 A semantic theory based around notions of equivalence\n\nThe model defined in this work only provides the basis of a semantic theory. Therefore, it would be interesting to extend this work so that given any two Erlang systems it would be able to show if they are truly semantically equivalent or not.\n6.3 Conclusion\n\nThis project gave a closer insight into Erlang’s error handling mechanisms. A formal semantic definition for these mechanisms was presented providing an accurate and unambiguous description of Erlang’s behaviour when dealing with errors. These definitions have been animated through an evaluator which returns a detailed description of all the possible different ways a particular Erlang system may behave.\n\nIn order to better appreciate the usefulness of these formal definitions, the behaviour of a number of different Erlang systems was described according to the defined semantics. These descriptions were found to be really helpful in understanding why sometimes certain systems behaved in an unexpected way. In addition, these descriptions were also able to approximate whether two syntactically different systems were truly semantically equivalent or not.\nHere are some steps that need to be followed in order to use the designed evaluator.\n\nA.1 Prerequisites\n\n- pdf reader eg. Acrobat Reader\n- implementation of LaTeX eg. MiKTeX (listings package needed)\n\nA.2 Using the Evaluator\n\nIn order to use the evaluator\n\n1. Copy Evaluator Folder onto your computer.\n2. Run the Evaluator.bat file.\n3. In the command prompt enter the path where the “functions” file is found. This file should contain the necessary function definitions that are needed when running the Erlang system. The syntax of the input file should be quite similar to the one used when writing an Erlang module. In fact the only differences between an ordinary Erlang module file and the input accepted by the evaluator are that in the input file:\n\n - the module and export constructs need not be included\n - definitions of functions which share the same function name are not delimited by a ; but by a .\n - the spawn_link, spawn_monitor and spawn functions do not expect the module name parameter\n - only the subset of Erlang as defined in Table 3.2 can be successfully parsed\nAppendix A.\n\nFollowing there is a simple Erlang module and how it can be expressed in terms of the evaluator’s input. The code in green, highlights the parts which need to be removed or modified before an Erlang module is fed to the evaluator.\n\nErlang Module:\n\n```erlang\n-module(example1).\n-export([init/1,sum/1,getSum/2]).\n\nsum([]) -> 0;\nsum([H|T]) -> H + sum(T).\n\ngetSum(Pid,List) -> Pid ! sum(List).\n\ninit(List) ->\n spawn_link(getSum,[self(),List]),\n receive\n Sum -> Sum\n end.\n```\n\nEvaluator’s input:\n\n```erlang\nsum([]) -> 0.\nsum([H|T]) -> H + sum(T).\n\ngetSum(Pid,List) -> Pid ! sum(List).\n\ninit(List) ->\n spawn_link(getSum,[self(),List]),\n receive\n Sum -> Sum\n end.\n```\n\n4. After entering the functions file path, enter the path of the file containing the expression that in actual Erlang is input into Erlang’s shell.\n\n5. In the command prompt then enter the name of the output file.\n\n6. The system will then automatically create and open a pdf file containing a detailed description of the different ways the system may behave.\nBibliography\n\n\n[9] S. Nyström Concurrency in Java and in Erlang Department of Information Technology, Uppsala University, Sweden, 2004\n\n\n"}}},{"rowIdx":154,"cells":{"id":{"kind":"string","value":"f75f4a27369f154a9321f2bd807da12c66ef168e"},"text":{"kind":"string","value":"Apache Wink Developer Guide\n\nApache Wink 1.0\n\nApache Wink is a complete Java based solution for implementing and consuming REST based Web Services. The goal of the Apache Wink framework is to provide a reusable and extendable set of classes and interfaces that will serve as a foundation on which a developer can efficiently construct applications.\n\nContents\n\n1 Introduction to Apache Wink\n2 Apache Wink Building Blocks\n3 Getting Started with Apache Wink\n4 JAX-RS Concepts\n5 Apache Wink Server\n 5.1 Registration and Configuration\n 5.2 Annotations\n 5.3 Resource Matching\n 5.4 APP. Service Document\n 5.5 Spring Integration\n 5.6 WebDAV Extension\n 5.7 Handler Chain\n 5.8 Link Builder\n 5.9 Assets\n 5.10 Admin Views\n6 Apache Wink Client\n 6.1 Getting Started with Apache Wink Client\n 6.2 Configuring the Apache Wink Client\n 6.3 Input and Output Stream Adapters\n7 Apache Wink Providers\n 7.1 Json\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>7.2 APP</td>\n<td></td>\n</tr>\n<tr>\n<td>7.3 Atom</td>\n<td></td>\n</tr>\n<tr>\n<td>7.4 RSS</td>\n<td></td>\n</tr>\n<tr>\n<td>7.5 HTML</td>\n<td></td>\n</tr>\n<tr>\n<td>7.6 CSV</td>\n<td></td>\n</tr>\n<tr>\n<td>7.7 OpenSearch</td>\n<td></td>\n</tr>\n<tr>\n<td>7.8 MultiPart</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**Appendix A - Feeds Support**\n\n**Appendix B - Google App Engine**\n1 Introduction to Apache Wink\n\nThis page last changed on Sep 12, 2009 by bluk.\n\nIntroduction to Apache Wink\n\nApache Wink 1.0 is a complete Java based solution for implementing and consuming REST based Web Services. The goal of the Wink framework is to provide a reusable and extendable set of classes and interfaces that will serve as a foundation on which a developer can efficiently construct applications.\n\nWink consists of a Server module for developing REST services, and of a Client module for consuming REST services. It cleanly separates the low-level protocol aspects from the application aspects. Therefore, in order to implement and consume REST Web Services the developer only needs to focus on the application business logic and not on the low-level technical details.\n\nThe Wink Developer Guide provides the developer with a rudimentary understanding of the Wink framework and the building blocks that comprise it.\n\nWelcome to Apache Wink\n\nWink is a framework for the simple implementation and consumption of REST web services. REST is an acronym that stands for REpresentational State Transfer. REST web services are \"Resources\" that are identified by unique URIs. These resources are accessed and manipulated using a set of \"Uniform methods\". Each resource has one or more \"Representations\" that are transferred between the client and the service during a web service invocation.\n\nThe central features that distinguish the REST architectural style from other network-based styles is its emphasis on a uniform interface, multi representations and services introspection.\n\nWink facilitates the development and consumption of REST web services by providing the means for modeling the service according to the REST architectural style. Wink provides the necessary infrastructure for defining and implementing the resources, representations and uniform methods that comprise a service.\n\nREST Architecture\n\nFor a detailed understanding of the REST architecture refer to the description by Roy Fielding in his dissertation, The Design of Network-based Software Architectures. In particular, Chapter 5 Representational State Transfer (REST) describes the principles of the architecture.\n\nREST Web Service\n\nFigure 1: REST Web service design structure\nFigure 1 demonstrates the design principles and components that comprise a REST web service. Wink reflects these design principles in the implementation of web services.\n\n**Apache Wink Open Development**\n\nThe purpose of this document is to provide detailed information about Wink 1.0 and describe the additional features that the Apache Wink 1.0 runtime provides in addition to the JAX-RS Java API for REST Web Service specification.\n\nIn addition to the features description, this document also provides information regarding implementation specific issues.\n\nThis document provides the developer with a rudimentary understanding of the Wink 1.0 framework in order to highlight the underlying concepts and precepts that make up the framework in order to create a basis for understanding, cooperation and open development of Wink.\n\n**JAX-RS Specification Document**\n\nFor more information on the JAX-RS functionality, refer to the JAX-RS specification document, available at the following location:\n\nhttp://jcp.org/aboutJava/communityprocess/final/jsr311/index.html\n\n**JAX-RS Compliancy**\n\nApache Wink 1.0 is a complete implementation of the JAX-RS v1.0 specification.\n\nJAX-RS is a Java based API for RESTful Web Services is a Java programming language API that provides support in creating web services according to the Representational State Transfer (REST) architectural style. JAX-RS uses annotations, introduced in Java SE 5, to simplify the development and deployment of web service clients and endpoints.\nApache Wink Building Blocks\n\nIn order to take full advantage of Apache Wink, a basic understanding of the building blocks that comprise it and their functional integration is required. The following section provides an introduction to the basic concepts and building blocks of Apache Wink, version 1.0. In order to gain in-depth understandings of the building blocks refer to the table of contents where these concepts are expanded and additional example are used to further illustrate the Apache Wink and JAX-RS SDK technologies.\n\nThis section contains the following topics:\n\nService Implementation Building Blocks\n\n- Resource\n- Providers\n- URI Dispatching\n- Assets\n- Annotations\n- URL Handling\n- HTTP Methods - GET, POST, PUT, DELETE and OPTIONS\n- Basic URL Query Parameters\n- Apache Wink Building Blocks Summary\n\nClient Components Building Blocks\n\n- RestClient Class\n- Resource Interface\n- ClientRequest Interface\n- ClientResponse Interface\n- ClientConfig Class\n- ClientHandler Interface\n- InputStreamAdapter Interface\n- OutputStreamAdapter Interface\n- EntityType Class\n\nThe Apache Wink Runtime\n\n- Request Processor\n- Deployment Configuration\n- Handler Chains\n\nService Implementation Building Block Overview\n\nAs mentioned in the “Apache Wink Introduction” section, Apache Wink 1.0 reflects the design principles of a REST web service. It does so by providing the developer with a set of java classes that enable the implementation of “Resources”, “Representations” and the association between them. Wink 1.0 also enables the developer to define the resource URI and the “Uniform methods” that are applicable to the resource.\nResource\n\nA \"resource\" represents a serviceable component that enables for the retrieval and manipulation of data. A \"resource class\" is used to implement a resource by defining the \"resource methods\" that handle requests by implementing the business logic. A resource is bound or anchored to a URI space by annotating the resource class with the @Path annotation.\n\nProviders\n\nA provider is a class that is annotated with the @Provider annotation and implements one or more interfaces defined by the JAX-RS specification. Providers are not bound to any specific resource. The appropriate provider is automatically selected by the Apache Wink runtime according to the JAX-RS specification. Apache Wink supplies many providers, however, application developers may supply their own which take precedence over any provider in the default runtime.\n\nThere are three types of providers defined by the JAX-RS specification:\n\n- Entry Providers\n- Context Providers\n- Exception Mapping Provider\n\nEntity Provider\n\nAn \"Entity Provider\" is a class that converts server data into a specific format requested by the client and/or converts a request transmitted by the client into server data. For instance, a String entity provider can turn request entities (message bodies) over the wire into a Java type (java.lang.String). Entity providers can also turn native Java types such as a java.lang.String into an appropriate response entity. An entity provider can be restricted to support a limited set of media types using the @javax.ws.rs.Produces and @javax.ws.rs.Consumes annotations. An entity provider is configured to handle a specific server data type by implementing the javax.ws.rs.ext.MessageBodyWriter and/or javax.ws.rs.ext.MessageBodyReader interfaces.\n\nContext Provider\n\nContext providers are used to supply contexts to resource classes and other providers by implementing the javax.ws.rs.ext.ContextResolver interface. For example, if a custom JAXBContext is required to serialize or deserialize JAXB objects, an application can provide a ContextResolver that will return a specific instance of a JAXBContext. Context providers may restrict the media types that they support using the @javax.ws.rs.Produces annotation.\n**Exception Mapping Provider**\n\nException mapping providers map exceptions into an instance of a `javax.ws.rs.core.Response` by implementing the `javax.ws.rs.ext.ExceptionMapper` interface. The Response objects can contain response information such as status codes, HTTP headers, and a response entity (message body). When a resource method throws an exception, the runtime will try to find a suitable ExceptionMapper to “translate” the exception to an appropriate Response object.\n\n*Figure 4: Exception Mapping Provider Diagram*\n\n**URI Dispatching**\n\nDesigning an efficient REST web service requires that the application developer understands the resources that comprise the service, how to best identify the resources, and how they relate to one another.\n\nRESTful resources are identified by URIs in most cases related resources have URIs that share common path elements.\n\n*Figure 5: Apache Wink Logic Flow*\nApache Wink Logic Flow\n\nFigure 5 illustrates the Apache Wink logic flow. The HTTP request sent by the client invokes the \"Apache Wink REST Servlet\". The REST servlet uses the \"Request Processor\" and the request URI in order to find, match and invoke the correct resource method.\n\nBookmarks Example\n\nThroughout this document, various project examples are used in order to describe the functionality and processes that comprise the Apache Wink. In order to explain the REST design principles used in the Apache Wink this developer guide refers to the \"Bookmark\" example project found in the examples folder located in the Apache Wink distribution.\n\nRefer to the code (using an IDE application) in the example in conjunction with the following explanations and illustrations in this developer guide.\n\nApache Wink Servlet and Request Processor\n\nFigure 6: Apache Wink REST Servlet and Request Processor for the Bookmark Services\nServer and Request Processor\n\nFigure 6 shows the Apache Wink servlet and request Processor concept in the context of the application server. In the \"Bookmarks\" example in Figure 6 there are two Resources, the first Resource is associated with the /mybookmarks URI and manages the bookmarks collection, the second resource is associated with the /mybookmarks/{bookmark} Resources and manages an individual bookmark within the collection.\n\nThe Resources' defined by the web service and managed by Apache Wink are referred to as \"URI space\". The Resources space is the collection of all URI's that exist in the same context. Figure 6 shows the URI space that contains /mybookmarks and /mybookmarks/{bookmarks}.\n\nURI Space\n\nThe Bookmarks service URI space consists of the following URI space items and detailed descriptions about their context and functionality.\n\nTable 1: URI Management\n\n<table>\n<thead>\n<tr>\n<th>URI space Item</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>/Bookmark/rest</td>\n<td>This URI is the root context of the bookmark service and the entry point of the URI space of the service. An HTTP GET request to this URI returns a "Service Document" which is automatically generated by Apache Wink. The service document provides information about all available collections in the URI space.</td>\n</tr>\n<tr>\n<td>/Bookmark/rest/mybookmarks</td>\n<td>This URI is associated with a collection of bookmarks resources. Clients use the HTTP GET method in order to retrieve a representation of</td>\n</tr>\n</tbody>\n</table>\nthe collection and HTTP POST method in order to create a new item in the collection.\n\n/Bookmark/rest /mybookmarks/ {bookmark}\nThis URI template is associated with a single bookmark resource. Clients use the HTTP GET method in order to retrieve a representation of the resource, HTTP PUT method is used in order to update the resource and HTTP DELETE method is used in order to delete the resource.\n\n## Assets\n\nAssets are classes that contain \"web service business logic\" implemented by the developer. Each Asset is associated with one or more URI. The Apache Wink dispatcher invokes the Asset, which is associated with the URI found in the HTTP request.\n\nAn Asset class can implement one or more methods, each method is associated with a single HTTP method (GET, HEAD, POST, PUT, DELETE etc). The methods can be associated with a MIME type of a produced representation. Methods that handle HTTP verbs of requests with a body (such as PUT, POST) are also associated with the MIME type of the HTTP request.\n\nThe Asset class can be registered to the Apache Wink using the \"Spring context xml\" or by using a registration API.\n\n#### Spring Context Configuration\nFor further information regarding the Spring Context, refer to 5.5 Spring Integration in section 5 Apache Wink Server.\n\n## Annotations\n\nAnnotations are a special text notations, or metadata, added to Java version 1.5. Annotations in Java source code can affect both compilation and runtime behavior of the resulting Java classes.\n\nJAX-RS is implemented by the use of annotations that are defined in the JAX-RS specification. Apache Wink provides a set of additional annotations that enrich the functionality of the JAX-RS enabled application.\n\nThe following table describes the additional Apache Wink annotations:\n\n<table>\n<thead>\n<tr>\n<th>Annotation</th>\n<th>Precedes</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>@Workspace</td>\n<td>Resource</td>\n<td>Associate a "Collection Resource" with a workspace element and collection elements in an APP Service Document</td>\n</tr>\n<tr>\n<td>@Scope</td>\n<td>Resource /Provider</td>\n<td>Defines the default lifecycle behavior for resources and providers, and the option for controlling the lifecycle through the javax.ws.rs.core.Application class</td>\n</tr>\n<tr>\n<td>@Parent</td>\n<td>Resource</td>\n<td>Provides the ability to define a base template URI for the URI specified in a resources @Path annotation</td>\n</tr>\n</tbody>\n</table>\n**URL Handling**\n\nThe Apache Wink receives HTTP requests and then dispatches a wrapped HTTP request to the appropriate Resource method. The HTTP request is matched to the Resource method based on the HTTP request parameters, the Resource method definitions and the MIME type.\n\n**Figure 7: URL Request Handling**\n\n\n\n**Request Handling**\n\nFigure 7 demonstrates the HTTP Client request path to the URI dispatcher; once the dispatcher receives the request it is then matched according to the HTTP method, URL and MIME type and finally the Resource registry definition.\n\n**HTTP Methods - GET, POST, PUT, DELETE and OPTIONS**\n\nThe common HTTP 1.1 methods for the Apache Wink are defined in the following section. This set of methods can be expanded.\nMethod Usage\n\nTable 3: HTTP Methods\n\n<table>\n<thead>\n<tr>\n<th>Method</th>\n<th>Safe</th>\n<th>Idempotent</th>\n<th>Cacheable</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GET</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>HEAD</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>PUT</td>\n<td></td>\n<td>X</td>\n<td></td>\n</tr>\n<tr>\n<td>POST</td>\n<td></td>\n<td></td>\n<td>*</td>\n</tr>\n<tr>\n<td>DELETE</td>\n<td></td>\n<td>X</td>\n<td></td>\n</tr>\n<tr>\n<td>OPTIONS</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nKey - X\n\n- **Safe** - does not affect the server state\n- **Idempotent** - a repeated application of the same method has the same effect as a single application\n- **Cacheable** - a response to a method is cacheable if it meets the requirements for HTTP caching\n- * - Responses to this method are not cacheable, unless the response includes an appropriate Cache-Control or Expires header fields. However, the 303 response can be used to direct the user agent to retrieve a cacheable resource.\n\n**GET**\n\nThe GET method is used to retrieve information from a specified URI and is assumed to be a safe and repeatable operation by browsers, caches and other HTTP aware components. This means that the operation must have no side effects and GET method requests can be re-issued.\n\n**HEAD**\n\nThe HEAD method is the same as the GET method except for the fact that the HEAD does not contain message body.\n\n**POST**\n\nThe POST method is used for operations that have side effects and cannot be safely repeated. For example, transferring money from one bank account to another has side effects and should not be repeated without explicit approval by the user.\n\nThe POST method submits data to be processed, for example, from an HTML form, to the identified resource. The data is included in the body of the request. This may result in the creation of a new resource or the updates of existing resources or both.\n\n**PUT**\n\nThe PUT method requests that the enclosed entity be stored under the supplied Request-URI. If the Request-URI refers to an already existing resource, the enclosed entity should be considered as a modified version of the one residing on the origin server.\n\nIf the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new resource by the requesting user agent, the origin server can create the resource with that URI.\nDELETE\n\nThe DELETE method requests that the origin server delete the resource identified by the Request-URI. This method can be overridden on the origin server. The client cannot be guaranteed that the operation has been carried out, even if the status code returned from the origin server indicates that the action has been completed successfully.\n\nOPTIONS\n\nThe OPTIONS method represents a request for information about the communication options available on the request/response chain identified by the Request-URI. This method allows the client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval.\n\nBasic URL Query Parameters\n\nA URL parameter is a name and value pair appended to a URL. The parameter begins with a question mark \"?\" and takes the form of name=value. If more than one URL parameter exists, each parameter is separated by an ampersand \"&\" symbol. URL parameters enable the client to send data as part of the URL to the server.\n\nWhen a server receives a request and parameters are appended to the URL of the request, the server uses these parameters as if they were sent as part of the request body. There are several predefined URL parameters recognized by Apache Wink when using Wink providers. The following table lists the parameters commonly used in web service URLs. These special URL parameters are defined in the \"RestConstants\" class.\n\nQuery Parameters\n\nTable 4: URL Parameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>alt</td>\n<td>Provides an alternative representation of the specified MIME type. Apache Wink recognizes this as a representation request of the highest priority.</td>\n<td>MIME type, e.g. "text%2Fplain"</td>\n</tr>\n<tr>\n<td>absolute-urls</td>\n<td>Indicates to Apache Wink that the generated links in the response should be absolute, mutual exclusive with the relative-urls parameter</td>\n<td>NONE</td>\n</tr>\n<tr>\n<td>relative-urls</td>\n<td>Indicates to Apache Wink that the generated links in the response should be relative, mutual exclusive with the absolute-urls parameter</td>\n<td>NONE</td>\n</tr>\n<tr>\n<td>callback</td>\n<td>Wrap javascript representation in callback function, is relevant when requested with an application/json MIME type.</td>\n<td>name of callback function. For example, "myfunc"</td>\n</tr>\n</tbody>\n</table>\n\nCombining URL Parameters\n\nA single URL can contain more than one URL parameter, example \"?alt=text%2Fjavascript&callback=myfunc\" (where \"%2F\" represents escaped \"/\").\nApache Wink Building Blocks Summary\n\nThe previous section \"Service Implementation Building Blocks\" outlines the basic precepts and building blocks that comprise the service side of Apache Wink. In order to understand the relationship between the building blocks that comprise Apache Wink a set of example applications have been designed and built that provide a reference point that demonstrate a rudimentary understanding about the functionality of Apache Wink.\n\nApache Wink Examples\n\nThe following examples applications are used in this \"Apache Wink Developer Guide\".\n\n- Bookmarks\n- HelloWorld\n- QADefects\n\nBookmarks Project\n\nThis developer guide uses the bookmarks example application in order to describe the logic flow process within Apache Wink. Refer to the comments located in the \"Bookmarks\" example application code for in-depth explanations about the methods used to build the bookmarks application.\n\nHelloWorld Project\n\nComplete the step-by-step \"HelloWorld\" tutorial in chapter 3 \"Getting Started with Apache Wink\" and then follow the installation instructions on page xx, in order to view the \"Bookmarks\" example application from within the Eclipse IDE.\n\nQADefects\n\nThe QADefects example application illustrates the advanced functionality of Apache Wink by implementing most of the features provided by the Apache Wink (Runtime) framework.\n\nApache Wink Client Component Basics Overview\n\nThe Apache Wink Client interacts with REST Web-Services. It maps REST concepts to Java classes and encapsulates underlying REST related standards and protocols, as well as providing a plug-in mechanism for raw HTTP streaming data manipulation. This mechanism also provides the ability to embed cross application functionality on the client side, such as security, compression and caching.\n\nFigure 8: Apache Wink Client Simplified Breakdown\nFigure 8: The illustration shows the basic elements that comprise the Apache Wink Client. The Apache Wink Client utilizes the providers mechanism defined by the JAX-RS specification to perform reading and writing of java objects. The Apache Wink Client is pre-initialized with the same providers that are predefined by the Apache Wink JAX-RS server implementation.\n\nApache Wink Client Components\n\nThe Apache Wink Client is comprised of several key elements that together create a simple and convenient framework for the consumption of REST based web services. The client is an abstraction of REST concepts modeled into simple java classes that encapsulate the underlying HTTP protocol, used for the service invocation.\n\nThe Apache Wink Client uses the java HttpURLConnection class for the HTTP invocation. The Apache Wink Client also provides a module that utilizes the Apache HTTP Client instead of the default HttpURLConnection class.\n\nThe following section provides an overview of the key elements and classes that comprise the Apache Wink Client.\n\nRestClient Class\n\nThe RestClient class is the central access point to Apache Wink Client. It provides the user with functionality that enables the creation of new Resource instances. The RestClient provides the user with the ability to set different configuration parameters and custom JAX-RS providers and propagates them to the created resources.\n\nResource Interface\n\nThe Resource interface represents a single web resource located at a specific URL, enabling for the manipulation and retrieval of the resource by the invocation of different HTTP methods on the resource instance. The resource interface is implemented following the Builder design pattern so method calls can be easily aggregated and in order to enable easy construction of requests and setting of the resource properties prior to invocation.\n\nClientRequest Interface\n\nThe ClientRequest interface represents a request issued by invoking any one of the invocation methods on a Resource. An instance of a ClientRequest is created at the beginning of an invocation and passed to all the client handlers defined on the client that was used for the invocation.\n**ClientResponse Interface**\n\nThe ClientResponse interface represents an HTTP response that is received after invoking any one of the invocation methods on a Resource. An instance of a ClientResponse is created by the ConnectionHandler at the end of the handler chain, and is returned from every handler on the chain.\n\n**ClientConfig Class**\n\nThe ClientConfig class provides client configuration when instantiating a new RestClient. The ClientConfig is implemented using the Builder design pattern so method calls can be easily aggregated. Custom Providers and client Handlers are set on the ClientConfig instance prior to the creation of the RestClient.\n\n**ClientHandler Interface**\n\nClient handlers are used to incorporate cross invocation functionality. The ClientHandler interface is implemented by client handlers, and the handle() method is invoked for every request invocation in order to allow the handler to perform custom actions during the request invocation.\n\n**InputStreamAdapter Interface**\n\nThe InputStreamAdapter interface is used to wrap the response input stream with another input stream in order to allow the manipulation of the response entity stream. The adapt() method is called after reading the response status code and response headers, and before returning to the ClientResponse to the handlers on the chain.\n\n**OutputStreamAdapter Interface**\n\nThe OutputStreamAdapter interface is used to wrap the request output stream with another output stream to allow the manipulation of the request entity stream. The adapt() method is called before writing the request headers to allow the adapter to manipulate the request.\n\n**EntityType Class**\n\nThe EntityType is used to specify the class type and the generic type of responses. Typically, an anonymous \"EntityType\" instance is created in order to specify the response type, as is shown in the following code example:\n\n```java\nResource resource = client.resource(uri);\nList<String> list = resource.get(new EntityType<List<String>>() {});\n```\n\n**ApacheHttpClientConfig Class**\n\nThe \"ApacheHttpClientConfig\" Configuration object configures the Apache Wink Client to use the Apache HttpClient as the underlying HTTP client. The following code snippet, demonstrates the typical usage:\n\n```java\n// creates the client that uses Apache DefaultHttpClient as the underlying Http client.\nRestClient client = new RestClient(new ApacheHttpClientConfig(new DefaultHttpClient()));\n\n// creates the resource\nResource resource = client.resource(\"http://myhost:80/my/service\");\n\n// invokes a GET method on the resource and receives the response entity as a string\nString entity = resource.get(String.class);\n```\nThe Apache Wink Runtime\n\nThe Apache Wink runtime is deployed on a JEE environment and is configured by defining the RestServlet in the web.xml file of the application. This servlet is the entry point of all the HTTP requests targeted for web services, and passes the request and response instances to the Wink engine for processing.\n\n**Figure 9: Apache Wink Request Processor Architecture**\n\nThe diagram illustrates the core components of the Apache Wink runtime. The Wink engine is the RequestProcessor. It builds an instance of a MessageContext with all of the required information for the request and passes it through the engine handler chains. The handler chains are responsible for serving the request, invoking the required resource method and finally generating a response.\n\nIn case of an error, the RequestProcessor invokes the Error chain with the generated exception for producing the appropriate response.\n\nThe Apache Wink runtime maintains providers and resources in two registries, the \"providers registry\" and the \"resource registry\" utilizing them during request processing.\n\n**Request Processor**\n\nThe RequestProcessor is the Apache Wink engine, that is initialized by the RestServlet and is populated with an instance of a DeploymentConfiguration.\n\nWhen a request is passed to the handleRequest() method of the RequestProcessor, a new instance of a MessageContext is created.\n\nThe MessageContext contains all of the information that is required for the Wink runtime to handle the request. The RequestProcessor first invokes the Request Handler Chain and then the Response Handler Chain.\n\nIf an exception occurs during any stage of the request processing, the RequestProcessor invokes the Error Handler Chain for processing the exception.\nDeployment Configuration\n\nThe Apache Wink runtime is initialized with an instance of a Deployment Configuration. The Deployment Configuration holds the runtime configuration, including the handler chains, registries, configuration properties.\n\nThe Deployment Configuration is initialized with an instance of a JAX-RS Application used for obtaining user resources and providers.\n\nCustomization of the Handlers Chain\n\nThe handler chain is customized by extending the org.apache.wink.server.handlers.HandlersFactory class, overriding specific methods and specifying the new class in the web.xml file of the application.\n\nIn order to specify a different HandlersFactory class instead of the default handlers, specify an init parameter for a custom properties file to be loaded by the RestServlet. Then, the value of the \\texttt{wink.handlersFactoryClass} property must be set as the fully qualified name of the customized handlers class in the properties file.\n\n```\n<servlet>\n <servlet-name>restSdkService</servlet-name>\n <servlet-class>\n org.apache.wink.server.internal.servlet.RestServlet\n </servlet-class>\n <init-param>\n <param-name>propertiesLocation</param-name>\n <param-value>path/to/my-wink-properties.properties</param-value>\n </init-param>\n</servlet>\n```\n\nIn the my-wink-properties properties file:\n\n```\nwink.handlersFactoryClass=org.apache.wink.MyCustomHandlersFactory\n```\n\nSee the JavaDoc for the HandlersFactory API.\n\nHandler Chains\n\nThe handler chain pattern is used by the Wink runtime for implementing the core functionalities. There are three handler chains utilized by the Wink runtime:\n\n- RequestHandlersChain\n- ResponseHandlersChain\n- ErrorHandlersChain\n\nFor further information regarding the \"Handler Chains\", refer to section 5 Apache Wink Server, 5.7 Handler Chain - Runtime Extension\nRegistries\n\nThe Apache Wink runtime utilizes two registries for maintaining the JAX-RS resources and providers. Both registries maintain their elements in a sorted state according to the JAX-RS specification for increasing performance during request processing. In addition to the JAX-RS specification sorting, Wink supports the prioritization of resources and providers.\n\nResources and Providers Prioritization\nFor further information regarding \"Resources and Providers Prioritization\", refer to the section 5.1 Registration and Configuration.\n\nResource Registry\n\nFigure 10: Resource Registry Architecture\n\n- **URI Template Processor** - represents a URI template associated with a resource. Used during the resource matching process.\n- **Resource Metadata** - holds the resource metadata collected from the resource annotations.\n- **Sub-Resource Records** - records of all the sub-resources (methods and locators) collected from the sub-resource annotations.\n- **Resource Factory** - a factory that retrieves an instance of the resource in accordance to the creation method defined for the resource.\n\nPossible creation methods include:\n- singleton\n- prototype\n- spring configuration\n- user customizable\nGetting Started with Apache Wink\n\nApache Wink consists of a main library and an additional set of dependant libraries. The Apache Wink distribution also includes an *examples* folder that contains all of the *example projects* referred to in this developer guide.\n\nThis section contains the following:\n\n- Apache Wink Distribution Files\n- Creating a Project using the Apache Wink\n- Testing the Project Deployment\n- HelloWorld Detailed Description\n- HelloWorld J2EE Deployment Descriptor - web.xml\n- HelloWorld Spring Deployment Descriptor HelloWorldContext-server.xml\n- Bookmark Example Application\n- Apache Wink Getting Started Summary\n\nGetting Started with Apache Wink Overview\n\nIn order to gain an in-depth understanding of the Apache Wink SDK a series of example projects have been designed to help the developer clarify the underlying principles and usage of the Apache Wink. The following sections provide a detailed step-by-step implementation and deployment of the HelloWorld example application using the Eclipse IDE as the default development environment.\n\nApache Wink Distribution Files\n\nTBD\n\nCreating a Project using the Apache Wink\n\nTBD\n\nTesting the Project Deployment\n\nTBD\n\nHelloWorld Detailed Description\n\nTBD\n\nHelloWorld J2EE Deployment Descriptor - web.xml\n\nTBD\n\nHelloWorld Spring Deployment Descriptor HelloWorldContext-server.xml\n\nTBD\nBookmark Example Application\n\nTBD\n\nApache Wink Getting Started Summary\n\nTBD\n4 JAX-RS Concepts\n\nThis page last changed on Sep 16, 2009 by michael.\n\nJAX-RS Concepts\n\nJAX-RS (JSR 311) is the latest JCP specification that provides a Java based API for REST Web services over the HTTP protocol. The JAX-RS specification is an annotation based server side API.\n\nApplying JAX-RS to Apache Wink\n\nApache Wink is a full implementation of the JAX-RS 1.0 specification, providing a rich set of features and expansions that extend and supplement the JAX-RS specification. Apache Wink is designed to be an easy to use, production quality and efficient implementation.\n\nThe Apache Wink architecture enables the incorporation of custom functionality via the use of handlers that provide for the manipulation of requests, Apache Wink also provides a powerful client module for the consumption of REST web services and is bundled with a range of built-in Providers that enable the developer to quickly implement applications that make use of industry standard formats such as XML, ATOM, APP, RSS, JSON, CSV, HTML.\n\nDeveloping REST Applications\n\nFor those new to JAX-RS or developing REST applications, follow this in-progress developer guide. If you have comments or questions, send an e-mail to the appropriate Apache Wink mailing lists.\n\nWhile this developer guide covers common scenarios, it is not intended to detail the JAX-RS specification itself. Please read the (brief yet understandable) specification if it is available to you.\n\nGetting Started - A Simple JAX-RS Application\n\n• Creating a Resource\n• Creating a javax.ws.rs.core.Application sub-class\n• Packaging Apache Wink with a Web Application\n• Installation and Running the Application\n\nApplication Configuration\n\n• javax.ws.rs.core.Application subclass\n• Container environment information\n\nResources, HTTP Methods, and Paths\n\n• Root Resource Methods\n• javax.ws.rs.core.Response\n• HTTP Methods\n• Subresource Methods\n• Subresource Locators\n• Regular Expressions\n\nRequest and Response Entities (Message Bodies) and Media Types\n\n• Produces/Consumes annotations\n• ATOM\n• XML\n• JSON\n• Standard Entity Parameter Types\n• Custom application provided Message Body Readers/ Writers\n• Transfer Encoding\n• Content Encoding\n\nParameters\n\n• Query Parameters\n• Path Parameters\n• Matrix Parameters\n• Header Parameters\n• Cookie Parameters\n\nHTTP Headers\n\n• Common HTTP Request Headers\n• Common HTTP Response Headers\n\nContent Negotiation\n\n• Using URIs to identify content type\n• Using parameters to identify content type\n• Using Accept headers\n\nUsing Request Context Information\n\n• HTTP Headers\n• URI Information\n• Security Information\n• Request\n• Providers\n\nCaching\n\n• Expires\n• Cache-Control\n**Applications**\n\nA JAX-RS application consists of one or more resources and zero or more providers. A JAX-RS application is packaged as a Web application in a .war file. The Application subclass, resource classes, and providers are packaged in WEB-INF/classes file and the required libraries are packaged in WEB-INF/lib. Included libraries can also contain resource classes and providers as desired.\n\nWhen using a Servlet 3 container, the Application subclass is optional. By default, all root resource classes and providers packaged in the web application must be included in the published JAX-RS application.\n\n**Including Subclasses**\n\nAn Application subclass can be included in a .war file to override the default behavior. If both getClasses and getSingletons return an empty list then the default \"willset\" of classes must be used. The implementations should support the Servlet 3 framework pluggability mechanism to enable portability between containers and to avail themselves of container-supplied class scanning facilities.\n\n**Servlet Containers**\n\nWhen using a non-JAX-RS aware servlet container, the servlet-class or filter-class element of the web.xml descriptor should name the JAX-RS implementation-supplied Servlet or Filter class respectively. The application-supplied subclass of the application is identified, using an init-param with a param-name of the \"javax.ws.rs.application\".\nJAX-RS Caching\n\nExpires\n\nCache Control\nCreating a Simple \"Hello World\" Application\n\nThe following example project will produce a simple JAX-RS application that can respond to requests at \"/helloworld\" with a \"Hello world!\" plain text resource. While not entirely RESTful, this example project is to show how to create a simple application and how to package it for consumption in a web container.\n\nThe application is packaged in a WAR file (which is similar to a JAR/ZIP file, except with special files in certain locations and a defined layout). It can be deployed in any web container, for example: Jetty, Tomcat and Geronimo. Perform the following steps in order to create the \"helloworld\" example application.\n\nStep 1 - Creating the Root Resource\n\nFirst, create a resource that will be used for HTTP GET requests to \"/helloworld\".\n\n```java\npackage org.apache.wink.example.helloworld;\n\nimport javax.ws.rs.GET;\nimport javax.ws.rs.Path;\n\n@Path(\"/helloworld\")\npublic class HelloWorldResource {\n @GET\n public String getMessage() {\n return \"Hello World!\";\n }\n}\n```\n\nAs shown above, the Java class is just a plain old Java object that has JAX-RS annotations.\n\nStep 2 - Creating a javax.ws.rs.core.Application sub-class\n\nFor non-JAX-RS aware web container environments (most environments are currently non JAX-RS aware), a javax.ws.rs.core.Application sub-class needs to be created which returns sets of JAX-RS root resources and providers. In the following example, there is only one root resource that will need to be returned.\n\n```java\npackage org.apache.wink.example.helloworld;\n\nimport java.util.HashSet;\nimport java.util.Set;\nimport javax.ws.rs.core.Application;\n\npublic class HelloWorldApplication extends Application {\n @Override\n public Set<Class<?>> getClasses() {\n Set<Class<?>> classes = new HashSet<Class<?>>();\n classes.add(HelloWorldResource.class);\n return classes;\n }\n}\n```\nCompiling the classes\n\nUsing the Apache Wink distribution's JARs in the classpath, compile the two classes from the previous example.\n\nStep 3 - Creating a web.xml file\n\nNow create a web.xml deployment descriptor. The deployment descriptor details information about the web application in the WAR. In this case, it says that the Apache Wink JAX-RS servlet should be initialized with a HelloWorldApplication instance.\n\nIn addition, any requests that begin with /rest/ will be handled by the Apache Wink JAX-RS servlet. So, the request URL would be \"/rest/helloworld\" to reach the HelloWorld resource.\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE web-app PUBLIC\n\"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN\"\n\"http://java.sun.com/dtd/web-app_2_3.dtd\" >\n\n<web-app>\n <display-name>Hello world Web Application</display-name>\n <servlet>\n <servlet-name>HelloWorldApp</servlet-name>\n <servlet-class>org.apache.wink.server.internal.servlet.RestServlet</servlet-class>\n <init-param>\n <param-name>javax.ws.rs.Application</param-name>\n <param-value>org.apache.wink.example.helloworld.HelloWorldApplication</param-value>\n </init-param>\n <load-on-startup>1</load-on-startup>\n </servlet>\n <servlet-mapping>\n <servlet-name>HelloWorldApp</servlet-name>\n <url-pattern>/rest/*</url-pattern>\n </servlet-mapping>\n</web-app>\n```\n\nStep 4 - Packaging the web application into a WAR file\n\nLayout the application as follows and create a WAR file from the base directory (the one before WEB-INF). Create a WAR by running \"jar cvf helloworld-jaxrs.war *\" from the base directory.\n\nNot every JAR in the lib directory is necessary for all environments. Read the documentation for more information about the requirements.\n\n```text\nWEB-INF/classes/org/apache/wink/example/helloworld/HelloWorldApplication.class\nWEB-INF/classes/org/apache/wink/example/helloworld/HelloWorldResource.class\nWEB-INF/lib/activation-1.1.jar\nWEB-INF/lib/commons-lang-2.3.jar\nWEB-INF/lib/jaxb-api-2.1.jar\nWEB-INF/lib/jaxb-impl-2.1.4.jar\nWEB-INF/lib/json-20080701.jar\nWEB-INF/lib/jsr311-api-1.0.jar\n```\n**Step 5 - Installing the WAR file into your environment**\n\nMost web container environments will take a WAR file and deploy it without any further configuration required. However, note the \"Context Root\" of the web application, or change it as required.\n\nThe context paths combine as follows:\nhttp://<hostname>/<web application context root>/<servlet url mapping path>/helloworld\n\nIf the environment deployed the WAR file to a context root of \"/helloworldapp\", then the following URL would be required to reach the HelloWorldResource.\n\nhttp://<hostname>/helloworldapp/rest/helloworld\nResources\n\nResources are one of the fundamental concepts in REST. REST emphasizes the manipulation of resources rather than issuing function calls. Resources have unique identifiers. In HTTP terms, this means associating every resource with at least one URL.\n\nIn order to manipulate a resource, requests are made with a specific HTTP method. For instance, in order to retrieve a representation of a resource, an HTTP GET request to the resource's URL is issued. In order to create a new item in a collection, an HTTP POST can be used with the collection URL.\n\nApplication developers define resources and the HTTP methods in order to quickly manipulate them by using regular plain old Java objects and JAX-RS annotations.\n\nDefining a Root Resource (@Path on Java class)\n\nDevelopers can use POJOs to define a resource. Root resources have a @Path annotation at the class declaration level. JAX-RS matches an incoming request's URL with the @Path annotation on all of an application's root resources in order to determine which initial Java class will handle the request.\n\nRoot resources Java class instances are created per request by default.\n\nReference\nRefer to the JAX-RS Application configuration topic for more information.\n\nResource classes have methods that are invoked when specific HTTP method requests are made, referred to as resource methods. In order to create Java methods that will be invoked with specific HTTP methods, a regular Java method must be implemented and annotated with one of the JAX-RS @HttpMethod annotated annotations (namely, @GET, @POST, @PUT, and @DELETE).\n\nFor example, if a resource is located at a \"/welcome\" URL, the following root resource is defined.\n\n```java\n@Path(\"/welcome\")\npublic class WelcomeMessage {\n private String welcomeMessage = \"Hello world!\";\n\n @GET\n public String returnWelcomeMessage() {\n return welcomeMessage;\n }\n}\n```\n\nAny incoming GET request that has the URL of \"/welcome\" is handled by WelcomeMessage class's returnWelcomeMessage() method. A string is returned that represents the response body and is sent as the response payload in a HTTP 200 status response.\n\nUsing a javax.ws.rs.core.Response\n\nIn the previous GET resource method example, the response body is returned as a String. If a more complex response is required for example, additional HTTP response headers or a different status code, a javax.ws.rs.core.Response should be used as the Java method's return type. By building a Response object, additional information can be returned to the client.\n\n```java\n@Path(\"/welcome\")\n```\nThe previous example uses 299 as the status code, standard HTTP status codes should be used in order to help clients understand responses. When using Strings as the response entity, different Java types may be used for complex responses.\n\nReference\nRefer to the Request/Response entities page for more details on how request/response entities are handled.\n\nUsing Common HTTP Methods (@GET, @POST, @PUT, @DELETE)\n\nThe four most common HTTP methods are GET, POST, PUT, and DELETE.\n\nAs shown in the previous example, an HTTP GET response to \"/welcome\" invokes the returnWelcomeMessage() Java method. In order to add a Java method that would be invoked when a HTTP PUT request is made to \"/welcome\", the following code should be added:\n\n```java\n@Path(\"/welcome\")\npublic class WelcomeMessage {\n private String welcomeMessage = \"Hello world!\";\n\n @GET\n public String returnWelcomeMessage() {\n return welcomeMessage;\n }\n\n @PUT\n public String updateWelcomeMessage(String aNewMessage) {\n welcomeMessage = aNewMessage;\n }\n}\n```\n\nNotice that the updateWelcomeMessage has an unannotated parameter which represents an incoming request's body.\n\nReference\nRefer to the Request/Response entities page for more details on how request/response entities are handled.\n\nSubresource Methods (@Path and @GET, @POST, @PUT, @DELETE on a Java method)\n\nSometimes it is easier having a root resource resolve a generic URL path and to have @Path annotated methods further resolve the request. For instance, suppose that a HTTP GET to \"/administrator\" returned generic information about an administrator. However, sometimes it is better to return smaller bits or more detailed information about the resource using a slightly different URL identifier. Suppose that a HTTP GET to \"/administrator/name\" should return the name. Instead of creating many root resource classes...\nfor each URL, you can have the root resource initially resolve the beginning of the URL request and then further resolve the request against subresource methods.\n\nSubresource methods are Java methods with a `@Path` annotation and a `@HttpMethod` annotated annotation (`@GET`, `@POST`, `@PUT`, `@DELETE`).\n\n```java\n@Path(\"/administrator\")\npublic class Administrator{\n\n @GET\n public String findUserInfo() {\n String userInfo = null;\n /* build user info */\n return userInfo;\n }\n\n @GET\n @Path(\"/name\")\n public String getJustUserName() {\n String userName = \"\";\n /* get the user name */\n return userName;\n }\n\n @GET\n @Path(\"/id\")\n public String getUserId() {\n String userId = \"\";\n /* get the user id */\n return userId;\n }\n}\n```\n\nAn HTTP URL request to the \"/administrator\" would resolve to `Administrator#findUserInfo()`. A HTTP URL request to \"/administrator/name\" would invoke the `Administrator#getJustUserName()` method. Finally a HTTP URL request to \"/administrator/id\" would resolve to `Administrator#getUserId()`.\n\n### Using Subresource Locators (`@Path` on Java method)\n\nIn more complicated scenarios, subresource locators are needed. Subresource locators are particularly useful when requests must be further resolved by other objects. Subresource locators are Java methods which have only an `@Path` annotation. They are different than subresource methods because they do not have any HTTP method annotation on them.\n\nA subresource locator returns an object that has JAX-RS annotations on its methods (or inherits them). The object is used to further resolve the incoming requests by dynamically inspecting the object for JAX-RS annotations.\n\nThis scenario uses `@PathParam` which are discussed on the parameters page.\n\n```java\n@Path(\"/users\")\npublic class UsersCollection {\n\n @Path(\"/{userid}\")\n public Object findUserInfo(@PathParam(\"userid\") String userId) {\n if(userId.equals(\"superuser\")) {\n return new SuperUser();\n }\n return User.findUserInDatabase(userId);\n }\n}\n```\npublic class Superuser {\n @GET\n public String getUserInfo() {\n String userInfo = /* get the user info */;\n return userInfo;\n }\n\n @GET\n @Path(\"/contactinfo\")\n public String getContactInfo() {\n String contactInfo = /* get the user contact info */;\n return contactInfo;\n }\n}\n\npublic class User {\n protected String name;\n\n protected User() {\n /* subresource locator object lifecycles are controlled by the developer */\n }\n\n public static User findUserInDatabase(String userName) {\n User u = /* get user from database with assigned field values */\n return u;\n }\n\n @GET\n public String getInfo() {\n String info = /* get the user info */;\n return info;\n }\n\n @GET\n @Path(\"/name\")\n public String getMyUserName() {\n return name;\n }\n}\n\nA HTTP GET to \"/users/superuser\" would result in User#findUserInfo() being invoked first. The method inspects the \"userId\" path parameter (which resolves to \"superuser\" for this request) so a Superuser object is returned. The request is then further resolved against the Superuser object. In the simple \"/users/superuser\" case, the request invokes Superuser#getUserInfo();\n\nIf a HTTP GET to \"/users/superuser/contactinfo\" was made, then User#findUserInfo() is invoked and again returns a Superuser object. The Superuser object is then used to resolve the \"/contactinfo\" portion of the request which invokes Superuser#getContactInfo.\n\nIf a HTTP GET to \"/users/user1/name\" was made, then User#findUserInfo() is again invoked but it would go and look up the user from the database and return a User object. The User object is then used to resolve the \"/name\" portion and results in the User#getMyUserName() method being invoked on the User object returned.\n**JAX-RS Request and Response Entities**\n\nRequest and response entities represent the main part of an HTTP request. Entities are also referred to as the \"message body\" or \"payload\". Entities are sent via a request, usually an HTTP POST and PUT method are used or they are returned in a response, this is relevant for all HTTP methods.\n\nUnlike other distributed systems technologies, there is generally no wrapper around an entity. For example, if a request is made for a binary PNG image represented here, http://example.com/user/abcd/portrait.png, the response entity is only the PNG image binary data.\n\nResource methods have a single entity parameter that represents the main entity body. It is the only unannotated parameter allowed in a resource method.\n\nWhen using JAX-RS, request and response entities are mapped to and from Java types by Entity Providers that implement the JAX-RS interfaces, MessageBodyReader and MessageBodyWriter. Applications may provide their own MessageBodyReaders and MessageBodyWriters that take precedence over the runtime provided ones.\n\n**Media Types (MIME) and javax.ws.rs.core.MediaType**\n\nThe request and response entity can be any form of data, a way of identifying what the entities bits and bytes represent is needed. In requests and responses, the **Content-Type** HTTP header is used to indicate the type of entity currently being sent. The Content-Type value comes from a well known media type as registered in IANA.\n\nCommon content types include \"text/plain\", \"text/xml\", \"text/html\", and \"application/json\".\n\nCorrect Content-Type values are essential for clients and servers. \"Unusual\" behavior by clients such as browsers can be attributed to wrong content types.\n\nMedia Types are also used in a request **Accept** header to indicate what type of resource representation the client wants to receive. Clients could indicate a preference as well, such as JSON before XML.\n\nReference\nRefer to the HTTP spec regarding the Accept header and the Content Negotiation topic.\n\njavax.ws.rs.core.MediaType has functionality and representations related to Media Types.\n\n**@Consumes and @Produces Annotations**\n\nAnnotating a class or a resource method with @Consumes and @Produces will help the JAX-RS runtime identify the appropriate methods to invoke for requests. For example:\n\n```java\n@Path(\"/example\")\npublic RootResource {\n @POST\n @Consumes(\"text/xml\")\n @Produces(\"text/xml\")\n public Response getOnlyXML(String incomingXML) {\n return Response.ok(\"only xml\").type(\"text/xml\").build();\n }\n\n @GET\n @Produces(\"text/html\", \"text/plain\")\n public String getText() {\n```\nIn the previous code example, if a HTTP POST to \"/example\" was issued with a Content-Type header of \"text/xml\" and an Accept header of \"text/xml\", then the RootResource#getOnlyXML method would be invoked. If the same POST request was issued with an Accept header of \"text/plain\", then a 406 Not Acceptable response would be generated by the JAX-RS runtime and the method would not be invoked.\n\nIt is a good practice to return a javax.ws.rs.core.Response with a .type() or .variant() call since it would guarantee a return content type. Notice that the above getText() code supports multiple data types. A javax.ws.rs.core.Response object returned must have a single concrete Content-Type value. In order to select the best acceptable representation in the resource method, use either the @Context HttpHeaders#getAcceptableMediaTypes() or a @Context Request#selectVariant() method.\n\nReference\nRefer to the Context topic page for more information.\n\nWhile resource methods may consume one media type for example XML and produce another such as JSON, most user requests expect the same media type that was sent in the request to be returned in the response.\n\nIf the Content-Type header is empty and there is an entity, then the JAX-RS runtime will make the Content-Type be \"application/octet-stream\". If an Accept header is empty, then according to the HTTP specification, the Accept header is equivalent to */* which is a wildcard that matches anything.\n\nImportant Note\nNote that the resource method ultimately has control over the response content. If a javax.ws.rs.core.Response is returned, then the developer can return whatever Content-Type is desired. The @Consumes and @Produces is primarily useful only when processing request information and determining which resource method is possible to invoke. If a specific Response content type is not specified via a returned javax.ws.rs.core.Response object, the response media type is determined by a combination of the @Produces annotation values and the available MessageBodyWriters for the response entity's Java type. This can lead to undesired results if there is no @Produces annotation or if the @Produces annotation has multiple media types listed.\n\nReference\nRefer to the JAX-RS specification for the effective algorithm used.\n\nJAX-RS Standard Entity Parameter Types\n\nJAX-RS requires certain parameters to be supported for virtually any content type. The following table lists the supported content types:\n\n<table>\n<thead>\n<tr>\n<th>Java Type</th>\n<th>Content Type Supported</th>\n<th>Special Notes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>java.lang.String</td>\n<td><em>/</em></td>\n<td></td>\n</tr>\n<tr>\n<td>byte[]</td>\n<td><em>/</em></td>\n<td></td>\n</tr>\n<tr>\n<td>java.io.InputStream</td>\n<td><em>/</em></td>\n<td></td>\n</tr>\n<tr>\n<td>java.io.Reader</td>\n<td><em>/</em></td>\n<td></td>\n</tr>\n<tr>\n<td>java.io.File</td>\n<td><em>/</em></td>\n<td></td>\n</tr>\n<tr>\n<td>javax.activation.DataSource</td>\n<td><em>/</em></td>\n<td></td>\n</tr>\n</tbody>\n</table>\nDevelopers can use the previous Java types as entity parameters for requests and responses.\n\n```java\n@Path(\"/example\")\npublic class RootResource {\n\n // GET\n @GET\n @Produces(\"text/xml\")\n public Response getInfo() {\n byte[] entity = /* get the entity into a byte array */\n return Response.ok(entity).type(\"text/xml\").build();\n }\n\n // POST\n @POST\n @Consumes(\"application/json\")\n @Produces(\"application/json\")\n public StreamingOutput createItem(InputStream requestBodyStream) {\n /* read the requestBodyStream like a normal input stream */\n return new StreamingOutput() {\n public void write(OutputStream output) throws IOException, WebApplicationException {\n byte[] out = /* get some bytes to write */\n output.write(out);\n }\n };\n }\n}\n```\n\n### Transfer Encoding\n\nTransfer or \"chunked\" encoding is handled by the container for incoming requests. The container or the application must do any transfer encoding for outgoing responses.\n\n### Content Encoding\n\nContent for example \"gzip\" and or \"deflate\" encoding is handled by the application. However, some containers handle content encoding for developers and will uncompress content automatically or will with various configuration set. Check the container documentation.\nJAX-RS Parameters\n\nParameters\n\nParameters are used to pass and add additional information to a request. Search queries, offsets/pages in a collection, and other information can be used. While parameters are sometimes used to add more verbs to HTTP, it is advised not to use parameters as a way to create new HTTP methods or to make existing HTTP methods break the generally understood attributes (i.e. idempotent).\n\nParameters can be any basic Java primitive type including java.lang.String as well as types with a constructor that takes in a single String or a valueOf(String) static method. In addition, List, SortedSet, and Set can be used where the generic type is one of the previously mentioned types such as a Set<String> when a parameter can have multiple values.\n\nWhen full control is needed for parsing requests, it is generally recommend that developers use a String as the parameter type so that some basic inspection can be performed and developers can customize error path responses.\n\nQuery Parameters (@QueryParam)\n\nQuery parameters are one of the better known parameters. A query string is appended to the request URL with a leading \"?\" and then name/value pairs.\n\nQuery Parameter Examples\n\nRefer to the following links:\nhttp://www.google.com/search?q=apache+wink\nhttp://www.example.com/users?offset=100&numPerPage=20\n\nIn order to enable JAX-RS to read a query parameters, add a parameter to the resource method and annotate with @QueryParam:\n\n```java\n@Path(\"/example\")\npublic class RootResource {\n @GET\n public Response invokeWithParameters(@QueryParam(\"q\") String searchTerm) {\n if (q == null) {\n return Response.status(Status.BAD_REQUEST).build();\n } /* do a search */\n return Response.ok(/* some entity here */).build();\n }\n}\n```\n\nIf a HTTP GET request to \"/example?q=abcd\" is made, searchTerm will have \"abcd\" as the value when invoked.\n\nPath Parameters (@PathParam)\n\nPath parameters take the incoming URL and match parts of the path as a parameter. By including <name> in a @Path annotation, the resource can later access the matching part of the URI to a path parameter with the corresponding \"name\". Path parameters make parts of the request URL as parameters which can be useful in embedding request parameter information to a simple URL.\n\n```java\n@Path(\"/books/{bookid}\")\n```\npublic class BookResource {\n @GET\n public Response invokeWithBookId(@PathParam(\"bookid\") String bookId) {\n /* get the info for bookId */\n return Response.ok(/* some entity here */).build();\n }\n\n @GET\n @Path(\"/{language}\")\n public Response invokeWithBookIdAndLanguage(@PathParam(\"bookid\") String bookId,\n @PathParam(\"language\") String language) {\n /* get the info for bookId */\n return Response.ok(/* some entity here */).build();\n }\n}\n\nIn the previous example, HTTP GET to /books/1 or to /books/abcd would result in invokeWithBookId being called. If a HTTP GET request is issued to /books/1/en or /books/1/fr or /books/abcd/jp, then invokeWithBookIdAndLanguage would be invoked with the appropriate parameters.\n\nMatrix Parameters (@MatrixParam)\n\nMatrix parameters are not as widely used on the Internet today. However, you can read a MatrixParam just as easily as any other parameter.\n\n@Path(\"/\")\npublic class RootResource {\n @GET\n public Response invokeWithParameters(@MatrixParam(\"name\") String name) {\n if(name == null) {\n return Response.status(Status.BAD_REQUEST).build();\n }\n return Response.ok(/* some entity here */).build();\n }\n}\n\nHeader Parameters (@HeaderParam)\n\nHeader parameters are useful especially when there are additional metadata control parameters that need to be passed in for example, security information, cache information, and so forth.\n\n@Path(\"/\")\npublic class RootResource {\n @GET\n public Response invokeWithParameters(@HeaderParam(\"controlInfo\") String controlInfo) {\n if(controlInfo == null) {\n return Response.status(Status.BAD_REQUEST).build();\n }\n return Response.ok(/* some entity here */).build();\n }\n}\n**CookieParameters (@CookieParam)**\n\nIn a REST application, requests are stateless although applications sometimes use Cookies for various reasons, such as adding some stateless resource viewing information without embedding it into the URL such as the maximum number of items to retrieve. The CookieParam annotation is used to easily retrieve the information.\n\n```java\n@Path(\"/\")\npublic class RootResource {\n \n @GET\n public Response invokeWithParameters(@CookieParam(\"max\") String maximumItems) {\n if(userId == null) {\n return Response.status(Status.BAD_REQUEST).build();\n }\n return Response.ok(/* some entity here */).build();\n }\n}\n```\nHTTP Headers\n\nHTTP headers generally store metadata and control information. There are some common headers shared in requests and responses but there are a few specific headers to either a request or a response. Developers should read the HTTP specification for a complete understanding of HTTP headers. Some of the more common HTTP headers are mentioned below in cases where JAX-RS provides convenient methods for the header.\n\nGenerally, in order to get the request header name and values, developers can use either an injected @HeaderParam annotated with a parameter/field/property or an injected @Context HttpHeaders parameter/field/property.\n\n```java\n@Path(\"/example\")\npublic ExampleResource {\n @Context HttpHeaders requestHeaders;\n\n @GET\n public void getSomething(@HeaderParam(\"User-Agent\") String theUserAgent) {\n /* use theUserAgent variable or requestHeader's methods to get more info */\n }\n}\n```\n\nIn order to set response headers, developers can set them on a javax.ws.rs.core.Response return object.\n\n```java\n@Path(\"/example\")\npublic ExampleResource {\n @GET\n public Response getSomething() {\n return Response.ok(/* some entity */).header(\"CustomHeader\", \"CustomValue\").build();\n }\n}\n```\n\nA response headers can be set when a MessageBodyWriter#writeTo() method is called.\n\nCommon Headers\n\nThe common header specifies the size and type of a header. Every header must begin with the common header. The common header must not appear by itself.\n\nContent-Type\n\nThe Content-Type signals the media type of the request/response entity. The Content-Type header on requests is read via HttpHeaders#getMediaType() method. The Content-Type is set for responses when doing a javax.ws.rs.core.Response.ResponseBuilder#type() method or a javax.ws.rs.core.Response.ResponseBuilder#variant() method.\n\nContent-Language\n\nThe Content-Language denotes what language the entity is in. In order to receive the request entity language, use the HttpHeaders#getLanguage() method. In order to set the response entity language, use the javax.ws.rs.core.Response.ResponseBuilder#language() method.\nContent-Length\n\nThe Content-Length is useful for determining the entity's length. If possible, the MessageBodyWriter entity providers will automatically set the Content-Length if possible, and some containers will set the response Content-Length if the entity is small.\n\nReference\nRefer to the HTTP spec for more details on when this header is set and valid.\n\nCommon Request HTTP Headers\n\nAn HTTP Request Header is a line of text that a client software (i.e. Web Browser) sends to a server together with other request data.\n\nAccept\n\nThe Accept header is used to determine the possible response representations that the client prefers such as XML over JSON but not plain text. When a resource method is effectively annotated with a @Produces, any incoming request must have a compatible Accept header value for the resource method to be selected. Clients can set quality parameters (priority ordering) for the best possible response and services generally try to honor the request. To get the best representation of a response, use either the HttpHeaders#getAcceptableMediaTypes() or Request#selectVariant() methods.\n\nAccept-Language\n\nLike the Accept header, Accept-Language lists the preferred languages. A HttpHeaders#getAcceptableLanguages() method will list the acceptable languages in a preferred order.\n\nIf-Match and If-None-Match\n\nIf a previous response had an ETag header, the client can re-use the ETag value with the If-Match or If-None-Match request header to do conditional requests (if the server application supported the If-Match/If-None-Match headers). For example, a POST with an If-Match header and an old ETag value should only execute the POST request if the old ETag value is still valid. javax.ws.rs.core.Request#evaluatePreconditions() may help evaluate the If-Match and If-None-Match headers.\n\nIf-Modified-Since and If-Unmodified-Since\n\nLike ETags, If-Modified-Since and If-Unmodified-Since are based on the Last-Modified date. Using either request header with a date, will set up a conditional request (if the server application supports the headers). For instance, a GET with an If-Modified-Since header of an old known date would allow the server to send back a response with just a HTTP status code of 304 (Not Modified). By sending back a HTTP status code of 304, the server is telling the client that the resource has not changed so there is no need to re-download the resource representation. This could save precious bandwidth for the client. javax.ws.rs.core.Request#evaluatePreconditions() may help evaluate the If-Modified-Since and If-Unmodified-Since headers.\n\nImportant Note\n\nNote that date formats are specified in the HTTP specification.\n\nCommon Response HTTP Headers\n\nHTTP Headers form the core of an HTTP request, and are very important in an HTTP response. They define various characteristics of the data that is requested or the data that has been provided. The headers are separated from the request or response body by a blank line\nETag\n\nETags or entity tags can be set. Like a hashcode, it is given to the client so a client can use various control request headers such as If-Match and If-None-Match for conditional requests. javax.ws.rs.core.Response.ResponseBuilder#tag() and javax.ws.rs.core.EntityTag are useful for ETags.\n\nExpires\n\nThe Expires response header indicates the amount of time that the response entity should be cached. It is useful to set the expiration for data that is not going to change for a known time length. Browsers use this response header to manage their caches among other user agents. The javax.ws.rs.core.Response.ResponseBuilder#expires() method can be used to set the Expires header.\n\nLast-Modified\n\nLast-Modified specifies the date when the resource was changed. A client can use the response value in combination with If-Modified-Since and If-Unmodified-Since request headers to perform conditional requests. The javax.ws.rs.core.Response.ResponseBuilder#lastModified() method can be used to set the Last-Modified header.\n\nImportant Note\nNote that date formats are specified in the HTTP specification.\n\nLocation\n\nThe Location response header usually indicates where the resource is located (in a redirect) or the URI of the new resource (when resources are created and usually in a HTTP 201 response). The javax.ws.rs.core.Response.ResponseBuilder#location() method can be used to set the Location header.\nWhat is Content Negotiation?\n\nOne of the more popular features of REST applications is the ability to return different representations of resources. For instance, data can be in JSON format or in XML. Or it can even be available in either format depending on the request. Content negotiation is the way for clients and servers to agree on what content format is sent.\n\nData is returned in multiple formats because the needs of each client's request can be different. A browser might prefer JSON format. Another command line based client might prefer XML format. A third client might request the same resource as a PNG image.\n\nIt is up to the service to determine which formats are supported.\n\nThere are many practical ways of performing content negotiation.\n\nContent Negotiation Based on URL\n\nMany popular public REST APIs perform content negotiation based on the URL. For instance, a resource in XML format might be at http://example.com/resource.xml. The same resource could be offered in JSON format but located at http://example.com/resource.json.\n\n```java\n@Path(\"/resources\")\npublic class Resource {\n @Path(\"{resourceID}.xml\")\n @GET\n public Response getResourceInXML(@PathParam(\"resourceID\") String resourceID) {\n return Response.ok(\"/* entity in XML format */\").type(MediaType.APPLICATION_XML).build();\n }\n\n @Path(\"{resourceID}.json\")\n @GET\n public Response getResourceInJSON(@PathParam(\"resourceID\") String resourceID) {\n return Response.ok(\"/* entity in JSON format */\").type(MediaType.APPLICATION_JSON).build();\n }\n}\n```\n\nIn the above code, a request to \"/resources/resourceID.myformat\" would result in a 404 status code.\n\nAnother way of implementing the above is to use a single resource method like below:\n\n```java\n@Path(\"/resources\")\npublic class Resource {\n @Path(\"{resourceID}.{type}\")\n @GET\n public Response getResource(@PathParam(\"resourceID\") String resourceID, @PathParam(\"type\") String type) {\n if (\"xml\".equals(type)) {\n return Response.ok(\"/* entity in XML format */\").type(MediaType.APPLICATION_XML).build();\n } else if (\"json\".equals(type)) {\n return Response.ok(\"/* entity in JSON format */\").type(MediaType.APPLICATION_JSON).build();\n }\n }\n}\n```\nThe previous code excerpt essentially behaves the same as the ContentNegotiationViaURL.java example.\n\n**Content Negotiation Based on Request Parameter**\n\nAnother popular method is for the client to specify the format in a parameter. For instance, by default, a resource could be offered in XML at http://example.com/resource. The JSON version could be retrieved by using a query parameter like http://example.com/resource?format=json.\n\n```java\n@Path(\"/resources\")\npublic class Resource {\n @Path(\"/{resourceID}\" )\n @GET\n public Response getResource(@PathParam(\"resourceID\") String resourceID,\n @QueryParam(\"format\") String format) {\n if (format == null || \"xml\".equals(format)) {\n return Response.ok(/* entity in XML format */).type(MediaType.APPLICATION_XML).build();\n } else if (\"json\".equals(format)) {\n return Response.ok(/* entity in JSON format */).type(MediaType.APPLICATION_JSON).build();\n }\n\n return Response.notAcceptable(Variant.mediaTypes(MediaType.APPLICATION_XML_TYPE,\n MediaType.APPLICATION_JSON_TYPE).add()\n .build()).build();\n }\n}\n```\n\n**Content Negotiation Based on Accept Header**\n\nPerhaps the most powerful form of content negotiation, the HTTP Accept header is another way of specifying the preferred representation format.\n\nThe following excerpt shows sample client code using the Wink RestClient:\n\n```java\nRestClient client = new RestClient();\nClientResponse response = client.resource(\"http://example.com/resources/resource1\").header(\"Accept\", \"application/json;q=1.0, application/xml;q=0.8\").get();\n// find what format was sent back\nString contentType = response.getHeaders().getFirst(\"Content-Type\");\n\nif (contentType.contains(\"application/json\")) {\n JSONObject entity = response.getEntity(JSONObject.class); /* or use a String, InputStream, or other provider that supports the entity media type */\n} else if (contentType.contains(\"application/xml\")) {\n String entity = response.getEntity(String.class); /* or use a JAXB class, InputStream, etc. */\n}\n```\n\nThe following example implements sample client code using the Apache HttpClient.\nHttpClient client = new HttpClient();\nGetMethod getMethod = \n new GetMethod(\"http://example.com/resources/resource1\");\n // prefer JSON over XML but both are acceptable to the client\ngetMethod.setRequestHeader(\"Accept\", \"application/json;q=1.0, application/xml;q=0.8\");\ntry {\n client.executeMethod(getMethod);\n // find what format was sent back\n getMethod.getResponseHeader(\"Content-Type\").getValue();\n // use getMethod.getResponseBodyAsString() or getMethod.getResponseBodyAsStream()\n // to read the body\n} finally {\n getMethod.releaseConnection();\n}\n\nUsing the @Context HttpHeaders injected variable, the client preferred response representation is found.\n\n@Path(\"/resources\")\npublic class Resource {\n\n @Context\n private HttpHeaders headers;\n\n @Path(\"/{resourceID}\"),\n @GET\n public Response getResource(@PathParam(\"resourceID\") String resourceID) {\n List<MediaType> acceptHeaders = headers.getAcceptableMediaTypes();\n if (acceptHeaders == null || acceptHeaders.size() == 0) {\n return Response.ok(/* entity in XML format */).type(MediaType.APPLICATION_XML).build();\n }\n for (MediaType mt : acceptHeaders) {\n String qValue = mt.getParameters().get(\"q\");\n if (qValue != null && Double.valueOf(qValue).doubleValue() == 0.0) {\n break;\n }\n if (MediaType.APPLICATION_XML_TYPE.isCompatible(mt)) {\n return Response.ok(/* entity in XML format */).type(MediaType.APPLICATION_XML).build();\n } else if (MediaType.APPLICATION_JSON_TYPE.isCompatible(mt)) {\n return Response.ok(/* entity in JSON format */).type(MediaType.APPLICATION_JSON).build();\n }\n }\n return Response.notAcceptable(Variant.mediaTypes(MediaType.APPLICATION_JSON_TYPE,\n MediaType.APPLICATION_XML_TYPE).add()\n .build()).build();\n }\n}\n\nIf the client request does not have an Accept HTTP header, then by default the XML format is returned.\nThe @Context HttpHeaders.getAcceptableMediaTypes() method returns an ordered list, sorted by the client preference of the representations.\n\nLooping through the acceptable media types, if the preferred media type is compatible with one of the service's available return types, then the preferred media type is used.\n**Note**\n\nNote that the quality factor is checked. In fairly rare requests, clients can let the service know that a media type should not be sent back (if the quality factor is 0.0).\nContext Information\n\nIn addition to request parameters and entities, there is more request information that can be accessed via request @Context injected variables.\n\nWhen a resource method is invoked, the runtime injects the @Context variables.\n\n```java\n@Path(\"/resource\")\npublic class Resource {\n\n @Context\n private HttpHeaders headers;\n\n @GET\n public void get(@Context UriInfo uriInfo) {\n /* use headers or uriInfo variable here */\n }\n}\n```\n\n**javax.ws.rs.core.HttpHeaders**\n\nHttpHeaders provides methods that allow users to access request headers. A few convenience methods such as `#getAcceptableLanguages()` and `#getAcceptableMediaTypes()` provide client preference sorted acceptable responses.\n\n**javax.ws.rs.core.UriInfo**\n\nUriInfo provides methods so developers can find or build URI information of the current request.\n\n**javax.ws.rs.core.SecurityContext**\n\nSecurityContext provides access to the security information.\n\n**javax.ws.rs.core.Request**\n\nRequest provides methods for evaluating preconditions and for selecting the best response variant based on the request headers.\n\n**javax.ws.rs.core.Providers**\n\nProviders allows access to the user and runtime provided MessageBodyReaders, MessageBodyWriters, ContextResolvers, and ExceptionMappers. It is useful for other providers but can sometimes be useful for resource methods and classes.\n5 Apache Wink Server\n\nThis page last changed on Oct 14, 2009 by michael.\n\nApache Wink Server Module\n\nThe following section describes the Apache Wink Server and provides a detailed description of the Apache Wink Server component and its functionality.\n\n<table>\n<thead>\n<tr>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>5.1 Registration and Configuration</td>\n</tr>\n<tr>\n<td>5.2 Annotations</td>\n</tr>\n<tr>\n<td>5.3 Resource Matching</td>\n</tr>\n<tr>\n<td>5.4 APP Service Document</td>\n</tr>\n<tr>\n<td>5.5 Spring Integration</td>\n</tr>\n<tr>\n<td>5.6 WebDAV Extension</td>\n</tr>\n<tr>\n<td>5.7 Handler Chain</td>\n</tr>\n<tr>\n<td>5.8 Link Builder</td>\n</tr>\n<tr>\n<td>5.9 Assets</td>\n</tr>\n<tr>\n<td>5.10 Admin Views</td>\n</tr>\n</tbody>\n</table>\n\nApache Wink Server Overview\n\nThe Apache Wink Server module is a complete implementation of the JAX-RS v1.0 specification. In addition to the core implementation, the Wink Server module provides a set of additional features that are designed to facilitate the development of RESTful Web services. The framework is easy to extend and to enrich with new functionality.\n\nMain Features\n\nThe Apache Wink Server main features are as follows:\n\n- Is a complete implementation of the JAX-RS v1.0 specification\n- Provides out-of-the-box Java object models for Atom, Json, RSS, APP, CSV, HTML, Multipart and OpenSearch along with providers to serialize and deserialize these models\n- Highly configurable and flexible runtime functionality\n- Provides a Handlers mechanism for manipulation of HTTP request and response messages\n- Automatic generation of APP document for collection resources\n- Spring integration\n- Provides support for WebDAV through the WebDAV extension\n- Provides an in-depth administration view of the runtime registries\n\nApache Wink High Level Server Architecture Overview\n\nThe following diagram illustrates the general architecture of the Apache Wink server runtime.\nThe Apache Wink server runtime layer receives incoming HTTP requests from the hosting container. Once a request is received the Apache Wink server runtime initiates a new request session by creating a message context that is passed through the handlers chain which consists of system and user defined handlers.\n\nInitially the runtime passes the message context through the handlers responsible for finding the resources and resource methods that match the request according to the JAX-RS specification. If required, the incoming request is de-serialized using the appropriate provider. Once the injectable parameters are ready for injection the matched resource method is invoked and the returned response object is then passed through the handler chain in order to select and activate the appropriate provider for serialization as the HTTP response.\n5.1 Registration and Configuration\n\nRegistration and Configuration\n\nApache Wink provides several methods for registering resources and providers. This chapter describes registration methods and Wink configuration options.\n\nSimple Application\n\nApache Wink provides the \"SimpleWinkApplication\" class in order to support the loading of resources and providers through a simple text file that contains a list of fully qualified class names of the resource and provider classes. Each line contains a single fully qualified class name that is either a resource or a provider. Empty lines and lines that begin with a number sign (#) are permitted and ignored.\n\n<table>\n<thead>\n<tr>\n<th># Providers</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>com.example.MyXmlProvider</td>\n<td></td>\n</tr>\n<tr>\n<td>com.example.MyJSONProvider</td>\n<td></td>\n</tr>\n<tr>\n<td># Resources</td>\n<td></td>\n</tr>\n<tr>\n<td>com.example.FooResource</td>\n<td></td>\n</tr>\n<tr>\n<td>com.example.BarResource</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nSpecifying the Simple Application File Location\n\nThe path to a simple application file is configured via the applicationConfigLocation init-param in the web.xml file. It is possible to specify multiple files by separating them with a semicolon.\n\n```\n<servlet>\n <servlet-name>restSdkService</servlet-name>\n <servlet-class>\n org.apache.wink.server.internal.servlet.RestServlet\n </servlet-class>\n <init-param>\n <param-name>applicationConfigLocation</param-name>\n <param-value>/WEB-INF/providers;/WEB-INF/resources</param-value>\n </init-param>\n</servlet>\n```\n\nApache Wink Application\n\nApache Wink extends the javax.ws.rs.core.Application class with the org.apache.wink.common.WinkApplication class in order to provide the Dynamic Resources and the Priorities functionality.\n\nAn application may provide an instance of the Apache Wink Application to the Apache Wink runtime as specified by the JAX-RS specification.\n\nDynamic Resources\n\nDynamic Resources enable the binding of a Resource class to a URI path during runtime instead of by using the @Path annotation. A dynamic resource must implement the DynamicResource interface and must not be annotated with the @Path annotation.\nMotivation\n\nA Dynamic Resource is useful for situations where a resource class must be bound to multiple paths, for example, a sorting resource:\n\n```java\npublic class SortingResource<E extends Comparable<? super E>> {\n private List<E> list;\n @POST\n public void sort() {\n Collections.sort(list);\n }\n public void setList(List<E> list) {\n this.list = list;\n }\n public List<E> getList() {\n return list;\n }\n}\n```\n\nExplanation\n\nIn this example, the SortingResource class can sort any list. If the application manages a library of books and exposes the following resource paths, then the SortingResource class can be used for the implementation of all these resource paths, assuming that it could be bound to more than one path.\n\n```\n/sort-books\n/sort-authors\n/sort-titles\n```\n\nA dynamic resource is also useful for situations where the resource path is unknown during development, and is only known during the application startup.\n\nUsage\n\nA Dynamic Resource is a resource class that implements the org.apache.wink.server.DynamicResource interface or extends the org.apache.wink.server.AbstractDynamicResource convenience class.\n\nA Dynamic Resource is not registered in Apache Wink through the Application#getClasses() method or the Application#getSignletons() method, since the same class can be used for multiple resources. In order to register Dynamic Resources in the system, the WinkApplication#getInstances() method must be used.\n\nScope\n\nThe scope of a Dynamic Resource is limited to \"singleton\" as it is initialized prior to its registration, and the system does not have enough information to create it in runtime. This limitation is irrelevant when working with Spring. Refer to chapter #0 for more information on Spring integration.\n\nPriorities\n\nAlthough JAX-RS defines the algorithm for searching for resources and providers, Apache Wink enables to extend this algorithm by allowing the specification of priorities for them. Apache Wink extends the JAX-RS search algorithms by providing the ability to specify priorities on the resources and providers. This is achieved by enabling the registration of multiple Application instances with different priorities, rendering the order of their registration irrelevant as long as they have different priorities.\nIn order to register a prioritized Application, it is necessary to register an instance of a Apache WinkApplication class. Priority values range between 0 and 1. In the event that the priority was not specified, a default priority of 0.5 is used.\n\n**Resource Priorities**\n\nPriorities on resources are useful for situations where an application registers core resources bound to paths, and allows extensions to register resources on the same paths in order to override the core resources.\n\nThe Apache Wink runtime first sorts the resources based on their priority and then based on the JAX-RS specification, thus if two resources have the same path, the one with higher priority is invoked.\n\n**Provider Priorities**\n\nJAX-RS requires that application-provided providers be used in preference to implementation pre-packaged providers. Apache Wink extends this requirement by allowing applications to specify a priority for providers.\n\nThe Apache Wink runtime initially sorts the matching providers according to the JAX-RS specification, and uses the priority as the last sorting key for providers of equal standing.\n\nIf two providers have the same priority, the order in which they are registered determines their priority such that the latest addition receives the highest priority.\n\nIn order to meet the JAX-RS requirements, the pre-packages providers are registered using a priority of 0.1.\n\n**Properties Table**\n\n<table>\n<thead>\n<tr>\n<th>Property Name</th>\n<th>Description</th>\n<th>Default Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>wink.http.uri</td>\n<td>URI that is used by the Link Builders in case of HTTP</td>\n<td>Use the URI from the request</td>\n</tr>\n<tr>\n<td>wink.https.uri</td>\n<td>URI used by the Link Builders in case of HTTPS</td>\n<td>Use the URI from the request</td>\n</tr>\n<tr>\n<td>wink.context.uri</td>\n<td>Context path used by the Link Builders</td>\n<td>Use the context path from the request</td>\n</tr>\n<tr>\n<td>wink.defaultUrisRelative</td>\n<td>Indicates if URIs generated by the Link Builders are absolute or relative, valid values: true or false</td>\n<td>true - links are relative</td>\n</tr>\n<tr>\n<td>wink.addAltParam</td>\n<td>Indicates if the "alt" query parameter should be added to URIs generated by the Link Builders. Valid values are: true, false</td>\n<td>true - add the alt query parameter</td>\n</tr>\n<tr>\n<td>wink.search PolicyContinuedSearch</td>\n<td>Indicates if continues search is enabled. Valid values: true, false</td>\n<td>true - continued search is enabled</td>\n</tr>\n<tr>\n<td>wink.rootResource</td>\n<td>Indicates if a root resource with Service Document generation capabilities should be added. Valid values are: none, atom, atom+html</td>\n<td>atom+html --atom and html Service Document generation capabilities</td>\n</tr>\n<tr>\n<td>wink.serviceDocumentCssPath</td>\n<td>Defines path to a css file that is used in the html Service</td>\n<td>No css file defined</td>\n</tr>\n</tbody>\n</table>\n## Custom Properties File Definition\n\nIn order to provide a custom properties file, the application should define the `propertiesLocation` init-param in the Apache Wink Servlet definition.\n\n```\n# Providers\n<servlet>\n <servlet-name>restSdkService</servlet-name>\n <servlet-class>org.apache.wink.server.internal.servlet.RestServlet</servlet-class>\n <init-param>\n <param-name>propertiesLocation</param-name>\n <param-value>/WEB-INF/configuration.properties</param-value>\n </init-param>\n <init-param>\n <param-name>winkApplicationConfigLocation</param-name>\n <param-value>/WEB-INF/application</param-value>\n </init-param>\n <load-on-startup>0</load-on-startup>\n</servlet>\n```\n\n## Runtime\n\nRegistration\n\nApache Wink provides several APIs for Runtime Registration. The APIs appear in the `org.apache.wink.server.utils.RegistrationUtils` class. The most important method is the one that registers an instance of the `javax.ws.rs.core.Application` class.\n\n```\n# Providers\nstatic void registerApplication(Application application, ServletContext servletContext)\n```\n\n**Double Registration**\n\nRegistration is ignored and a warning is printed to the log if the instance was previously registered.\n**Media-Type Mapping**\n\nIt is sometimes necessary to override the Content-Type response header based on the client user agent. For example, the Firefox browser cannot handle the application/atom+xml media type for Atom content, unless it is defined as a text/xml.\n\nApache Wink provides a set of predefined Media-Type mappings for use in such cases by supplying the MediaTypeMapper class. Applications may extend or override the MediaTypeMapper class to define additional mappings.\n\n**Customizing Mappings**\n\nIn order to customize these mappings the application should create an instance of a\norg.apache.wink.server.handlers.MediaTypeMapperFactory class and set it in a customized Wink properties file.\n\n**Alternative Shortcuts**\n\nClients specify the requested media type by setting the Http Accept header. Apache Wink provides an alternate method for specifying the requested media type via use of the “alt” request parameter. This functionality is useful in situations where the client has little affect on the accept header, for example when requesting a resource using a browser.\n\nFor example, a request to /entry?alt=application/xml specifies that the requested response media type is application/xml. Apache Wink provides a shortcut mechanism for specifying the media type of the alt query parameter and provides a predefined set of shortcuts for common media types.\n\n**Predefined Shortcuts**\n\n<table>\n<thead>\n<tr>\n<th>Shortcut</th>\n<th>Media Type</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>json</td>\n<td>text/javascript</td>\n</tr>\n<tr>\n<td>atom</td>\n<td>application/atom+xml</td>\n</tr>\n<tr>\n<td>xml</td>\n<td>application/xml</td>\n</tr>\n<tr>\n<td>text</td>\n<td>text/plain</td>\n</tr>\n<tr>\n<td>html</td>\n<td>text/html</td>\n</tr>\n<tr>\n<td>csv</td>\n<td>text/csv</td>\n</tr>\n<tr>\n<td>opensearch</td>\n<td>application/opensearchdescription+xml</td>\n</tr>\n</tbody>\n</table>\n\n**Customizing Shortcuts**\n\nThe shortcuts table can be customized by overriding the deployment configuration class.\n\nReference\nRefer to section 5.1 Registration and Configuration for more information on Customizing the Default Properties Configuration.\n5.2 Annotations\n\nAnnotations\n\nApache Wink provides several annotations in addition to those defined by the JAX-RS specification. The following section describes these annotations in detail.\n\n@Workspace Annotation\n\nThe purpose of the @Workspace annotation is to associate a \"Collection Resource\" with a workspace element and collection elements in an APP Service Document.\n\nReference\n\nFor more information regarding the APP Service Document, refer to section 5.4 APP Service Document\n\nThe workspaceTitle annotation parameter specifies the title of the workspace and the collectionTitle annotation parameter specifies the title of the collection.\n\n@Workspace Annotation Specification\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Description</th>\n<th>Target</th>\n<th>Parameters</th>\n<th>Name</th>\n<th>Type</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Mandatory</td>\n<td>No</td>\n<td>Resource class</td>\n<td>workspaceTitle</td>\n<td>String</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>collectionTitle</td>\n<td>String</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nExample\n\n@Workspace(workspaceTitle = \"Title\", collectionTitle = \"Collection\")\n\n@Workspace Annotation Example\n\nThe following example demonstrates the use of @Workspace annotation on two resources in order to have the auto-generated APP service document contain the information about them.\n\nGiven the following collection Resources definitions, ResourceA and ResourceB, the result is displayed in the \"Auto Generated APP Service Document\" table that follows.\n\nResourceA Definition\n\n```java\n@Workspace(workspaceTitle = \"Services\", collectionTitle = \"Service1\")\n@Path(\"services/service1\")\npublic class ResourceA {\n @POST\n @Produces(\"text/plain\")\n @Consumes({\"application/atom+xml\", \"application/xml\"})\n public String getText() {return \"hey there1\";}\n```\nResourceB Definition\n\n```java\n@Workspace(workspaceTitle = \"Services\", collectionTitle = \"Service2\")\n@Path(\"services/service2\")\npublic class ResourceB {\n @POST\n @Produces(\"text/plain\")\n @Consumes({\"application/atom+xml\", \"application/xml\"})\n public String getText() {return \"hey there2\";}\n}\n```\n\nThe auto-generated APP Service Document is as follows:\n\n**Auto Generated APP Service Document**\n\n```xml\n<service xmlns:atom=http://www.w3.org/2005/Atom\n xmlns=\"http://www.w3.org/2007/app\">\n <workspace>\n <atom:title>Services</atom:title>\n <collection href=\"services/service1\">\n <atom:title>Service1</atom:title>\n <accept>application/xml</accept>\n <accept>application/atom+xml</accept>\n </collection>\n <collection href=\"services/service2\">\n <atom:title>Service2</atom:title>\n <accept>application/xml</accept>\n <accept>application/atom+xml</accept>\n </collection>\n </workspace>\n</service>\n```\n\n**@Asset Annotation**\n\nThe @Asset annotation is a marker annotation used by the Apache Wink runtime in order to identify an entity as an Asset.\n\n**Reference**\nFor more information about Assets refer to section 5.9 Assets.\n\n**@Asset Annotation Specification**\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Mandatory</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Target</td>\n<td>Resource class</td>\n</tr>\n<tr>\n<td>Parameters</td>\n<td>None</td>\n</tr>\n<tr>\n<td>Example</td>\n<td>@Asset</td>\n</tr>\n</tbody>\n</table>\n@Scope Annotation\n\nThe JAX-RS specification defines the default lifecycle behavior for resources and providers, and the option for controlling the lifecycle through the javax.ws.rs.core.Application class.\n\nApache Wink provides the @Scope annotation to specify the lifecycle of a provider or resource.\n\n@Scope Annotation Specification\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Mandatory</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Target</td>\n<td>Provider class or Resource class</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Parameters</th>\n<th>Name</th>\n<th>Type</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Value</td>\n<td>Value</td>\n<td>ScopeType enum</td>\n</tr>\n</tbody>\n</table>\n\nExample\n\n```\n@Scope(ScopeType.PROTOTYPE)\n```\n\nResource Example\n\nThe following example illustrates how to define a resource with a singleton lifecycle.\n\n```\n@Scope(ScopeType.SINGLETON)\n@Path(\"service1\")\npublic class ResourceA {\n ...\n}\n```\n\nProvider Example\n\nThe following example illustrates how to define a provider with a prototype lifecycle.\n\n```\n@Scope(ScopeType.PROTOTYPE)\n@Provider\npublic class EntityProvider implements MessageBodyReader<String> {\n ...\n}\n```\n\n@Parent Annotation\n\nThe @Parent annotation provides the ability to define a base template URI for the URI specified in a resources @Path annotation.\nIf a resource is annotated with the @Parent annotation, the Apache Wink runtime calculates the final resource template by first retrieving the value of the @Parent annotation, which holds the parent resource class, and then concatenates the resource path template definition to the path template definition of the parent resource.\n@Parent Annotation Specification\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Mandatory</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Target</td>\n<td>Provider class or Resource class</td>\n</tr>\n<tr>\n<td>Parameters</td>\n<td>Name</td>\n</tr>\n<tr>\n<td></td>\n<td>Value</td>\n</tr>\n<tr>\n<td>Example</td>\n<td>@Parent(ParentResource.class)</td>\n</tr>\n</tbody>\n</table>\n\nExample 1\n\n```java\n@Path(\"services\")\npublic class ParentResource {\n ...\n}\n```\n\nExample 2\n\n```java\n@Parent(BaseResource.class)\n@Path(\"service1\")\npublic class ResourceA {\n ...\n}\n```\n\nExplanation\n\nIn the example, the user defined two resources: A ParentResource and ResourceA. ParentResource defines the @Path annotation to associate it with \"services\" URI. ResourceA defines the @Path annotation to associate it with \"service1\" URI and defines ParentResource to be its parent by specifying it in the @Parent annotation. In this case, the final URI path for ResourceA is \"services/service1\".\n5.3 Resource Matching\n\nResource Matching\n\nApache Wink provides a Continued Search mode when searching for a resource method to invoke during request processing, which is an extended search mode to the algorithm defined by the JAX-RS specification.\n\nResource Matching Overview\n\nSection 3.7.2 of the JAX-RS specification describes the process of matching requests to resource methods. The fact that only the first matching root resource (section 1(f) of the algorithm) and only the first matching sub-resource locator (section 2(g) of the algorithm) are selected during the process makes it difficult for application developers to implement certain scenarios. For example, it is impossible to have two resources anchored to the same URI, each having its own set of supported methods:\n\n```java\n@Path(\"my/service\")\npublic class ResourceA {\n @GET\n @Produces(\"text/plain\")\n public String getText() {...}\n}\n\n@Path(\"my/service\")\npublic class ResourceB {\n @GET\n @Produces(\"text/html\")\n public String getHtml() {...}\n}\n```\n\nExplanation\n\nIn order to implement this according to the JAX-RS specification, ResourceB must extend ResourceA and be registered instead of ResourceA. However, this may not always be possible, such as in an application that uses JAX-RS as the web service frontend while providing an open architecture for registering extending services. For example, Firefox that provides an Extensions mechanism. The extending service must be aware of the core implementation workings and classes, that may not always be plausible. Moreover, it is impossible for a service to extend the functionality of another service without knowing the inner workings of that service, that creates an \"evil\" dependency between service implementations.\n\nIn order to solve this problem, Apache Wink provides a special resource Continued Search mode when searching for a resource and method to invoke. By default, this mode is off, meaning that the search algorithm is strictly JAX-RS compliant. When this mode is activated, and a root resource or sub-resource locator proves to be a dead-end, the Apache Wink runtime will continue to search from the next root-resource or sub-resource locator, as if they were the first match.\n\nIn the previous example, there is no way to know which of the resources is a first match for a request to \"/my/service\". If the Continued Search mode is off, either the getText() method is unreachable or the getHtml() method is unreachable. However, when the Continued Search mode is active, a request for text/plain reaches the getText() method in ResourceA, and a request for text/html reaches the getHtml() method in ResourceB.\n**Configuration**\n\nThe Continued Search mode is activated by setting the value of the `wink.searchPolicyContinuedSearch` key in the application configuration properties file to true. If the key is set to anything else but true or if it does not exist in the properties file, then the Continued Search mode is set to off, and the behavior is strictly JAX-RS compliant.\n5.4 APP Service Document\n\nThis page last changed on Oct 13, 2009 by michael.\n\nAPP Service Document\n\nApache Wink supports the automatic and manual generation of APP Service Documents by providing an APP data model and set of complementary providers.\n\nAtom Publishing Protocol Service Documents are designed to support the auto-discovery of services. APP Service Documents represent server-defined groups of Collections used to initialize the process of creating and editing resources. These groups of collections are called Workspaces. The Service Document can indicate which media types and categories a collection accepts.\n\nThe Apache Wink runtime supports the generation of the APP Service Documents in the XML (application/atomsvc+xml) and HTML (text/html) representations.\n\nEnabling the APP Service Document Auto Generation\n\nAPP Service Document generation is activated by setting the wink.rootResource key in the configuration properties file. By default, the key value is set to \"atom+html\", indicating that both XML (application/atomsvc+xml) and HTML (text/html) representations are available.\n\nOnce activated, the auto-generated APP Service Document is available at the application root URL \"http://host:port/application\".\n\nAdding Resources to APP Service Document\n\nApache Wink provides the @Workspace annotation used to associate a Collection Resource with an APP Service Document workspace and collection elements. The only requirement to incorporate a collection resource in a service document is to place the @Workspace annotation on the resource.\n\nReference\n\nFor more information on the @Workspace annotation refer to 5.2 Annotations.\n\nExample\n\nGiven the following collection resource definition:\n\n```java\n@Workspace(workspaceTitle = \"Workspace\", collectionTitle = \"Title\")\n@Path(\"my/service\")\npublic class ResourceA {\n...\n}\n```\n\nThe auto-generated APP Service Document is:\n\n```xml\n<service xmlns:atom=\"http://www.w3.org/2005/Atom\"\n xmlns=\"http://www.w3.org/2007/app\">\n <workspace>\n <atom:title>Workspace</atom:title>\n <collection href=\"my/service\">\n <atom:title>Title</atom:title>\n <accept/>\n </collection>\n </workspace>\n</service>\n```\nAPP Service Document HTML Styling\n\nApache Wink provides the ability to change the default styling of the APP Service Document HTML representation. The styling is changed by setting the value of the `wink.serviceDocumentCssPath` key in the configuration properties file to the application specific CSS file location.\n\nImplementation\n\nThe following classes implement the APP Service Document support:\n\n5.5 Spring Integration\n\nSpring Integration\n\nApache Wink provides an additional module deployed as an external jar in order to provide Spring integration. The Spring integration provides the following features:\n\n• The ability to register resources and providers from the Spring context, registered as classes or as Spring beans\n• The ability to define the lifecycle of resources or providers that are registered as Spring beans, overriding the default scope specified by the JAX-RS specification.\n• Resources and providers can benefit from Spring features such as IoC and post-processors.\n• Customize Apache Wink from the Spring context. When working with Spring, Apache Wink defines a core spring context that contains customization hooks, enabling easy customization that would otherwise require coding.\n\nSpring Registration\n\nSpring makes it convenient to register resources and providers as spring beans.\n\nSpring Context Loading. In order to load the Spring Context, it is necessary to add a Context Load Listener definition to the web.xml file. The contextConfigLocation context-param must specify the location of the Apache Wink core context file and the application context file, as described in the following example:\n\n```xml\n<context-param>\n <param-name>contextConfigLocation</param-name>\n <param-value>\n classpath:META-INF/server/winkCoreContext-server.xml\n classpath:mycontext.xml\n </param-value>\n</context-param>\n\n<listener>\n <listener-class>\n org.springframework.web.context.ContextLoaderListener\n </listener-class>\n</listener>\n```\n\nRegistering Resources and Providers\n\nApache Wink provides the org.apache.wink.spring.Registrar class in order to register resources and providers through a Spring context. The Registrar class extends the WinkApplication class and must be registered as a singleton spring bean. It is possible to define multiple registrars in the same context. All registrars are automatically collected by the runtime and registered as WinkApplication objects during the context loading. The registrar provides the following properties:\n\n• **instances** - instances of resources and providers. Ordinarily, these instances are Spring beans, so they can benefit from IoC and other Spring features.\n• **classes** - a set of resources and providers class names. This property is similar to the getClasses() method of the Application class.\n• **priority** - the priority of the WinkApplication\nCustom Properties File Definition\n\nApache Wink provides a set of customizable properties. When working with Spring, the user should redefine the custom properties file using the Spring context:\n\n```\n<bean id=\"customPropertiesFactory\"\n class=\"org.springframework.beans.factory.config.PropertiesFactoryBean\">\n <property name=\"locations\">\n <list>\n <value>WEB-INF/configuration.properties</value>\n </list>\n </property>\n</bean>\n\n<bean id=\"customConfigurer\"\n class=\"org.springframework.beans.factory.config.PropertyPlaceholderConfigurer\">\n <property name=\"ignoreUnresolvablePlaceholders\" value=\"true\" />\n <property name=\"order\" value=\"1\" />\n <property name=\"propertiesArray\">\n <list>\n <props>\n <prop key=\"wink.propertiesFactory\">customPropertiesFactory</prop>\n </props>\n </list>\n </property>\n</bean>\n```\n\n- The customPropertiesFactory bean loads the properties file.\n- The customConfigurer bean overrides the default factory with a custom factory.\n- The order is set to \"1\". This makes the customConfigurer bean run before the default Apache Wink configurer.\n- In addition, notice that ignoreUnresolvablePlaceholders must be set to true, otherwise the configurer will fail, since some unresolved properties can remain in the context.\n\nCustomizing Media-Type Mappings\n\nApache Wink provides the ability to customize the Media-Type mappings using Spring context.\n• The custom.MediaTypeMapper bean creates a new Media-Type mapper.\n\n• The customConfigurer bean overrides the default factory with a custom factory.\n\n **customConfigurer**\n The order is set to \"1\". This makes the customConfigurer run before the default Apache Wink configurer.\n\n* In addition, notice that ignoreUnresolvablePlaceholders must be set to true, otherwise the configurer will fail, since some unresolved properties can remain in the context.\n\n# Customizing Alternative Shortcuts\n\nApache Wink provides the ability to customize the Alternative Shortcuts in one of two ways.\n\n**Reference**\nFor more information on Alternative Shortcuts Mappings refer to section 5.1 Registration and Configuration.\n\n## External Properties File\n\nThe shortcuts are defined in a properties file. The shortcuts properties file is loaded in the same way that the configuration properties file is loaded.\n\n```xml\n<bean id=\"custom.Shortcuts\"\n```\n**Spring Context File**\n\nDefines the map of the shortcuts in the Spring context.\n5.6 WebDAV Extension\n\nWebDAV Extension\n\nApache Wink provides an extension module for supporting the WebDAV protocol. The extension contains the complete WebDAV XML model and a WebDAV response builder for easing the process of creating a WebDAV multistatus response.\n\n**Useful Information**\nThe WebDAV extension is a single jar wink-webdav-<version>.jar, and it has no special dependencies.\n\nWebDAV Data Model\n\nThe WebDAV extension provides a Java data model that reflects the WebDAV XMLs defined in the WebDAV RFC. All classes of the data model are located in the org.apache.wink.webdav.model package.\n\nWebDAV Classes\n\nThe WebDAV extension provides several classes that applications can use in order to receive basic support for common WebDAV methods.\n\n**WebDAVModelHelper**\n\nThe WebDAVModelHelper class provides helper methods for XML marshaling and unmarshaling of the WebDAV data model classes. It also provides helper methods for creating generic properties as DOM element classes to populate the WebDAV Prop element.\n\n**WebDAVResponseBuilder**\n\nThe WebDAVResponseBuilder class is used in order to create responses to WebDAV PROPFIND requests. It takes a SyndEntry or SyndFeed as input in order to create the response.\n\nResource Method Definition\n\nA resource method is defined to handle the desired WebDAV method by annotating it with one of the WebDAV method designators defined in the WebDAVMethod enum. The supported WebDAV Http methods are as follows:\n\n- PROPFIND\n- PROPPATCH\n- MKCOL\n- COPY\n- MOVE\n- LOCK\n- UNLOCK.\nCreating a Multistatus Response\n\nIn order to create a **MULTISTATUS** response to a **PROPFIND** request the user can use the **WebDAVResponseBuilder** class, or create the response manually.\n\nUsing WebDAVResponseBuilder\n\nIn order to create a multistatus response using the **WebDAVResponseBuilder** class, call one of the propfind() methods.\n\nThe **WebDAVResponseBuilder** class also enables the user to provide the properties to include in the response by extending the PropertyProvider class, overriding the setPropertyValue() method and passing the property provider instance to the response builder propfind() method.\n\n**WebDAVResponseBuilder Example**\n\n```java\n@Path(\"defects/{defect}\")\npublic class DefectResource {\n @WebDAVMethod.PROPFIND\n @Consumes(\"application/xml\")\n @Produces(\"application/xml\")\n public Response propfindDefect(@PathParam(\"defect\") String defected) {\n SyndFeed feed = ...\n return WebDAVResponseBuilder.propfind(feed);\n }\n}\n```\n\nThe propfindDefect() method is associated with the PROPFIND WebDAV Http method using the @WebDAVMethod.PROPFIND annotation.\n\nWhen the propfindDefect() method is invoked, an instance of a **org.apache.wink.common.model.synd.SyndFeed** is created and passed to the **WebDAVResponseBuilder.propfind()** method in order to create the actual response.\n\nManual Creation\n\nIn order to create a Multistatus response manually, perform the following steps:\n\n1. Create a new **org.apache.wink.webdav.model.Multistatus** instance and set its fields according to the application logic.\n2. Create a new **javax.ws.rs.core.Response** instance, set the response code to **MULTI_STATUS** (207), and set its entity to be the Multistatus instance.\n\nReturn the Response instance from the resource method.\n\n5.7 Handler Chain - Runtime Extension\n\nHandler Chain - Runtime Extension\n\nThe Apache Wink runtime utilizes three Handler Chains for the complete processing of a request: Request chain, Response chain and Error chain. A handler receives a MessageContext instance for accessing and manipulating the current request information and a HandlerChain instance for advancing the chain. It is the responsibility of the handler to pass control to the next handler on the chain by invoking the doChain() method on the HandlerChain instance.\n\nA handler may call the doChain() method several times if needed, so handlers are required to consider the possibility they will be invoked more than once for the same request.\nAll handler related interfaces reside in the org.apache.wink.server.handlers package.\n\nThe implementation of separate chains provides the ability to move up and down one chain before moving on to the next chain. This is particularly useful for the implementation of the JAX-RS resource-method search algorithm that includes invoking sub-resource locators, and implementing the Continued Search mode.\n\nHandlers\n\nThere are two types of handlers:\n\n- **System Handler** - are the handlers that implement the core engine of the Apache Wink runtime. The Apache Wink runtime will not function correctly if any of the system handlers are removed from the chain.\n\n- **User Handler** - are the handlers that are provided by an application to customize a chains behavior and to add unique functionality to it. User handlers are not part of the core functionality of Apache Wink.\n\nReference\n\nIn order to customize a handler chain refer to section 2 \"Apache Wink Building Blocks\", Customization of the Handlers Chain\n\nMessage Context\n\nThe MessageContext allows the following:\nAllows handlers to access and manipulate the current request informationAllows handlers to maintain a state by setting attributes on the message context, as the handlers themselves are singletons and therefore stateless.\nAllows handlers to pass information to other handlers on the chain\n\nRequest Handler Chain\n\nThe Request Handler Chain is responsible for processing a request according to the JAX-RS specification by accepting the request, searching for the resource method to invoke, de-serializing the request entity and finally for invoking the resource method. It is responsible for invoking sub-resource locators by moving up and down the chain as needed. A Request handler is a class that implements the org.apache.wink.server.handlers.RequestHandler interface.\n\nSystem Request Handlers\n\nThe following is a list of system handlers comprising the request handler chain in the order that they appear in the chain.\n<table>\n<thead>\n<tr>\n<th>Handler</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SearchResultHandler</td>\n<td>Responsible for throwing the search result error if there was one during the search for the resource method</td>\n</tr>\n<tr>\n<td>OptionsMethodHandler</td>\n<td>Generates a response for an OPTIONS request in case that there is no resource method that is associated with OPTIONS, according to the JAX-RS spec</td>\n</tr>\n<tr>\n<td>HeadMethodHandler</td>\n<td>Handles a response for a HEAD request in case that there is no resource method that is associated with HEAD, according to the JAX-RS spec</td>\n</tr>\n<tr>\n<td>FindRootResourceHandler</td>\n<td>Locates the root resource that best matches the request</td>\n</tr>\n<tr>\n<td>FindResourceMethodHandler</td>\n<td>Locates the actual method to invoke that matches the request, invoking sub-resource locators as needed</td>\n</tr>\n<tr>\n<td>CreateInvocationParametersHandler</td>\n<td>Creates the parameters of the resource method to invoke and de-serializes the request entity using the appropriate MessageBodyReader</td>\n</tr>\n<tr>\n<td>InvokeMethodHandler</td>\n<td>Invokes the resource method</td>\n</tr>\n</tbody>\n</table>\n\n**User Request Handlers**\n\nUser request handlers are inserted before the InvokeMethodHandler handler.\n\nReference\nIn order to customize a handler chain refer to section 2 \"Apache Wink Building Blocks\", Customization of the Handlers Chain\n\n**Response Handler Chain**\n\nThe Response Handler Chain is responsible for handling the object returned from invoking a resource method or sub-resource method according to the JAX-RS specification. It is responsible for determining the response status code, selecting the response media type and for serializing the response entity. A Response handler is a class that implements the org.apache.wink.server.handlers.ResponseHandler interface.\n\n**System Response Handlers**\n\nThe following is a list of system handlers comprising the response handler chain in the order that they appear in the chain.\n\n<table>\n<thead>\n<tr>\n<th>Handler</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PopulateResponseStatusHandler</td>\n<td>Determines the response status code, according to the JAX-RS spec</td>\n</tr>\n<tr>\n<td>PopulateResponseMediaTypeHandler</td>\n<td>Determines the response media type, according to the JAX-RS spec</td>\n</tr>\n</tbody>\n</table>\nFlushResultHandler | Serializes the response entity using the appropriate MessageBodyWriter\nHeadMethodHandler | Performs cleanup operations in case that there was no resource method that was associated with HEAD.\n\n**User Response Handlers**\n\nUser response handlers are inserted before the FlushResultHandler handler. Apache Wink initializes the user response handler chain with the `CheckLocationHeaderHandler` handler that verifies that the \"Location\" response header is present on a response when there is a status code that requires it, for example, status code: 201.\n\n**Reference**\nIn order to customize a handler chain refer to section 2 \"Apache Wink Building Blocks\", Customization of the Handlers Chain\n\n**Error Handler Chain**\n\nThe Error Handler Chain is responsible for handling all of the exceptions that are thrown during the invocation of the Request and Response handler chains, according to the JAX-RS specification for handling exceptions. It is responsible for determining the response status code, selecting the response media type and for serializing the response entity.\n\nAn Error handler is a class that implements the `org.apache.wink.server.handlers.ResponseHandler` interface.\n\n**System Error Handlers**\n\nThe following is a list of system handlers comprising the error handler chain in the order that they appear in the chain.\n\n**Error Handlers**\n\n<table>\n<thead>\n<tr>\n<th>Handler</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PopulateErrorResponseHandler</td>\n<td>Prepares the response entity from a thrown exception according to the JAX-RS specification</td>\n</tr>\n<tr>\n<td>PopulateResponseStatusHandler</td>\n<td>Determines the response status code according to the JAX-RS spec</td>\n</tr>\n<tr>\n<td>PopulateResponseMediaTypeHandler</td>\n<td>Determines the response media type, according to the JAX-RS spec</td>\n</tr>\n<tr>\n<td>FlushResultHandler</td>\n<td>Serializes the response entity using the appropriate MessageBodyWriter</td>\n</tr>\n</tbody>\n</table>\n\n**User Error Handlers**\n\nUser error handlers are inserted before the FlushResultHandler handler.\n\n**Reference**\nIn order to customize a handler chain refer to section 2 \"Apache Wink Building Blocks\", Customization of the Handlers Chain\n**Request Processing**\n\nThe following details how the Apache Wink runtime performs request processing:\n\n1. Create new instances of the three handler chains. The handlers themselves are singletons.\n2. Create a new instance of a MessageContext to pass between the handlers.\n3. Invoke the first handler on the Request chain.\n4. Once the request chain is complete, invoke the Response chain and pass it the MessageContext that was used in the Request chain.\n5. Make both chains and the MessageContext available for garbage collection.\n\nIf at any time during the execution of a Request or Response chain an exception is thrown, catch the exception, wrap it in a new MessageContext instance and invoke the Error chain to produce an appropriate response.\n5.8 Link Builder\n\nThis page last changed on Oct 12, 2009 by bluk.\n\nLink Builders\n\nThe LinkBuilders interface enables access to two types of links builders, the SystemLinksBuilder and the SingleLinkBuilder. An instance of LinkBuilders is injected into a class field or method parameter using the @Context annotation.\n\nUpon creation, the LinkBuilders automatically detects if the target method being invoked is a resource method or a sub-resource method. The \"resource\" and \"subResource\" properties of the builder are initialized accordingly. The link builder interfaces reside in the org.apache.wink.server.utils package.\n\nLink Builders Overview\n\nThe JAX-RS specification defines the UriBuilder interface used to construct a URI from a template, but does not specify any mechanism that can automatically generate all resource links. Apache Wink provides the SystemLinksBuilder for automatic generation of all the alternate links to a resource, one link per every supported media type. For example, this is useful for an application that produces Atom feeds to include in the feed all the alternate representations of the resource.\n\nApache Wink provides a mechanism for defining if the generated links should be absolute links or relative to a base URI. For example, links embedded in an Atom feed should be as short as possible in order to optimize the payload size.\n\nThe \"alt\" Query Parameter\n\nApache Wink supports the special query parameter \"alt\" that is used to override the value of the request Accept header. When the link builders generate a link that specifies the \"type\" attribute, then the \"alt\" query parameter is automatically added to the generated link. This is controlled by setting the wink.addAltParam key of the configuration properties file or by calling the LinksBuilder#addAltParam() method.\n\nReference\n\nFor more information on the Configuration Properties File refer to section 5.1 Registration and Configuration.\n\nSystem Links Builder\n\nThe SystemLinksBuilder interface enables the generation of all, or a subset of, the system links to a resource or its sub-resources. The links are generated as absolute URIs or as relative to the base URI according to the SystemLinksBuilder state, request information or the application configuration.\n\nExample\n\n```java\n@Path(\"defects/{id}\")\npublic class DefectResource {\n @GET\n @Produces(\"application/atom+xml\")\n public SyndEntry getAtom() { ... }\n @GET\n @Produces(\"application/json\")\n public JSONObject getJson() { ... }\n @GET\n @Produces(\"application/xml\")\n```\npublic Defect getXml(@Context LinkBuilders linkBuilders) { SystemLinksBuilder builder = linkBuilders.systemLinksBuilder(); ListsystemLinks = builder.build(null); ... }\n\nExplanation\n\nThe DefectResource#getXml() method is invoked when a GET request for application/xml is made to /defects/3. The Apache Wink runtime injects an instance of LinkBuilders to the linkBuilder parameter and a new instance of a SystemLinksBuilder is created by invoking the systemLinksBuilder() method. The call to the build() method of the SystemLinksBuilder generates three alternate links to the DefectResource and the self link:\n\n• <link rel=\"self\" href=\"/defects/3\"/>\n• <link rel=\"alternate\" type=\"application/json\" href=\"/defects/3\"/>\n• <link rel=\"alternate\" type=\"application/xml\" href=\"/defects/3\"/>\n• <link rel=\"alternate\" type=\"application/xtom+xml\" href=\"/defects/3\"/>\n\nSingle Link Builder\n\nThe SingleLinkBuilder interface enables the generation of a single link referencing a resource or a sub-resource, allowing the specification of the 'rel' and 'type' attributes of the generated link. The links are generated as absolute URIs or as relative to the base URI according to the SingleLinkBuilder state, request information or the application configuration.\n\nGenerating Absolute or Relative Links\n\nThe link builders generate absolute or relative links based on the following algorithm:\n\n1. Use the value that was passed to the relativize() method of the builder.\n2. If the relativize() method was not called, then use the value of the \"relative-urls\" query parameter from the request. The value must be either true or false.\n3. If the request does not contain the \"relative-urls\" query parameter, then use the value of the wink.defaultUrisRelative key set in the application configuration properties file. The value must be either true or false.\n4. If the configuration key does not exist, then use true.\n\nReference\n\nFor more information on the Configuration Properties File refer to section 5.1 Registration and Configuration.\n5.9 Assets\n\nThis page last changed on Oct 13, 2009 by michael.\n\nAssets\n\nAn Asset is a special entity that is returned by a resource method or is injected into a resource method as an entity parameter. The asset is used for retrieving the actual request entity or response entity. The purpose of an asset is to act as a container of an entity data model while providing the transformation methods of the data model into data models of other representations. Asset classes are POJOs, annotated with the @Asset annotation, that have any number of entity methods.\n\nWhen an asset instance is returned from a resource method or is set as the entity on a Response instance, it is used by the Apache Wink runtime to retrieve the actual response entity by invoking the appropriate entity-producing method of the asset.\n\nReference\n\nFor more information on Entity-Producing Methods refer to section Entity Producing Methods.\n\nWhen an asset is the entity parameter of a resource method, it is used by the Apache Wink runtime to set the actual request entity by invoking the appropriate entity-consuming method of the asset.\n\nAssets Overview\n\nA typical application exposes each resource in a number of representations. Some form of data model usually backs the resource, and the application business logic relies on the manipulation of that data model. The application will most likely expose resource methods allowing the consumption of the data model in more than one representation (for example Atom and XML) and the production of the data model in other representation (for example Atom, XML and JSON).\n\nAccording to the JAX-RS specification, the optimal method for implementing a resource is one that consumes and produces an application data model and makes use of a different provider for every media type.\n\nFor example, if a resource implements methods that consume and produce a \"Defect\" bean, then a provider must be implemented for each representation of the \"Defect\" (Atom, XML and JSON). However, there are times that the transformation of the application data model into a representation requires information that may only be available to the resource but is unavailable to a provider (for example, a connection to the Database).\n\nThere are several solutions for dealing with the problem of a provider not having sufficient information to perform application data transformations. The following is a description of two possible solutions:\n\n- Passing the information as members on the resource and accessing the resource from the provider via the UriInfo context.\n\nThis solution is only plausible if the resource scope is \"per request\" and does not work if the resource is a singleton.\n\n- Passing the information from the resource to the provider via the attributes of the HttpServletRequest.\n\nThis solution is only plausible when the application is deployed in a JEE container and is not the optimal solution.\n\nIn addition to the previously mentioned problem, the creation of a provider for every data model per media type may result in the inflation of providers in the system, causing the provider selection algorithm to consider a large set of potential providers.\n\nAs a result, the selection of the actual provider from the set of potential providers is non-deterministic, because the selection between them is undefined.\nPerformance Degradation\nAn additional side effect of provider inflation is performance degradation.\n\nThe use of an asset solves the problem of passing information between a resource and a provider and reduces the amount of registered providers in the system.\n\nLifecycle\n\nResource methods can use an asset as a response entity and as a request entity. The Apache Wink runtime applies different lifecycles for each case.\n\nResponse Entity Asset\n\nThe lifecycle of an asset as a response entity is as follows:\n\n1. The application creates and returns the asset from the resource method.\n2. The appropriate entity-producing method is invoked by the Apache Wink runtime to retrieve the actual response entity.\n3. The appropriate message body writer as obtained from the Providers#getMessageBodyWriter() method serializes the entity obtained at the previous step.\n4. The asset is made available for garbage collection.\n\nRequest Entity Asset\n\nThe lifecycle of an asset as a request entity is as follows:\n\n1. An asset class is instantiated by the Apache Wink runtime by invoking the asset default constructor. Note that this implies that the asset class must have a public default constructor.\n2. The appropriate message body reader as obtained from the Providers#getMessageBodyReader() method is invoked by the Apache Wink runtime to read the request entity.\n3. The appropriate entity-consuming method is invoked on the asset to populate the asset with the request entity.\n4. The asset is injected into the resource method as the entity parameter.\n5. The asset is made available for garbage collection after returning from the resource method.\n\nAsset Entity Methods\n\nAsset Entity methods are the public methods of an asset annotated with either @Consumes or @Produces annotation. Annotating a method with both @Consumes and @Produces annotations is not supported and may result in unexpected behavior.\n\nEntity Producing Methods\n\nAn Entity Producing Method is a public asset method annotated with the @Produces annotation, designating it to produce the actual response entity. Such methods produce an entity only for the media types declared in the @Produces annotation. Note that under this definition, wildcard (\"/\") is allowed. The Apache Wink runtime will not invoke an entity-producing method whose effective value of @Produces does not match the request Accept header.\n\nEntity Consuming Methods\n\nAn Entity Consuming Method is a public asset method annotated with the @Consumes annotation, designating it to consume the actual request entity for populating the asset. Such methods consume an entity only for the media types declared in the @Consumes annotation. Note that under this definition, wildcard (\"/\") is allowed. The Apache Wink runtime will not invoke an entity-consuming method whose effective value of @Consumes does not match the request Content-Type header.\nParameters\n\nAsset Entity methods support the same parameter types as JAX-RS specifies for a resource method.\n\nReturn Type\n\nEntity methods may return any type that is permissible to return from a resource method.\n\nExceptions\n\nExceptions thrown from an entity method are treated as exceptions thrown from a resource method.\n\nAnnotation Inheritance\n\nThe @Produces and @Consumes annotations are not inherited when an asset sub-class overrides an asset entity method. Asset sub-classes must re-declare the @Produces and @Consumes annotations for the overriding method to be an entity method.\n\nEntity Method Matching\n\nAsset classes are handled by the AssetProvider which is a JAX-RS provider that is capable of consuming and producing all media types.\n\nReference\n\nFor more information on Asset Providers refer to section 7.7 Assets Provider.\n\nRequest Entity Matching\n\nThe following points describe the process of selecting the asset entity-consuming method to handle the request entity. This process occurs during the invocation of the AssetProvider#isReadable() method.\n\n1. Collect all the entity-consuming methods of the asset. These are the public methods annotated with @Consumes annotation.\n2. Sort the collected entity-consuming methods in descending order, where methods with more specific media types precede methods with less specific media types, following the rule n/m > n/* > /.\n3. Select the first method that supports the media type of the request entity body as provided to the AssetProvider#isReadable() method, and return true.\n4. If no entity-consuming method supports the media type of the request entity body, return false. The Apache Wink runtime continues searching for a different provider to handle the asset as a regular entity.\n\nResponse Entity Matching\n\nThe following points describe the process of selecting an entity-producing method to produce the actual response entity. The following process occurs during the invocation of the AssetProvider#isWriteable() method.\n\n1. Collect all the entity-producing methods of the asset. These are the public methods annotated with @Produces annotation.\n2. Sort the collected entity-producing methods in descending order, where methods with more specific media types precede methods with less specific media types, following the rule n/m > n/* > /.\n3. Select the first method that supports the media type of the response entity body as provided to the AssetProvider#isWriteable() method and return true.\n4. If no entity-producing method supports the media type of the response entity body, return false. The Apache Wink runtime continues searching for a different provider to handle the asset as a regular entity.\nAsset Example\n\nThe following example illustrates the use of an asset. The \"Defect\" bean is a JAXB annotated class.\n\nDefectAsset Class\n\nThe DefectAsset class is the asset backed by an instance of a \"Defect\" bean.\n\n```java\n@Asset\npublic class DefectAsset {\n public Defect defect;\n public DefectAsset(Defect defect) {\n this.defect = defect;\n }\n @Produces(\"application/xml\")\n public Defect getDefect() {\n return this.defect;\n }\n @Produces(\"text/html\")\n public String getDefectAsHtml() {\n String html = \"...\";\n return html;\n }\n @Produces(\"application/atom+xml\")\n public AtomEntry getDefectAsAtom() {\n AtomEntry entry = \"...\";\n return entry;\n }\n @Consumes(\"application/xml\")\n public void setDefect(Defect defect) {\n this.defect = defect;\n }\n}\n```\n\nDefectResource Class\n\nThe DefectResource class is a resource that is anchored to the URI path \"defects/{id}\" within the Apache Wink runtime.\n\n```java\n@Path(\"defects/{id}\")\npublic class DefectResource {\n @GET\n public DefectAsset getDefect(@PathParam(\"id\") String id) {\n return new DefectAsset(defects.get(id));\n }\n @PUT\n public DefectAsset updateDefect(DefectAsset defectAsset,\n @PathParam(\"id\") String id) {\n defects.put(id, defectAsset.getDefect());\n return defectAsset;\n }\n}\n```\n\nScenario Explanation 1\n\n1. A client issues an HTTP GET request with a URI=\"/defects/1\" and Accept Header= \"application/xml\"\n2. The Apache Wink runtime analyzes the request and invokes the DefectResource#getDefect() resource method.\n3. The DefectResource#getDefect() resource method creates an instance of DefectAsset and populates it with defect \"1\" data.\n4. The DefectResource#getDefect() resource method returns the DefectAsset instance back to Apache Wink runtime.\n5. The Apache Wink runtime analyzes the asset and invokes the DefectAsset#getDefect() entity-producing method to obtain the reference to the \"Defect\" bean.\n6. The \"Defect\" bean is serialized by Apache Wink runtime as an XML using the appropriate provider.\n\n**Scenario Explanation 2**\n\n1. A Client issues an HTTP GET request with a URI=\"/defects/1\" and Accept Header= \"text/html\"\n2. The Apache Wink runtime analyzes the request and invokes the DefectResource#getDefect() resource method.\n3. The DefectResource#getDefect() resource method creates an instance of DefectAsset and populates it with defect \"1\" data.\n4. The DefectResource#getDefect() method returns the populated asset back to the Apache Wink runtime.\n5. The Apache Wink runtime analyzes the asset and invokes the DefectAsset#getDefectAsHtml() entity-producing method in order to obtain the reference to the \"Defect\" bean.\n6. The \"Defect\" is serialized by Apache Wink runtime as an HTML using the appropriate provider.\n\n**Scenario Explanation 3**\n\n1. A Client issues an HTTP PUT request with a URI=\"/defects/1\" and Accept Header= \"text/html\"\n2. The Apache Wink runtime analyzes the request and invokes the DefectResource#updateDefect() method with an instance of DefectAsset populated with the request entity.* A DefectAsset is instantiated by the Apache Wink runtime.\n3. The DefectAsset#setDefect() entity-consuming method is invoked in order to populate the DefectAsset with the defect data.\n5.10 Admin Views\n\nAdministration Views\n\nApache Wink provides administration views in order to help developers better understand the services that the REST application expose. There are two administration views, the \"application resource XML view\" and the \"resource registry XML view\".\n\nApplication Resources XML View\n\nThe application resource XML view shows the way the application is exposed to the user, it exposes the REST resources with their URI templates, the HTTP methods that are supported by the resources and the consume/produces MimeType supported by each method. This view can be used as a base for the service documentation.\n\nResource Registry XML View\n\nThe resource registry XML view shows the way that the application is developed, it is similar to the \"Application resources XML view\" but it also exposes the classes that implement resources and their priority in the registry. This view can be useful for debugging.\n\nConfiguration\n\nBy default these views are disabled, in order to activate them register the \"AdminServlet\" implemented by the org.apache.wink.server.internal.servlet.AdminServlet in the web.xml file. No init parameters are required.\n\nExample\n\nThe following code snippet is an example of a web application descriptor file.\n\n```\n<servlet>\n <servlet-name>restSdkAdmin</servlet-name>\n <servlet-class>org.apache.wink.server.internal.servlet.AdminServlet</servlet-class>\n</servlet>\n\n<servlet-mapping>\n <servlet-name>restSdkAdmin</servlet-name>\n <url-pattern>/admin</url-pattern>\n</servlet-mapping>\n```\nApache Wink Client Overview\n\nThe Apache Wink Client is an easy-to-use client, providing a high level Java API for writing clients that consume HTTP-based RESTful Web Services. The Apache Wink Client utilizes JAX-RS concepts, encapsulates Rest standards and protocols and maps Rest principles concepts to Java classes, which facilitates the development of clients for any HTTP-based Rest Web Services.\n\nThe Apache Wink Client also provides a Handlers mechanism that enables the manipulation of HTTP request/response messages.\n\nMain Features\n\nThe Apache Wink Clients main features are as follows:\n\n- Utilizes JAX-RS Providers for resource serialization and deserialization\n- Provides Java object models for Atom, Json, RSS, APP, CSV, Multipart and OpenSearch along with providers to serialize and deserialize these models\n- Uses the JDK HttpURLConnection as the underlying Http transport\n- Allows for the easy replacement of the underlying Http transport\n- Provides a Handlers mechanism for manipulation of HTTP request and response messages\n\nSupports\n\n- Http proxy\n- SSL\n\nApache Wink High Level Client Architecture Overview\n\nThe following diagram illustrates the high-level architecture of the Apache Wink Client.\nThe RestClient class is the Apache Wink Client entry point and is responsible for holding different configuration options and the provider registry.\n\nThe RestClient is used to create instances of the Resource class. The Resource class represents a web resource associated with a specific URI and is used to perform uniform interface operations on the resource it represents. Every method invocation goes through a user defined handlers chain that enables for manipulation of the request and response.\n6.1 Getting Started with Apache Wink Client\n\nGetting Started with the Apache Wink Client\n\nThe following section details the getting started examples that demonstrate how to write a simple client that consume RESTful Web Services with the Apache Wink Client.\n\nGET Request\n\nThe following example demonstrates how to issue an Http GET request.\n\n```java\n// create the rest client instance\n1 RestClient client = new RestClient();\n\n// create the resource instance to interact with\n2 Resource resource = client.resource(\"http://services.com/HelloWorld\");\n\n// perform a GET on the resource. The resource will be returned as plain text\n3 String response = resource.accept(\"text/plain\").get(String.class);\n```\n\nExplanation\n\nThe RestClient is the entry point for building a RESTful Web Service client. In order to start working with the Wink Client, a new instance of RestClient needs to be created, as the example shows in line 1 of the example. A new Resource is then created with the given URI, by calling the RestClient#resource() method as appears in line 2.\n\nFinally, the Resource#get() method is invoked in order to issue an Http GET request as appears in line 3. Once the Http response is returned, the client invokes the relevant provider to desterilizes the response in line 3.\n\nPOST Request\n\nThe following example demonstrates how to issue an Http POST request.\n\n```java\n// create the rest client instance\n1 RestClient client = new RestClient();\n\n// create the resource instance to interact with\n2 Resource resource = client.resource(\"http://services.co\");\n\n// issue the request\n3 String response = resource.contentType(\"text/plain\").accept(\"text/plain\").post(String.class, \"foo\");\n```\n\nExplanation\n\nThe POST Request example demonstrates how to issue a simple Http POST request that sends and receives resources as strings.\n\nFirst, a new instance of a Resource is created through the RestClient. The Http POST request is then issued by specifying the request and response media types and the response entity type (String.class).\n\nPOST Atom Request\n\nThe following example demonstrates how to issue an Http POST request that sends and receives atom entries.\n// create the rest client instance\n1 RestClient client = new RestClient();\n\n// create the resource instance to interact with\n2 Resource resource = client.resource(\"http://services.co\");\n\n3 AtomEntry request = getAtomEntry();\n\n// issue the request\n4 AtomEntry response = resource.contentType(\"application/atom+xml\").accept(\"application/atom+xml\").post(AtomEntry.class, request);\n\n**Explanation**\n\nThe Apache Wink Client provides an object model for Atom (atom feed and atom entry), and supplies out-of-the-box providers that enable sending and receiving atom feeds and entries.\n\n**Using ClientResponse**\n\nThe following example demonstrates how to use the ClientResponse object in order to de-serialize the response entity.\n\n// create the rest client instance\n1 RestClient client = new RestClient();\n\n// create the resource instance to interact with\n2 Resource resource = client.resource(\"http://services.co\");\n\n// issue the request\n3 ClientResponse response = resource.accept(\"text/plain\").get();\n\n// deserialize response\n4 String responseAsString = response.getEntity(String.class);\n\n**Explanation**\n\nIf the response entity type is not provided when invoking the Resource#get() method that appears in line 3, the response will be returned as the raw ClientResponse. In order to trigger the response deserialization mechanism, the ClientResponse#getInstance() method needs to be invoked as it appears in line 4 with the required response entity type.\n6.2 Configuring the Apache Wink Client\n\nThis page last changed on Oct 13, 2009 by michael.\n\nClient Configuration\n\nThe RestClient configuration is performed by using the ClientConfig class. An instance of the configuration class is passed to the constructor of the RestClient when constructing a new RestClient.\n\nThe following options can be configured in the RestClient:\n\n- Custom providers via JAX-RS Application\n- Handler chain\n- Proxy host and port\n- Connect and read timeouts\n- Redirect\n\nHandler Configuration\n\nThe following example demonstrates how to register a custom handler.\n\n```java\n1 ClientConfig config = new ClientConfig();\n// Create new JAX-RS Application\n2 config.handlers(new DummyHandler());\n// create the rest client instance\n3 RestClient client = new RestClient(config);\n// create the resource instance to interact with\n4 Resource resource = client.resource(\"http://services.com/HelloWorld\");\n// perform a GET on the resource\n// the resource will be returned as plain text\n5 String response = resource.accept(\"text/plain\").get(String.class);\n```\n\nExplanation\n\nFirst, a new instance of a ClientConfig is created as it appears in line 1. Then the new handler is added to the handlers chain by invoking the handlers() method on the ClientConfig instance as it appears in line 2. Finally, a new instance of a RestClient is created with this configuration as it appears in line 3.\n\nCustom Provider Configuration\n\nThe following example demonstrates how to register a custom entity provider.\n\n```java\n1 ClientConfig config = new ClientConfig();\n// Create new JAX-RS Application\n2 Application app = new Application() {\n @Override\n public Set<Class<?>> getClasses() {\n HashSet<Class<?>> set = new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>(\n new HashSet<Class<?>>))));\n return set;}});\n3 conf.applications(app);\n// create the rest client instance\n4 Restclient client = new RestClient(config);\n// create the resource instance to interact with\n5 Resource resource = client.resource(\"http://services.com/HelloWorld\");\n// perform a GET on the resource, the resource will be returned as plain text\n```\n```java\n6 String response = resource.accept(\"text/plain\").get(String.class);\n```\n\n**Explanation**\n\nFirst, a new instance of ClientConfig is created as it appears in line 1. Then a new anonymous Application is instantiated and set on the ClientConfig as it appears in line 2 and 3. Finally, a new instance of a RestClient is created with this configuration as it appears in line 4.\n6.3 Input and Output Stream Adapters\n\nInput and Output Stream Adapters\n\nThe Apache Wink Client provides the ability to manipulate raw Http input and output entity streams through the InputStreamAdapter and the OutputStreamAdapter interfaces. This is useful for modifying the input and output streams, regardless of the actual entity, for example when adding compression capabilities.\n\nThe adapt() method of the output stream adapter is called before the request headers are committed, in order to allow the adapter to manipulate them.\n\nThe adapt() method of the input stream adapter is called after the response status code and the headers are received in order to allow the adapter to behave accordingly.\n\nStream Adapters Example\n\nThe following example demonstrates how to implement input and output adapters.\n\nGzip Handler\n\nThe following code snippet is an example of adding a input and output adapters in the Gzip handler.\n\n```java\npublic class GzipHandler implements ClientHandler {\n public ClientResponse handle(ClientRequest request, HandlerContext context) {\n request.getHeaders().add(\"Accept-Encoding\", \"gzip\");\n context.addInputStreamAdapter(new GzipInputAdapter());\n context.addOutputStreamAdapter(new GzipOutputAdapter());\n return context.doChain(request);\n }\n}\n```\n\nExplanation\n\nThe Gzip handler creates instances of the `GzipInputAdapter` and the `GzipOutputAdapter` and adds them to the stream adapters of the current request by invoking the `addInputStreamAdapter()` method and the `addOutputStreamAdapter()` method on the HandlerContext instance.\n\nGzip Input Stream Adapter\n\nThe following code snippet is an example of an implementation of a Gzip input stream adapter.\n\n```java\nclass GzipInputAdapter implements InputStreamAdapter{\n public InputStream adapt(InputStream is, ClientResponse response) {\n String header = response.getHeaders().getFirst(\"Content-Encoding\");\n if (header != null && header.equalsIgnoreCase(\"gzip\")) {\n return new GZIPInputStream(is);\n }\n return is;\n }\n}\n```\n\nExplanation\n\nThe Gzip input stream adapter is responsible for wrapping the input stream with the Gzip input stream.\nGzip Output Stream Adapter\n\nThe following code snippet is an example of an implementation of a Gzip output stream adapter.\n\n```java\nclass GzipOutputAdapter implements OutputStreamAdapter {\n public OutputStream adapt(OutputStream os, ClientRequest request) {\n request.getHeaders().add(\"Content-Encoding\", \"gzip\");\n return new GZIPOutputStream(os);\n }\n}\n```\n\nExplanation\n\nThe Gzip output stream adapter is responsible for wrapping the output stream with the Gzip output stream.\n7 Apache Wink Representations\n\nIn addition to the JAX-RS standard representations Apache Wink provides an expanded set of representations that can be used by an application to expose resources in a rich set of representations. The following section provides information about the representations that are supported by Apache Wink.\n\n## Contents\n\n- 7.1 Json\n- 7.2 APP\n- 7.3 Atom\n- 7.4 RSS\n- 7.5 HTML\n- 7.6 CSV\n- 7.7 OpenSearch\n- 7.8 MultiPart\n\n## Apache Wink Representations Request Flow\n\nThe following diagram illustrates the client request flow for a resource.\n\nA resource is an abstract entity and as such can not be transmitted between peers. When a client is required to send or receive a resource it must use a representation of that resource. The resource representation is a specific formatting of the resource data. The diagram illustrates that a request for a resource is in fact a request for a specific representation of that resource.\n\nApache Wink implements resource representations through the use of providers for java objects as defined by the JAX-RS specification.\nApache Wink Providers\n\nIn addition to JAX-RS standard providers (refer to section 4.2 of the JAX-RS specification), Apache Wink provides a set of complementary providers. The purpose of these providers is to provide mapping services between various representations for example Atom, APP, OpenSearch, CSV, JSON and HTML, and their associated Java data models.\n\nThe Apache Wink providers are pre-registered and delivered with the Apache Wink runtime along with the JAX-RS standard providers.\n\nApache Wink provides an additional method for defining the life cycle of a provider via the use of the @Scope annotation and a way to define the providers priorities.\n\nScoping\n\nThe JAX-RS specification defines by default, that a singleton instance of each provider class is instantiated for each JAX-RS application. Apache Wink fully supports this requirement and in addition provides a \"Prototype\" lifecycle, which is an instance per-request lifecycle.\n\nPrototype means that a new instance of a provider class is instantiated for each request. The @Scope annotation (section #0) is used on a provider class to specify its lifecycle. The lifecycle of a provider that does not specify the @Scope annotation defaults to the singleton lifecycle.\n\nPrototype Example\n\nThe following example shows how to define a provider with a prototype lifecycle.\n\n```java\n@Scope(ScopeType.PROTOTYPE)\n@Provider\npublic class MyProvider implements MessageBodyReader<String> {\n ...\n}\n```\n\nSingleton Example 1\n\nThe following example shows how to define a provider with a singleton lifecycle.\n\n```java\n@Scope(ScopeType.SINGELTON)\n@Provider\npublic class MyProvider implements MessageBodyReader<String> {\n ...\n}\n```\n\nSingleton Example 2\n\nThe following example shows that when the @Scope annotation is not used, the provider will be a singleton, as per the JAX-RS specification.\n\n```java\n@Provider\npublic class MyProvider implements MessageBodyReader<String> {\n ...\n}\n```\n**Priority**\n\nApache Wink provides a method for setting a priority for a provider.\n\n---\n\n**Reference**\n\nFor more information on Provider Priorities refer to section 5.1 Registration and Configuration.\n7.1 JSON\n\nThis page last changed on Oct 13, 2009 by michael.\n\nJSON Providers\n\nApache Wink provides a set providers that are capable of serializing a number of data models into JSON representations. There are currently 3 Apache Wink extensions that provide JSON support. Each has unique features that may make one more suitable for your particular application.\n\nwink-json-provider (org.json)\n\nThe wink-json-provider extension is provided in the binary distribution and uses the JSON.org classes to provide JSON support. Include the wink-json-provider-<VERSION>.jar in the classpath and the providers will automatically be registered. You will also need the org.json JAR which is provided in the ext/wink-json-provider/lib folder.\n\n**org.apache.wink.providers.json.JsonProvider**\n\nHandles reading and writing of org.json.JSONObject classes for the application/json and application/javascript media types.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Entity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>application/json ,</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>application/javascript</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/json ,</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>application/javascript</td>\n</tr>\n</tbody>\n</table>\n\n**org.apache.wink.providers.json.JsonArrayProvider**\n\nHandles reading and writing of org.json.JSONArray classes for the application/json and application/javascript media types.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Entity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>application/json ,</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>application/javascript</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/json ,</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>application/javascript</td>\n</tr>\n</tbody>\n</table>\n\n**org.apache.wink.providers.json.JsonJAXBProvider**\n\nHandles reading and writing of JAXBElement and JAXB annotated classes for the application/json and application/javascript media types.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Entity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>application/json ,</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>application/javascript</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/json ,</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>application/javascript</td>\n</tr>\n</tbody>\n</table>\nProducing and Consuming JSON Example\n\nThe following example demonstrates the usage of a JSON provider for reading and writing JSON representations.\n\n```java\n@GET\n@Consumes(MediaType.APPLICATION_JSON)\n@Produces(MediaType.APPLICATION_JSON)\npublic JSONObject postJSON(JSONObject requestJSON) {\n String property = requestJSON.getString(\"property\");\n JSONObject job = new JSONObject();\n return job;\n}\n\n/* Book is a JAXB annotated class */\n\n@GET\n@Consumes(MediaType.APPLICATION_JSON)\n@Produces(MediaType.APPLICATION_JSON)\npublic Book postJSONBook(Book requestBookEntity) {\n String title = requestBookEntity.getTitle();\n /* other code */\n Book response = new Book();\n return response;\n}\n```\n\nwink-jettison-provider (org.codehaus.jettison)\n\nThe wink-jettison-provider extension is provided in the binary distribution and uses the Jettison code to provide JSON support. Include the wink-jettison-provider-<VERSION>.jar in the classpath and the providers will automatically be registered. You will also need the Jettison library JARs which are provided in the ext/wink-jettison-provider/lib folder.\n\nBy default, reading is currently disabled due to potential issues with the reader. You can enable it by calling setUseAsReader(boolean) on each provider and registering as a singleton in the JAX-RS Application sub-class.\n\norg.apache.wink.providers.jettison.JettisonJAXBElementProvider\n\nHandles reading and writing of JAXBElement classes for the application/json media type.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Entity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>application/json</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/json</td>\n</tr>\n</tbody>\n</table>\n\norg.apache.wink.providers.jettison.JettisonJAXBElementProvider\n\nHandles reading and writing of JAXB annotated classes for the application/json media type.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Entity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>application/json</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/json</td>\n</tr>\n</tbody>\n</table>\nExample\n\nThe following examples demonstrate the usage of a Jettison provider for producing and consuming JSON.\n\nJettison Provider Registration\n\nThe following code example demonstrates the way to register a Jettison provider within a JAX-RS application.\n\n```java\npublic class MyApp extends Application {\n public Set getClasses() {\n Set s = new HashSet();\n s.add(MyResource.class);\n return s;\n }\n\n public Set<Object> getSingletons() {\n Set s = new HashSet();\n JettisonJAXBProvider jaxbProvider = new JettisonJAXBProvider();\n jaxbProvider.setUseAsReader(true);\n return s;\n }\n}\n```\n\nProducing and Consuming JSON\n\nThe following code example demonstrates the reading and writing of JAXB objects into a JSON representation by using a Jettison provider.\n\n```java\n/* Book is a JAXB annotated class */\n\n@GET\n@Consumes(MediaType.APPLICATION_JSON)\n@Produces(MediaType.APPLICATION_JSON)\npublic Book postJSONBook(Book requestBookEntity) {\n String title = requestBookEntity.getTitle();\n /* other code */\n Book response = new Book();\n return response;\n}\n```\n\nJackson JSON Processor\n\nJackson JSON Processor may also suit your needs and can be used. They provide their own JAX-RS entity provider. See their documentation for more information.\nAtom Publishing Protocol (AtomPub) Overview\n\nThe Atom Publishing Protocol (AtomPub) is an application-level protocol for publishing and editing Web resources. The protocol is based on HTTP transport of Atom-formatted representations. The Atom format is documented in the Atom Syndication Format.\n\nData Model\n\nApache Wink provides an Atom Publishing Protocol data model for producing Service Documents (application/atomsvc+xml) and Categories Documents (application/atomcat+xml). All of the model classes are located under the org.apache.wink.common.model.app package.\n\nImportant Note\n\nThe APP data model can also be used to produce Service and Categories documents in HTML (text/html) and JSON (application/json) formats. For more details regarding HTML see section HTML (TBD). For JSON format see section (TBD)\n\nAPP Service Document Support\n\nThe following table shows the APP service document data models and the representations in which it can be serialized and de-serialized.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data Model</th>\n<th>Provider Registration</th>\n</tr>\n</thead>\n</table>\n| Read | Yes | application/atomsvc+xml | org.apache.wink.common.model.app.AppService\n| | | | Not required.\n| | | | Registered by default |\n| Write | Yes | application/atomsvc+xml | org.apache.wink.common.model.app.AppService\n| | | | Not required.\n| | | | Registered by default |\n\nAPP Categories Document Support\n\nThe following table shows the APP Catagories document data models and the representations in which it can be serialized and de-serialized.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data Model</th>\n<th>Provider Registration</th>\n</tr>\n</thead>\n</table>\n| Read | Yes | application/atomcat+xml | org.apache.wink.common.model.app.AppCategories\n| | | | Not required.\n| | | | Registered by default |\n| Write | Yes | application/atomcat+xml | org.apache.wink.common.model.app.AppCategories\n| | | | Not required.\n| | | | Registered by default |\n\nProducing an APP Service Document Example\n\nThe following code example demonstrates the creation of an APP Service Document.\n@GET\n@Produces(MediaTypeUtils.ATOM_SERVICEDOCUMENT)\npublic AppService getServiceDocument() {\n AppService serviceDocument = new AppService();\n List<AppWorkspace> workspaces = serviceDocument.getWorkspace();\n AppWorkspace workspace1 = new AppWorkspace();\n workspace1.setTitle(new AtomText(\"Workspace1\"));\n List<AppCollection> collections = workspace1.getCollection();\n AppCollection collection = new AppCollection();\n collection.setTitle(new AtomText(\"Collection1\"));\n collections.add(collection);\n workspaces.add(workspace1);\n ...\n return serviceDocument;\n}\n\nExplanation\n\nAppService class is JAXB annotated POJO. An instance of an AppService class is created, populated and returned by the resource. A generic JAXB provider is used to serializes this class into an XML representation.\n7.3 Atom\n\nAtom Syndication Format Overview\n\nAtom is an XML-based document format that describes lists of related information known as \"feeds\". Feeds are composed of a number of items, known as \"entries\", each with an extensible set of attached metadata. For example, each entry has a title. The primary use case that Atom addresses is the syndication of Web content such as weblogs and news headlines to Web sites as well as directly to user agents.\n\nData Model\n\nApache Wink provides an Atom Syndication Format data model for consuming and producing Atom Feeds and Atom Entries (application/atom+xml). All of the model classes are located under the org.apache.wink.common.model.atom and org.apache.wink.common.model.synd packages.\n\nImportant Note\n\nThe Atom Syndication Format data model can also be used to produce Atom Feeds and Atom Entries in HTML (text/html) and JSON (application/json) formats. For more details regarding HTML see section HTML (TBD). For JSON format see section (TBD).\n\nAtom Feed Support\n\nThe following table shows the Atom Feed data models and the representations in which it can be serialized and de-serialized.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data Model</th>\n<th>Provider registration</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>application/atom+xml</td>\n<td>org.apache.wink.common.model.atom.AtomFeed, org.apache.wink.common.model.synd.SyndFeed</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/atom+xml</td>\n<td>org.apache.wink.common.model.atom.AtomFeed, org.apache.wink.common.model.synd.SyndFeed</td>\n</tr>\n</tbody>\n</table>\n\nAtom Entry Support\n\nThe following table shows the Atom Entry data models and the representations in which it can be serialized and de-serialized.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data Model</th>\n<th>Provider registration</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>application/atom+xml</td>\n<td>org.apache.wink.common.model.atom.AtomEntry, org.apache.wink.common.model.synd.SyndEntry</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/atom+xml</td>\n<td>org.apache.wink.common.model.atom.AtomEntry</td>\n</tr>\n</tbody>\n</table>\n\n**Examples**\n\nThe following code example demonstrates reading and writing of Atom Feeds and Atom Entries.\n\n**Producing Atom Feed**\n\nThe following code example demonstrates the creation of an Atom Feed.\n\n```java\n@GET\n@Produces(MediaType.APPLICATION_ATOM_XML)\npublic AtomFeed getFeed() {\n AtomFeed feed = new AtomFeed();\n feed.setId(\"http://example.com/atomfeed\");\n feed.setTitle(new AtomText(\"Example\"));\n feed.setUpdated(new Date());\n AtomLink link1 = new AtomLink();\n ...\n return feed;\n}\n```\n\n**Consuming Atom Feed**\n\nThe following code example demonstrates the consumption of an Atom Feed.\n\n```java\n@POST\n@Consumes(MediaType.APPLICATION_ATOM_XML)\npublic void setFeed(AtomFeed feed) {\n ...\n return;\n}\n```\n\n**Producing Atom Entry**\n\nThe following code example demonstrates the creation of an Atom Entry.\n\n```java\n@GET\n@Produces(MediaType.APPLICATION_ATOM_XML)\npublic AtomEntry getEntry() {\n AtomEntry entry = new AtomEntry();\n entry.setId(\"http://example.com/entry\");\n entry.setTitle(new AtomText(\"Web Demo\"));\n entry.setUpdated(new Date());\n entry.setPublished(new Date());\n ...\n```\nConsuming Atom Entry\n\nThe following code example demonstrates the consumption of an Atom Entry.\n\n```java\n@POST\n@Consumes(MediaType.APPLICATION_ATOM_XML)\npublic void setEntry(AtomEntry entry) {\n ...\n return entry;\n}\n```\n7.4 RSS\n\nRSS Data Model\n\nRSS (Really Simple Syndication) is an XML-based document format for the syndication of web content such as weblogs and news headlines to Web sites as well as directly to user agents. Apache Wink supports the RSS 2.0 specification.\n\n(Really Simple Syndication) RSS Data Model Overview\n\nApache Wink provides an RSS data model for consuming and producing RSS Feeds (application/xml). All of the model classes are located under `org.apache.wink.common.model.rss` package.\n\nRSS Feed Support\n\nThe following table shows the RSS Feed data models and the representations in which it can be serialized and de-serialized.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data Model</th>\n<th>Provider registration</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>application/xml</td>\n<td>org.apache.wink.common.model.rss.RssFeed</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/xml</td>\n<td>org.apache.wink.common.model.rss.RssFeed</td>\n</tr>\n</tbody>\n</table>\n\nExamples\n\nThe following code example demonstrates reading and writing of RSS Feeds.\n\nProducing RSS Feed\n\nThe following code example demonstrates the creation of an RSS Feed.\n\n```java\npublic RssFeed getFeed() {\n RssFeed rss = new RssFeed();\n RssChannel channel = new RssChannel();\n channel.setTitle(\"Liftoff News\");\n channel.setLink(\"http://liftoff.msfc.nasa.gov\");\n channel.setDescription(\"Liftoff to Space Exploration.\");\n channel.setPubDate(new Date().toString());\n RssItem item = new RssItem();\n item.setTitle(\"Star City\");\n item.setDescription(\"How do Americans get ready to work with Russians aboard the International Space Station?\");\n channel.getItems().add(item);\n}\n```\nConsuming RSS Feed\n\nThe following code example demonstrates the consumption of an RSS Feed.\n\n```java\n@POST\n@Consumes(MediaType.APPLICATION_XML)\npublic void setFeed(RssFeed feed) {\n ...\n return;\n}\n```\n### 7.5 HTML\n\nThis page last changed on Oct 14, 2009 by michael.\n\n#### HTML\n\nApache Wink provides a set of providers that are capable of serializing a number of data models (SyndEntry and SyndFeed) as HTML.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data model</th>\n<th>Provider registration</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>No</td>\n<td>N/A</td>\n<td>N/A</td>\n</tr>\n</tbody>\n</table>\n\n#### Activating the HTML provider\n\nThe Apache Wink HTML providers are not enabled by default. In order to activate them they must be registered by the `HtmlSyndEntryProvider` and the `HtmlSyndFeedProvider` providers, located in the `org.apache.wink.server.internal.providers.entity.html` package.\n\nAs the HTML providers use a jsp in order to generate the representation the HtmlDefaultRepresentation folder must include all its content and subfolders available for the servlet container.\n\n#### Example\n\nDetailed example of the HTML implementation can be seen at the QADefect example.\nComma Separated Values (CSV) Providers\n\nApache Wink provides a CSV data model and providers for producing and consuming CSV (text/csv). The model is based on a Serialization and a Deserialization interface, in addition to a simple CSV Table class. All of the model classes are located under the org.apache.wink.common.model.csv package.\n\nThe following tables list the providers that provide this functionality.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data Model</th>\n<th>Provider registration</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>text/csv</td>\n<td>org.apache.wink .common.model .csv.CsvDeserializer org.apache.wink .common.model .csv.CsvTable org.apache.wink .common.model .csv.MultiCsvTable</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>text/csv</td>\n<td>org.apache.wink .common.model .csv.CsvSerializer org.apache.wink .common.model .csv.CsvTable org.apache.wink .common.model .csv.MultiCsvTable</td>\n</tr>\n</tbody>\n</table>\n\nExamples\n\nThe following code example demonstrates the reading and writing of CSV documents.\n\n**Producing CSV**\n\nThe following code example demonstrates the creation of a CSV document.\n\n```java\n@GET\n@Produces(\"text/csv\")\npublic CsvTable getJohns() {\n CsvTable cvs = new CsvTable(\"Id\", \"First Name\", \"Last Name\", \"Email\");\n cvs.addRow(\"1\", \"John\", \"Kennedy\", \"john@Kennedy.org\");\n cvs.addRow(\"2\", \"John\", \"Lennon\", \"john@Lennon.org\");\n cvs.addRow(\"3\", \"John\", \"Malkovich\", \"john@malkovich.org\");\n cvs.addRow(\"4\", \"John\", \"McCain\", \"john@McCain.org\");\n return cvs;\n}\n```\n\n**Consuming CSV**\n\nThe following code example demonstrates the consumption of a CSV document.\n@POST\n@Consumes(\"text/csv\")\npublic void postCsv(CsvTable csv) {\n for (String[] row : csv.getRows()) {\n for(String cell: row) {\n System.out.print(cell + \" ,\");\n }\n System.out.print(\"\\n\");\n }\n}\n7.7 OpenSearch\n\nThis page last changed on Oct 14, 2009 by michael.\n\n**OpenSearch Overview**\n\nOpenSearch is a collection of simple formats for the sharing of search results. The OpenSearch description document format is used to describe a search engine that can be used by search client applications.\n\nThe OpenSearch response elements can be used to extend existing syndication formats, such as RSS and Atom, with the extra metadata needed to return search results. The OpenSearch document is associated with the “application/opensearchdescription+xml” mime type.\n\n**Note**\nFor more detailed information about Open Search, refers to the Open Search home page at [http://www.opensearch.org/Home](http://www.opensearch.org/Home)\n\n**Data Model**\n\nApache Wink provides an Open Search data model for producing Open Search Documents. All of the model classes are located under the org.apache.wink.common.model.opensearch package. OpenSearchDescription class is used by an application to build Open Search Description documents.\n\n**OpenSearch Support**\n\nThe following table shows the OpenSearch data model and representation in which it can be serialized and de-serialized.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data Model</th>\n<th>Provider registration</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>NA</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>Write</td>\n<td>Yes</td>\n<td>application/opensearchdescription+xml</td>\n<td>org.apache.wink.common.model.opensearch.OpenSearchDescription</td>\n</tr>\n</tbody>\n</table>\n\n**Producing an OpenSearch Document Example**\n\nThe following example demonstrates the creation of an OpenSearch document.\n\n```java\n@GET\n@Produces(MediaTypeUtils.OPENSEARCH)\npublic OpenSearchDescription getOpenSearch(@Context UriInfo info) {\n String baseUri = info.getAbsolutePath().toString();\n OpenSearchDescription openSearchDescription = new OpenSearchDescription();\n openSearchDescription.setShortName(\"Example search engine\");\n ... \n return openSearchDescription;\n}\n```\n7.8 MultiPart\n\nThis page last changed on Oct 14, 2009 by michael.\n\nMultiPart\n\nApache Wink provides a MultiPart data model and providers for producing and consuming multipart messages (multipart/*). All of the model classes are located under the org.apache.wink.common.model.multipart package distributed with the wink-common jar.\n\nThe data model can be used with the wink-server module or with the wink-client module.\n\n<table>\n<thead>\n<tr>\n<th>Supported</th>\n<th>Media Types</th>\n<th>Data Model</th>\n<th>Provider registration</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Read</td>\n<td>Yes</td>\n<td>multipart/*</td>\n<td>org.apache.wink .common.model .multipart.InMultiPart</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>not required. Registered by default</td>\n</tr>\n</tbody>\n</table>\n\n| Write | Yes | multipart/*| org.apache.wink .common.model .multipart.OutMultiPart |\n| | | | not required. Registered by default |\n\nSerialization and De-serialization\n\nThe serialization and de-serialization of a multipart message is performed by the multipart providers. The serialization and de-serialization of the parts that make up the multipart message is performed as if each part is a separate message and in accordance with the JAX-RS specification. This means that every part is serialized and de-serialized using the appropriate provider that matches the binding class and content media type of that specific part.\n\nMain Classes\n\nThe multipart data model is comprised of the following main classes:\n\n- **InMultiPart** - is used for de-serialization of an incoming multipart message.\n- **InPart** - represents a single part contained in an incoming multipart message.\n- **OutMultiPart** - is used for serialization of an outgoing multipart message.\n- **OutPart** - represents a single part contained in an outgoing multipart message.\n\nStreaming Multipart\n\nThe base multipart classes are designed to handle multipart messages without buffering the data in order to avoid possible memory issues. This means that the data is accessible only once by the use of an iterator.\nBuffering Multipart\n\nThe BufferedInMultiPart and BufferedOutMultiPart classes are used to handle multipart messages where the complete message is buffered in the memory, allowing random and multiple access of the data. These classes are suitable for situations where the multipart message is small.\n\nExamples\n\nThe following examples illustrate the usage of the multipart data model.\n\nMultipart Consumption\n\nThe following example illustrates the usage of a streaming multipart message.\n\n```java\n@Path(\"files\")\n@POST\n@Consumes(MediaTypeUtils.MULTIPART_FORM_DATA)\npublic String uploadFiles(InMultiPart inMP) throws IOException {\n while (inMP.hasNext()) {\n InPart part = inMP.next();\n MultivaluedMap<String, String> heades = part.getHeaders();\n String CDHeader = heades.getFirst(\"Content-Disposition\");\n InputStream is = part.getBody(InputStream.class, null);\n // use the input stream to read the part body\n }\n}\n```\n\n* Detailed example of the MultiPart implementation can be seen at the MultiPart example.\n\nBuffered Multipart Consumption\n\nThe following example illustrates the usage of a buffering multipart message.\n\n```java\n@Path(\"users\")\n@POST\n@Consumes(\"multipart/mixed\")\npublic BufferedOutMultiPart addUser(BufferedInMultiPart inMP) throws IOException {\n List<InPart> parts = inMP.getParts();\n for (InPart p : parts) {\n User u = p.getBody(User.class, null);\n // use the user object retrieved from the part body\n }\n}\n```\n\n* Detailed example of the MultiPart implementation can be seen at the MultiPart example.\nMigration from Apache Abdera to Apache Wink\n\nApache Wink is an excellent solution for consuming and producing Atom, APP and RSS documents. The following section describes how to migrate from Apache Abdera to Apache Wink by providing a set of examples that cover most use cases.\n\nAdvantages of Apache Wink over Apache Abdera\n\n- Standardized APIs (using JAX-RS and JAXB)\n- Support for handling XML and JSON more easily\n- Support for handling RSS and ATOM more easily\n\nThis section contains the following topics:\n\n- 1) Consuming Atom Documents\n- 2) a) Producing Atom Documents\n- 2) b) Producing Atom Documents - the JAX-RS way\n- 3) Consuming RSS Documents\n- 4) Producing RSS Documents\n- 5) Writing Atom Publishing Protocol (APP) Server\n- 6) Writing Atom Publishing Protocol (APP) Client\n\n1) Consuming Atom Documents\n\nThe following code example demonstrates the consumption of Atom documents using Apache Abdera.\n\n```java\nAbdera abdera = new Abdera();\nParser parser = abdera.getParser();\nURL url = new URL(\"http://alexharden.org/blog/atom.xml\");\nDocument<Feed> doc = parser.parse(url.openStream());\nFeed feed = doc.getRoot();\nSystem.out.println(feed.getTitle());\nfor (Entry entry : feed.getEntries()) {\n System.out.println(\"\\t\" + entry.getTitle());\n}\n```\n\nThe following code example demonstrates the consumption of Atom documents using Apache Wink.\n\n```java\nRestClient client = new RestClient();\nResource resource = client.resource(\"http://alexharden.org/blog/atom.xml\");\nAtomFeed feed = resource.accept(MediaType.APPLICATION_ATOM_XML).get(AtomFeed.class);\n```\n2) a) Producing Atom Documents\n\nThe following code example demonstrates the production of Atom documents using Apache Abdera.\n\nApache Abdera - Click on links to Download - ProduceAtomUsingAbdera.java\nProduceAtomUsingAbdera_web.xml\n\n```java\nprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {\n Abdera abdera = new Abdera();\n Feed feed = abdera.newFeed();\n\n feed.setId(\"tag:example.org,2007:/foo\");\n feed.setTitle(\"Test Feed\");\n feed.setSubtitle(\"Feed subtitle\");\n feed.setUpdated(new Date());\n feed.addAuthor(\"Shiva HR\");\n feed.addLink(\"http://example.com\");\n feed.addLink(\"http://example.com/foo\", \"self\");\n\n Entry entry = feed.addEntry();\n entry.setId(\"tag:example.org,2007:/foo/entries/1\");\n entry.setTitle(\"Entry title\");\n entry.setSummaryAsHtml(\"<p>This is the entry title</p>\");\n entry.setUpdated(new Date());\n entry.setPublished(new Date());\n entry.addLink(\"http://example.com/foo/entries/1\");\n\n feed.getDocument().writeTo(response.getWriter());\n}\n```\n\nThe following code example demonstrates the production of Atom documents using Apache Wink.\n\nApache Wink - Click on links to Download - ProduceAtomUsingWink.java\nProduceAtomUsingWink_web.xml\n\n```java\nprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {\n AtomFeed feed = new AtomFeed();\n feed.setId(\"tag:example.org,2007:/foo\");\n feed.setTitle(new AtomText(\"Test Feed\"));\n feed.setSubtitle(new AtomText(\"Feed subtitle\"));\n feed.setUpdated(new Date());\n\n AtomPerson person = new AtomPerson();\n person.setName(\"Shiva HR\");\n```\n2) b) Producing Atom Documents - the JAX-RS way\n\nA more elegant way of producing Atom documents using Apache Wink is the JAX-RS way as described below:\n\n1. Open the Eclipse development environment and create a \"Dynamic Web Project\".\n2. Add Apache Wink & its dependent JARs under Java EE Module Dependencies.\n3. Create a POJO class and a method that creates Atom feed document. Annotate the class & its methods with the required JAX-RS annotations as below:\n\n ProduceAtom.java\n\n4. Add org.apache.wink.server.internal.servlet.RestServlet into web.xml and specify the path of above Resource class in it's init-param.\n\n See ProduceAtomWinkElegant_web.xml and application\n\n5. Deploy the web-application and access it using the url http://localhost:8080/ProduceAtom_Wink_Elegant/rest/getAtom\n\n6. Final WAR -> ProduceAtom_Wink_Elegant.zip (add Wink & its dependent JARs under ProduceAtom_Wink_Elegant\\WEB-INF\\lib and re-zip it as WAR).\n\n3) Consuming RSS Documents\n\nThe following code example demonstrates the consuming of RSS documents using Apache Abdera.\n\nApache Abdera - Click on link to Download - ConsumeRssUsingAbdera.java\n```java\npublic static void main(String[] args) throws ParseException, IOException {\n System.out.println(\"Consuming RSS Documents using Abdera...\\n\");\n Abdera abdera = new Abdera();\n Parser parser = abdera.getParser();\n URL url = new URL(\"http://www.rssboard.org/files/sample-rss-2.xml\");\n Document<RssFeed> doc = parser.parse(url.openStream());\n RssFeed rssFeed = doc.getRoot();\n System.out.println(\"Title: \" + rssFeed.getTitle());\n System.out.println(\"Description: \" + rssFeed.getSubtitle() + \"\\n\");\n int itemCount = 0;\n for (Entry entry : rssFeed.getEntries()) {\n System.out.println(\"Item \" + ++itemCount + \":\");\n System.out.println(\"\\tTitle: \" + entry.getTitle());\n System.out.println(\"\\tPublish Date: \" + entry.getPublished());\n System.out.println(\"\\tDescription: \" + entry.getContent());\n }\n}\n```\n\nThe following code example demonstrates the consuming of RSS documents using Apache Wink.\n\n```java\nApache Wink - Click on link to Download - ConsumeRssUsingWink.java\n```\n\n```java\npublic static void main(String[] args) {\n System.out.println(\"Consuming RSS Documents using Apache Wink...\");\n RestClient client = new RestClient();\n Resource resource = client.resource(url);\n RssFeed rss = resource.accept(MediaType.APPLICATION_XML).get(RssFeed.class);\n RssChannel channel = rss.getChannel();\n System.out.println(\"Title: \" + channel.getTitle());\n System.out.println(\"Description: \" + channel.getDescription() + \"\\n\");\n int itemCount = 0;\n for (RssItem item : channel.getItems()) {\n System.out.println(\"Item \" + ++itemCount + \":\");\n System.out.println(\"\\tTitle: \" + item.getTitle());\n System.out.println(\"\\tPublish Date: \" + item.getPubDate());\n System.out.println(\"\\tDescription: \" + item.getDescription());\n }\n}\n```\n\n4) Producing RSS Documents\n\n**Apache Abdera**\n\nApache Abdera version 0.4 does not support RSS write.\n\n**Apache Wink**\n\nSame as in 2) b) Producing Atom Documents - the JAX-RS way. However the resource method now returns an RssFeed object instead of AtomFeed object.\nApache Wink - Click on link to Download - ProduceRss_Wink_Elegant.zip\n\n```java\n@Path(\"/getRss\")\npublic class ProduceRss {\n @GET\n @Produces(MediaType.APPLICATION_XML)\n public Rss getRss() {\n RssFeed rss = new RssFeed();\n\n RssChannel channel = new RssChannel();\n channel.setTitle(\"Liftoff News\");\n channel.setLink(\"http://liftoff.msfc.nasa.gov\");\n channel.setDescription(\"Liftoff to Space Exploration.\");\n channel.setPubDate(new Date().toString());\n\n RssItem item = new RssItem();\n item.setTitle(\"Star City\");\n item.setDescription(\"How do Americans get ready to work with Russians aboard the International Space Station?\");\n\n channel.addItem(item);\n rss.setChannel(channel);\n\n return rss;\n }\n}\n```\n\n5) Writing Atom Publishing Protocol (APP) Server\n\nIn order to write and publish an APP server using Apache Abdera and Apache Wink perform the following steps:\n\nThe following scenario explains how to Implement an APP server as described in the following beautiful article by James Snell: http://www.ibm.com/developerworks/library/x-atompp1/\n\nApache Abdera\n\n1. Open the Eclipse development environment and create a \"Dynamic Web Project\".\n2. Add Apache Abdera & its dependent JARs under Java EE Module Dependencies.\n3. Add the following CollectionAdapter and Provider classes under src/myPackage directory:\n ```java\n APP_CollectionAdapter.java\n APP_ContentProvider.java\n ```\n4. Add org.apache.abdera.protocol.server.servlet.AbderaServlet into web.xml and point the following init parameters to the classes added above.\n ```java\n org.apache.abdera.protocol.server.Provider\n org.apache.abdera.protocol.server.CollectionAdapter\n ```\n5. Add the following index.jsp which has help on how to perform the APP operations:\n ```java\n APP_Server_Abdera_index.jsp\n ```\n6. Deploy and run the application.\n\n Final WAR -> APP_Server_Abdera.zip (add Apache Abdera & its dependent JARs under APP_Server_Abdera\\WEB-INF\\lib and re-rip it as WAR).\n\nApache Wink\n\n1. Open the Eclipse development environment and create a \"Dynamic Web Project\".\n2. Add Apache Wink & its dependent JARs under Java EE Module Dependencies.\n3. Add the following Resource class under src/myPackage directory: EntriesCollection.java\n4. Add org.apache.wink.server.internal.servlet.RestServlet into web.xml and specify the path of above Resource class in it's init-param. APP_Server_Wink_web.xml APP_Server_Wink_application\n5. Add the following index.jsp which has help on how to perform the APP operations: APP_Server_Wink_index.jsp\n6. Deploy and run the application.\n\nFinal WAR -> APP_Server_Wink.zip (add Apache Wink & its dependent JARs under APP_Server_Wink \\WEB-INF\\lib and re-riot it as WAR)\n\nReferences\n\n\n6) Writing Atom Publishing Protocol (APP) Client\n\nIn order to write an Atom Publishing Protocol refer to the following examples.\n\nImportant Note\nMake sure that the APP_Server_Abdera.war and the APP_Server_Wink.war provided in the previous example are deployed before running this example.\n\nApache Abdera - Click on link to Download - APP_Client_Abdera.java\n\n1. Accessing Service Document:\n\n```java\nDocument<Service> introspection = abderaClient.get(SERVICE_URL).getDocument();\nService service = introspection.getRoot();\nList<Workspace> workspaces = service.getWorkspaces();\nfor (Workspace workspace : workspaces) {\n System.out.println(\"workspace.getTitle() + workspace.getTitle() + workspace.getHref());\n for (Collection collection : workspace.getCollections()) {\n System.out.println(\"collection.getTitle() + collection.getHref() + collection.getHref());\n }\n}\n```\n\n2. Getting a Feed\n\n```java\nRequestOptions opts = new RequestOptions();\nopts.setContentType(\"application/atom+xml;type=feed\");\nClientResponse response = abderaClient.get(FEED_URL, opts);\nFeed feed = (Feed)response.getDocument().getRoot();\n```\n### 3. Posting an entry to a Feed\n\n```java\nRequestOptions opts = new RequestOptions();\nopts.setContentType(\"application/atom+xml;type=entry\");\nClientResponse response = abderaClient.post(FEED_URL, newEntry, opts);\n```\n\n### 4. Putting a change to an Entry\n\n```java\nRequestOptions opts = new RequestOptions();\nopts.setContentType(\"application/atom+xml;type=entry\");\nClientResponse response = abderaClient.put(ENTRY_URL, changedEntry.getDocument(), opts);\n```\n\n### 5. Getting an Entry\n\n```java\nRequestOptions opts = new RequestOptions();\nopts.setContentType(\"application/atom+xml;type=entry\");\nClientResponse response = abderaClient.get(ENTRY_URL, opts);\nEntry entry = (Entry)response.getDocument().getRoot();\n```\n\n### 6. Deleting an Entry\n\n```java\nClientResponse response = abderaClient.delete(ENTRY_URL);\n```\n\n### Apache Wink - Click on link to Download - APP_Client_Wink.java\n\n#### 1. Acessing Service Document:\n\n```java\nResource resource = restClient.resource(SERVICE_URL);\nAppService service = resource.accept(MediaTypeUtils.ATOM_SERVICE_DOCUMENT).get(AppService.class);\nList<AppWorkspace> workspaces = service.getWorkspace();\nfor (AppWorkspace workspace : workspaces) {\n System.out.println(\"\\t\" + workspace.getTitle().getValue());\n List<AppCollection> collections = workspace.getCollection();\n for (AppCollection collection : collections) {\n System.out.println(\"\\t\\t\" + collection.getTitle().getValue()\n + \"\\t\\t\" + collection.getHref());\n }\n System.out.println(\"\\n\");\n}\n```\n\n#### 2. Getting a Feed\n3. Posting an entry to a Feed\n\n```java\nResource feedResource = restClient.resource(FEED_URL);\nAtomFeed feed = feedResource.accept(MediaType.APPLICATION_ATOM_XML).get(AtomFeed.class);\n```\n\n4. Putting a change to an Entry\n\n```java\nResource feedResource = restClient.resource(ENTRY_URL);\nClientResponse response =\n feedResource.contentType(MediaType.APPLICATION_ATOM_XML).put(changedEntry);\n```\n\n5. Getting an Entry\n\n```java\nResource feedResource = restClient.resource(ENTRY_URL);\nAtomEntry atomEntry = feedResource.accept(MediaType.APPLICATION_ATOM_XML).get(AtomEntry.class);\n```\n\n6. Deleting an Entry\n\n```java\nResource feedResource = restClient.resource(ENTRY_URL);\nClientResponse response = feedResource.delete();\n```\nAppendix B - Google App Engine\n\nThis page last changed on Oct 14, 2009 by michael.\n\nGoogle App Engine\n\nApache Wink can be run using Google App Engine as the core functionality is fully compatible. However, due to some of the App Engine limitations, a number of the additional functions may not work correctly.\n\nKnown Limitations\n\nJAXB - Google App Engine doesn't support JAXB. Therefore, the built-in JAXB, Atom and JSON providers will not work.\n\nLogging\n\nGoogle uses java.util.logging, also referred to as the JDK 1.4 logging. Apache Wink uses slf4j. In order to enable Wink's logging function, replace the slf4j-simple-<version>.jar with the slf4j-jdk14-<version>.jar.\n\nIn order to view all of Wink's messages place the following property in the logging.properties file:\n\n```\norg.apache.wink.level=ALL\n```\n\nEverything that the servlet writes to the standard output stream (System.out) and standard error stream (System.err) is captured by the App Engine and then recorded in the application logs.\n\nUseful Tip\n\nIn order to gain an in depth understanding refer to Logging.\n\nWhen running with Spring, make sure that you have jcl-over-slf4j-<version>.jar in the classpath. This jar is needed, since Spring uses commons-logging.\n\nAdditional Issues\n\nThe following section contains \"Additional Issues\" that maybe experience while trying to run custom developer code in the Google App Engine. It is advantageous to read the relevant documentation as it provides important information, that will save valuable developer time that is required to ascertain why the application behaves differently in comparison to a regular servlet container.\n\nContext Path\n\nUsually the URI in a servlet container looks like this:\n\n```\nrequestURI = contextPath + servletPath + pathInfo\n```\n\nwhile in most servlet containers context path is a war name (or it can be configured), in App Engine it's just empty.\n\nSo if your servlet is mapped to \"rest\", access\n\n```\nhttp://host:port/rest\n```\n\nReferences\n\n- App Engine Java Overview\n- Will it play in App Engine"}}},{"rowIdx":155,"cells":{"id":{"kind":"string","value":"2009e8e2772dcdb40ff6a98aab9da8caefde7833"},"text":{"kind":"string","value":"Package ‘rtables’\n\nMay 25, 2023\n\nTitle Reporting Tables\nVersion 0.6.1\nDate 2023-05-04\nDescription Reporting tables often have structure that goes beyond simple rectangular data. The ‘rtables’ package provides a framework for declaring complex multi-level tabulations and then applying them to data. This framework models both tabulation and the resulting tables as hierarchical, tree-like objects which support sibling sub-tables, arbitrary splitting or grouping of data in row and column dimensions, cells containing multiple values, and the concept of contextual summary computations. A convenient pipe-able interface is provided for declaring table layouts and the corresponding computations, and then applying them to data.\nLicense Apache License 2.0 | file LICENSE\nBugReports https://github.com/insightsengineering/rtables/issues\nDepends formatters (>= 0.5.0), magrittr, methods, R (>= 2.10)\nImports grid, htmltools, stats\nSuggests dplyr, flextable, knitr, officer, rmarkdown, survival, testthat, tibble, tidyr, xml2, r2rtf\nVignetteBuilder knitr\nEncoding UTF-8\nLanguage en-US\nRoxygenNote 7.2.3\nCollate '00tabletrees.R' 'Viewer.R' 'argument_conventions.R'\n'as_html.R' 'utils.R' 'colby_constructors.R'\n'compare_rtables.R' 'deprecated.R' 'format_rcell.R' 'indent.R'\n'make_subset_expr.R' 'simple_analysis.R' 'split_funs.R'\n'make_split_fun.R' 'summary.R' 'tree_accessors.R'\n'tt_afun_utils.R' 'tt_compare_tables.R' 'tt_compatibility.R'\nR topics documented:\n\n'tt_dotabulation.R' 'tt_paginate.R' 'tt_pos_and_access.R'\n'tt_showmethods.R' 'tt_sort.R' 'tt_test_afuns.R'\n'tt_toString.R' 'tt_export.R' 'index_footnotes.R'\n'tt_from_df.R' 'zzz_constants.R'\n\nNeedsCompilation no\n\nAuthor Gabriel Becker [aut, cre],\nAdrian Waddell [aut],\nDaniel Sabanés Bové [ctb],\nMaximilian Mordig [ctb],\nDavide Garolini [ctb]\n\nMaintainer Gabriel Becker <gabembecker@gmail.com>\n\nRepository CRAN\n\nDate/Publication 2023-05-25 16:50:02 UTC\n\nR topics documented:\n\nadd_colcounts ...................................................... 4\nadd_combo_facet .................................................... 5\nadd_existing_table .................................................. 6\nadd_overall_col ..................................................... 7\nadd_overall_level ................................................... 8\nall_zero_or_na ....................................................... 9\nanalyze .............................................................. 11\nAnalyzeVarSplit .................................................... 15\nanalyze_colvars ..................................................... 17\nappend_topleft ..................................................... 19\nasvec ............................................................... 20\nas_html .............................................................. 21\nbasic_table .......................................................... 22\nbrackets ............................................................. 23\nbuild_table .......................................................... 26\ncbind_rtables ......................................................... 28\nCellValue ............................................................ 29\ncell_values .......................................................... 30\nclayout ............................................................... 32\nclear_indent_mods .................................................... 34\ncollect_leaves ....................................................... 35\ncompare_rtables ....................................................... 36\ncompat_args .......................................................... 38\nconstr_args .......................................................... 39\ncontent_table ......................................................... 41\ncont_n_allcols ....................................................... 41\ncounts_wpcts .......................................................... 42\ncustom_split_funs .................................................... 43\ndf_to_tt .............................................................. 44\ndo_base_split ......................................................... 45\nR topics documented:\n\ndrop_facet_levels ......................................................... 46\nElementaryTable-class ................................................. 47\nEmptyColInfo ............................................................. 49\nexport_as_pdf ............................................................. 49\nexport_as_tsv ............................................................. 51\nformat_rcell ............................................................. 52\ngen_args ................................................................. 54\nget_formatted_cells ..................................................... 56\nhead ......................................................................... 57\nhorizontal_sep ........................................................... 58\nindent ...................................................................... 59\nindent_string ............................................................ 60\ninsert_row_at_path ...................................................... 61\ninsert_rrow ............................................................... 62\nInstantiatedColumnInfo-class ........................................... 63\nin_rows .................................................................... 64\nis_rtable ................................................................. 65\nLabelRow ................................................................. 66\nlabel_at_path ............................................................. 67\nlength,CellValue-method ............................................... 68\nlist_wrap_x ............................................................... 69\nlyt_args ................................................................. 70\nmake_afun ................................................................. 73\nmake_col_df .............................................................. 76\nmake_split_fun .......................................................... 77\nmake_split_result ....................................................... 79\nManualSplit ............................................................. 80\nmanual_cols ............................................................. 82\nmatrix_form,VTableTree-method ....................................... 83\nMultiVarSplit ........................................................... 84\nnames,VTableNodeInfo-method ......................................... 86\nno_colinfo ............................................................... 87\nnrow,VTableTree-method ................................................ 87\nobj_avar ................................................................. 88\nobj_name,VNodeInfo-method ........................................... 89\npag_tt_indices .......................................................... 94\npath_enriched_df ....................................................... 98\nprune_table ............................................................. 99\nrbindl_rtables .......................................................... 100\nrcell ...................................................................... 101\nrheader ................................................................. 103\nrow_footnotes ........................................................... 104\nrow_paths ............................................................... 105\nrow_paths_summary ..................................................... 106\nrrow ...................................................................... 107\nrrowl ........................................................ .......... 108\nrtable ................................................................. 109\nrtables_aligns .......................................................... 111\nadd_colcounts\n\nDescription\n\nAdd the data derived column counts.\n\nUsage\n\n```r\nadd_colcounts(lyt, format = \"(N=xx)\")\n```\n**add_combo_facet**\n\n**Arguments**\n\n- `lyt` layout object pre-data used for tabulation\n- `format` FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\n\n**Details**\n\nIt is often the case that the column counts derived from the input data to build_table is not representative of the population counts. For example, if events are counted in the table and the header should display the number of subjects and not the total number of events. In that case use the `col_count` argument in build_table to control the counts displayed in the table header.\n\n**Value**\n\nA `PreDataTableLayouts` object suitable for passing to further layouting functions, and to build_table.\n\n**Author(s)**\n\nGabriel Becker\n\n**Examples**\n\n```r\nlyt <- basic_table() %>% split_cols_by(\"ARM\") %>%\n add_colcounts() %>%\n split_rows_by(\"RACE\", split_fun = drop_split_levels) %>%\n analyze(\"AGE\", afun = function(x) list(min = min(x), max = max(x)))\nlyt\n\n.tbl <- build_table(lyt, DM)\n.tbl\n```\n\n---\n\n**add_combo_facet** \n*Add a combination facet in postprocessing*\n\n**Description**\n\nAdd a combination facet during postprocessing stage in a custom split fun.\n\n**Usage**\n\n```r\nadd_combo_facet(name, label = name, levels, extra = list())\nadd_overall_facet(name, label, extra = list())\n```\nadd_existing_table\n\nAdd an already calculated table to the layout\n\nArguments\n\nname character(1). Name for the resulting facet (for use in pathing, etc).\nlabel character(1). Label for the resulting facet.\nlevels character. Vector of levels to combine within the resulting facet.\nextra list. Extra arguments to be passed to analysis functions applied within the resulting facet.\n\nDetails\n\nFor add_combo_facet, the data associated with the resulting facet will be the data associated with the facets for each level in levels, rbound together. In particular, this means that if those levels are overlapping, data that appears in both will be duplicated.\n\nValue\n\na function which can be used within the post argument in make_split_fun.\n\nSee Also\n\nmake_split_fun\nOther make_custom_split: drop_facet_levels(). make_split_fun(). make_split_result(). trim_levels_in_facets()\n\nExamples\n\nmysplfun <- make_split_fun(post = list(add_combo_facet(\"A_B\", label = \"Arms A+B\", levels = c(\"A: Drug X\", \"B: Placebo\"): add_overall_facet(\"ALL\", label = \"All Arms\")))\n\nlyt <- basic_table(show_colcounts = TRUE) %>%\n split_cols_by(\"ARM\", split_fun = mysplfun) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\n**Add Overall Column**\n\nThis function will *only* add an overall column at the *top* level of splitting, NOT within existing column splits. See `add_overall_level` for the recommended way to add overall columns more generally within existing splits.\n\n**Usage**\n\n```r\nadd_overall_col(lyt, label)\n```\nArguments\n\n- `lyt` layout object pre-data used for tabulation\n- `label` character(1). A label (not to be confused with the name) for the object/structure.\n\nValue\n\nA `PreDataTableLayouts` object suitable for passing to further layouting functions, and to `build_table`.\n\nSee Also\n\n- `add_overall_level()`\n\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n add_overall_col(\"All Patients\") %>%\n analyze(\"AGE\")\n\nlyt\ntbl <- build_table(lyt, DM)\ntbl\n```\n\n---\n\n**add_overall_level** \nAdd an virtual 'overall' level to split\n\nDescription\n\nAdd an virtual 'overall' level to split\n\nUsage\n\n```r\nadd_overall_level(\n valname = \"Overall\",\n label = valname,\n extra_args = list(),\n first = TRUE,\n trim = FALSE\n)\n```\n\nArguments\n\n- `valname` character(1). 'Value' to be assigned to the implicit all-observations split level. Defaults to \"Overall\"\n- `label` character(1). A label (not to be confused with the name) for the object/structure.\nextra_args\n\nlist. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\n\nfirst\n\nlogical(1). Should the implicit level appear first (TRUE) or last FALSE. Defaults to TRUE.\n\ntrim\n\nlogical(1). Should splits corresponding with 0 observations be kept when tabulating.\n\nValue\n\nda closure suitable for use as a splitting function (splfun) when creating a table layout\n\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\", split_fun = add_overall_level(\"All Patients\", first = FALSE)) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\n\nlyt2 <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"RACE\", split_fun = add_overall_level(\"All Ethnicities\")) %>%\n summarize_row_groups(label_fstr = \"%s (n)\") %>%\n analyze(\"AGE\")\n\nTbl2 <- build_table(lyt2, DM)\n\nlyt2\n\nTbl2\n```\n\n---\n\n**all_zero_or_na**\n\nTrimming and Pruning Criteria\n\n**Description**\n\nCriteria functions (and constructors thereof) for trimming and pruning tables.\n\n**Usage**\n\n```r\nall_zero_or_na(tr)\nall_zero(tr)\n```\ncontent_all_zeros_nas(tt, criteria = all_zero_or_na)\n\nprune_empty_level(tt)\n\nprune_zeros_only(tt)\n\nlow_obs_pruner(min, type = c(\"sum\", \"mean\"))\n\nArguments\n\ntr TableRow (or related class). A TableRow object representing a single row within a populated table.\n\ntt TableTree (or related class). A TableTree object representing a populated table.\n\ncriteria function. Function which takes a TableRow object and returns TRUE if that row should be removed. Defaults to all_zero_or_na\n\nmin numeric(1). (low_obs_pruner only). Minimum aggregate count value. Subtables whose combined/average count are below this threshold will be pruned\n\ntype character(1). How count values should be aggregated. Must be \"sum\" (the default) or \"mean\"\n\nDetails\n\nall_zero_or_na returns TRUE (and thus indicates trimming/pruning) for any non-LabelRow TableRow which contain only any mix of NA (including NaN), 0, Inf and -Inf values.\n\nall_zero returns TRUE for any non-Label row which contains only (non-missing) zero values.\n\ncontent_all_zeros_nas Prunes a subtable if a) it has a content table with exactly one row in it, and b) all_zero_or_na returns TRUE for that single content row. In practice, when the default summary/content function is used, this represents pruning any subtable which corresponds to an empty set of the input data (e.g., because a factor variable was used in split_rows_by but not all levels were present in the data).\n\nprune_empty_level combines all_zero_or_na behavior for TableRow objects, content_all_zeros_nas on content_table(tt) for TableTree objects, and an additional check that returns TRUE if the tt has no children.\n\nprune_zeros_only behaves as prune_empty_level does, except that like all_zero it prunes only in the case of all non-missing zero values.\n\nlow_obs_pruner is a constructor function which, when called, returns a pruning criteria function which will prune on content rows by comparing sum or mean (dictated by type) of the count portions of the cell values (defined as the first value per cell regardless of how many values per cell there are) against min.\n\nValue\n\nA logical value indicating whether tr should be included (TRUE) or pruned (FALSE) during pruning.\nanalyze\n\nGenerate Rows Analyzing Variables Across Columns\n\nDescription\n\nAdding *analyzed variables* to our table layout defines the primary tabulation to be performed. We do this by adding calls to `analyze` and/or `analyze_colvars` into our layout pipeline. As with adding further splitting, the tabulation will occur at the current/next level of nesting by default.\n\nUsage\n\n```r\nanalyze( \n lyt, \n vars, \n afun = simple_analysis, \n```\n\nSee Also\n\n`prune_table()`, `trim_rows()`\n\nExamples\n\n```r\nadsl <- ex_adsl\nlevels(adsl$SEX) <- c(levels(ex_adsl$SEX), \"OTHER\")\nadsl$AGE[adsl$SEX == \"UNDIFFERENTIATED\"] <- 0\nadsl$BMRKR1 <- 0\n\ntbl_to_prune <- basic_table() %>% \n analyze(\"BMRKR1\") %>% \n split_cols_by(\"ARM\") %>% \n split_rows_by(\"SEX\") %>% \n summarize_row_groups() %>% \n split_rows_by(\"STRATA1\") %>% \n summarize_row_groups() %>% \n analyze(\"AGE\") %>% \n build_table(adsl)\n\ntbl_to_prune %>% prune_table(all_zero_or_na)\n\ntbl_to_prune %>% prune_table(all_zero)\n\ntbl_to_prune %>% prune_table(content_all_zeros_nas)\n\ntbl_to_prune %>% prune_table(prune_empty_level)\n\ntbl_to_prune %>% prune_table(prune_zeros_only)\n\nmin_prune <- low_obs_pruner(70, \"sum\")\ntbl_to_prune %>% prune_table(min_prune)\n```\n```r\nvar_labels = vars,\ntable_names = vars,\nformat = NULL,\nna_str = NA_character_,\nnested = TRUE,\ninclNAs = FALSE,\nextras = list(),\nshow_labels = c(\"default\", \"visible\", \"hidden\"),\nindent_mod = 0L,\nsection_div = NA_character_\n)\n```\n\n**Arguments**\n\n- **lyt**: layout object pre-data used for tabulation.\n- **vars**: character vector. Multiple variable names.\n- **afun**: function. Analysis function, must take x or df as its first parameter. Can optionally take other parameters which will be populated by the tabulation framework. See Details in `analyze`.\n- **var_labels**: character. Variable labels for 1 or more variables.\n- **table_names**: character. Names for the tables representing each atomic analysis. Defaults to var.\n- **format**: FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as `analyze` calls, they can character vectors or lists of functions.\n- **na_str**: character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\n- **nested**: boolean. Should this layout instruction be applied within the existing layout structure if possible (TRUE, the default) or as a new top-level element (FALSE). Ignored if it would nest a split underneath analyses, which is not allowed.\n- **inclNAs**: boolean. Should observations with NA in the var variable(s) be included when performing this analysis. Defaults to FALSE.\n- **extra_args**: list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\n- **show_labels**: character(1). Should the variable labels for corresponding to the variable(s) in vars be visible in the resulting table.\n- **indent_mod**: numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure's children. Defaults to 0, which corresponds to the unmodified default behavior.\n- **section_div**: character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\nanalyze\n\nDetails\n\nWhen non-NULL format is used to specify formats for all generated rows, and can be a character vector, a function, or a list of functions. It will be repped out to the number of rows once this is known during the tabulation process, but will be overridden by formats specified within rcell calls in afun.\n\nThe analysis function (afun) should take as its first parameter either x or df. Which of these the function accepts changes the behavior when tabulation is performed.\n\n- If afun’s first parameter is x, it will receive the corresponding subset vector of data from the relevant column (from var here) of the raw data being used to build the table.\n- If afun’s first parameter is df, it will receive the corresponding subset data.frame (i.e. all columns) of the raw data being tabulated\n\nIn addition to differentiation on the first argument, the analysis function can optionally accept a number of other parameters which, if and only if present in the formals will be passed to the function by the tabulation machinery. These are as follows:\n\n-.N_col column-wise N (column count) for the full column being tabulated within\n-.N_total overall N (all observation count, defined as sum of column counts) for the tabulation\n-.N_row row-wise N (row group count) for the group of observations being analyzed (ie with no column-based subsetting)\n-.df_row data.frame for observations in the row group being analyzed (ie with no column-based subsetting)\n-.var variable that is analyzed\n-.ref_group data.frame or vector of subset corresponding to the ref_group column including subsetting defined by row-splitting. Optional and only required/meaningful if a ref_group column has been defined\n-.ref_full data.frame or vector of subset corresponding to the ref_group column without subsetting defined by row-splitting. Optional and only required/meaningful if a ref_group column has been defined\n-.in_ref_col boolean indicates if calculation is done for cells within the reference column\n-.spl_context data.frame, each row gives information about a previous/’ancestor’ split state. see below\n\nValue\n\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\n\n.spl_context Details\n\nThe .spl_context data.frame gives information about the subsets of data corresponding to the splits within-which the current analyze action is nested. Taken together, these correspond to the path that the resulting (set of) rows the analysis function is creating, although the information is in a slightly different form. Each split (which correspond to groups of rows in the resulting table), as well as the initial ’root’ ”split”, is represented via the following columns:\nsplit The name of the split (often the variable being split in the simple case)\nvalue The string representation of the value at that split\nfull_parent_df a dataframe containing the full data (ie across all columns) corresponding to the\npath defined by the combination of split and value of this row and all rows above this row\nall_cols_n the number of observations corresponding to this row grouping (union of all columns)\n(row-split and analyze contexts only) <1 column for each column in the table structure These list\ncolumns (named the same as names(col_exprs(tab))) contain logical vectors correspond-\ning to the subset of this row’s full_parent_df corresponding to that column\ncur_col_subset List column containing logical vectors indicating the subset of that row’s full_parent_df\nfor the column currently being created by the analysis function\ncur_col_n integer column containing the observation counts for that split\n\nnote Within analysis functions that accept .spl_context, the all_cols_n and cur_col_n columns\nof the dataframe will contain the ‘true’ observation counts corresponding to the row-group and row-\ngroup by column subsets of the data. These numbers will not, and currently cannot, reflect alternate\ncolumn observation counts provided by the alt_counts_df, col_counts or col_total arguments\nto build_table\n\nNote\n\nNone of the arguments described in the Details section can be overridden via extra_args or when\ncalling make_afun. .N_col and .N_total can be overridden via the col_counts argument to\nbuild_table. Alternative values for the others must be calculated within afun based on a combi-\nnation of extra arguments and the unmodified values provided by the tabulation framework.\n\nAuthor(s)\n\nGabriel Becker\n\nExamples\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n analyze(\"AGE\", afun = list_wrap_x(summary), format = \"xx.xx\")\nlyt\n\ntbl <- build_table(lyt, DM)\ntbl\n\nlyt2 <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n analyze(head(names(iris), -1), afun = function(x) {\n list(\n \"mean / sd\" = rcell(c(mean(x), sd(x)), format = \"xx.xx (xx.xx)\"),\n \"range\" = rcell(diff(range(x)), format = \"xx.xx\")\n )\n })\nlyt2\nAnalyzeVarSplit\n\nDefine a subset tabulation/analysis\n\nDescription\nDefine a subset tabulation/analysis\n\nUsage\nAnalyzeVarSplit(\n var,\n split_label = var,\n afun,\n defrowlab = \"\",\n cfun = NULL,\n cformat = NULL,\n split_format = NULL,\n split_na_str = NA_character_,\n inclNAs = FALSE,\n split_name = var,\n extra_args = list(),\n indent_mod = 0L,\n label_pos = \"default\",\n cvar = \"\"\n)\n\nAnalyzeColVarSplit(\n afun,\n defrowlab = \"\",\n cfun = NULL,\n cformat = NULL,\n split_format = NULL,\n split_na_str = NA_character_,\n inclNAs = FALSE,\n split_name = \"\",\n extra_args = list(),\n indent_mod = 0L,\n label_pos = \"default\",\n cvar = \"\"\n)\nAnalyzeMultiVars(\n var,\n split_label = \"\",\n afun,\n defrowlab = \"\",\n cfun = NULL,\n cformat = NULL,\n split_format = NULL,\n split_na_str = NA_character_,\n inclNAs = FALSE,\n .payload = NULL,\n split_name = NULL,\n extra_args = list(),\n indent_mod = 0L,\n child_labels = c(\"default\", \"topleft\", \"visible\", \"hidden\"),\n child_names = var,\n cvar = \"\",\n section_div = NA_character_\n)\n\nArguments\n\nvar string, variable name\n\nsplit_label string. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).\n\nafun function. Analysis function, must take x or df as its first parameter. Can optionally take other parameters which will be populated by the tabulation framework. See Details in analyze.\n\ndefrowlab character. Default row labels if they are not specified by the return value of afun\n\ncfun list/function/NULL. tabulation function(s) for creating content rows. Must accept x or df as first parameter. Must accept labelstr as the second argument. Can optionally accept all optional arguments accepted by analysis functions. See analyze.\n\ncformat format spec. Format for content rows\n\nsplit_format FormatSpec. Default format associated with the split being created.\n\nsplit_na_str character. NA string vector for use with split_format.\n\ninclNAs boolean. Should observations with NA in the var variable(s) be included when performing this analysis. Defaults to FALSE\n\nsplit_name string. Name associated with this split (for pathing, etc)\n\nextra_args list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\nanalyze_colvars\n\n- **indent_mod**: numeric. Modifier for the default indent position for the structure created by this function (subtable, content table, or row) and all of that structure's children. Defaults to 0, which corresponds to the unmodified default behavior.\n\n- **label_pos**: character(1). Location the variable label should be displayed, Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\n\n- **cvar**: character(1). The variable, if any, which the content function should accept. Defaults to NA.\n\n- **.payload**: Used internally, not intended to be set by end users.\n\n- **child_labels**: string. One of \"default\", \"visible\", \"hidden\". What should the display behavior be for the labels (i.e., label rows) of the children of this split. Defaults to \"default\" which flags the label row as visible only if the child has 0 content rows.\n\n- **child_names**: character. Names to be given to the sub splits contained by a compound split (typically an AnalyzeMultiVars split object).\n\n- **section_div**: character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\n\n---\n\n**Value**\n\nAn AnalyzeVarSplit object.\n\nAn AnalyzeMultiVars split object.\n\n---\n\n**Author(s)**\n\nGabriel Becker\n\n---\n\n**analyze_colvars**\n\n*Generate Rows Analyzing Different Variables Across Columns*\n\n---\n\n**Description**\n\nGenerate Rows Analyzing Different Variables Across Columns\n\n---\n\n**Usage**\n\n```r\nanalyze_colvars(\n lyt,\n afun,\n format = NULL,\n nested = TRUE,\n extra_args = list(),\n indent_mod = 0L,\n inclNAs = FALSE\n)\n```\nArguments\n\n- **lyt**: layout object pre-data used for tabulation\n- **afun**: function or list. Function(s) to be used to calculate the values in each column. The list will be repped out as needed and matched by position with the columns during tabulation.\n- **format**: FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\n- **nested**: boolean. Should this layout instruction be applied within the existing layout structure if possible (TRUE, the default) or as a new top-level element (FALSE). Ignored if it would nest a split underneath analyses, which is not allowed.\n- **extra_args**: list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\n- **indent_mod**: numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure’s children. Defaults to 0, which corresponds to the unmodified default behavior.\n- **inclNAs**: boolean. Should observations with NA in the var variable(s) be included when performing this analysis. Defaults to FALSE\n\nValue\n\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\n\nAuthor(s)\n\nGabriel Becker\n\nSee Also\n\n- `split_cols_by_multivar()`\n\nExamples\n\n```r\nlibrary(dplyr)\nANL <- DM %>% mutate(value = rnorm(n()), pctdiff = runif(n()))\n\n## toy example where we take the mean of the first variable and the count of >.5 for the second.\ncolfuns <- list(function(x) rcell(mean(x), format = \"xx.x\"),\n function(x) rcell(sum(x > .5), format = \"xx\"))\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by_multivar(c(\"value\", \"pctdiff\")) %>%\n split_rows_by(\"RACE\", split_label = \"ethnicity\")\n```\nappend_topleft\n\n\\[\n\\text{split\\_fun} = \\text{drop\\_split\\_levels}) \\%>%\n\\text{summarize\\_row\\_groups()} \\%>%\n\\text{analyze\\_colvars(afun = colfuns)}\n\\]\n\n\\[\n\\text{lyt}\n\\]\n\n\\[\n\\text{tbl} \\leftarrow \\text{build\\_table(lyt, ANL)}\n\\]\n\n\\[\n\\text{tbl}\n\\]\n\n\\[\n\\text{lyt2} \\leftarrow \\text{basic\\_table()} \\%>%\n\\text{split\\_cols\\_by(\"ARM\")} \\%>%\n\\text{split\\_cols\\_by\\_multivar(c(\"value\", \"pctdiff\"),\n\\text{varlabels = c(\"Measurement\", \"Pct Diff\")})} \\%>%\n\\text{split\\_rows\\_by(\"RACE\", split\\_label = \"ethnicity\",\n\\text{split\\_fun = drop\\_split\\_levels})} \\%>%\n\\text{summarize\\_row\\_groups()} \\%>%\n\\text{analyze\\_colvars(afun = mean, format = \"xx.xx\")}\n\\]\n\n\\[\n\\text{tbl2} \\leftarrow \\text{build\\_table(lyt2, ANL)}\n\\]\n\n\\[\n\\text{tbl2}\n\\]\n\n---\n\n**append_topleft**\n\n*Append a description to the 'top-left' materials for the layout*\n\n---\n\n**Description**\n\nThis function *adds* newlines to the current set of \"top-left materials\".\n\n**Usage**\n\n```r\nappend_topleft(lyt, newlines)\n```\n\n**Arguments**\n\n- `lyt` layout object pre-data used for tabulation\n- `newlines` character. The new line(s) to be added to the materials\n\n**Details**\n\nAdds newlines to the set of strings representing the 'top-left' materials declared in the layout (the content displayed to the left of the column labels when the resulting tables are printed). Top-left material strings are stored and then displayed *exactly as is*, no structure or indenting is applied to them either when they are added or when they are displayed.\n\n**Value**\n\nA `PreDataTableLayouts` object suitable for passing to further layouting functions, and to `build_table`. \nNote\n\nCurrently, where in the construction of the layout this is called makes no difference, as it is independent of the actual splitting keywords. This may change in the future.\nThis function is experimental, its name and the details of its behavior are subject to change in future versions.\n\nSee Also\ntop_left()\n\nExamples\n\nlibrary(dplyr)\n\nDM2 <- DM %>% mutate(RACE = factor(RACE), SEX = factor(SEX))\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by(\"SEX\") %>%\n split_rows_by(\"RACE\") %>%\n append_topleft(\"Ethnicity\") %>%\n analyze(\"AGE\") %>%\n append_topleft(\"Age\")\n\ntbl <- build_table(lyt, DM2)\ntbl\n\nasvec\n\nconvert to a vector\n\nDescription\n\nConvert an rtables framework object into a vector, if possible. This is unlikely to be useful in realistic scenarios.\n\nUsage\n\n## S4 method for signature 'VTableTree'\nas.vector(x, mode = \"any\")\n\nArguments\n\nx ANY. The object to be converted to a vector\nmode character(1). Passed on to as.vector\n\nValue\n\na vector of the chosen mode (or an error is raised if more than one row was present).\nNote\nThis only works for a table with a single row or a row object.\n\n---\n\n**as_html**\n\n*Convert an rtable object to a shiny.tag html object*\n\n**Description**\n\nThe returned html object can be immediately used in shiny and rmarkdown.\n\n**Usage**\n\n```r\nas_html(\n x,\n width = NULL,\n class_table = \"table table-condensed table-hover\",\n class_tr = NULL,\n class_td = NULL,\n class_th = NULL,\n link_label = NULL\n)\n```\n\n**Arguments**\n\n- `x`: rtable object\n- `width`: width\n- `class_table`: class for table tag\n- `class_tr`: class for tr tag\n- `class_td`: class for td tag\n- `class_th`: class for th tag\n- `link_label`: link anchor label (not including tab: prefix) for the table.\n\n**Value**\n\nA shiny.tag object representing x in HTML.\n\n**Examples**\n\n```r\ntbl <- rtable(\n header = LETTERS[1:3],\n format = \"xx\",\n rrow(\"r1\", 1,2,3),\n rrow(\"r2\", 4,3,2, indent = 1),\n rrow(\"r3\", indent = 2)\n)\n```\n```r\nas_html(tbl)\nas_html(tbl, class_table = \"table\", class_tr = \"row\")\nas_html(tbl, class_td = \"aaa\")\n## Not run:\nViewer(tbl)\n## End(Not run)\n```\n\n### basic_table\n\nLayout with 1 column and zero rows\n\n#### Description\n\nEvery layout must start with a basic table.\n\n#### Usage\n\n```r\nbasic_table(\n title = \"\",\n subtitles = character(),\n main_footer = character(),\n prov_footer = character(),\n show_colcounts = FALSE,\n colcount_format = \"(N=xx)\",\n inset = 0L\n)\n```\n\n#### Arguments\n\n- **title**: character(1). Main title. Ignored for subtables.\n- **subtitles**: character. Subtitles. Ignored for subtables.\n- **main_footer**: character. Main global (non-referential) footer materials.\n- **prov_footer**: character. Provenance-related global footer materials. Generally should not be modified by hand.\n- **show_colcounts**: logical(1). Should column counts be displayed in the resulting table when this layout is applied to data\n- **colcount_format**: character(1). Format for use when displaying the column counts. Must be 1d, or 2d where one component is a percent. See details.\n- **inset**: numeric(1). Number of spaces to inset the table header, table body, referential footnotes, and main footer, as compared to alignment of title, subtitle, and provenance footer. Defaults to 0 (no inset).\nDetails\n\ncolcount_format is ignored if show_colcounts is FALSE (the default). When show_colcounts is TRUE, and colcount_format is 2-dimensional with a percent component, the value component for the percent is always populated with 1 (ie 100%). 1d formats are used to render the counts exactly as they normally would be, while 2d formats which don’t include a percent, and all 3d formats result in an error. Formats in the form of functions are not supported for colcount format. See list_valid_format_labels for the list of valid format labels to select from.\n\nValue\n\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\n\nNote\n\nBecause percent components in colcount_format are always populated with the value 1, we can get arguably strange results, such as that individual arm columns and a combined \"all patients\" column all list \"100%\" as their percentage, even though the individual arm columns represent strict subsets of the all patients column.\n\nExamples\n\n```r\nlyt <- basic_table() %>%\n analyze(\"AGE\", afun = mean)\n\ntbl <- build_table(lyt, DM)\ntbl\n\nlyt2 <- basic_table(title = \"Title of table\",\n subtitles = c(\"a number\", \"of subtitles\"),\n main_footer = \"test footer\",\n prov_footer = paste(\"test.R program, executed at\",\n Sys.time()))) %>%\n split_cols_by(\"ARM\") %>%\n analyze(\"AGE\", mean)\n\ntbl2 <- build_table(lyt2, DM)\ntbl2\n\nlyt3 <- basic_table(show_colcounts = TRUE,\n colcount_format = \"xx. (xx.%)\") %>%\n split_cols_by(\"ARM\")\n```\n\nRetrieve and assign elements of a TableTree\nDescription\n\nRetrieve and assign elements of a TableTree\n\nUsage\n\n## S4 replacement method for signature 'VTableTree,ANY,ANY,list'\nx[i, j, ...] <- value\n\n## S4 method for signature 'VTableTree,logical,logical'\nx[i, j, ..., drop = FALSE]\n\nArguments\n\nx TableTree\ni index\nj index\n... Includes\n\nkeep_topleft logical(1) ([ only) Should the top-left material for the table be retained after subsetting. Defaults to TRUE if all rows are included (i.e. subsetting was by column), and drops it otherwise.\nkeep_titles logical(1) Should title information be retained. Defaults to FALSE.\nkeep_footers logical(1) Should non-referential footer information be retained. Defaults to keep_titles.\nreindex.refs logical(1). Should referential footnotes be re-indexed as if the resulting subset is the entire table. Defaults to TRUE.\n\nvalue Replacement value (list, TableRow, or TableTree)\ndrop logical(1). Should the value in the cell be returned if one cell is selected by the combination of i and j. It is not possible to return a vector of values. To do so please consider using cell_values(). Defaults to FALSE.\n\nDetails\n\nby default, subsetting drops the information about title, subtitle, main footer, provenance footer, and topleft. If only a column is selected and all rows are kept, the topleft information remains as default. Any referential footnote is kept whenever the subset table contains the referenced element.\n\nValue\n\na TableTree (or ElementaryTable) object, unless a single cell was selected with drop=TRUE, in which case the (possibly multi-valued) fully stripped raw value of the selected cell.\n\nNote\n\nsubsetting always preserve the original order, even if provided indexes do not preserve it. If sorting is needed, please consider using sort_at_path(). Also note that character indices are treated as paths, not vectors of names in both [ and [<-.\nSee Also\n\nRegarding sorting: `sort_at_path()` and how to understand path structure: `summarize_row_groups()`, and `summarize_col_groups()`.\n\nExamples\n\n```r\nlyt <- basic_table(title = \"Title\",\n subtitles = c(\"Sub\", \"titles\"),\n prov_footer = \"prov footer\",\n main_footer = \"main footer\") %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"SEX\") %>%\n analyze(c(\"AGE\"))\n\ntbl <- build_table(lyt, DM)\ntop_left(tbl) <- \"Info\"\ntbl\n\n# As default header, footer, and topleft information is lost\ntbl[1, ]\ntbl[1:2, 2]\n\n# Also boolean filters can work\ntbl[, c(FALSE, TRUE, FALSE)]\n\n# If drop = TRUE, the content values are directly retrieved\ntbl[2, 1]\ntbl[2, 1, drop = TRUE]\n\n# Drop works also if vectors are selected, but not matrices\ntbl[, 1, drop = TRUE]\ntbl[2, , drop = TRUE]\ntbl[1, 1, drop = TRUE] # NULL because it is a label row\ntbl[2, 1:2, drop = TRUE] # vectors can be returned only with cell_values()\ntbl[1:2, 1:2, drop = TRUE] # no dropping because it is a matrix\n\n# If all rows are selected, topleft is kept by default\ntbl[, 2]\ntbl[, 1]\n\n# It is possible to deselect values\ntbl[-2, ]\ntbl[, -1]\n\n# Values can be reassigned\ntbl[2, 1] <- rcell(999)\ntbl[2, ] <- list(rrow(\"FFF\", 888, 666, 777))\ntbl[6, ] <- list(-111, -222, -333)\ntbl\n\n# We can keep some information from the original table if we need\ntbl[1, 2, keep_titles = TRUE]\n```\nbuild_table\n\nCreate a table from a layout and data\n\nDescription\n\nLayouts are used to describe a table pre-data. build_table is used to create a table using a layout and a dataset.\n\nUsage\n\nbuild_table(\n lyt,\n df,\n alt_counts_df = NULL,\n col_counts = NULL,\n col_total = if (is.null(alt_counts_df)) nrow(df) else nrow(alt_counts_df),\n topleft = NULL,\n hsep = default_hsep(),\n ...\n)\n\nArguments\n\nlyt layout object pre-data used for tabulation\ndf dataset (data.frame or tibble)\nalt_counts_df dataset (data.frame or tibble). Alternative full data the rtables framework will use (only) when calculating column counts.\nbuild_table\n\ncol_counts numeric (or NULL). Deprecated. If non-null, column counts which override those calculated automatically during tabulation. Must specify \"counts\" for all resulting columns if non-NULL. NA elements will be replaced with the automatically calculated counts.\n\ncol_total integer(1). The total observations across all columns. Defaults to nrow(df).\n\ntopleft character. Override values for the \"top left\" material to be displayed during printing.\n\nhsep character(1). Set of character(s) to be repeated as the separator between the header and body of the table when rendered as text. Defaults to a connected horizontal line (unicode 2014) in locals that use a UTF charset, and to - elsewhere (with a once per session warning).\n\n... currently ignored.\n\nDetails\n\nWhen alt_counts_df is specified, column counts are calculated by applying the exact column sub-setting expressions determined when applying column splitting to the main data (df) to alt_counts_df and counting the observations in each resulting subset.\n\nIn particular, this means that in the case of splitting based on cuts of the data, any dynamic cuts will have been calculated based on df and simply re-used for the count calculation.\n\nValue\n\nA TableTree or ElementaryTable object representing the table created by performing the tabulations declared in lyt to the data df.\n\nNote\n\nWhen overriding the column counts or totals care must be taken that, e.g., length() or nrow() are not called within tabulation functions, because those will NOT give the overridden counts. Writing/using tabulation functions which accept .N_col and .N_total or do not rely on column counts at all (even implicitly) is the only way to ensure overridden counts are fully respected.\n\nAuthor(s)\n\nGabriel Becker\n\nExamples\n\n```r\nlyt <- basic_table() %>%\nsplit_cols_by(\"Species\") %>%\nanalyze(\"Sepal.Length\", afun = function(x) {\n list(\n \"mean (sd)\" = rcell(c(mean(x), sd(x)), format = \"xx.xx (xx.xx)\")\n )\n})\n```\nlyt\n\ntbl <- build_table(lyt, iris)\ntbl\n\n# analyze multiple variables\nlyt2 <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n analyze(c(\"Sepal.Length\", \"Petal.Width\"), afun = function(x) {\n list( \n \"mean (sd)\" = rcell(c(mean(x), sd(x)), format = \"xx.xx (xx.xx)\") \n )\n })\ntbl2 <- build_table(lyt2, iris)\ntbl2\n\n# an example more relevant for clinical trials with column counts\nlyt3 <- basic_table(show_colcounts = TRUE) %>%\n split_cols_by(\"ARM\") %>%\n analyze(\"AGE\", afun = function(x) {\n setNames(as.list(fivenum(x)), c(\"minimum\", \"lower-hinge\", \"median\", \n \"upper-hinge\", \"maximum\"))\n })\ntbl3 <- build_table(lyt3, DM)\ntbl3\n\ntbl4 <- build_table(lyt3, subset(DM, AGE > 40))\ntbl4\n\n# with column counts calculated based on different data\nminiDM <- DM[sample(1:NROW(DM), 100),]\ntbl5 <- build_table(lyt3, DM, alt_counts_df = miniDM)\ntbl5\n\ntbl6 <- build_table(lyt3, DM, col_counts = 1:3)\ntbl6\n\n---\n\n**cbind_rtables**\n\n**cbind two rtables**\n\n### Description\n\ncbind two rtables\n\n### Usage\n\n```r\ncbind_rtables(x, ...)\n```\n**CellValue** \n\n**Arguments**\n\n- `x` A table or row object\n- `...` 1 or more further objects of the same class as `x`\n\n**Value**\n\nA formal table object.\n\n**Examples**\n\n```r\nx <- rtable(c(\"A\", \"B\"), rrow(\"row 1\", 1,2), rrow(\"row 2\", 3, 4))\ny <- rtable(c(\"C\", rrow(\"row 1\", 5), rrow(\"row 2\", 6))\nz <- rtable(c(\"D\", rrow(\"row 1\", 9), rrow(\"row 2\", 10))\nt1 <- cbind_rtables(x, y)\nt1\nt2 <- cbind_rtables(x, y, z)\nt2\n\ncol_paths_summary(t1)\ncol_paths_summary(t2)\n```\n\n---\n\n**CellValue** \n\n*Cell Value constructor*\n\n**Description**\n\nCell Value constructor\n\n**Usage**\n\n`CellValue(\n val,\n format = NULL,\n colspan = 1L,\n label = NULL,\n indent_mod = NULL,\n footnotes = NULL,\n align = NULL,\n format_na_str = NULL\n)`\n**Argument**\n\n- **val**: ANY. Value in the cell exactly as it should be passed to a formatter or returned when extracted.\n- **format**: FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\n- **colspan**: integer(1). Column span value.\n- **label**: character(1). A label (not to be confused with the name) for the object/structure.\n- **indent_mod**: numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure’s children. Defaults to 0, which corresponds to the unmodified default behavior.\n- **footnotes**: list or NULL. Referential footnote messages for the cell.\n- **align**: character(1) or NULL. Alignment the value should be rendered with. It defaults to \"center\" if NULL is used. See rtables_aligns for currently supported alignments.\n- **format_na_str**: character(1). String which should be displayed when formatted if this cell’s value(s) are all NA.\n\n**Value**\n\nAn object representing the value within a single cell within a populated table. The underlying structure of this object is an implementation detail and should not be relied upon beyond calling accessors for the class.\n\n---\n\n**cell_values**\n\n*Retrieve cell values by row and column path*\n\n**Description**\n\nRetrieve cell values by row and column path.\n\n**Usage**\n\n```r\ncell_values(tt, rowpath = NULL, colpath = NULL, omit_labrows = TRUE)\n\nvalue_at(tt, rowpath = NULL, colpath = NULL)\n```\n\n```r\n## S4 method for signature 'VTableTree'\nvalue_at(tt, rowpath = NULL, colpath = NULL)\n```\n\n**Arguments**\n\n- **tt**: TableTree (or related class). A TableTree object representing a populated table.\n- **rowpath**: character. Path in row-split space to the desired row(s). Can include \"@content\".\n- **colpath**: character. Path in column-split space to the desired column(s). Can include \"*\".\n- **omit_labrows**: logical(1). Should label rows underneath rowpath be omitted (TRUE, the default), or return empty lists of cell \"values\" (FALSE).\n**cell_values**\n\n**Value**\n\nFor `cell_values`, a list (regardless of the type of value the cells hold), if `rowpath` defines a path to a single row, `cell_values` returns the list of cell values for that row, otherwise a list of such lists, one for each row captured underneath `rowpath`. This occurs after subsetting to `colpath` has occurred.\n\nFor `value_at` the \"unwrapped\" value of a single cell, or an error, if the combination of `rowpath` and `colpath` do not define the location of a single cell in `tt`.\n\n**Note**\n\ncell_values will return a single cell's value wrapped in a list. Use `value_at` to receive the \"bare\" cell value.\n\n**Examples**\n\n```r\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by(\"SEX\") %>%\n split_rows_by(\"RACE\") %>%\n summarize_row_groups() %>%\n split_rows_by(\"STRATA1\") %>%\n analyze(\"AGE\")\n\nlibrary(dplyr) ## for mutate\ntbl <- build_table(lyt, DM %>%\n mutate(SEX = droplevels(SEX), RACE = droplevels(RACE)))\n\nrow_paths_summary(tbl)\ncol_paths_summary(tbl)\n\ncell_values(tbl, c(\"RACE\", \"ASIAN\", \"STRATA1\", \"B\"),\nc(\"ARM\", \"A: Drug X\", \"SEX\", \"F\"))\n\n# it's also possible to access multiple values by being less specific\ncell_values(tbl, c(\"RACE\", \"ASIAN\", \"STRATA1\"),\nc(\"ARM\", \"A: Drug X\", \"SEX\", \"F\"))\ncell_values(tbl, c(\"RACE\", \"ASIAN\"), c(\"ARM\", \"A: Drug X\", \"SEX\", \"M\"))\n\n## any arm, male columns from the ASIAN content (ie summary) row\n\ncell_values(tbl, c(\"RACE\", \"ASIAN\", \"@content\"),\nc(\"ARM\", \"B: Placebo\", \"SEX\", \"M\"))\ncell_values(tbl, c(\"RACE\", \"ASIAN\", \"@content\"),\nc(\"ARM\", \"x\", \"SEX\", \"M\"))\n\n## all columns\n\ncell_values(tbl, c(\"RACE\", \"ASIAN\", \"STRATA1\", \"B\"))\n\n## all columns for the Combination arm\n\ncell_values(tbl, c(\"RACE\", \"ASIAN\", \"STRATA1\", \"B\"),\nc(\"ARM\", \"C: Combination\"))\n```\ncvlist <- cell_values(tbl, c(\"RACE\", \"ASIAN\", \"STRATA1\", \"B\", \"AGE\", \"Mean\"),\n c(\"ARM\", \"B: Placebo\", \"SEX\", \"M\"))\ncvnolist <- value_at(tbl, c(\"RACE\", \"ASIAN\", \"STRATA1\", \"B\", \"AGE\", \"Mean\"),\n c(\"ARM\", \"B: Placebo\", \"SEX\", \"M\"))\nstopifnot(identical(cvlist[[1]], cvnolist))\n\nclayout\n\nColumn information/structure accessors\n\nDescription\n\nColumn information/structure accessors\n\nUsage\n\nclayout(obj)\n\n## S4 method for signature 'VTableNodeInfo'\nclayout(obj)\n\n## S4 method for signature 'PreDataTableLayouts'\nclayout(obj)\n\n## S4 method for signature 'ANY'\nclayout(obj)\n\nclayout(object) <- value\n\n## S4 replacement method for signature 'PreDataTableLayouts'\nclayout(object) <- value\n\ncol_info(obj)\n\n## S4 method for signature 'VTableNodeInfo'\ncol_info(obj)\n\ncol_info(obj) <- value\n\n## S4 replacement method for signature 'TableRow'\ncol_info(obj) <- value\n\n## S4 replacement method for signature 'ElementaryTable'\ncol_info(obj) <- value\n\n## S4 replacement method for signature 'TableTree'\ncol_info(obj) <- value\nclayout\n\n```r\ncoltree(obj, df = NULL, rtpos = TreePos())\n## S4 method for signature 'InstantiatedColumnInfo'\ncoltree(obj, df = NULL, rtpos = TreePos())\n\n## S4 method for signature 'PreDataTableLayouts'\ncoltree(obj, df = NULL, rtpos = TreePos())\n\n## S4 method for signature 'PreDataColLayout'\ncoltree(obj, df = NULL, rtpos = TreePos())\n\n## S4 method for signature 'LayoutColTree'\ncoltree(obj, df = NULL, rtpos = TreePos())\n\n## S4 method for signature 'VTableTree'\ncoltree(obj, df = NULL, rtpos = TreePos())\n\n## S4 method for signature 'TableRow'\ncoltree(obj, df = NULL, rtpos = TreePos())\n\ncol_exprs(obj, df = NULL)\n## S4 method for signature 'PreDataTableLayouts'\ncol_exprs(obj, df = NULL)\n\n## S4 method for signature 'PreDataColLayout'\ncol_exprs(obj, df = NULL)\n\n## S4 method for signature 'InstantiatedColumnInfo'\ncol_exprs(obj, df = NULL)\n\ncol_counts(obj, path = NULL)\n## S4 method for signature 'InstantiatedColumnInfo'\ncol_counts(obj, path = NULL)\n\n## S4 method for signature 'VTableNodeInfo'\ncol_counts(obj, path = NULL)\n\ncol_counts(obj, path = NULL) <- value\n\n## S4 replacement method for signature 'InstantiatedColumnInfo'\ncol_counts(obj, path = NULL) <- value\n\n## S4 replacement method for signature 'VTableNodeInfo'\ncol_counts(obj, path = NULL) <- value\n```\nclear_indentmods\n\ncol_total(obj)\n\n## S4 method for signature 'InstantiatedColumnInfo'\ncol_total(obj)\n\n## S4 method for signature 'VTableNodeInfo'\ncol_total(obj)\n\ncol_total(obj) <- value\n\n## S4 replacement method for signature 'InstantiatedColumnInfo'\ncol_total(obj) <- value\n\n## S4 replacement method for signature 'VTableNodeInfo'\ncol_total(obj) <- value\n\nArguments\n\nobj ANY. The object for the accessor to access or modify\nobject The object to modify in-place\nvalue The new value\ndf data.frame/NULL. Data to use if the column information is being generated from a Pre-Data layout object\nrtpos TreePos. Root position.\npath character or NULL. col_counts getter and setter only. Path (in column structure).\n\nValue\n\nA LayoutColTree object.\nVarious column information, depending on the accessor used.\n\nclear_indent.mods Clear All Indent Mods from a Table\n\nDescription\n\nClear All Indent Mods from a Table\n\nUsage\n\nclear_indent.mods(tt)\n\n## S4 method for signature 'VTableTree'\nclear_indent.mods(tt)\n\n## S4 method for signature 'TableRow'\nclear_indent.mods(tt)\n**Arguments**\n\n- **tt** \n TableTree (or related class). A TableTree object representing a populated table.\n\n**Value**\n\nThe same class as *tt*, with all indent mods set to zero.\n\n**Examples**\n\n```r\nlyt1 <- basic_table() %>%\n summarize_row_groups(\"STUDYID\", label_fstr = \"overall summary\") %>%\n split_rows_by(\"AEBODSYS\", child_labels = \"visible\") %>%\n summarize_row_groups(\"STUDYID\", label = \"subgroup summary\") %>%\n analyze(\"AGE\", indent_mod = -1L)\n\ntbl1 <- build_table(lyt1, ex_adae)\ntbl1\nclear_indent_mods(tbl1)\n```\n\n---\n\n**collect_leaves** \n*Collect leaves of a table tree*\n\n**Description**\n\nCollect leaves of a table tree\n\n**Usage**\n\n```r\ncollect_leaves(tt, incl.cont = TRUE, add.labrows = FALSE)\n```\n\n**Arguments**\n\n- **tt** \n TableTree (or related class). A TableTree object representing a populated table.\n\n- **incl.cont** \n logical. Include rows from content tables within the tree. Defaults to TRUE\n\n- **add.labrows** \n logical. Include label rows. Defaults to FALSE\n\n**Value**\n\nA list of TableRow objects for all rows in the table\ncompare_rtables \n\n**Compare two rtables**\n\n**Description**\n\nPrints a matrix where . means cell matches, X means cell does cells do not match, + cell (row) is missing, and ~ cell (row) should not be there. If structure is set to TRUE, C indicates columnar structure mismatch, R indicates row-structure mismatch, and S indicates mismatch in both row and column structure.\n\n**Usage**\n\n```r\ncompare_rtables(\n object,\n expected,\n tol = 0.1,\n comp.attr = TRUE,\n structure = FALSE\n)\n```\n\n**Arguments**\n\n- `object`: rtable to test\n- `expected`: rtable expected\n- `tol`: numerical tolerance\n- `comp.attr`: boolean. Compare format of cells. Other attributes are silently ignored.\n- `structure`: boolean. Should structure (in the form of column and row paths to cells) be compared. Currently defaults to FALSE, but this is subject to change in future versions.\n\n**Value**\n\na matrix of class \"rtables_diff\" representing the differences between object and expected as described above.\n\n**Note**\n\nIn its current form compare_rtables does not take structure into account, only row and cell position.\n\n**Examples**\n\n```r\nt1 <- rtable(header = c(\"A\", \"B\"), format = \"xx\", rrow(\"row 1\", 1, 2))\nt2 <- rtable(header = c(\"A\", \"B\", \"C\"), format = \"xx\", rrow(\"row 1\", 1, 2, 3))\ncompare_rtables(object = t1, expected = t2)\n```\nif(interactive(){\n Viewer(t1, t2)\n}\n\nexpected <- rtable(\n header = c(\"ARM A\\nN=100\", \"ARM B\\nN=200\"),\n format = \"xx\",\n rrow(\"row 1\", 10, 15),\n rrow(),\n rrow(\"section title\"),\n rrow(\"row colspan\", rcell(c(.345543, .4432423), colspan = 2, format = \"(xx.xx, xx.xx)\"))\n)\n\nobject <- rtable(\n header = c(\"ARM A\\nN=100\", \"ARM B\\nN=200\"),\n format = \"xx\",\n rrow(\"row 1\", 10, 15),\n rrow(),\n rrow(\"section title\")\n)\n\ncompare_rtables(object, expected, comp.attr = FALSE)\n\nobject <- rtable(\n header = c(\"ARM A\\nN=100\", \"ARM B\\nN=200\"),\n format = \"xx\",\n rrow(\"row 1\", 14, 15.03),\n rrow(),\n rrow(\"section title\")\n)\n\ncompare_rtables(object, expected)\n\nobject <- rtable(\n header = c(\"ARM A\\nN=100\", \"ARM B\\nN=200\"),\n format = \"xx\",\n rrow(\"row 1\", 10, 15),\n rrow(),\n rrow(\"section title\"),\n rrow(\"row colspan\", rcell(c(.345543, .4432423), colspan = 2, format = \"(xx.xx, xx.xx)\"))\n)\n\ncompare_rtables(object, expected)\n### Description\n\nCompatibility Arg Conventions\n\n### Usage\n\n\\[\n\\text{compat_args}(\\text{.lst, row.name, format, indent, label, inset})\n\\]\n\n### Arguments\n\n- **.lst**: list. An already-collected list of arguments to be used instead of the elements of `...`. Arguments passed via `...` will be ignored if this is specified.\n- **row.name**: if NULL then an empty string is used as `row.name` of the `rrow`.\n- **format**: character(1) or function. The format label (string) or formatter function to apply to the cell values passed via `...`. See `list_valid_format_labels` for currently supported format labels.\n- **indent**: deprecated.\n- **label**: character(1). A label (not to be confused with the name) for the object/structure.\n- **inset**: integer(1). The table inset for the row or table being constructed. See `table_inset`.\n\n### Value\n\nNULL (this is an argument template dummy function)\n\n### See Also\n\nOther conventions: `constr_args()`, `gen_args()`, `lyt_args()`, `sf_args()`\n### Constructor Arg Conventions\n\n#### Description\n\nConstructor Arg Conventions\n\n#### Usage\n\n```r\nconstr_args(\n kids,\n cont,\n lev,\n iscontent,\n cinfo,\n labelrow,\n vals,\n cspan,\n label_pos,\n cindent_mod,\n cvar,\n label,\n cextra_args,\n child_names,\n title,\n subtitles,\n main_footer,\n prov_footer,\n footnotes,\n page_title,\n page_prefix,\n section_div,\n trailing_sep,\n split_na_str,\n cna_str,\n inset,\n table_inset\n)\n```\n\n#### Arguments\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><code>kids</code></td>\n<td>list. List of direct children.</td>\n</tr>\n<tr>\n<td><code>cont</code></td>\n<td>ElementaryTable. Content table.</td>\n</tr>\n<tr>\n<td><code>lev</code></td>\n<td>integer. Nesting level (roughly, indentation level in practical terms).</td>\n</tr>\n<tr>\n<td><code>iscontent</code></td>\n<td>logical. Is the TableTree/ElementaryTable being constructed the content table for another TableTree.</td>\n</tr>\n</tbody>\n</table>\ncinfo InstantiatedColumnInfo (or NULL). Column structure for the object being created.\n\nlabelrow LabelRow. The LabelRow object to assign to this Table. Constructed from label by default if not specified.\n\nvals list. cell values for the row\n\nctspan integer. Column span. 1 indicates no spanning.\n\nclabel_pos character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\n\ncindent_mod numeric(1). The indent modifier for the content tables generated by this split.\n\ncvar character(1). The variable, if any, which the content function should accept. Defaults to NA.\n\nclabel character(1). A label (not to be confused with the name) for the object/structure.\n\ncextra_args list. Extra arguments to be passed to the content function when tabulating row group summaries.\n\nchild_names character. Names to be given to the sub splits contained by a compound split (typically a AnalyzeMultiVars split object).\n\ntitle character(1). Main title. Ignored for subtables.\n\nsubtitles character. Subtitles. Ignored for subtables.\n\nmain_footer character. Main global (non-referential) footer materials.\n\nprov_footer character. Provenance-related global footer materials. Generally should not be modified by hand.\n\nfootnotes list or NULL. Referential footnotes to be applied at current level\n\npage_title character. Page specific title(s).\n\npage_prefix character(1). Prefix, to be appended with the split value, when forcing pagination between the children of this split/table\n\nsection_div character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\n\ntrailing_sep character(1). String which will be used as a section divider after the printing of the last row contained in this (sub)-table, unless that row is also the last table row to be printed overall, or NA_character_ for none (the default). When generated via layouting, this would correspond to the section_div of the split under which this table represents a single facet.\n\nsplit NA_str character. NA string vector for use with split_format.\n\ncna_str character. NA string for use with cformat for content table.\n\ninset numeric(1). Number of spaces to inset the table header, table body, referential footnotes, and main_footer, as compared to alignment of title, subtitle, and provenance footer. Defaults to 0 (no inset).\n\ntable_inset numeric(1). Number of spaces to inset the table header, table body, referential footnotes, and main_footer, as compared to alignment of title, subtitle, and provenance footer. Defaults to 0 (no inset).\n**content_table**\n\n**Value**\n\nNULL (this is an argument template dummy function)\n\n**See Also**\n\nOther conventions: `compat_args()`, `gen_args()`, `lyt_args()`, `sf_args()`\n\n---\n\n**content_table**\n\n*Retrieve or set Content Table from a TableTree*\n\n**Description**\n\nReturns the content table of `obj` if it is a `TableTree` object, or NULL otherwise\n\n**Usage**\n\n`content_table(obj)`\n\n`content_table(obj) <- value`\n\n**Arguments**\n\n- `obj` TableTree. The TableTree\n- `value` ElementaryTable. The new content table for `obj`.\n\n**Value**\n\nthe `ElementaryTable` containing the (top level) *content rows* of `obj` (or NULL if `obj` is not a formal table object).\n\n---\n\n**cont_n_allcols**\n\n*Score functions for sorting TableTrees*\n\n**Description**\n\nScore functions for sorting TableTrees\n\n**Usage**\n\n`cont_n_allcols(tt)`\n\n`cont_n_onecol(j)`\ncounts_wpcts\n\n**Arguments**\n\n- `tt`: TableTree (or related class). A TableTree object representing a populated table.\n- `j`: numeric(1). Number of column used for scoring.\n\n**Value**\n\nA single numeric value indicating score according to the relevant metric for `tt`, to be used when sorting.\n\n**See Also**\n\nFor examples and details please read main documentation `sort_at_path()` and relevant vignette ((Sorting and Pruning))\n\n---\n\n**counts_wpcts** \n*Analysis function to count levels of a factor with percentage of the column total*\n\n**Description**\n\nAnalysis function to count levels of a factor with percentage of the column total\n\n**Usage**\n\n`counts_wpcts(x, .N_col)`\n\n**Arguments**\n\n- `x`: factor. Vector of data, provided by rtables pagination machinery\n- `.N_col`: integer(1). Total count for the column, provided by rtables pagination machinery\n\n**Value**\n\nA RowsVerticalSection object with counts (and percents) for each level of the factor\n\n**Examples**\n\n`counts_wpcts(DM$SEX, 400)`\n**Custom Split Functions**\n\n**Description**\n\nSplit functions provide the work-horse for `rtables`'s generalized partitioning. These functions accept a (sub)set of incoming data, a split object, and return 'splits' of that data.\n\n**Custom Splitting Function Details**\n\nUser-defined custom split functions can perform any type of computation on the incoming data provided that they meet the contract for generating 'splits' of the incoming data 'based on' the split object.\n\nSplit functions are functions that accept:\n\n- **df** data.frame of incoming data to be split\n- **spl** a Split object. this is largely an internal detail custom functions will not need to worry about, but `obj_name(spl)`, for example, will give the name of the split as it will appear in paths in the resulting table\n- **vals** Any pre-calculated values. If given non-null values, the values returned should match these. Should be NULL in most cases and can likely be ignored\n- **labels** Any pre-calculated value labels. Same as above for **values**\n- **trim** If TRUE, resulting splits that are empty should be removed\n- **(Optional) .spl_context** a data.frame describing previously performed splits which collectively arrived at **df**\n\nThe function must then output a named list with the following elements:\n\n- **values** The vector of all values corresponding to the splits of **df**\n- **datasplit** a list of data.frames representing the groupings of the actual observations from **df**.\n- **labels** a character vector giving a string label for each value listed in the **values** element above\n- **(Optional) extras** If present, extra arguments are to be passed to summary and analysis functions whenever they are executed on the corresponding element of **datasplit** or a subset thereof\n\nOne way to generate custom splitting functions is to wrap existing split functions and modify either the incoming data before they are called or their outputs.\n\n**See Also**\n\n- `make_split_fun()` for the API for creating custom split functions, and `split_funcs` for a variety of pre-defined split functions.\nExamples\n\n# Example of a picky split function. The number of values in the column variable\n# var decrees if we are going to print also the column with all observation\n# or not.\n\npicky_splitter <- function(var) {\n # Main layout function\n function(df, spl, vals, labels, trim) {\n orig_vals <- vals\n\n # Check for number of levels if all are selected\n if (is.null(vals)) {\n vec <- df[[var]]\n vals <- unique(vec)\n }\n\n # Do a split with or without All obs\n if (length(vals) == 1) {\n do_base_split(spl = spl, df = df, vals = vals, labels = labels, trim = trim)\n } else {\n fnc_tmp <- add_overall_level(\"Overall\", label = \"All Obs\", first = FALSE)\n fnc_tmp(df = df, spl = spl, vals = orig_vals, trim = trim)\n }\n }\n}\n\n# Data sub-set\nd1 <- subset(ex_adsl, ARM == \"A: Drug X\" | (ARM == \"B: Placebo\" & SEX == \"F\"))\nd1 <- subset(d1, SEX %in% c(\"M\", \"F\"))\nd1$SEX <- factor(d1$SEX)\n\n# This table uses the number of values in the SEX column to add the overall col or not\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\", split_fun = drop_split_levels) %>%\n split_cols_by(\"SEX\", split_fun = picky_splitter(\"SEX\")) %>%\n analyze(\"AGE\", show_labels = \"visible\")\ntbl <- build_table(lyt, d1)\ntbl\n\ndf_to_tt\n\nCreate ElementaryTable from data.frame\n\nDescription\n\nCreate ElementaryTable from data.frame\n\nUsage\n\ndf_to_tt(df)\n**do_base_split**\n\n**Arguments**\n\n- **df** data.frame.\n\n**Value**\n\nan `ElementaryTable` object with unnested columns corresponding to `names(df)` and row labels corresponding to `row.names(df)`\n\n**Examples**\n\ndf_to_tt(mtcars)\n\n---\n\n**do_base_split** \n*Apply Basic Split (For Use In Custom Split Functions)*\n\n**Description**\n\nThis function is intended for use inside custom split functions. It applies the current split as if it had no custom splitting function so that those default splits can be further manipulated.\n\n**Usage**\n\ndo_base_split(spl, df, vals = NULL, labels = NULL, trim = FALSE)\n\n**Arguments**\n\n- **spl** A Split object defining a partitioning or analysis/tabulation of the data.\n- **df** dataset (data.frame or tibble)\n- **vals** ANY. Already calculated/known values of the split. Generally should be left as NULL.\n- **labels** character. Labels associated with vals. Should be NULL when vals is, which should almost always be the case.\n- **trim** logical(1). Should groups corresponding to empty data subsets be removed. Defaults to FALSE.\n\n**Value**\n\nthe result of the split being applied as if it had no custom split function, see `custom_split_funs`\ndrop_facet_levels\n\nExamples\n\n```r\nuneven_splfun <- function(df, spl, vals = NULL, labels = NULL, trim = FALSE) {\n ret <- do_base_split(spl, df, vals, labels, trim)\n if(NROW(df) == 0)\n ret <- lapply(ret, function(x) x[[1]])\n ret\n}\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by_multivar(c(\"USUBJID\", \"AESEQ\", \"BMRKR1\"),\n varlabels = c(\"N\", \"E\", \"BMR1\"),\n split_fun = uneven_splfun) %>%\n analyze_colvars(list(USUBJID = function(x, ...) length(unique(x)),\n AESEQ = max,\n BMRKR1 = mean))\n\ntbl <- build_table(lyt, subset(ex_adae, as.numeric(ARM) <= 2))\n\ntbl\n```\n\n---\n\ndrop_facet_levels Preprocessing Functions for use in make_split_fun\n\nDescription\n\nThis function is intended for use as a preprocessing component in make_split_fun, and should not be called directly by end users.\n\nUsage\n\ndrop_facet_levels(df, spl, ...)\n\nArguments\n\ndf data.frame. The incoming data corresponding with the parent facet\nspl Split.\n... dots. This is used internally to pass parameters.\n\nSee Also\n\nmake_split_fun\n\nOther make_custom_split: add_combo_facet(), make_split_fun(), make_split_result(), trim_levels_in_facets()\nDescription\n\nTableTree classes\n\nTable Constructors and Classes\n\nUsage\n\nElementaryTable(\n kids = list(),\n name = \"\",\n lev = 1L,\n label = \"\",\n labelrow = LabelRow(lev = lev, label = label, vis = !isTRUE(iscontent) && !is.na(label)\n && nzchar(label)),\n rspans = data.frame(),\n cinfo = NULL,\n iscontent = NA,\n var = NA_character_,\n format = NULL,\n na_str = NA_character_,\n indent_mod = 0L,\n title = \"\",\n subtitles = character(),\n main_footer = character(),\n prov_footer = character(),\n hsep = default_hsep(),\n trailing_sep = NA_character_,\n inset = 0L\n)\n\nTableTree(\n kids = list(),\n name = if (!is.na(var)) var else \"\",\n cont = EmptyElTable,\n lev = 1L,\n label = name,\n labelrow = LabelRow(lev = lev, label = label, vis = nrow(cont) == 0 && !is.na(label) &&\n nzchar(label)),\n rspans = data.frame(),\n iscontent = NA,\n var = NA_character_,\n cinfo = NULL,\n format = NULL,\nElementaryTable-class\n\n```r\nna_str = NA_character_,\nindent_mod = 0L,\ntitle = \"\",\nsubtitles = character(),\nmain_footer = character(),\nprov_footer = character(),\npage_title = NA_character_,\nhsep = default_hsep(),\ntrailing_sep = NA_character_,\ninset = 0L\n```\n\n**Arguments**\n\n- **kids** list. List of direct children.\n- **name** character(1). Name of the split/table/row being created. Defaults to same as the corresponding label, but is not required to be.\n- **lev** integer. Nesting level (roughly, indentation level in practical terms).\n- **label** character(1). A label (not to be confused with the name) for the object/structure.\n- **labelrow** LabelRow. The LabelRow object to assign to this Table. Constructed from `label` by default if not specified.\n- **rspans** data.frame. Currently stored but otherwise ignored.\n- **cinfo** InstantiatedColumnInfo (or NULL). Column structure for the object being created.\n- **iscontent** logical. Is the TableTree/ElementaryTable being constructed the content table for another TableTree.\n- **var** string, variable name\n- **format** FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as `analyze` calls, they can character vectors or lists of functions.\n- **na_str** character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\n- **indent_mod** numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure’s children. Defaults to 0, which corresponds to the unmodified default behavior.\n- **title** character(1). Main title. Ignored for subtables.\n- **subtitles** character. Subtitles. Ignored for subtables.\n- **main_footer** character. Main global (non-referential) footer materials.\n- **prov_footer** character. Provenance-related global footer materials. Generally should not be modified by hand.\n- **hsep** character(1). Set of character(s) to be repeated as the separator between the header and body of the table when rendered as text. Defaults to a connected horizontal line (unicode 2014) in locals that use a UTF charset, and to - elsewhere (with a once per session warning).\ntrailing_sep character(1). String which will be used as a section divider after the printing of the last row contained in this (sub)-table, unless that row is also the last table row to be printed overall, or NA_character_ for none (the default). When generated via layouting, this would correspond to the section_div of the split under which this table represents a single facet.\n\ninset numeric(1). Number of spaces to inset the table header, table body, referential footnotes, and main_footer, as compared to alignment of title, subtitle, and provenance footer. Defaults to 0 (no inset).\n\ncont ElementaryTable. Content table.\n\npage_title character. Page specific title(s).\n\nValue\nA formal object representing a populated table.\n\nAuthor(s)\nGabriel Becker\nfont_family = \"Courier\",\nfontsize = 8,\nfont_size = fontsize,\npaginate = TRUE,\nlpp = NULL,\ncpp = NULL,\nhsep = \"-\",\nindent_size = 2,\ntf_wrap = TRUE,\nmax_width = NULL,\ncolwidths = propose_column_widths(matrix_form(tt, TRUE)),\n...)\n\nArguments\n\n**tt**\nTableTree (or related class). A TableTree object representing a populated table.\n\n**file**\nfile to write, must have .pdf extension\n\n**page_type**\ncharacter(1). Name of a page type. See page_types. Ignored when pg_width and pg_height are set directly.\n\n**landscape**\nlogical(1). Should the dimensions of page_type be inverted for landscape? Defaults to FALSE, ignored when pg_width and pg_height are set directly.\n\n**pg_width**\nnumeric(1). Page width in inches.\n\n**pg_height**\nnumeric(1). Page height in inches.\n\n**width**\nDeprecated, please use pg_width or specify page_type. The width of the graphics region in inches\n\n**height**\nDeprecated, please use pg_height or specify page_type. The height of the graphics region in inches\n\n**margins**\nnumeric(4). The number of lines/characters of margin on the bottom, left, top, and right sides of the page.\n\n**font_family**\ncharacter(1). Name of a font family. An error will be thrown if the family named is not monospaced. Defaults to Courier.\n\n**fontsize**\nDeprecated, please use font_size. the size of text (in points)\n\n**font_size**\nnumeric(1). Font size, defaults to 12.\n\n**paginate**\nlogical(1). Whether pagination should be performed, defaults to TRUE if page size is specified (including the default).\n\n**lpp**\nnumeric(1) or NULL. Lines per page. if NA (the default, this is calculated automatically based on the specified page size). NULL indicates no vertical pagination should occur.\n\n**cpp**\nnumeric(1) or NULL. Width in characters per page. if NA (the default, this is calculated automatically based on the specified page size). NULL indicates no horizontal pagination should occur.\n\n**hsep**\ncharacter(1). Characters to repeat to create header/body separator line.\nexport_as_tsv\n\nindent_size numeric(1). Indent size in characters. Ignored when x is already a MatrixPrintForm object in favor of information there.\n\ntf_wrap logical(1). Should the texts for title, subtitle, and footnotes be wrapped?\n\nmax_width integer(1), character(1) or NULL. Width that title and footer (including footnotes) materials should be word-wrapped to. If NULL, it is set to the current print width of the session (getOption(\"width\")). If set to \"auto\", the width of the table (plus any table inset) is used. Ignored completely if tf_wrap is FALSE.\n\ncolwidths numeric vector. Column widths (in characters) for use with vertical pagination.\n\n... arguments passed on to paginate_table\n\nDetails\n\nBy default, pagination is performed, with default cpp and lpp defined by specified page dimensions and margins. User-specified lpp and cpp values override this, and should be used with caution.\n\nTitle and footer materials are also word-wrapped by default (unlike when printed to the terminal), with cpp, as defined above, as the default max_width.\n\nSee Also\n\nformatters::export_as_txt()\n\nExamples\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n analyze(c(\"AGE\", \"BMRKR2\", \"COUNTRY\"))\n\ntbl <- build_table(lyt, ex_adsl)\n\n## Not run:\ntf <- tempfile(fileext = \".pdf\")\nexport_as_pdf(tbl, file = tf, pg_height = 4)\ntf <- tempfile(fileext = \".pdf\")\nexport_as_pdf(tbl, file = tf, lpp = 8)\n\n## End(Not run)\n\nexport_as_tsv Create Enriched flat value table with paths\n\nDescription\n\nThis function creates a flat tabular file of cell values and corresponding paths via path_enriched_df. I then writes that data.frame out as a tsv file.\nUsage\n\n```r\nexport_as_tsv(\n tt,\n file = NULL,\n path_fun = collapse_path,\n value_fun = collapse_values\n)\n\nimport_from_tsv(file)\n```\n\nArguments\n\n- `tt` TableTree (or related class). A TableTree object representing a populated table.\n- `file` character(1). The path of the file to written to or read from.\n- `path_fun` function. Function to transform paths into single-string row/column names.\n- `value_fun` function. Function to transform cell values into cells of the data.frame. Defaults to `collapse_values` which creates strings where multi-valued cells are collapsed together, separated by `|`.\n\nDetails\n\nBy default (ie when `value_func` is not specified, List columns where at least one value has length > 1 are collapsed to character vectors by collapsing the list element with \"|\").\n\nValue\n\nNULL silently for `export_as_tsv`, a data.frame with re-constituted list values for `export_as_tsv`.\n\nNote\n\nThere is currently no round-trip capability for this type of export. You can read values exported this way back in via `import_from_tsv` but you will receive only the data.frame version back, NOT a TableTree.\n\n---\n\n`format_rcell` \n\n**Format rcell**\n\nDescription\n\nThis is a wrapper around `formatters::format_value` for use with `CellValue` objects\nformat_rcell\n\nUsage\n\nformat_rcell(\n x,\n format,\n output = c(\"ascii\", \"html\"),\n na_str = obj_na_str(x) || \"NA\",\n pr_row_format = NULL,\n pr_row_na_str = NULL,\n shell = FALSE\n)\n\nArguments\n\n x an object of class CellValue, or a raw value.\n format character(1) or function. The format label (string) or formatter function to apply to x.\n output character(1). Output type.\n na_str character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\n pr_row_format list of default format coming from the general row.\n pr_row_na_str list of default \"NA\" string coming from the general row.\n shell logical(1). Should the formats themselves be returned instead of the values with formats applied. Defaults to FALSE.\n\nValue\n\n formatted text representing the cell\n\nExamples\n\nc11 <- CellValue(pi, format = \"xx.xxx\")\nformat_rcell(c11)\n\n# Cell values precedes the row values\nc11 <- CellValue(pi, format = \"xx.xxx\")\nformat_rcell(c11, pr_row_format = \"xx.x\")\n\n# Similarly for NA values\nc11 <- CellValue(NA, format = \"xx.xxx\", format_na_str = \"This is THE NA\")\nformat_rcell(c11, pr_row_na_str = \"This is NA\")\nDescription\n\nGeneral Argument Conventions\n\nUsage\n\n```r\ngen_args(\n df,\n alt_counts_df,\n spl,\n pos,\n tt,\n tr,\n verbose,\n colwidths,\n obj,\n x,\n value,\n object,\n path,\n label,\n label_pos,\n cvar,\n topleft,\n page_prefix,\n hsep,\n indent_size,\n section_div,\n na_str,\n inset,\n table_inset,\n ...\n)\n```\n\nArguments\n\n- **df**: dataset (data.frame or tibble) \n- **alt_counts_df**: dataset (data.frame or tibble). Alternative full data the rtables framework will use *(only)* when calculating column counts.\n- **spl**: A Split object defining a partitioning or analysis/tabulation of the data.\n- **pos**: numeric. Which top-level set of nested splits should the new layout feature be added to. Defaults to the current\n- **tt**: TableTree (or related class). A TableTree object representing a populated table.\n**tr** TableRow (or related class). A TableRow object representing a single row within a populated table.\n\n**verbose** logical(1). Should extra debugging messages be shown. Defaults to FALSE.\n\n**colwidths** numeric vector. Column widths for use with vertical pagination.\n\n**obj** ANY. The object for the accessor to access or modify\n\n**x** An object\n\n**value** The new value\n\n**object** The object to modify in-place\n\n**path** character. A vector path for a position within the structure of a tabletree. Each element represents a subsequent choice amongst the children of the previous choice.\n\n**label** character(1). A label (not to be confused with the name) for the object/structure.\n\n**label_pos** character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\n\n**cvar** character(1). The variable, if any, which the content function should accept. Defaults to NA.\n\n**topleft** character. Override values for the \"top left\" material to be displayed during printing.\n\n**page_prefix** character(1). Prefix, to be appended with the split value, when forcing pagination between the children of this split/table\n\n**hsep** character(1). Set of character(s) to be repeated as the separator between the header and body of the table when rendered as text. Defaults to a connected horizontal line (unicode 2014) in locals that use a UTF charset, and to - elsewhere (with a once per session warning).\n\n**indent_size** numeric(1). Number of spaces to use per indent level. Defaults to 2\n\n**section_div** character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\n\n**na_str** character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\n\n**inset** numeric(1). Number of spaces to inset the table header, table body, referential footnotes, and main_footer, as compared to alignment of title, subtitle, and provenance footer. Defaults to 0 (no inset).\n\n**table_inset** numeric(1). Number of spaces to inset the table header, table body, referential footnotes, and main_footer, as compared to alignment of title, subtitle, and provenance footer. Defaults to 0 (no inset).\n\n... Passed on to methods or tabulation functions.\n\n**Value**\n\nNULL (this is an argument template dummy function)\nSee Also\n\nOther conventions: \\texttt{compat_args()}, \\texttt{constr_args()}, \\texttt{lyt_args()}, \\texttt{sf_args()}\n\n---\n\nget\\_formatted\\_cells \nget formatted cells\n\ndescription\n\nget formatted cells\n\nUsage\n\nget\\_formatted\\_cells(obj, shell = FALSE)\n\n\\# S4 method for signature 'TableTree'\nget\\_formatted\\_cells(obj, shell = FALSE)\n\n\\# S4 method for signature 'ElementaryTable'\nget\\_formatted\\_cells(obj, shell = FALSE)\n\n\\# S4 method for signature 'TableRow'\nget\\_formatted\\_cells(obj, shell = FALSE)\n\n\\# S4 method for signature 'LabelRow'\nget\\_formatted\\_cells(obj, shell = FALSE)\n\ng\\_cell\\_aligns(obj)\n\n\\# S4 method for signature 'TableTree'\ng\\_cell\\_aligns(obj)\n\n\\# S4 method for signature 'ElementaryTable'\ng\\_cell\\_aligns(obj)\n\n\\# S4 method for signature 'TableRow'\ng\\_cell\\_aligns(obj)\n\n\\# S4 method for signature 'LabelRow'\ng\\_cell\\_aligns(obj)\n\nArguments\n\n\\begin{itemize}\n\\item obj \\quad \\text{ANY. The object for the accessor to access or modify}\n\\item shell \\quad \\text{logical(1). Should the formats themselves be returned instead of the values with formats applied. Defaults to FALSE.}\n\\end{itemize}\nhead\n\nValue\nthe formatted print-strings for all (body) cells in obj.\n\nExamples\n\nlibrary(dplyr)\n\niris2 <- iris %>%\n group_by(Species) %>%\n mutate(group = as.factor(rep_len(c(\"a\", \"b\"), length.out = n()))) %>%\n ungroup()\n\ntbl <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n split_cols_by(\"group\") %>%\n analyze(c(\"Sepal.Length\", \"Petal.Width\"), afun = list_wrap_x(summary), format = \"xx.xx\") %>%\n build_table(iris2)\n\nget_formatted_cells(tbl)\n\nhead\n\nHead and tail methods\n\nDescription\nHead and tail methods\n\nUsage\nhead(x, ...)\n\n## S4 method for signature 'VTableTree'\nhead(\nx,\n n = 6,\n ..., \n keep_topleft = TRUE,\n keep_titles = TRUE,\n keep_footers = keep_titles,\n reindex_refs = FALSE\n)\n\ntail(x, ...)\n\n## S4 method for signature 'VTableTree'\ntail(\nx,\nn = 6,\n..., \nkeep_topleft = TRUE,\nkeep_titles = TRUE,\nkeep_footers = keep_titles,\nreindex.refs = FALSE\n)\n\nArguments\nx an object\n... arguments to be passed to or from other methods.\nn an integer vector of length up to dim(x) (or 1, for non-dimensioned objects). Values specify the indices to be selected in the corresponding dimension (or along the length) of the object. A positive value of n[i] includes the first/last n[i] indices in that dimension, while a negative value excludes the last/first abs(n[i]), including all remaining indices. NA or non-specified values (when length(n) < length(dim(x))) select all indices in that dimension. Must contain at least one non-missing value.\nkeep_topleft logical(1). If TRUE (the default), top_left material for the table will be carried over to the subset.\nkeep_titles logical(1). If TRUE (the default), all title material for the table will be carried over to the subset.\nkeep_footers logical(1). If TRUE, all footer material for the table will be carried over to the subset. It defaults to keep_titles.\nreindex.refs logical(1). Defaults to FALSE. If TRUE, referential footnotes will be reindexed for the subset.\n\nhorizontal.sep Access or recursively set header-body separator for tables\n\nDescription\nAccess or recursively set header-body separator for tables\n\nUsage\nhorizontal.sep(obj)\n\n## S4 method for signature 'VTableTree'\nhorizontal.sep(obj)\n\nhorizontal.sep(obj) <- value\n\n## S4 replacement method for signature 'VTableTree'\n## horizontal_sep(obj) <- value\n\n### S4 replacement method for signature 'TableRow'\n\n**Arguments**\n\n- **obj**: ANY. The object for the accessor to access or modify\n- **value**: character(1). String to use as new header/body separator.\n\n**Value**\n\n- for `horizontal_sep` the string acting as the header separator.\n- for `horizontal_sep<-`, the `obj`, with the new header separator applied recursively to it and all its subtables.\n\n---\n\n### indent\n\n**Change indentation of all rows in an rtable**\n\n**Description**\n\nChange indentation of all rows in an rtable\n\n**Usage**\n\n```r\ndf <- indent(x, by = 1)\n```\n\n**Arguments**\n\n- **x**: rtable object\n- **by**: integer to increase indentation of rows. Can be negative. If final indentation is smaller than 0 then the indentation is set to 0.\n\n**Value**\n\n- `x` with its indent modifier incremented by `by`.\n\n**Examples**\n\n```r\nis_setosa <- iris$Species == \"setosa\"\n\nm_tbl <- rtable(\n header = rheader(\n rrow(row.name = NULL, rcell(\"Sepal.Length\", colspan = 2), rcell(\"Petal.Length\", colspan=2)),\n rrow(NULL, \"mean\", \"median\", \"mean\", \"median\")\n ),\n rrow(\n row.name = \"All Species\",\n mean(iris$Sepal.Length), median(iris$Sepal.Length),\n mean(iris$Petal.Length), median(iris$Petal.Length)\n ),\n by = 1)\n```\n```r\nformat = \"xx.xx\"\nrow(row.name = \"Setosa\",\nmean(iris$Sepal.Length[is_setosa]), median(iris$Sepal.Length[is_setosa]),\nmean(iris$Petal.Length[is_setosa]), median(iris$Petal.Length[is_setosa]),\nformat = \"xx.xx\"\n)\n```\n\n---\n\n**indent_string**\n\n**Indent Strings**\n\n**Description**\n\nUsed in rtables to indent row names for the ASCII output.\n\n**Usage**\n\n```r\nindent_string(x, indent = 0, incr = 2, including_newline = TRUE)\n```\n\n**Arguments**\n\n- `x`: a character vector\n- `indent`: a vector of length `length(x)` with non-negative integers\n- `incr`: non-negative integer: number of spaces per indent level\n- `including_newline`: boolean: should newlines also be indented\n\n**Value**\n\n`x` indented by left-padding with `codeindent*incr` white-spaces.\n\n**Examples**\n\n```r\nindent_string(\"a\", 0)\nindent_string(\"a\", 1)\nindent_string(letters[1:3], 0:2)\nindent_string(paste0(letters[1:3], \"\\n\", LETTERS[1:3]), 0:2)\n```\nDescription\n\nInsert a row into an existing table directly before or directly after an existing data (i.e., non-content and non-label) row, specified by its path.\n\nUsage\n\n```r\ninsert_row_at_path(tt, path, value, after = FALSE)\n```\n\n## S4 method for signature 'VTableTree,DataRow'\n```r\ninsert_row_at_path(tt, path, value, after = FALSE)\n```\n\n## S4 method for signature 'VTableTree,ANY'\n```r\ninsert_row_at_path(tt, path, value)\n```\n\nArguments\n\n- `tt` TableTree (or related class). A TableTree object representing a populated table.\n- `path` character. A vector path for a position within the structure of a tabletree. Each element represents a subsequent choice amongst the children of the previous choice.\n- `value` The new value\n- `after` logical(1). Should value be added as a row directly before (FALSE, the default) or after (TRUE) the row specified by path.\n\nSee Also\n\n- `DataRow()`\n- `rrow()`\n\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_rows_by(\"COUNTRY\", split_fun = keep_split_levels(c(\"CHN\", \"USA\"))) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\n\ntbl2 <- insert_row_at_path(tbl, c(\"COUNTRY\", \"CHN\", \"AGE\", \"Mean\"),\n rrow(\"new row\", 555))\n\ntbl2\n\ntbl3 <- insert_row_at_path(tbl2, c(\"COUNTRY\", \"CHN\", \"AGE\", \"Mean\"),\n rrow(\"new row redux\", 888),\n after = TRUE)\n\ntbl3\n```\nDescription\n\nThis function is deprecated and will be removed in a future release of rtables. Please use insert_row_at_path or label_at_path instead.\n\nUsage\n\ninsert_rrow(tbl, rrow, at = 1, ascontent = FALSE)\n\nArguments\n\ntbl rtable\nrrow rrow to append to rtable\nat position into which to put the rrow, defaults to beginning (ie 1)\nascontent logical. Currently ignored.\n\nValue\n\nA TableTree of the same specific class as tbl\n\nNote\n\nLabel rows (ie a row with no data values, only a row.name) can only be inserted at positions which do not already contain a label row when there is a non-trivial nested row structure in tbl\n\nExamples\n\no <- options(warn = 0)\nlyt <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n analyze(\"Sepal.Length\")\ntbl <- build_table(lyt, iris)\n\ninsert_rrow(tbl, rrow(\"Hello World\"))\ninsert_rrow(tbl, rrow(\"Hello World\"), at = 2)\n\nlyt2 <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n split_rows_by(\"Species\") %>%\n analyze(\"Sepal.Length\")\ntbl2 <- build_table(lyt2, iris)\n\ninsert_rrow(tbl2, rrow(\"Hello World\"))\ninsert_rrow(tbl2, rrow(\"Hello World\"), at = 2)\ninsert_rrow(tbl2, rrow(\"Hello World\"), at = 4)\n\ninsert_rrow(tbl2, rrow(\"new row\", 5, 6, 7))\ninsert_rrow(tbl2, rrow(\"new row\", 5, 6, 7), at = 3)\n\noptions(o)\n\n---\n\n**InstantiatedColumnInfo-class**\n\n*InstantiatedColumnInfo*\n\n**Description**\n\nInstantiatedColumnInfo\n\n**Usage**\n\n```r\nInstantiatedColumnInfo(\n treelyt = LayoutColTree(),\n csubs = list(expression(TRUE)),\n extras = list(list()),\n cnts = NA_integer_,\n total_cnt = NA_integer_,\n dispcounts = FALSE,\n countformat = \"(N=xx)\",\n count_na_str = \"\",\n topleft = character()\n)\n```\n\n**Arguments**\n\n- **treelyt**: LayoutColTree.\n- **csubs**: list. List of subsetting expressions.\n- **extras**: list. Extra arguments associated with the columns.\n- **cnts**: integer. Counts.\n- **total_cnt**: integer(1). Total observations represented across all columns.\n- **dispcounts**: logical(1). Should the counts be displayed as header info when the associated table is printed.\n- **countformat**: character(1). Format for the counts if they are displayed.\n- **count_na_str**: character. NA string to be used when formatting counts. Defaults to \"\".\n- **topleft**: character. Override values for the \"top left\" material to be displayed during printing.\nin_rows\n\nCreate multiple rows in analysis or summary functions\n\nDescription\n\ndefine the cells that get placed into multiple rows in a fun\n\nUsage\n\nin_rows(\n ..., \n .list = NULL,\n .names = NULL,\n .labels = NULL,\n .formats = NULL,\n .indent_mods = NULL,\n .cell_footnotes = list(NULL),\n .row_footnotes = list(NULL),\n .aligns = NULL,\n .format_na_strs = NULL\n)\n\nArguments\n\n... single row defining expressions\n\n.list list cell content, usually rcells, the .list is concatenated to ...\n\n.names character or NULL. Names of the returned list/structure.\n\n.labels character or NULL. labels for the defined rows\n\n.formats character or NULL. Formats for the values\n\n.indent_mods integer or NULL. Indent modifications for the defined rows.\n\n.cell_footnotes list. Referential footnote messages to be associated by name with cells\n\n.row_footnotes list. Referential footnotes messages to be associated by name with rows\n\n.aligns character or NULL. Alignments for the cells. Standard for NULL is \"center\". See rtables_aligns for currently supported alignments.\n\n.format_na_strs character or NULL. NA strings for the cells\n\nValue\n\nan RowsVerticalSection object (or NULL). The details of this object should be considered an internal implementation detail.\nis_rtable\n\nis_rtable(65)\n\nSee Also\n\nanalyze()\n\nExamples\n\n\\[\n\\text{in\\_rows}(1, 2, 3, .names = c(\"a\", \"b\", \"c\"))\n\\]\n\n\\[\n\\text{in\\_rows}(1, 2, 3, .labels = c(\"a\", \"b\", \"c\"))\n\\]\n\n\\[\n\\text{in\\_rows}(1, 2, 3, .names = c(\"a\", \"b\", \"c\"), .labels = c(\"AAA\", \"BBB\", \"CCC\"))\n\\]\n\n\\[\n\\text{in\\_rows}(\\text{.list} = \\text{list}(a = 1, b = 2, c = 3))\n\\]\n\n\\[\n\\text{in\\_rows}(1, 2, \\text{.list} = \\text{list}(3), .names = c(\"a\", \"b\", \"c\"))\n\\]\n\n\\[\n\\text{lyt} \\leftarrow \\text{basic\\_table()} \\%\\%\n\\hspace{1em} \\text{split\\_cols\\_by(\"ARM\")} \\%\\%\n\\hspace{1em} \\text{analyze(\"AGE\", \\text{afun} = \\text{function}(x) \\{}\n\\hspace{2em} \\text{in\\_rows(}\n\\hspace{3em} \\text{\"Mean (sd)\"} = \\text{rcell}(\\text{mean}(x), \\text{sd}(x)), \\text{format = \"xx.xx (xx.xx)\");}\n\\hspace{3em} \\text{\"Range\"} = \\text{rcell}(\\text{range}(x), \\text{format = \"xx.xx - xx.xx\")}\n\\hspace{2em}\\})\n\\hspace{1em})\n\\]\n\n\\[\n\\text{tbl} \\leftarrow \\text{build\\_table(lyt, ex\\_adsl)}\n\\]\n\n\\[\n\\text{tbl}\n\\]\n\n---\n\nis_rtable\n\nCheck if an object is a valid rtable\n\nDescription\n\nCheck if an object is a valid rtable\n\nUsage\n\nis_rtable(x)\n\nArguments\n\nx an object\n\nValue\n\nTRUE if x is a formal Table object, FALSE otherwise.\n\nExamples\n\nis_rtable(build_table(basic_table(), iris))\nLabelRow\n\nRow classes and constructors\n\nUsage\n\nLabelRow(\n lev = 1L,\n label = \"\",\n name = label,\n vis = !is.na(label) & nzchar(label),\n cinfo = EmptyColInfo,\n indent_mod = 0L,\n table_inset = 0L\n)\n\n.tablerow(\n vals = list(),\n name = \"\",\n lev = 1L,\n label = name,\n cspan = rep(1L, length(vals)),\n cinfo = EmptyColInfo,\n var = NA_character_,\n format = NULL,\n na_str = NA_character_,\n klass,\n indent_mod = 0L,\n footnotes = list(),\n table_inset = 0L\n)\n\nDataRow(...)\n\nContentRow(...)\n\nArguments\n\nlev integer. Nesting level (roughly, indentation level in practical terms).\nlabel character(1). A label (not to be confused with the name) for the object/structure.\nname character(1). Name of the split/table/row being created. Defaults to same as the corresponding label, but is not required to be.\n**label_at_path**\n\n**vis** logical. Should the row be visible (LabelRow only).\n\n**cinfo** InstantiatedColumnInfo (or NULL). Column structure for the object being created.\n\n**indent_mod** numeric. Modifier for the default indent position for the structure created by this function (subtable, content table, or row) and all of that structure's children. Defaults to 0, which corresponds to the unmodified default behavior.\n\n**table_inset** numeric(1). Number of spaces to inset the table header, table body, referential footnotes, and main footer, as compared to alignment of title, subtitle, and provenance footer. Defaults to 0 (no inset).\n\n**vals** list. Cell values for the row\n\n**cspan** integer. Column span. 1 indicates no spanning.\n\n**var** string, variable name\n\n**format** FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\n\n**na_str** character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\n\n**klass** Internal detail.\n\n**footnotes** list or NULL. Referential footnotes to be applied at current level\n\n... passed to shared constructor (.tablerow).\n\n**Value**\n\nA formal object representing a table row of the constructed type.\n\n**Author(s)**\n\nGabriel Becker\n\n---\n\n**Description**\n\nGets or sets the label at a path\n\n**Usage**\n\n```\nlabel_at_path(tt, path)\n```\n\n```\nlabel_at_path(tt, path) <- value\n```\nArguments\n\n- `tt`: TableTree (or related class). A TableTree object representing a populated table.\n- `path`: character. A vector path for a position within the structure of a tabletree. Each element represents a subsequent choice amongst the children of the previous choice.\n- `value`: The new value\n\nDetails\n\nIf `path` resolves to a single row, the label for that row is retrieved or set. If, instead, `path` resolves to a subtable, the text for the row-label associated with that path is retrieved or set. In the subtable case, if the label text is set to a non-NA value, the labelrow will be set to visible, even if it was not before. Similarly, if the label row text for a subtable is set to NA, the label row will be set to non-visible, so the row will not appear at all when the table is printed.\n\nNote\n\nWhen changing the row labels for content rows, it is important to path all the way to the row. Paths ending in \"@content\" will not exhibit the behavior you want, and are thus an error. See `row_paths` for help determining the full paths to content rows.\n\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_rows_by(\"COUNTRY\", split_fun = keep_split_levels(c(\"CHN\", \"USA\"))) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\n\nlabel_at_path(tbl, c(\"COUNTRY\", \"CHN\"))\n\nlabel_at_path(tbl, c(\"COUNTRY\", \"USA\")) <- \"United States\"\n\ntbl\n```\n\n---\n\n**length,CellValue-method**\n\n*Length of a Cell value*\n\nDescription\n\nLength of a Cell value\n\nUsage\n\n```r\n## S4 method for signature 'CellValue'\nlength(x)\n```\n**Arguments**\n\n\\[\nx \\quad x.\n\\]\n\n**Value**\n\nAlways returns 1L\n\n---\n\n**Description**\n\nReturns a function that coerces the return values of \\( f \\) to a list\n\n**Usage**\n\n\\[\n\\text{list\\_wrap\\_x}(f) \\\\\n\\text{list\\_wrap\\_df}(f)\n\\]\n\n**Arguments**\n\n\\[\nf \\quad \\text{The function to wrap.}\n\\]\n\n**Details**\n\n\\( \\text{list\\_wrap\\_x} \\) generates a wrapper which takes \\( x \\) as its first argument, while \\( \\text{list\\_wrap\\_df} \\) generates an otherwise identical wrapper function whose first argument is named \\( \\text{df} \\).\n\nWe provide both because when using the functions as tabulation in \\texttt{analyze}, functions which take \\( \\text{df} \\) as their first argument are passed the full subset dataframe, while those which accept anything else notably including \\( x \\) are passed only the relevant subset of the variable being analyzed.\n\n**Value**\n\nA function which calls \\( f \\) and converts the result to a list of CellValue objects.\n\n**Author(s)**\n\nGabriel Becker\nExamples\n\n```r\nsummary(iris$Sepal.Length)\n\nf <- list_wrap_x(summary)\nf(x = iris$Sepal.Length)\n\nf2 <- list_wrap_df(summary)\nf2(df = iris$Sepal.Length)\n```\n\nDescription\n\nLayouting Function Arg Conventions\n\nUsage\n\n```r\nlyt_args(\n lyt, \n var, \n vars, \n label, \n labels_var, \n varlabels, \n varnames, \n split_format, \n split_na_str, \n nested, \n format, \n cfun, \n cformat, \n cna_str, \n split_fun, \n split_name, \n split_label, \n afun, \n inclNAs, \n valorder, \n ref_group, \n compfun, \n label_fstr, \n child_labels, \n extra_args, \n name,\n)```\n### lyt_args\n\ncuts, \ncutlabels, \ncutfun, \ncutlabelfun, \ncumulative, \nindent_mod, \nshow_labels, \nlabel_pos, \nvar_labels, \ncvar, \ntable_names, \ntopleft, \nalign, \npage_by, \npage_prefix, \nformat_na_str, \nsection_div, \nna_str \n)\n\n#### Arguments\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>lYT</td>\n<td>layout object pre-data used for tabulation</td>\n</tr>\n<tr>\n<td>var</td>\n<td>string, variable name</td>\n</tr>\n<tr>\n<td>vars</td>\n<td>character vector. Multiple variable names.</td>\n</tr>\n<tr>\n<td>label</td>\n<td>character(1). A label (not to be confused with the name) for the object/structure.</td>\n</tr>\n<tr>\n<td>labels_var</td>\n<td>string, name of variable containing labels to be displayed for the values of var</td>\n</tr>\n<tr>\n<td>varlabels</td>\n<td>character vector. Labels for vars</td>\n</tr>\n<tr>\n<td>varnames</td>\n<td>character vector. Names for vars which will appear in pathing. When vars are all unique this will be the variable names. If not, these will be variable names with suffixes as necessary to enforce uniqueness.</td>\n</tr>\n<tr>\n<td>split_format</td>\n<td>FormatSpec. Default format associated with the split being created.</td>\n</tr>\n<tr>\n<td>split_na_str</td>\n<td>character vector for use with split_format.</td>\n</tr>\n<tr>\n<td>nested</td>\n<td>boolean. Should this layout instruction be applied within the existing layout structure if possible (TRUE, the default) or as a new top-level element (FALSE). Ignored if it would nest a split underneath analyses, which is not allowed.</td>\n</tr>\n<tr>\n<td>format</td>\n<td>FormatSpec. Format associated with this split. Formats can be declared via strings ("xx.x") or function. In cases such as analyze calls, they can character vectors or lists of functions.</td>\n</tr>\n<tr>\n<td>cfun</td>\n<td>list/function/NULL. tabulation function(s) for creating content rows. Must accept x or df as first parameter. Must accept labelstr as the second argument. Can optionally accept all optional arguments accepted by analysis functions. See analyze.</td>\n</tr>\n<tr>\n<td>cformat</td>\n<td>format spec. Format for content rows</td>\n</tr>\n<tr>\n<td>cna_str</td>\n<td>character. NA string for use with cformat for content table.</td>\n</tr>\n<tr>\n<td><strong>split_fun</strong></td>\n<td>function/NULL. Custom splitting function. See <code>custom_split_funs</code></td>\n</tr>\n<tr>\n<td><strong>split_name</strong></td>\n<td>String. Name associated with this split (for pathing, etc)</td>\n</tr>\n<tr>\n<td><strong>split_label</strong></td>\n<td>String. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).</td>\n</tr>\n<tr>\n<td><strong>afun</strong></td>\n<td>Function. Analysis function, must take <code>x</code> or <code>df</code> as its first parameter. Can optionally take other parameters which will be populated by the tabulation framework. See Details in <code>analyze</code>.</td>\n</tr>\n<tr>\n<td><strong>inclNAs</strong></td>\n<td>Boolean. Should observations with NA in the <code>var</code> variable(s) be included when performing this analysis. Defaults to FALSE.</td>\n</tr>\n<tr>\n<td><strong>valorder</strong></td>\n<td>Character vector. Order that the split children should appear in resulting table.</td>\n</tr>\n<tr>\n<td><strong>ref_group</strong></td>\n<td>Character. Value of <code>var</code> to be taken as the ref_group/control to be compared against.</td>\n</tr>\n<tr>\n<td><strong>compfun</strong></td>\n<td>Function/string. The comparison function which accepts the analysis function outputs for two different partitions and returns a single value. Defaults to subtraction. If a string, taken as the name of a function.</td>\n</tr>\n<tr>\n<td><strong>label_fstr</strong></td>\n<td>String. An sprintf style format string containing. For non-comparison splits, it can contain up to one "%s" which takes the current split value and generates the row/column label. Comparison-based splits it can contain up to two "%s".</td>\n</tr>\n<tr>\n<td><strong>child_labels</strong></td>\n<td>String. One of "default", "visible", "hidden". What should the display behavior be for the labels (ie label rows) of the children of this split. Defaults to "default" which flags the label row as visible only if the child has 0 content rows.</td>\n</tr>\n<tr>\n<td><strong>extra_args</strong></td>\n<td>List. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.</td>\n</tr>\n<tr>\n<td><strong>name</strong></td>\n<td>Character(1). Name of the split/table/row being created. Defaults to same as the corresponding label, but is not required to be.</td>\n</tr>\n<tr>\n<td><strong>cuts</strong></td>\n<td>Numeric. Cuts to use</td>\n</tr>\n<tr>\n<td><strong>cutlabels</strong></td>\n<td>Character (or NULL). Labels for the cuts</td>\n</tr>\n<tr>\n<td><strong>cutfun</strong></td>\n<td>Function. Function which accepts the full vector of <code>var</code> values and returns cut points to be used (via <code>cut</code>) when splitting data during tabulation</td>\n</tr>\n<tr>\n<td><strong>cutlabelfun</strong></td>\n<td>Function. Function which returns either labels for the cuts or NULL when passed the return value of <code>cutfun</code></td>\n</tr>\n<tr>\n<td><strong>cumulative</strong></td>\n<td>Logical. Should the cuts be treated as cumulative. Defaults to FALSE.</td>\n</tr>\n<tr>\n<td><strong>indent_mod</strong></td>\n<td>Numeric. Modifier for the default indent position for the structure created by this function (subtable, content table, or row) and all of that structure’s children. Defaults to 0, which corresponds to the unmodified default behavior.</td>\n</tr>\n<tr>\n<td><strong>show_labels</strong></td>\n<td>Character(1). Should the variable labels for corresponding to the variable(s) in <code>vars</code> be visible in the resulting table.</td>\n</tr>\n</tbody>\n</table>\n\n\nlabel_pos character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\n\ncvar character(1). The variable, if any, which the content function should accept. Defaults to NA.\n\ntable_names character. Names for the tables representing each atomic analysis. Defaults to var.\n\ntopleft character. Override values for the \"top left\" material to be displayed during printing.\n\nalign character(1) or NULL. Alignment the value should be rendered with. It defaults to \"center\" if NULL is used. See rtables_aligns for currently supported alignments.\n\npage_by logical(1). Should pagination be forced between different children resulting form this split.\n\ngroup_prefix character(1). Prefix, to be appended with the split value, when forcing pagination between the children of this split/table\n\nformat_na_str character(1). String which should be displayed when formatted if this cell’s value(s) are all NA.\n\nsection_div character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\n\nna_str character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\n\nValue\n\nNULL (this is an argument template dummy function)\n\nSee Also\n\nOther conventions: compat_args(), constr_args(), gen_args(), sf_args()\nUsage\n\n```r\nmake_afun(\n fun,\n .stats = NULL,\n .formats = NULL,\n .labels = NULL,\n .indent_mods = NULL,\n .ungroup_stats = NULL,\n .format_na_strs = NULL,\n ...\n .null_ref_cells = \".in_ref_col\" %in% names(formals(fun))\n)\n```\n\nArguments\n\n- **fun** function. The function to be wrapped in a new customized analysis fun. Should return named list.\n- **.stats** character. Names of elements to keep from `fun`'s full output.\n- **.formats** ANY. vector/list of formats to override any defaults applied by `fun`.\n- **.labels** character. Vector of labels to override defaults returned by `fun`.\n- **.indent_mods** integer. Named vector of indent modifiers for the generated rows.\n- **.ungroup_stats** character. Vector of names, which must match elements of `.stats`.\n- **.format_na_strs** ANY. vector/list of na strings to override any defaults applied by `fun`.\n- **...** dots. Additional arguments to `fun` which effectively become new defaults. These can still be overridden by extra args within a split.\n- **.null_ref_cells** logical(1). Should cells for the reference column be NULL-ed by the returned analysis function. Defaults to TRUE if `fun` accepts `.in_ref_col` as a formal argument. Note this argument occurs after `...` so it must be fully specified by name when set.\n\nValue\n\nA function suitable for use in `analyze` with element selection, reformatting, and relabeling performed automatically.\n\nNote\n\nSetting `.ungroup_stats` to non-null changes the structure of the value(s) returned by `fun`, rather than just labeling (.labels), formatting (.formats), and selecting amongst (.stats) them. This means that subsequent `make_afun` calls to customize the output further both can and must operate on the new structure, *NOT* the original structure returned by `fun`. See the final pair of examples below.\nSee Also\n\nanalyze()\n\nExamples\n\ns_summary <- function(x) {\n stopifnot(is.numeric(x))\n\n list(\n n = sum(!is.na(x)),\n mean_sd = c(mean = mean(x), sd = sd(x)),\n min_max = range(x)\n )\n}\n\ns_summary(iris$Sepal.Length)\n\na_summary <- make_afun(\n fun = s_summary,\n .formats = c(n = \"xx\", mean_sd = \"xx.xx (xx.xx)\", min_max = \"xx.xx - xx.xx\"),\n .labels = c(n = \"n\", mean_sd = \"Mean (sd)\", min_max = \"min - max\")\n)\n\na_summary(x = iris$Sepal.Length)\n\na_summary2 <- make_afun(a_summary, .stats = c(\"n\", \"mean_sd\"))\n\na_summary2(x = iris$Sepal.Length)\n\na_summary3 <- make_afun(a_summary, .formats = c(mean_sd = \"(xx.xxx, xx.xxx)\"))\n\ns_foo <- function(df, .N_col, a = 1, b = 2) {\n list(\n nrow_df = nrow(df),\n .N_col = .N_col,\n a = a,\n b = b\n )\n}\n\ns_foo(iris, 40)\n\na_foo <- make_afun(s_foo, b = 4,\n .formats = c(nrow_df = \"xx.xx\", \".N_col\" = \"xx.\", a = \"xx\", b = \"xx.x\"),\n .labels = c(nrow_df = \"Nrow df\",\n \".N_col\" = \"n in cols\", a = \"a value\", b = \"b value\"),\n .indent_mods = c(nrow_df = 2L, a = 1L)\n)\na_foo(iris, .N_col = 40)\na_foo2 <- make_afun(a_foo, .labels = c(nrow_df = \"Number of Rows\"))\na_foo2(iris, .N_col = 40)\n\n#grouping and further customization\ns_grp <- function(df, .N_col, a = 1, b = 2) {\n list(\n nrow_df = nrow(df),\n .N_col = .N_col,\n letters = list(a = a,\n b = b)\n )\n}\na_grp <- make_afun(s_grp, b = 3,\n .labels = c(nrow_df = \"row count\",\n .N_col = \"count in column\"),\n .formats = c(nrow_df = \"xx.\", .N_col = \"xx.\"),\n .indent_mod = c(letters = 1L),\n .ungroup_stats = \"letters\")\na_grp(iris, 40)\na_aftergrp <- make_afun(a_grp, .stats = c(\"nrow_df\", \"b\"),\n .formats = c(b = \"xx.\"))\na_aftergrp(iris, 40)\n\ns_ref <- function(x, .in_ref_col, .ref_group) {\n list(\n mean_diff = mean(x) - mean(.ref_group)\n )\n}\na_ref <- make_afun(s_ref,\n .labels = c( mean_diff = \"Mean Difference from Ref\"))\na_ref(iris$Sepal.Length, .in_ref_col = TRUE, 1:10)\na_ref(iris$Sepal.Length, .in_ref_col = FALSE, 1:10)\n\n---\n\nmake_col_df \n\nColumn Layout Summary\n\nDescription\nGenerate a structural summary of the columns of an rtables table and return it as a data.frame.\n\nUsage\nmake_col_df(tt, colwidths = NULL, visible_only = TRUE)\nmake_split_fun\n\nArguments\n\n- **tt**: ANY. Object representing the table-like object to be summarized.\n- **colwidths**: numeric. Internal detail do not set manually.\n- **visible_only**: logical(1). Should only visible aspects of the table structure be reflected in this summary. Defaults to TRUE. May not be supported by all methods.\n\nDetails\n\nUsed for Pagination\n\n---\n\n**make_split_fun**\n\nCreate a Custom Splitting Function\n\nDescription\n\nCreate a Custom Splitting Function\n\nUsage\n\nmake_split_fun(pre = list(), core_split = NULL, post = list())\n\nArguments\n\n- **pre**: list. Zero or more functions which operate on the incoming data and return a new data frame that should split via core_split. They will be called on the data in the order they appear in the list.\n- **core_split**: function or NULL. If not NULL, a function which accepts the same arguments do_base_split does, and returns the same type of named list. Custom functions which override this behavior cannot be used in column splits.\n- **post**: list. Zero or more functions which should be called on the list output by splitting.\n\nDetails\n\nCustom split functions can be thought of as (up to) 3 different types of manipulations of the splitting process:\n\n1. Preprocessing of the incoming data to be split\n2. (Row-splitting only) Customization of the core mapping of incoming data to facets, and\n3. Postprocessing operations on the set of facets (groups) generated by the split.\n\nThis function provides an interface to create custom split functions by implementing and specifying sets of operations in each of those classes of customization independently.\n\nPreprocessing functions (1), must accept: df, spl, vals, labels, and can optionally accept .spl_context. They then manipulate df (the incoming data for the split) and return a modified data.frame. This modified data.frame must contain all columns present in the incoming data.frame, but can add\ncolumns if necessary (though we note that these new columns cannot be used in the layout as split or analysis variables, because they will not be present when validity checking is done).\n\nThe preprocessing component is useful for things such as manipulating factor levels, e.g., to trim unobserved ones or to reorder levels based on observed counts, etc.\n\nCustomization of core splitting (2) is currently only supported in row splits. Core splitting functions override the fundamental splitting procedure, and are only necessary in rare cases. These must accept `spl`, `df`, `vals`, `labels`, and can optionally accept `spl_context`. They must return a named list with elements, all of the same length, as follows:\n\n- `datasplit` (containing a list of data.frames).\n- `values` containing values associated with the facets, which must be character or `SplitValue` objects. These values will appear in the paths of the resulting table.\n- `labels` containing the character labels associated with `values`.\n\nPostprocessing functions (3) must accept the result of the core split as their first argument (which as of writing can be anything), in addition to `spl`, and `fulldf`, and can optionally accept `spl_context`. They must each return a modified version of the same structure specified above for core splitting.\n\nIn both the pre- and post-processing cases, multiple functions can be specified. When this happens, they are applied sequentially, in the order they appear in the list passed to the relevant argument (pre and post, respectively).\n\n**Value**\n\nA function for use as a custom split function.\n\n**See Also**\n\n`custom_split_funs` for a more detailed discussion on what custom split functions do.\n\nOther `make_custom_split`: `add_combo_facet()`, `drop_facet_levels()`, `make_split_result()`, `trim_levels_in_facets()`\n\n**Examples**\n\n```r\ndef <- make_split_fun(pre = list(drop_facet_levels),\n post = list(add_overall_facet(\"ALL\", \"All Arms\")))\n\nbasic_table(show_colcounts = TRUE) %>%\n split_cols_by(\"ARM\", split_fun = def) %>%\n analyze(\"AGE\") %>%\n build_table(subset(DM, ARM %in% c(\"B: Placebo\", \"C: Combination\")))\n```\n\n```r\n# post (and pre) arguments can take multiple functions, here\n# we add an overall facet and the reorder the facets\nreorder_facets <- function(splret, spl, fulldf, ...) {\n ord <- order(names(splret$values))\n make_split_result(splret$values[ord],\n splret$datasplit[ord],\n splret$labels[ord])\n}\n```\nmake_split_result\n\nThese functions can be used to create or add to a split result in functions which implement core\nsplitting or post-processing within a custom split function.\n\nUsage\n\nmake_split_result(values, datasplit, labels, extras = NULL)\n\nadd_to_split_result(splres, values, datasplit, labels, extras = NULL)\n\nArguments\n\nvalues character or list(SplitValue). The values associated with each facet\ndatasplit list(data.frame). The facet data for each facet generated in the split\nlabels character. The labels associated with each facet\nManualSplit\n\nManually defined split\n\nDescription\n\nManually defined split\n\nUsage\n\n```r\nManualSplit(\n levels,\n label,\n name = \"manual\",\n extra_args = list(),\n indent_mod = 0L,\n cindent_mod = 0L,\n cvar = \"\",\n cextra_args = list(),\n label_pos = \"visible\",\n```\nArguments\n\nlevels character. Levels of the split (i.e., the children of the manual split).\nlabel character(1). A label (not to be confused with the name) for the object/structure.\nname character(1). Name of the split/table/row being created. Defaults to same as the corresponding label, but is not required to be.\nextra_args list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\nindent_mod numeric. Modifier for the default indent position for the structure created by this function (subtable, content table, or row) and all of that structure's children. Defaults to 0, which corresponds to the unmodified default behavior.\ncindent_mod numeric(1). The indent modifier for the content tables generated by this split.\ncvar character(1). The variable, if any, which the content function should accept. Defaults to NA.\ncextra_args list. Extra arguments to be passed to the content function when tabulating row group summaries.\nlabel_pos character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\npage_prefix character(1). Prefix, to be appended with the split value, when forcing pagination between the children of this split/table.\nsection_div character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\n\nValue\n\nA ManualSplit object.\n\nAuthor(s)\n\nGabriel Becker\nManual column declaration\n\nDescription\n\nManual column declaration\n\nUsage\n\nmanual_cols(..., .lst = list(...))\n\nArguments\n\n... One or more vectors of levels to appear in the column space. If more than one set of levels is given, the values of the second are nested within each value of the first, and so on.\n\n.lst A list of sets of levels, by default populated via list(...).\n\nValue\n\nAn InstantiatedColumnInfo object, suitable for use declaring the column structure for a manually constructed table.\n\nAuthor(s)\n\nGabriel Becker\n\nExamples\n\n# simple one level column space\nrows <- lapply(1:5, function(i) {\n DataRow(rep(i, times = 3))\n})\ntbl1 <- TableTree(kids = rows, cinfo = manual_cols(split = c(\"a\", \"b\", \"c\")))\ntbl1\n\n# manually declared nesting\ntbl2 <- TableTree(kids = list(DataRow(as.list(1:4))),\n cinfo = manual_cols(Arm = c(\"Arm A\", \"Arm B\"),\n Gender = c(\"M\", \"F\")))\ntbl2\n**matrix_form**, **VTableTree-method**\n\n*Transform rtable to a list of matrices which can be used for outputting*\n\n**Description**\n\nAlthough rtables are represented as a tree data structure when outputting the table to ASCII or HTML it is useful to map the rtable to an in between state with the formatted cells in a matrix form.\n\n**Usage**\n\n```r\n## S4 method for signature 'VTableTree'\nmatrix_form(\n obj,\n indent_rownames = FALSE,\n expand_newlines = TRUE,\n indent_size = 2\n)\n```\n\n**Arguments**\n\n- `obj` ANY. The object for the accessor to access or modify\n- `indent_rownames` logical(1), if TRUE the column with the row names in the strings matrix of has indented row names (strings pre-fixed)\n- `expand_newlines` logical(1). Should the matrix form generated expand rows whose values contain newlines into multiple 'physical' rows (as they will appear when rendered into ASCII). Defaults to TRUE\n- `indent_size` numeric(1). Number of spaces to use per indent level. Defaults to 2\n\n**Details**\n\nThe strings in the return object are defined as follows: row labels are those determined by `make_row_df` and cell values are determined using `get_formatted_cells`. (Column labels are calculated using a non-exported internal function.\n\n**Value**\n\nA list with the following elements:\n\n- **strings** The content, as it should be printed, of the top-left material, column headers, row labels , and cell values of tt\n- **spans** The column-span information for each print-string in the strings matrix\n- **aligns** The text alignment for each print-string in the strings matrix\n- **display** Whether each print-string in the strings matrix should be printed or not.\n**row_info** the data.frame generated by `make_row_df`\n\nWith an additional `nrow_header` attribute indicating the number of pseudo \"rows\" the column structure defines.\n\n**Examples**\n\n```r\nlibrary(dplyr)\n\niris2 <- iris %>%\ngroup_by(Species) %>%\nmutate(group = as.factor(rep_len(c(\"a\", \"b\"), length.out = n()))) %>%\nungroup()\n\nlyt <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n split_cols_by(\"group\") %>%\n analyze(c(\"Sepal.Length\", \"Petal.Width\"),\n afun = list_wrap_x(summary), format = \"xx.xx\")\n\nlyt\n\ntbl <- build_table(lyt, iris2)\n\nmatrix_form(tbl)\n```\n\n### MultiVarSplit\n\n**Split between two or more different variables**\n\n**Description**\n\nSplit between two or more different variables\n\n**Usage**\n\n```r\nMultiVarSplit(\n vars,\n split_label = \"\",\n varlabels = NULL,\n varnames = NULL,\n cfun = NULL,\n cformat = NULL,\n cna_str = NA_character_,\n split_format = NULL,\n split_na_str = NA_character_,\n split_name = \"multivars\",\n child_labels = c(\"default\", \"visible\", \"hidden\"),\n extra_args = list(),\n indent_mod = 0L,\n)```\ncindent_mod = 0L,\ncvar = \"\",\ncextra_args = list(),\nlabel_pos = \"visible\",\nsplit_fun = NULL,\npage_prefix = NA_character_,\nsection_div = NA_character_\n)\n\nArguments\n\nvars character vector. Multiple variable names.\nsplit_label string. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).\nvarlabels character vector. Labels for vars\nvarnames character vector. Names for vars which will appear in pathing. When vars are all unique this will be the variable names. If not, these will be variable names with suffixes as necessary to enforce uniqueness.\ncfun list/function/NULL. tabulation function(s) for creating content rows. Must accept x or df as first parameter. Must accept labelstr as the second argument. Can optionally accept all optional arguments accepted by analysis functions. See analyze.\ncformat format spec. Format for content rows\ncna_str character. NA string for use with cformat for content table.\nsplit_format FormatSpec. Default format associated with the split being created.\nsplit_na_str character. NA string vector for use with split_format.\nsplit_name string. Name associated with this split (for pathing, etc)\nchild_labels string. One of \"default\", \"visible\", \"hidden\". What should the display behavior be for the labels (ie label rows) of the children of this split. Defaults to \"default\" which flags the label row as visible only if the child has 0 content rows.\nextra_args list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\nindent_mod numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure's children. Defaults to 0, which corresponds to the unmodified default behavior.\ncindent_mod numeric(1). The indent modifier for the content tables generated by this split.\ncvar character(1). The variable, if any, which the content function should accept. Defaults to NA.\ncextra_args list. Extra arguments to be passed to the content function when tabulating row group summaries.\nlabel_pos character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\n\nsplit_fun function/NULL. custom splitting function. See custom_split_funs\n\npage_prefix character(1). Prefix, to be appended with the split value, when forcing pagination between the children of this split/table\n\nsection_div character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\n\nValue\n\nA MultiVarSplit object.\n\nAuthor(s)\n\nGabriel Becker\n\n---\n\n### Description\n\nNames of a TableTree\n\n### Usage\n\n```r\n## S4 method for signature 'VTableNodeInfo'\nnames(x)\n\n## S4 method for signature 'InstantiatedColumnInfo'\nnames(x)\n\n## S4 method for signature 'LayoutColTree'\nnames(x)\n\n## S4 method for signature 'VTableTree'\nrow.names(x)\n```\n\n### Arguments\n\n- **x** the object.\nDetails\nFor TableTrees with more than one level of splitting in columns, the names are defined to be the\ntop-level split values reped out across the columns that they span.\n\nValue\nThe column names of \\( x \\), as defined in the details above.\n\n---\n\nno_colinfo \nExported for use in tern\n\nDescription\nDoes the table/row/InstantiatedColumnInfo object contain no column structure information?\n\nUsage\n\n```r\nno_colinfo(obj)\n```\n\n## S4 method for signature 'VTableNodeInfo'\n\n```r\nno_colinfo(obj)\n```\n\n## S4 method for signature 'InstantiatedColumnInfo'\n\n```r\nno_colinfo(obj)\n```\n\nArguments\n\n- `obj` \n ANY. The object for the accessor to access or modify\n\nValue\n\nTRUE if the object has no/empty instantiated column information, FALSE otherwise.\n\n---\n\nnrow,VTableTree-method\n\nTable Dimensions\n\nDescription\n\nTable Dimensions\nUsage\n\n## S4 method for signature 'VTableTree'\nnrow(x)\n\n## S4 method for signature 'VTableNodeInfo'\nncol(x)\n\n## S4 method for signature 'VTableNodeInfo'\ndim(x)\n\nArguments\n\nx\n\nTableTree or ElementaryTable object\n\nValue\n\nthe number of rows (nrow), columns (ncol) or both (dim) of the object.\n\nExamples\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n analyze(c(\"SEX\", \"AGE\"))\n\ntbl <- build_table(lyt, ex_adsl)\n\ndim(tbl)\nnrow(tbl)\ncol(tbl)\n\nNROW(tbl)\nNCOL(tbl)\n\n---\n\nobj_avar\n\nRow attribute accessors\n\nDescription\n\nRow attribute accessors\n\nUsage\n\nobj_avar(obj)\n\n## S4 method for signature 'TableRow'\nobj_avar(obj)\n## S4 method for signature 'ElementaryTable'\n\n```r\nobj_aivar(obj)\nrow_cells(obj)\n```\n\n## S4 method for signature 'TableRow'\n\n```r\nrow_cells(obj)\nrow_cells(obj) <- value\n```\n\n## S4 replacement method for signature 'TableRow'\n\n```r\nrow_cells(obj) <- value\nrow_values(obj)\nrow_values(obj) <- value\n```\n\n## S4 replacement method for signature 'TableRow'\n\n```r\nrow_values(obj) <- value\n```\n\n## S4 replacement method for signature 'LabelRow'\n\n```r\nrow_values(obj) <- value\n```\n\n### Arguments\n\n- **obj**\n - ANY. The object for the accessor to access or modify\n\n- **value**\n - The new value\n\n### Value\n\nvarious, depending on the accessor called.\n\n---\n\nMethods for generics in the formatters package\n\n### Description\n\nSee the formatters documentation for descriptions of these generics.\nUsage\n\n## S4 method for signature 'VNodeInfo'\nobj_name(obj)\n\n## S4 method for signature 'Split'\nobj_name(obj)\n\n## S4 replacement method for signature 'VNodeInfo'\nobj_name(obj) <- value\n\n## S4 replacement method for signature 'Split'\nobj_name(obj) <- value\n\n## S4 method for signature 'Split'\nobj_label(obj)\n\n## S4 method for signature 'TableRow'\nobj_label(obj)\n\n## S4 method for signature 'VTableTree'\nobj_label(obj)\n\n## S4 method for signature 'ValueWrapper'\nobj_label(obj)\n\n## S4 replacement method for signature 'Split'\nobj_label(obj) <- value\n\n## S4 replacement method for signature 'TableRow'\nobj_label(obj) <- value\n\n## S4 replacement method for signature 'ValueWrapper'\nobj_label(obj) <- value\n\n## S4 replacement method for signature 'VTableTree'\nobj_label(obj) <- value\n\n## S4 method for signature 'VTableNodeInfo'\nobj_format(obj)\n\n## S4 method for signature 'CellValue'\nobj_format(obj)\n\n## S4 method for signature 'Split'\nobj_format(obj)\n\n## S4 replacement method for signature 'VTableNodeInfo'\nobj_format(obj) <- value\n## S4 replacement method for signature 'Split'\nobj_format(obj) <- value\n\n## S4 replacement method for signature 'CellValue'\nobj_format(obj) <- value\n\n## S4 method for signature 'Split'\nobj_na_str(obj)\n\n## S4 method for signature 'VTitleFooter'\nmain_title(obj)\n\n## S4 replacement method for signature 'VTitleFooter'\nmain_title(obj) <- value\n\n## S4 method for signature 'VTitleFooter'\nsubtitles(obj)\n\n## S4 replacement method for signature 'VTitleFooter'\nsubtitles(obj) <- value\n\n## S4 method for signature 'VTitleFooter'\nmain_footer(obj)\n\n## S4 replacement method for signature 'VTitleFooter'\nmain_footer(obj) <- value\n\n## S4 method for signature 'VTitleFooter'\nprov_footer(obj)\n\n## S4 replacement method for signature 'VTitleFooter'\nprov_footer(obj) <- value\n\n## S4 method for signature 'VTableNodeInfo'\ntable_inset(obj)\n\n## S4 method for signature 'PreDataTableLayouts'\ntable_inset(obj)\n\n## S4 replacement method for signature 'VTableNodeInfo'\ntable_inset(obj) <- value\n\n## S4 replacement method for signature 'PreDataTableLayouts'\ntable_inset(obj) <- value\n\n## S4 replacement method for signature 'InstantiatedColumnInfo'\ntable_inset(obj) <- value\n## S4 method for signature 'TableRow'\n\\texttt{nlines}(x, \\texttt{colwidths} = \\texttt{NULL}, \\texttt{max\\_width} = \\texttt{NULL})\n\n## S4 method for signature 'LabelRow'\n\\texttt{nlines}(x, \\texttt{colwidths} = \\texttt{NULL}, \\texttt{max\\_width} = \\texttt{NULL})\n\n## S4 method for signature 'RefFootnote'\n\\texttt{nlines}(x, \\texttt{colwidths} = \\texttt{NULL}, \\texttt{max\\_width} = \\texttt{NULL})\n\n## S4 method for signature 'InstantiatedColumnInfo'\n\\texttt{nlines}(x, \\texttt{colwidths} = \\texttt{NULL}, \\texttt{max\\_width} = \\texttt{NULL})\n\n## S4 method for signature 'VTableTree'\n\\texttt{make\\_row\\_df}(\\ \n\\texttt{tt,}\n\\texttt{\\texttt{colwidths} = \\texttt{NULL},}\n\\texttt{\\texttt{visible\\_only} = \\texttt{TRUE,}}\n\\texttt{\\texttt{rownum} = \\texttt{\\texttt{0},}}\n\\texttt{\\texttt{indent} = \\texttt{\\texttt{0L},}}\n\\texttt{\\texttt{path} = \\texttt{\\texttt{character()},}}\n\\texttt{\\texttt{incontent} = \\texttt{\\texttt{FALSE,}}}\n\\texttt{\\texttt{repr\\_ext} = \\texttt{\\texttt{\\texttt{0L,}}}\n\\texttt{\\texttt{repr\\_inds} = \\texttt{\\texttt{integer(),}}}\n\\texttt{\\texttt{sibpos} = \\texttt{\\texttt{NA\\_integer\\_},}}\n\\texttt{\\texttt{nsibs} = \\texttt{\\texttt{NA\\_integer\\_},}}\n\\texttt{\\texttt{max\\_width} = \\texttt{\\texttt{NULL}}}\n\\texttt{)}\n\n## S4 method for signature 'TableRow'\n\\texttt{make\\_row\\_df}(\\ \n\\texttt{tt,}\n\\texttt{\\texttt{colwidths} = \\texttt{NULL},}\n\\texttt{\\texttt{visible\\_only} = \\texttt{TRUE,}}\n\\texttt{\\texttt{rownum} = \\texttt{\\texttt{0,}}}\n\\texttt{\\texttt{indent} = \\texttt{\\texttt{0L,}}}\n\\texttt{\\texttt{path} = \\texttt{\\texttt{\"root\",}}}\n\\texttt{\\texttt{incontent} = \\texttt{\\texttt{\\texttt{FALSE,}}}\n\\texttt{\\texttt{repr\\_ext} = \\texttt{\\texttt{\\texttt{0L,}}}\n\\texttt{\\texttt{repr\\_inds} = \\texttt{\\texttt{integer(),}}}\n\\texttt{\\texttt{sibpos} = \\texttt{\\texttt{NA\\_integer\\_},}}\n\\texttt{\\texttt{nsibs} = \\texttt{\\texttt{NA\\_integer\\_},}}\n\\texttt{\\texttt{max\\_width} = \\texttt{\\texttt{NULL}}}\n\\texttt{)}\n\n## S4 method for signature 'LabelRow'\n\\texttt{make\\_row\\_df}(\\ \n\\texttt{tt,}\nobj_name, VNodeInfo-method\n\n```r\ncolwidths = NULL,\nvisible_only = TRUE,\nrownum = 0,\nindent = 0L,\npath = \"root\",\nincontent = FALSE,\nrepr_ext = 0L,\nrepr_inds = integer(),\nsibpos = NA_integer_,\nnsibs = NA_integer_,\nmax_width = NULL\n)\n```\n\n**Arguments**\n\n- **obj**: ANY. The object for the accessor to access or modify.\n- **value**: The new value.\n- **x**: An object.\n- **colwidths**: numeric vector. Column widths for use with vertical pagination.\n- **max_width**: numeric(1). Width strings should be wrapped to when determining how many lines they require.\n- **tt**: TableTree (or related class). A TableTree object representing a populated table.\n- **visible_only**: logical(1). Should only visible aspects of the table structure be reflected in this summary. Defaults to TRUE. May not be supported by all methods.\n- **rownum**: numeric(1). Internal detail do not set manually.\n- **indent**: integer(1). Internal detail do not set manually.\n- **path**: character. A vector path for a position within the structure of a tabletree. Each element represents a subsequent choice amongst the children of the previous choice.\n- **incontent**: logical(1). Internal detail do not set manually.\n- **repr_ext**: integer(1). Internal detail do not set manually.\n- **repr_inds**: integer. Internal detail do not set manually.\n- **sibpos**: integer(1). Internal detail do not set manually.\n- **nsibs**: integer(1). Internal detail do not set manually.\n\n**Details**\n\nWhen `visible_only` is TRUE (the default), methods should return a data.frame with exactly one row per visible row in the table-like object. This is useful when reasoning about how a table will print, but does not reflect the full pathing space of the structure (though the paths which are given will all work as is).\n\nIf supported, when `visible_only` is FALSE, every structural element of the table (in row-space) will be reflected in the returned data.frame, meaning the full pathing-space will be represented but some rows in the layout summary will not represent printed rows in the table as it is displayed.\n\nMost arguments beyond `tt` and `visible_only` are present so that `make_row_df` methods can call `make_row_df` recursively and retain information, and should not be set during a top-level call.\nValue\n\nfor getters, the current value of the component being accessed on obj, for setters, a modified copy of obj with the new value.\n\nNote\n\nthe technically present root tree node is excluded from the summary returned by both make_row_df and make_col_df, as it is simply the row/column structure of tt and thus not useful for pathing or pagination.\n\npag_tt_indices Pagination of a TableTree\n\nDescription\n\nPaginate an rtables table in the vertical and/or horizontal direction, as required for the specified page size.\n\nUsage\n\n```r\npag_tt_indices(\n tt,\n lpp = 15,\n min_siblings = 2,\n nosplitin = character(),\n colwidths = NULL,\n max_width = NULL,\n verbose = FALSE\n)\n```\n\n```r\npaginate_table(\n tt,\n page_type = \"letter\",\n font_family = \"Courier\",\n font_size = 8,\n lineheight = 1,\n landscape = FALSE,\n pg_width = NULL,\n pg_height = NULL,\n margins = c(top = 0.5, bottom = 0.5, left = 0.75, right = 0.75),\n lpp = NA_integer_,\n cpp = NA_integer_,\n min_siblings = 2,\n nosplitin = character(),\n colwidths = NULL,\n tf_wrap = FALSE,\n max_width = NULL,\n)```\n\nverbose = FALSE\n\nArguments\n\n**tt**\nTableTree (or related class). A TableTree object representing a populated table.\n\n**lpp**\nnumeric. Maximum lines per page including (re)printed header and context rows\n\n**min_siblings**\nnumeric. Minimum sibling rows which must appear on either side of pagination row for a mid-subtable split to be valid. Defaults to 2.\n\n**nosplitin**\ncharacter. List of names of sub-tables where page-breaks are not allowed, regardless of other considerations. Defaults to none.\n\n**colwidths**\numeric vector. Column widths for use with vertical pagination.\n\n**max_width**\ninteger(1), character(1) or NULL. Width that title and footer (including footnotes) materials should be word-wrapped to. If NULL, it is set to the current print width of the session (getOption(\"width\"). If set to \"auto\", the width of the table (plus any table inset) is used. Ignored completely if tf_wrap is FALSE.\n\n**verbose**\nlogical(1). Should extra debugging messages be shown. Defaults to FALSE.\n\n**page_type**\ncharacter(1). Name of a page type. See page_types. Ignored when pg_width and pg_height are set directly.\n\n**font_family**\ncharacter(1). Name of a font family. An error will be thrown if the family named is not monospaced. Defaults to Courier.\n\n**font_size**\nnumeric(1). Font size, defaults to 12.\n\n**lineheight**\nnumeric(1). Line height, defaults to 1.\n\n**landscape**\nlogical(1). Should the dimensions of page_type be inverted for landscape? Defaults to FALSE, ignored when pg_width and pg_height are set directly.\n\n**pg_width**\nnumeric(1). Page width in inches.\n\n**pg_height**\nnumeric(1). Page height in inches.\n\n**margins**\nnumeric(4). Named numeric vector containing 'bottom', 'left', 'top', and 'right' margins in inches. Defaults to .5 inches for both vertical margins and .75 for both horizontal margins.\n\n**cpp**\nnumeric(1) or NULL. Width (in characters) of the pages for horizontal pagination. NA (the default) indicates cpp should be inferred from the page size; NULL indicates no horizontal pagination should be done regardless of page size.\n\n**tf_wrap**\nlogical(1). Should the texts for title, subtitle, and footnotes be wrapped?\n\nDetails\n\nrtables pagination is context aware, meaning that label rows and row-group summaries (content rows) are repeated after (vertical) pagination, as appropriate. This allows the reader to immediately understand where they are in the table after turning to a new page, but does also mean that a rendered, paginated table will take up more lines of text than rendering the table without pagination would.\nPagination also takes into account word-wrapping of title, footer, column-label, and formatted cell value content.\n\nVertical pagination information (pagination data.frame) is created using (make_row_df)\n\nHorizontal pagination is performed by creating a pagination data.frame for the columns, and then applying the same algorithm used for vertical pagination to it.\n\nIf physical page size and font information are specified, these are used to derive lines-per-page (lpp) and characters-per-page (cpp) values.\n\nThe full multi-direction pagination algorithm then is as follows:\n\n1. Adjust lpp and cpp to account for rendered elements that are not rows (columns)\n • titles/footers/column labels, and horizontal dividers in the vertical pagination case\n • row-labels, table_inset, and top-left materials in the horizontal case\n\n1. Perform 'forced pagination' representing page-by row splits, generating 1 or more tables\n2. Perform vertical pagination separately on each table generated in (1)\n3. Perform horizontal pagination on the entire table and apply the results to each table page generated in (1)-(2)\n4. Return a list of subtables representing full bi-directional pagination\n\nPagination in both directions is done using the Core Pagination Algorithm implemented in the formatters package:\n\nValue\n\nfor pag_tt_indices a list of paginated-groups of row-indices of tt. For paginate_table, The subtables defined by subsetting by the indices defined by pag_tt_indices.\n\nPagination Algorithm\n\nPagination is performed independently in the vertical and horizontal directions based solely on a pagination data.frame, which includes the following information for each row/column:\n\n• number of lines/characters rendering the row will take after word-wrapping (self_extent)\n• the indices (reprint inds) and number of lines (par_extent) of the rows which act as context for the row\n• the row’s number of siblings and position within its siblings\n\nGiven lpp (cpp) already adjusted for rendered elements which are not rows/columns and a dataframe of pagination information, pagination is performed via the following algorithm, and with a start = 1:\n\nCore Pagination Algorithm:\n\n1. Initial guess for pagination point is start + lpp (start + cpp)\n2. While the guess is not a valid pagination position, and guess > start, decrement guess and repeat\nan error is thrown if all possible pagination positions between start and start + lpp (start + cpp) would ever be < start after decrementing\n\n1. Retain pagination index\n2. if pagination point was less than NROW(tt) (ncol(tt)), set start to pos + 1, and repeat steps (1) - (4).\n\nValidating pagination position:\n\nGiven an (already adjusted) lpp or cpp value, a pagination is invalid if:\n\n- The rows/columns on the page would take more than (adjusted) lpp lines/cpp characters to render including\n - word-wrapping\n - (vertical only) context repetition\n- (vertical only) footnote messages and or section divider lines take up too many lines after rendering rows\n- (vertical only) row is a label or content (row-group summary) row\n- (vertical only) row at the pagination point has siblings, and it has less than min_siblings preceding or following siblings\n- pagination would occur within a sub-table listed in nosplitin\n\nExamples\n\n```r\ns_summary <- function(x) {\n if (is.numeric(x)) {\n in_rows(\n \"n\" = rcell(sum(!is.na(x)), format = \"xx\"),\n \"Mean (sd)\" = rcell(c(mean(x, na.rm = TRUE), sd(x, na.rm = TRUE)),\n format = \"xx.xx (xx.xx)\")),\n \"IQR\" = rcell(IQR(x, na.rm = TRUE), format = \"xx.xx\"),\n \"min - max\" = rcell(range(x, na.rm = TRUE), format = \"xx.xx - xx.xx\")\n )\n } else if (is.factor(x)) {\n vs <- as.list(table(x))\n do.call(in_rows, lapply(vs, rcell, format = \"xx\"))\n } else {\n stop(\"type not supported\")\n }\n}\nlyt <- basic_table() %>%\nsplit_cols_by(var = \"ARM\") %>%\nanalyze(c(\"AGE\", \"SEX\", \"BEP01FL\", \"BMRKR1\", \"BMRKR2\", \"COUNTRY\"), afun = s_summary)\n\ntbl <- build_table(lyt, ex_adsl)\n```\npath_enriched_df\n\nTransform TableTree object to Path-Enriched data.frame\n\nDescription\n\nTransform TableTree object to Path-Enriched data.frame\n\nUsage\n\npath_enriched_df(tt, path_fun = collapse_path, value_fun = collapse_values)\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>tt</td>\n<td>TableTree (or related class). A TableTree object representing a populated table.</td>\n</tr>\n<tr>\n<td>path_fun</td>\n<td>function. Function to transform paths into single-string row/column names.</td>\n</tr>\n<tr>\n<td>value_fun</td>\n<td>function. Function to transform cell values into cells of the data.frame. De-</td>\n</tr>\n<tr>\n<td></td>\n<td>faults to collapse_values which creates strings where multi-valued cells are</td>\n</tr>\n<tr>\n<td></td>\n<td>collapsed together, separated by |.</td>\n</tr>\n</tbody>\n</table>\n\nValue\n\nA data frame of tt’s cell values (processed by value_fun, with columns named by the full column paths (processed by path_fun and an additional row_path column with the row paths (processed by by path_fun).\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n analyze(c(\"AGE\", \"BMRKR2\"))\n\ntbl <- build_table(lyt, ex_adsl)\npath_enriched_df(tbl)\n```\n\nDescription\n\nRecursively prune a TableTree\n\nUsage\n\n```r\nprune_table(\n tt,\n prune_func = prune_empty_level,\n stop_depth = NA_real_,\n depth = 0\n)\n```\n\nArguments\n\n- `tt`: TableTree (or related class). A TableTree object representing a populated table.\n- `prune_func`: function. A Function to be called on each subtree which returns TRUE if the entire subtree should be removed.\n- `stop_depth`: numeric(1). The depth after which subtrees should not be checked for pruning. Defaults to `NA` which indicates pruning should happen at all levels.\n- `depth`: numeric(1). Used internally, not intended to be set by the end user.\n\nValue\n\nA TableTree pruned via recursive application of `prune_func`.\n\nSee Also\n\n`prune_empty_level()` for details on this and several other basic pruning functions included in the `rtables` package.\nExamples\n\n```r\nadsl <- ex_adsl\nlevels(adsl$SEX) <- c(levels(ex_adsl$SEX), \"OTHER\")\n\ntbl_to_prune <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"SEX\") %>%\n summarize_row_groups() %>%\n split_rows_by(\"STRATA1\") %>%\n summarize_row_groups() %>%\n analyze(\"AGE\") %>%\n build_table(adsl)\n\ntbl_to_prune %>% prune_table()\n```\n\n```\n\nrbindl_rtables\n\nrbind TableTree and related objects\n\nDescription\n\nrbind TableTree and related objects\n\nUsage\n\n`rbindl_rtables(x, gap = 0, check_headers = TRUE)`\n\n```r\n## S4 method for signature 'VTableNodeInfo'\nrbind(..., deparse.level = 1)\n```\n\n```r\n## S4 method for signature 'VTableNodeInfo,ANY'\nrbind2(x, y)\n```\n\nArguments\n\n- `x`: VTableNodeInfo. TableTree, ElementaryTable or TableRow object.\n- `gap`: deprecated. Ignored.\n- `check_headers`: deprecated. Ignored.\n- `...`: ANY. Elements to be stacked.\n- `deparse.level`: numeric(1). Currently Ignored.\n- `y`: VTableNodeInfo. TableTree, ElementaryTable or TableRow object.\n\nValue\n\nA formal table object.\nExamples\n\n```r\nmtbl <- rtable(\n header = rheader(\n rrow(row.name = NULL, rcell(\"Sepal.Length\", colspan = 2), rcell(\"Petal.Length\", colspan=2),\n rrow(NULL, \"mean\", \"median\", \"mean\", \"median\")\n ),\n rrow(\n row.name = \"All Species\",\n mean(iris$Sepal.Length), median(iris$Sepal.Length),\n mean(iris$Petal.Length), median(iris$Petal.Length),\n format = \"xx.xx\"\n )\n)\n\nmtbl2 <- with(subset(iris, Species == \"setosa\"), rtable(\n header = rheader(\n rrow(row.name = NULL, rcell(\"Sepal.Length\", colspan = 2), rcell(\"Petal.Length\", colspan=2),\n rrow(NULL, \"mean\", \"median\", \"mean\", \"median\")\n ),\n rrow(\n row.name = \"Setosa\",\n mean(Sepal.Length), median(Sepal.Length),\n mean(Petal.Length), median(Petal.Length),\n format = \"xx.xx\"\n )\n))\n\nrbind(mtbl, mtbl2)\nrbind(mtbl, rrow(), mtbl2)\nrbind(mtbl, rrow(\"aaa\"), indent(mtbl2))\n```\n\nrcell\n\n**Cell value constructors**\n\n**Description**\n\nConstruct a cell value and associate formatting, labeling, indenting, and column spanning information with it.\n\n**Usage**\n\n```r\nrcell(\n x,\n format = NULL,\n colspan = 1L,\n label = NULL,\n indent_mod = NULL,\n footnotes = NULL,\n align = NULL,\n```\nformat_na_str = NULL\n)\n\nnon_ref_rcell(\n x,\n is_ref,\n format = NULL,\n colspan = 1L,\n label = NULL,\n indent_mod = NULL,\n refval = NULL,\n align = \"center\",\n format_na_str = NULL\n)\n\nArguments\n\nx ANY. Cell value.\nformat character(1) or function. The format label (string) or formatter function to apply\nto x. See list_valid_format_labels for currently supported format labels.\ncolspan integer(1). Column span value.\nlabel character(1). Label or NULL. If non-null, it will be looked at when determining\nrow labels.\nindent_mod numeric. Modifier for the default indent position for the structure created by\nthis function(subtable, content table, or row) and all of that structure's children.\nDefaults to 0, which corresponds to the unmodified default behavior.\nfootnotes list or NULL. Referential footnote messages for the cell.\nalign character(1) or NULL. Alignment the value should be rendered with. It defaults to\n\"center\" if NULL is used. See rtables_aligns for currently supported alignments.\nformat_na_str character(1). String which should be displayed when formatted if this cell's\nvalue(s) are all NA.\nis_ref logical(1). Are we in the reference column (ie .in_ref_col should be passed to\nthis argument)\nrefval ANY. Value to use when in the reference column. Defaults to NULL.\n\nDetails\n\nnon_ref_rcell provides the common blank for cells in the reference column, this value otherwise,\nand should be passed the value of .in_ref_col when it is used.\n\nValue\n\nAn object representing the value within a single cell within a populated table. The underlying\nstructure of this object is an implementation detail and should not be relied upon beyond calling\naccessors for the class.\nNote\nCurrently column spanning is only supported for defining header structure.\n\nrheader\n\nCreate a header\n\nDescription\nCreate a header\n\nUsage\nrheader(..., format = \"xx\", .lst = NULL)\n\nArguments\n...\nrow specifications (either as character vectors or the output from rrow or DataRow, LabelRow, etc.\nformat character(1) or function. The format label (string) or formatter function to apply to the cell values passed via .... See list_valid_format_labels for currently supported format labels.\n.lst list. An already-collected list of arguments to be used instead of the elements of .... Arguments passed via ... will be ignored if this is specified.\n\nValue\na InstantiatedColumnInfo object.\n\nSee Also\nOther compatibility: rrow1(), rrow(), rtable()\n\nExamples\nh1 <- rheader(c(\"A\", \"B\", \"C\"))\nh2 <- rheader(\nrrow(NULL, rcell(\"group 1\", colspan = 2), rcell(\"group 2\", colspan = 2)),\nrrow(NULL, \"A\", \"B\", \"A\", \"B\")\n)\nh1\nh2\nReferential Footnote Accessors\n\nDescription\nGet and set referential footnotes on aspects of a built table\n\nUsage\nrow_footnotes(obj)\nrow_footnotes(obj) <- value\ncell_footnotes(obj)\ncell_footnotes(obj) <- value\ncol_fnotes_here(obj)\ncol_fnotes_here(obj) <- value\nref_index(obj)\nref_index(obj) <- value\nref_symbol(obj)\nref_symbol(obj) <- value\nref_msg(obj)\n\nfnotes_at_path(obj, rowpath = NULL, colpath = NULL, reset_idx = TRUE) <- value\n\nArguments\nobj ANY. The object for the accessor to access or modify\nvalue The new value\nrowpath character or NULL. Path within row structure. NULL indicates the footnote should go on the column rather than cell.\ncolpath character or NULL. Path within column structure. NULL indicates footnote should go on the row rather than cell\nreset_idx logical(1). Should the numbering for referential footnotes be immediately recalculated. Defaults to TRUE.\n\nSee Also\nrow_paths(), col_paths(), row_paths_summary(), col_paths_summary()\nExamples\n\n```r\n# How to add referencial footnotes after having created a table\nlyt <- basic_table() %>%\n split_rows_by(\"SEX\", page_by = TRUE) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\ntbl <- trim_rows(tbl)\n# Check the row and col structure to add precise references\n# row_paths(tbl)\n# col_paths(tbl)\n# row_paths_summary(tbl)\n# col_paths_summary(tbl)\n\n# Add the citation numbers on the table and relative references in the footnotes\nfnotes_at_path(tbl, rowpath = c(\"SEX\", \"F\", \"AGE\", \"Mean\")) <- \"Famous paper 1\"\nfnotes_at_path(tbl, rowpath = c(\"SEX\", \"UNDIFFERENTIATED\")) <- \"Unfamous paper 2\"\n```\n\n---\n\n**row_paths**\n\nReturn List with Table Row/Col Paths\n\n**Description**\n\nReturn List with Table Row/Col Paths\n\n**Usage**\n\n```r\nrow_paths(x)\ncol_paths(x)\n```\n\n**Arguments**\n\n- `x` an rtable object\n\n**Value**\n\na list of paths to each row/column within `x`\n\n**See Also**\n\n- `cell_values()`, `fnotes_at_path<-`, `row_paths_summary()`, `col_paths_summary()`\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n analyze(c(\"SEX\", \"AGE\"))\n\ntbl <- build_table(lyt, ex_adsl)\ntbl\n\nrow_paths(tbl)\ncol_paths(tbl)\n\ncell_values(tbl, c(\"AGE\", \"Mean\"), c(\"ARM\", \"B: Placebo\"))\n```\n\n---\n\n**row_paths_summary**\n\nPrint Row/Col Paths Summary\n\n**Description**\n\nPrint Row/Col Paths Summary\n\n**Usage**\n\n```r\nrow_paths_summary(x)\ncol_paths_summary(x)\n```\n\n**Arguments**\n\n- `x` an rtable object\n\n**Value**\n\nA data.frame summarizing the row- or column-structure of `x`.\n\n**Examples**\n\n```r\nlibrary(dplyr)\n\nex_adsl_MF <- ex_adsl %>% filter(SEX %in% c(\"M\", \"F\"))\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by(\"SEX\", split_fun = drop_split_levels) %>%\n analyze(c(\"AGE\", \"BMRKR2\"))\n\ntbl <- build_table(lyt, ex_adsl_MF)\ntbl\n```\n```r\ndf <- row_paths_summary(tbl)\ndf\n\ncol_paths_summary(tbl)\n\n# manually constructed table\ntbl2 <- rtable(\n rheader(\n rrow(\"row 1\", rcell(\"a\", colspan = 2),\n rcell(\"b\", colspan = 2),\n ),\n rrow(\"h2\", \"a\", \"b\", \"c\", \"d\"),\n rrow(\"r1\", 1, 2, 1, 2), rrow(\"r2\", 3, 4, 2,1)\n )\n col_paths_summary(tbl2)\n```\n\n---\n\n**rrow**\n\n**row**\n\n### Description\n\n**row**\n\n### Usage\n\n```r\nrrow(row.name = \"\", ..., format = NULL, indent = 0, inset = 0L)\n```\n\n### Arguments\n\n- **row.name**\n - if NULL then an empty string is used as row.name of the **rrow**.\n- **...**\n - cell values\n- **format**\n - character(1) or function. The format label (string) or formatter function to apply to the cell values passed via .... See **list_valid_format_labels** for currently supported format labels.\n- **indent**\n - deprecated.\n- **inset**\n - integer(1). The table inset for the row or table being constructed. See **table_inset**.\n\n### Value\n\nA row object of the context-appropriate type (label or data)\n\n### See Also\n\nOther compatibility: **rheader(), rrowl(), rtable()**\nExamples\n\n```r\nrrowl(\"ABC\", c(1,2), c(3,2), format = \"xx (xx.%)\")\nrrow(\"\"\n```\n\n**Description**\n\n**rrowl**\n\n**Usage**\n\n```r\nrrowl(row.name, ..., format = NULL, indent = 0, inset = 0L)\n```\n\n**Arguments**\n\n- `row.name`: if NULL then an empty string is used as row.name of the `rrow`\n- `...`: values in vector/list form\n- `format`: character(1) or function. The format label (string) or formatter function to apply to the cell values passed via .... See `list_valid_format_labels` for currently supported format labels.\n- `indent`: deprecated.\n- `inset`: integer(1). The table inset for the row or table being constructed. See `table_inset`.\n\n**Value**\n\nA row object of the context-appropriate type (label or data)\n\n**See Also**\n\nOther compatibility: `rheader()`, `rrow()`, `rtable()`\n\n**Examples**\n\n```r\nrrowl(\"a\", c(1,2,3), format = \"xx\")\nrrowl(\"a\", c(1,2,3), c(4,5,6), format = \"xx\")\n```\n\n```r\nrrowl(\"N\", table(iris$Species))\nrrowl(\"N\", table(iris$Species), format = \"xx\")\n```\n\n```r\nx <- tapply(iris$Sepal.Length, iris$Species, mean, simplify = FALSE)\nrrow(row.name = \"row 1\", x)\n```\nrrow(\"ABC\", 2, 3)\n\nrrowl(row.name = \"row 1\", c(1, 2), c(3,4))\nrrow(row.name = \"row 2\", c(1, 2), c(3,4))\n\n**rtable** \n*Create a Table*\n\n### Description\n\nCreate a Table\n\n### Usage\n\n```r\nrtable(header, ..., format = NULL, hsep = default_hsep(), inset = 0L)\nrtablel(header, ..., format = NULL, hsep = default_hsep(), inset = 0L)\n```\n\n### Arguments\n\n- **header**: Information defining the header (column structure) of the table. This can be as row objects (legacy), character vectors or a `InstantiatedColumnInfo` object.\n- **...**: Rows to place in the table.\n- **format**: character(1) or function. The format label (string) or formatter function to apply to the cell values passed via `...`. See `list_valid_format_labels` for currently supported format labels.\n- **hsep**: character(1). Set of character(s) to be repeated as the separator between the header and body of the table when rendered as text. Defaults to a connected horizontal line (unicode 2014) in locals that use a UTF charset, and to `-` elsewhere (with a once per session warning).\n- **inset**: integer(1). The table inset for the row or table being constructed. See `table_inset`.\n\n### Value\n\nA formal table object of the appropriate type (`ElementaryTable` or `TableTree`).\n\n### See Also\n\nOther compatibility: `rheader()`, `rrowl()`, `rrow()`\nExamples\n\n```r\nrtable(\n header = LETTERS[1:3],\n rrow(\"one to three\", 1, 2, 3),\n rrow(\"more stuff\", rcell(pi, format = \"xx.xx\"), \"test\", \"and more\")\n)\n\n# Table with multirow header\nsel <- iris$Species == \"setosa\"\nmtbl <- rtable(\n header = rheader(\n rrow(row.name = NULL, rcell(\"Sepal.Length\", colspan = 2),\n rcell(\"Petal.Length\", colspan=2)),\n rrow(NaN, \"mean\", \"median\", \"mean\", \"median\")\n ),\n rrow(\n row.name = \"All Species\",\n mean(iris$Sepal.Length), median(iris$Sepal.Length),\n mean(iris$Petal.Length), median(iris$Petal.Length),\n format = \"xx.xx\"\n ),\n rrow(\n row.name = \"Setosa\",\n mean(iris$Sepal.Length[sel]), median(iris$Sepal.Length[sel]),\n mean(iris$Petal.Length[sel]), median(iris$Petal.Length[sel])\n )\n)\n\nmtbl\n\nnames(mtbl) # always first row of header\n\n# Single row header\n\ntbl <- rtable(\n header = c(\"Treatment\\nN=100\", \"Comparison\\nN=300\"),\n format = \"xx (xx.xx%)\",\n rrow(\"A\", c(104, .2), c(100, .4)),\n rrow(\"B\", c(23, .4), c(43, .5)),\n rrow(\"\"),\n rrow(\"this is a very long section header\"),\n rrow(\"estimate\", rcell(55.23, \"xx.xx\", colspan = 2)),\n rrow(\"95% CI\", indent = 1, rcell(c(44.8, 67.4), format = \"(xx.x, xx.x)\", colspan = 2))\n)\ntbl\n\nrow.names(tbl)\nnames(tbl)\n```\n# Subsetting\ntbl[1,]\ntbl[, 1]\ntbl[1, 2]\ntbl[2, 1]\ntbl[3, 2]\ntbl[5, 1]\ntbl[5, 2]\n\n# Data Structure methods\ndim(tbl)\nnrow(tbl)\nncol(tbl)\nnames(tbl)\n\n# Colspans\ntbl2 <- rtable(\n c(\"A\", \"B\", \"C\", \"D\", \"E\"),\n format = \"xx\",\n rrow(\"r1\", 1, 2, 3, 4, 5),\n\n rrow(\"r2\", rcell(\"sp2\", colspan = 2), \"sp1\", rcell(\"sp2-2\", colspan = 2))\n)\ntbl2\n\nrtables_aligns\n\nAlignment utils\n\nDescription\nCurrently supported cell value alignments. These values may be used to set content alignment\n(align in rcell() or .aligns in in_rows()).\n\nUsage\nrtables_aligns()\n\nValue\na vector of alignments currently supported.\n\nSee Also\nin_rows(), rcell()\nExamples\n\n# See the alignments available in rtables\nrtables_aligns()\n\n# Right alignment with align in rcell()\nlyt <- basic_table() %>%\nanalyze(\"Species\", function(x) in_rows(left = rcell(\"r\", align = \"right\")))\n\ntbl <- build_table(lyt, iris)\ntbl\n\n# Set multiple alignments using character vectors with .aligns in in_rows()\nlyt2 <- basic_table() %>%\nanalyze(\"Species\", function(x) {\nin_rows(\n left = rcell(\"l\"),\n right = rcell(\"r\"),\n .aligns = c(\"left\", \"right\")\n)\n})\n\ntbl2 <- build_table(lyt2, iris)\ntbl2\n\n# Clinical data example:\nlyt3 <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"SEX\", split_fun = drop_split_levels) %>%\n analyze(c(\"AGE\"), function(x) {\nin_rows(\n \"mean\" = rcell(mean(x), align = \"right\"),\n \"sd\" = rcell(sd(x), align = \"left\"), .formats = c(\"xx.x\")\n), show_labels = \"visible\", na_str = \"NE\"\n)\n\ntbl3 <- build_table(lyt3, ex_adsl)\ntbl3\n\nselect_all_levels \n\nAdd Combination Levels to split\n\nDescription\n\nAdd Combination Levels to split\n\nUsage\n\n```r\nselect_all_levels\n\nadd_combo_levels(combosdf, trim = FALSE, first = FALSE, keep_levels = NULL)\n```\nselect_all_levels\n\nArguments\n\ncombosdf data.frame/tbl_df. Columns valname, label, levelcombo, exargs. Of which levelcombo and exargs are list columns. Passing the select_all_levels object as a value in the comblevels column indicates that an overall/all-observations level should be created.\n\ntrim logical(1). Should splits corresponding with 0 observations be kept when tabulating.\n\nfirst logical(1). Should the created split level be placed first in the levels (TRUE) or last (FALSE, the default).\n\nkeep_levels character or NULL. If non-NULL, the levels to retain across both combination and individual levels.\n\nFormat\n\nAn object of class AllLevelsSentinel of length 0.\n\nValue\n\na closure suitable for use as a splitting function (splfun) when creating a table layout\n\nNote\n\nAnalysis or summary functions for which the order matters should never be used within the tabulation framework.\n\nExamples\n\nlibrary(tibble)\ncombodf <- tribble(\n ~valname, ~label, ~levelcombo, ~exargs,\n \"A_B\", \"Arms A+B\", c(\"A: Drug X\", \"B: Placebo\"), list(),\n \"A_C\", \"Arms A+C\", c(\"A: Drug X\", \"C: Combination\"), list())\n\nlyt <- basic_table(show_colcounts = TRUE) %>%\n split_cols_by(\"ARM\", split_fun = add_combo_levels(combodf)) %>%\n analyze(\"AGE\")\n\n.tbl <- build_table(lyt, DM)\n.tbl\n\nlyt1 <- basic_table(show_colcounts = TRUE) %>%\n split_cols_by(\"ARM\", split_fun = add_combo_levels(combodf, keep_levels = c(\"A_B\", \"A_C\"))) %>%\n analyze(\"AGE\")\n\n.tbl1 <- build_table(lyt1, DM)\n.tbl1\nsmallerDM <- droplevels(subset(DM, SEX %in% c(\"M\", \"F\") &\n grepl(\"^(A|B)\\\", ARM)))\nlyt2 <- basic_table(show_colcounts = TRUE) %>%\n split_cols_by(\"ARM\", split_fun = add_combo_levels(combodf[1,])) %>%\n split_cols_by(\"SEX\",\n split_fun = add_overall_level(\"SEX_ALL\", \"All Genders\")) %>%\n analyze(\"AGE\")\nlyt3 <- basic_table(show_colcounts = TRUE) %>%\n split_cols_by(\"ARM\", split_fun = add_combo_levels(combodf)) %>%\n split_rows_by(\"SEX\",\n split_fun = add_overall_level(\"SEX_ALL\", \"All Genders\")) %>%\n summarize_row_groups() %>%\n analyze(\"AGE\")\ntbl3 <- build_table(lyt3, smallerDM)\ntbl3\n\n---\n\n### sf_args\n\n**Split Function Arg Conventions**\n\n**Description**\n\nSplit Function Arg Conventions\n\n**Usage**\n\nsf_args(trim, label, first)\n\n**Arguments**\n\n- trim: logical(1). Should splits corresponding with 0 observations be kept when tabulating.\n- label: character(1). A label (not to be confused with the name) for the object/structure.\n- first: logical(1). Should the created split level be placed first in the levels (TRUE) or last (FALSE, the default).\n\n**Value**\n\nNULL (this is an argument template dummy function)\n\n**See Also**\n\nOther conventions: compat_args(), constr_args(), gen_args(), lyt_args()\nsimple_analysis\n\nDescription\n\nThis function is used when analyze is invoked\n\nUsage\n\n```r\nsimple_analysis(x, ...)\n```\n\n```r\n## S4 method for signature 'numeric'\nsimple_analysis(x, ...)\n```\n\n```r\n## S4 method for signature 'logical'\nsimple_analysis(x, ...)\n```\n\n```r\n## S4 method for signature 'factor'\nsimple_analysis(x, ...)\n```\n\n```r\n## S4 method for signature 'ANY'\nsimple_analysis(x, ...)\n```\n\nArguments\n\n- `x` the *already split* data being tabulated for a particular cell/set of cells\n- `...` passed on directly\n\nDetails\n\nThis function has the following behavior given particular types of inputs:\n\n- **numeric** calls `mean` on `x`\n- **logical** calls `sum` on `x`\n- **factor** calls `length` on `x`\n\n`in_rows` is called on the resulting value(s).\n\nAll other classes of input currently lead to an error.\n\nValue\n\nan `RowsVerticalSection` object (or `NULL`). The details of this object should be considered an internal implementation detail.\n\nAuthor(s)\n\nGabriel Becker and Adrian Waddell\nsort_at_path\n\nSorting a Table at a Specific Path\n\nDescription\n\nMain sorting function to order the substructure of a TableTree at a particular Path in the table tree.\n\nUsage\n\nsort_at_path(\n tt,\n path,\n scorefun,\n decreasing = NA,\n na.pos = c(\"omit\", \"last\", \"first\"),\n .prev_path = character()\n)\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>tt</td>\n<td>TableTree (or related class). A TableTree object representing a populated table.</td>\n</tr>\n<tr>\n<td>path</td>\n<td>character. A vector path for a position within the structure of a tabletree. Each element represents a subsequent choice amongst the children of the previous choice.</td>\n</tr>\n<tr>\n<td>scorefun</td>\n<td>function. Scoring function, should accept the type of children directly under the position at path (either VTableTree, VTableRow, or VTableNodeInfo, which covers both) and return a numeric value to be sorted.</td>\n</tr>\n<tr>\n<td>decreasing</td>\n<td>logical(1). Should the the scores generated by scorefun be sorted in decreasing order. If unset (the default of NA), it is set to TRUE if the generated scores are numeric and FALSE if they are characters.</td>\n</tr>\n<tr>\n<td>na.pos</td>\n<td>character(1). What should be done with children (sub-trees/rows) with NA scores. Defaults to "omit", which removes them, other allowed values are "last" and "first" which indicate where they should be placed in the order.</td>\n</tr>\n<tr>\n<td>.prev_path</td>\n<td>character. Internal detail, do not set manually.</td>\n</tr>\n</tbody>\n</table>\n\nExamples\n\n```r\nsimple_analysis(1:3)\nsimple_analysis(iris$Species)\nsimple_analysis(iris$Species == \"setosa\")\n```\nsort_at_path\n\nDetails\n\nThe path here can include the \"wildcard\" \"*\" as a step, which translates roughly to any node/branching element and means that each child at that step will be separately sorted based on scorefun and the remaining path entries. This can occur multiple times in a path.\n\nNote that sorting needs a deeper understanding of table structure in rtables. Please consider reading related vignette (Sorting and Pruning) and explore table structure with useful functions like table_structure() and row_paths_summary(). It is also very important to understand the difference between \"content\" rows and \"data\" rows. The first one analyzes and describes the split variable generally and is generated with summarize_row_groups(), while the second one is commonly produced by calling one of the various analyze() instances.\n\nBuilt-in score functions are cont_n_allcols() and cont_n_onecol(). They are both working with content rows (coming from summarize_row_groups()) while a custom score function needs to be used on DataRows. Here, some useful descriptor and accessor functions (coming from related vignette):\n\n- cell_values() - Retrieves a named list of a TableRow or TableTree object's values.\n- obj_name() - Retrieves the name of an object. Note this can differ from the label that is displayed (if any is) when printing.\n- obj_label() - Retrieves the display label of an object. Note this can differ from the name that appears in the path.\n- content_table() - Retrieves a TableTree object’s content table (which contains its summary rows).\n- tree_children() - Retrieves a TableTree object’s direct children (either subtables, rows or possibly a mix thereof, though that should not happen in practice).\n\nValue\n\nA TableTree with the same structure as tt with the exception that the requested sorting has been done at path.\n\nSee Also\n\ncont_n_allcols() and cont_n_onecol()\n\nExamples\n\n# Creating a table to sort\n\n# Function that gives two statistics per table-tree \"leaf\"\nmore_analysis_fnc <- function(x) {\n in_rows(\n \"median\" = median(x),\n \"mean\" = mean(x),\n .formats = \"xx.x\"\n )\n}\n\n# Main layout of the table\nsplit_cols_by\n\nDeclaring a column-split based on levels of a variable\n\nDescription\n\nWill generate children for each subset of a categorical variable\n\nUsage\n\nsplit_cols_by(\n lyt,\n var,\n labels_var = var,\n split_label = var,\n split_fun = NULL,\n format = NULL,\n nested = TRUE,\n)\nsplit_cols_by\n\nchild_labels = c(\"default\", \"visible\", \"hidden\"),\nextra_args = list(),\nref_group = NULL\n)\n\nArguments\n\nlyt layout object pre-data used for tabulation\nvar string, variable name\nlabels_var string, name of variable containing labels to be displayed for the values of var\nsplit_label string. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).\nsplit_fun function/NULL. custom splitting function See custom_split_funs\nformat FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\nnested boolean. Should this layout instruction be applied within the existing layout structure if possible (TRUE, the default) or as a new top-level element (FALSE). Ignored if it would nest a split underneath analyses, which is not allowed.\nchild_labels string. One of \"default\", \"visible\", \"hidden\". What should the display behavior be for the labels (ie label rows) of the children of this split. Defaults to \"default\" which flags the label row as visible only if the child has 0 content rows.\nextra_args list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\nref_group character(1) or NULL. Level of var which should be considered ref_group/reference\n\nValue\n\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\n\nCustom Splitting Function Details\n\nUser-defined custom split functions can perform any type of computation on the incoming data provided that they meet the contract for generating 'splits' of the incoming data 'based on' the split object.\n\nSplit functions are functions that accept:\n\ndf data.frame of incoming data to be split\nspl a Split object. this is largely an internal detail custom functions will not need to worry about, but obj_name(spl), for example, will give the name of the split as it will appear in paths in the resulting table\nvals Any pre-calculated values. If given non-null values, the values returned should match these. Should be NULL in most cases and can likely be ignored.\n\nlabels Any pre-calculated value labels. Same as above for values.\n\ntrim If TRUE, resulting splits that are empty should be removed.\n\n(Optional) spl_context a data.frame describing previously performed splits which collectively arrived at df\n\nThe function must then output a named list with the following elements:\n\nvalues The vector of all values corresponding to the splits of df.\n\ndatasplit a list of data.frames representing the groupings of the actual observations from df.\n\nlabels a character vector giving a string label for each value listed in the values element above.\n\n(Optional) extras If present, extra arguments are to be passed to summary and analysis functions whenever they are executed on the corresponding element of datasplit or a subset thereof.\n\nOne way to generate custom splitting functions is to wrap existing split functions and modify either the incoming data before they are called or their outputs.\n\nAuthor(s)\nGabriel Becker\n\nExamples\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n analyze(c(\"AGE\", \"BMRKR2\"))\n\ntbl1 <- build_table(lyt, ex_adsl)\ntbl\n\n# Let's look at the splits in more detail\n\nlyt1 <- basic_table() %>% split_cols_by(\"ARM\")\nlyt1\n\n# add an analysis (summary)\nlyt2 <- lyt1 %>%\n analyze(c(\"AGE\", \"COUNTRY\"), afun = list_wrap_x(summary), format = \"xx.xx\")\nlyt2\n\ntbl2 <- build_table(lyt2, DM)\ntbl2\n\n# By default sequentially adding layouts results in nesting\nlibrary(dplyr)\nDM_MF <- DM %>% filter(SEX %in% c(\"M\", \"F\")) %>%\n mutate(SEX = droplevels(SEX))\nsplit_cols_by_cuts\n\nSplit on static or dynamic cuts of the data\n\nDescription\nCreate columns (or row splits) based on values (such as quartiles) of var.\n\nUsage\n\nsplit_cols_by_cuts(\n lyt, \n var, \n cuts, \n cutlabels = NULL, \n split_label = var, \n nested = TRUE, \n cumulative = FALSE\n)\nsplit_rows_by_cuts(\n lyt,\n var,\n cuts,\n cutlabels = NULL,\n split_label = var,\n format = NULL,\n na_str = NA_character_,\n nested = TRUE,\n cumulative = FALSE,\n label_pos = \"hidden\",\n section_div = NA_character_\n)\n\nsplit_cols_by_cutfun(\n lyt,\n var,\n cutfun = qtile_cuts,\n cutlabelfun = function(x) NULL,\n split_label = var,\n nested = TRUE,\n extra_args = list(),\n cumulative = FALSE\n)\n\nsplit_cols_by_quartiles(\n lyt,\n var,\n split_label = var,\n nested = TRUE,\n extra_args = list(),\n cumulative = FALSE\n)\n\nsplit_rows_by_quartiles(\n lyt,\n var,\n split_label = var,\n format = NULL,\n na_str = NA_character_,\n nested = TRUE,\n child_labels = c(\"default\", \"visible\", \"hidden\"),\n extra_args = list(),\n cumulative = FALSE,\n indent_mod = 0L,\n label_pos = \"hidden\",\n section_div = NA_character_\nsplit_rows_by_cutfun(\n lyt,\n var,\n cutfun = qtile_cuts,\n cutlabelfun = function(x) NULL,\n split_label = var,\n format = NULL,\n na_str = NA_character_,\n nested = TRUE,\n child_labels = c(\"default\", \"visible\", \"hidden\"),\n extra_args = list(),\n cumulative = FALSE,\n indent_mod = 0L,\n label_pos = \"hidden\",\n section_div = NA_character_,\n)\n\nArguments\n\nlyt layout object pre-data used for tabulation\nvar string, variable name\ncuts numeric. Cuts to use\ncutlabels character (or NULL). Labels for the cuts\nsplit_label string. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).\nnested boolean. Should this layout instruction be applied within the existing layout structure if possible (TRUE, the default) or as a new top-level element ('FALSE). Ignored if it would nest a split underneath analyses, which is not allowed.\ncumulative logical. Should the cuts be treated as cumulative. Defaults to FALSE\nformat FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\nna_str character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\nlabel_pos character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\nsection_div character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\ncutfun function. Function which accepts the full vector of var values and returns cut points to be passed to cut.\nsplit_cols_by_cuts\n\ncutlabelfun function. Function which returns either labels for the cuts or NULL when passed\nthe return value of cutfun\nextra_args list. Extra arguments to be passed to the tabulation function. Element position\nin the list corresponds to the children of this split. Named elements in the child-specific\nlists are ignored if they do not match a formal argument of the tabulation\nfunction.\nchild_labels string. One of \"default\", \"visible\", \"hidden\". What should the display\nbehavior be for the labels (ie label rows) of the children of this split. Defaults\nto \"default\" which flags the label row as visible only if the child has 0 content\nrows.\nindent_mod numeric. Modifier for the default indent position for the structure created by\nthis function(subtable, content table, or row) and all of that structure's children.\nDefaults to 0, which corresponds to the unmodified default behavior.\n\nDetails\n\nFor dynamic cuts, the cut is transformed into a static cut by build_table based on the full dataset,\nbefore proceeding. Thus even when nested within another split in column/row space, the resulting\nsplit will reflect the overall values (e.g., quartiles) in the dataset, NOT the values for subset it is\nnested under.\n\nValue\n\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\n\nAuthor(s)\n\nGabriel Becker\n\nExamples\n\nlibrary(dplyr)\n\n# split_cols_by_cuts\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by_cuts(\"AGE\", split_label = \"Age\",\n cuts = c(0, 25, 35, 1000),\n cutlabels = c(\"young\", \"medium\", \"old\") %>%\n analyze(c(\"BMRKR2\", \"STRATA2\")) %>%\n append_topleft(\"counts\")\n\ntbl <- build_table(lyt, ex_ads1)\ntbl\n\n# split_rows_by_cuts\nlyt2 <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by_cuts(\"AGE\", split_label = \"Age\",\n cuts = c(0, 25, 35, 1000),\n cutlabels = c(\"young\", \"medium\", \"old\") %>%\n analyze(c(\"BMRKR2\", \"STRATA2\")) %>%\n append_topleft(\"counts\")\nsplit_cols_by_cuts\n\n```r\n\ncutlabels = c(\"young\", \"medium\", \"old\")\n%>%\nanalyze(c(\"BMRKR2\", \"STRATA2\"))\n%>%\nappend_topleft(\"counts\")\n\ntbl2 <- build_table(lyt2, ex_adsl)\ntbl2\n\n# split_cols_by_quartiles\n\nlyt3 <- basic_table()\n%>%\nsplit_cols_by(\"ARM\")\n%>%\nsplit_cols_by_quartiles(\"AGE\", split_label = \"Age\")\n%>%\nanalyze(c(\"BMRKR2\", \"STRATA2\"))\n%>%\nappend_topleft(\"counts\")\n\ntbl3 <- build_table(lyt3, ex_adsl)\ntbl3\n\n# split_rows_by_quartiles\n\nlyt4 <- basic_table(show_colcounts = TRUE)\n%>%\nsplit_cols_by(\"ARM\")\n%>%\nsplit_rows_by_quartiles(\"AGE\", split_label = \"Age\")\n%>%\nanalyze(\"BMRKR2\")\n%>%\nappend_topleft(c(\"Age Quartiles\", \"Counts BMRKR2\"))\n\ntbl4 <- build_table(lyt4, ex_adsl)\ntbl4\n\n# split_cols_by_cutfun\ncutfun <- function(x) {\n cutpoints <- c(\n min(x),\n mean(x),\n max(x)\n )\n names(cutpoints) <- c(\"\", \"Younger\", \"Older\")\n\n cutpoints\n}\n\nlyt5 <- basic_table()\n%>%\nsplit_cols_by_cutfun(\"AGE\", cutfun = cutfun)\n%>%\nanalyze(\"SEX\")\n\ntbl5 <- build_table(lyt5, ex_adsl)\ntbl5\n\n# split_rows_by_cutfun\n\nlyt6 <- basic_table()\n%>%\nsplit_cols_by(\"SEX\")\n%>%\nsplit_rows_by_cutfun(\"AGE\", cutfun = cutfun)\n%>%\nanalyze(\"BMRKR2\")\n\n```\nsplit_cols_by_multivar\n\nAssociate Multiple Variables with Columns\n\nDescription\n\nIn some cases, the variable to be ultimately analyzed is most naturally defined on a column, not a row basis. When we need columns to reflect different variables entirely, rather than different levels of a single variable, we use split_cols_by_multivar\n\nUsage\n\nsplit_cols_by_multivar(\n lyt,\n vars,\n split_fun = NULL,\n varlabels = vars,\n varnames = NULL,\n nested = TRUE,\n extra_args = list()\n)\n\nArguments\n\nlyt layout object pre-data used for tabulation\nvars character vector. Multiple variable names.\nsplit_fun function/NULL. custom splitting function See custom_split_funs\nvarlabels character vector. Labels for vars\nvarnames character vector. Names for vars which will appear in pathing. When vars are all unique this will be the variable names. If not, these will be variable names with suffixes as necessary to enforce uniqueness.\nnested boolean. Should this layout instruction be applied within the existing layout structure if possible (TRUE, the default) or as a new top-level element (FALSE). Ignored if it would nest a split underneath analyses, which is not allowed.\nextra_args list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\n\nValue\n\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\nlibrary(dplyr)\nANL <- DM %>% mutate(value = rnorm(n()), pctdiff = runif(n()))\n\n## toy example where we take the mean of the first variable and the\n## count of >.5 for the second.\ncolfuns <- list(function(x) in_rows(mean = mean(x), .formats = \"xx.x\"),\n function(x) in_rows(\"# x > .5\" = sum(x > .5), .formats = \"xx\"))\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by_multivar(c(\"value\", \"pctdiff\")) %>%\n split_rows_by(\"RACE\", split_label = \"ethnicity\",\n split_fun = drop_split_levels) %>%\n summarize_row_groups() %>%\n analyze_colvars(afun = colfuns)\nlyt\ntbl <- build_table(lyt, ANL)\ntbl\n\n---\n\n**Description**\n\nSplit functions\n\n**Usage**\n\nremove_split_levels(excl)\n\nkeep_split_levels(only, reorder = TRUE)\n\ndrop_split_levels(df, spl, vals = NULL, labels = NULL, trim = FALSE)\n\ndrop_and_remove_levels(excl)\nreorder_split_levels(neworder, newlabels = neworder, drlevels = TRUE)\n\ntrim_levels_in_group(innervar, drop_outlevs = TRUE)\n\nArguments\n\nexcl character. Levels to be excluded (they will not be reflected in the resulting table structure regardless of presence in the data).\nonly character. Levels to retain (all others will be dropped).\nreorder logical(1). Should the order of only be used as the order of the children of the split. defaults to TRUE\ndf dataset (data.frame or tibble)\nspl A Split object defining a partitioning or analysis/tabulation of the data.\nvals ANY. For internal use only.\nlabels character. Labels to use for the remaining levels instead of the existing ones.\ntrim logical(1). Should splits corresponding with 0 observations be kept when tabulating.\nneworder character. New order or factor levels.\newlabels character. Labels for (new order of) factor levels\ndrlevels logical(1). Should levels in the data which do not appear in neworder be dropped. Defaults to TRUE\ninnervar character(1). Variable whose factor levels should be trimmed (e.g., empty levels dropped) separately within each grouping defined at this point in the structure\ndrop_outlevs logical(1). Should empty levels in the variable being split on (ie the ’outer’ variable, not innervar) be dropped? Defaults to TRUE\n\nValue\n\na closure suitable for use as a splitting function (splfun) when creating a table layout\n\nCustom Splitting Function Details\n\nUser-defined custom split functions can perform any type of computation on the incoming data provided that they meet the contract for generating ’splits’ of the incoming data ’based on’ the split object.\n\nSplit functions are functions that accept:\n\ndf data.frame of incoming data to be split\nspl a Split object. this is largely an internal detail custom functions will not need to worry about, but obj_name(spl), for example, will give the name of the split as it will appear in paths in the resulting table\nvals Any pre-calculated values. If given non-null values, the values returned should match these. Should be NULL in most cases and can likely be ignored\nlabels Any pre-calculated value labels. Same as above for values\n**trim** If TRUE, resulting splits that are empty should be removed\n\n(Optimal) **.spl_context** a data.frame describing previously performed splits which collectively arrived at df\n\nThe function must then output a named list with the following elements:\n\n**values** The vector of all values corresponding to the splits of df\n\n**datasplit** a list of data.frames representing the groupings of the actual observations from df.\n\n**labels** a character vector giving a string label for each value listed in the values element above\n\n(Optional) **extras** If present, extra arguments are to be passed to summary and analysis functions whenever they are executed on the corresponding element of datasplit or a subset thereof\n\nOne way to generate custom splitting functions is to wrap existing split functions and modify either the incoming data before they are called or their outputs.\n\n**Examples**\n\n```r\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"COUNTRY\",\n split_fun = remove_split_levels(c(\"USA\", \"CAN\", \"CHE\", \"BRA\"))) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"COUNTRY\",\n split_fun = keep_split_levels(c(\"USA\", \"CAN\", \"BRA\"))) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"SEX\", split_fun = drop_split_levels) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\n\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"SEX\", split_fun = drop_and_remove_levels(c(\"M\", \"U\"))) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\n```\nsplit_rows_by\n\nAdd Rows according to levels of a variable\n\nDescription\n\nAdd Rows according to levels of a variable\n\nUsage\n\nsplit_rows_by(\n lyt,\n var,\n labels_var = var,\n split_label = var,\n split_fun = NULL,\n format = NULL,\n na_str = NA_character_,\n nested = TRUE,\n child_labels = c(\"default\", \"visible\", \"hidden\"),\n label_pos = \"hidden\",\n indent_mod = 0L,\n page_by = FALSE,\n page_prefix = split_label,\n section_div = NA_character_\n)\n\nArguments\n\nlyt layout object pre-data used for tabulation\nvar string, variable name\nlabels_var string, name of variable containing labels to be displayed for the values of var\nsplit_label string. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).\nsplit_fun function/NULL. custom splitting function See custom_split_funs\nformat FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\nna_str character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\nnested boolean. Should this layout instruction be applied within the existing layout structure if possible (TRUE, the default) or as a new top-level element (FALSE). Ignored if it would nest a split underneath analyses, which is not allowed.\nchild_labels string. One of \"default\", \"visible\", \"hidden\". What should the display behavior be for the labels (ie label rows) of the children of this split. Defaults to \"default\" which flags the label row as visible only if the child has 0 content rows.\n\nlabel_pos character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\n\nindent_mod numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure's children. Defaults to 0, which corresponds to the unmodified default behavior.\n\ntop level logical(1). Should pagination be forced between different children resulting form this split.\n\npage_prefix character(1). Prefix, to be appended with the split value, when forcing pagination between the children of this split/table.\n\nValue\n\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\n\nCustom Splitting Function Details\n\nUser-defined custom split functions can perform any type of computation on the incoming data provided that they meet the contract for generating 'splits' of the incoming data 'based on' the split object.\n\nSplit functions are functions that accept:\n\ndf data.frame of incoming data to be split\n\nsp a Split object. this is largely an internal detail custom functions will not need to worry about, but obj_name(sp), for example, will give the name of the split as it will appear in paths in the resulting table\n\ncalculated Any pre-calculated values. If given non-null values, the values returned should match these. Should be NULL in most cases and can likely be ignored\n\nlabels Any pre-calculated value labels. Same as above for values\n\ntrim If TRUE, resulting splits that are empty should be removed\n\n(OPTIONAL) .sp context a data.frame describing previously performed splits which collectively arrived at df\n\nThe function must then output a named list with the following elements:\n\nvalues The vector of all values corresponding to the splits of df\n\ndata split a list of data.frames representing the groupings of the actual observations from df.\n\nlabels a character vector giving a string label for each value listed in the values element above\n(Optional) extras If present, extra arguments are to be passed to summary and analysis functions whenever they are executed on the corresponding element of datasplit or a subset thereof.\n\nOne way to generate custom splitting functions is to wrap existing split functions and modify either the incoming data before they are called or their outputs.\n\nNote\n\nIf var is a factor with empty unobserved levels and labels_var is specified, it must also be a factor with the same number of levels as var. Currently the error that occurs when this is not the case is not very informative, but that will change in the future.\n\nAuthor(s)\n\nGabriel Becker\n\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"RACE\", split_fun = drop_split_levels) %>%\n analyze(\"AGE\", mean, var_labels = \"Age\", format = \"xx.xx\")\n\ntbl <- build_table(lyt, DM)\n\nlyt2 <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"RACE\") %>%\n analyze(\"AGE\", mean, var_labels = \"Age\", format = \"xx.xx\")\n\ntbl2 <- build_table(lyt2, DM)\n\nlyt3 <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by(\"SEX\") %>%\n summarize_row_groups(label_fstr = \"Overall (N)\") %>%\n split_rows_by(\"RACE\", split_label = \"Ethnicity\", labels_var = \"ethn_lab\",\n split_fun = drop_split_levels) %>%\n summarize_row_groups(\"RACE\", label_fstr = \"%s (n)\") %>%\n analyze(\"AGE\", var_labels = \"Age\", afun = mean, format = \"xx.xx\")\n\nlyt3\n\nlibrary(dplyr)\nDM2 <- DM %>%\n filter(SEX %in% c(\"M\", \"F\")) %>%\n mutate(\n SEX = droplevels(SEX),\n gender_lab = c(\"F\" = \"Female\", \"M\" = \"Male\",\n```\n\"U\" = \"Unknown\",\n\"UNDIFFERENTIATED\" = \"Undifferentiated\")[SEX],\nethn_lab = c(\n \"ASIAN\" = \"Asian\",\n \"BLACK OR AFRICAN AMERICAN\" = \"Black or African American\",\n \"WHITE\" = \"White\",\n \"AMERICAN INDIAN OR ALASKA NATIVE\" = \"American Indian or Alaska Native\",\n \"MULTIPLE\" = \"Multiple\",\n \"NATIVE HAWAIIAN OR OTHER PACIFIC ISLANDER\" =\n \"Native Hawaiian or Other Pacific Islander\",\n \"OTHER\" = \"Other\", \"UNKNOWN\" = \"Unknown\"\n)[RACE\"\n)\n\ntbl3 <- build_table(lyt3, DM2)\ntbl3\n\n---\n\n**split_rows_by_multivar**\n\nAssociate Multiple Variables with Rows\n\n**Description**\n\nWhen we need rows to reflect different variables rather than different levels of a single variable, we use `split_rows_by_multivar`.\n\n**Usage**\n\n```r\nsplit_rows_by_multivar(\n lyt,\n vars,\n split_fun = NULL,\n split_label = \"\",\n varlabels = vars,\n format = NULL,\n na_str = NA_character_,\n nested = TRUE,\n child_labels = c(\"default\", \"visible\", \"hidden\"),\n indent_mod = 0L,\n section_div = NA_character_,\n extra_args = list()\n)\n```\n\n**Arguments**\n\n- **lyt**: layout object pre-data used for tabulation\n- **vars**: character vector. Multiple variable names.\nsplit_fun function/NULL. custom splitting function See custom_split_funs\nsplit_label string. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).\nvarlabels character vector. Labels for vars\nformat FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\nna_str character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\nnested boolean. Should this layout instruction be applied within the existing layout structure if possible (TRUE, the default) or as a new top-level element (FALSE). Ignored if it would nest a split underneath analyses, which is not allowed.\nchild_labels string. One of \"default\", \"visible\", \"hidden\". What should the display behavior be for the labels (ie label rows) of the children of this split. Defaults to \"default\" which flags the label row as visible only if the child has 0 content rows.\nindent_mod numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure’s children. Defaults to 0, which corresponds to the unmodified default behavior.\nsection_div character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\nextra_args list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\n\nValue\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\n\nSee Also\nsplit_rows_by() for typical row splitting, and split_cols_by_multivar() to perform the same type of split on a column basis.\n\nExamples\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by_multivar(c(\"SEX\", \"STRATA1\")) %>%\n summarize_row_groups() %>%\n analyze(c(\"AGE\", \"SEX\"))\n\ntbl <- build_table(lyt, DM)\ntbl\n### spl_context\n\nData frame giving information about subsets of data corresponding to splits within which the current `analyze` action is nested. These correspond to the path that the resulting (set of) rows the analysis function is creating, although the information is in a slightly different form. Each split (which correspond to groups of rows in the resulting table), as well as the initial ‘root’ \"split\", is represented via the following columns:\n\n- **split**: The name of the split (often the variable being split in the simple case)\n- **value**: The string representation of the value at that split\n- **full_parent_df**: A data frame containing the full data (i.e., across all columns) corresponding to the path defined by the combination of `split` and `value` of this row and all rows above this row\n- **all_cols_n**: The number of observations corresponding to this row grouping (union of all columns)\n- **cur_col_subset**: List column containing logical vectors indicating the subset of that row’s `full_parent_df` for the column currently being created by the analysis function\n- **cur_col_n**: Integer column containing the observation counts for that split\n\nNote: Within analysis functions that accept `.spl_context`, the `all_cols_n` and `cur_col_n` columns of the dataframe will contain the ‘true’ observation counts corresponding to the row-group and row-group x column subsets of the data. These numbers will not, and currently cannot, reflect alternate column observation counts provided by the `alt_counts_df`, `col_counts` or `col_total` arguments to `build_table`.\n\n### spl_context_to_disp_path\n\nFunction to convert `.spl_context` to a path for error messages.\n\n**Usage**\n\n```r\nspl_context_to_disp_path(ctx)\n```\n**spl_variable**\n\n### Arguments\n\n- **ctx** data.frame. The spl_context data.frame where the error occurred\n\n### Value\n\nA character string containing a description of the row path corresponding to the `ctx`\n\n---\n\n**Description**\n\nThis function is intended for use when writing custom splitting logic. In cases where the split is associated with a single variable, the name of that variable will be returned. At time of writing this includes splits generated via the `split_rows_by`, `split_cols_by`, `split_rows_by_cuts`, `split_cols_by_cuts`, `split_rows_by_cutfun`, and `split_cols_by_cutfun` layout directives.\n\n### Usage\n\n```r\nspl_variable(spl)\n```\n\n**See Also**\n\n- `make_split_fun`\nsummarize_rows is deprecated in favor of make_row_df.\n\nUsage\n\nsummarize_rows(obj)\n\nArguments\n\nobj VTableTree.\n\nValue\n\nA data.frame summarizing the rows in obj.\n\nsummarize_row_groups Add a content row of summary counts\n\nDescription\n\nAdd a content row of summary counts\n\nUsage\n\nsummarize_row_groups(\n lyt,\n var = \"\",\n label_fstr = \"%s\",\n format = \"xx (xx.x\\%)\",\n na_str = \"-\",\n cfun = NULL,\n indent_mod = 0L,\n extra_args = list()\n)\n### Arguments\n\n- **lyt**\n - layout object pre-data used for tabulation\n\n- **var**\n - string, variable name\n\n- **label_fstr**\n - string. An sprintf style format string containing. For non-comparison splits, it can contain up to one \"%s\" which takes the current split value and generates the row/column label. Comparison-based splits it can contain up to two \"%s\".\n\n- **format**\n - FormatSpec. Format associated with this split. Formats can be declared via strings (\"xx.x\") or function. In cases such as analyze calls, they can character vectors or lists of functions.\n\n- **na_str**\n - character(1). String that should be displayed when the value of x is missing. Defaults to \"NA\".\n\n- **cfun**\n - list/function/NULL. tabulation function(s) for creating content rows. Must accept x or df as first parameter. Must accept labelstr as the second argument. Can optionally accept all optional arguments accepted by analysis functions. See analyze.\n\n- **indent_mod**\n - numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure’s children. Defaults to 0, which corresponds to the unmodified default behavior.\n\n- **extra_args**\n - list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\n\n### Details\n\nIf format expects 1 value (i.e. it is specified as a format string and xx appears for two values (i.e. xx appears twice in the format string) or is specified as a function, then both raw and percent of column total counts are calculated. If format is a format string where xx appears only one time, only raw counts are used.\n\ncfun must accept x or df as its first argument. For the df argument cfun will receive the subset data.frame corresponding with the row- and column-splitting for the cell being calculated. Must accept labelstr as the second parameter, which accepts the label of the level of the parent split currently being summarized. Can additionally take any optional argument supported by analysis functions. (see analyze).\n\n### Value\n\nA PreDataTableLayouts object suitable for passing to further layouting functions, and to build_table.\n\n### Author(s)\n\nGabriel Becker\nExamples\n\n```r\nDM2 <- subset(DM, COUNTRY %in% c(\"USA\", \"CAN\", \"CHN\"))\n\nlyt <- basic_table() %>% split_cols_by(\"ARM\") %>%\n split_rows_by(\"COUNTRY\", split_fun = drop_split_levels) %>%\n summarize_row_groups(label_fstr = \"%s (n)\") %>%\n analyze(\"AGE\", afun = list_wrap_x(summary), format = \"xx.xx\")\nlyt\n\ntbl <- build_table(lyt, DM2)\ntbl\n\nrow_paths_summary(tbl) # summary count is a content table\n\n## use a cfun and extra_args to customize summarization\n## behavior\nsfun <- function(x, labelstr, trim) {\n in_rows(\n c(mean(x, trim = trim), trim),\n .formats = \"xx.x (xx.x%)\",\n .labels = sprintf(\"%s (Trimmed mean and trim %%)\",\n labelstr)\n )\n}\n\nlyt2 <- basic_table(show_colcounts = TRUE) %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"COUNTRY\", split_fun = drop_split_levels) %>%\n summarize_row_groups(\"AGE\", cfun = sfun,\n extra_args = list(trim = .2)) %>%\n analyze(\"AGE\", afun = list_wrap_x(summary), format = \"xx.xx\") %>%\n append_topleft(c(\"Country\", \" Age\"))\n\ntbl2 <- build_table(lyt2, DM2)\ntbl2\n```\n\n---\n\n**Description**\n\nA table shell is a rendering of the table which maintains the structure, but does not display the values, rather displaying the formatting instructions for each cell.\nUsage\n\n```r\ntable_shell(\n tt,\n widths = NULL,\n col_gap = 3,\n hsep = default_hsep(),\n tf_wrap = FALSE,\n max_width = NULL\n)\n\ntable_shell_str(\n tt,\n widths = NULL,\n col_gap = 3,\n hsep = default_hsep(),\n tf_wrap = FALSE,\n max_width = NULL\n)\n```\n\nArguments\n\n- **tt**: TableTree (or related class). A TableTree object representing a populated table.\n- **widths**: widths of row.name and columns\n- **col_gap**: gap between columns\n- **hsep**: character to create line separator\n- **tf_wrap**: logical(1). Should the texts for title, subtitle, and footnotes be wrapped?\n- **max_width**: integer(1), character(1) or NULL. Width that title and footer (including footnotes) materials should be word-wrapped to. If NULL, it is set to the current print width of the session (`getOption(\"width\")`). If set to \"auto\", the width of the table (plus any table inset) is used. Ignored completely if `tf_wrap` is FALSE.\n\nValue\n\nFor `table_shell_str` the string representing the table shell, for `table_shell`, `NULL`, as the function is called for the side effect of printing the shell to the console\n\nExamples\n\n```r\nlibrary(dplyr)\n\niris2 <- iris %>%\n group_by(Species) %>%\n mutate(group = as.factor(rep_len(c(\"a\", \"b\"), length.out = n()))) %>%\n ungroup()\n\nlyt <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n```\ntable_structure\n\nsplit_cols_by(\"group\") %>%\nanalyze(c(\"Sepal.Length\", \"Petal.Width\"), afun = list_wrap_x(summary), format = \"xx.xx\")\n\ntbl <- build_table(lyt, iris2)\ntable_shell(tbl)\n\ntable_structure\n\n---\n\nDescription\n\nSummarize Table\n\nUsage\n\ntable_structure(x, detail = c(\"subtable\", \"row\"))\n\nArguments\n\nx a table object\ndetail either row or subtable\n\nValue\n\ncurrently no return value. Called for the side-effect of printing a row- or subtable-structure summary of x.\n\nExamples\n\nlibrary(dplyr)\n\niris2 <- iris %>%\n group_by(Species) %>%\n mutate(group = as.factor(rep_len(c(\"a\", \"b\"), length.out = n())))) %>%\n ungroup()\n\nlyt <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n split_cols_by(\"group\") %>%\n analyze(c(\"Sepal.Length\", \"Petal.Width\"), afun = list_wrap_x(summary),\n format = \"xx.xx\")\n\ntbl <- build_table(lyt, iris2)\ntbl\n\nrow_paths(tbl)\ntable_structure(tbl)\ntable_structure(tbl, detail = \"row\")\nDescription\n\nA TableTree object can have top left material which is a sequence of strings which are printed in the area of the table between the column header display and the label of the first row. These functions access and modify that material.\n\nUsage\n\ntop_left(obj)\n\n## S4 method for signature 'VTableTree'\ntop_left(obj)\n\n## S4 method for signature 'InstantiatedColumnInfo'\ntop_left(obj)\n\n## S4 method for signature 'PreDataTableLayouts'\ntop_left(obj)\n\ntop_left(obj) <- value\n\n## S4 replacement method for signature 'VTableTree'\ntop_left(obj) <- value\n\n## S4 replacement method for signature 'InstantiatedColumnInfo'\ntop_left(obj) <- value\n\n## S4 replacement method for signature 'PreDataTableLayouts'\ntop_left(obj) <- value\n\nArguments\n\nobj ANY. The object for the accessor to access or modify\n\nvalue The new value\n\nValue\n\nA character vector representing the top-left material of obj (or obj after modification, in the case of the setter).\ntostring\n\nConvert an rtable object to a string\n\nDescription\n\nTransform a complex object into a string representation ready to be printed or written to a plain-text file.\n\nUsage\n\n```r\n## S4 method for signature 'VTableTree'\ntoString(\n x,\n widths = NULL,\n col_gap = 3,\n hsep = horizontal_sep(x),\n indent_size = 2,\n tf_wrap = FALSE,\n max_width = NULL\n)\n```\n\nArguments\n\n- `x`: table object\n- `widths`: widths of row.name and columns\n- `col_gap`: gap between columns\n- `hsep`: character to create line separator\n- `indent_size`: numeric(1). Number of spaces to use per indent level. Defaults to 2\n- `tf_wrap`: logical(1). Should the texts for title, subtitle, and footnotes be wrapped?\n- `max_width`: integer(1), character(1) or NULL. Width that title and footer (including footnotes) materials should be word-wrapped to. If NULL, it is set to the current print width of the session (`getOption(\"width\")`). If set to \"auto\", the width of the table (plus any table inset) is used. Ignored completely if `tf_wrap` is FALSE.\n\nDetails\n\nManual insertion of newlines is not supported when `tf_wrap` is on and will result in a warning and undefined wrapping behavior. Passing vectors of already split strings remains supported, however in this case each string is word-wrapped separately with the behavior described above.\n\nValue\n\nA string representation of `x` as it appears when printed.\nExamples\n\n```r\nlibrary(dplyr)\n\niris2 <- iris %>%\n group_by(Species) %>%\n mutate(group = as.factor(rep_len(c(\"a\", \"b\"), length.out = n()))) %>%\n ungroup()\n\nlyt <- basic_table() %>%\n split_cols_by(\"Species\") %>%\n split_cols_by(\"group\") %>%\n analyze(c(\"Sepal.Length\", \"Petal.Width\"), afun = list_wrap_x(summary), format = \"xx.xx\")\n\ntbl <- build_table(lyt, iris2)\n\ncat(toString(tbl, col_gap = 3))\n```\n\ntree_children\n\n**Retrieve or set the direct children of a Tree-style object**\n\n**Description**\n\nRetrieve or set the direct children of a Tree-style object\n\n**Usage**\n\n```r\ntree_children(x)\n\ntree_children(x) <- value\n```\n\n**Arguments**\n\n- **x**\n \n An object with a Tree structure\n\n- **value**\n \n New list of children.\n\n**Value**\n\nList of direct children of x\ntrim_levels_in_facets Trim Levels of Another Variable From Each Facet (Postprocessing split step)\n\nDescription\nTrim Levels of Another Variable From Each Facet (Postprocessing split step)\n\nUsage\ntrim_levels_in_facets(innervar)\n\nArguments\ninnervar(character. The variable(s) to trim (remove unobserved levels) independently within each facet.\n\nValue\na function suitable for use in the pre (list) argument of make_split_fun\n\nSee Also\nmake_split_fun\nOther make_custom_split: add_combo_facet(), drop_facet_levels(), make_split_fun(), make_split_result()\n\ntrim_levels_to_map Trim Levels to map\n\nDescription\nThis split function constructor creates a split function which trims levels of a variable to reflect restrictions on the possible combinations of two or more variables which are split by (along the same axis) within a layout.\n\nUsage\ntrim_levels_to_map(map = NULL)\n\nArguments\nmap(data.frame. A data.frame defining allowed combinations of variables. Any combination at the level of this split not present in the map will be removed from the data, both for the variable being split and those present in the data but not associated with this split or any parents of it.)\nDetails\n\nWhen splitting occurs, the map is subset to the values of all previously performed splits. The levels of the variable being split are then pruned to only those still present within this subset of the map representing the current hierarchical splitting context.\n\nSplitting is then performed via the `keep_split_levels` split function.\n\nEach resulting element of the partition is then further trimmed by pruning values of any remaining variables specified in the map to those values allowed under the combination of the previous and current split.\n\nValue\n\na fun\n\nSee Also\n\n`trim_levels_in_group()`\n\nExamples\n\n```r\nmap <- data.frame(\n LBCAT = c(\"CHEMISTRY\", \"CHEMISTRY\", \"CHEMISTRY\", \"IMMUNOLOGY\"),\n PARAMCD = c(\"ALT\", \"CRP\", \"CRP\", \"IGA\"),\n ANRIND = c(\"LOW\", \"LOW\", \"HIGH\", \"HIGH\"),\n stringsAsFactors = FALSE\n)\nlyt <- basic_table() %>%\n split_rows_by(\"LBCAT\") %>%\n split_rows_by(\"PARAMCD\", split_fun = trim_levels_to_map(map = map)) %>%\n analyze(\"ANRIND\")\ntbl <- build_table(lyt, ex_adlb)\n```\n\n---\n\n**trim_rows** \n*Trim rows from a populated table without regard for table structure*\n\nDescription\n\nTrim rows from a populated table without regard for table structure\n\nUsage\n\n`trim_rows(tt, criteria = all_zero_or_na)`\n\nArguments\n\n- `tt` \n TableTree (or related class). A TableTree object representing a populated table.\n\n- `criteria` \n Function. Function which takes a TableRow object and returns `TRUE` if that row should be removed. Defaults to `all_zero_or_na`\nDetails\n\nThis function will be deprecated in the future in favor of the more elegant and versatile `prune_table()` function which can perform the same function as `trim_rows()` but is more powerful as it takes table structure into account.\n\nValue\n\nThe table with rows that have only NA or 0 cell values removed\n\nNote\n\nVisible LabelRows are including in this trimming, which can lead to either all label rows being trimmed or label rows remaining when all data rows have been trimmed, depending on what criteria returns when called on a LabelRow object. To avoid this, use the structurally-aware `prune_table` machinery instead.\n\nSee Also\n\n`prune_table()`\n\nExamples\n\n```r\nadsl <- ex_adsl\nlevels(adsl$SEX) <- c(levels(ex_adsl$SEX), \"OTHER\")\n\ntbl_to_trim <- basic_table() %>%\n analyze(\"BMRKR1\") %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"SEX\") %>%\n summarize_row_groups() %>%\n split_rows_by(\"STRATA1\") %>%\n summarize_row_groups() %>%\n analyze(\"AGE\") %>%\n build_table(adsl)\n\ntbl_to_trim %>% trim_rows()\n\ntbl_to_trim %>% trim_rows(all_zero)\n```\n\n---\n\n**trim_zero_rows**\n\nTrim Zero Rows\nUsage\n\n`trim_zero_rows(tbl)`\n\nArguments\n\n- `tbl` table object\n\nValue\n\n- an rtable object\n\n---\n\n**tt_at_path**\n\n*Get or set table elements at specified path*\n\nDescription\n\nGet or set table elements at specified path\n\nUsage\n\n```\ntt_at_path(tt, path, ...)\n```\n\n```\ntt_at_path(tt, path, ...) <- value\n```\n\nArguments\n\n- `tt` TableTree (or related class). A TableTree object representing a populated table.\n- `path` character. A vector path for a position within the structure of a tabletree. Each element represents a subsequent choice amongst the children of the previous choice.\n- `...` unused.\n- `value` The new value\n\nNote\n\nSetting `NULL` at a defined path removes the corresponding sub table.\n\nExamples\n\n```\n# Accessing sub table.\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"SEX\") %>%\n split_rows_by(\"BMRKR2\") %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, ex_adsl) %>% prune_table()\n```\nsub_tbl <- tt_at_path(tbl, path = c(\"SEX\", \"F\", \"BMRKR2\"))\n\n# Removing sub table.\ntbl2 <- tbl\ntt_at_path(tbl2, path = c(\"SEX\", \"F\")) <- NULL\n tbl2\n\n# Setting sub table.\nlyt3 <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_rows_by(\"SEX\") %>%\n analyze(\"BMRKR2\")\n\n tbl3 <- build_table(lyt3, ex_adsl) %>% prune_table()\n\n tt_at_path(tbl3, path = c(\"SEX\", \"F\", \"BMRKR2\")) <- sub_tbl\n tbl3\n\n---\n\n**tt_to_flextable**\n\nCreate a FlexTable object representing an rtables TableTree\n\n**Description**\n\nCreate a FlexTable object representing an rtables TableTree\n\n**Usage**\n\n```r\ntt_to_flextable(\n tt,\n paginate = FALSE,\n lpp = NULL,\n cpp = NULL,\n ...,\n colwidths = propose_column_widths(matrix_form(tt, indent_rownames = TRUE)),\n tf_wrap = !is.null(cpp),\n max_width = cpp,\n total_width = 10\n)\n```\n\n**Arguments**\n\n- **tt**\n - TableTree (or related class). A TableTree object representing a populated table.\n- **paginate**\n - logical(1). Should `tt` be paginated and exported as multiple flextables. Defaults to FALSE\n- **lpp**\n - numeric. Maximum lines per page including (re)printed header and context rows\nupdate_ref_indexing\n\n**Description**\n\nRe-indexes footnotes within a built table\n\n**Usage**\n\n`update_ref_indexing(tt)`\nArguments\n\n- **tt**: TableTree (or related class). A TableTree object representing a populated table.\n\nDetails\n\nAfter adding or removing referential footnotes manually, or after subsetting a table, the reference indexes (i.e., the number associated with specific footnotes) may be incorrect. This function recalculates these based on the full table.\n\nNote\n\nIn the future this should not generally need to be called manually.\n\n---\n\nvalue_formats\n\n<table>\n<thead>\n<tr>\n<th>Value Formats</th>\n</tr>\n</thead>\n</table>\n\nDescription\n\nReturns a matrix of formats for the cells in a table\n\nUsage\n\n```r\nvalue_formats(obj, default = obj_format(obj))\n```\n\n- **ANY**\n ```r\n value_formats(obj, default = obj_format(obj))\n ```\n\n- **TableRow**\n ```r\n value_formats(obj, default = obj_format(obj))\n ```\n\n- **LabelRow**\n ```r\n value_formats(obj, default = obj_format(obj))\n ```\n\n- **VTableTree**\n ```r\n value_formats(obj, default = obj_format(obj))\n ```\n\nArguments\n\n- **obj**: A table or row object.\n- **default**: FormatSpec.\n\nValue\n\nMatrix (storage mode list) containing the effective format for each cell position in the table (including 'virtual' cells implied by label rows, whose formats are always NULL)\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_rows_by(\"RACE\", split_fun = keep_split_levels(c(\"ASIAN\", \"WHITE\"))) %>%\n analyze(\"AGE\")\n\ntbl <- build_table(lyt, DM)\nvalue_formats(tbl)\n```\n\nVarLevelSplit-class Split on levels within a variable\n\nDescription\n\nSplit on levels within a variable\n\nUsage\n\nVarLevelSplit(\n var,\n split_label,\n labels_var = NULL,\n cfun = NULL,\n cformat = NULL,\n cna_str = NA_character_,\n split_fun = NULL,\n split_format = NULL,\n split_na_str = NA_character_,\n valorder = NULL,\n split_name = var,\n child_labels = c(\"default\", \"visible\", \"hidden\"),\n extra_args = list(),\n indent_mod = 0L,\n label_pos = c(\"topleft\", \"hidden\", \"visible\"),\n cindent_mod = 0L,\n cvar = \",\n cextra_args = list(),\n page_prefix = NA_character_,\n section_div = NA_character_,\n)\n\nVarLevWBaselineSplit(\n var,\n ref_group,\n labels_var = var,\n split_label,\n split_fun = NULL,\nlabel_fstr = \"%s - %s\",\ncfun = NULL,\ncformat = NULL,\ncna_str = NA_character_,\ncvar = \"\",\nsplit_format = NULL,\nsplit_na_str = NA_character_,\nvalorder = NULL,\nsplit_name = var,\nextra_args = list()\n)\n\nArguments\n\nvar string, variable name\n\nsplit_label string. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).\n\nlabels_var string, name of variable containing labels to be displayed for the values of var\n\ncfun list/function/NULL. tabulation function(s) for creating content rows. Must accept x or df as first parameter. Must accept labelstr as the second argument. Can optionally accept all optional arguments accepted by analysis functions. See analyze.\n\ncformat format spec. Format for content rows\n\ncna_str character. NA string for use with cformat for content table.\n\nsplit_fun function/NULL. custom splitting function See custom_split_funs\n\nsplit_format FormatSpec. Default format associated with the split being created.\n\nsplit_na_str character. NA string vector for use with split_format.\n\nvalorder character vector. Order that the split children should appear in resulting table.\n\nsplit_name string. Name associated with this split (for pathing, etc)\n\nchild_labels string. One of \"default\", \"visible\", \"hidden\". What should the display behavior be for the labels (ie label rows) of the children of this split. Defaults to \"default\" which flags the label row as visible only if the child has 0 content rows.\n\nextra_args list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\n\nindent_mod numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure’s children. Defaults to 0, which corresponds to the unmodified default behavior.\n\nlabel_pos character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\ncindent_mod numeric(1). The indent modifier for the content tables generated by this split.\ncvar character(1). The variable, if any, which the content function should accept. Defaults to NA.\ncextra_args list. Extra arguments to be passed to the content function when tabulating row group summaries.\npage_prefix character(1). Prefix, to be appended with the split value, when forcing pagination between the children of this split/table.\nsection_div character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_ (the default) for no section divider.\nref_group character. Value of var to be taken as the ref_group/control to be compared against.\nlabel_fstr string. An sprintf style format string containing. For non-comparison splits, it can contain up to one \"%s\" which takes the current split value and generates the row/column label. Comparison-based splits it can contain up to two \"%s\".\n\nValue\n\nda VarLevelSplit object.\n\nAuthor(s)\n\nGabriel Becker\n\nVarStaticCutSplit-class\n\nSplits for cutting by values of a numeric variable\n\nDescription\n\nSplits for cutting by values of a numeric variable\nCreate static cut or static cumulative cut split\n\nUsage\n\nmake_static_cut_split(\n var,\n split_label,\n cuts,\n cutlabels = NULL,\n cfun = NULL,\n cformat = NULL,\n cna_str = NA_character_,\n split_format = NULL,\n split_na_str = NA_character_,\n)\nVarStaticCutSplit-class\n\nsplit_name = var,\nchild_labels = c(\"default\", \"visible\", \"hidden\"),\nextra_args = list(),\nindent_mod = 0L,\ncindent_mod = 0L,\ncvar = \",\ncextra_args = list(),\nlabel_pos = \"visible\",\ncumulative = FALSE,\npage_prefix = NA_character_,\nsection_div = NA_character_\n)\n\nVarDynCutSplit(\n var,\nsplit_label,\ncutfun,\ncutlabelfun = function(x) NULL,\ncfun = NULL,\ncformat = NULL,\ncna_str = NA_character_,\nsplit_format = NULL,\nsplit_na_str = NA_character_,\nsplit_name = var,\nchild_labels = c(\"default\", \"visible\", \"hidden\"),\nextra_args = list(),\ncumulative = FALSE,\nindent_mod = 0L,\ncindent_mod = 0L,\ncvar = \",\ncextra_args = list(),\nlabel_pos = \"visible\",\npage_prefix = NA_character_,\nsection_div = NA_character_\n)\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>var</td>\n<td>string, variable name</td>\n</tr>\n<tr>\n<td>split_label</td>\n<td>string. Label string to be associated with the table generated by the split. Not to be confused with labels assigned to each child (which are based on the data and type of split during tabulation).</td>\n</tr>\n<tr>\n<td>cuts</td>\n<td>numeric. Cuts to use</td>\n</tr>\n<tr>\n<td>cutlabels</td>\n<td>character (or NULL). Labels for the cuts</td>\n</tr>\n<tr>\n<td>cfun</td>\n<td>list/function/NULL. tabulation function(s) for creating content rows. Must accept x or df as first parameter. Must accept labelstr as the second argument. Can optionally accept all optional arguments accepted by analysis functions. See analyze.</td>\n</tr>\n</tbody>\n</table>\nVarStaticCutSplit-class\n\n- **cformat**: format spec. Format for content rows.\n- **cna_str**: character. NA string for use with cformat for content table.\n- **split_format**: FormatSpec. Default format associated with the split being created.\n- **split_na_str**: character. NA string vector for use with split_format.\n- **split_name**: string. Name associated with this split (for pathing, etc)\n- **child_labels**: string. One of \"default\", \"visible\", \"hidden\". What should the display behavior be for the labels (ie label rows) of the children of this split. Defaults to \"default\" which flags the label row as visible only if the child has 0 content rows.\n- **extra_args**: list. Extra arguments to be passed to the tabulation function. Element position in the list corresponds to the children of this split. Named elements in the child-specific lists are ignored if they do not match a formal argument of the tabulation function.\n- **indent_mod**: numeric. Modifier for the default indent position for the structure created by this function(subtable, content table, or row) and all of that structure’s children. Defaults to 0, which corresponds to the unmodified default behavior.\n- **cindent_mod**: numeric(1). The indent modifier for the content tables generated by this split.\n- **cvar**: character(1). The variable, if any, which the content function should accept. Defaults to NA.\n- **cextra_args**: list. Extra arguments to be passed to the content function when tabulating row group summaries.\n- **label_pos**: character(1). Location the variable label should be displayed. Accepts hidden (default for non-analyze row splits), visible, topleft, and - for analyze splits only - default. For analyze calls, default indicates that the variable should be visible if and only if multiple variables are analyzed at the same level of nesting.\n- **cumulative**: logical. Should the cuts be treated as cumulative. Defaults to FALSE.\n- **page_prefix**: character(1). Prefix, to be appended with the split value, when forcing pagination between the children of this split/table.\n- **section_div**: character(1). String which should be repeated as a section divider after each group defined by this split instruction, or NA_character_(the default) for no section divider.\n- **cutfun**: function. Function which accepts the full vector of var values and returns cut points to be used (via cut) when splitting data during tabulation.\n- **cutlabelfun**: function. Function which returns either labels for the cuts or NULL when passed the return value of cutfun.\n\n**Value**\n\nA VarStaticCutSplit, CumulativeCutSplit object for `make_static_cut_split`, or a VarDynCutSplit object for `VarDynCutSplit()`\nvars_in_layout\n\nList Variables required by a pre-data table layout\n\nDescription\n\nList Variables required by a pre-data table layout\n\nUsage\n\nvars_in_layout(lyt)\n\n## S4 method for signature 'PreDataTableLayout'\nvars_in_layout(lyt)\n\n## S4 method for signature 'PreDataAxisLayout'\nvars_in_layout(lyt)\n\n## S4 method for signature 'SplitVector'\nvars_in_layout(lyt)\n\n## S4 method for signature 'Split'\nvars_in_layout(lyt)\n\n## S4 method for signature 'CompoundSplit'\nvars_in_layout(lyt)\n\n## S4 method for signature 'ManualSplit'\nvars_in_layout(lyt)\n\nArguments\n\nlyt The Layout (or a component thereof)\n\nDetails\n\nThis will walk the layout declaration and return a vector of the names of the unique variables that are used in any of the following ways:\n\n- Variable being split on (directly or via cuts)\n- Element of a Multi-variable column split\n- Content variable\n- Value-label variable\n\nValue\n\nA character vector containing the unique variables explicitly used in the layout (see Notes).\nNote\n\nThis function will not detect dependencies implicit in analysis or summary functions which accept x or df and then rely on the existence of particular variables not being split on/analyzed.\n\nThe order these variable names appear within the return vector is undefined and should not be relied upon.\n\nExamples\n\n```r\nlyt <- basic_table() %>%\n split_cols_by(\"ARM\") %>%\n split_cols_by(\"SEX\") %>%\n summarize_row_groups(label_fstr = \"Overall (N)\") %>%\n split_rows_by(\"RACE\", split_label = \"Ethnicity\", labels_var = \"ethn_lab\",\n split_fun = drop_split_levels) %>%\n summarize_row_groups(\"RACE\", label_fstr = \"%s (n)\") %>%\n analyze(\"AGE\", var_labels = \"Age\", afun = mean, format = \"xx.xx\")\n\nvars_in_layout(lyt)\n```\n\n---\n\n**Viewer**\n\n*Display an rtable object in the Viewer pane in RStudio or in a browser*\n\nDescription\n\nThe table will be displayed using the bootstrap styling for tables.\n\nUsage\n\n```r\nViewer(x, y = NULL, row.names.bold = FALSE, ...)\n```\n\nArguments\n\n- `x` object of class rtable or shiny.tag (defined in htmltools)\n- `y` optional second argument of same type as x\n- `row.names.bold` row.names.bold boolean, make rownames bold\n- `...` arguments passed to as_html\n\nValue\n\nnot meaningful. Called for the side effect of opening a browser or viewer pane.\nExamples\n\n```r\nif(interactive()) {\n sl5 <- factor(iris$Sepal.Length > 5, levels = c(TRUE, FALSE),\n labels = c(\"S.L > 5\", \"S.L <= 5\"))\n\n df <- cbind(iris, sl5 = sl5)\n\n lyt <- basic_table() %>%\n split_cols_by(\"sl5\") %>%\n analyze(\"Sepal.Length\")\n\n tbl <- build_table(lyt, df)\n Viewer(tbl)\n Viewer(tbl, tbl)\n\n tbl2 <- htmltools::tags$div(\n class = \"table-responsive\",\n as_html(tbl, class_table = \"table\")\n )\n\n Viewer(tbl, tbl2)\n}\n```\nIndex\n\n* compatibility\n rheader, 103\n rrow, 107\n rrowl, 108\n rtable, 109\n* conventions\n compat_args, 38\n constr_args, 39\n gen_args, 54\n lyt_args, 70\n sf_args, 114\n* datasets\n select_all_levels, 112\n* make_custom_split\n add_combo_facet, 5\n drop_facet_levels, 46\n make_split_fun, 77\n make_split_result, 79\n trim_levels_in_facets, 145\n .tablerow(LabelRow), 66\n [,VTableTree,logical,logical-method (brackets), 23\n [<-,VTableTree,ANY,ANY,list-method (brackets), 23\n add_colcounts, 4\n add_combo_facet, 5, 46, 78, 80, 145\n add_combo_levels (select_all_levels), 112\n add_existing_table, 6\n add_overall_col, 7\n add_overall_facet (add_combo_facet), 5\n add_overall_level, 7, 8\n add_overall_level(), 8\n add_to_split_result\n (make_split_result), 79\n all_zero (all_zero_or_na), 9\n all_zero_or_na, 9, 10, 146\n analyze, 11, 12, 16, 69, 71, 72, 74, 85, 115, 138, 153, 155\n analyze(), 65, 75, 117\n analyze_colvars, 11, 17\n analyze_colvars(), 127\n AnalyzeColVarSplit (AnalyzeVarSplit), 15\n AnalyzeMultiVars (AnalyzeVarSplit), 15\n AnalyzeVarSplit, 15\n append_topleft, 19\n as.vector, 20\n as.vector, VTableTree-method (asvec), 20\n as_html, 21\n asvec, 20\n basic_table, 22\n brackets, 23\n build_table, 14, 26, 124, 135\n cbind_rtables, 28\n cell_footnotes (row_footnotes), 104\n cell_footnotes<- (row_footnotes), 104\n cell_values, 30\n cell_values(), 24, 105, 117\n CellValue, 29, 53\n clayout, 32\n clayout, ANY-method (clayout), 32\n clayout, PreDataTableLayouts-method (clayout), 32\n clayout, VTableNodeInfo-method (clayout), 32\n clayout<-(clayout), 32\n clayout<-, PreDataTableLayouts-method (clayout), 32\n clear_indent_mods, 34\n clear_indent_mods, TableRow-method (clear_indent_mods), 34\n clear_indent_mods, VTableTree-method (clear_indent_mods), 34\n col_counts (clayout), 32\n col_counts, InstantiatedColumnInfo-method (clayout), 32\ncol_counts, VTableNodeInfo-method (clayout), 32\ncol_counts<- (clayout), 32\ncol_counts<-, InstantiatedColumnInfo-method (clayout), 32\ncol_counts<-, VTableNodeInfo-method (clayout), 32\ncol_exprs (clayout), 32\ncol_exprs, InstantiatedColumnInfo-method (clayout), 32\ncol_exprs, PreDataColLayout-method (clayout), 32\ncol_exprs, PreDataTableLayouts-method (clayout), 32\ncol_fnotes_here (row_footnotes), 104\ncol_fnotes_here<- (row_footnotes), 104\ncol_info (clayout), 32\ncol_info, VTableNodeInfo-method (clayout), 32\ncol_info<- (clayout), 32\ncol_info<-, ElementaryTable-method (clayout), 32\ncol_info<-, TableRow-method (clayout), 32\ncol_info<-, TableTree-method (clayout), 32\ncol_paths (row_paths), 105\ncol_paths(), 104\ncol_paths_summary (row_paths_summary), 106\ncol_paths_summary(), 104, 105\ncol_total (clayout), 32\ncol_total, InstantiatedColumnInfo-method (clayout), 32\ncol_total, VTableNodeInfo-method (clayout), 32\ncol_total<- (clayout), 32\ncol_total<-, InstantiatedColumnInfo-method (clayout), 32\ncol_total<-, VTableNodeInfo-method (clayout), 32\ncollect_leaves, 35\ncoltree (clayout), 32\ncoltree, InstantiatedColumnInfo-method (clayout), 32\ncoltree, LayoutColTree-method (clayout), 32\ncoltree, PreDataColLayout-method (clayout), 32\ncoltree, PreDataTableLayouts-method (clayout), 32\ncoltree, TableRow-method (clayout), 32\ncoltree, TableTree-method (clayout), 32\ncompare_rtables, 36\ncompair_args, 38, 41, 56, 73, 114\nconstr_args, 38, 39, 56, 73, 114\ncnt_n_allcols, 41\ncnt_n_allcols(), 117\ncnt_n_onecol (cnt_n_allcols), 41\ncnt_n_onecol(), 117\ncontent_all_zeros_nas (all_zero_or_na), 9\ncontent_table, 41\ncontent_table(), 117\ncontent_table<- (content_table), 41\nContentRow (LabelRow), 66\nContentRow-class (LabelRow), 66\ncounts_wpcts, 42\nCumulativeCutSplit-class\n(VarStaticCutSplit-class), 154\ncustom_split_funcs, 43, 45, 72, 78, 86, 119, 126, 130, 134, 153\nDataRow, 103\nDataRow (LabelRow), 66\nDataRow(), 61\nDataRow-class (LabelRow), 66\ndf_to_tt, 44\ndim, VTableNodeInfo-method\n(nrow, VTableTree-method), 87\ndo_base_split, 45\ndrop_and_remove_levels (split_funcs), 127\ndrop_facet_levels, 6, 46, 78, 80, 145\ndrop_split_levels (split_funcs), 127\nElementaryTable\n(ElementaryTable-class), 47\nElementaryTable-class, 47\nEmptyAllSplit (EmptyColInfo), 49\nEmptyColInfo, 49\nEmptyElTable (EmptyColInfo), 49\nEmptyRootSplit (EmptyColInfo), 49\nexport_as_pdf, 49\nexport_as_tsv, 51\nfnotes_at_path<- (row_footnotes), 104\nformat_rcell, 52\nformatters::export_as_txt(), 51\nformatters::format_value, 52\nformatters_methods\n (obj_name,VNodeInfo-method), 89\n\ngen_args, 38, 41, 54, 73, 114\nget_cell_aligns (get_formatted_cells), 56\nget_cell_aligns,ElementaryTable-method\n (get_formatted_cells), 56\nget_cell_aligns,LabelRow-method\n (get_formatted_cells), 56\nget_cell_aligns,TableRow-method\n (get_formatted_cells), 56\nget_cell_aligns,TableTree-method\n (get_formatted_cells), 56\nget_formatted_cells, 56\nget_formatted_cells,ElementaryTable-method\n (get_formatted_cells), 56\nget_formatted_cells,LabelRow-method\n (get_formatted_cells), 56\nget_formatted_cells,TableRow-method\n (get_formatted_cells), 56\nget_formatted_cells,TableTree-method\n (get_formatted_cells), 56\nhead, 57\nhead,VTableTree-method (head), 57\nhorizontal_sep, 58\nhorizontal_sep,VTableTree-method\n (horizontal_sep), 58\nhorizontal_sep<-(horizontal_sep), 58\nhorizontal_sep<-,TableRow-method\n (horizontal_sep), 58\nhorizontal_sep<-,TableTree-method\n (horizontal_sep), 58\nimport_from_tsv (export_as_tsv), 51\nin_rows, 64\nin_rows(), 111\nindent, 59\nindent_string, 60\ninsert_row_at_path, 61, 62\ninsert_row_at_path,VTableTree,ANY-method\n (insert_row_at_path), 61\ninsert_row_at_path,VTableTree,DataRow-method\n (insert_row_at_path), 61\ninsert_row, 62\n\nInstantiatedColumnInfo\n (InstantiatedColumnInfo-class), 63\nInstantiatedColumnInfo-class, 63\nis_rtable, 65\nkeep_split_levels, 146\nkeep_split_levels (split_funcs), 127\nlabel_at_path, 62, 67\nlabel_at_path<-(label_at_path), 67\nLabelRow, 66, 103\nLabelRow-class (LabelRow), 66\nlength, 115\nlength,CellValue-method, 68\nlist_valid_format_labels, 23, 38, 102,\n 103, 107–109\nlist_wrap_df (list_wrap_x), 69\nlist_wrap_x, 69\nlow_obs_pruner (all_zero_or_na), 9\nlyt_args, 38, 41, 56, 70, 114\nmain_footer,VTitleFooter-method\n (obj_name,VNodeInfo-method), 89\nmain_footer<-,VTitleFooter-method\n (obj_name,VNodeInfo-method), 89\nmain_title,VTitleFooter-method\n (obj_name,VNodeInfo-method), 89\nmain_title<-,VTitleFooter-method\n (obj_name,VNodeInfo-method), 89\nmake_afun, 14, 73\nmake_col_df, 76\nmake_row_df,LabelRow-method\n (obj_name,VNodeInfo-method), 89\nmake_row_df,TableRow-method\n (obj_name,VNodeInfo-method), 89\nmake_row_df,VTableTree-method\n (obj_name,VNodeInfo-method), 89\nmake_split_fun, 6, 46, 77, 80, 136, 145\nmake_split_fun(), 43\nmake_split_result, 6, 46, 78, 79, 145\nmake_static_cut_split\n (VarStaticCutSplit-class), 154\nmanual_cols, 82\nManualSplit, 80\nmatrix_form,VTableTree-method, 83\nmean, 115\nMultiVarSplit, 84\nINDEX\n\nrheader, 103, 107–109\nrow.names, VTableTree-method\n (names, VTableNodeInfo-method), 86\nrow.cells(obj_avar), 88\nrow.cells, TableRow-method(obj_avar), 88\nrow.cells<-(obj_avar), 88\nrow_footnotes, 104\nrow_footnotes<-(row_footnotes), 104\nrow_paths, 68, 105\nrow_paths_summary, 106\nrow_paths_summary(), 104, 105, 117\nrow_values(obj_avar), 88\nrow_values, TableRow-method(obj_avar), 88\nrow_values<-(obj_avar), 88\nrow_values<-, LabelRow-method(obj_avar), 88\nrow_values<-, TableRow-method(obj_avar), 88\nrrow, 38, 103, 107, 108, 109\nrrow(), 61\nrrowl, 103, 107, 108, 109\nrtable, 59, 103, 107, 108, 109, 158\nrtable1(rtable), 109\nrtables_aligns, 30, 64, 73, 102, 111\nselect_all_levels, 112\nsf_args, 38, 41, 56, 73, 114\nsimple_analysis, 115\nsimple_analysis, ANY-method\n (simple_analysis), 115\nsimple_analysis, factor-method\n (simple_analysis), 115\nsimple_analysis, logical-method\n (simple_analysis), 115\nsimple_analysis, numeric-method\n (simple_analysis), 115\nsort_at_path, 116\nsort_at_path(), 42\nspcontext, 135\nspcontext_to_disp_path, 135\nspvariable, 136\nspvariable, Split-method\n (spvariable), 136\nspvariable, VarDynCutSplit-method\n (spvariable), 136\nspvariable, VarLevelSplit-method\n (spvariable), 136\nspvariable, VarStaticCutSplit-method\n (spvariable), 136\nsplit_cols_by, 118, 136\nsplit_cols_by_cutfun, 136\nsplit_cols_by_cutfun\n (split_cols_by_cutfun), 121\nsplit_cols_by_cuts, 121, 136\nsplit_cols_by_multivar, 126\nsplit_cols_by_multivar(), 18, 134\nsplit_cols_by_quartiles\n (split_cols_by_cutfun), 121\nsplit_funcs, 43, 127\nsplit_rows_by, 10, 130, 136\nsplit_rows_by(), 134\nsplit_rows_by_cutfun, 136\nsplit_rows_by_cutfun\n (split_cols_by_cutfun), 121\nsplit_rows_by_cuts, 136\nsplit_rows_by_cuts\n (split_cols_by_cutfun), 121\nsplit_rows_by_multivar, 133\nsplit_rows_by_quartiles\n (split_cols_by_cutfun), 121\nsubtitles, VTitleFooter-method\n (obj_name, VNodeInfo-method), 89\nsubtitles<-, VTitleFooter-method\n (obj_name, VNodeInfo-method), 89\nsum, 115\nsummarize_row_groups, 137\nsummarize_row_groups()\n (), 117\nsummarize_rows, 137\ntable_inset, 38, 107–109\ntable_inset, PreDataTableLayouts-method\n (obj_name, VNodeInfo-method), 89\ntable_inset, VTableNodeInfo-method\n (obj_name, VNodeInfo-method), 89\ntable_inset<-, InstantiatedColumnInfo-method\n (obj_name, VNodeInfo-method), 89\ntable_inset<-, PreDataTableLayouts-method\n (obj_name, VNodeInfo-method), 89\ntable_inset<-, VTableNodeInfo-method\n (obj_name, VNodeInfo-method), 89\ntable_shell, 139\ntable_shell_str(table_shell), 139\nINDEX\n\nTableTree (ElementaryTable-class), 47\n\nTableTree-class\n(ElementaryTable-class), 47\n\ntail (head), 57\ntag,VTableTree-method (head), 57\ntop_left, 142\ntop_left(), 20\ntop_left,InstantiatedColumnInfo-method (top_left), 142\ntop_left,PreDataTableLayouts-method (top_left), 142\n\ntop_left<-, (top_left), 142\ntop_left<-, InstantiatedColumnInfo-method (top_left), 142\ntop_left<-,PreDataTableLayouts-method (top_left), 142\ntop_left<-,VTableTree-method (top_left), 142\ntostring, 143\ntoString,VTableTree-method (tostring), 143\ntree_children, 144\ntree_children(), 117\ntree_children<-, (tree_children), 144\ntrim_levels_in_facets, 6, 46, 78, 80, 145\ntrim_levels_in_group (split_funcs), 127\ntrim_levels_in_group(), 146\ntrim_levels_to_map, 145\ntrim_rows, 146\ntrim_rows(), 11\ntrim_zero_rows, 147\ntt_at_path, 148\ntt_at_path<-, (tt_at_path), 148\ntt_to_flexttable, 149\nupdate_ref_indexing, 150\n\nvalue_at (cell_values), 30\n\nvalue_at,VTableTree-method (cell_values), 30\n\nvalue_formats, TableRow-method (value_formats), 151\n\nvalue_formats, VTableTree-method (value_formats), 151\n\nVarDynCutSplit (VarStaticCutSplit-class), 154\n\nVarDynCutSplit-class (VarStaticCutSplit-class), 154\n\nVarLevelSplit (VarLevelSplit-class), 152\n\nVarLevelSplit-class, 152\n\nVarLevWBaselineSplit (VarLevelSplit-class), 152\n\nvars_in_layout, 157\n\nvars_in_layout, CompoundSplit-method (vars_in_layout), 157\n\nvars_in_layout, ManualSplit-method (vars_in_layout), 157\n\nvars_in_layout, PreDataAxisLayout-method (vars_in_layout), 157\n\nvars_in_layout, PreDataTableLayouts-method (vars_in_layout), 157\n\nvars_in_layout, Split-method (vars_in_layout), 157\n\nvars_in_layout, SplitVector-method (vars_in_layout), 157\n\nVarStaticCutSplit-class, 154\n\nViewer, 158"}}},{"rowIdx":156,"cells":{"id":{"kind":"string","value":"bee829a94f389cd972c3d26f8ddda8f5dcae357a"},"text":{"kind":"string","value":"CONFLICT RESOLUTION AND OPERATOR PRIORITIES\nIN EXTENDED BNF\n\nRESEARCH THESIS\n\nSUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS\nFOR THE DEGREE OF\nMASTER OF SCIENCE IN COMPUTER SCIENCE\n\nANNA BEKKERMAN\n\nSUBMITTED TO THE SENATE OF THE TECHNION - ISRAEL INSTITUTE OF TECHNOLOGY\n\nTAMUZ, 5764 HAIFA JULY, 2004\nACKNOWLEDGMENTS\n\nI am grateful to my advisor Dr. Joseph Gil. He patiently guided me throughout the work, and taught me much about research.\nI would like to thank my husband for his help. I thank my parents for their everlasting love, encouragement and support. Also, I am grateful to Felix Laventman for technical support.\n\nTHE GENEROUS FINANCIAL HELP OF THE TECHNION IS GRATEFULLY ACKNOWLEDGED\n# Contents\n\nNotation ................................................................. 2\n\n1 Introduction and Related Works ..................................... 4\n 1.1 LL parsers .......................................................... 6\n 1.2 LR parsers .......................................................... 10\n 1.3 Employing EBNF for parsing ....................................... 13\n 1.4 Contributions ....................................................... 19\n\n2 Preliminaries and Definitions ......................................... 21\n 2.1 Grammars ............................................................. 21\n 2.2 Derivation ............................................................ 22\n 2.3 Parse Trees ........................................................... 23\n 2.4 LR Parsing ............................................................ 24\n 2.4.1 Actions ........................................................... 26\n 2.4.2 Stack ............................................................. 26\n 2.4.3 Parsing Table ................................................... 26\n 2.5 The Algorithm for LR-parsing Extended Context Free Grammars . 27\n\n3 JAMOOS ................................................................. 29\n 3.1 Extended BNF in JAMOOS ........................................... 29\n 3.2 Production Types .................................................... 31\n\n4 Types of Conflicts ..................................................... 33\n 4.1 Reduce/Reduce Conflicts ............................................ 34\n 4.2 Shift/Reduce Conflicts ............................................. 35\n 4.3 Pop/Reduce Conflicts .............................................. 35\n 4.4 Pop/Pop Conflicts .................................................. 36\n\n5 JAMOOS Extension for Priorities and Associativity ................. 37\n 5.1 Priorities Section ................................................... 37\n 5.2 Local Priority Assignment ......................................... 39\n 5.3 Problems with Priorities in JAMOOS .............................. 40\n 5.3.1 Assigning Priority and Associativity to a Production .... 40\n 5.3.2 Assigning Priority and Associativity to a Token ........... 41\n 5.3.3 Statement of Context-Dependent Priority Problem ......... 41\n 5.3.4 Statement of Ambiguous Assignment Problem .............. 42\n 5.4 Solution for Context-Dependent Priority Problem .............. 43\n 5.5 Solution for Ambiguous Assignment Problem ................. 46\n\n6 Algorithms Developed for Conflict Resolution ...................... 48\n 6.1 Resolution of Reduce/Reduce Conflicts .......................... 48\n 6.2 Resolution of Shift/Reduce Conflicts ............................ 48\n 6.3 Resolution of Pop/Reduce Conflicts ............................. 55\n 6.4 Resolution of Pop/Pop Conflicts ................................ 56\n7 Implementation 58\n7.1 Adding Syntactical Support for Priorities Section Definitions 60\n7.2 Conflict Resolution Implementation 60\n7.3 Grammar Report Generation 61\n 7.3.1 Generation of Conflict Reports 62\n 7.3.2 Parser Representation Format 63\n8 Conflict Resolution in Grammars of JAVA and JAMOOS 64\n8.1 Shift/Reduce Conflicts 65\n 8.1.1 Array Creation Conflict 65\n 8.1.2 Modifiers Conflict 66\n 8.1.3 Dangling Else Conflict 68\n8.2 Reduce/Reduce Conflicts 68\n8.3 Pop/Reduce Conflicts 70\n 8.3.1 Choice Expressions in JAMOOS 70\n 8.3.2 Nested Choice Expressions Conflict 71\n8.4 Pop/Pop Conflicts 73\n 8.4.1 Optional Expressions in JAMOOS 73\n 8.4.2 Optional-Choice Conflict 74\n9 Conclusions 76\nA JAVA Language Grammar 79\nList of Figures\n\n1 Parse trees derived for unambiguous input string ........................................ 5\n2 Parse trees derived for expressions 2+3*5 and 3*5+2 according to a grammar for which left\n recursion elimination technique was applied ............................................. 8\n3 Parse tree derived for the expression 6–4–1 according to an LL grammar that describes\n arithmetic expressions ................................................................. 9\n4 Parse trees derived for the same sting according to a production which contains\n regular expressions ................................................................. 18\n5 Parse tree for BNF grammar ............................................................. 24\n6 Parse tree for EBNF grammar ............................................................. 24\n7 Generation and execution of an object oriented parser by JAMOOS parser generator 31\n8 Reduce/Reduce conflict ................................................................. 34\n9 Shift/Reduce conflict ................................................................. 35\n10 Pop/Reduce conflict ................................................................. 36\n11 Pop/Pop conflict ................................................................. 37\n12 Resolution of a Pop/Reduce conflict in favor of the pop action ...................... 55\n13 Resolution of a Pop/Reduce conflict in favor of the reduce action .................. 56\n14 Resolution of a Pop/Pop conflict in favor of a shorter alternative .................. 58\n15 Resolution of a Pop/Pop conflict in favor of a longer alternative .................. 58\n16 Array creation conflict in JAVA ..................................................... 66\n17 Modifiers conflict in JAVA .......................................................... 67\n18 Resolution of the nested choice expression conflict in JAMOOS in favor of the pop\n action .................................................................................. 72\n19 Resolution of the nested choice expression conflict in JAMOOS in favor of the reduce\n action .................................................................................. 72\n20 Resolution of the optional-choice conflict in JAMOOS in favor of choice expression\n interpretation ........................................................................ 75\n21 Resolution of the optional-choice conflict in JAMOOS in favor of general optional\n expression interpretation ............................................................ 75\n**List of Algorithms**\n\n1. Madsen and Kristensen’s generalized algorithm for LR parsing of Extended Context Free Grammars .................................................. 30\n2. Intermediate step in resolution of a Shift/Reduce conflict: split productions that contain the shifted token to two groups according to the token’s priority and associativity with respect to the priority of the reduced production ........................................... 45\n3. Intermediate step in resolution of a Shift/Reduce conflict (lookahead): generate set of tokens that can potentially follow a given token ......................................................... 46\n4. Intermediate step in resolution of a Shift/Reduce conflict (lookahead): generate two sets of tokens that can follow a given token; each group corresponds to a group of productions built in Algorithm 2 .............................................................. 47\n5. Reduce/Reduce conflict resolution ...................................................... 49\n6. Priority assignment to a production according to the priority of its rightmost token ......................................................... 50\n7. Identification of the rightmost token in a production ......................... 51\n8. Identification of the rightmost token in a list ..................................... 52\n9. Shift/Reduce conflict resolution ......................................................... 53\n10. Priority and associativity assignment to a token according to the priority and associativity of a production in which the token appears ................................................................. 54\n11. Pop/Reduce conflict resolution ......................................................... 57\n12. Pop/Pop conflict resolution ............................................................. 59\nAbstract\n\nConflict resolution is a fundamental problem in the theory of compilation. YACC resolves conflicts by means of priorities and associativity. The main disadvantage of YACC is that it is based on BNF grammars which do not provide intuitive way of a formal language description. Extended BNF (EBNF) improves BNF by involving regular expressions such as lists, alternatives etc. Many conflicts of BNF grammars do not occur in EBNF grammars. Still, EBNF grammars bear conflicts that should be resolved. Furthermore, in addition to standard types of conflicts (Shift/Reduce and Reduce/Reduce) two other types (Pop/Reduce and Pop/Pop) may occur.\n\nObviously, conflicts can be eliminated by the grammar redesign. Also, the user can resolve conflicts by extending the parser’s functionality with special conflict resolution subroutines that would be unique for each grammar given. Both these user-provided solutions are extremely time consuming; the user should demonstrate deep knowledge in the parsing theory and large experience with the particular parser generator. A good conflict resolution method would be built-in the system, while a high-level user interface would be provided to decide about resolution strategies.\n\nThis thesis is the first work that proposes a built-in conflict resolution method that is universal for all four types of conflicts which may occur in EBNF grammars. To our knowledge, a built-in method for resolution of Pop/Reduce conflicts is first proposed in this thesis. Our method generalizes the popular approach of priorities and associativity. We provide original user interface for priorities and associativity assignment. In our method priorities can be explicitly specified for productions and production components as well as for tokens. In addition, Automatic Priority and Associativity Inference (APAI) is proposed for implicit assignment of priorities and associativity. Combined with explicit priority assignment, APAI allows managing priorities of abstract entities such as arithmetic operations. A runtime APAI is also proposed that performs a one-symbol lookahead for determining the actual parsing route in order to identify priority of the shifted token when more than one possible parsing routes exist for the input. The runtime APAI enriches the context information and provides the power of LR(2) without enlarging parsing tables. A set of original algorithms are designed for supporting the proposed conflict resolution method.\n\nWe implement these algorithms in a framework of a large ongoing project JAMOOS – a new object-oriented parser generator. In addition to natural advantages of its pure object-oriented software design, JAMOOS represents the ideal combination of a strong LR parsing technique and beneficial Extended BNF approach. Powered by our universal conflict resolution method, JAMOOS becomes the unique state-of-the-art modern system for parser generation.\nNotation\n\n$L$ Language\n$G$ Grammar\n$P$ Production\n$\\varepsilon$ Empty right-hand side of a production\n$t$ Token\n$x$ Either token or variable\n$\\mathcal{N}$ Set of nonterminal symbols\n$\\Sigma$ Set of terminal symbols\n$\\mathcal{P}$ Set of productions\n$S$ Start symbol of a grammar\n$A, B, D$ Nonterminals\n$\\alpha, \\beta, \\gamma, \\omega, \\phi, \\psi$ Expressions consisting of tokens and variables\n$RE(\\mathcal{N} \\cup \\Sigma)$ Set of regular expressions over $\\mathcal{N} \\cup \\Sigma$\n$\\epsilon$ Set consisting of empty string\n$\\emptyset$ Empty set\n$\\Rightarrow$ Derivation\n$\\Rightarrow^*$ Derivation performed in zero or more steps\n$T$ Parse tree\n$\\bullet$ LR-marker (dot)\n$s$ Parser state\n$\\phi$ Phrase of a language\n$#$ Indication on the action to be performed during parsing process. Used in algorithm for parsing EBNF grammars only\n$E_R$ Regular expression\n$r$ Reduce item\n$l$ List regular expression\n$e_l$ Repeated element of the list $l$\n$a$ Alternative regular expression\n$ch$ Choice in an alternative regular expression\n$P_l(s)$ Set of all productions which yielded LR-items in the state $s$ with the LR-marker directly before the token $t$\n$C$ Conflict\n$\\pi$ Priority\n$\\rho$ Associativity\n$PT$ Priority and associativity table\n$c$ Component of a production\n$S_C$ Set of LR-items from the parser state in which a conflict $C$ occurs\n<table>\n<thead>\n<tr>\n<th>Abbreviation</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>APAI</td>\n<td>Automatic Priority and Associativity Inference</td>\n</tr>\n<tr>\n<td>BNF</td>\n<td>Bachus-Naur Form</td>\n</tr>\n<tr>\n<td>CFG</td>\n<td>Context Free Grammar</td>\n</tr>\n<tr>\n<td>EBNF</td>\n<td>Extended Bachus-Naur Form</td>\n</tr>\n<tr>\n<td>ECFG</td>\n<td>Extended Context Free Grammar</td>\n</tr>\n<tr>\n<td>LR parsing</td>\n<td>A parsing technique. "L" stands for left-to-right scanning of the input, “R” stands for constructing rightmost derivation</td>\n</tr>\n<tr>\n<td>MSc</td>\n<td>Master of Science</td>\n</tr>\n</tbody>\n</table>\n1 Introduction and Related Works\n\nA process of compilation consists of a number of stages: lexical analysis, parsing, semantic analysis, intermediate code generation, optimizations, assembly and linkage. This thesis is focused on the parsing stage of the compilation process. The parsing (or syntactic analysis) bears especial importance since all further compilation stages depend on its successful execution.\n\nGiven an input in a language $L$ a parse tree of the input is built at the parsing stage. The parsing is based on a grammar $G$ that describes the syntax of the language $L$. In most cases syntax rules of a language are described in a recursive meta-language called Backus-Naur Form (BNF).\n\nAll languages are classified into two groups: ambiguous and unambiguous. A language is ambiguous if it appears to express more than one possible meaning. For example, all natural languages are ambiguous. Consider the following sentence:\n\nShe sent the apples to the buyers before they were ready.\n\nThe above sentence has two meanings. According to the first meaning the apples were not ready while according to the second one the buyers were not ready.\n\nProgramming languages may be ambiguous too. Probably the most famous ambiguity which appears in programming languages is related to conditional statements. For example, the following conditional statement is ambiguous:\n\n```\nif (i > 10) if (j < 0) k++ else k--\n```\n\nThe else branch in the example above may be equally associated with both conditions. This ambiguity is called a dangling else problem. It appears in programming languages such as JAVA and C++. Actually dangling else problem is not the only ambiguity which appears in these languages [32, 33, 18].\n\nSimilar to languages grammars may be either ambiguous or unambiguous. However, the term \"ambiguity\" has a different meaning when it is applied to grammars. A grammar is ambiguous if two or more parse trees can be built for the same input string according to this grammar. In other words, an ambiguous grammar gives more than one way of understanding an input.\n\nIf a language is ambiguous all grammars which describe the language will be ambiguous. However, if a grammar is ambiguous it does not necessarily mean that the language described by this grammar is ambiguous.\n\nExample 1. Consider the following grammar which describes a list of identifiers separated by commas:\n\n```\nList → Id;\nList → List OptComma Id;\nList → List “,”;\nOptComma → “,”;\nOptComma → ε;\n```\n\nThe above grammar is ambiguous though the language described by the grammar is unambiguous. Figure 1 shows two parse trees obtained for the input $a$, $b$.\n\n---\n\n1The implementational part of this research was carried out in the framework of the JAMOOS project. JAMOOS is an object oriented language for grammars, all grammars which will be discussed in this work, will be written in JAMOOS’s syntax unless other is specified. JAMOOS and its syntax are discussed in details in Section 3.\nObviously ambiguous grammars cannot be employed in the compilation process: two or more parse trees for the same input program implies two or more executables with different meanings for this program. Unfortunately, even unambiguous grammars sometimes are unsuitable for parsing because they are too complicated for the parsing algorithm. For the purposes of this discussion, we call such grammars confusing.\n\nExample 2. Consider the following grammar that describes strings which consists of letters a only and whose length is odd:\n\n\\[\nA \\rightarrow \"a\"; \\quad \\text{(1)} \\\\\nA \\rightarrow \"a\" A \"a\"; \\quad \\text{(2)}\n\\]\n\nThe grammar above is unambiguous: for each input string there exist a unique parse tree. Still, a parser generator such as YACC that builds parsers which read their inputs strictly left-to-right cannot handle this grammar.\n\nAccording to the grammar a parsing process should start at the middle of an input. However, a parser which read an input from left to right cannot locate the middle of the input because it uses a finite lookahead.\n\nParsers built for both ambiguous and confusing grammars contain conflicts. There exist several approaches to dealing with conflicts.\n\nOne of the approaches implies redesign of a grammar. There are several disadvantages in this approach. First, grammars must provide a suitable framework for associating semantic meaning with the input. Rewriting of a grammar in most cases hampers the structure of the grammar and causes to rethinking the semantic attribution. Another problem is that given an ambiguous grammar \\(G\\) that describes a language \\(L\\), it is undecidable whether there exist a grammar \\(G'\\) that describes \\(L\\) and does not contain conflicts [19]. It follows that grammar rewriting does not necessarily lead to eliminating of conflicts.\n\nAnother approach implies redesign of a language. For example, the dangling else problem would not occur if a terminating keyword such as end was used at the end of each conditional statement. The main disadvantage of this approach is that it often complicates the language. The end keyword which should be written after each conditional statement is an extra rule that anyone learning the language has to remember.\n\nMany conflicts can be eliminated by changing a parsing algorithm. The decision that a parser repeatedly makes is: given what it has already read of an input, and the grammar productions it has already applied, which production should be applied next? The more context information the\nA parser can obtain before it has to make the decision, the more likely it is to be able to avoid a conflict. Different parsing techniques provide different amount of context information to a parser. A considerable amount of conflicts, in particular those which occur in confusing grammars, can be eliminated by choosing a more powerful parsing algorithm.\n\nConflicts that cannot be eliminated by rewriting a grammar, language redesign or changing the parsing technique must be resolved. Each conflict is represented by two or more actions which a parser may perform at the same stage of a parsing process. A user or the parser itself decides which of these actions will be performed at parsing time. This decision can be made statically at the parser generation stage or dynamically at parsing time.\n\nIn the following sections we describe parsing techniques that can be employed for parsing formal languages, explain how conflicts occur, discuss existing conflict resolution methods, and present original conflict resolution method which is universal for all existing types of conflicts.\n\n1.1 LL parsers\n\nLL parsers are often called \"predictive\" or \"top-down\" because they start building a parse tree from its root. At each step of a parsing process an LL parser chooses a production which should be applied. The only context the parser uses in order to choose the production is \\( k \\) current symbols of an input string.\n\nAho et al. [9] describe a simple procedure which calculates for each production a set of \\( k \\) symbol strings. This set is called a Select set. At each step of the parsing process the parser chooses a production whose Select set contains a string which is equal to \\( k \\) current symbols of the input. If two or more productions have the same left-hand side and there exists a string which appears in Select sets of all these productions a conflict occurs.\n\nThe most popular approach to the conflict resolution in LL parsers is based on increasing the amount of the available context. There exist many different implementations of this approach. For example, one of conflict resolution methods in CppCC system [1] allows a number of lookahead symbols to be explicitly set for conflicting productions. SLK parser generator [6] builds parsers which in case of a conflict gradually increase a lookahead until a production that should be applied will be unequivocally determined.\n\nA more sophisticated method implemented in ANTLR [27] and CppCC [1] systems employs syntactic predicates. A syntactic predicate defines a context in which certain production should appear. The context is defined as a simplified production. When a conflict between two productions \\( P_1 \\) and \\( P_2 \\) occurs a parser attempts to parse an input according to a syntactic predicate attached to \\( P_1 \\). If the parser succeeds the conflict is resolved in favor of \\( P_1 \\) because the context in which \\( P_1 \\) appears was found. Otherwise the conflict is resolved in favor of \\( P_2 \\).\n\nExample 3. Consider the following productions which describe statements in E language:\n\n\\[\n\\text{Statement} \\rightarrow \\text{List}; \\quad (1) \\\\\n\\text{Statement} \\rightarrow \\text{List} \\text{\"=} \\text{List; } \\quad (2)\n\\]\n\nThe first production describes a list of variables. The second production describes parallel assignments: variables from the second list are assigned to variables from the first list.\n\nThe productions above contain a conflict: since both productions start identically a parser with one symbol lookahead cannot decide which one to choose. Actually this conflict cannot be resolved by a parser with any fixed lookahead because the length of the variables list is not constant.\n\n\\[2\\text{In most cases LL parsers use only one symbol of lookahead.}\\]\nThe conflict can be resolved employing a syntactic predicate that would describe the context in which the production (2) should appear. Since in case of parallel assignments a list of variables must be followed by the assignment operator the syntactic predicate may be defined as follows:\n\nList \\( \\text{\"=\"} \\)\n\nThe syntactic predicate above means that when the conflict occurs the parser will look in an input string for a list of variables followed by an assignment operator. If such a pattern will be found the production (2) will be applied, otherwise the production (1) will be chosen.\n\nOther methods of conflict resolution involve backtracking: a parser tries to apply all conflicting production one after another, the first production which leads to a parse tree without errors is chosen [6, 23]. Often conflicts are resolved in favor of the longest match and not in favor of just the first successful one [7, 27, 21]. A dangling else problem is a notorious example of a conflict which can be effectively resolved by the longest match method.\n\nRelatively small group of existing LL parser generators employs semantic information for a conflict resolution. This approach involves extracting of the meaning of the input. For example, ANTLR [27], CppCC [1] and LLGen [17] systems allow to attach a user-supplied function to conflicting productions. The resolution of the conflict depends on the value returned by this function. Assume, for example, that a conflict occurs between productions \\( P_1 \\) and \\( P_2 \\), and \\( P_1 \\) has a function attached to it. A parser will execute the function at parsing time. If the function returns true, then the conflict will be resolved in favor of \\( P_1 \\), otherwise it will be resolved in favor of \\( P_2 \\).\n\nThe most exotic conflict resolution approaches involve:\n\n- Choosing the very first conflicting production [6].\n- Finding all possible interpretations of an input [27]. All possible parse routes are proceeded in parallel. When all parse trees are constructed a user should choose from them the right one.\n- Ignoring conflicts. For example, T-Gen [16] and Oops [22] parser generators deal only with grammars which contain no conflicts.\n\nEven a superficial study of the variety of parser generators is enough to show that LL parsers are quite popular. The LL parsing method is fast and simple; it produces economical and readable parsers for small grammars. LL parsers are ideal for parsing tricky lines of input, date formats, simple nested data etc. LL parsers can also be constructed for certain programming languages such as C, ADA or PASCAL because these languages were specially designed to be easy for parsing [21]. However, LL parsers have several disadvantages which make them improper for parsing more complicated programming languages such as JAVA or C++.\n\nOne of the most annoying disadvantages of LL parsers is their inability to deal with left recursion and common prefixes in productions. As it was shown in the Example 3 productions which have common prefixes lead to conflicts. Aho et al. [10] showed a simple left factoring technique which eliminates common prefixes.\n\nLeft recursion occurs if a nonterminal symbol which appears in the left-hand side of a production is also the leftmost symbol of the right-hand side of the production.\n\nExample 4. Consider the following grammar which describes arithmetic expressions:\n\n\\[\n\\begin{align*}\n\\text{Expression} & \\rightarrow \\text{Expression \"+\" Expression}; \\quad (1) \\\\\n\\text{Expression} & \\rightarrow \\text{Expression \"-\" Expression}; \\quad (2) \\\\\n\\text{Expression} & \\rightarrow \\text{Expression \"*\" Expression}; \\quad (3) \\\\\n\\text{Expression} & \\rightarrow \\text{Number}; \\quad (4)\n\\end{align*}\n\\]\nThere is a left recursion in productions (1), (2) and (3) because the nonterminal Expression which appears in the left-hand sides of the productions is the leftmost symbol of their right-hand sides.\n\nNone of top-down parsers can deal with left recursion because it makes them enter an infinite loop while parsing an input. A well-known technique shown by Aho et al. [10] helps to eliminate left recursion by employing right recursion instead. This technique though makes the resulting productions hardly understandable. For example, the grammar from the Example 4 will be transformed into the following grammar:\n\n```\nExpression → Number A;\nA → B A;\nA → ε ;\nB → “+” Expression;\nB → “-” Expression;\nB → “*” Expression;\n```\n\nBesides of unreadability the grammar above has another problem: it does not allow to associate with operators any information about their precedence. Figure 2 shows that parse trees derived for the expressions 2+3*5 and 3*5+2 according to the grammar above are absolutely identical. It follows that though these expressions have the same meaning they will be interpreted differently. The expression 2+3*5 will be interpreted as \\((2+(3*5))\\) while the expression 3*5+2 will be interpreted as \\((3*(5+2))\\).\n\n\n\nAho et al. [10] show a technique which introduces operator precedences to an LL grammar. According to this technique operations with lower precedence are described through operations with higher precedence. For example, the grammar from the Example 2 will be modified as follows:\n\n```\nExpression → AddExpr I;\nExpression → SubExpr I;\nI → “+” AddExpr I;\nI → “-” AddExpr I;\nI → “*” AddExpr I;\n```\nThe technique described above has two significant disadvantages. Firstly, it produces unnatural and confusing grammars when the number of arithmetic operations which should be described is greater than 40 (which is the case in all modern programming languages). Secondly, resulting grammars fail to handle left associative operators. For example, the subtraction operator will be wrongly interpreted as a right associative one according to the grammar above. Figure 3 shows that the expression $6-4-1$ will be interpreted as $(6-(4-1))$.\n\n\n\nThe infamous problem of handling left associativity in LL grammars does not have any solution [10]. There exist a few techniques, however, which help to overcome this problem at the parser level: after the parser is created a user should manually extend its functionality to support left associativity.\n\nThe main problem of LL grammars that cannot be solved even manually is their weakness in terms of parsing: the group of languages that can be described by LL grammars is relatively small. There exist languages which cannot be recognized by LL parsers even if an infinite lookahead is available [10].\n\n**Example 5.** Consider the following LL grammar which describes strings consisting of $n$, $n \\geq 0$, letters $x$ followed by $n$ letters $y$. A string ends with the letter $e$ if $n$ is even. A string ends with the letter $o$ if $n$ is odd.\n\n\\[\n\\begin{align*}\nS & \\rightarrow E \\quad \"e\"; \\quad (1) \\\\\nS & \\rightarrow O \\quad \"o\"; \\quad (2) \\\\\nE & \\rightarrow \"x\" \\ O \\quad \"y\"; \\quad (3) \\\\\nE & \\rightarrow \\varepsilon; \\quad (4) \\\\\nO & \\rightarrow \"x\" \\ E \\quad \"y\"; \\quad (5)\n\\end{align*}\n\\]\nThe grammar above contains a conflict. At the very first step of a parsing process either production (1) or (2) should be chosen. Since the first symbol which will be derived from both nonterminals E and O is x the parser cannot decide which of the two productions to choose. A parser with \\(k, k > 1\\), symbols lookahead is useless in this case: for each \\(k\\) there exist an input string in which the number of symbols \\(x\\) is \\(k + 1\\).\n\nA conflict described in Example 5 occurs because LL parsers have access to few context information. The context for an LL parser is restricted to \\(k\\) lookahead symbols only. The parser must uniquely predict which production to apply basing on these lookahead symbols. The problem arises when several productions can be applied at the same time and the parser must choose one of them.\n\nThe problem of choosing the relevant production from several applicable ones would not occur if the parser could attempt to match all applicable productions at the same time and postponed making a decision until sufficient input had been seen. This is the strategy employed in LR parsers; many conflicts such as the one described in the Example 5 simply would not occur if an LR parser were used. It follows that LR parsers unlike LL ones can be employed for parsing complicated programming languages such as Java or C++.\n\n### 1.2 LR parsers\n\nLR parsers are often called \"bottom-up\" because they build a parse tree starting from its leaves. While scanning an input string an LR parser tries to find a production right-hand side that matches a part of the input which has been already seen. When the parser finds such a production it replaces this part of the input with a nonterminal on the production’s left-hand side. The parser proceeds until it the whole input string will be replaced by a start nonterminal symbol.\n\nThe process of input scanning is called **shifting**. The process of replacing of some part of an input with a nonterminal symbol is called **reducing**. These two actions are essential in LR parsing strategy; they even gave another name to LR parsers – ”shift-reduce“ parsers.\n\nLR parsers are stronger than LL parsers which were described in Section 1.1 because they use more context information. The context for an LR parser consists of all grammar productions consistent with the previously seen input and \\(k\\) symbols of lookahead\\(^3\\). An LR parser attempts to apply several productions at the same time and postpones making a decision until sufficient input has been seen.\n\nBesides the input buffer an LR parser has a stack on which it keeps a list of states it has been in. The parser also has two tables that tell to which new state the parser should shift or by which production it should reduce given the state the parser is currently in and a terminal/nonterminal symbol it has just seen in the input.\n\nThe parser may reach a configuration in which basing on the stack content and the current input token it cannot decide whether to shift or reduce. In this case a **Shift/Reduce conflict** occurs. There also may exist a configuration in which the parser may reduce by several productions. In this case a **Reduce/Reduce conflict** occurs \\(^4\\).\n\nThe most popular approach to conflict resolution implies that a user should prompt a parser in favor of which action a conflict should be resolved. One of implementations for this approach employs priorities and associativity. Simple yet powerful and elegant this method has gained a wide recognition [20, 4, 8, 30, 28, 32].\n\n---\n\n\\(^3\\)In most cases LR parsers use only one symbol of lookahead.\n\n\\(^4\\)A detailed description of conflict types is given in Section 4\nAccording to this method priority and associativity can be assigned both to tokens and productions. In most cases priority and associativity are assigned to a token explicitly while a production derives priority from the rightmost token in its right-hand side.\n\nIf a Shift/Reduce conflict occurs, priorities of the conflicting token and production are compared. If the token has a higher priority, the conflict is resolved in favor of shift. If the production has a higher priority, the conflict is resolved in favor of reduce. If priorities are equal, associativity is used: left associativity leads to choosing reduce, while right associativity leads to choosing shift.\n\nA Reduce/Reduce conflict is resolved in favor of a production with the highest priority.\n\nThis method provides a natural solution for the problem of precedence and associativity of arithmetical operators (see Section 1.1).\n\nExample 6. Consider the grammar for arithmetic expressions from the Example 4:\n\n\\[\n\\begin{align*}\n\\text{Expression} & \\rightarrow \\text{Expression} \\; \\text{\"+\"} \\; \\text{Expression}; \\quad (1) \\\\\n\\text{Expression} & \\rightarrow \\text{Expression} \\; \\text{\"-\"} \\; \\text{Expression}; \\quad (2) \\\\\n\\text{Expression} & \\rightarrow \\text{Expression} \\; \\text{\"*\"} \\; \\text{Expression}; \\quad (3) \\\\\n\\text{Expression} & \\rightarrow \\text{Number}; \\quad (4)\n\\end{align*}\n\\]\n\nThe grammar above contains a few Shift/Reduce conflicts. Consider some of these conflicts:\n\n- A conflict between a token \"+\" and a production (3) is actually a conflict between addition and multiplication operators. This conflict can be easily resolved by assigning higher priority to the token \"*\" which is associated with the multiplication operator. The production (3) will derive the priority from the token \"*\" because it is the rightmost token in the production’s right-hand side. It follows that the conflict will be resolved in favor of the reduce action: multiplication will be performed before addition.\n\n- A conflict between a token \"-\" and a production (2) is a conflict between two subtractions. This conflict can be resolved by assigning a left associativity to the token \"-\" which is associated with the subtraction operator. Since priorities of both the production (2) and the token \"-\" are equal associativity will be used for the conflict resolution. The conflict will be resolved in favor of the reduction because the token \"-\" is left associative.\n\nA slightly different method of assigning priorities implemented in SGLR system [32] employs preference attributes. A preference attribute is a prefer keyword which may follow any production. When a conflict occurs it is resolved in favor of a production to which a preference attribute is attached. In the example below the dangling else conflict is resolved so that an else branch will be associated with the innermost condition:\n\n\\[\n\\begin{align*}\n\\text{Statement} & \\rightarrow \\text{if} \\; \\text{Expression} \\; \\text{then} \\; \\text{Statement} \\; | \\\\\n& \\quad \\text{if} \\; \\text{Expression} \\; \\text{then} \\; \\text{Statement} \\; \\text{else} \\; \\text{Statement} \\; \\{\\text{prefer}\\}.\n\\end{align*}\n\\]\n\nParser generators, such as PRECC [11] and BTYACC [12] employ a backtracking approach to conflict resolution. The obvious disadvantage of this approach is that it leads to highly inefficient parsers. On the other hand backtracking allows the user to refrain from dealing with conflict resolution as such. The entire responsibility for conflict resolution is upon a parser which eventually will come up with a correct parse tree.\n\nAccording to this approach conflicts are resolved at parsing time as follows:\n\n1. When the parser enters a conflict state, it remembers the content of the stack and the current input token.\n2. The parser chooses one of the conflicting actions and continues parsing process.\n\n3. If the parser runs into an error, it backtracks to the most recent conflict point and tries a different action.\n\nThe parser tries different parse routes until it finds a successful one or there is no more routes to try.\n\nThe order of productions in a grammar are important in this method, because if a conflict occurs, a parser examines the productions in order of their appearance. Therefore by setting productions in a certain order a user actually assigns a priority to them.\n\nFor example, in order to resolve the dangling else problem the user should define the choice that contains the else branch first:\n\n\\[\n\\text{Statement} \\rightarrow \\text{if Expression then Statement else Statement} \\mid \\text{if Expression then Statement;}\n\\]\n\nWhen the conflict will occur the parser will start to examine choices from the first alternative which will lead to associating the else branch with the innermost condition.\n\nSome parser generators involve subgrammars for conflict resolution. For example, in Ana-Gram [28] a user can define a separate grammar for parsing logically independent pieces of an input such as regular expressions. Separating a grammar into several grammars constricts contexts in which productions may appear. The smaller a production context, the less likely that another production will appear in the same context which means that the number of conflicts decreases.\n\nAn interesting method of conflict resolution, proposed by Rus and Jones [29], involves analyzing of the context in which a conflict occurs.\n\nConsider a Reduce/Reduce conflict between productions \\(P_1\\) and \\(P_2\\). When the conflict occurs the parser calculates two sets of tokens for both productions. One set is called Follow and contains all tokens that may appear after the left-hand side nonterminal of a production. Another set is called Precede and contains all tokens that may appear before the left-hand side nonterminal of the production.\n\nThe parser compares the current context with those in which \\(P_1\\) and \\(P_2\\) may appear. The conflict is resolved in favor of a production whose context is equal to the current one. If a one-symbol context is not enough to resolve the conflict, the parser calculates Follow and Precede sets that contain strings which consist of two tokens and so on.\n\nA similar algorithm is used for Shift/Reduce conflicts resolution. Consider a Shift/Reduce conflict between the token \\(t\\) and the production \\(P\\). When the conflict occurs the parser calculates two Follow sets. One set contains all tokens that may appear after \\(t\\). Another set contains all tokens that may appear after the left-hand side variable of \\(P\\). The conflict is resolved by comparing the contexts of \\(t\\) and \\(P\\) with the current one.\n\nSurprisingly large number of parser generators do not employ any method of conflict resolution [28, 16, 2]. If a grammar contains conflicts a user is proposed to rewrite it. The main idea behind this approach is that it yields the highest level of confidence in the resulting parser [28]. This approach, however, has several disadvantages which were discussed in the beginning of this section.\n\nIn spite of the fact that LR parsers use much context information a considerable number of conflicts occur because a parser is not able to obtain enough context information in order to decide how to act.\n\n**Example 7.** Consider the following grammar that describes a declaration of a function in E programming language:\nEach function in E language should return a value. The nonterminal `TypeName` in productions (1) and (2) describes the type of the returned value.\n\nA function may receive parameters. If two or more parameters have the same type they can be declared in one group; in this case the type is specified only once before the names of these parameters. Parameters (or groups of parameters) should be separated from each other by commas. Here is an example of a function declaration in E:\n\n```c\nvoid foo(int a, b, short c)\n```\n\nThe grammar contains a Shift/Reduce conflict. Assume that the above string is being parsed. When the substring\n\n```c\nvoid foo(int a\n```\n\nhas been read and comma is the current input symbol a parser can perform two actions: shift and reduction by the production (5). Performing the shift action in this situation will lead to reduction by the production (7).\n\nProductions from Example 7 describe strings which represent nested repeated patterns. Identifiers separated by commas represent an inner pattern \\( R \\). Pairs \\((\\text{type name}, R)\\) also separated by commas represent an outer pattern. The only way to describe such strings is to employ a recursive technique. It follows that a parser will have to reduce each time it finds an identifier though more natural behavior in this case would be to reduce only once after the entire expression has been seen.\n\nPerforming reductions on early stages of a parsing process often leads to conflicts. In the example above the conflict would not occur if the parser could read the whole expression before reduction.\n\nThere exist a natural way to avoid early reductions which employs Extended BNF (EBNF) for productions definitions. EBNF employ regular expressions for a grammar definition which allows to describe such complicate patterns as lists in one production. Consequently, a reduction is delayed to the later stages of a parsing process.\n\n### 1.3 Employing EBNF for parsing\n\nEBNF can be considered as an extension of BNF. The very first version of BNF was created by John Backus. Shortly after it was improved by Peter Naur; this improved version was publicly used for the first time, to define ALGOL 60 [26]. Many extensions to BNF were used to define programming languages after ALGOL 60, all slightly different.\n\nIn 1977 Niklaus Wirth proposed a single formulation of BNF which employed regular expressions [35]. Later this formulation got a special name – Extended BNF (EBNF). During the last thirty years large number of EBNF versions were created. In the most general case EBNF can be viewed as any variation on the basic BNF notation with the following additional constructs:\n- Repetition operator (\\(\\ast\\) or \\(+\\))\n- Alternative operator (\\(\\mid\\)) \\(^5\\)\n\nHere is a list of main EBNF dialects:\n\n- **Wirth** According to Wirth [35] a left-hand side of a production \\(P\\) should be separated from its right-hand side by an assignment symbol (\\(=\\)); \\(P\\) should be ended with a dot. Terminal symbols should be embraced in double quotes. Terminals and nonterminals in the right-hand side of \\(P\\) should be separated by one or more spaces. Choices of an alternative should be separated by vertical bars (\\(\\mid\\)). Optional sections should be embraced in square brackets. Lists should be embraced in curly brackets. The notations for both a list whose items may appear zero or more times and a list whose items may appear one or more times are equal. Wirth proposed the following technique for describing lists of the latter type \\(^6\\):\n\n \\[\n \\text{List} = \\text{Listitem} \\{ \\text{Listitem} \\}.\n \\]\n\n Here is an example of a production written in Wirth’s EBNF dialect. The production describes the syntax of a URL:\n\n \\[\n \\text{Url} = (\"http\" | \"ftp\") \"://\" \\text{Domain} \"/\" [\"~\" \\text{UserName} \"/\" ] \\{ \\text{Field} \"/\" \\}.\n \\]\n\n- **SAIF** Spatial Archive and Interchange Format (SAIF) employs a different version of EBNF [5]. In this version a left-hand side of a production should be separated from its right-hand side by a double semicolon followed by an assignment symbol (\\(::=\\)). Nonterminal symbols should be embraced in triangular brackets while terminal symbols should be embraced in double quotes. Terminals and nonterminals in the right-hand side of \\(P\\) should be separated by one or more spaces. Notations for alternatives, optional sections and lists are identical to those in Wirth’s version.\n\n The following example shows the URL production from the previous paragraph written in SAIF dialect:\n\n \\[\n \\langle \\text{Url} \\rangle ::= (\"http\" | \"ftp\") \"://\" \\langle \\text{Domain} \\rangle \"/\" [\"~\" \\langle \\text{Name} \\rangle \"/\" ] \\{ \\langle \\text{Field} \\rangle \"/\" \\}\n \\]\n\n- **Farrel** According to Farrel [14] a left-hand side of a production should be separated from its right-hand side by a semicolon followed by a double assignment symbol (\\(::=\\)). Terminal symbols should be embraced in single quotes.\n\n There exist two notations for alternatives. The first notation is identical to the one of Wirth: choices of an alternative should be separated by vertical bars (\\(\\mid\\)). According to the second\n\n\\(^5\\)An alternative operator first was employed as a part of BNF as early as in ALGOL 60 [26]. However, in BNF the operator was employed only as a succinct notation for productions with identical left-hand sides. In EBNF this operator is also employed for defining productions whose right-hand sides contain alternatives.\n\n\\(^6\\)This example is written in Wirth’s EBNF dialect.\nnotation the entire alternative is embraced in square brackets while its choices are separated from each other by commas. The second notation is similar to the one for optional sections which also should be embraced in square brackets. Such a similarity emphasizes the fact that an optional section can be considered as an alternation with two choices. The first choice is an item of the optional section while the second one is empty.\n\nLists should be embraced in curly brackets. A star which follows a close curly bracket indicates that items of a list may appear zero or more times.\n\nThe following example shows the URL production from the previous paragraph written in Farrel dialect:\n\n```\nUrl := ['http', 'ftp'] '::' Domain ' '/' ['' UserName ' '/' ] {Field ' '/'}*\n```\n\n- **Pascal** Welsh and Elder employed an original version of EBNF for the description of **Pascal** language [34]. According to this version a right-hand side of a production should be written under its left-hand side. There is no any specific symbol which would separate these two sides from each other. Similar to SAIF dialect nonterminal symbols should be embraced in triangular brackets. However, when a nonterminal appears on a left-hand side of a production it should not be embraced in brackets. Terminal symbols may be either embraced in double quotes or written in a bold font. Notations for alternatives, optional sections and lists are identical to those in Wirth’s version.\n\nThe following example shows the URL production from the previous paragraph written in Pascal dialect:\n\n```\nUrl (http | ftp) \"::\" (Domain) \" '/' ['' UserName ' '/' ] {Field ' '/'}\"\n```\n\n- **ISO/IEC** In 1996 International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC) approved a standardized version of EBNF [3]. In this version a left-hand side of a production $P$ should be separated from its right-hand side by an assignment symbol ($=$). $P$ should be ended with a semicolon. Terminals and nonterminals in the right-hand side of $P$ should be separated by commas; ISO/IEC is the only version of EBNF in which symbols in a right-hand side of a production are explicitly separated from each other.\n\nTerminal symbols may be embraced either in single or in double quotes.\n\nNotations for alternatives and optional sections are identical to those in Wirth’s version. There exist though different notations for lists. Lists should be embraced in curly brackets. A minus symbol ($-$) which follows a close curly bracket indicates that items of a list may appear one or more times. Items which should appear in an input exactly $n$ times are prefixed by the number $n$ and a following star. For example, the following production describes a string which consists of 4 letters a.\n\n```\nA = 4\"'a\";\n```\nISO/IEC version contains a comment facility: each comment should be prefixed by a open bracket and a star (\\((\\ast)\\) and should be ended by a star and close bracket (\\(\\ast\\))).\n\nThis version also allows to define productions which specify exceptional cases. A minus symbol (\\((-)\\)) is employed for this purpose. For example the following production defines that every symbol except of a semicolon may appear as a part of a comment:\n\n\\[\n\\text{CommentChar} = \\text{Char} - \"\\;\";\n\\]\n\nThe following example shows the URL production from the previous paragraph written in ISO/IEC version of EBNF:\n\n\\[\n\\text{Url} = \\text{\"http\" } | \\text{\"ftp\" } , \\text{\";\" } , \\text{Domain} , \\text{\";\" } , \\text{[ \"~\" } , \\text{UserName} , \\text{\";\" } ] , \\text{, Field} , \\text{\";\"};\n\\]\n\n- **Jamoos** This research was carried out in the framework of the JAMOOS project which defines its own version of EBNF notation [31]. There is a direct correspondence between this notation and main principles of JAMOOS (see Section 3 for details).\n\nIn JAMOOS version a left-hand side of a production \\(P\\) should be separated from its right-hand side by an arrow (\\(\\rightarrow\\)). \\(P\\) should be ended with a semicolon. Terminal symbols may be embraced either in double or single quotes or may not be embraced by anything.\n\nA notation for optional sections is identical to the one in Wirth’s version.\n\nThere exist two different notations for alternatives. In both cases choices of an alternative should be separated by a bar (\\(|\\)). However, one of the notations allows specifying names for the choices while another does not.\n\nThe notation for lists is rather sophisticated yet handy. As in all previously discussed EBNF dialects lists should be embraced in curly brackets. In contrast to all previous EBNF versions the JAMOOS notation allows to define sequences of symbols which may appear before and after a list, and symbols which may separate items of the list [31]. One or more plus symbols (+) may follow a list. The number of pluses actually defines a number of mandatory repetitions. For example, the following production describes strings which consist of at least three letters a:\n\n\\[\n\\text{A} \\rightarrow \\{\\text{\"a\"}\\}+++;\n\\]\n\nJAMOOS version contains a comment facility; each line started by two minus symbols is considered as comment. The following example shows the URL production written in JAMOOS dialect:\n\n\\[\n\\text{Url} \\rightarrow \\text{http OF \"http\" } | \\text{ ftp OF \"ftp\" \";\" } \\text{Domain \";\" } [ \\text{ \"~\" } , \\text{UserName} \\text{ \";\" } ] , \\text{Field} \\text{ \";\" } \\ldots);\n\\]\nEBNF is not more powerful than BNF; lists, alternatives and optional sections can be expressed in plain BNF using extra productions. However, employing EBNF for a grammar definition improves its readability because EBNF allows to describe many language constructs in a more natural and succinct way.\n\nThere exist two approaches to parsing EBNF grammars:\n\n1. Conversion into equal plain BNF grammar and then employ the algorithm described by Aho et al. [9].\n2. Employ the parsing algorithm that works directly on EBNF grammars.\n\nThe first approach has several disadvantages:\n\n- Conversion into plain BNF destroys the semantic meaning of a grammar. It is a complicated task to split semantic actions among productions of a converted grammar, so that their resulting meaning will be preserved.\n- Conversion into plain BNF may lead to appearance of new conflicts (see Example 7 and Example 8).\n\nEmploying second approach helps to avoid the occurrence of some conflicts. There exist two main reasons for this phenomena. First, EBNF allows to avoid null productions which are the main source of Reduce/Reduce conflicts. Second, EBNF allows to describe in one production complicate phrases which would require several productions if plain BNF was employed. It means that parsers which work directly on EBNF often perform reductions on later stages of a parsing process. Late reductions provide more context information to a parser which helps to avoid many conflicts.\n\nExample 8. Function declarations described in Example 7 can be defined by one EBNF production as follows:\n\nFunctionDecl → TypeName Id \"(\" { (TypeName { Id \",\" ... }+) \",\" ... } \")\";\n\nAccording to the production above parameters of a function should be embraced by brackets. The parameters may appear in groups where each group is described as follows:\n\nTypeName { Id \",\" ... }+\n\nIn the production the expression above is followed by a comma embraced by quotation marks which means that the groups of parameters should be separated by commas. The dots that follows the comma mean that the groups of parameters may appear in the input several times.\n\nThe same syntax is used for description of a list of identifiers also separated by commas:\n\n{ Id \",\" ... }+\n\nThe plus sign which follows the list means that at least one identifier should appear in the list. At the same time the outer list (list of parameter groups) is not followed by pluses which means that the parameters list may be empty.\n\nThe conflict described in the Example 7 in this case does not occur, because the parser performs reduction only when the entire expression is matched.\n\n7The detailed description of such an algorithm is given in Section 2.5\nThe main drawback of late reductions is that a reduction procedure for the same production can be different depending on the input. Intuitively, employing regular expressions for description of a language $L$ implies that there can be a situation when one production may derive the same string $\\sigma, \\sigma \\in L$, differently.\n\nConsider the following production:\n\n$$A \\rightarrow a \\mid aa \\{a \\ldots\\};$$\n\nThe above production describes strings which consist of letters $a$ only. Consider the string $aaa$. Obviously, this string is derived by the production $A$; still, the alternation in the right-hand side of the productions allows two different parse trees to be obtained for the string (see Figure 4).\n\n\n\nMadsen and Kristensen [24] showed that conflicts of two new types may occur in EBNF grammars:\n\n- If a production $P$ contains a list, the number of list elements that should be popped during reduction by $P$ may be different. While performing a reduction by $P$, a parser may reach a configuration in which it must decide whether a symbol on the top of the stack is an element of the list or not. In this case we say that a Pop/Reduce conflict occurs.\n\n- If a production $P$ contains an alternative, different choices of it can be popped while reducing by $P$. While performing a reduction by $P$, a parser may reach a configuration in which two or more choices of the same alternative can be popped. In this case we say that a Pop/Pop conflict occurs.\n\nMadsen and Kristensen [24] also generalized LR parsing theory introduced by Aho et al. [9] so that it can be applied to EBNF grammars. They proofed that in addition to Shift/Reduce and Reduce/Reduce conflicts only conflicts of the two types described above may occur in EBNF grammars [24, Theorem 2].\n\nSurprisingly large number of parser generators which employ EBNF does not provide any means for resolution of Pop/Reduce and Pop/Pop conflicts explaining this by relatively rare occurrence of these conflicts [28, 16, 13]. We are aware of only two parser generators (Accent and LLGen) that do allow resolution of such conflicts.\n\nAccent parser generator allows to resolve Pop/Pop conflicts by assigning priorities to conflicting choices of an alternative [30]. Each conflicting choice can be attached a number with the help of the keyword %prio. The conflict is resolved in favor of a choice whose attached number is the biggest. Accent does not provide any means for resolution of Pop/Reduce conflicts.\n\nLLGen provides advanced method of conflict resolution which employs conflict resolvers [17]. Conflict resolver is a user-supplied routine which is called at parsing time when a conflict occurs. The resolution of the conflict depends on a boolean value which the conflict resolver returns.\nIn order to resolve a Pop/Pop conflict conflict resolvers are attached to conflicting choices of an alternation with the help of the keyword %if. When the conflict occurs the resolvers are executed in order of appearances of choices associated with them. The conflict is resolved in favor of the first choice whose resolver returns true.\n\nThe resolution of Pop/Reduce conflicts is different. The keyword %while is used to attach a conflict resolver to the element of a list. Each time the conflict occurs the conflict resolver is executed. If the resolver returns true, the symbol on the top of the stack is considered as an element of the list. If the conflict resolver returns false, the symbol on the top of the stack is not considered as an element of the list.\n\nThe method used by LLGen for conflict resolution has three significant drawbacks:\n\n- The method is inflexible. For instance, it does not offer an intuitive way for supporting different levels of precedence.\n- It is user-unfriendly. The user should be deeply involved in inner aspects of the parsing process.\n- It is inefficient. The conflicts are resolved at runtime.\n\n1.4 Contributions\n\nIt is difficult to compose an unambiguous readable grammar which would also provide a convenient framework for attaching semantic actions. The more complex a language is, the more complex is the problem of composing a grammar for this language.\n\nIn the previous sections we have shown that different parsing techniques provide different levels of assistance to a user with the problem of composing unambiguous grammars. The direct parsing of EBNF grammars discussed in Section 1.3 is the most powerful parsing method ever developed for parsing formal languages. This method minimizes the necessity for the user to redesign a grammar in order to eliminate conflicts. The less grammar redesign is needed, the more readable and intuitive the grammar remains.\n\nUnfortunately, even employing of the most powerful parsing technique does not guarantee that a grammar will contain no conflicts, these conflicts should be resolved. A large number of conflict resolution methods have been developed. Most of the methods require that the user demonstrate a deep knowledge in the parsing theory. Often the methods are also intimately connected to a particular parser generator which complicates their employment by the user who has little experience with this parser generator. A good conflict resolution method would be built-in the system; minimal involvement of the user would be suggested.\n\nIn this thesis we propose a built-in conflict resolution method that is universal for all four types of conflicts which may occur in EBNF grammars. Our method generalizes the popular approach of priorities and associativity. Here are the most important characteristics of our conflict resolution method which comprise contributions of this work:\n\n1. User-friendly interface for priorities and associativity assignment. In our method priorities can be explicitly assigned to productions and production components as well as to tokens. Priority and associativity can be assigned to a production by specifying a nonterminal symbol which appears on the left-hand side of the production (see Section 5). This mechanism is more intuitive and flexible than mechanisms which use special keywords for assigning priority, or mechanisms which derive production’s priority and associativity from those of a certain token.\nAnother mechanism of priority assignment was developed as a part of algorithm for resolution of Pop/Reduce and Pop/Pop conflicts. Such conflicts occur between production components: Pop/Reduce conflict occurs between a list and its repeated item while Pop/Pop conflict occurs between choices of an alternative. We propose two mechanisms for assigning priority to production components:\n\n(a) Assigning priorities to list and its repeated item by employing their user-defined names (see Section 5.1).\n\n(b) Assigning priorities to choices of an alternative by specifying priority groups (see Section 5.2).\n\n2. **Automatic Priority and Associativity Inference (APAI).** Often it is useful to treat a token and a production in which the token appears as a single unit that has priority and associativity. For example, a production that defines a multiplication operation and a token \")\" obviously should have equal priority and associativity. We propose the APAI method based on this interdependent relationship between a production and tokens which appears in it.\n\nAccording to APAI method a token derives priority and associativity of the production in which it appears (see Section 5.3.2). On the other hand a production derives priority and associativity of the rightmost token in its right-hand side (see Section 5.3.1). The meaning of a rightmost token in an EBNF production is not well defined because in addition to nonterminals and tokens the production may contain lists, alternations and optional sections. We give a formal definition of the rightmost token in an EBNF production and provide algorithms for its identification (Algorithms 7 and 8).\n\nThe formal description of an algorithm for APAI for tokens is presented in Algorithm 10. The formal description of an algorithm for APAI for productions is given in Algorithm 6.\n\n3. **Runtime Automatic Priority and Associativity Inference (Runtime APAI).** In many cases the same token may have different meanings. For example, in C++ language the same token \")\" is used both in multiplication operations and in pointer definitions. Obviously, in a grammar describing C++ this token appears in two different productions which means that it may infer priority and associativity differently.\n\nWe propose a dynamic method for priority and associativity inference that disambiguates priority and associativity assignment for polysemantic tokens. In order to find an actual production from which a token derives its priority and associativity a parser attempts to determine a parse route that will be chosen for a current input. For this purpose the parser increases an available amount of context information by performing one symbol lookahead during the parsing time (see Section 5.4).\n\nA set of algorithms which support Runtime APAI has been developed (see Algorithms 2, 4, 3, and 9)\n\n4. **Resolution of Pop/Reduce and Pop/Pop conflicts.** We propose a method for resolution Pop/Reduce and Pop/Pop conflicts (see Sections 6.3 and 6.4). The formal description of Pop/Reduce conflict resolution algorithm is given in Algorithm 11. The formal description of Pop/Pop conflict resolution algorithm is presented in Algorithm 12.\n\n**Outline** The following section makes some pertinent definitions. All conflict resolution techniques presented in this thesis were implemented in the framework of the JAMOOS project which\nis described in Section 3. Different conflict types are discussed in Section 4. Section 5 describes techniques for conflict resolution in EBNF grammars within the framework of JAMOOS project. Formal description of proposed conflict resolution algorithms is given in Section 6. Implementation of developed conflict resolution techniques and algorithms in JAMOOS project is discussed in Section 7. Conflict resolution techniques developed in this work were tested while generating parsers for JAMOOS and JAVA programming language; obtained conflicts and their resolution are subject of Section 8. Finally, Section 9 gives brief conclusions.\n\n2 Preliminaries and Definitions\n\nA discussion on the conflict resolution implies understanding of the most basic concepts of the compilation theory. In this section terms of the compilation theory necessary for the further discussion will be presented.\n\nThe concept of the conflict resolution is inseparable from the one of a grammar which is subject of the Section 2.1. All conflicts which will be discussed in this work will be illustrated by two or more possible parse trees. The concept of parse trees is based on the concept of a derivation. Definitions of a derivation and a parse tree are presented in Section 2.2 and Section 2.3 accordingly.\n\nA resolution of conflicts takes place at a stage of a compilation process called parsing. Conflict resolution algorithms presented in this thesis will be described in terms of LR parsing. These algorithms, however, can be easily adapted to the LL parsing method. An explanation of the LR parsing process essentials is given in Section 2.4.\n\nA special parsing algorithm for direct parsing of EBNF grammars is discussed in Section 2.5.\n\n2.1 Grammars\n\nA context free grammar (CFG) is an inductive definition of a formal language.\n\nDefinition 9 (CFG). A Context-Free Grammar (CFG) is a 4-tuple $G = (N, \\Sigma, P, S)$ where\n\n- $N$ is a finite set of nonterminal symbols.\n- $\\Sigma$ is a finite set of terminal symbols, disjoint from $N$.\n- $P$ is a finite set of productions. Each production has the form $A \\rightarrow \\alpha$, where $A \\in N$ and $\\alpha \\in (N \\cup \\Sigma)^*$. \n- $S$ is a distinguished symbol in $N$ called the start symbol.\n\nEach production $A \\rightarrow \\alpha$ consists of two parts: $A$ is called left-hand side of the production and $\\alpha$ is called right-hand side of the production. A production is called an epsilon production if its right-hand side is empty. An epsilon production is denoted as follows:\n\n$$A \\rightarrow \\varepsilon$$\n\nAn extended context free grammar (ECFG) is CFG in which the right-hand sides of the productions may contain regular expressions, i.e., repetition operators ($*$ or $+$) and alternative operator ($|$) may be used to express the right-hand side of the productions.\n\nHere is a formal definition of regular expressions.\n\n\\[8\\text{In some sources a production with an empty right-hand side is called a lambda production.}\\]\nDefinition 10 (Regular expressions). Let \\{, \\}, *, +, | be symbols not in \\(\\mathcal{N} \\cup \\Sigma\\). The set of regular expressions over \\(\\mathcal{N} \\cup \\Sigma\\), denoted \\(\\text{RE}(\\mathcal{N} \\cup \\Sigma)\\) is defined as follows:\n\n- If \\(\\alpha \\in (\\mathcal{N} \\cup \\Sigma)\\), then \\(\\alpha \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\).\n- If \\(\\alpha, \\beta \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\), then \\(\\alpha \\beta \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\).\n- If \\(\\alpha \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\), then \\(\\{\\alpha\\}^* \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\).\n- If \\(\\alpha \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\), then \\(\\{\\alpha\\}^+ \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\).\n- If \\(\\omega_1, \\omega_2, \\ldots, \\omega_n \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\), then \\(\\{\\omega_1 | \\omega_2 | \\ldots | \\omega_n\\} \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\).\n- \\(\\epsilon \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\).\n- \\(\\emptyset \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\).\n\nThe expression \\(\\{\\alpha\\}^*\\) means that \\(\\alpha\\) can be repeated zero or more times, while the expression \\(\\{\\alpha\\}^+\\) means that \\(\\alpha\\) can be repeated one or more times. The expression \\(\\{\\omega_1 | \\omega_2 | \\ldots | \\omega_n\\}\\) means precisely one of \\(\\omega_1, \\omega_2, \\ldots, \\omega_n\\). The symbol \\(\\epsilon\\) denotes the set \\(\\{\\epsilon\\}\\) consisting of the empty string and the symbol \\(\\emptyset\\) denotes empty set.\n\nDefinition 11 (ECFG). An extended context free grammar (ECFG) is a 4-tuple \\(G = (\\mathcal{N}, \\Sigma, \\mathcal{P}, S)\\) where\n\n- \\(\\mathcal{N}\\) is a finite set of nonterminal symbols.\n- \\(\\Sigma\\) is a finite set of terminal symbols, disjoint from \\(\\mathcal{N}\\).\n- \\(\\mathcal{P}\\) is a finite set of productions. Each production has the form \\(A \\rightarrow \\alpha\\), where \\(A \\in \\mathcal{N}\\) and \\(\\alpha \\in \\text{RE}(\\mathcal{N} \\cup \\Sigma)\\).\n- \\(S\\) is a distinguished symbol in \\(\\mathcal{N}\\) called the start symbol.\n\n2.2 Derivation\n\nEvery string of a formal language can be generated employing the set of productions of a CFG that defines that language. A string can be generated by replacing left-hand sides of productions with their right-hand sides. This process is called derivation.\n\nThe symbol \\(\\Rightarrow\\) is used to denote a derivation. The expression \\(\\alpha \\Rightarrow \\beta\\) means that \\(\\alpha\\) derives \\(\\beta\\) in one step. If a derivation is performed in several steps, the symbol \\(\\Rightarrow\\) is used to denote such a derivation. The expression \\(\\alpha \\Rightarrow \\beta\\) means that \\(\\alpha\\) derives \\(\\beta\\) in zero or more steps.\n\nFor example, consider the following grammar for arithmetic expressions, with the nonterminal \\(E\\) representing an expression:\n\n\\[\nE \\rightarrow E + E \\mid E * E \\mid (E) \\mid \\text{id}\n\\]\n\nString \\((\\text{id} + \\text{id}) * \\text{id}\\) can be derived as follows:\n\n\\[\nE \\Rightarrow E * E \\Rightarrow E * \\text{id} \\Rightarrow (E) * \\text{id} \\Rightarrow (E + E) * \\text{id} \\Rightarrow (E + \\text{id}) * \\text{id} \\Rightarrow (\\text{id} + \\text{id}) * \\text{id}\n\\]\nIn a leftmost derivation, the leftmost nonterminal is replaced at each step. In a rightmost derivation, the rightmost nonterminal is replaced at each step. The derivation of the example above is a rightmost derivation.\n\nA non-terminal $A$ is called nullable if $A \\xrightarrow{\\epsilon} \\epsilon$.\n\nThe derivation process is different for ECFG: not only nonterminal symbols can be replaced at each derivation step, but also regular expressions can be replaced by corresponding strings [24].\n\nExample 12. Consider the following grammar that describes a variables definition section in a PASCAL-like language.\n\n$$\\text{VarDef} \\rightarrow \\{ \\text{Type} \\{ \\text{VarName} \\}^* ; \\}^*$$\n\n$$\\text{Type} \\rightarrow \\text{int} \\mid \\text{char}$$\n\n$$\\text{VarName} \\rightarrow \\text{id}$$\n\nConsider the following statements which define three variables. Two of the variables are of the integer type while the third one is of the character type.\n\n```plaintext\nint a b;\nchar c;\n```\n\nHere is the derivation that corresponds to the above statements:\n\n```\nVarDef \\Rightarrow \\{ \\text{Type} \\{ \\text{VarName} \\}^* ; \\}^* \n \\Rightarrow \\text{Type} \\{ \\text{VarName} \\}^* ; \\text{Type} \\{ \\text{VarName} \\}^* ;\n \\Rightarrow \\text{Type} \\{ \\text{VarName} \\}^* ; \\text{Type} \\text{VarName} ;\n \\Rightarrow \\text{Type} \\{ \\text{VarName} \\}^* ; \\text{Type} \\text{id} ;\n \\Rightarrow \\text{Type} \\{ \\text{VarName} \\}^* ; \\text{CHAR} \\text{id} ;\n \\Rightarrow \\text{Type} \\text{VarName} \\text{VarName} ; \\text{CHAR} \\text{id} ;\n \\Rightarrow \\text{Type} \\text{VarName} \\text{id} ; \\text{CHAR} \\text{id} ;\n \\Rightarrow \\text{Type} \\text{id} \\text{id} ; \\text{CHAR} \\text{id} ;\n \\Rightarrow \\text{INT} \\text{id} \\text{id} ; \\text{CHAR} \\text{id} ;\n```\n\n2.3 Parse Trees\n\nA parse tree is an alternative method to show the derivation process for some input.\n\nGiven a context free grammar $G = (N, \\Sigma, P, S)$, a parse tree is a tree with the following properties:\n\n- The root is labeled by $S$.\n- Each leaf is labeled by a token $t \\in (\\Sigma \\cup \\epsilon)$.\n- Each interior node is labeled by a nonterminal $A \\in N$. \n\n23\nConsider an interior node labeled by $A$, where $A \\in \\mathcal{N}$. Consider also $n$ nodes labeled by $A_1, A_2, \\ldots, A_n$, where $A_1 \\in (\\Sigma \\cup \\mathcal{N}), A_2 \\in (\\Sigma \\cup \\mathcal{N}), \\ldots, A_n \\in (\\Sigma \\cup \\mathcal{N})$. If $A_1, A_2, \\ldots, A_n$ are children of $A$ (from left to right) then $A \\rightarrow A_1 A_2 \\cdots A_n$ is a production from $\\mathcal{P}$.\n\n**Example 13.** Consider the following grammar:\n\n$$E \\rightarrow E + E \\mid E * E \\mid (E) \\mid id$$\n\nThe parsing tree for the input $(id + id)*id$ is shown in Figure 5:\n\n\n\nA parse tree $T$, which is built according to ECFG, will look different: since productions in ECFG may contain regular expressions in their right-hand sides, interior nodes of $T$ may be labeled by regular expressions.\n\n**Example 14.** Consider the following grammar:\n\n$$\\begin{align*}\n\\text{VarDef} &\\rightarrow \\{ \\text{Type} \\{ \\text{VarName} \\}^* ; \\}^* \\\\\n\\text{Type} &\\rightarrow \\{ \\text{INT} \\mid \\text{CHAR} \\} \\\\\n\\text{VarName} &\\rightarrow \\text{id}\n\\end{align*}$$\n\nThe parsing tree for the input $\\text{INT a b;}$ is shown in Figure 6:\n\n\n\n2.4 LR Parsing\n\nParsing is a process of determining whether a string of tokens can be derived from the start symbol of a grammar. A technique that is called LR parsing is used to parse context-free grammars; “L” stands for left-to-right scanning of the input, “R” for constructing rightmost derivation.\nThe main idea behind the concept of parsing is that a language $L$ described by a context free grammar $G$ can be represented as a finite set of its possible configurations. The configurations are called states and built on the basis of productions in $G$.\n\n**Example 15.** Consider a language $L$ that consists of the string $a \\ b$ only. Here is a grammar $G$ which describes $L$:\n\n$$S \\rightarrow a \\ b$$\n\nThe following three states can be built on the basis of $G$:\n\n1. $S \\rightarrow \\bullet \\ a \\ b$\n Nothing has been read yet, the symbol $a$ is expected.\n\n2. $S \\rightarrow a \\bullet \\ b$\n The symbol $a$ has been read, the symbol $b$ is expected.\n\n3. $S \\rightarrow a \\ b \\bullet$\n The string $a \\ b$ has been read.\n\nThe dot symbol ($\\bullet$) indicates the part of a string that has been already read. The dot also indicates a token of $L$ which will appear next.\n\nThe states obtained from the grammar $G$ can be organized in a directed graph. Nodes of the graph are the states, while edges are legal transitions between states. Each edge is labeled with a token or a variable of $G$. An edge labeled $x$ goes from state $s_1$ to $s_2$ if $s_1$ contains a production with a dot before $x$ and $s_2$ contains a production with a dot after $x$. This transition describes a basic step of parsing: in state $s_1$ the element $x$ has not been yet read but has been expected, while in state $s_2$ the element $x$ has already been read.\n\nTo summarize the above, the parsing process is travelling over the graph of states while keeping the travelling history: storing all the nodes visited and all the labels on the transition edges. When the parsing process eventually enters a state in which the dot is located after the end of the production (i.e. $A \\rightarrow \\alpha \\bullet$) the right-hand expression $\\alpha$ should be flushed off the parsing history and the left-hand variable $A$ should be stored instead. The action of replacing the right-hand expression $\\alpha$ with the left-hand variable $A$ is called reduction by production $A \\rightarrow \\alpha$.\n\nAfter reading the entire input the parsing history will contain only the start symbol of the grammar. In this case we say that the parsing process has been successfully finished: the parsed phrase $\\phi$ belongs to the language $L$. However, if on a certain stage of the parsing process the current state is not connected to any other state by an edge labeled with the currently seen input token, the failure of parsing the input is reported.\n\nThe LR parser consists of:\n\n- Stack\n- Parsing table\n- Parsing algorithm\n2.4.1 Actions\n\nThe following actions may be performed during the parsing process:\n\n- **Accept.** The parsing process succeeded. An input string is empty and the parser stack contains only one symbol, i.e., the start symbol.\n- **Error.** No valid state transition exists for the current input token.\n- **Shift.** Push the next input symbol to the parser stack.\n- **Reduce.** The top of the parser stack holds the right-hand side of a production. The parser pops it off the stack and pushes the left-hand side of the production to the stack.\n\n2.4.2 Stack\n\nThe stack stores pairs of the following form: (grammar symbol, state). A grammar symbol represents terminal or nonterminal symbol of the grammar. A state summarizes the information contained in the stack below it. The combination of the state number on the top of the stack and the current input symbol is used to index the parsing table and determine the action that should be performed.\n\n2.4.3 Parsing Table\n\nA parsing table has two parts: *action table* and *goto table*.\n\nThe *action table* is a table with rows indexed by parsing states and columns indexed by terminal symbols. For each parser state \\( s \\) and for each terminal symbol \\( t \\) the action table determines the action that should be applied if \\( t \\) is the current terminal symbol of the input string while the parser is in the state \\( s \\).\n\nThe *goto table* is a table with rows indexed by parser states and columns indexed by nonterminal symbols. For each parser state \\( s \\) and for each nonterminal symbol \\( A \\) goto table determines the state number to which the parser should transit if reduction to \\( A \\) was performed in the state \\( s \\).\n\nThe process of building the parsing table (see [9]) consists of two stages:\n\n1. Creating the set of LR-items and grouping them into the parser states.\n2. Constructing action and goto tables on the basis of the parser states.\n\nAn LR-item of a grammar \\( G \\) is a production of \\( G \\) with a LR-marker (dot) at some position of the right side. LR-marker indicates how much of a production has been already parsed. For example, production \\( A \\rightarrow BD \\) yields the three LR-items:\n\n\\[\nA \\rightarrow \\bullet BD \\\\\nA \\rightarrow B \\bullet D \\\\\nA \\rightarrow BD\\bullet\n\\]\n\nThe first item indicates that a string derivable from \\( BD \\) is expected to appear next in the input. The second item indicates that a string derivable from \\( B \\) has been already parsed and a string derivable from \\( D \\) is expected to appear next in the input.\n2.5 The Algorithm for LR-parsing Extended Context Free Grammars\n\nLR-parsing algorithm for CFG [9] is based on the fact that the right-hand side of a production has fixed length and content. Here are two main characteristics of this algorithm:\n\n1. Number of parser states is always finite.\n The number of productions in a grammar is finite. Since the right-hand side of a production \\( P \\) has fixed length, the number of possible LR-items yielded by \\( P \\) is finite. Therefore the number of all LR-item combinations is also finite. From these LR-item combinations only those which are legal input configurations are parser states.\n\n2. Reduction procedure always is fixed sequence of pops.\n Consider a production \\( A \\to \\alpha \\). Since \\( \\alpha \\) has fixed content, the procedure of reduction by \\( A \\) is fixed: pop from the stack all symbols in \\( \\alpha \\) in the reversed order.\n\nIn contrast to CFG right-hand side of a production in ECFG may have:\n\n- Variable length, if list is used.\n- Variable content, if alternation or optional section are used.\n\nThe algorithm for parsing CFG fails to parse ECFG because of the following reasons:\n\n1. Number of parser states may be infinite.\n\n2. Reduction procedure for the same production may be different.\n\nMadsen and Kristensen [24] showed how the algorithm for parsing CFG can be modified to work directly on ECFG. The essential changes are:\n\n1. New rules for moving the LR-marker through a regular expression for the purpose of computing LR-items.\n\n2. Parsing algorithm is extended to work on tables constructed from the new type of LR-items.\n The difference is that new algorithm does not know the length of the right-hand side of an applied production.\n\nThe LR-items are constructed as usual [9] employing the following additional rules:\n\n1. Any LR-item of the form\n \\[ A \\to \\alpha \\bullet \\{ \\beta \\}^* \\gamma \\]\n is replaced by\n \\[ A \\to \\alpha \\# \\{ \\beta \\}^* \\gamma \\]\n \\[ A \\to \\alpha \\{ \\bullet \\beta \\}^* \\gamma \\]\n \\[ A \\to \\alpha \\{ \\beta \\}^* \\bullet \\gamma \\]\n\n2. Any LR-item of the form\n \\[ A \\to \\alpha \\{ \\beta \\bullet \\}^* \\gamma \\]\n is replaced by...\n3. Any LR-item of the form\n \\[ A \\to \\alpha \\{ \\beta \\}^+ \\gamma \\]\nis replaced by\n \\[ A \\to \\alpha \\{ \\beta \\}^\\# + \\gamma \\]\n \\[ A \\to \\alpha \\{ \\bullet \\beta \\}^+ + \\gamma \\]\n\n4. Any LR-item of the form\n \\[ A \\to \\alpha \\{ \\beta \\bullet \\}^+ \\gamma \\]\nis replaced by\n \\[ A \\to \\alpha \\{ \\beta \\}^\\# + \\gamma \\]\n \\[ A \\to \\alpha \\{ \\bullet \\beta \\}^+ + \\gamma \\]\n\n5. Any LR-item of the form\n \\[ A \\to \\alpha \\bullet \\{ \\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\omega_n \\} \\beta \\]\nis replaced by\n \\[ A \\to \\alpha \\{ \\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\cdot \\omega_i \\mid \\ldots \\mid \\omega_n \\} \\beta \\]\n for \\( i = 1, 2, \\ldots, n \\).\n\n6. Any LR-item of the form\n \\[ A \\to \\alpha \\{ \\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\cdot \\omega_i \\bullet \\mid \\ldots \\mid \\omega_n \\} \\beta \\]\nis replaced by\n \\[ A \\to \\alpha \\{ \\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\omega_i \\cdot \\mid \\ldots \\mid \\omega_n \\} \\beta \\]\n \\[ A \\to \\alpha \\{ \\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\omega_n \\} \\bullet \\beta \\]\n\nThe idea behind the rules is to keep track of which productions are applicable at a given point in the input string, in the manner consistent with the meanings of regular expressions. New symbol \\# indicates what is the current content of the stack. If this symbol appears at the end of a repeated pattern (when * or + operators are used) it means that the pattern is now on the top of the stack and it should be popped. Accordingly, if the symbol appears after some alternative (when | operator is used) it is the sign that this alternative should be popped now. On the contrary, if this symbol appears before a repeated pattern it means that there is no such pattern on the stack.\n\nAn LR-item that contains symbol \\# is called reduce item.\n\nThe parsing algorithm is alike the common algorithm [9] except when a reduction is applied.\n\nAssume that the production \\( A \\to \\alpha \\) is applied. Right-hand side of the production can be split into \\( \\alpha_1, \\alpha_2, \\ldots, \\alpha_n \\) (\\( n \\geq 1 \\)) such that \\( \\alpha = \\alpha_1 \\alpha_2 \\ldots \\alpha_n \\) and each \\( \\alpha_i \\) has the form:\n1. $\\alpha_i \\in (N \\cup \\Sigma)^*$.\n2. $\\alpha_i = \\{\\beta\\}^*$ for some $\\beta$.\n3. $\\alpha_i = \\{\\beta\\}^+$ for some $\\beta$.\n4. $\\alpha_i = \\{\\omega_1 | \\omega_2 | \\ldots | \\omega_m\\}$ for some $\\omega_j$ ($j = 1, 2, \\ldots, m$).\n\nThe reduction can be split into popping first $|\\alpha_n|$ symbols, then $|\\alpha_{n-1}|$ symbols etc., and finally $|\\alpha_1|$ symbols. If $\\alpha_i$ represents regular expression (the last three forms of $\\alpha_i$) similar splitting have to be done since $\\alpha_i$ may contain nested regular expressions.\n\nThe formal description of the reduce function is presented in Algorithm 1.\n\n3 JAMOOS\n\nJAMOOS is object oriented language for grammars [31]. JAMOOS exploits the correspondence between grammar productions and object oriented classes. The main principle of this correspondence is that a grammar production also defines a class. The left-hand side of the production declares the name of the class, and the right-hand side defines the structure of the class. A production of the form $A \\rightarrow B \\mid C$ defines an inheritance relationship between classes. A production of the form $X \\rightarrow BC$ defines an aggregation relationship between classes.\n\nJAMOOS receives an EBNF grammar $G$ that describes a language $L$ and creates for it an object oriented parser. Terminal symbols of $G$ are called tokens. Non-terminal symbols of $G$ are called variables.\n\nThe object oriented parser consists of two parts:\n\n- **Set of classes.** For each production in $G$ JAMOOS defines a corresponding class.\n- **Parser.** The parser identifies grammatical phrases of $L$ in the input stream. For each phrase $\\phi$ there is a corresponding production $P_\\phi$ in $G$. Each time the parser identifies $\\phi$ it creates an object of a class that corresponds to $P_\\phi$.\n\nA parse tree produced by the object oriented parser can be viewed from grammatical and object oriented points of view. From the grammatical point of view the parse tree is an hierarchical tree that shows the parsing process (see Section 2.3). From the object oriented point of view the parse tree is an object with a recursive structure. This object corresponds to the root of the tree, and all the nested objects correspond to its subtrees.\n\nFigure 7 shows the processes of generation and execution of the object oriented parser.\n\n3.1 Extended BNF in JAMOOS\n\nThere exist two approaches to parsing EBNF grammars:\n\n1. Conversion into equal plain BNF grammar and then employ the algorithm described by Aho et al. [9].\n2. Employ the parsing algorithm that works directly on EBNF grammars.\n\nThe first approach has several disadvantages:\nAlgorithm 1 Reduce function of the parsing algorithm that works directly on ECFG. The algorithm does not examine the case when right-hand site of an applied production contains regular expression of the form: \\(\\{\\alpha\\}^+\\). Such regular expressions should be treated in exactly the same manner as regular expressions of the form: \\(\\{\\alpha\\}\\).\n\n**Input:** \\(\\alpha\\) – a string of terminal symbols, nonterminal symbols and regular expressions\n\n**Procedure Reduce**\n\n1. Split \\(\\alpha\\) into \\(\\alpha_1, \\alpha_2, \\ldots, \\alpha_n\\)\n2. for \\(i = n, \\ldots, 1\\) do\n3. \\(\\varphi = \\alpha_1 \\ldots \\alpha_{i-1}\\)\n4. \\(\\psi = \\alpha_{i+1} \\ldots \\alpha_n\\)\n5. if \\(\\alpha_i \\in (N \\cup \\Sigma)^*\\) then\n6. Pop \\(|\\alpha_i|\\) symbols from the stack\n7. else\n8. if \\(\\alpha_i = \\{\\beta\\}^*\\) then\n9. repeat\n10. \\(s \\leftarrow \\text{Stack.top.state} \\quad \\text{// Parser state whose number is on the top of the stack}\\)\n11. if \\(s\\) contains both items \\(A \\rightarrow \\varphi \\{\\beta\\}^* \\psi\\) and \\(A \\rightarrow \\varphi \\{\\beta\\} \\psi\\) then\n12. Report conflict\n13. Exit\n14. end if\n15. if \\(s\\) contains item \\(A \\rightarrow \\varphi \\{\\beta\\}^* \\psi\\) then\n16. Reduce (\\(\\beta\\))\n17. end if\n18. until \\(s\\) contains item \\(A \\rightarrow \\varphi \\{\\beta\\} \\psi\\)\n19. else // \\(\\alpha_i = \\{\\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\omega_m\\}\\)\n20. \\(s \\leftarrow \\text{Stack.top.state}\\)\n21. if \\(s\\) contains both items \\(A \\rightarrow \\varphi \\{\\omega_1 \\mid \\ldots \\mid \\omega_j \\} \\psi\\) and \\(A \\rightarrow \\varphi \\{\\omega_j \\mid \\ldots \\mid \\omega_m\\} \\psi\\), \\(j \\neq s\\) then\n22. Report conflict\n23. Exit\n24. end if\n25. if \\(s\\) contains item \\(A \\rightarrow \\varphi \\{\\omega_1 \\mid \\ldots \\mid \\omega_j \\} \\psi\\) then\n26. Reduce (\\(\\omega_j\\))\n27. end if\n28. end if\n29. end if\n• Conversion into plain BNF destroys all the semantic meaning of the grammar, i.e., classes and fields defined by the JAMOOS productions. It is a complicated task to redefine all the classes according to the converted grammar, so that their resulting meaning will be preserved.\n\n• Conversion into plain BNF may lead to appearance of new conflicts (see Example 7 and Example 8).\n\nJAMOOS uses the second approach for parsing EBNF grammars. It implements the algorithm developed by Madsen and Kristensen [24] (Section 2.5 provides a detailed discussion on the algorithm).\n\n3.2 Production Types\n\nThere are two types of productions common and ignore. Common productions represent productions of EBNF grammar. Ignore productions describe elements such as blanks, tabulations, newlines and comments that should be ignored by a parser.\n\nCommon productions are divided into inheritance and composition productions. Inheritance productions define inheritance: classes, defined by the non-terminals in the right-hand side of a production $P$, inherit from the class, defined by the non-terminal in the left-hand side of $P$. For example, the following production:\n\n\\[\n\\text{Expression} \\rightarrow \\text{AddExpr} \\mid \\text{MultExpr} \\mid \\text{Number};\n\\]\n\ndefines four classes: Expression, AddExpr, MultExpr and Number, where the last three classes inherit from the class Expression.\n\nComposition productions define classes. Right-hand side of a composition production consist of JAMOOS language components. Each JAMOOS language component defines a field in the class described by the production. Further we will refer to JAMOOS language component simply as component.\n\nDefinition 16 (Component). Component is defined as follows:\n\n- If $a$ is a token, then $a$ is a component.\n• If \\( a \\) is a variable, then \\( a \\) is a component.\n\n• If \\( a_1, a_2, \\ldots, a_n \\) are components, then \\( a_1 a_2 \\ldots a_n \\) is a component.\n\n• If \\( a, a_1, a_S \\) and \\( a_T \\) are components, then \\( \\{ a \\ \\backslash \\ a \\ a_S \\ldots a_T \\}^+ \\) is a component.\n\nIn this component \\( a_1, a_S \\) and \\( a_T \\) may be omitted. By \\( ^+ \\) we represent a sequence of symbols + that may have arbitrary length.\n\n• If \\( a \\) is a component, then \\([ a ]\\) is a component.\n\n• If \\( a_1, a_2, \\ldots, a_n \\) are components and \\( x_1, x_2, \\ldots, x_n \\) are strings,\nthen \\( x_1 \\ OF \\ a_1 \\ OF \\ a_2 \\ldots \\ OF \\ a_n \\) is a component.\n\nThe component \\( a_1 a_2 \\ldots a_n \\) is called a sequence component.\n\nThe component \\( \\{ a \\ \\backslash \\ a \\ a_S \\ldots a_T \\}^+ \\) is called list component. It means that the \\( a \\) component is repeated as many times as the symbol + appears in +. The component \\( a \\) is called repeated item of the list. Repeated items may be separated by the component \\( a_S \\). The component \\( a_T \\) may appear before the sequence of repeated items. The component \\( a_T \\) may appear before the sequence of repeated items. Here is an example of a production that contains a list:\n\n\\[\n\\text{VarDecl} \\rightarrow \\{\\text{Type}\\} \\backslash \\text{VarName} \\ldots ;\\}^+;\n\\]\n\nThe component \\([ a ]\\) is called optional section. It means that the component \\( a \\) may appear zero or one time. Here is an example of a production that contains an optional section:\n\n\\[\n\\text{ConditionalStmt} \\rightarrow \\text{if} \\ \\text{Expression} \\ \\text{then} \\ \\text{Stmt} \\ [\\text{else} \\ \\text{Stmt}];\n\\]\n\nThe component \\( x_1 \\ OF \\ a_1 \\ OF \\ a_2 \\ldots \\ OF \\ a_n \\) is called alternation. It means that only one component \\( a_i \\), \\( i = 1, \\ldots, n \\), can appear. The component \\( a_i \\), \\( i = 1, \\ldots, n \\), is called choice. Each choice \\( a_i \\), \\( i = 1, \\ldots, n \\), has a name \\( x_i \\). Here is an example of a production that contains an alternation:\n\n\\[\n\\text{Operator} \\rightarrow \\text{plus} \\ OF \\ \\text{“+”} \\ | \\ \\text{mult} \\ OF \\ \\text{“*”};\n\\]\n\nComponents may be given names. If a component has a name the corresponding class field has the same name. A component and its name are separated by semicolon. For example:\n\n\\[\n\\text{Program} \\rightarrow \\text{“Program”} \\ progName:Id \\ \\text{body}:\\text{\\{}\\text{Statement “;”} \\ldots \\}^+ \\ “End”;\n\\]\n\nIn the example above:\n\n• The component \\( \\text{Id} \\) has a name \\( \\text{progName} \\)\n\n• The list \\( \\{\\text{Statement “;”} \\ldots \\}^+ \\) has a name \\( \\text{body} \\)\n\n• The component \\( \\text{Statement} \\) has no name.\n4 Types of Conflicts\n\nThe common parsing algorithm [9] is based on the fact that the right-hand side of a production has fixed length and content. This fact gives a possibility to build a set of parser states; each parser state unequivocally defines a part of a production that:\n\n- has been already seen\n- is expected to appear next in the input\n\nIf a production $P$ contains a regular expression $E_R$, the exact length (if $E_R$ is a list) or content (if $E_R$ is an alternative) of the right-hand side of $P$ is not known. The algorithm for parsing EBNF grammars [24] uses special hints that help to parse regular expressions. Such hints are represented as reduce items in parser states (see 2.5).\n\nWhile parsing a list a parser has to decide when the list ends. Consider the following production:\n\n$$ A \\rightarrow \\{ \\alpha \\}^* $$\n\nThe production above yields two reduce items with different meanings:\n\n- $A \\rightarrow \\{ \\alpha \\# \\}^*$\n This reduce item hints to the parser that the current symbol in the stack is the element of the list.\n- $A \\rightarrow \\# \\{ \\alpha \\}^*$\n This reduce item hints to the parser that the current symbol in the stack is not the element of the list.\n\n**Definition 17 (Conflicting list reduce items).** Reduce items $r_1$, $r_2$ are called conflicting list reduce items if the following conditions are hold:\n\n1. Both $r_1$ and $r_2$ are yielded by the same production $P$.\n2. The right-hand side of $P$ has the form $\\alpha \\{ \\beta \\}^* \\gamma$ or $\\alpha \\{ \\beta \\}^+ \\gamma$.\n3. $r_1$ has the form $\\alpha \\# \\{ \\beta \\}^* \\gamma$.\n4. $r_2$ has the form $\\alpha \\{ \\beta \\# \\}^* \\gamma$.\n\nWhile parsing an alternative a parser has to decide which choice should be popped. Consider the following production:\n\n$$ A \\rightarrow \\alpha | \\beta $$\n\nThe production above yields two reduce items with different meanings:\n\n- $A \\rightarrow \\alpha \\# | \\beta$\n This reduce item hints to the parser that the choice $\\alpha$ should be popped from the stack.\n- $A \\rightarrow \\alpha | \\beta \\#$\n This reduce item hints to the parser that the choice $\\beta$ should be popped from the stack.\n\n**Definition 18 (Conflicting alternative reduce items).** Reduce items $r_1$, $r_2$ are called conflicting alternative reduce items if the following conditions are hold:\n1. Both $r_1$ and $r_2$ are yielded by the same production $P$.\n\n2. The right-hand side of $P$ has the form $\\alpha\\{\\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\omega_n\\}\\beta$.\n\n3. $r_1$ has the form $\\alpha\\{\\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\omega_i\\# \\mid \\ldots \\mid \\omega_n\\}\\beta$, $i = 1, 2, \\ldots, n$.\n\n4. $r_2$ has the form $\\alpha\\{\\omega_1 \\mid \\omega_2 \\mid \\ldots \\mid \\omega_j\\# \\mid \\ldots \\mid \\omega_n\\}\\beta$, $j = 1, 2, \\ldots, n$ and $j \\neq i$.\n\nWe say that ECFG contains conflicts if the LR parser that was build for the grammar contains conflict states.\n\n**Definition 19 (Conflict state).** A parser state $s$ of a parser that works directly on ECFG is called conflict state if at least one of the following conditions holds:\n\n- Multiple actions are defined for $s$ and a terminal symbol in the action table of the parser.\n- $s$ contains conflicting list reduce items.\n- $s$ contains conflicting alternative reduce items.\n\nThere exist four types of conflicts. Two of them, Reduce/Reduce and Shift/Reduce, occur between several actions. Another two types of conflicts, Pop/Reduce and Pop/Pop, differ from the two previous types: they occur if there exist more than one possibility to execute a reduction.\n\n### 4.1 Reduce/Reduce Conflicts\n\nReduce/Reduce conflicts occur in a conflict state for which two or more reduce actions are defined. In other words, this conflict occurs if there are two or more productions that can be applied to the same input string. For example, consider the following grammar $G_{Friends}$:\n\n- $Friends \\rightarrow \\text{boys OF (BoyName and \"John\") | girls OF (GirlName and \"Jane\")}$;\n- $BoyName \\rightarrow \"Alex\"$;\n- $GirlName \\rightarrow \"Alex\"$;\n\nConsider an input *Alex and John*. The string *Alex* can be reduced to both *BoyName* and *GirlName* productions. Figure 8 shows two possible parse trees which can be produced.\n\n**Figure 8:** Reduce/Reduce conflict which occurs in the grammar $G_{Friends}$\n4.2 Shift/Reduce Conflicts\n\nShift/Reduce conflicts occur in a conflict state for which both shift and reduce actions are defined. In other words, this conflict occurs if the content of the stack matches right-hand side of a production (the reduce action can be performed) and at the same time it is also legitimate to shift the current token, because this would lead to a reduction by another production.\n\nFor example, consider the following grammar $G_{E_{xpr}}$ for arithmetical expressions:\n\n\\[\nE_{xpr} \\rightarrow A_{ddexpr} \\mid M_{ultexpr} \\mid N_{umber};\n\\]\n\\[\nA_{ddexpr} \\rightarrow E_{xpr} \\ast E_{xpr} ;\n\\]\n\\[\nM_{ultexpr} \\rightarrow E_{xpr} \\ast E_{xpr} ;\n\\]\n\\[\nN_{umber} \\rightarrow \\{[1-9][0-9]*\\};\n\\]\n\nThe grammar $G_{E_{xpr}}$ contains several Shift/Reduce conflicts. One of them is between the token + and the production $M_{ultexpr}$.\n\nConsider the input $2 \\ast 6 + 3$. When the substring $2 \\ast 6$ has been already seen and the token + is the current input token, both shift and reduce actions can be performed. The corresponding parse trees are shown in Figure 9:\n\n\n\n4.3 Pop/Reduce Conflicts\n\nPop/Reduce conflicts occur in a conflict state that contains conflicting list reduce items.\n\nConsider a production $P$ which contains a list $l$ in its right-hand side. While parsing the same input there may exist two or more ways to reduce by $P$ so that the content of $l$ would be different after each reduction. In this case we say that Pop/Reduce conflict occurs.\n\nFor example, this conflict occurs in the following grammar which describes strings that consist of the symbols $a$ only:\n\n\\[\nA \\rightarrow \\{ “a” \\} \\{ “a” \\ldots \\};\n\\]\nConsider an input that consists of two symbols \\( a \\). The parser for the grammar above will read the input, put both symbols to the stack and start to reduce by \\( A \\). The reduction by \\( A \\) is performed in two stages: first, all elements of the list should be popped from the stack, second, the element of the optional section should be popped.\n\nConsider the first reduction stage. Since the optional section contains only one element, the second symbol \\( a \\) in the input obviously is the part of the list, so, the parser will pop it from the stack. Then the parser should decide whether the remaining symbol \\( a \\) is an element of the list or an element of the optional section.\n\nIn the first case the parser will pop the symbol \\( a \\) from the stack. At this point of the parsing process the stack will be empty. This will cause the parser to finish the first reduction stage and to start the second one.\\(^9\\) When the reduction will be finished, the list will contain two elements and the optional section will be empty.\n\nIn the second case the parser will assume that all list elements have already been popped and will start the second reduction stage. When the reduction will be finished, the list will contain one element and the optional section will contain an element.\n\nFigure 10 shows two possible parsing trees which can be produced for the input \\( aa \\).\n\n![Figure 10: Pop/Reduce conflict which occurs in production \\( A \\rightarrow [\\{a\\} \\{a\\}]; \\)](image)\n\n### 4.4 Pop/Pop Conflicts\n\nPop/Pop conflicts occur in a conflict state that contains conflicting alternative reduce items.\n\nConsider a production \\( P \\) which contains an alternative in its right-hand side. While parsing the same input there may exist two or more ways to reduce by \\( P \\) so that different choice will be made at each reduction. In this case we say that Pop/Pop conflict occurs.\n\nFor example, this conflict occurs in the following grammar \\( G_A \\):\n\n\\[\nA \\rightarrow \\text{alt1:}(c1 \\text{ OF } “a” \\mid c2 \\text{ OF } “ab”) \\\\\n\\text{alt2:}(c3 \\text{ OF } “bc” \\mid c4 \\text{ OF } “c”);\n\\]\n\nConsider the input \\( abc \\). The parser for \\( G_A \\) will read the three tokens of the input, push them to the stack and start to reduce by \\( A \\). The reduction by \\( A \\) is performed in two stages: first, the alternative \\text{alt1} should be reduced, second, the alternative \\text{alt2} should be reduced. At the first stage either choice “bc” or “c” should be popped from the stack. At the second stage either choice “a” or “ab” should be popped from the stack.\n\n\\(^9\\)In this case nothing will be done at the second reduction stage. Since the stack is empty, the optional section will also be considered empty.\nConsider the first reduction stage. Both choices “bc” and “c” are legitimate. If the parser pops choice “bc” then the choice “a” should be popped at the second reduction stage. If the parser pops choice “c” then the choice “ab” should be popped at the second reduction stage.\n\nFigure 11 shows two possible parsing trees which can be produced for the input abc.\n\n\n\n5 JAMOOS Extension for Priorities and Associativity\n\nThe Shift/Reduce, Reduce/Reduce, Pop/Reduce and Pop/Pop conflicts are resolved employing priorities and associativity. JAMOOS allows to assign priority and associativity to both tokens and non-terminal symbols. By assigning priority and associativity to a nonterminal symbol, these priority and associativity are assigned to the production which has the nonterminal symbol on its left-hand side.\n\nJAMOOS allows to assign priority to components. This can be done by assigning priority to the name of a component. Consider the following production:\n\n```\nVarDeclaration → Type var_list:{ var_name:Var ... }+;\n```\n\nThere are three components in the production above:\n\n1. Variable `Type`. This component is unnamed.\n2. List `{ var_name:Var ... }+`. The name of this component is `var_list`.\n3. Variable `Var`. This component is the repeated item of the list `{ var_name:Var ... }+`. The name of this component is `var_name`.\n\nBy assigning priority to the name `var_list`, the priority is assigned to the list. By assigning priority to the name `var_name`, the priority is assigned to the element of the list.\n\nPriorities and associativity in JAMOOS can be assigned in the priorities section (see Sec. 5.1). JAMOOS also provides additional method of priority assigning: locally in connection to a specific production (see Sec. 5.2).\n\n5.1 Priorities Section\n\nIn the priorities section groups of tokens, nonterminal symbols and component names are declared in a certain order, so that a group has lower priority than the priority of the groups declared afterwards. Within each group, the tokens, nonterminal symbols and component names have the same priority.\nFor each group of tokens, nonterminal symbols and component names the associativity of its elements should be defined. The associativity can be declared employing keywords \\texttt{LEFT} or \\texttt{RIGHT}.\n\nComponent names do not have associativity. Although a component name appears in a group with a certain associativity, this associativity is not assigned to the component name.\n\nThere are two methods of assigning priority to a component name:\n\n- **Specifying simple name.** Consider a component name \\texttt{id}_1 that appears in only one production. A priority can be assigned to \\texttt{id}_1 just by declaring \\texttt{id}_1 in the priorities section.\n\n- **Specifying qualified name.** Consider a component name \\texttt{id}_2 that appears in the right-hand sides of the productions \\( A \\rightarrow \\alpha \\) and \\( B \\rightarrow \\beta \\). Assume that a priority should be assigned to the component \\texttt{id}_2 which appears in the production \\( A \\rightarrow \\alpha \\). The priority can be assigned by specifying in the priorities section a qualified component name which includes the variable \\( A \\) and the component name \\texttt{id}_2 separated by dot.\n\nBelow is a JAMOOS definitions that describes the syntax of the priorities section:\n\n```plaintext\nPrioritiesSection \\rightarrow\n{ \"PRIORITIES\" /\n { left of \"LEFT\" | right of \"RIGHT\"\n { token of Token | NT_symbol of Name | qualified_name of (Name \".\" Id) ... }+ }\n ... \"END\" }+ ;\nToken \\rightarrow strng OF StringExp | keyword OF Keyword | regexp OF RegExpression;\nStringExp \\rightarrow ⟨(\"([\"\\\"].\")(\"[^\\\"].\")\")|(\"([\"\\\"].\")(\"[^\\\"].\")\")⟩;\n-- A string surrounded by quotation marks \" or '\nKeyword \\rightarrow ⟨[a-z][a-zA-Z0-9]*⟩;\n-- A string started from the small letter\nRegExpression \\rightarrow PARSE(\"<\",RegularExpression(),\">\");\n-- Regular expressions are described in the special grammar\nName \\rightarrow ⟨[A-Z][a-zA-Z0-9]*⟩;\n-- A string started from the capital letter\n```\n\n**Example 20 (Declaring priorities and associativity in priorities section).** Consider the following JAMOOS program which describes arithmetical expressions:\n\n```plaintext\nGRAMMAR Expression()\nPRIORITIES\nLEFT \"+\" AddExpr.exp2\nLEFT MultExpr\nRIGHT num\nEND -- Priorities Section\nExpression \\rightarrow AddExpr | MultExpr | Number;\n```\n\n38\nAddExpr → exp1:Expression “+” exp2:Expression;\nMultExpr → exp1:Expression “*” exp2:Expression;\nNumber → num:([1-9][0-9]*);\n\nEND -- Program\n\nFrom the declaration of the priorities section in this program it follows that:\n\n1. Priorities of the token “+” and the component exp2, which appears in the production AddExpr, are equal.\n2. The priority of the token “+” is lower than the one of the variable MultExpr.\n3. The priority of the component exp2, which appears in the production AddExpr, is lower than the one of the variable MultExpr.\n4. The priority of the variable MultExpr is lower than the one of the component num which appears in the production Number.\n5. Both token “+” and variable MultExpr are left-associative.\n\n5.2 Local Priority Assignment\n\nIn JAMOOS the alternation operator (\\(|\\)) is used in two cases:\n\n1. Declaration of classes that inherit from another class. For example, consider the following production:\n\n Expression → MultExpr | AddExpr;\n\n This production defines three classes: Expression, MultExpr and AddExpr. Both classes MultExpr and AddExpr inherit from the class Expression.\n\n2. Specifying choices in an alternative section. For example:\n\n Expression → mult OF MultExpr | add OF AddExpr;\n\n This production does not define an inheritance. It defines a class Expression with only one field which has a variable content. Depending on input the content can be either MultExpr or AddExpr.\n\n In both cases a priority order can be defined among the choices. This can be done by using the double vertical bar separator (\\(\\|\\)). The bar divides the choices into groups. The priority of all choices in a group \\(x\\) is higher than the one of choices in a group to the right of \\(x\\). Within a group all choices have equal priority.\n\nExample 21 (Local declaration of priorities). Consider the following productions:\n\n Expression → MultExpr | DivExpr || AddExpr | SubExpr || AssignExpr; \\hspace{1cm} (1)\n Operator → mult OF “*” | div OF “/” || add OF “+” | sub OF “-” || assign OF “=”; \\hspace{1cm} (2)\nIn both production priorities are assigned locally. In the production (1) priorities are assigned to the non-terminals, whereas in the production (2) priorities are assigned to the choices of the alternative section.\n\nAccording to the priority assignment in the production (1):\n\n1. Non-terminals MultExpr and DivExpr have equal priority.\n2. Non-terminals AddExpr and SubExpr have equal priority.\n3. The priority of non-terminals MultExpr and DivExpr is higher than the one of non-terminals AddExpr and SubExpr.\n4. The priority of non-terminals AddExpr and SubExpr is higher than the one of the non-terminal AssignExpr.\n\nAccording to the priority assignment in the production (2):\n\n1. The choices mult and div have equal priorities.\n2. The choices add and sub have equal priorities.\n3. The priority of the choices mult and div is higher than the one of the choices add and sub.\n4. The priority of the choices add and sub is higher than the one of the choice assign.\n\n5.3 Problems with Priorities in JAMOOS\n\n5.3.1 Assigning Priority and Associativity to a Production\n\nIn JAMOOS there are two methods for assigning priority and associativity to a production:\n\n1. Explicitly, by assigning a priority and associativity to a nonterminal symbol which represents the left-hand side of the production.\n2. Implicitly, basing on the priority and associativity of a rightmost terminal symbol in the right-hand side of the production.\n\nExample 22 (Explicit assignment of priorities and associativity to a production). Consider the following grammar for arithmetical expressions:\n\nExpression → AddExpr | MultExpr | Number; (1)\nAddExpr → Expression “+” Expression; (2)\nMultExpr → Expression “*” Expression; (3)\nNumber → ⟨[0-9]∗⟩; (4)\n\nAssume that we want to declare the production (2) as left-associative and to assign it a priority that is lower than the priority of the production (3).\n\nSuch assignment can be made explicitly as follows:\n\nPRIORITIES\n LEFT AddExpr\n LEFT MultExpr\nEND\n\nThe nonterminal AddExpr is declared before the nonterminal MultExpr, therefore the production (2) has a lower priority than the production (3).\nExample 23 (Implicit assignment of priorities and associativity to a production). Consider the grammar from the Example 22 and consider that the following declaration takes place:\n\n```\nPRIORITIES\n LEFT \"+\"\n LEFT MultExpr\nEND\n```\n\nHere the production (2) derives its priority and associativity from its rightmost token “+”. The production (2) has lower priority than the production (3), because the token “+” was declared earlier than the nonterminal MultExpr in the PRIORITIES section.\n\n5.3.2 Assigning Priority and Associativity to a Token\n\nIn JAMOOS there are two methods for assigning priority and associativity to a token:\n\n1. Explicit declaration.\n2. Implicitly, basing on the priority and associativity of a nonterminal symbol which represents the left-hand side of a production that contains the token.\n\nIn the Example 23 token “+” is explicitly declared as left-associative and its priority is lower than the priority of the production (3).\n\nIn the Example 22 token “*” derives its priority and associativity from the production:\n\n```\nMultExpr → Expression \"*\" Expression;\n```\n\n5.3.3 Statement of Context-Dependent Priority Problem\n\nConsider the grammar from the Example 22. The token “+” appears only in the production:\n\n```\nAddExpr → Expression \"+\" Expression;\n```\n\ntherefore by assigning a priority to the production we unequivocally assign this priority to the token.\n\nA problem arises when there is more than one production that contains a token. In this case a parser has to determine the production from which the token derives its priority at a given stage of the parsing process. We call this problem Context-Dependent Priority Problem.\n\nExample 24 (Context-Dependent Priority Problem). Consider the following grammar for arithmetical expressions.\n\n```\nExpression → AddExpr | MultExpr | IncExpr | Number; (1)\nAddExpr → Expression \"+\" Expression; (2)\nMultExpr → Expression \"*\" Expression; (3)\nIncExpr → Expression \"+\" \"+\"; (4)\nNumber → ⟨[1-9][0-9]*)⟩; (5)\n```\nThe Shift/Reduce conflict occurs between reduction by the production (3) and shift of the token +. The conflict can be resolved by assigning priorities to the production (3) and to the token +. Assume that the priorities were assigned as follows:\n\nPRIORITIES\n\n| LEFT | AddExpr |\n| LEFT | MultExpr |\n| LEFT | IncExpr |\n\nDepending on the input, the token + may derive its priority from the production (2) or from the production (4). In the first case the conflict is resolved by choosing reduce by MultExpr. In the second case the conflict is resolved by choosing shift action.\n\nFor example, consider the expression 2 * 3 + +. When the substring 2 * 3 has already been parsed and the token + appears next in the input, the parser has to decide which action to perform. The decision depends on the priority of the token +. The parser has to recognize that in the current situation the token derives its priority from the production IncExpr, therefore its priority is higher than the priority of MultExpr, and to perform the shift action.\n\nConsider another input: 2 * 3 + 5. In this case the parser must recognize that the token + derives its priority from the production AddExpr. Since the priority of this production is lower than the one of the production MultExpr, the conflict should be resolved by choosing reduce.\n\nThe solution of the Context-Dependent Priority Problem is described in Section 5.4.\n\n5.3.4 Statement of Ambiguous Assignment Problem\n\nThe Ambiguous Assignment Problem occurs when different methods are combined while assigning priority/associativity to a production or a token.\n\nExample 25 (Ambiguous Assignment Problem). Consider the following JAMOOS code:\n\n```\nPRIORITIES\n RIGHT \"+\n LEFT AddExpr\nEND\n\nExpression → AddExpr | MultExpr | Number;\nAddExpr → Expression \"+\" Expression;\n```\n\nHere the token “+” was explicitly declared as right-associative. Implicitly the token derives its associativity from the production:\n\n```\nAddExpr → Expression \"+\" Expression;\n```\n\nand the production was declared as left-associative. Also the priority of the token is not well defined.\n\nThe solution of the Ambiguous Assignment Problem is described in Section 5.5.\n5.4 Solution for Context-Dependent Priority Problem\n\nAssume that the parser is currently at a state $s$ and a Shift/Reduce conflict occurs in this state: the reduce by the production $P$ may be performed and, at the same time, it is legitimate to shift the current input symbol $t$. The parser state $s$ contains a set of LR-items. The token $t$ may derive its priority only from productions which yielded LR-items with the dot directly before $t$.\n\nExample 26. Consider the following grammar $G_{Expr}$ for arithmetical expressions:\n\n$$\n\\begin{align*}\n\\text{Expression} & \\rightarrow \\text{AddExpr} \\mid \\text{AssignExpr} \\mid \\text{CompoundAssign} \\mid \\text{Var}; \\quad (1) \\\\\n\\text{AddExpr} & \\rightarrow \\text{Expression}^{+}\\text{Expression}; \\quad (2) \\\\\n\\text{AssignExpr} & \\rightarrow \\text{Expression}^{=}\\text{Expression}; \\quad (3) \\\\\n\\text{CompoundAssign} & \\rightarrow \\text{Expression}^{+^{=}}\\text{Expression}; \\quad (4) \\\\\n\\text{Var} & \\rightarrow \\langle[a-z]\\rangle; \\quad (5)\n\\end{align*}\n$$\n\nThe grammar $G_{Expr}$ contains several Shift/Reduce conflicts. One of them is between the token $=$ and the production (2). The corresponding conflict state looks like follows:\n\n$$\n\\begin{align*}\n\\text{AddExpr} & \\rightarrow \\text{Expression}^{+}\\text{Expression}; \\quad \\bullet \\quad (a) \\\\\n\\text{AddExpr} & \\rightarrow \\text{Expression}^{=^{=}}\\text{Expression}; \\quad (b) \\\\\n\\text{AssignExpr} & \\rightarrow \\text{Expression}^{=}\\text{Expression}; \\quad (c) \\\\\n\\text{CompoundAssign} & \\rightarrow \\text{Expression}^{+^{=}}\\text{Expression}; \\quad (d)\n\\end{align*}\n$$\n\nThe token $=$ appears in both (c) and (d) LR-items. However, the token derives its priority from the production (3), because the only LR-item with the dot directly before $=$ is (c) and the item was yielded by the production (3).\n\nLet us define $P_t(s)$ as the set of all productions which yielded LR-items in $s$ with the dot directly before $t$. Assume that priorities are defined for all productions in $P_t(s)$. Otherwise implicit priority and associativity assignment to $t$ is impossible, the conflict will be resolved by default.\n\nHaving $P_t(s)$ the conflict can be easily resolved if priority of each production in $P_t(s)$ is higher than the priority of $P$. In this case it is not important to exactly determine the production from which $t$ derives its priority. The priority of $t$ will be higher than the priority of $P$, so, the conflict should be resolved by choosing the shift. Accordingly, if priority of each production in $P_t(s)$ is lower than the priority of $P$, the conflict should be resolved by choosing the reduce. If each production in $P_t(s)$ has a priority that equals to the priority of $P$, the associativity should be used to resolve the conflict.\n\nIf $P_t(s)$ contains productions with priority that is higher than the priority of $P$ as well as productions with lower or equal priority, it is necessary to exactly determine the production from which $t$ derives its priority. Such a production cannot be determined at compile-time. The selection of the production depends on the given input: the fact that in $s$ several LR-items with dot before $t$ exist implies that parsing process can go over different routes depending on the input. JAMOOS uses Runtime Automatic Priority and Associativity Inference (Runtime APAI) to find a production from which $t$ derives its priority and associativity.\n\nRuntime APAI is actually performed in two steps:\n\n1. **Compile-time.** Productions in $P_t(s)$ are divided into two groups $P_{Shift}$ and $P_{Reduce}$. If priority of a production $P'$, $P' \\in P_t(s)$, is higher than priority of $P$, then $P'$ is putted to $P_{Shift}$. If priority of a production $P'$, $P' \\in P_t(s)$, is lower than priority of $P$, then $P'$ is putted to $P_{Reduce}$. If both productions $P'$, $P' \\in P_t(s)$, and $P$ have equal priorities associativity is used. If $P'$ is left-associative it is putted to $P_{Reduce}$, otherwise $P'$ is putted to $P_{Shift}$.\n\n<table>\n<thead>\n<tr>\n<th>Production</th>\n<th>Action</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$P_{Shift}$</td>\n<td>Putted</td>\n</tr>\n<tr>\n<td>$P_{Reduce}$</td>\n<td>Putted</td>\n</tr>\n</tbody>\n</table>\n\n2. **Runtime APAI.** The tokens in $s$ are processed one by one. For each token $t$ the priority of each production in $P_t(s)$ is determined and the production is chosen.\n\nThe corresponding conflict state looks like follows:\n\n$$\n\\begin{align*}\n\\text{AddExpr} & \\rightarrow \\text{Expression}^{+}\\text{Expression}; \\quad \\bullet \\quad (a) \\\\\n\\text{AddExpr} & \\rightarrow \\text{Expression}^{=^{=}}\\text{Expression}; \\quad (b) \\\\\n\\text{AssignExpr} & \\rightarrow \\text{Expression}^{=}\\text{Expression}; \\quad (c) \\\\\n\\text{CompoundAssign} & \\rightarrow \\text{Expression}^{+^{=}}\\text{Expression}; \\quad (d)\n\\end{align*}\n$$\n\nThe token $=$ appears in both (c) and (d) LR-items. However, the token derives its priority from the production (3), because the only LR-item with the dot directly before $=$ is (c) and the item was yielded by the production (3).\n\nLet us define $P_t(s)$ as the set of all productions which yielded LR-items in $s$ with the dot directly before $t$. Assume that priorities are defined for all productions in $P_t(s)$. Otherwise implicit priority and associativity assignment to $t$ is impossible, the conflict will be resolved by default.\n\nHaving $P_t(s)$ the conflict can be easily resolved if priority of each production in $P_t(s)$ is higher than the priority of $P$. In this case it is not important to exactly determine the production from which $t$ derives its priority. The priority of $t$ will be higher than the priority of $P$, so, the conflict should be resolved by choosing the shift. Accordingly, if priority of each production in $P_t(s)$ is lower than the priority of $P$, the conflict should be resolved by choosing the reduce. If each production in $P_t(s)$ has a priority that equals to the priority of $P$, the associativity should be used to resolve the conflict.\n\nIf $P_t(s)$ contains productions with priority that is higher than the priority of $P$ as well as productions with lower or equal priority, it is necessary to exactly determine the production from which $t$ derives its priority. Such a production cannot be determined at compile-time. The selection of the production depends on the given input: the fact that in $s$ several LR-items with dot before $t$ exist implies that parsing process can go over different routes depending on the input. JAMOOS uses Runtime Automatic Priority and Associativity Inference (Runtime APAI) to find a production from which $t$ derives its priority and associativity.\n\nRuntime APAI is actually performed in two steps:\n\n1. **Compile-time.** Productions in $P_t(s)$ are divided into two groups $P_{Shift}$ and $P_{Reduce}$. If priority of a production $P'$, $P' \\in P_t(s)$, is higher than priority of $P$, then $P'$ is putted to $P_{Shift}$. If priority of a production $P'$, $P' \\in P_t(s)$, is lower than priority of $P$, then $P'$ is putted to $P_{Reduce}$. If both productions $P'$, $P' \\in P_t(s)$, and $P$ have equal priorities associativity is used. If $P'$ is left-associative it is putted to $P_{Reduce}$, otherwise $P'$ is putted to $P_{Shift}$.\nThe formal description of the algorithm for division of $P_t(s)$ into groups $P_{Shift}$ and $P_{Shift}$ is presented in Algorithm 2.\n\nHaving two production groups $P_{Shift}$ and $P_{Reduce}$ JAMOOS forms two sets of tokens $T_{Shift}$ and $T_{Reduce}$. The set $T_{Shift}$ contains tokens that may be derived immediately after $t$ by productions from $P_{Shift}$. The set $T_{Reduce}$ contains tokens that may be derived immediately after $t$ by productions from $P_{Reduce}$.\n\nDefinition 27 (FOLLOW(A,t)). Let $A$ be a nonterminal symbol, $t$ be a terminal symbol. Assume that there exists production $A \\rightarrow \\alpha$ such, that $\\alpha$ contains $t$. FOLLOW(A,t) is the set of terminal symbols that can appear immediately to the right of $t$.\n\nIt follows that:\n\n$$T_{Shift} = \\bigcup_{p_i \\in P_{Shift}} \\text{FOLLOW}(p_i, t)$$ \\hspace{1cm} (1)\n\n$$T_{Reduce} = \\bigcup_{p_i \\in P_{Reduce}} \\text{FOLLOW}(p_i, t)$$ \\hspace{1cm} (2)\n\nThe formal description of the algorithm for computing FOLLOW(A,t) set is presented in Algorithm 3.\n\nThe same token $t'$ may appear in both $T_{Shift}$ and $T_{Reduce}$ sets, which means that one-symbol lookahead is not enough to exactly determine the applied production. In this case the preference is given to productions from the $P_{Shift}$ group. The token $t'$, when it will appear next to $t$ in the input, will be considered as indication that a production from $P_{Shift}$ is applied and the conflict will be resolved in favor of shift.\n\nThe formal description of the algorithm for calculating the $T_{Shift}$ and $T_{Reduce}$ token sets is presented in Algorithm 4.\n\nWhen the sets $T_{Shift}$ and $T_{Reduce}$ are formed, a parser can be created. The parser stores the Shift/Reduce conflict and both token sets which are associated with the conflict.\n\n2. **Runtime.** When the Shift/Reduce conflict occurs, the parser performs one-symbol lookahead. Assume that a token $t'$ appears next to $t$ in the input. If $t' \\in T_{Shift}$ the token $t$ derives its priority and associativity from a production in $P_{Shift}$, which means that the conflict should be resolved in favor of shift. If $t' \\in T_{Reduce}$ the token $t$ derives its priority and associativity from a production in $P_{Reduce}$, which means that the conflict should be resolved in favor of reduce.\nAlgorithm 2: Given a Shift/Reduce conflict $C$ between a production $P$ and a token $t$. Implicit priority and associativity assignment is required for resolution of $C$. The token $t$ may derive priority and associativity from several productions which form group $\\mathcal{P}$. Depending on a production from which $t$ derives priority and associativity $C$ can be resolved differently. This function divides $\\mathcal{P}$ into groups $P_{\\text{Shift}}$ and $P_{\\text{Reduce}}$. If $t$ derives priority and associativity from a production from $P_{\\text{Shift}}$ group, $C$ is resolved in favor of Shift. If $t$ derives priority and associativity from a production from $P_{\\text{Reduce}}$ group, $C$ is resolved in favor of Reduce.\n\n**Input:** $\\mathcal{P}$ – set of productions from which the token $t$ may derive priority and associativity. Each production in the set has priority $\\pi$ and associativity $\\rho$; \n$\\pi_P$ – priority of a production $P$\n\n**Output:** $P_{\\text{Shift}}$ and $P_{\\text{Reduce}}$\n\n**Function FormShiftReduceProductionGroups**\n\n1: $n \\leftarrow$ size of $\\mathcal{P}$\n2: for $p_i \\in \\mathcal{P}$, $i = 1, \\ldots, n$ do\n3: if $p_i.\\pi > \\pi_P$ then\n4: Add $p_i$ to $P_{\\text{Shift}}$\n5: end if\n6: if $p_i.\\pi < \\pi_P$ then\n7: Add $p_i$ to $P_{\\text{Reduce}}$\n8: end if\n9: if $p_i.\\pi == \\pi_P$ then\n10: if $p_i.\\rho$ is LEFT then\n11: Add $p_i$ to $P_{\\text{Reduce}}$\n12: else\n13: Add $p_i$ to $P_{\\text{Shift}}$\n14: end if\n15: end if\n16: end for\n17: return $P_{\\text{Shift}}$ and $P_{\\text{Reduce}}$\n5.5 Solution for Ambiguous Assignment Problem\n\nJAMOOS does not assure that priority/associativity which was assigned to a token or nonterminal explicitly is equal to the priority/associativity which was derived implicitly. The user is expected to bear the responsibility for unambiguous assignment of priority/associativity.\n\nAssume that Ambiguous Assignment Problem arises for a token/nonterminal \\( x \\). If \\( x \\) is involved in a conflict, JAMOOS will use for the conflict resolution the priority/associativity that was assigned to \\( x \\) explicitly.\n\n**Example 28.** Consider the following JAMOOS code:\n\n```\nPRIORITIES\n LEFT AddExpr\n LEFT “+”\nEND\nExpression → AddExpr | MultExpr | Number; (1)\nAddExpr → Expression “+” Expression; (2)\nMultExpr → Expression “*” Expression; (3)\nNumber → ⟨[0-9]*⟩; (4)\n```\n\nThe Shift/Reduce conflict occurs between the token “+” and the production (2). To resolve the conflict JAMOOS will compare priorities of the token and the production.\n\nHere it is desirable to implicitly assign the priority to the production. In this case priorities of the token and the production would be equal. It means that associativity would be used for the conflict resolution and since “+” is left-associative, the reduce would be chosen.\n\n**Algorithm 3** The recursive function calculates \\( FOLLOW(A,t) \\) set. The function uses \\( FIRST \\) and \\( FOLLOW \\) functions described in Aho et al. [9].\n\n**Input:** \\( A \\to \\alpha \\) – a production;\n\\( t \\) – a token which is contained in the right-hand side of the production \\( A \\to \\alpha \\)\n\n**Output:** \\( \\Sigma_t \\) – set of tokens that may be derived by the production \\( A \\) immediately after \\( t \\)\n\n**Function Follow**\n1. Split \\( \\alpha \\) into three parts so that \\( \\alpha \\equiv \\alpha_1 t \\alpha_2 \\)\n2. if \\( \\alpha_2 \\) has the form \\( t’ \\beta \\), where \\( t’ \\) is a token then\n3. Add \\( t’ \\) to \\( \\Sigma_t \\)\n4. end if\n5. if \\( \\alpha_2 \\) has the form \\( B \\beta \\), where \\( B \\) is a non-terminal symbol then\n6. Add \\( FIRST(B) \\) to \\( \\Sigma_t \\)\n7. if \\( B \\) is nullable then\n8. \\( \\Sigma’ \\leftarrow Follow(A \\to \\alpha_1 t \\beta, t) \\)\n9. Add \\( \\Sigma’ \\) to \\( \\Sigma_t \\)\n10. end if\n11. end if\n12. if \\( \\alpha_2 \\) is empty then\n13. // \\( t \\) is the last symbol in the right-hand side of \\( A \\)\n14. Add \\( FOLLOW(A) \\) to \\( \\Sigma_t \\)\n15. end if\n16. return \\( \\Sigma_t \\)\nAlgorithm 4 Given a Shift/Reduce conflict $C$ between a production $P$ and a token $t$. Implicit priority and associativity assignment to $t$ is required for resolution of $C$. The token $t$ may derive priority and associativity from several productions. These productions are divided into two groups $P_{Shift}$ and $P_{Reduce}$. If $t$ derived priority and associativity from a production which belong to $P_{Shift}$, $C$ should be resolved in favor of shift. If $t$ derived priority and associativity from a production which belong to $P_{Reduce}$, $C$ should be resolved in favor of reduce. In order to determine the actual production from which $t$ must derive priority and associativity a parser performs one-symbol lookahead at parsing time. This function calculates two groups of tokens $T_{Shift}$ and $T_{Reduce}$ that may appear after $t$ in the input. A token from the group $T_{Shift}$ that appears after $t$ indicates that $t$ must derive priority and associativity from a production from $P_{Shift}$ group. A token from the group $T_{Reduce}$ that appears after $t$ indicates that $t$ must derive priority and associativity from a production from $P_{Reduce}$ group. This function calls Follow function for calculating the set of tokens that may appear after $t$. The Follow function is described in Algorithm 3.\n\nInput: $t$ – a token;\n$P_{Shift}$ – a set of productions. If $t$ derives priority and associativity from a production from this set, the conflict is resolved in favor of shift;\n$P_{Reduce}$ – a set of productions. If $t$ derives priority and associativity from a production from this set, the conflict is resolved in favor of reduce\n\nOutput: $T_{Shift}$ – set of tokens. If a token from this set appears in the input next to $t$, the conflict should be resolved in favor of shift;\n$T_{Reduce}$ – set of tokens. If a token from this set appears in the input next to $t$, the conflict should be resolved in favor of reduce\n\nFunction FormTokenSets\n1: $n \\leftarrow$ size of $P_{Shift}$\n2: for $p_i \\in P_{Shift}, \\; i = 1, \\ldots, n$ do\n3: \\hspace{1em} $\\Sigma_t \\leftarrow \\text{Follow}(p_i, t)$\n4: \\hspace{1em} Add $\\Sigma_t$ to $T_{Shift}$\n5: end for\n6: $n \\leftarrow$ size of $P_{Reduce}$\n7: for $p_i \\in P_{Reduce}, \\; i = 1, \\ldots, n$ do\n8: \\hspace{1em} $\\Sigma_t \\leftarrow \\text{Follow}(p_i, t)$\n9: \\hspace{1em} Add $\\Sigma_t$ to $T_{Reduce}$\n10: end for\n11: // Tokens that appear both in $T_{Shift}$ and $T_{Reduce}$ groups are deleted from $T_{Reduce}$ group\n12: $T_{Reduce} \\leftarrow T_{Reduce} \\setminus (T_{Shift} \\cap T_{Reduce})$\n13: return $T_{Shift}$ and $T_{Reduce}$\nHowever, Ambiguous Assignment Problem arises for the nonterminal AddExpr, therefore explicit assignments will be used. Basing on explicit assignments, the priority of the token is higher than the priority of the production. The conflict will be resolved by choosing shift.\n\n6 Algorithms Developed for Conflict Resolution\n\n6.1 Resolution of Reduce/Reduce Conflicts\n\nConsider a Reduce/Reduce conflict $C$ that occurs between $n$ productions $P_1, P_2, \\ldots, P_n$. This conflict will be resolved in favor of the production $P_i, i = 1, \\ldots, n$ with the highest priority.\n\nIf more than one conflicting production have the highest priority, default resolution is performed. By default, $C$ is resolved in favor of a production whose left-hand side variable is the first in alphabetical order.\n\nIf priority is not assigned to a production $P_i, i = 1, \\ldots, n$ explicitly in the priorities section, JAMOOS attempts to assign the priority implicitly basing on the priority of the rightmost token in the right-hand side of $P_i$ (see Section 5.3.1). If JAMOOS also fails to assign the priority implicitly, it resolves $C$ by default.\n\nThe formal description of the Reduce/Reduce conflict resolution algorithm is presented in Algorithm 5.\n\n6.2 Resolution of Shift/Reduce Conflicts\n\nConsider a Shift/Reduce conflict $C$ between a token $t$ and a production $P$. Actually a Shift/Reduce conflict may occur between a token $t$ and a set of productions $P$. This kind of conflict can be reduced to $C$ by resolving the Reduce/Reduce conflict between the productions in $P$.\n\nAssume that $P$ has priority $\\pi_P$ and $t$ has priority $\\pi_t$. If $\\pi_t$ is higher than $\\pi_P$ the shift action should be performed. If $\\pi_t$ is lower than $\\pi_P$ the reduce action should be performed.\n\nIf $\\pi_t$ is equal to $\\pi_P$ then associativity should be used\\(^{10}\\). If $t$ is left associative the reduce action should be performed. If $t$ is right associative the shift action should be performed.\n\nIf JAMOOS fails to determine $\\pi_P$ or $\\pi_t$, default resolution is performed. By default $C$ is resolved by choosing shift action.\n\nIf priority and associativity are not assigned to a token $t$ explicitly in the priorities section, JAMOOS attempts to assign them implicitly, basing on the priority and associativity of a production which contains $t$ (see Section 5.3.2).\n\nWhile attempting to assign priority and associativity to $t$ implicitly, the Context-Dependent Priority problem may occur (see Section 5.3.3). The resolution of this problem is described in the Section 5.4.\n\nIf priority is not assigned to a production $P$ explicitly in the priorities section, JAMOOS attempts to assign the priority implicitly basing on the priority of the rightmost token in the right-hand side of $P$ (see Algorithm 6).\n\nFormal description of Shift/Reduce conflict resolution algorithm is presented in Algorithm 9. The algorithm for implicit priority assignment to token is presented in Algorithm 10. Formal description of Runtime APAI is presented in Section 5.4.\n\n\\(^{10}\\)The associativity of both $t$ and $P$ can be used to resolve $C$. Since both $P$ and $t$ have equal priorities, they should be declared in the same group in the priorities section and have equal associativity.\nAlgorithm 5 The function that resolves a Reduce/Reduce conflict between productions $P_1$, $P_2$, \\ldots, $P_n$. The function calls the AssignPriorityToProduction function when it is required to assign a priority to a production implicitly. This function is described in Algorithm 6.\n\n**Input:** $P_1$, $P_2$, \\ldots, $P_n$ – conflicting productions sorted in an alphabetical order by variables on their left-hand sides;\n\n$PT$ – priority and associativity table that contains all variables and tokens which appear in the priorities section, together with their priorities and associativity values\n\n**Output:** $P_i$, $i = 1, \\ldots, n$ – production in favor of which the conflict is resolved\n\n```\nFunction ResolveReduceReduceConflict\n1: for all $P_i$, $i = 1, \\ldots, n$ do\n2: if variable on left-hand side of $P_i$ appears in $PT$ then\n3: $\\pi_i \\leftarrow$ priority of $P_i$\n4: else\n5: // Attempting to assign a priority to $P_i$ implicitly.\n6: // In case of success the priority of $P_i$ is set to $\\pi_i$ and the function returns true.\n7: // In case of failure the function returns false.\n8: $res \\leftarrow$ AssignPriorityToProduction($P_i$, $PT$, $\\pi_i$)\n9: if $res == false$ then\n10: return $P_1$ // Default resolution\n11: end if\n12: end if\n13: end for\n14: $z \\leftarrow \\max(\\pi_1, \\pi_2, \\ldots, \\pi_n)$\n15: // Initiate the variable that will contain the number of a production which has the highest priority\n16: $k \\leftarrow 0$\n17: for all $P_i$, $i = 1, \\ldots, n$ do\n18: if $\\pi_i == z$ then\n19: if $k == 0$ then\n20: $k \\leftarrow i$\n21: else\n22: return $P_1$ // More than one production has the highest priority. Apply default resolution.\n23: end if\n24: end if\n25: end for\n26: return $P_k$\n```\nAlgorithm 6 The function infers priority of a production basing on the priority of the rightmost token in its right-hand side. The function fails to infer priority of the production if it does not contain any token in the right-hand side or if the priority of its rightmost token is not defined in priorities section. In order to find the rightmost token the function calls auxiliary function LastToken. This function is described in Algorithm 7.\n\nInput: $P$ – production for which priority should be assigned;\n$PT$ – priority and associativity table that contains all variables and tokens which appear in the priorities section together with their priorities and associativity values;\n$\\pi$ – a variable which will contain the priority of $P$ in case of successful priority assignment\n\nOutput: In case of successful priority assignment the function returns true. Otherwise it returns false.\n\nFunction AssignPriorityToProduction\n\n1: if $P$ is a Composition then\n2: $n \\leftarrow$ number of components in $P$\n3: let $c_i, i = 1, \\ldots, n$, be a component of $P$\n4: for $i = n, i \\rightarrow 0$ do\n5: // Attempting to find a rightmost token $t$ in the component $c_i$.\n6: // In case of success the function returns true. In case of failure the function returns false.\n7: res $\\leftarrow$ LastToken($c_i, t$)\n8: if res $== true$ then\n9: if $t$ appears in $PT$ then\n10: $\\pi \\leftarrow$ priority of $t$\n11: return true\n12: else\n13: return false\n14: end if\n15: end for\n16: return false\nAlgorithm 7 The function searches the rightmost token in a production component. The function fails to find such a token if the component does not contain any token. The function calls an auxiliary function ListLastToken (see Algorithm 8) in order to find the rightmost token in a List component.\n\n**Input:** $c$ – component whose rightmost token should be found; $t$ – a variable which will contain the rightmost token of $C$ in case of successful function completion.\n\n**Output:** The function returns true if the rightmost token of $c$ was successfully found. Otherwise the function returns false.\n\n**Function LastToken**\n\n1: if $c$ is Token then\n2: $t \\leftarrow c$\n3: return true\n4: end if\n5: if $c$ is Variable then\n6: return false\n7: end if\n8: if $c$ is Sequence or $c$ is Optional then\n9: $n \\leftarrow$ number of components in $c$\n10: let $c_i, i = 1, \\ldots, n$, be a component of $c$\n11: for $i = n, i - -$ do\n12: $res \\leftarrow$ LastToken($c_i, t$)\n13: if $res ==$ true then return true\n14: end for\n15: return false\n16: end if\n17: if $c$ is List then\n18: $res \\leftarrow$ ListLastToken($c, t$)\n19: if $res ==$ true then return true\n20: return false\n21: end if\n22: if $c$ is an Alternative then\n23: $n \\leftarrow$ number of choices in $c$\n24: let $c_i, i = 1, \\ldots, n$, be a choice of $c$\n25: for $i = n, i - -$ do\n26: $res \\leftarrow$ LastToken($c_i, t'$)\n27: if $res ==$ true then return true\n28: end for\n29: return false\n30: end if\nAlgorithm 8 The function searches the rightmost token in a List component. The function fails to find such a token if the component does not contain any token.\n\n**Input:** $c_l$ – List component whose rightmost token should be found; \n$t$ – a variable which will contain the rightmost token of $c_l$ in case of successful function completion. \n**Output:** The function returns **true** if the rightmost token of $c_l$ was successfully found. Otherwise the function returns **false**.\n\n**Function ListLastToken**\n\n1: if $c_l$ has a terminal component then\n2: $c \\leftarrow$ the terminal component of $c_l$\n3: res $\\leftarrow$ LastToken($c$, $t$)\n4: if res $==$ true then\n5: return true\n6: end if\n7: end if\n8: $c \\leftarrow$ the repeated item of $c_l$\n9: res $\\leftarrow$ LastToken($c$, $t$)\n10: if res $==$ true then\n11: return true\n12: end if\n13: if $c_l$ has a separator component then\n14: $c \\leftarrow$ the separator component of $c_l$\n15: res $\\leftarrow$ LastToken($c$, $t$)\n16: if res $==$ true then\n17: return true\n18: end if\n19: end if\n20: if $c_l$ has a initial component then\n21: $c \\leftarrow$ the initial component of $c_l$\n22: res $\\leftarrow$ LastToken($c$, $t$)\n23: if res $==$ true then\n24: return true\n25: end if\n26: end if\n27: return false\nAlgorithm 9 The function resolves Shift/Reduce conflict \\( C \\) between the token \\( t \\) and the production \\( P \\). When it is required to assign priority and associativity to \\( t \\) implicitly, auxiliary function \\texttt{AssignPriorityToToken} (see Algorithm 10) is called. When it is required to assign priority and associativity to \\( P \\) implicitly, auxiliary function \\texttt{AssignPriorityToProduction} (see Algorithm 6) is called.\n\n**Input:** \\( P \\) – production by which reduction can be performed; \n\\( t \\) – token that can be shifted; \n\\( PT \\) – priority and associativity table that contains all variables and tokens which appear in the priorities section together with their priorities and associativity values; \n\\( S_C \\) – set of LR-items from the parser state in which \\( C \\) occurs\n\n**Output:** The function may return three values: \\texttt{Shift}, \\texttt{Reduce} and \\texttt{VariableAction}. If the function returns \\texttt{Shift}, \\( C \\) is resolved by shifting \\( t \\). If the function returns \\texttt{Reduce}, \\( C \\) is resolved in favor of reduction by \\( P \\). If the function returns \\texttt{VariableAction}, \\( C \\) is resolved by performing Runtime APAI.\n\n**Function** \\texttt{ResolveShiftReduceConflict}\n\n1. if left-hand variable of \\( P \\) appears in \\( PT \\) then\n2. \\( \\pi_P \\leftarrow \\) priority of \\( P \\)\n3. else\n4. // Attempting to assign priority to \\( P \\) implicitly.\n5. // In case of successful assignment priority of \\( P \\) will be set to \\( \\pi_P \\).\n6. res \\( \\leftarrow \\) \\texttt{AssignPriorityToProduction}(\\( P \\), \\( PT \\), \\( \\pi_P \\))\n7. if res \\( == \\) false then return \\texttt{Shift} // Default resolution\n8. end if\n9. if \\( t \\) appears in \\( PT \\) then\n10. \\( \\pi_t \\leftarrow \\) priority of \\( t \\)\n11. else\n12. // Attempting to assign priority and associativity to \\( t \\) implicitly. In case of successful\n13. // assignment priority of \\( t \\) will be set to \\( \\pi_t \\) and associativity of \\( t \\) will be set to \\( \\rho \\).\n14. res \\( \\leftarrow \\) \\texttt{AssignPriorityToToken}(\\( t \\), \\( PT \\), \\( S_C \\), \\( \\pi_P \\), \\( \\pi_t \\), \\( \\rho \\))\n15. if res \\( == \\) lookahead then return \\texttt{VariableAction} // Runtime APAI should be performed\n16. if res \\( == \\) false then return \\texttt{Shift} // Default resolution\n17. end if\n18. if \\( \\pi_P < \\pi_t \\) then return \\texttt{Shift}\n19. if \\( \\pi_P > \\pi_t \\) then return \\texttt{Reduce}\n20. if \\( \\pi_P == \\pi_t \\) then\n21. if \\( \\rho \\) is \\texttt{LEFT} then return \\texttt{Reduce}\n22. if \\( \\rho \\) is \\texttt{RIGHT} then return \\texttt{Shift}\n23. end if\nAlgorithm 10 The function infers priority and associativity of a token \\( t \\) basing on the priorities and associativity of one or more productions in which \\( t \\) appears. The token \\( t \\) may derive priority and associativity only from a production involved in a Shift/Reduce conflict \\( C \\) which occurs between \\( t \\) itself and a production \\( P \\).\n\n**Input:** \\( t \\) – token to which priority and associativity should be assigned; \n\\( PT \\) – priority and associativity table; \n\\( S_C \\) – set of LR-items from the parser state in which \\( C \\) occurs; \n\\( \\pi_P \\) – priority of the production \\( P \\); \n\\( \\pi_t \\) – variable that will contain the priority of \\( t \\); \n\\( \\rho \\) – variable that will contain the associativity of \\( t \\)\n\n**Output:** The function may return three values: **true**, **false** and **lookahead**. The function returns **true** in case of successful priority and associativity assignment. The function returns **false**, if priority of one or more productions from which \\( t \\) may derive its priority is not defined in a priorities section. The function returns **lookahead**, if Runtime APAI should be used.\n\n**Function** AssignPriorityToToken\n\n1: let \\( R_C \\) be a set of LR-items \n2: \\( R_C \\leftarrow \\) LR-items from \\( S_C \\) which have dot before \\( t \\) \n3: \\( n \\leftarrow \\) size of \\( R_C \\) \n4: \\( \\text{// Attempting to find priorities and associativity of all productions involved in } C \\)\n5: for item \\( i \\in R_C, i = 1, \\ldots, n \\) do\n6: \\( A \\leftarrow \\) left-hand variable of item \\( i \\)\n7: if \\( A \\) appears in \\( PT \\) then\n8: \\( \\pi_i \\leftarrow \\) priority of \\( A ), \\rho_i \\leftarrow \\) associativity of \\( A \\)\n9: else\n10: return false\n11: end if\n12: end for\n13: \\( s \\leftarrow \\) true, \\( r \\leftarrow \\) true\n14: for \\( i, i = 1, \\ldots, n \\) do\n15: if \\( \\pi_i < \\pi_P \\) or \\( (\\pi_i == \\pi_P \\text{ and } \\rho_i \\text{ is LEFT}) \\) then \\( s \\leftarrow \\) false\n16: if \\( \\pi_i > \\pi_P \\) or \\( (\\pi_i == \\pi_P \\text{ and } \\rho_i \\text{ is RIGHT}) \\) then \\( r \\leftarrow \\) false\n17: end for\n18: if \\( s == \\) false and \\( r == \\) false then\n19: return lookahead // \\( t \\) may derive priority higher than \\( \\pi_P \\) as well as priority lower than \\( \\pi_P \\)\n20: else\n21: \\( \\pi_t \\leftarrow \\pi_1, \\rho \\leftarrow \\rho_1 \\)\n22: return true\n23: end if\n6.3 Resolution of Pop/Reduce Conflicts\n\nConsider a Pop/Reduce conflict $C$ between repeated element $e_l$ of a list $l$ and the list itself. While reducing $l$ a parser must decide whether a symbol $x$ on the top of the stack is an element of $l$ or not.\n\nIn the first case the parser pops $x$ and considers it as $e_l$. In the second case the parser stops reduction of $l$ and considers $x$ as a part of some other component (see detailed description of the conflict in Section 4.3).\n\nSince both $e_l$ and $l$ are components of JA MOOS language, priorities can be assigned to them. Assume that $e_l$ has priority $\\pi_{elem}$ and $l$ has priority $\\pi_l$. If $\\pi_{elem}$ is higher than $\\pi_l$, the parser will continue popping symbols from the stack as elements of $l$. If $\\pi_{elem}$ is lower than $\\pi_l$, the parser will finish reduction of $l$.\n\nExample 29. Consider the grammar $G_A$ that describes strings which consist of the symbol $a$ only:\n\n```\nGRAMMAR A()\n A → [\"a\"] aList: { listElem: \"a\" ... } ;\nEND\n```\n\nA Pop/Reduce conflict occurs in the grammar above. While parsing a sequence of symbols $a$, the parser has to decide whether the first symbol in the sequence is a part of the list or an element of the optional section.\n\nThe conflict can be resolved by assigning priorities to both the list and its repeated item. If it is required always to consider the first symbol $a$ as a part of the list, higher priority should be assigned to the repeated item of the list. In this case the priorities section will look like follows:\n\n```\nPRIORITIES\n LEFT aList\n LEFT listElem\nEND\n```\n\nThe parse tree for the input $aa$ is shown in Figure 12. The parse tree is typical for this conflict resolution: optional section always is considered empty, all symbols $a$ are considered as elements of the list.\n\n```\nA\n [\"a\"] { \"a\" ... }\n a\n / \\a\n```\n\nFigure 12: Parse tree for the input $aa$ described by the grammar $G_A$. A Pop/Reduce conflict which occurred in $G_A$ while parsing the input was resolved by choosing to pop the first symbol $a$ as the list element.\n\nIf the first symbol $a$ always should be considered as an element of the optional section, higher priority should be assigned to the list. In this case the priorities section will look like follows:\n\n```\nPRIORITIES\n```\n\n55\nThe parse tree for the input \\textit{aa} is shown in Figure 13. The parse tree is typical for this conflict resolution: the first symbol \\textit{a} is always an element of the optional section.\n\n\\begin{figure}[h]\n\\centering\n\\includegraphics[width=0.5\\textwidth]{figure13}\n\\caption{Parse tree for the input \\textit{aa} described by the grammar $G_A$. A Pop/Reduce conflict which occurred in $G_A$ while parsing the input was resolved by choosing to pop the first symbol \\textit{a} as the element of the optional section.}\n\\end{figure}\n\nIf priorities of a list or of its element are not defined explicitly in the priorities section, default resolution is performed. By default, the parser will continue popping symbols from the stack as elements of the list.\n\nFormal description of the Pop/Reduce conflict resolution algorithm is presented in Algorithm 11.\n\n6.4 Resolution of Pop/Pop Conflicts\n\nConsider a Pop/Pop conflict \\textit{C} that occurs between two choices \\textit{ch}_1 and \\textit{ch}_2 in an alternative section \\textit{a}. While reducing \\textit{a} the parser can pop both \\textit{ch}_1 and \\textit{ch}_2, because the stack content matches both choices. In this case the parser must decide which choice to pop (see detailed description of this conflict in Section 4.4).\n\nThe conflict \\textit{C} can be resolved by assigning priorities to \\textit{ch}_1 and \\textit{ch}_2. Priorities can be assigned to choices locally (see Section 5.2). The conflict is resolved in favor of the choice with the highest priority.\n\nIf both \\textit{ch}_1 and \\textit{ch}_2 have equal priority \\textit{C} default resolution is performed. By default \\textit{C} is resolved in favor of an alternative which appears first in \\textit{a}.\n\n\\textbf{Example 30.} Consider the following grammar $G_{Friends}$:\n\n\\begin{verbatim}\nGRAMMAR Friends()\n Friends -> boys:(john OF “John” | boys OF (“John” and “Alex”)) and Girls;\n Girls -> jane OF “Jane” | girls OF (“Alex” and “Jane”);\nEND\n\\end{verbatim}\n\nA Pop/Pop conflict occurs in the grammar above. While parsing the following input\n\nJohn and Alex and Jane\n\nit is legitimate to pop both choices of the production Girls. If the choice \\textit{girls} is popped while reducing by the production Girls, then the choice \\textit{john} will be popped when reduction by the\nAlgorithm 11 The function resolves Pop/Reduce conflict.\n\n**Input:**\n- `list` – a name of the list component;\n- `elem` – a name of a component which is the repeated item of the `list`;\n- `PT` – priority table that contains all component names which appear in the priorities section together with their priority values\n\n**Output:** The function may return two values `pop` and `reduce`. The function returns `pop`, if the conflict is resolved in favor of popping: a symbol on the top of the stack will be popped as the repeated item of the list. The function returns `reduce`, if the conflict is resolved in favor of reduction: a symbol on the top of the stack will not be considered as the repeated item of the list, and the reduction of the list will be completed.\n\n**Function ResolvePopReduceConflict**\n\n1. if `list` appears in `PT` then\n2. \\[ \\pi_{list} \\leftarrow \\text{priority of list} \\]\n3. else\n4. return `pop` // Default resolution\n5. end if\n6. if `elem` appears in `PT` then\n7. \\[ \\pi_{elem} \\leftarrow \\text{priority of elem} \\]\n8. else\n9. return `pop` // Default resolution\n10. end if\n11. if \\( \\pi_{elem} > \\pi_{list} \\) then\n12. return `pop`\n13. else if \\( \\pi_{elem} < \\pi_{list} \\) then\n14. return `reduce`\n15. else\n16. return `pop` // Default resolution\n17. end if\nproduction Friends will be performed. If the choice jane is popped while reducing by the production Girls, then the choice boys will be popped when reduction by the production Friends will be performed.\n\nThe conflict can be resolved by assigning priorities to the choices jane and girls. If it is required that Alex always should be considered as a boy, the production Girls should be rewritten as follows:\n\n\\[\n\\text{Girls} \\rightarrow \\text{jane OF “Jane” || girls OF (“Alex” and “Jane”)};\n\\]\n\nThe parse tree for the above input is shown in Figure 14.\n\nFigure 14: Parse tree for the input John and Alex and Jane described by the grammar G_{Friends}. A Pop/Pop conflict which occurred in G_{Friends} while parsing the input, was resolved in favor of the choice jane.\n\nIf it is required that Alex always should be considered as a girl, the production Girls should be rewritten as follows:\n\n\\[\n\\text{Girls} \\rightarrow \\text{girls OF (“Alex” and “Jane”) || jane OF “Jane”};\n\\]\n\nThe parse tree which will be obtained in this case is shown in Figure 15.\n\nFigure 15: Parse tree for the input John and Alex and Jane described by the grammar G_{Friends}. A Pop/Pop conflict which occurred in G_{Friends} while parsing the input was resolved in favor of the choice girls.\n\nFormal description of the Pop/Pop conflict resolution algorithm is presented in Algorithm 12.\n\n7 Implementation\n\nIn this section we will discuss details of conflict resolution implementation in the framework of JAMOOS project. The implementation stages included:\nAlgorithm 12 The function resolves Pop/Pop conflict.\n\nInput: $a$ – an alternative section in which Pop/Pop conflict occurred.\n\n- $a$ has the form $\\alpha_1 \\| \\alpha_2 \\| \\ldots \\| \\alpha_n$, $n \\geq 1$.\n- $\\alpha_i$, $i = 1, \\ldots, n$, has the form $\\beta_{i1} | \\beta_{i2} | \\ldots | \\beta_{im_i}$, $m_i > 1$;\n- $ch_1, ch_2$ – conflicting choices of $a$ sorted in order of their appearance in $a$\n\nOutput: $ch$ – a choice in favor of which the conflict is resolved\n\nFunction ResolvePopPopConflict\n\n1: for $i$, $i = 1, \\ldots, n$ do\n2: for $j$, $j = 1, \\ldots, m_i$ do\n3: if $\\beta_{ij} \\equiv ch_1$ then\n4: $\\pi_1 \\leftarrow i$\n5: end if\n6: if $\\beta_{ij} \\equiv ch_2$ then\n7: $\\pi_2 \\leftarrow i$\n8: end if\n9: end for\n10: end for\n11: if $\\pi_1 > \\pi_2$ then\n12: return $ch_1$\n13: end if\n14: if $\\pi_1 < \\pi_2$ then\n15: return $ch_2$\n16: end if\n17: if $\\pi_1 == \\pi_2$ then\n18: return $ch_1$ // Default resolution\n19: end if\n• Adding syntactical support for priorities section definitions. Another bootstrapping step was performed in order to build the version of JAMOOS which would allow priorities section definitions.\n\n• Implementation of Conflict Resolution module and its implantation into JAMOOS project\n\n• Automatic generation of conflict reports\n\n7.1 Adding Syntactical Support for Priorities Section Definitions\n\nJAMOOS was developed gradually employing a bootstrapping technique: JAMOOS was used to define the grammar of the JAMOOS language itself and generate a parser for the grammar. BISON (the GNU version of YACC) was used to initiate the bootstrapping process. Then at each step new language features have been added to the grammar employing already existed ones [31].\n\nBy the time this work has been started syntax of JAMOOS has not allowed definition of priorities section in JAMOOS programs. Double bar in alternations, which is necessary for the resolution of Pop/Pop conflicts (see Section 5.2), was supported by JAMOOS, though no semantic action was associated with it.\n\nIn order to obtain a parser which would accept JAMOOS programs that contain priorities section another step of bootstrapping was performed. Productions that describe priorities section were added to the existed JAMOOS grammar. Then Jamoos was used to generate a set of classes and a parser for the extended JAMOOS grammar.\n\nSince most of the productions from J have been transferred to J’ without any changes, the classes generated for them by JAMOOS have not been changed either. Therefore the code that implemented semantic actions associated with these productions was almost entirely reused.\n\n7.2 Conflict Resolution Implementation\n\nBy the time this work has been started already implemented parts of JAMOOS included: automatic translation of a grammar productions into C++ classes and generation of an object oriented parser for the grammar. The Parser Generator module has provided an information about conflicts that occur in the grammar. For each type of conflicts the following characteristics have been provided:\n\n• Shift/Reduce conflict\n 1. State in which the conflict has been occurred\n 2. Number of a token by which shift action can be performed\n 3. Number of a parser state to which the parser would move in case if the shift action was chosen\n 4. List of numbers of productions by which reduce action can be performed\n\n• Reduce/Reduce conflict\n 1. State in which the conflict has been occurred\n 2. List of numbers of productions by which reduce action can be performed\n\n• Pop/Reduce conflict\n 1. Production in which the conflict has been occurred\n2. List in the production which contains the conflict\n\n- **Pop/Pop conflict**\n 1. Production in which the conflict has been occurred\n 2. List of alternatives in the production among which the conflict has been occurred\n\nThe main tasks of the Conflict Resolution module designed and implemented in this work were as follows:\n\n- Establish a connection with the Parser Generation module employing the interface described above and obtain the information about conflicts which occur in a grammar.\n- Obtain information about user-provided priorities and associativity of tokens, variables and tags. Build priority and associativity tables.\n- Resolve the conflicts basing on priorities and associativity defined by a user in priorities section of the grammar.\n\nSeveral classes were designed to accomplish the tasks above. Here is a description of the most important of them.\n\n**PrioAssocTable** This class describes priority and associativity table which contains priorities and associativity defined by a user in priorities section. The table consists of three independent tables: for tokens, variables and tags.\n\nThe tables are created on the basis of the information extracted from the class `PrioritySection` automatically generated by JAMOOS. The structure of the `PrioritySection` class reflects the structure of the corresponding production. Tokens, variables and tags are stored in nested lists in arbitrary order. Priority is defined by order of the lists: if the list \\( l_1 \\) appears before the list \\( l_2 \\), then tokens, variables and tags from \\( l_2 \\) have the higher priority than the ones from \\( l_1 \\). Associativity is defined in a special field associated with each list. The `PrioAssocTable` class extracts information about priority and associativity of tokens, variables and tags, and sort it into three corresponding tables.\n\n**ConflictResolver** This class implements algorithms of conflict resolution described in Section 6.\n\n**PATFacade** This class defines a higher-level interface that makes the priority and associativity tables easier to use.\n\nTokens, variables and tags are represented in the `PrioAssocTable` class as objects, while in the `ConflictResolver` class they are represented as numbers (token/variable/tag id). The `PATFacade` class provides to the `ConflictResolver` class convenient interface that allows the latter to use the priority tables defined in class `PrioritySection`.\n\n### 7.3 Grammar Report Generation\n\nAlong with a set of classes and a parser JAMOOS generates for a grammar an HTML file which contains a grammar report. A grammar report for a grammar \\( G \\) is a document that provides different kinds of information about \\( G \\), such as statistics about \\( G \\), description of states of a parser generated for \\( G \\), relationships between tokens, variables and productions of \\( G \\) etc.\n\nThe main purpose of a grammar report is to provide a handy way to follow the parsing process in order to find inaccuracies or errors in the grammar definition. The problem of tracing the parsing\nprocess becomes even more crucial when conflicts occur. In order to understand how a conflict has occurred it is not enough to observe the conflict parser state only. Often a conflict between certain productions is actually caused by another productions which even may not appear in the conflict state. The Modifiers conflict that occurs in JAVA language is an example of such a conflict (see Section 8.1.2).\n\nA proper conflict resolution requires information about all parsing paths which led to the conflict. A compact and easy-to-understand format of a parser representation is therefore of a great importance. In this section we will describe how a Documentation Generation module of JAMOOS was extended by conflict report generation methods. The improvements in the parser representation format will be discussed also.\n\n7.3.1 Generation of Conflict Reports\n\nA grammar report is generated by the Documentation Generation module of JAMOOS. This module was extended by methods which provide a detailed information about all conflicts that have occurred in the grammar.\n\nFor each Shift/Reduce or Reduce/Reduce conflict $C$ the following information is provided:\n\n- States in which $C$ occurs.\n- Tokens which are read by a parser by the time $C$ occurs. In case of Shift/Reduce conflicts they are tokens by which the shift action can be performed.\n- Productions by which the reduction might be performed.\n- Resolution of $C$. There are three ways to resolve a conflict:\n - **Shift**\n - **Reduce** In this case a production by which the reduce action will be performed, is specified.\n - **Variable Action** Runtime APAI will be used to resolve $C$ (see Section 5.4). In this case two lists of tokens that may appear in the input right after the current input token are provided. One list contains tokens which indicate that the shift action must be performed. Another one contains tokens which indicate that the reduce action must be performed.\n\nFor each Pop/Reduce conflict $C$ the following information is provided:\n\n- States in which $C$ occurs.\n- A list $l$ that contains $C$.\n- A production in which $l$ appears.\n- Resolution of $C$. There are two ways to resolve a conflict:\n - **Continue** Resolution in favor of the pop action. A parser will pop the current symbol from the stack as an element of $l$.\n - **Stop** Resolution in favor of the reduce action. A parser stops the reduction of $l$. The current symbol in the stack will be considered as a part of the component which will be reduced after $l$. \n\n\nFor each Pop/Pop conflict \\( C \\) the following information is provided:\n\n- States in which \\( C \\) occurs.\n- Conflicting alternatives.\n- A DataTypes component \\( a \\) that contains the conflicting alternatives.\n- A production in which \\( a \\) appears.\n- Resolution of \\( C \\). An alternative, which will be popped, is specified.\n\n### 7.3.2 Parser Representation Format\n\nA parser is represented as a set of parser states which in turn are represented as a set of LR-items. Since parser states often contain a huge number of LR-items, it is crucial to find the most compact and understandable representation of the items. Different fonts and colors were used for this purpose. Here is the list of improvements which were made in the representation of LR-items:\n\n1. Reduce items are printed in italic font. The left-hand side variables of reduce items are printed in a bright green color, which facilitates locating them among the regular LR-items.\n2. The LR-marker (dot) in LR-items and the sharp symbol (#) in reduce items are printed in a red color.\n3. String tokens are printed in a green color.\n4. Keyword tokens are printed in a blue color.\n5. Regular expressions are printed in a light brown color.\n\nEach parser state \\( s \\) is associated with a row in a parse table. The parse table is divided into Action and Goto tables.\n\nFor each token \\( t \\) in a grammar \\( G \\) there is a column in the Action table associated with it. The action that should be performed in \\( s \\) when \\( t \\) is the current input symbol appears in the corresponding cell of the Action table. If the cell contains more than one action then a conflict occurs.\n\nFor each variable \\( A \\) in \\( G \\) there is a column in the Goto table associated with it. Assume that when a string described by \\( A \\) is derived the parser is in \\( s \\). When the reduction by \\( A \\) is performed the parser moves to the state \\( s' \\). The number of \\( s' \\) appears in the cell of the Goto table which corresponds to \\( s \\) and \\( A \\).\n\nEntries to the Action and Goto tables play the key role in tracing a parsing process. In order to gain maximal understandability of the entries the following improvements in their representation were made:\n\n1. Separate presentation of the entries to Action and Goto tables\n2. Entries are presented as tables rather than lists. The Action table entry for \\( s \\) is represented as a table \\( \\text{Action}_s \\) with two columns. The first column contains tokens of \\( G \\), while the second one contains actions corresponding to \\( s \\) and the tokens.\\(^{11}\\) The Goto table entry for \\( s \\) is represented as a table \\( \\text{Goto}_s \\) with two columns. The first column contains variables of \\( G \\), while the second one contains numbers of states to which the parser moves after reductions.\n\n\\(^{11}\\)If the same action should be performed on several tokens, the entries corresponding to these tokens are merged.\n3. Cells that contain conflicts are represented by several rows in Action$^2$; each row corresponds to a different action of a conflict. However, only the action which will be performed at parsing time is printed in regular font. The actions which are not relevant are printed in italic font.\n\n8 Conflict Resolution in Grammars of JAVA and JAMOOS\n\nIn this chapter we will show how conflict resolution techniques described in chapter 6 were used for the resolution of conflicts in grammars of JAVA language and JAMOOS.\n\nAs the base of our discussion on conflict resolution in the JAVA language, we choose a JAVA grammar composed by Gosling et al. [15, §16]. This grammar then went through a number of revisions:\n\n- Syntax errors were corrected. For example, in certain cases the initial grammar described statements that missed a semicolon afterwards, which contradicts with the JAVA syntax.\n\n- The grammar was extended with several necessary productions. For instance, the initial grammar lacked description of certain constructions of the JAVA standard, such as literals (numbers, characters, strings etc.).\n\n- A few productions were replaced by the ones that exactly correspond to the JAVA standard. For example, a group of productions that specifies arithmetic and logic expressions in the initial grammar has no possibility to describe complex expressions without parenthesis, such that $2 + 5 \\ast x$.\n\n- The grammar was translated into the JAMOOS format, given in Section 3.\n\nThe full text of the JAVA grammar in JAMOOS notation can be found in Appendix A.\n\nThe resulting grammar contains only one Reduce/Reduce conflict and several Shift/Reduce conflicts. It contains no Pop conflicts.\n\nMost of Shift/Reduce conflicts occurred in a grammar part which describes arithmetic expressions. The nature of these conflicts is trivial, no special discussion on it will be held in this work. The resolution of these conflicts, however, emphasizes one of important characteristics of our conflict resolution method. Our APAI mechanism empowered by the original interface for assigning priorities and associativity to productions allows to assign priority and associativity to abstract entities such as arithmetical operations. In contrast, YACC allows to assign priorities and associativity to operators only. For example, in YACC priorities and associativity are assigned to operators \"=\"，“\\+ “, “++ “ while in our method priorities and associativity are assigned directly to arithmetical operations assignment, multiplication, postfix increment.\n\nWe will demonstrate the application of our Pop conflict resolution techniques on resolution of Pop conflicts which occur in a grammar of JAMOOS. For this purpose we have chosen the JAMOOS grammar composed by Tsoglin [31]$^{12}$. The grammar contains four Pop conflicts: one Pop/Reduce conflict and three Pop/Pop conflicts. We will show the resolutions of the Pop/Reduce conflict and one of the Pop/Pop conflicts$^{13}$.\n\n$^{12}$Tsoglin defined the complete JAMOOS grammar. Since JAMOOS is an ongoing project the current version of JAMOOS grammar that was considered in Section 3 is incomplete and lacks a lot of features. The syntax of the complete JAMOOS grammar differs from the current JAMOOS grammar syntax.\n\n$^{13}$The rest of the Pop/Pop conflicts have the similar resolution and therefore they are not of interest for the current discussion.\n8.1 Shift/Reduce Conflicts\n\n8.1.1 Array Creation Conflict\n\nThis conflict occurs while parsing JAVA statements in which a multidimensional array is created. Consider the following statement:\n\n\\[\n\\text{new int}[4][i*5]\n\\]\n\nTwo interpretations of this statement are possible. One of them considers the statement as a creation of a 2-dimensional array.\n\nAnother interpretation considers a sub-expression \\text{new int}[4] as a creation of a 1-dimensional array. An array creation statement is considered as a kind of the simplest JAVA expressions, among other simplest expressions such as names of variables. These expressions are described by Primary production:\n\n\\[\n\\text{Primary} \\to \\text{reference OF (}} \\text{Identifier \\ldots} \\text{) + [ IdentifierSuffix ] } | \\text{instance creation OF (new Creator);}\n\\]\n\nCreator \\to \\text{Type ArrayCreatorRest;}\n\nThe grammar allows the Primary nonterminal to have an array access operator afterwards.\n\nLeftHandSide \\to \\text{Primary \\{ Selector \\ldots \\};}\n\nSelector \\to \\text{“[” Expression “]”};\n\nIn the example above the sub-expression \\([i*5]\\) is interpreted as an access to the \\((i*5)\\)-th element of the array \\text{new int}[4].\n\nThe ambiguous interpretation of the array creation statements leads to Shift/Reduce conflict between the token “[\" and the production ArrayCreatorRest.\n\nArrayCreatorRest \\to \\{ (\"[\" Expression \"]\") \\ldots \\} + BracketsOpt;\n\nBracketsOpt \\to \\{ \"[\" \\ldots \\};\n\nIn the example above the conflict occurs when the sub-expression \\text{new int}[4] has been already parsed and the token “[\" appears next in the input. If shift on token “[\" is performed, the entire statement will be considered as a creation of 2-dimensional array. If reduce by ArrayCreatorRest is performed, the statement will be considered as array access.\n\nFigure 16 shows two possible parsing trees which can be produced for the statement from the example above.\n\nAccording to JAVA semantic rules, Primary expression, which has an array access operator after it, cannot be an array creation expression [15, §15.13]. It means that the right parsing tree on Figure 16 is erroneous. While parsing array creation statements, the Shift action should be performed to obtain semantically correct parsing trees.\n\nThe conflict is resolved by means of priorities. The priority is assigned both to the token “[\" and to the nonterminal ArrayCreationRest. The priority of the token is higher than the priority of the nonterminal, and this causes to the shift action to be performed at parsing time.\n8.1.2 Modifiers Conflict\n\nClass members in Java can be declared with different access control attributes. Special keywords which are called modifiers are used for this purpose. Consider the class Point:\n\n```java\nclass Point {\n protected int x, y;\n public void move(int dx, int dy) { x += dx; y += dy; }\n}\n```\n\nThe fields `x` and `y` are declared `protected`. The modifier `protected` means that the fields are accessible only in objects of the class `Point` or in its subclasses. The method `move` of the class `Point` is declared `public`. The modifier `public` means that the method is available to any code that uses an object of type `Point`.\n\nClass members are described by the following production:\\(^{14:}\\)\n\n```java\nClassBodyDeclaration → ModifiersOpt MemberDecl;\nModifiersOpt → { Modifier ... };\nModifier → \n pub OF public | \n prot OF protected | \n priv OF private | \n abstract OF abstract;\n```\n\nA class member, in turn, can be a class or an interface. A class, whose declaration occurs within the body of another class or interface, is called a nested class. Both nested class and interface can be specified with their own access control attributes.\n\n```java\nMemberDecl → ClassOrInterfaceDeclaration;\nClassOrInterfaceDeclaration → ModifiersOpt\n class_decl OF ClassDeclaration | intrf_decl OF InterfaceDeclaration;\n```\n\n\\(^{14:}\\)For sake of simplicity, only part of the modifiers list is shown.\nConsider the following declaration of a nested class `Nested`:\n\n```java\nclass TopLevel {\n public class Nested { ... }\n}\n```\n\nWhile parsing the nested class declaration we receive the following derivation according to the productions above:\n\n```\nClassBodyDeclaration ⇒\n ModifiersOpt MemberDecl ⇒\n ModifiersOpt ClassOrInterfaceDeclaration ⇒\n ModifiersOpt ModifiersOpt ClassDeclaration ⇒\n ModifiersOpt ModifiersOpt class Nested { ... }\n```\n\nThe list of modifiers `ModifiersOpt` can be empty. Therefore the modifier `public` of the class `Nested` can be considered as a part of either `ClassBodyDeclaration` or `ClassOrInterfaceDeclaration`.\n\nThis ambiguity leads to the Shift/Reduce conflict between the tokens which represent modifiers, and the nonterminal `ModifiersOpt`.\n\nWhile parsing the declaration of the class `Nested` in the example above, the conflict occurs when the token `public` appears in the input. If shift action is performed at this stage, the token `public` will be considered as a part of `ClassBodyDeclaration`. If reduce by the nonterminal `ModifiersOpt` is performed, the token `public` will be considered as a part of `ClassOrInterfaceDeclaration`.\n\nFigure 17 shows two possible parsing trees which can be derived for the `Nested` class declaration.\n\n\n\nBoth parsing trees are legitimate. Still the conflict is resolved by choosing `Reduce` which means that the modifiers will be considered as a part of `ClassOrInterfaceDeclaration`. This decision provides the common treatment to all class or interface declarations.\n\nTo resolve the conflict priorities are assigned to all the tokens which represent modifiers and to the nonterminal `ModifiersOpt`. The priority of the nonterminal is higher than the priorities of the tokens, and this causes to the reduce action to be performed at parsing time.\n8.1.3 Dangling Else Conflict\n\nConsider the following input:\n\n```plaintext\nif (i > 10)\n if (j < 5)\n // do something...\nelse\n // do something else...\n```\n\nHere the `else` branch can be associated with both conditional statements. This ambiguity leads to the Shift/Reduce conflict between the token `else` and the nonterminal `Statement`:\n\n```plaintext\nStatement → if ParExpression Statement [ else Statement ];\n```\n\nIn the example above the conflict occurs when the conditional statements have been already parsed and the token `else` appears next in the input. If the shift action is performed, the `else` branch will be bound to the innermost conditional statement.\n\nIf the reduce action is performed, parsing error will occur. The token `else` appears only in the production `Statement`. If the reduce action is performed each time when the token appears in the input, the parsing flow never will enter to the optional section of the `Statement` production. It follows that the token `else` will cause to parsing errors each time it appears in the input.\n\nThis conflict is resolved by binding `else` branch to the innermost conditional statement. Priorities are assigned both to the token `else` and to the nonterminal `Statement`. The priority of the token is higher that the priority of the nonterminal, which means that Shift will be performed.\n\n8.2 Reduce/Reduce Conflicts\n\nConsider the following block:\n\n```plaintext\n{\n Telephone = 123456;\n}\n```\n\nThis block statement represents an assignment expression. The identifier `Telephone` is a variable name.\n\nThe following derivation corresponds to the block statement from the example above:\n\n```plaintext\nStatement ⇒\n Assignment ; ⇒\n LeftHandSide AssignmentOperator AssignmentExpression ; ⇒\n LeftHandSide = 123456; ⇒\n Primary = 123456; ⇒\n \\{ Identifier \".\" ... \\}+ [ IdentifierSuffix ] = 123456; ⇒\n Telephone = 123456;\n```\n\nConsider another block:\n\n```plaintext\n{\n Telephone tel = 123456;\n}\n```\nThis block statement represents a declaration of a local variable `tel`. Here the identifier `Telephone` is a type name of the variable.\n\nThe following derivation corresponds to this block statement:\n\n\\[\n\\text{LocalVariableDeclarationStatement} \\Rightarrow \\\\\n[\\text{final }] \\text{Type VariableDeclarators}; \\Rightarrow \\\\\n\\text{Type} \\; \\text{tel} = 123456; \\Rightarrow \\\\\n\\text{Reference} \\; \\text{tel} = 123456; \\Rightarrow \\\\\n\\text{QualifiedIdentifier} \\; \\text{BracketsOpt} \\; \\text{tel} = 123456; \\Rightarrow \\\\\n\\{ \\text{Identifier} \\; \\text{.} \\; \\text{.} \\; \\text{.} \\}+ \\text{tel} = 123456; \\Rightarrow \\\\\n\\text{Telephone tel} = 123456;\n\\]\n\nIn the Java grammar both `Statement` and `LocalVariableDeclarationStatement` are kind of `BlockStatement`:\n\n\\[\n\\text{BlockStatement} \\rightarrow \\\\\n\\text{local decl OF LocalVariableDeclarationStatement} \\mid \\\\\n\\text{simple OF Statement};\n\\]\n\nIt means that parsing of the statements, which are described by both `Statement` and `LocalVariableDeclarationStatement` nonterminals, is started from the same parser state. These statements, as we saw in the examples above, may have the same beginning: a qualified identifier. While parsing the qualified identifier, the parsing flow will be identical for both assignment statements and local variable declarations. When the qualified identifier is parsed it can be considered as:\n\n- Variable name. The entire statement is considered as an assignment statement.\n- Type name. The entire statement is considered as a declaration of a local variable.\n\nThis ambiguity leads to the Reduce/Reduce conflict between the following productions:\n\n\\[\n\\text{Primary} \\rightarrow \\{ \\text{Identifier} \\; \\text{.} \\; \\text{.} \\; \\text{.} \\}+ \\; \\text{[ IdentifierSuffix ];} \\\\\n\\text{QualifiedIdentifier} \\rightarrow \\{ \\text{Identifier} \\; \\text{.} \\; \\text{.} \\; \\text{.} \\}+;\n\\]\n\nIf reduce by `Primary` production is performed, the identifier is considered as a variable name. If reduce by `QualifiedIdentifier` production is performed, the identifier is considered as a type name.\n\nThis conflict cannot be resolved by means of priorities and associativity, because both reduce actions may take place at parsing time. However, this conflict can be resolved by exploiting semantic information about the qualified identifier. If the identifier is a type name, one of the three following options should take place:\n\n- The identifier is a basic type name. In this case it should appear in the list of the language keywords.\n- The identifier is a name of a type that appears in one of the standard packets imported. In this case the type name can be found in the list of types that appear in the imported packet.\n- The identifier is a user-defined type name. In this case it should have already appeared in the program symbol table.\nThus, in all the cases if the identifier is a type name, it should have already been known at the current parsing step. If it is unknown, it should be interpreted as a variable name. Therefore, this conflict can be unequivocally resolved employing the semantic information enclosed in the JAVA program.\n\n8.3 Pop/Reduce Conflicts\n\nIn this section we will discuss the Pop/Reduce conflict which occurs while parsing nested JAMOOS choice expressions, and demonstrate the resolution of the conflict.\n\n8.3.1 Choice Expressions in JAMOOS\n\nConsider the following JAMOOS program which checks if a number is divisible by 5.\n\n```\nGRAMMAR DivisibleBy5()\n DivisibleBy5 → num:Number;\nFEATURES\n return := \n ||\n ||\n ||\n yes: [ printf(\"yes\") ] |\n no: [ printf(\"no\") ];\nEND;\nNumber → ⟨[1-9][0-9]*⟩;\nEND\n```\n\nThe program reads a number and stores it in the field `num` of the production `DivisibleBy5`. Then the program applies rules of divisibility by 5 and prints `yes` if the number is divisible by 5 or `no` if it is not.\n\nA number is divisible by 5 if its last digit is either 5 or 0. In order to implement these two rules choice expressions were used in the program above.\n\nThe JAMOOS choice expression allow selection among multiple choices; it is similar to alternations in regular expressions. The choices are separated from each other by a vertical bar. Each choice has a name which appears immediately to the left of the choice and is separated from it by a colon.\n\nEach choice in a choice expression may have a corresponding condition. The condition appears immediately to the left of the choice’s name and is separated from it by a question-mark. In this case the evaluation of the choice expression is similar to the one of C++ switch statement. The conditions are evaluated in order of their appearance; the first choice whose condition is true will be chosen.\n\nA last choice in a choice expression is often defined without corresponding condition. In this case the meaning of this choice is equal to the one of the default case in C++. If none of the conditions was true the last choice is chosen.\n\nThe syntax of choice expressions is described by the following production:\n\n```\nChoiceExpression → {(condition:[Expression “?”] tag:Id “:“ Expression) “|” }+;\n```\n\nChoice expressions are a kind of compound type expressions which in turn are a kind of JAMOOS expressions:\n\n70\nCompoundTypeExpression → SequenceExpression | ConstantSizeListExpression | OptionalExpression | ChoiceExpression;\nExpression → CompoundTypeExpression | TestExpression | EmbeddedCPP;\n\nIt follows from the ChoiceExpression production definition that conditions can be described by any type of JAMOOS expressions.\\textsuperscript{15} In the program above conditions corresponding to two first choices are sections of C++ code:\\textsuperscript{16}\n\n\\[\n[[ /* if the last digit of num is 5? */ ]]\n\\]\n\nand\n\n\\[\n[[ /* if the last digit of num is 0? */ ]]\n\\]\n\nIn JAMOOS sections of C++ code are surrounded by double square brackets.\n\nAnother condition from the program above is described by a choice expression, as follows:\n\n\\[\n[[ /* if the last digit of num is 5? */ ] ? t1: true |\n[[ /* if the last digit of num is 0? */ ] ? t2: true |\n\\]\n\nAssume that we would like to check if 100 is divisible by 5. When the number 100 is read JAMOOS will calculate the value of the return field in the production DivisibleBy5. For this purpose JAMOOS will evaluate the outer choice expression. It means that the first condition, which in turn is described by a choice expression, must be evaluated.\n\nIn order to evaluate the inner choice expression the first C++ code section will be executed. Since the last digit of the number 100 is not 5 JAMOOS will proceed to the second condition and will execute the second C++ code section. The last digit of the number 100 is indeed 0, therefore the choice t2, which is true, will be chosen.\n\nThe value of the outer choice expression is true and therefore the choice named yes will be chosen. This choice is described by a C++ code section that outputs yes.\n\n8.3.2 Nested Choice Expressions Conflict\n\nWhile parsing the choice expression ce from the JAMOOS program described in the Section 8.3.1, a Pop/Reduce conflict occurs. For sake of simplicity, let us denote first and second conditions in the inner choice expression of ce as c1 and c2 accordingly. Let us also denote expression t1 as e1, t2 as e2, f as e3, yes as e4 and no as e5. The outer choice expression now will look like follows:\n\n\\[\n(c1 ? t1: e1 | c2 ? t2: e2 | f: e3 ? yes: e4 | no: e5)\n\\]\n\nThere exist two different interpretations of this choice expression:\n\n\n\\textsuperscript{15}The only restriction on conditions is that they must return a boolean value.\n\\textsuperscript{16}The real C++ code which checks if the last digit of a number is 5 or 0 is omitted for sake of simplicity.\n• The inner choice expression consists of two choices: \\( c_2 \\ ? \\ t_2 \\cdot e_2 \\) and \\( f \\cdot e_3 \\). The outer choice expression consists of three choices: \\( c_1 \\ ? \\ t_1 \\cdot e_1 \\), \\( c_2 \\ ? \\ t_2 \\cdot e_2 \\) | \\( f \\cdot e_3 \\) | yes: \\( e_4 \\) and no: \\( e_5 \\).\n\nThis ambiguity comes out as a Pop/Reduce conflict at the parsing time. When a parser pops choices of the inner choice expression and reaches the choice \\( c_1 \\ ? \\ t_1 \\cdot e_1 \\), it does not know whether this choice is a part of inner or outer choice expression. In the first case the parser will continue popping the choices of the inner choice expression. It means that the choice \\( c_1 \\ ? \\ t_1 \\cdot e_1 \\) will be considered as a part of the inner choice expression. In the second case the parser will stop popping the choices of the inner choice expression, reduce choices that have been already popped, i.e., \\( c_2 \\ ? \\ t_2 \\cdot e_2 \\) and \\( f \\cdot e_3 \\), to the Expression and will continue reduction of the outer choice expression. It means that the choice \\( c_1 \\ ? \\ t_1 \\cdot e_1 \\) will be considered as a part of the outer choice expression.\n\nThe Figure 18 shows the parse tree which is derived if the Pop/Reduce conflict is resolved in favor of pop. The Figure 19 shows the parse tree which is derived if the Pop/Reduce conflict is resolved in favor of reduce.\n\nSince both resolutions are equally legitimate we should define a convention of choosing between them. We decide to choose such resolution that leads to a more compact parse tree. In our case the resolution in favor of the pop action leads to a more compact parse tree.\n\nIn order to resolve the conflict in favor of pop we should:\n1. Change the `ChoiceExpression` production so, that names will be assigned to both its list and the element of the list. For example:\n\n ```\n ChoiceExpression → choices:{elem:(condition:[Expression \"?\"] tag:Id \"::\" Expression) \"|\" ... }+;\n ```\n\n2. Assign higher priority to the element of the list as follows:\n\n ```\n PRIORITIES\n LEFT choices\n LEFT elem\n END\n ```\n\n### 8.4 Pop/Pop Conflicts\n\nIn this section a Pop/Pop conflict which occurs while parsing JAMOOS choice expressions will be discussed and the resolution of the conflict will be demonstrated. This conflict occurs as a result of an ambiguity raised by productions that describe the choice expressions and optional expressions in JAMOOS.\n\nThe Section 8.4.1 presents a brief explanation on JAMOOS optional expressions in general, and in particular on general optional expressions\\(^\\text{17}\\). The understanding of this kind of JAMOOS optional expressions is important, because the production which describes them causes the Pop/Pop conflict above. A detailed explanation on the conflict and its resolution is given in the Section 8.4.2.\n\n#### 8.4.1 Optional Expressions in JAMOOS\n\nThe JAMOOS optional expression describes an object that may or may not be created by a JAMOOS program depending on the program input. This type of JAMOOS expressions is similar to an optional section in regular expressions.\n\nThere exist several types of optional expressions. All of them, except of general optional expressions, should be embraced by square brackets. Here is an example of a production which contains optional expression in its right-hand side:\n\n ```\n Name → f:FirstName m:[MiddleName] s:SecondName;\n ```\n\nIn the production above two fields, `FirstName` and `SecondName`, are mandatory, while the field `MiddleName` may be absent. Both names, which contain a middle name, and names, which does not contain ones, will be accepted by this production. However, objects of the type `Name` that will be created in these two cases are different. If a name contains a middle name, an object \\(o_m\\) of the type `MiddleName` will be created and the field \\(m\\) of the `Name` object will be initialized by the reference to \\(o_m\\). If a name does not contain a middle name, the value of the field \\(m\\) of the `Name` object will be `NULL`.\n\nJAMOOS general optional expression describes an object which is created by a JAMOOS program if a certain condition holds. The object should be defined by a JAMOOS expression. The condition appears immediately to the left of the expression and is separated from it by a question-mark. The following production describes the syntax of general optional expressions:\n\n ```\n GeneralOptional → [Expression \"?\"] Expression;\n ```\n\n\\(^\\text{17}\\) A detailed information about JAMOOS choice expressions can be found at the Section 8.3.1\nGeneral optional expressions are a kind of optional expressions which are subtype of compound type expressions:\n\n\\[\n\\begin{align*}\n\\text{OptionalExpression} & \\rightarrow \\text{EmptyOptional} \\mid \\text{GeneralOptional}; \\\\\n\\text{CompoundTypeExpression} & \\rightarrow \\text{SequenceExpression} \\mid \\text{ConstantSizeListExpression} \\mid \\text{OptionalExpression} \\mid \\text{ChoiceExpression}; \\\\\n\\text{Expression} & \\rightarrow \\text{CompoundTypeExpression} \\mid \\text{TestExpression} \\mid \\text{EmbeddedCPP};\n\\end{align*}\n\\]\n\n### 8.4.2 Optional-Choice Conflict\n\nConsider the following JAMOOS program which checks if a number is divisible by 2:\n\n```plaintext\nGRAMMAR DivisibleBy2()\n DivisibleBy2 → num:Number;\n FEATURES\n return := ⌜ /* if the last digit of num is even? */ ⌝ ?\n yes: ⌜ printf(\"yes\") ⌝ |\n no: ⌜ printf(\"no\") ⌝;\n END;\nNumber → ⟨ [1-9][0-9]* ⟩;\nEND\n```\n\nThe number is read from the input and stored in the variable `num` of the production `DivisibleBy2`. In order to check if the number is divisible by 2 the choice expression should be evaluated. First, the condition\n\n\\[\n\\text{⌜ /* if the last digit of num is even? */ ⌝}\n\\]\n\nwill be evaluated\\(^{18}\\). If the condition holds, then the first choice named `yes` will be chosen, which means that the corresponding C++ code section will be executed and `yes` will be printed. If the condition does not holds, JAMOOS will proceed to the choice `no`, execute the corresponding C++ code and `no` will be printed.\n\nWhile parsing the choice expression from the JAMOOS program above a Pop/Pop conflict occurs.\n\nFor sake of simplicity let us denote the condition as `c`, the choices `yes` and `no` as `e1` and `e2` accordingly. Then the choice expression will look as follows:\n\n\\[\nc \\ ? \\ yes:e1 \\mid no:e2\n\\]\n\nThere exist two interpretations of the expression above:\n\n- Choice expression that consists of two choices: `c ? yes:e1` and `no:e2`.\n- General optional expression in which `c` is a condition and `yes:e1 | no:e2` is an optional expression.\n\n\\(^{18}\\)The real C++ code which checks if the last digit of a number is even is omitted for sake of simplicity.\nConsider a production that describes JAMOOS choice expressions:\n\n```\nChoiceExpression → choices:{elem:(condition:[Expression \"?\"] tag:Id \":\" Expression) \"|\" ... }+;\n```\n\nThe optional condition `Expression \"?\"` is treated by JAMOOS as the following alternation:\n\n```\nExpression \"?\" | \n```\n\nThe symbol `__` in JAMOOS stands for an empty string. The alternation above means that in the input may appear either `Expression \"?\"` or nothing.\n\nWhile parsing the expression `c ? yes:e1 | no:e2` both alternatives can be popped. If the alternative `Expression \"?\"` is popped, the string `c ?` is interpreted as a part of the choice expression. It means the the whole expression is considered as a choice expression. The corresponding parse tree is shown in Figure 20.\n\nIf the empty alternative is popped, the whole expression is considered as a general optional expression. The corresponding parse tree is shown in Figure 21.\n\nSince both resolutions are equally legitimate we choose one that leads to more compact parse tree. It means that the conflict will be resolved in favor of the non-empty alternative.\n\nIn order to resolve the conflict the following steps should be performed:\n1. The optional section in the production `ChoiceExpression` should be rewritten as an alternation as follows:\n\n \\[\n \\text{ChoiceExpression} \\rightarrow \\text{choices:}\n \\begin{cases}\n \\text{elem:(condition:(Expression \"?\" | _)}\n \\\t\\text{tag:Id \"::\" Expression) }^*\\|... \\}\\};\n \\end{cases}\n \\]\n\n2. Priority groups should be defined for the alternatives so that the priority of the non-empty alternative will be higher than the priority of the empty one. The resulting production will look as follows:\n\n \\[\n \\text{ChoiceExpression} \\rightarrow \\text{choices:}\n \\begin{cases}\n \\text{elem:(condition:(Expression \"?\" \\| _)}\n \\\t\\text{tag:Id \"::\" Expression) }^*\\|... \\}\\};\n \\end{cases}\n \\]\n\n9 Conclusions\n\nIn this thesis we continue working on programming language JAMOOS that was defined by Tsoglin [31].\n\nJAMOOS was extended for resolving Shift/Reduce and Reduce/Reduce conflicts while generating a parser for a given grammar. The algorithm for Shift/Reduce and Reduce/Reduce conflicts resolution based on priorities and associativity was proposed.\n\nThe current JAMOOS's grammar was extended by a production that determines the syntax of a specific JAMOOS program section called \"Priorities Section\". In this section a user can assign priorities and associativity to tokens and nonterminal grammar symbols.\n\nIt was shown that assigning a priority to a token basing on the priority of a production that contains the token is essential for resolving Shift/Reduce conflicts. Since more than one production may contain the token, the parser should determine which particular production is applicable at the given stage of the parsing process. In most cases, the applicable production can be determined at the stage of the parser generation employing the priorities defined by the user and the set of LR-items of the grammar. However, in some cases a next input token should be known to determine the applicable production. The JAMOOS was extended to generate parsers that contain built-in mechanism that determines at run time which production is applicable at the current stage of parsing process.\n\nReferences\n\n\nA JAVA Language Grammar\n\nGRAMMAR CompilationUnit ()\n\nPRIORITIES\nLEFT Statement BracketsOpt ModifiersOpt\nLEFT final synchronized public protected private static abstract native\n transient volatile strictfp \"\\\" else\nRIGHT AssignmentExpression\nRIGHT ConditionalExpression\nLEFT ConditionalOrExpression\nLEFT ConditionalAndExpression\nLEFT InclusiveOrExpression\nLEFT ExclusiveOrExpression\nLEFT AndExpression\nLEFT EqualityExpression\nLEFT RelationalExpression\nLEFT ShiftExpression\nLEFT AdditiveExpression\nLEFT MultiplicativeExpression\nRIGHT PrefixUnaryExpression\nLEFT PostfixUnaryExpression\nEND\n\nQualifiedIdentifier →\n { Identifier \".\" .. }+ ;\n\nLiteral →\n IntegerLiteral |\n FloatingPointLiteral |\n CharacterLiteral |\n StringLiteral |\n BooleanLiteral |\n NullLiteral ;\n\nIntegerLiteral →\n DecimalIntegerLiteral |\n HexIntegerLiteral |\n OctalIntegerLiteral;\n\nDecimalIntegerLiteral → DecimalNumeral;\n\nHexIntegerLiteral → HexNumeral;\n\nOctalIntegerLiteral → OctalNumeral;\n\nBooleanLiteral → tr OF true | fls OF false;\n\nCharacterLiteral → SingleCharacter | EscapeSequence;\n\n79\nNullLiteral -> null;\n\nExpression -> AssignmentExpression | ConditionalExpression | ConditionalOrExpression | ConditionalAndExpression | InclusiveOrExpression | ExclusiveOrExpression | AndExpression | EqualityExpression | RelationalExpression | ShiftExpression | CastExpression | PrefixUnaryExpression | PostfixUnaryExpression;\n\nAssignmentExpression -> LeftHandSide\n equal OF \"=\" |\n plus_eq OF \"+=\" |\n minus_eq OF \"+-=\" |\n mult_eq OF \"**=\" |\n div_eq OF \"/=\" |\n and_eq OF \"/&=\" |\n or_eq OF \"/|=\" |\n xor_eq OF \"/^=\" |\n mod_eq OF \"/%=\" |\n shift_left_eq OF \"<<=\" |\n shift_right_eq OF \">>=\" |\n zero_ext_eq OF \">>>=\" Expression;\n\nLeftHandSide -> Primary { Selector . . . };\n\nConditionalExpression -> Expression \"?\" Expression \":\" Expression;\n\nConditionalOrExpression -> Expression \"||\" Expression;\n\nConditionalAndExpression -> Expression \"&&\" Expression;\n\nInclusiveOrExpression -> Expression \"|\" Expression;\n\nExclusiveOrExpression -> Expression \"^\" Expression;\n\nAndExpression -> Expression \"&\" Expression;\n\nEqualityExpression -> Expression equal OF \"==\" | not_equal OF \"!=\" Expression;\n\nRelationalExpression -> relational OF (Expression less OF \"<\" | more OF \">\" | less_eq OF \"<=\" | more_eq OF \">=\") Expression) |\ninstanceof OF (Expression instanceof Type) ;\n\nShiftExpression → Expression\nshift_left OF \"<<\" |\nshift_right OF \">>\" |\nzero_ext OF \">>>\"\nExpression;\n\nAdditiveExpression → Expression plus OF \"+\" | minus OF \"-\" Expression;\n\nMultiplicativeExpression → Expression\nmult OF \"*\" |\ndiv OF \"/\" |\nmod OF \"%\"\nExpression;\n\nPrefixUnaryExpression → inc OF \"++\" |\ndec OF \"--\" |\nlogical_compliment OF \"!\" |\nbitwise_compliment OF \"~\" |\nplus OF \"++\" |\nminus OF \"--\"\nExpression;\n\nPostfixUnaryExpression → primary OF Primary |\nicdec OF (Expression inc OF \"++\" | dec OF \"--\");\n\nCastExpression → \"(\" Type \")\" Expression;\n\nType → (reference OF QualifiedIdentifier | basic OF Basic) BracketsOpt ;\n\nBasic → BasicType ;\n\nStatementExpression → Expression ;\n\nConstantExpression → Expression ;\n\nSelector →\nid OF (\".\" Identifier [ Arguments ]) |\nthis_ OF (\".\" this) |\nsuper OF (\".\" super SuperSuffix) |\ncreation OF (\".\" new InnerCreator) |\nexpr OF (\"[\" Expression \"]\") ;\n\nPrimary →\nparenthesized OF (\"(\" Expression \")\") |\nthis_token OF (this [ Arguments ]) |\nsuper_token OF (super SuperSuffix) |\nliteral OF Literal |\ninstance_creation OF (new Creator) |\nreference OF ([ Identifier \".\" \".\" ]+ [ IdentifierSuffix ]) |\nclass_literals OF (Type BracketsOpt \".\" class) |\nvoid_class_literals OF (void \".\" class) ;\n\nIdentifierSuffix →\nbrackets_expr -> [ \"[\" empty_brackets_and_class OF [ \"[\" BracketsOpt \"]\" class ] ] | array_init OF { Expression \"\"] } ] |\narguments OF Arguments |\nspecified OF [ \":\" class OF class ] |\nthis_ OF this |\nsuper OF super Arguments |\ncreation OF new InnerCreator ] ;\n\nSuperSuffix -> \narg OF Arguments |\nqualified superclass method OF [ \":\" Identifier [ Arguments ] ] ;\n\nBasicType -> \nbyte_ OF byte |\nshort_ OF short |\nchar_ OF char |\nint_ OF int |\nlong_ OF long |\nfloat_ OF float |\ndouble_ OF double |\nboolean_ OF boolean ;\n\nArgumentsOpt -> [ Arguments ] ;\n\nArguments -> [ \"(\" { Expression \":\" ... } \")\" ] ;\n\nBracketsOpt -> [ \"[\" ... ] ;\n\nCreator -> Type |\n(array_creator OF ArrayCreatorRest | class_creator OF ClassCreatorRest) ;\n\nInnerCreator -> Identifier ClassCreatorRest ;\n\nArrayCreatorRest -> [ \"[\" |\narray_init OF [ \"[\" BracketsOpt ArrayInitializer ] ] |\nexpr_in_brackets OF { Expression \"\"] } [ [ \":\" Expression \"]\" ] ... } BracketsOpt ;\n\nClassCreatorRest -> Arguments [ ClassBody ] ;\n\nArrayInitializer -> [ [ \"[\" VariableInitializer \":\" ... ] [ : ] ] ] ;\n\nVariableInitializer -> |\nArrayInitializer |\nExpressionInitializer ;\n\nParExpression -> [ \"(\" Expression \")\" ] ;\n\nBlock -> [ \"{\" BlockStatements \"}\" ] ;\n\nBlockStatements -> [ BlockStatement ... ];\nBlockStatement →\n local decl OF LocalVariableDeclarationStatement |\n class_or_interface decl OF ClassOrInterfaceDeclaration |\n simple OF Statement;\n\nLocalVariableDeclarationStatement → [ final ] Type VariableDeclarators \";\" ;\n\nStatement →\n block OF Block |\n if_stmt OF (if ParExpression Statement [ else Statement ]) |\n for_stmt OF (for \"(\" [ ForInit ] \";\" [ Expression ] \";\" [ ForUpdate ] \")\" Statement) |\n while_stmt OF (while ParExpression Statement) |\n repeat_stmt OF (do Statement while ParExpression \";\") |\n try_stmt OF (try Block without_fin OF Catches | with_fin OF ([ Catches ] finally Block)) |\n switch_stmt OF (switch ParExpression \"(\" SwitchBlockStatementGroups \")\") |\n synchro_stmt OF (synchronized ParExpression Block) |\n return_stmt OF (return [ Expression ] \";\") |\n throw_stmt OF (throw Expression \";\") |\n break_stmt OF (break [ Identifier ] \";\") |\n continue_stmt OF (continue [ Identifier ] \";\") |\n empty_stmt OF \";\" |\n expr_stmt OF (ExpressionStatement \";\") |\n labeled_stmt OF (Identifier \";\" Statement) ;\n\nExpressionStatement → StatementExpression ;\n\nCatches → { CatchClause ... }+ ;\n\nCatchClause → catch \"(\" FormalParameter \")\" Block ;\n\nSwitchBlockStatementGroups → { SwitchBlockStatementGroup ... } ;\n\nSwitchBlockStatementGroup → SwitchLabel BlockStatements ;\n\nSwitchLabel →\n regular_case OF (case ConstantExpression \";\") |\n default_case OF (default \";\") ;\n\nForInit →\n statements OF { StatementExpression \";\" ... }+ |\n finalized OF ([ [ final ] Type VariableDeclarators] ) ;\n\nForUpdate → { StatementExpression \";\" ... }+ ;\n\nModifiersOpt → { Modifier ... } ;\n\nModifier →\n pub OF public |\n prot OF protected |\n priv OF private |\n stat OF static |\n abstract OF abstract |\n final OF final |\n native OF native |\n synchro OF synchronized |\ntransient OF transient | volatile OF volatile | strictfp OF strictfp ;\n\nVariableDeclarators → { VariableDeclarator “,” ... }+ ;\n\nConstantDeclaratorsRest → ConstantDeclaratorRest { (“,” ConstantDeclarator) ... } ;\n\nVariableDeclarator → Identifier VariableDeclaratorRest ;\n\nConstantDeclarator → Identifier ConstantDeclaratorRest ;\n\nVariableDeclaratorRest → BracketsOpt [ “=” VariableInitializer ] ;\n\nConstantDeclaratorRest → BracketsOpt “=” VariableInitializer ;\n\nVariableDeclaratorId → Identifier BracketsOpt ;\n\nCompilationUnit → [ package QualifiedIdentifier “;” ] { ImportDeclaration ... } { TypeDeclaration ... } ;\n\nImportDeclaration → import { Identifier “,” ... }+ [ “,” “*” ] “;” ;\n\nTypeDeclaration → class_or_interface OF ClassOrInterfaceDeclaration | empty OF “;” ;\n\nClassOrInterfaceDeclaration → ModifiersOpt\nclass_decl OF ClassDeclaration | infrf_decl OF InterfaceDeclaration ;\n\nClassDeclaration → class Identifier [ extends Type ] [ implements TypeList ] ClassBody ;\n\nInterfaceDeclaration → interface Identifier [ extends TypeList ] InterfaceBody ;\n\nTypeList → { Type “,” ... }+ ;\n\nClassBody → “{” { ClassBodyDeclaration ... } “}” ;\n\nInterfaceBody → “{” { InterfaceBodyDeclaration ... } “}” ;\n\nClassBodyDeclaration → empty OF “;” |\nblock OF ([ static ] Block) |\nmember_decl OF (ModifiersOpt MemberDecl) ;\n\nMemberDecl → method_or_field OF MethodOrFieldDecl |\nvoid_return OF (void Identifier MethodDeclaratorRest) |\nctor_decl OF (Identifier ConstructorDeclaratorRest) |\nclass_or_interface OF ClassOrInterfaceDeclaration ;\n\nMethodOrFieldDecl → Type Identifier MethodOrFieldRest ;\nMethodOrFieldRest →\n var decl OF (VariableDeclaratorRest “;”) |\n method decl OF MethodDeclaratorRest ;\n\nInterfaceBodyDeclaration →\n empty OF “;” |\n member decl OF (ModifiersOpt InterfaceMemberDecl) ;\n\nInterfaceMemberDecl →\n method_or_field OF InterfaceMethodOrFieldDecl |\n void_return OF (void Identifier VoidInterfaceMethodDeclaratorRest) |\n class_or_interface OF ClassOrInterfaceDeclaration ;\n\nInterfaceMethodOrFieldDecl → Type Identifier InterfaceMethodOrFieldRest ;\n\nInterfaceMethodOrFieldRest →\n constants OF (ConstantDeclaratorsRest “;”) |\n methods OF InterfaceMethodDeclaratorRest ;\n\nMethodDeclaratorRest →\n FormalParameters BracketsOpt [ throws QualifiedIdentifierList ]\n ( body OF MethodBody | empty_body OF “;” ) ;\n\nInterfaceMethodDeclaratorRest → FormalParameters BracketsOpt [ throws QualifiedIdentifierList ] “;” ;\n\nVoidInterfaceMethodDeclaratorRest → FormalParameters [ throws QualifiedIdentifierList ] “;” ;\n\nConstructorDeclaratorRest → FormalParameters [ throws QualifiedIdentifierList ] MethodBody ;\n\nQualifiedIdentifierList → { QualifiedIdentifier “;” ... }+ ;\n\nFormalParameters → (“” { FormalParameter “;” ... } “)” ;\n\nFormalParameter → [final] Type VariableDeclaratorId ;\n\nMethodBody → Block ;\n\nIdentifier → ([a-zA-Z0-9]*) ;\n\nDecimalNumeral → (0)([1-9][0-9]*) ;\n\nHexNumeral → (0)(x)(X)([0-9a-fA-F]*) ;\n\nOctalNumeral → (0[0-7]*) ;\n\nDigits → ([0-9]*) ;\n\nSingleCharacter → (\"[\"\\]\\]) ;\n\nEscapeSequence → (\\b)(\\f)(\\n)(\\r)(\\t)(\\\\)(\\\\)(\\\\[0-7])(\\\\[0-7][0-7])(\\\\[0-3][0-7][0-7]) ;\nStringLiteral \\rightarrow \\langle (([^\\\"]\\|/(\\\\))*)\\rangle;"}}},{"rowIdx":157,"cells":{"id":{"kind":"string","value":"d58079d12a10b5fff78745974efa8547bea87174"},"text":{"kind":"string","value":"Abstract\n\nThis document provides information on how to use Service Mesh in OpenShift Container Platform\nTable of Contents\n\nCHAPTER 1. SERVICE MESH RELEASE NOTES .................................................. 6\n1.1. RED HAT OPENS SHIFT SERVICE MESH OVERVIEW .................. 6\n1.2. GETTING SUPPORT ........................................................................... 6\n1.3. RED HAT OPENS SHIFT SERVICE MESH SUPPORTED CONFIGURATIONS .... 6\n 1.3.1. Supported configurations for Kiali on Red Hat OpenShift Service Mesh .......... 7\n 1.3.2. Supported Mixer adapters ................................................................. 7\n 1.3.3. Component versions included in Red Hat OpenShift Service Mesh version 1.1.1 ... 7\n 1.3.4. New features Red Hat OpenShift Service Mesh 1.1.1 ........................... 8\n 1.3.5. New features Red Hat OpenShift Service Mesh 1.1.0 ........................... 8\n 1.3.6. New features Red Hat OpenShift Service Mesh 1.0.10 ......................... 8\n 1.3.7. New features Red Hat OpenShift Service Mesh 1.0.9 ........................... 8\n 1.3.8. New features Red Hat OpenShift Service Mesh 1.0.8 ........................... 8\n 1.3.9. New features Red Hat OpenShift Service Mesh 1.0.7 ........................... 8\n 1.3.10. New features Red Hat OpenShift Service Mesh 1.0.6 ......................... 8\n 1.3.11. New features Red Hat OpenShift Service Mesh 1.0.5 ........................... 8\n 1.3.12. New features Red Hat OpenShift Service Mesh 1.0.4 ........................... 8\n 1.3.13. New features Red Hat OpenShift Service Mesh 1.0.3 ........................... 8\n 1.3.14. New features Red Hat OpenShift Service Mesh 1.0.2 ........................... 8\n 1.3.15. New features Red Hat OpenShift Service Mesh 1.0.1 ........................... 9\n 1.3.16. New features Red Hat OpenShift Service Mesh 1.0 ........................... 9\n1.4. KNOWN ISSUES .............................................................................. 9\n 1.4.1. Service Mesh known issues ................................................................. 9\n 1.4.2. Kiali known issues ......................................................................... 10\n 1.4.3. Jaeger known issues ...................................................................... 10\n1.5. FIXED ISSUES .................................................................................. 11\n 1.5.1. Service Mesh fixed issues ................................................................. 11\n 1.5.2. Kiali fixed issues ........................................................................... 12\n\nCHAPTER 2. SERVICE MESH ARCHITECTURE ................................................. 13\n2.1. UNDERSTANDING RED HAT OPENS SHIFT SERVICE MESH ............. 13\n 2.1.1. Understanding service mesh ............................................................... 13\n 2.1.2. Red Hat OpenShift Service Mesh Architecture ................................. 13\n 2.1.3. Red Hat OpenShift Service Mesh control plane ................................. 14\n 2.1.4. Multi-tenancy in Red Hat OpenShift Service Mesh versus cluster-wide installations ........................................................................................................... 14\n 2.1.5. Automatic injection ......................................................................... 15\n 2.1.6. Istio Role Based Access Control features ......................................... 15\n 2.1.7. OpenSSL ......................................................................................... 16\n 2.1.8. The Istio Container Network Interface (CNI) plug-in ........................... 16\n 2.1.9. Envoy, Secret Discovery Service, and Certificates ............................ 16\n2.2. KIALI OVERVIEW ............................................................................ 16\n 2.2.1. Kiali overview ............................................................................... 16\n 2.2.2. Kiali architecture ......................................................................... 17\n 2.2.3. Kiali features ................................................................................. 17\n2.3. UNDERSTANDING JAEGER ................................................................. 18\n 2.3.1. Jaeger overview ........................................................................... 18\n 2.3.2. Jaeger architecture ....................................................................... 18\n 2.3.3. Jaeger features ............................................................................. 19\n2.4. COMPARING SERVICE MESH AND ISTIO .......................................... 19\n 2.4.1. Red Hat OpenShift Service Mesh control plane ................................. 19\n 2.4.2. Multi-tenancy in Red Hat OpenShift Service Mesh versus cluster-wide installations ........................................................................................................... 19\n 2.4.3. Automatic injection ........................................................................ 19\n2.4.4. Istio Role Based Access Control features\n2.4.5. OpenSSL\n2.4.6. The Istio Container Network Interface (CNI) plug-in\n2.4.7. Envoy, Secret Discovery Service, and Certificates\n2.4.8. Kiali and service mesh\n2.4.9. Jaeger and service mesh\n\nCHAPTER 3. SERVICE MESH INSTALLATION\n\n3.1. PREPARING TO INSTALL RED HAT OPENSOURCE SERVICE MESH\n3.1.1. Red Hat OpenShift Service Mesh supported configurations\n 3.1.1.1. Supported configurations for Kiali on Red Hat OpenShift Service Mesh\n 3.1.1.2. Supported Mixer adapters\n3.1.2. Red Hat OpenShift Service Mesh installation activities\n\n3.2. INSTALLING RED HAT OPENSOURCE SERVICE MESH\n3.2.1. Installing the Operators from OperatorHub\n 3.2.1.1. Installing the Elasticsearch Operator\n 3.2.1.2. Installing the Jaeger Operator\n 3.2.1.3. Installing the Kiali Operator\n 3.2.1.4. Installing the Red Hat OpenShift Service Mesh Operator\n 3.2.1.5. Deploying the Red Hat OpenShift Service Mesh control plane\n 3.2.1.5.1. Deploying the control plane from the web console\n 3.2.1.5.2. Deploying the control plane from the CLI\n 3.2.1.6. Creating the Red Hat OpenShift Service Mesh member roll\n 3.2.1.6.1. Creating the member roll from the web console\n 3.2.1.6.2. Creating the member roll from the CLI\n 3.2.1.7. Creating the Red Hat OpenShift Service Mesh members\n 3.2.1.8. Deleting the Red Hat OpenShift Service Mesh member roll\n3.2.2. Updating your application pods\n\n3.3. CUSTOMIZING THE RED HAT OPENSOURCE SERVICE MESH INSTALLATION\n3.3.1. Red Hat OpenShift Service Mesh custom resources\n3.3.2. ServiceMeshControlPlane parameters\n 3.3.2.1. Istio global example\n 3.3.2.2. Istio gateway configuration\n 3.3.2.3. Istio Mixer configuration\n 3.3.2.4. Istio Pilot configuration\n3.3.3. Configuring Kiali\n 3.3.3.1. Configuring Kiali for Grafana\n 3.3.3.2. Configuring Kiali for Jaeger\n3.3.4. Configuring Jaeger\n 3.3.4.1. Configuring Elasticsearch\n3.3.5. 3scale configuration\n\n3.4. UPDATING RED HAT OPENSOURCE SERVICE MESH\n3.4.1. Manual updates\n\n3.5. REMOVING RED HAT OPENSOURCE SERVICE MESH\n3.5.1. Removing the Red Hat OpenShift Service Mesh control plane\n 3.5.1.1. Removing the control plane with the web console\n 3.5.1.2. Removing the control plane from the CLI\n3.5.2. Removing the installed Operators\n 3.5.2.1. Removing the Red Hat OpenShift Service Mesh Operator\n 3.5.2.2. Removing the Jaeger Operator\n3.5.2.3. Removing the Kiali Operator\n3.5.2.4. Removing the Elasticsearch Operator\n3.5.2.5. Clean up Operator resources\n\nCHAPTER 4. DAY TWO\n4.1. DEPLOYING APPLICATIONS ON RED HAT OPENSHIFT SERVICE MESH\n4.1.1. Creating control plane templates\n4.1.1.1. Creating the ConfigMap\n4.1.2. Red Hat OpenShift Service Mesh’s sidecar injection\n4.1.2.1. Enabling automatic sidecar injection\n4.1.2.2. Updating Mixer policy enforcement\n4.1.3. Setting the correct network policy\n4.2. CONFIGURING YOUR SERVICE MESH FOR DISTRIBUTED TRACING\n4.2.1. Configuring the Elasticsearch index cleaner job\n4.3. EXAMPLE APPLICATION\n4.3.1. Bookinfo application\n4.3.2. Installing the Bookinfo application\n4.3.3. Adding default destination rules\n4.3.4. Verifying the Bookinfo installation\n4.3.5. Removing the Bookinfo application\n4.3.5.1. Delete the Bookinfo project\n4.3.5.2. Remove the Bookinfo project from the Service Mesh member roll\n4.4. KIALI TUTORIAL\n4.4.1. Accessing the Kiali console\n4.4.2. Exploring the Graph page\n4.4.3. Exploring the Applications page\n4.4.4. Exploring the Workloads page\n4.4.5. Exploring the Services page\n4.4.6. Exploring the Istio Config page\n4.5. DISTRIBUTED TRACING TUTORIAL\n4.5.1. Generating traces and analyzing trace data\n4.6. AUTOMATIC ROUTE CREATION\n4.6.1. Enabling Automatic Route Creation\n\nCHAPTER 5. SUPPORT\n5.1. COLLECTING RED HAT OPENSHIFT SERVICE MESH DATA FOR RED HAT SUPPORT\n5.1.1. About the must-gather tool\n5.1.2. About collecting service mesh data\n\nCHAPTER 6. 3SCALE ADAPTER\n6.1. USING THE 3SCALE ISTIO ADAPTER\n6.1.1. Integrate the 3scale adapter with Red Hat OpenShift Service Mesh\n6.1.1.1. Generating 3scale custom resources\n6.1.1.2. Generate templates from URL examples\n6.1.1.3. Generating manifests from a deployed adapter\n6.1.1.4. Routing service traffic through the adapter\n6.1.2. Configure the integration settings in 3scale\n6.1.3. Caching behavior\n6.1.4. Authenticating requests\n6.1.4.1. Applying authentication patterns\n6.1.4.1.1. API key authentication method\n6.1.4.1.2. Application ID and application key pair authentication method\n6.1.4.1.3. OpenID authentication method\n6.1.4.1.4. Hybrid authentication method\n6.15. 3scale Adapter metrics\nCHAPTER 1. SERVICE MESH RELEASE NOTES\n\n1.1. RED HAT OPENSSHIFT SERVICE MESH OVERVIEW\n\nRed Hat OpenShift Service Mesh is a platform that provides behavioral insight and operational control over the service mesh, providing a uniform way to connect, secure, and monitor microservice applications.\n\nThe term service mesh describes the network of microservices that make up applications in a distributed microservice architecture and the interactions between those microservices. As a service mesh grows in size and complexity, it can become harder to understand and manage.\n\nBased on the open source Istio project, Red Hat OpenShift Service Mesh adds a transparent layer on existing distributed applications without requiring any changes to the service code. You add Red Hat OpenShift Service Mesh support to services by deploying a special sidecar proxy throughout your environment that intercepts all network communication between microservices. You configure and manage the service mesh using the control plane features.\n\nRed Hat OpenShift Service Mesh provides an easy way to create a network of deployed services that provides discovery, load balancing, service-to-service authentication, failure recovery, metrics, and monitoring. A service mesh also provides more complex operational functionality, including A/B testing, canary releases, rate limiting, access control, and end-to-end authentication.\n\n1.2. GETTING SUPPORT\n\nIf you experience difficulty with a procedure described in this documentation, visit the Red Hat Customer Portal at http://access.redhat.com. Through the customer portal, you can:\n\n- Search or browse through the Red Hat Knowledgebase of technical support articles about Red Hat products\n- Submit a support case to Red Hat Global Support Services (GSS)\n- Access other product documentation\n\nIf you have a suggestion for improving this guide or have found an error, please submit a Bugzilla report at http://bugzilla.redhat.com against Product for the Documentation component. Please provide specific details, such as the section number, guide name, and Service Mesh version so we can easily locate the content.\n\n1.3. RED HAT OPENSHEET SERVICE MESH SUPPORTED CONFIGURATIONS\n\nThe following are the only supported configurations for the Red Hat OpenShift Service Mesh:\n\n- Red Hat OpenShift Container Platform version 4.x.\n\nNOTE\n\nOpenShift Online and OpenShift Dedicated are not supported for Red Hat OpenShift Service Mesh 1.1.1.\n- The deployment must be contained to a single OpenShift Container Platform cluster that is not federated.\n\n- This release of Red Hat OpenShift Service Mesh is only available on OpenShift Container Platform x86_64.\n\n- This release only supports configurations where all Service Mesh components are contained in the OpenShift cluster in which it operates. It does not support management of microservices that reside outside of the cluster, or in a multi-cluster scenario.\n\n- This release only supports configurations that do not integrate external services such as virtual machines.\n\n### 1.3.1. Supported configurations for Kiali on Red Hat OpenShift Service Mesh\n\n- The Kiali observability console is only supported on the two most recent releases of the Chrome, Edge, Firefox, or Safari browsers.\n\n### 1.3.2. Supported Mixer adapters\n\n- This release only supports the following Mixer adapter:\n - 3scale Istio Adapter\n\nRed Hat OpenShift Service Mesh provides a number of key capabilities uniformly across a network of services:\n\n- **Traffic Management** - Control the flow of traffic and API calls between services, make calls more reliable, and make the network more robust in the face of adverse conditions.\n\n- **Service Identity and Security** - Provide services in the mesh with a verifiable identity and provide the ability to protect service traffic as it flows over networks of varying degrees of trustworthiness.\n\n- **Policy Enforcement** - Apply organizational policy to the interaction between services, ensure access policies are enforced and resources are fairly distributed among consumers. Policy changes are made by configuring the mesh, not by changing application code.\n\n- **Telemetry** - Gain understanding of the dependencies between services and the nature and flow of traffic between them, providing the ability to quickly identify issues.\n\n### 1.3.3. Component versions included in Red Hat OpenShift Service Mesh version 1.1.1\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Version</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Istio</td>\n<td>1.4.6</td>\n</tr>\n<tr>\n<td>Jaeger</td>\n<td>1.17.1</td>\n</tr>\n<tr>\n<td>Kiali</td>\n<td>1.12.7</td>\n</tr>\n<tr>\n<td>3scale Istio Adapter</td>\n<td>1.0.0</td>\n</tr>\n</tbody>\n</table>\n1.3.4. New features Red Hat OpenShift Service Mesh 1.1.1\nThis release of Red Hat OpenShift Service Mesh adds support for a disconnected installation.\n\n1.3.5. New features Red Hat OpenShift Service Mesh 1.1.0\nThis release of Red Hat OpenShift Service Mesh adds support for Istio 1.4.6 and Jaeger 1.17.1.\n\n1.3.6. New features Red Hat OpenShift Service Mesh 1.0.10\nThis release of Red Hat OpenShift Service Mesh addresses Common Vulnerabilities and Exposures (CVEs).\n\n1.3.7. New features Red Hat OpenShift Service Mesh 1.0.9\nThis release of Red Hat OpenShift Service Mesh addresses Common Vulnerabilities and Exposures (CVEs).\n\n1.3.8. New features Red Hat OpenShift Service Mesh 1.0.8\nThis release of Red Hat OpenShift Service Mesh addresses compatibility issues with OpenShift Container Platform 4.4. You must upgrade Red Hat OpenShift Service Mesh to 1.0.8 before you upgrade from OpenShift Container Platform 4.3 to OpenShift Container Platform 4.4.\n\n1.3.9. New features Red Hat OpenShift Service Mesh 1.0.7\nThis release of Red Hat OpenShift Service Mesh addresses Common Vulnerabilities and Exposures (CVEs).\n\n1.3.10. New features Red Hat OpenShift Service Mesh 1.0.6\nThis release contains internal improvements.\n\n1.3.11. New features Red Hat OpenShift Service Mesh 1.0.5\nThis release contains internal improvements.\n\n1.3.12. New features Red Hat OpenShift Service Mesh 1.0.4\nThis release of Red Hat OpenShift Service Mesh adds support for Kiali 1.0.9, and addresses Common Vulnerabilities and Exposures (CVEs).\n\n1.3.13. New features Red Hat OpenShift Service Mesh 1.0.3\nThis release of Red Hat OpenShift Service Mesh adds support for Kiali 1.0.8, and addresses Common Vulnerabilities and Exposures (CVEs).\n\n1.3.14. New features Red Hat OpenShift Service Mesh 1.0.2\nThis release of Red Hat OpenShift Service Mesh adds support for Istio 1.1.17, Jaeger 1.13.1, Kiali 1.0.7, and the 3scale Istio Adapter 1.0 and OpenShift Container Platform 4.2.\n1.3.15. New features Red Hat OpenShift Service Mesh 1.0.1\n\nThis release of Red Hat OpenShift Service Mesh adds support for Istio 1.1.11, Jaeger 1.13.1, Kiali 1.0.6, and the 3scale Istio Adapter 1.0 and OpenShift Container Platform 4.1.\n\n1.3.16. New features Red Hat OpenShift Service Mesh 1.0\n\nThis release of Red Hat OpenShift Service Mesh adds support for Istio 1.1.11, Jaeger 1.13.1, Kiali 1.0.5, and the 3scale Istio Adapter 1.0 and OpenShift Container Platform 4.1.\n\nOther notable changes in this release include the following:\n\n- The Kubernetes Container Network Interface (CNI) plug-in is always on.\n- The control plane is configured for multitenancy by default. Single tenant, cluster-wide control plane configurations are deprecated.\n- The Elasticsearch, Jaeger, Kiali, and Service Mesh Operators are installed from OperatorHub.\n- You can create and specify control plane templates.\n- Automatic route creation was removed from this release.\n\n1.4. KNOWN ISSUES\n\nThese limitations exist in Red Hat OpenShift Service Mesh:\n\n- **Red Hat OpenShift Service Mesh does not support IPv6**, as it is not supported by the upstream Istio project, nor fully supported by OpenShift.\n\n- **Graph layout** - The layout for the Kiali graph can render differently, depending on your application architecture and the data to display (number of graph nodes and their interactions). Because it is difficult if not impossible to create a single layout that renders nicely for every situation, Kiali offers a choice of several different layouts. To choose a different layout, you can choose a different **Layout Schema** from the **Graph Settings** menu.\n\n1.4.1. Service Mesh known issues\n\nThese are the known issues in Red Hat OpenShift Service Mesh:\n\n- **Bug 1821432** Toggle controls in OpenShift Container Platform Control Resource details page do not update the CR correctly. UI Toggle controls in the Service Mesh Control Plane (SMCP) Overview page in the OpenShift Container Platform web console sometimes update the wrong field in the resource. To update a SMCP, edit the YAML content directly or update the resource from the command line instead of clicking the toggle controls.\n\n- **Jaeger/Kiali Operator upgrade blocked with operator pending** When upgrading the Jaeger or Kiali Operators with Service Mesh 1.0.x installed, the operator status shows as Pending. There is a solution in progress and a workaround. See the linked Knowledge Base article for more information.\n\n- **Istio-14743** Due to limitations in the version of Istio that this release of Red Hat OpenShift Service Mesh is based on, there are several applications that are currently incompatible with Service Mesh. See the linked community issue for details.\n• **MAISTA-858** The following Envoy log messages describing deprecated options and configurations associated with Istio 1.1.x are expected:\n \n 1. [2019-06-03 07:03:28.943][19][warning][misc]\n [external/envoy/source/common/protobuf/utility.cc:129] Using deprecated option 'envoy.api.v2.listener.Filter.config'. This configuration will be removed from Envoy soon.\n \n 2. [2019-08-12 22:12:59.001][13][warning][misc]\n [external/envoy/source/common/protobuf/utility.cc:174] Using deprecated option 'envoy.api.v2.Listener.use_original_dst' from file lds.proto. This configuration will be removed from Envoy soon.\n \n• **MAISTA-681** and **KIALI-2686** When the control plane has many namespaces, it can lead to performance issues.\n \n• **MAISTA-465** The Maistra operator fails to create a service for operator metrics.\n \n• **MAISTA-453** If you create a new project and deploy pods immediately, sidecar injection does not occur. The operator fails to add the maistra.io/member-of before the pods are created, therefore the pods must be deleted and recreated for sidecar injection to occur.\n \n• **MAISTA-193** Unexpected console info messages are visible when health checking is enabled for citadel.\n\n• **MAISTA-158** Applying multiple gateways referencing the same hostname will cause all gateways to stop functioning.\n \n• **MAISTA-806** Evicted Istio Operator Pod causes mesh and CNI not to deploy. If the istio-operator pod is evicted while deploying the control pane, delete the evicted istio-operator pod.\n\n### 1.4.2. Kiali known issues\n\nThese are the known issues in Kiali:\n\n• **KIALI-3262** In the Kiali console, when you click on Distributed Tracing in the navigation or on a Traces tab, you are asked to accept the certificate, and then asked to provide your OpenShift login credentials. This happens due to an issue with how the framework displays the Trace pages in the Console. The Workaround is to open the URL for the Jaeger console in another browser window and log in. Then you can view the embedded tracing pages in the Kiali console.\n\n• **KIALI-3118** After changes to the ServiceMeshMemberRoll, for example adding or removing projects, the Kiali pod restarts and then displays errors on the Graph page while the Kiali pod is restarting.\n\n• **KIALI-2206** When you are accessing the Kiali console for the first time, and there is no cached browser data for Kiali, the “View in Grafana” link on the Metrics tab of the Kiali Service Details page redirects to the wrong location. The only way you would encounter this issue is if you are accessing Kiali for the first time.\n\n• **KIALI-507** Kiali does not support Internet Explorer 11. This is because the underlying frameworks do not support Internet Explorer. To access the Kiali console, use one of the two most recent versions of the Chrome, Edge, Firefox or Safari browser.\n\n### 1.4.3. Jaeger known issues\n\nThese limitations exist in Jaeger:\n- While Kafka publisher is included as part of Jaeger, it is not supported.\n\n- Apache Spark is not supported.\n\n- Only self-provisioned Elasticsearch instances are supported. External Elasticsearch instances are not supported in this release.\n\nThese are the known issues in Jaeger:\n\n- **TRACING-1166** It is not currently possible to use the Jaeger streaming strategy within a disconnected environment. When a Kafka cluster is being provisioned, it results in an error: `Failed to pull image registry.redhat.io/amq7/amq-streams-kafka-24-rhel7@sha256:f9ceca004f1b7dccb3b82d9a8027961f9fe4104e0ed69752c0bddd8078b4a1076`.\n\n- **TRACING-809** Jaeger Ingester is incompatible with Kafka 2.3. When there are two or more instances of the Jaeger Ingester and enough traffic it will continuously generate rebalancing messages in the logs. This is due to a regression in Kafka 2.3 that was fixed in Kafka 2.3.1. For more information, see [Jaegertracing-1819](#).\n\n### 1.5. FIXED ISSUES\n\nThe following issues been resolved in the current release:\n\n#### 1.5.1. Service Mesh fixed issues\n\n- **OSSM-99** Workloads generated from direct Pod without labels may crash Kiali.\n\n- **OSSM-93** IstioConfigList can’t filter by two or more names.\n\n- **OSSM-92** Cancelling unsaved changes on the VS/DR YAML edit page does not cancel the changes.\n\n- **OSSM-90** Traces not available on the service details page.\n\n- **MAISTRA-1001** Closing HTTP/2 connections could lead to segmentation faults in [istio-proxy](#).\n\n- **MAISTRA-932** Added the `requires` metadata to add dependency relationship between Jaeger operator and Elasticsearch operator. Ensures that when the Jaeger operator is installed, it automatically deploys the Elasticsearch operator if it is not available.\n\n- **MAISTRA-862** Galley dropped watches and stopped providing configuration to other components after many namespace deletions and re-creations.\n\n- **MAISTRA-833** Pilot stopped delivering configuration after many namespace deletions and re-creations.\n\n- **MAISTRA-684** The default Jaeger version in the [istio-operator](#) is 1.12.0, which does not match Jaeger version 1.13.1 that shipped in Red Hat OpenShift Service Mesh 0.12.TechPreview.\n\n- **MAISTRA-622** In Maistra 0.12.0/TP12, permissive mode does not work. The user has the option to use Plain text mode or Mutual TLS mode, but not permissive.\n\n- **MAISTRA-572** Jaeger cannot be used with Kiali. In this release Jaeger is configured to use the OAuth proxy, but is also only configured to work through a browser and does not allow service access. Kiali cannot properly communicate with the Jaeger endpoint and it considers Jaeger to be disabled. See also [TRACING-591](#).\n• **MAISTRA-357** In OpenShift 4 Beta on AWS, it is not possible, by default, to access a TCP or HTTPS service through the ingress gateway on a port other than port 80. The AWS load balancer has a health check that verifies if port 80 on the service endpoint is active. Without a service running on port 80, the load balancer health check fails.\n\n• **MAISTRA-348** OpenShift 4 Beta on AWS does not support ingress gateway traffic on ports other than 80 or 443. If you configure your ingress gateway to handle TCP traffic with a port number other than 80 or 443, you have to use the service hostname provided by the AWS load balancer rather than the OpenShift router as a workaround.\n\n### 1.5.2. Kiali fixed issues\n\n• **KIALI-3239** If a Kiali Operator pod has failed with a status of “Evicted” it blocks the Kiali operator from deploying. The workaround is to delete the Evicted pod and redeploy the Kiali operator.\n\n• **KIALI-3096** Runtime metrics fail in Service Mesh. There is an OAuth filter between the Service Mesh and Prometheus, requiring a bearer token to be passed to Prometheus before access will be granted. Kiali has been updated to use this token when communicating to the Prometheus server, but the application metrics are currently failing with 403 errors.\n\n• **KIALI-3070** This bug only affects custom dashboards, not the default dashboards. When you select labels in metrics settings and refresh the page, your selections are retained in the menu but your selections are not displayed on the charts.\nCHAPTER 2. SERVICE MESH ARCHITECTURE\n\n2.1. UNDERSTANDING RED HAT OPENSHIFT SERVICE MESH\n\nRed Hat OpenShift Service Mesh provides a platform for behavioral insight and operational control over your networked microservices in a service mesh. With Red Hat OpenShift Service Mesh, you can connect, secure, and monitor microservices in your OpenShift Container Platform environment.\n\n2.1.1. Understanding service mesh\n\nA service mesh is the network of microservices that make up applications in a distributed microservice architecture and the interactions between those microservices. When a Service Mesh grows in size and complexity, it can become harder to understand and manage.\n\nBased on the open source Istio project, Red Hat OpenShift Service Mesh adds a transparent layer on existing distributed applications without requiring any changes to the service code. You add Red Hat OpenShift Service Mesh support to services by deploying a special sidecar proxy to relevant services in the mesh that intercepts all network communication between microservices. You configure and manage the Service Mesh using the control plane features.\n\nRed Hat OpenShift Service Mesh gives you an easy way to create a network of deployed services that provide:\n\n- Discovery\n- Load balancing\n- Service-to-service authentication\n- Failure recovery\n- Metrics\n- Monitoring\n\nRed Hat OpenShift Service Mesh also provides more complex operational functions including:\n\n- A/B testing\n- Canary releases\n- Rate limiting\n- Access control\n- End-to-end authentication\n\n2.1.2. Red Hat OpenShift Service Mesh Architecture\n\nRed Hat OpenShift Service Mesh is logically split into a data plane and a control plane:\n\nThe data plane is a set of intelligent proxies deployed as sidecars. These proxies intercept and control all inbound and outbound network communication between microservices in the service mesh. Sidecar proxies also communicate with Mixer, the general-purpose policy and telemetry hub.\n- **Envoy proxy** intercepts all inbound and outbound traffic for all services in the service mesh. Envoy is deployed as a sidecar to the relevant service in the same pod.\n\nThe **control plane** manages and configures proxies to route traffic, and configures Mixers to enforce policies and collect telemetry.\n\n- **Mixer** enforces access control and usage policies (such as authorization, rate limits, quotas, authentication, and request tracing) and collects telemetry data from the Envoy proxy and other services.\n\n- **Pilot** configures the proxies at runtime. Pilot provides service discovery for the Envoy sidecars, traffic management capabilities for intelligent routing (for example, A/B tests or canary deployments), and resiliency (timeouts, retries, and circuit breakers).\n\n- **Citadel** issues and rotates certificates. Citadel provides strong service-to-service and end-user authentication with built-in identity and credential management. You can use Citadel to upgrade unencrypted traffic in the service mesh. Operators can enforce policies based on service identity rather than on network controls using Citadel.\n\n- **Galley** ingests the service mesh configuration, then validates, processes, and distributes the configuration. Galley protects the other service mesh components from obtaining user configuration details from OpenShift Container Platform.\n\nRed Hat OpenShift Service Mesh also uses the istio-operator to manage the installation of the control plane. An **Operator** is a piece of software that enables you to implement and automate common activities in your OpenShift cluster. It acts as a controller, allowing you to set or change the desired state of objects in your cluster.\n\n### 2.1.3. Red Hat OpenShift Service Mesh control plane\n\nRed Hat OpenShift Service Mesh installs a multi-tenant control plane by default. You specify the projects that can access the Service Mesh, and isolate the Service Mesh from other control plane instances.\n\n### 2.1.4. Multi-tenancy in Red Hat OpenShift Service Mesh versus cluster-wide installations\n\nThe main difference between a multi-tenant installation and a cluster-wide installation is the scope of privileges used by the control plane deployments, for example, Galley and Pilot. The components no longer use cluster-scoped Role Based Access Control (RBAC) resource **ClusterRoleBinding**, but rely on project-scoped **RoleBinding**.\n\nEvery project in the **members** list will have a **RoleBinding** for each service account associated with a control plane deployment and each control plane deployment will only watch those member projects. Each member project has a **maistra.io/member-of** label added to it, where the **member-of** value is the project containing the control plane installation.\n\nRed Hat OpenShift Service Mesh configures each member project to ensure network access between itself, the control plane, and other member projects. The exact configuration differs depending on how OpenShift software-defined networking (SDN) is configured. See About OpenShift SDN for additional details.\n\nIf the OpenShift Container Platform cluster is configured to use the SDN plug-in:\n\n- **NetworkPolicy**: Red Hat OpenShift Service Mesh creates a **NetworkPolicy** resource in each member project allowing ingress to all pods from the other members and the control plane. If\nyou remove a member from Service Mesh, this **NetworkPolicy** resource is deleted from the project.\n\n**NOTE**\n\nThis also restricts ingress to only member projects. If ingress from non-member projects is required, you need to create a **NetworkPolicy** to allow that traffic through.\n\n- **Multitenant:** Red Hat OpenShift Service Mesh joins the **NetNamespace** for each member project to the **NetNamespace** of the control plane project (the equivalent of running `oc adm pod-network join-projects --to control-plane-project member-project`). If you remove a member from the Service Mesh, its **NetNamespace** is isolated from the control plane (the equivalent of running `oc adm pod-network isolate-projects member-project`).\n\n- **Subnet:** No additional configuration is performed.\n\n### 2.1.5. Automatic injection\n\nThe upstream Istio community installation automatically injects the sidecar into pods within the projects you have labeled.\n\nRed Hat OpenShift Service Mesh does not automatically inject the sidecar to any pods, but requires you to specify the `<prefix>.istio.io/inject` annotation as illustrated in the Automatic sidecar injection section.\n\n### 2.1.6. Istio Role Based Access Control features\n\nIstio Role Based Access Control (RBAC) provides a mechanism you can use to control access to a service. You can identify subjects by user name or by specifying a set of properties and apply access controls accordingly.\n\nThe upstream Istio community installation includes options to perform exact header matches, match wildcards in headers, or check for a header containing a specific prefix or suffix.\n\nRed Hat OpenShift Service Mesh extends the ability to match request headers by using a regular expression. Specify a property key of `request.regex.headers` with a regular expression.\n\n**Upstream Istio community matching request headers example**\n\n```yaml\napiVersion: \"rbac.istio.io/v1alpha1\"\nkind: ServiceRoleBinding\nmetadata:\n name: httpbin-client-binding\nnamespace: httpbin\nspec:\n subjects:\n - user: \"cluster.local/ns/istio-system/sa/istio-ingressgateway-service-account\"\n properties:\n request.headers[<header>]: \"value\"\n```\n\n**Red Hat OpenShift Service Mesh matching request headers by using regular expressions**\n\n```yaml\napiVersion: \"rbac.istio.io/v1alpha1\"\nkind: ServiceRoleBinding\n```\n2.1.7. OpenSSL\n\nRed Hat OpenShift Service Mesh replaces BoringSSL with OpenSSL. OpenSSL is a software library that contains an open source implementation of the Secure Sockets Layer (SSL) and Transport Layer Security (TLS) protocols. The Red Hat OpenShift Service Mesh Proxy binary dynamically links the OpenSSL libraries (libssl and libcrypto) from the underlying Red Hat Enterprise Linux operating system.\n\n2.1.8. The Istio Container Network Interface (CNI) plug-in\n\nRed Hat OpenShift Service Mesh includes CNI plug-in, which provides you with an alternate way to configure application pod networking. The CNI plug-in replaces the init-container network configuration eliminating the need to grant service accounts and projects access to Security Context Constraints (SCCs) with elevated privileges.\n\n2.1.9. Envoy, Secret Discovery Service, and Certificates\n\n- Red Hat OpenShift Service Mesh does not support QUIC-based services.\n- Deployment of TLS certificates using the Secret Discovery Service (SDS) functionality of Istio is not currently supported in Red Hat OpenShift Service Mesh. The Istio implementation depends on a nodeagent container that uses hostPath mounts.\n\nNext steps\n\n- Prepare to install Red Hat OpenShift Service Mesh in your OpenShift Container Platform environment.\n\n2.2. KIALI OVERVIEW\n\nKiali provides visibility into your service mesh by showing you the microservices in your service mesh, and how they are connected.\n\n2.2.1. Kiali overview\n\nKiali provides observability into the Service Mesh running on OpenShift Container Platform. Kiali helps you define, validate, and observe your Istio service mesh. It helps you to understand the structure of your service mesh by inferring the topology, and also provides information about the health of your service mesh.\n\nKiali provides an interactive graph view of your namespace in real time that provides visibility into features like circuit breakers, request rates, latency, and even graphs of traffic flows. Kiali offers insights about components at different levels, from Applications to Services and Workloads, and can display the interactions with contextual information and charts on the selected graph node or edge. Kiali also provides the ability to validate your Istio configurations, such as gateways, destination rules, virtual...\nservices, mesh policies, and more. Kiali provides detailed metrics, and a basic Grafana integration is available for advanced queries. Distributed tracing is provided by integrating Jaeger into the Kiali console.\n\nKiali is installed by default as part of the Red Hat OpenShift Service Mesh.\n\n2.2.2. Kiali architecture\n\nKiali is composed of two components: the Kiali application and the Kiali console.\n\n- **Kiali application** (back end) – This component runs in the container application platform and communicates with the service mesh components, retrieves and processes data, and exposes this data to the console. The Kiali application does not need storage. When deploying the application to a cluster, configurations are set in ConfigMaps and secrets.\n\n- **Kiali console** (front end) – The Kiali console is a web application. The Kiali application serves the Kiali console, which then queries the back end for data in order to present it to the user.\n\nIn addition, Kiali depends on external services and components provided by the container application platform and Istio.\n\n- **Red Hat Service Mesh** (Istio) - Istio is a Kiali requirement. Istio is the component that provides and controls the service mesh. Although Kiali and Istio can be installed separately, Kiali depends on Istio and will not work if it is not present. Kiali needs to retrieve Istio data and configurations, which are exposed through Prometheus and the cluster API.\n\n- **Prometheus** - A dedicated Prometheus instance is included as part of the Red Hat OpenShift Service Mesh installation. When Istio telemetry is enabled, metrics data is stored in Prometheus. Kiali uses this Prometheus data to determine the mesh topology, display metrics, calculate health, show possible problems, and so on. Kiali communicates directly with Prometheus and assumes the data schema used by Istio Telemetry. Prometheus is an Istio dependency and a hard dependency for Kiali, and many of Kiali’s features will not work without Prometheus.\n\n- **Cluster API** - Kiali uses the API of the OpenShift Container Platform (cluster API) in order to fetch and resolve service mesh configurations. Kiali queries the cluster API to retrieve, for example, definitions for namespaces, services, deployments, pods, and other entities. Kiali also makes queries to resolve relationships between the different cluster entities. The cluster API is also queried to retrieve Istio configurations like virtual services, destination rules, route rules, gateways, quotas, and so on.\n\n- **Jaeger** - Jaeger is optional, but is installed by default as part of the Red Hat OpenShift Service Mesh installation. When you install Jaeger as part of the default Red Hat OpenShift Service Mesh installation, the Kiali console includes a tab to display Jaeger’s tracing data. Note that tracing data will not be available if you disable Istio’s distributed tracing feature. Also note that user must have access to the namespace where the control plane is installed in order to view Jaeger data.\n\n- **Grafana** - Grafana is optional, but is installed by default as part of the Red Hat OpenShift Service Mesh installation. When available, the metrics pages of Kiali display links to direct the user to the same metric in Grafana. Note that user must have access to the namespace where the control plane is installed in order to view links to the Grafana dashboard and view Grafana data.\n\n2.2.3. Kiali features\n\nThe Kiali console is integrated with Red Hat Service Mesh and provides the following capabilities:\n• **Health** – Quickly identify issues with applications, services, or workloads.\n\n• **Topology** – Visualize how your applications, services, or workloads communicate via the Kiali graph.\n\n• **Metrics** – Predefined metrics dashboards let you chart service mesh and application performance for Go, Node.js, Quarkus, Spring Boot, Thorntail and Vert.x. You can also create your own custom dashboards.\n\n• **Tracing** – Integration with Jaeger lets you follow the path of a request through various microservices that make up an application.\n\n• **Validations** – Perform advanced validations on the most common Istio objects (Destination Rules, Service Entries, Virtual Services, and so on).\n\n• **Configuration** – Optional ability to create, update and delete Istio routing configuration using wizards or directly in the YAML editor in the Kiali Console.\n\n2.3. UNDERSTANDING JAEGER\n\nEvery time a user takes an action in an application, a request is executed by the architecture that may require dozens of different services to participate in order to produce a response. The path of this request is a distributed transaction. Jaeger lets you perform distributed tracing, which follows the path of a request through various microservices that make up an application.\n\nDistributed tracing is a technique that is used to tie the information about different units of work together—usually executed in different processes or hosts—in order to understand a whole chain of events in a distributed transaction. Distributed tracing lets developers visualize call flows in large service oriented architectures. It can be invaluable in understanding serialization, parallelism, and sources of latency.\n\nJaeger records the execution of individual requests across the whole stack of microservices, and presents them as traces. A trace is a data/execution path through the system. An end-to-end trace is comprised of one or more spans.\n\nA span represents a logical unit of work in Jaeger that has an operation name, the start time of the operation, and the duration. Spans may be nested and ordered to model causal relationships.\n\n2.3.1. Jaeger overview\n\nAs a service owner, you can use Jaeger to instrument your services to gather insights into your service architecture. Jaeger is an open source distributed tracing platform that you can use for monitoring, network profiling, and troubleshooting the interaction between components in modern, cloud-native, microservices-based applications.\n\nUsing Jaeger lets you perform the following functions:\n\n• Monitor distributed transactions\n\n• Optimize performance and latency\n\n• Perform root cause analysis\n\nJaeger is based on the vendor-neutral OpenTracing APIs and instrumentation.\n\n2.3.2. Jaeger architecture\n\nOpenShift Container Platform 4.4 Service Mesh\nJaeger is made up of several components that work together to collect, store, and display tracing data.\n\n- **Jaeger Client** (Tracer, Reporter, instrumented application, client libraries) - Jaeger clients are language specific implementations of the OpenTracing API. They can be used to instrument applications for distributed tracing either manually or with a variety of existing open source frameworks, such as Camel (Fuse), Spring Boot (RHOAR), MicroProfile (RHOAR/Thorntail), Wildfly (EAP), and many more, that are already integrated with OpenTracing.\n\n- **Jaeger Agent** (Server Queue, Processor Workers) - The Jaeger agent is a network daemon that listens for spans sent over User Datagram Protocol (UDP), which it batches and sends to the collector. The agent is meant to be placed on the same host as the instrumented application. This is typically accomplished by having a sidecar in container environments like Kubernetes.\n\n- **Jaeger Collector** (Queue, Workers) - Similar to the Agent, the Collector is able to receive spans and place them in an internal queue for processing. This allows the collector to return immediately to the client/agent instead of waiting for the span to make its way to the storage.\n\n- **Storage** (Data Store) - Collectors require a persistent storage backend. Jaeger has a pluggable mechanism for span storage. Note that for this release, the only supported storage is Elasticsearch.\n\n- **Query** (Query Service) - Query is a service that retrieves traces from storage.\n\n- **Ingester** (Ingester Service) - Jaeger can use Apache Kafka as a buffer between the collector and the actual backing storage (Elasticsearch). Ingester is a service that reads data from Kafka and writes to another storage backend (Elasticsearch).\n\n- **Jaeger Console** - Jaeger provides a user interface that lets you visualize your distributed tracing data. On the Search page, you can find traces and explore details of the spans that make up an individual trace.\n\n### 2.3.3. Jaeger features\n\nJaeger tracing provides the following capabilities:\n\n- Integration with Kiali – When properly configured, you can view Jaeger data from the Kiali console.\n\n- High scalability – The Jaeger backend is designed to have no single points of failure and to scale with the business needs.\n\n- Distributed Context Propagation – Lets you connect data from different components together to create a complete end-to-end trace.\n\n- Backwards compatibility with Zipkin – Jaeger provides backwards compatibility with Zipkin by accepting spans in Zipkin formats (Thrift or JSON v1/v2) over HTTP.\n\n### 2.4. COMPARING SERVICE MESH AND ISTIO\n\nAn installation of Red Hat OpenShift Service Mesh differs from upstream Istio community installations in multiple ways. The modifications to Red Hat OpenShift Service Mesh are sometimes necessary to resolve issues, provide additional features, or to handle differences when deploying on OpenShift Container Platform.\nThe current release of Red Hat OpenShift Service Mesh differs from the current upstream Istio community release in the following ways:\n\n2.4.1. Red Hat OpenShift Service Mesh control plane\n\nRed Hat OpenShift Service Mesh installs a multi-tenant control plane by default. You specify the projects that can access the Service Mesh, and isolate the Service Mesh from other control plane instances.\n\n2.4.2. Multi-tenancy in Red Hat OpenShift Service Mesh versus cluster-wide installations\n\nThe main difference between a multi-tenant installation and a cluster-wide installation is the scope of privileges used by the control plane deployments, for example, Galley and Pilot. The components no longer use cluster-scoped Role Based Access Control (RBAC) resource `ClusterRoleBinding`, but rely on project-scoped `RoleBinding`.\n\nEvery project in the `members` list will have a `RoleBinding` for each service account associated with a control plane deployment and each control plane deployment will only watch those member projects. Each member project has a `maistra.io/member-of` label added to it, where the `member-of` value is the project containing the control plane installation.\n\nRed Hat OpenShift Service Mesh configures each member project to ensure network access between itself, the control plane, and other member projects. The exact configuration differs depending on how OpenShift software-defined networking (SDN) is configured. See About OpenShift SDN for additional details.\n\nIf the OpenShift Container Platform cluster is configured to use the SDN plug-in:\n\n- **NetworkPolicy**: Red Hat OpenShift Service Mesh creates a `NetworkPolicy` resource in each member project allowing ingress to all pods from the other members and the control plane. If you remove a member from Service Mesh, this `NetworkPolicy` resource is deleted from the project.\n\n **NOTE**\n\n This also restricts ingress to only member projects. If ingress from non-member projects is required, you need to create a `NetworkPolicy` to allow that traffic through.\n\n- **Multitenant**: Red Hat OpenShift Service Mesh joins the `NetNamespace` for each member project to the `NetNamespace` of the control plane project (the equivalent of running `oc adm pod-network join-projects --to control-plane-project member-project`). If you remove a member from the Service Mesh, its `NetNamespace` is isolated from the control plane (the equivalent of running `oc adm pod-network isolate-projects member-project`).\n\n- **Subnet**: No additional configuration is performed.\n\n2.4.3. Automatic injection\n\nThe upstream Istio community installation automatically injects the sidecar into pods within the projects you have labeled.\n\nRed Hat OpenShift Service Mesh does not automatically inject the sidecar to any pods, but requires you to specify the `sidecar.istio.io/inject` annotation as illustrated in the Automatic sidecar injection section.\n2.4.4. Istio Role Based Access Control features\n\nIstio Role Based Access Control (RBAC) provides a mechanism you can use to control access to a service. You can identify subjects by user name or by specifying a set of properties and apply access controls accordingly.\n\nThe upstream Istio community installation includes options to perform exact header matches, match wildcards in headers, or check for a header containing a specific prefix or suffix.\n\nRed Hat OpenShift Service Mesh extends the ability to match request headers by using a regular expression. Specify a property key of `request.regex.headers` with a regular expression.\n\n**Upstream Istio community matching request headers example**\n\n```yaml\napiVersion: \"rbac.istio.io/v1alpha1\"\nkind: ServiceRoleBinding\nmetadata: \n name: httpbin-client-binding\nnamespace: httpbin\nspec: \n subjects: \n - user: \"cluster.local/ns/istio-system/sa/istio-ingressgateway-service-account\"\n properties: \n request.headers[<header>]: \"value\"\n```\n\n**Red Hat OpenShift Service Mesh matching request headers by using regular expressions**\n\n```yaml\napiVersion: \"rbac.istio.io/v1alpha1\"\nkind: ServiceRoleBinding\nmetadata: \n name: httpbin-client-binding\nnamespace: httpbin\nspec: \n subjects: \n - user: \"cluster.local/ns/istio-system/sa/istio-ingressgateway-service-account\"\n properties: \n request.regex.headers[<header>]: \"<regular expression>\"\n```\n\n2.4.5. OpenSSL\n\nRed Hat OpenShift Service Mesh replaces BoringSSL with OpenSSL. OpenSSL is a software library that contains an open source implementation of the Secure Sockets Layer (SSL) and Transport Layer Security (TLS) protocols. The Red Hat OpenShift Service Mesh Proxy binary dynamically links the OpenSSL libraries (libssl and libcrypto) from the underlying Red Hat Enterprise Linux operating system.\n\n2.4.6. The Istio Container Network Interface (CNI) plug-in\n\nRed Hat OpenShift Service Mesh includes CNI plug-in, which provides you with an alternate way to configure application pod networking. The CNI plug-in replaces the `init-container` network configuration eliminating the need to grant service accounts and projects access to Security Context Constraints (SCCs) with elevated privileges.\n\n2.4.7. Envoy, Secret Discovery Service, and Certificates\n- Red Hat OpenShift Service Mesh does not support QUIC-based services.\n- Deployment of TLS certificates using the Secret Discovery Service (SDS) functionality of Istio is not currently supported in Red Hat OpenShift Service Mesh. The Istio implementation depends on a nodeagent container that uses hostPath mounts.\n\n### 2.4.8. Kiali and service mesh\n\nInstalling Kiali via the Service Mesh on OpenShift Container Platform differs from community Kiali installations in multiple ways. These modifications are sometimes necessary to resolve issues, provide additional features, or to handle differences when deploying on OpenShift Container Platform.\n\n- Kiali has been enabled by default.\n- Ingress has been enabled by default.\n- Updates have been made to the Kiali ConfigMap.\n- Updates have been made to the ClusterRole settings for Kiali.\n- Users should not manually edit the ConfigMap or the Kiali custom resource files as those changes might be overwritten by the Service Mesh or Kiali operators. All configuration for Kiali running on Red Hat OpenShift Service Mesh is done in the `ServiceMeshControlPlane` custom resource file and there are limited configuration options. Updating the operator files should be restricted to those users with cluster-admin privileges.\n\n### 2.4.9. Jaeger and service mesh\n\nInstalling Jaeger with the Service Mesh on OpenShift Container Platform differs from community Jaeger installations in multiple ways. These modifications are sometimes necessary to resolve issues, provide additional features, or to handle differences when deploying on OpenShift Container Platform.\n\n- Jaeger has been enabled by default for Service Mesh.\n- Ingress has been enabled by default for Service Mesh.\n- The name for the Zipkin port name has changed to jaeger-collector-zipkin (from http)\n- Jaeger uses Elasticsearch for storage by default.\n- The community version of Istio provides a generic \"tracing\" route. Red Hat OpenShift Service Mesh uses a \"jaeger\" route that is installed by the Jaeger operator and is already protected by OAuth.\n- Red Hat OpenShift Service Mesh uses a sidecar for the Envoy proxy, and Jaeger also uses a sidecar, for the Jaeger agent. These two sidecars are configured separately and should not be confused with each other. The proxy sidecar creates spans related to the pod’s ingress and egress traffic. The agent sidecar receives the spans emitted by the application and sends them to the Jaeger Collector.\nCHAPTER 3. SERVICE MESH INSTALLATION\n\n3.1. PREPARING TO INSTALL RED HAT OPENSOURCE SERVICE MESH\n\nBefore you can install Red Hat OpenShift Service Mesh, review the installation activities, ensure that you meet the prerequisites:\n\nPrerequisites\n\n- Possess an active OpenShift Container Platform subscription on your Red Hat account. If you do not have a subscription, contact your sales representative for more information.\n\n- Review the OpenShift Container Platform 4.4 overview.\n\n- Install OpenShift Container Platform 4.4.\n - Install OpenShift Container Platform 4.4 on AWS\n - Install OpenShift Container Platform 4.4 on user-provisioned AWS\n - Install OpenShift Container Platform 4.4 on bare metal\n - Install OpenShift Container Platform 4.4 on vSphere\n\n- Install the version of the OpenShift Container Platform command line utility (the `oc` client tool) that matches your OpenShift Container Platform version and add it to your path.\n - If you are using OpenShift Container Platform 4.4, see About the CLI.\n\n3.1.1. Red Hat OpenShift Service Mesh supported configurations\n\nThe following are the only supported configurations for the Red Hat OpenShift Service Mesh:\n\n- Red Hat OpenShift Container Platform version 4.x.\n\nNOTE\n\nOpenShift Online and OpenShift Dedicated are not supported for Red Hat OpenShift Service Mesh 1.1.1.\n\n- The deployment must be contained to a single OpenShift Container Platform cluster that is not federated.\n\n- This release of Red Hat OpenShift Service Mesh is only available on OpenShift Container Platform x86_64.\n\n- This release only supports configurations where all Service Mesh components are contained in the OpenShift cluster in which it operates. It does not support management of microservices that reside outside of the cluster, or in a multi-cluster scenario.\n\n- This release only supports configurations that do not integrate external services such as virtual machines.\n\n3.1.1.1. Supported configurations for Kiali on Red Hat OpenShift Service Mesh\n3.1.2. Supported Mixer adapters\n\n- This release only supports the following Mixer adapter:\n - 3scale Istio Adapter\n\n3.1.2. Red Hat OpenShift Service Mesh installation activities\n\nTo install the Red Hat OpenShift Service Mesh Operator, you must first install these Operators:\n\n- **Elasticsearch** - Based on the open source Elasticsearch project that enables you to configure and manage an Elasticsearch cluster for tracing and logging with Jaeger.\n\n- **Jaeger** - Based on the open source Jaeger project, lets you perform tracing to monitor and troubleshoot transactions in complex distributed systems.\n\n- **Kiali** - Based on the open source Kiali project, provides observability for your service mesh. By using Kiali you can view configurations, monitor traffic, and view and analyze traces in a single console.\n\nAfter you install the Elasticsearch, Jaeger, and Kiali Operators, then you install the Red Hat OpenShift Service Mesh Operator. The Service Mesh Operator defines and monitors the ServiceMeshControlPlane resources that manage the deployment, updating, and deletion of the Service Mesh components.\n\n- **Red Hat OpenShift Service Mesh** - Based on the open source Istio project, lets you connect, secure, control, and observe the microservices that make up your applications.\n\n**WARNING**\n\nPlease see configuring Elasticsearch for details on configuring the default Jaeger parameters for Elasticsearch in a production environment.\n\nNext steps\n\n- Install Red Hat OpenShift Service Mesh in your OpenShift Container Platform environment.\n\n### 3.2. INSTALLING RED HAT OPENSHIFT SERVICE MESH\n\nInstalling the Service Mesh involves installing the Elasticsearch, Jaeger, Kiali and Service Mesh Operators, creating and managing a ServiceMeshControlPlane resource to deploy the control plane, and creating a ServiceMeshMemberRoll resource to specify the namespaces associated with the Service Mesh.\nNOTE\n\nMixer’s policy enforcement is disabled by default. You must enable it to run policy tasks. See Update Mixer policy enforcement for instructions on enabling Mixer policy enforcement.\n\nNOTE\n\nMulti-tenant control plane installations are the default configuration starting with Red Hat OpenShift Service Mesh 1.0.\n\nNOTE\n\nThe Service Mesh documentation uses istio-system as the example project, but you may deploy the service mesh to any project.\n\nPrerequisites\n\n- Follow the Preparing to install Red Hat OpenShift Service Mesh process.\n- An account with the cluster-admin role.\n\n3.2.1. Installing the Operators from OperatorHub\n\nThe Service Mesh installation process uses the OperatorHub to install the ServiceMeshControlPlane custom resource definition within the openshift-operators project. The Red Hat OpenShift Service Mesh defines and monitors the ServiceMeshControlPlane related to the deployment, update, and deletion of the control plane.\n\nStarting with Red Hat OpenShift Service Mesh 1.1.1, you must install the Elasticsearch Operator, the Jaeger Operator, and the Kiali Operator before the Red Hat OpenShift Service Mesh Operator can install the control plane.\n\n3.2.1.1. Installing the Elasticsearch Operator\n\nYou must install the Elasticsearch Operator for the Red Hat OpenShift Service Mesh Operator to install the control plane.\n\nWARNING\n\nDo not install Community versions of the Operators. Community Operators are not supported.\n\nPrerequisites\n\n- Access to the OpenShift Container Platform web console.\n\nProcedure\n\n1. Log in to the OpenShift Container Platform web console.\n\n3. Type Elasticsearch into the filter box to locate the Elasticsearch Operator.\n\n4. Click the Elasticsearch Operator to display information about the Operator.\n\n5. Click Install.\n\n6. On the Create Operator Subscription page, select All namespaces on the cluster (default)\n This installs the Operator in the default openshift-operators project and makes the Operator\n available to all projects in the cluster.\n\n7. In the Update Channel, select the most current version.\n\n8. Select the Automatic Approval Strategy.\n\n **NOTE**\n The Manual approval strategy requires a user with appropriate credentials to\n approve the Operator install and subscription process.\n\n9. Click Subscribe.\n\n10. The Installed Operators page displays the Elasticsearch Operator’s installation progress.\n\n### 3.2.1.2. Installing the Jaeger Operator\n\nYou must install the Jaeger Operator for the Red Hat OpenShift Service Mesh Operator to install the\ncontrol plane.\n\n**WARNING**\nDo not install Community versions of the Operators. Community Operators are not supported.\n\n**Prerequisites**\n- Access to the OpenShift Container Platform web console.\n- The Elasticsearch Operator must be installed.\n\n**Procedure**\n1. Log in to the OpenShift Container Platform web console.\n3. Type Jaeger into the filter box to locate the Jaeger Operator.\n4. Click the Jaeger Operator provided by Red Hat to display information about the Operator.\n5. Click **Install**.\n\n6. On the **Create Operator Subscription** page, select **All namespaces on the cluster (default)**. This installs the Operator in the default `openshift-operators` project and makes the Operator available to all projects in the cluster.\n\n7. Select the **stable** Update Channel.\n\n8. Select the **Automatic** Approval Strategy.\n\n **NOTE**\n \n The Manual approval strategy requires a user with appropriate credentials to approve the Operator install and subscription process.\n\n9. Click **Subscribe**.\n\n10. The **Installed Operators** page displays the Jaeger Operator’s installation progress.\n\n### 3.2.1.3. Installing the Kiali Operator\n\nYou must install the Kiali Operator for the Red Hat OpenShift Service Mesh Operator to install the control plane.\n\n**WARNING**\n\nDo not install Community versions of the Operators. Community Operators are not supported.\n\n**Prerequisites**\n\n- Access to the OpenShift Container Platform web console.\n\n**Procedure**\n\n1. Log in to the OpenShift Container Platform web console.\n\n2. Navigate to **Operators → OperatorHub**.\n\n3. Type **Kiali** into the filter box to find the Kiali Operator.\n\n4. Click the **Kiali Operator** provided by Red Hat to display information about the Operator.\n\n5. Click **Install**.\n\n6. On the **Create Operator Subscription** page, select **All namespaces on the cluster (default)**. This installs the Operator in the default `openshift-operators` project and makes the Operator available to all projects in the cluster.\n\n7. Select the **stable** Update Channel.\n8. Select the **Automatic** Approval Strategy.\n\n **NOTE**\n The Manual approval strategy requires a user with appropriate credentials to approve the Operator install and subscription process.\n\n9. Click **Subscribe**.\n\n10. The **Installed Operators** page displays the Kiali Operator’s installation progress.\n\n### 3.2.1.4. Installing the Red Hat OpenShift Service Mesh Operator\n\n**Prerequisites**\n\n- Access to the OpenShift Container Platform web console.\n- The Elasticsearch Operator must be installed.\n- The Jaeger Operator must be installed.\n- The Kiali Operator must be installed.\n\n**Procedure**\n\n1. Log in to the OpenShift Container Platform web console.\n\n2. Navigate to **Operators → OperatorHub**.\n\n3. Type **Red Hat OpenShift Service Mesh** into the filter box to find the Red Hat OpenShift Service Mesh Operator.\n\n4. Click the Red Hat OpenShift Service Mesh Operator to display information about the Operator.\n\n5. On the **Create Operator Subscription** page, select **All namespaces on the cluster (default)**. This installs the Operator in the default **openshift-operators** project and makes the Operator available to all projects in the cluster.\n\n6. Click **Install**.\n\n7. Select the **stable** Update Channel.\n\n8. Select the **Automatic** Approval Strategy.\n\n **NOTE**\n The Manual approval strategy requires a user with appropriate credentials to approve the Operator install and subscription process.\n\n9. Click **Subscribe**.\n\n10. The **Installed Operators** page displays the Red Hat OpenShift Service Mesh Operator’s installation progress.\n3.2.1.5. Deploying the Red Hat OpenShift Service Mesh control plane\n\nThe ServiceMeshControlPlane resource defines the configuration to be used during installation. You can deploy the default configuration provided by Red Hat or customize the ServiceMeshControlPlane file to fit your business needs.\n\nYou can deploy the Service Mesh control plane by using the OpenShift Container Platform web console or from the command line using the oc client tool.\n\n3.2.1.5.1. Deploying the control plane from the web console\n\nFollow this procedure to deploy the Red Hat OpenShift Service Mesh control plane by using the web console.\n\nPrerequisites\n\n- The Red Hat OpenShift Service Mesh Operator must be installed.\n- Review the instructions for how to customize the Red Hat OpenShift Service Mesh installation.\n- An account with the cluster-admin role.\n\nProcedure\n\n1. Log in to the OpenShift Container Platform web console as a user with the cluster-admin role.\n2. Create a project named istio-system.\n b. Click Create Project.\n c. Enter istio-system in the Name field.\n d. Click Create.\n3. Navigate to Operators → Installed Operators.\n4. If necessary, select istio-system from the Project menu. You may have to wait a few moments for the Operators to be copied to the new project.\n5. Click the Red Hat OpenShift Service Mesh Operator. Under Provided APIs, the Operator provides links to create two resource types:\n - A ServiceMeshControlPlane resource\n - A ServiceMeshMemberRoll resource\n7. On the Create Service Mesh Control Plane page, modify the YAML for the default ServiceMeshControlPlane template as needed.\nNOTE\n\nFor additional information about customizing the control plane, see customizing the Red Hat OpenShift Service Mesh installation. For production, you must change the default Jaeger template.\n\n8. Click Create to create the control plane. The Operator creates Pods, services, and Service Mesh control plane components based on your configuration parameters.\n\n9. Click the Istio Service Mesh Control Plane tab.\n\n10. Click the name of the new control plane.\n\n11. Click the Resources tab to see the Red Hat OpenShift Service Mesh control plane resources the Operator created and configured.\n\n3.2.1.5.2. Deploying the control plane from the CLI\n\nFollow this procedure to deploy the Red Hat OpenShift Service Mesh control plane the command line.\n\nPrerequisites\n\n- The Red Hat OpenShift Service Mesh Operator must be installed.\n- Review the instructions for how to customize the Red Hat OpenShift Service Mesh installation.\n- An account with the cluster-admin role.\n- Access to the OpenShift Container Platform Command-line Interface (CLI), commonly known as oc.\n\nProcedure\n\n1. Log in to the OpenShift Container Platform CLI as a user with the cluster-admin role.\n\n `$ oc login https://{HOSTNAME}:6443`\n\n2. Create a project named istio-system.\n\n `$ oc new-project istio-system`\n\n3. Create a ServiceMeshControlPlane file named istio-installation.yaml using the full example found in \"Customize the Red Hat OpenShift Service Mesh installation\". You can customize the values as needed to match your use case. For production, you must change the default Jaeger template.\n\n4. Run the following command to deploy the control plane:\n\n `$ oc create -n istio-system -f istio-installation.yaml`\n\n5. Execute the following command to see the status of the control plane installation.\n\n `$ oc get smcp -n istio-system`\nThe installation has finished successfully when the READY column is true.\n\n<table>\n<thead>\n<tr>\n<th>NAME</th>\n<th>READY</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>basic-install</td>\n<td>True</td>\n</tr>\n</tbody>\n</table>\n\n6. Run the following command to watch the progress of the Pods during the installation process:\n\n```\n$ oc get pods -n istio-system -w\n```\n\nYou should see output similar to the following:\n\n<table>\n<thead>\n<tr>\n<th>NAME</th>\n<th>READY</th>\n<th>STATUS</th>\n<th>RESTARTS</th>\n<th>AGE</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>grafana-7bf5764d9d-2b2f6</td>\n<td>2/2</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>istio-citadel-576b9c5bbd-z84z4</td>\n<td>1/1</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>istio-egressgateway-5476bc4656-r4zdv</td>\n<td>1/1</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>istio-galley-7d57b47bb7-lqdxv</td>\n<td>1/1</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>istio-ingressgateway-dbb8f7f46-cf6n5</td>\n<td>1/1</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>istio-pilot-546bf69578-ccg5x</td>\n<td>2/2</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>istio-policy-77fd498655-7pvjw</td>\n<td>2/2</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>istio-sidecar-injector-df45bd899-ctxdt</td>\n<td>1/1</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>istio-telemetry-66f697d6d5-cj28l</td>\n<td>2/2</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n<tr>\n<td>jaeger-896945cbc-7lqrr</td>\n<td>2/2</td>\n<td>Running</td>\n<td>0</td>\n<td>11h</td>\n</tr>\n<tr>\n<td>kiali-78d9c5b87c-snjzh</td>\n<td>0/1</td>\n<td>Running</td>\n<td>0</td>\n<td>22h</td>\n</tr>\n<tr>\n<td>prometheus-6dff867c97-gr2n5</td>\n<td>2/2</td>\n<td>Running</td>\n<td>0</td>\n<td>28h</td>\n</tr>\n</tbody>\n</table>\n\nFor a multitenant installation, Red Hat OpenShift Service Mesh supports multiple independent control planes within the cluster. You can create reusable configurations with `ServiceMeshControlPlane` templates. For more information, see Creating control plane templates.\n\n### 3.2.1.6. Creating the Red Hat OpenShift Service Mesh member roll\n\nThe `ServiceMeshMemberRoll` lists the projects belonging to the control plane. Only projects listed in the `ServiceMeshMemberRoll` are affected by the control plane. A project does not belong to a service mesh until you add it to the member roll for a particular control plane deployment.\n\nYou must create a `ServiceMeshMemberRoll` resource named `default` in the same project as the `ServiceMeshControlPlane`.\n\n**NOTE**\n\nThe member projects are only updated if the Service Mesh control plane installation succeeds.\n\n#### 3.2.1.6.1. Creating the member roll from the web console\n\nFollow this procedure to add one or more projects to the Service Mesh member roll by using the web console.\n\n**Prerequisites**\n\n- An installed, verified Red Hat OpenShift Service Mesh Operator.\n- Location of the installed `ServiceMeshControlPlane`.\n• List of existing projects to add to the service mesh.\n\nProcedure\n\n1. If you don’t already have projects for your mesh, or you are starting from scratch, create a project. It must be different from istio-system.\n b. Enter a name in the Name field.\n c. Click Create.\n\n2. Log in to the OpenShift Container Platform web console.\n\n3. Navigate to Operators → Installed Operators.\n\n4. Click the Project menu and choose the project where your ServiceMeshControlPlane is deployed from the list, for example istio-system.\n\n5. Click the Red Hat OpenShift Service Mesh Operator.\n\n6. Click the All Instances tab.\n\n7. Click Create New, and then select Create Istio Service Mesh Member Roll\n\n NOTE\n It can take a short time for the Operator to finish copying the resources, therefore you may need to refresh the screen to see the Create Istio Service Mesh Member Roll button.\n\n8. On the Create Service Mesh Member Roll page, modify the YAML to add your projects as members. You can add any number of projects, but a project can only belong to one ServiceMeshMemberRoll resource.\n\n9. Click Create to save the Service Mesh Member Roll.\n\n3.2.1.6.2. Creating the member roll from the CLI\n\nFollow this procedure to add a project to the ServiceMeshMemberRoll from the command line.\n\nPrerequisites\n\n• An installed, verified Red Hat OpenShift Service Mesh Operator.\n\n• Location of the installed ServiceMeshControlPlane.\n\n• List of projects to add to the service mesh.\n\n• Access to the OpenShift Container Platform Command-line Interface (CLI) commonly known as oc.\n\nProcedure\n\n1. Log in to the OpenShift Container Platform CLI.\n2. Create a `ServiceMeshMemberRoll` resource in the same project as the `ServiceMeshControlPlane` resource, in our example that is `istio-system`. The resource must be named `default`.\n\n```bash\n$ oc create -n istio-system -f servicemeshmemberroll-default.yaml\n```\n\n**Example servicemeshmemberroll-default.yaml**\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshMemberRoll\nmetadata:\n name: default\n namespace: istio-system\nspec:\n members:\n # a list of projects joined into the service mesh\n - your-project-name\n - another-project-name\n```\n\n3. Modify the default YAML to add your projects as `members`. You can add any number of projects, but a project can only belong to one `ServiceMeshMemberRoll` resource.\n\n### 3.2.1.6.3. Creating the Red Hat OpenShift Service Mesh members\n\n`ServiceMeshMember` resources can be created by service mesh users who don’t have privileges to add members to the `ServiceMeshMemberRoll` directly. While project administrators are automatically given permission to create the `ServiceMeshMember` resource in their project, they cannot point it to any `ServiceMeshControlPlane` until the service mesh administrator explicitly grants access to the service mesh. Administrators can grant users permissions to access the mesh by granting them the `mesh-user` user role, for example:\n\n```bash\n$ oc policy add-role-to-user -n <control-plane-namespace> --role-namespace <control-plane-namespace> mesh-user <user-name>.\n```\n\nAdministrators can modify the `mesh user` role binding in the control plane project to specify the users and groups that are granted access. The `ServiceMeshMember` adds the project to the `ServiceMeshMemberRoll` within the control plane project it references.\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshMember\nmetadata:\n name: default\nspec:\n controlPlaneRef:\n namespace: control-plane-namespace\n name: minimal-install\n```\n\nThe mesh-users role binding is created automatically after the administrator creates the `ServiceMeshControlPlane` resource. An administrator can use the following command to add a role to a user.\n$ oc policy add-role-to-user\n\nThe administrator can also create the `mesh-user` role binding before the administrator creates the `ServiceMeshControlPlane` resource. For example, the administrator can create it in the same `oc apply` operation as the `ServiceMeshControlPlane` resource.\n\nThis example adds a role binding for `alice`:\n\n```yaml\napiVersion: rbac.authorization.k8s.io/v1\nkind: RoleBinding\nmetadata:\n namespace: control-plane-namespace\n name: mesh-users\nroleRef:\n apiGroup: rbac.authorization.k8s.io\n kind: Role\n name: mesh-user\nsubjects:\n- apiGroup: rbac.authorization.k8s.io\n kind: User\n name: alice\n```\n\n3.2.1.7. Adding or removing projects from the service mesh\n\nFollow this procedure to modify an existing Service Mesh `ServiceMeshMemberRoll` resource using the web console.\n\n- You can add any number of projects, but a project can only belong to one `ServiceMeshMemberRoll` resource.\n\n- The `ServiceMeshMemberRoll` resource is deleted when its corresponding `ServiceMeshControlPlane` resource is deleted.\n\n3.2.1.7.1. Modifying the member roll from the web console\n\nPrerequisites\n\n- An installed, verified Red Hat OpenShift Service Mesh Operator.\n\n- An existing `ServiceMeshMemberRoll` resource.\n\n- Name of the project with the `ServiceMeshMemberRoll` resource.\n\n- Names of the projects you want to add or remove from the mesh.\n\nProcedure\n\n1. Log in to the OpenShift Container Platform web console.\n\n2. Navigate to `Operators → Installed Operators`.\n\n3. Click the `Project` menu and choose the project where your `ServiceMeshControlPlane` is deployed from the list, for example `istio-system`.\n\n4. Click the Red Hat OpenShift Service Mesh Operator.\n5. Click the *Istio Service Mesh Member Roll* tab.\n\n6. Click the `default` link.\n\n7. Click the YAML tab.\n\n8. Modify the YAML to add or remove projects as members. You can add any number of projects, but a project can only belong to one *ServiceMeshMemberRoll* resource.\n\n9. Click *Save*.\n\n10. Click *Reload*.\n\n### 3.2.1.7.2. Modifying the member roll from the CLI\n\nFollow this procedure to modify an existing Service Mesh member roll using the command line.\n\n#### Prerequisites\n\n- An installed, verified Red Hat OpenShift Service Mesh Operator.\n- An existing *ServiceMeshMemberRoll* resource.\n- Name of the project with the *ServiceMeshMemberRoll* resource.\n- Names of the projects you want to add or remove from the mesh.\n- Access to the OpenShift Container Platform Command-line Interface (CLI) commonly known as *oc*.\n\n#### Procedure\n\n1. Log in to the OpenShift Container Platform CLI.\n\n2. Edit the *ServiceMeshMemberRoll* resource.\n\n ```sh\n $ oc edit smmr -n <controlplane-namespace>\n ```\n\n3. Modify the YAML to add or remove projects as members. You can add any number of projects, but a project can only belong to one *ServiceMeshMemberRoll* resource.\n\n **Example servicemeshmemberroll-default.yaml**\n\n ```yaml\n apiVersion: maistra.io/v1\n kind: ServiceMeshMemberRoll\n metadata:\n name: default\n namespace: istio-system\n spec:\n members:\n # a list of projects joined into the service mesh\n - your-project-name\n - another-project-name\n ```\n\n### 3.2.1.8. Deleting the Red Hat OpenShift Service Mesh member roll\nThe ServiceMeshMemberRole resource is automatically deleted when you delete the ServiceMeshControlPlane resource it is associated with.\n\n### 3.2.2. Updating your application pods\n\nIf you selected the Automatic Approval Strategy when you were installing your Operators, then the Operators update the control plane automatically, but not your applications. Existing applications continue to be part of the mesh and function accordingly. The application administrator must restart applications to upgrade the sidecar.\n\nIf your deployment uses Automatic sidecar injection, you can update the pod template in the deployment by adding or modifying an annotation. Run the following command to redeploy the pods:\n\n```bash\n$ oc patch deployment/<deployment> -p '{\"spec\":{\"template\":{\"metadata\":{\"annotations\":\n{\"kubectl.kubernetes.io/restartedAt\": \"'`date -Iseconds`'\"}}}}}'\n```\n\nIf your deployment does not use automatic sidecar injection, you must manually update the sidecars by modifying the sidecar container image specified in the deployment or pod.\n\n**Next steps**\n\n- [Customize the Red Hat OpenShift Service Mesh installation](#).\n- [Prepare to deploy applications](#) on Red Hat OpenShift Service Mesh.\n\n### 3.3. CUSTOMIZING THE RED HAT OPENSHEFT SERVICE MESH INSTALLATION\n\nYou can customize your Red Hat OpenShift Service Mesh by modifying the default Service Mesh custom resource or by creating a new custom resource.\n\n**Prerequisites**\n\n- An account with the cluster-admin role.\n- Completed the [Preparing to install Red Hat OpenShift Service Mesh](#) process.\n- Have installed the operators.\n\n### 3.3.1. Red Hat OpenShift Service Mesh custom resources\n\n**NOTE**\n\nThe istio-system project is used as an example throughout the Service Mesh documentation, but you can use other projects as necessary.\n\nA custom resource allows you to extend the API in an Red Hat OpenShift Service Mesh project or cluster. When you deploy Service Mesh it creates a default ServiceMeshControlPlane that you can modify to change the project parameters.\n\nThe Service Mesh operator extends the API by adding the ServiceMeshControlPlane resource type, which enables you to create ServiceMeshControlPlane objects within projects. By creating a ServiceMeshControlPlane object, you instruct the Operator to install a Service Mesh control plane into\nthe project, configured with the parameters you set in the `ServiceMeshControlPlane` object.\n\nThis example `ServiceMeshControlPlane` definition contains all of the supported parameters and deploys Red Hat OpenShift Service Mesh 1.1.1 images based on Red Hat Enterprise Linux (RHEL).\n\n**IMPORTANT**\n\nThe 3scale Istio Adapter is deployed and configured in the custom resource file. It also requires a working 3scale account (SaaS or On-Premises).\n\n**Full example istio-installation.yaml**\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshControlPlane\nmetadata:\n name: full-install\nspec:\n\n istio:\n global:\n proxy:\n resources:\n requests:\n cpu: 100m\n memory: 128Mi\n limits:\n cpu: 500m\n memory: 128Mi\n\n gateways:\n istio-egressgateway:\n autoscaleEnabled: false\n istio-ingressgateway:\n autoscaleEnabled: false\n\n mixer:\n policy:\n autoscaleEnabled: false\n\n telemetry:\n autoscaleEnabled: false\n resources:\n requests:\n cpu: 100m\n memory: 1G\n limits:\n cpu: 500m\n memory: 4G\n\n pilot:\n autoscaleEnabled: false\n traceSampling: 100\n\n kiali:\n enabled: true\n```\n3.3.2. **ServiceMeshControlPlane** parameters\n\nThe following examples illustrate use of the **ServiceMeshControlPlane** parameters and the tables provide additional information about supported parameters.\n\n**IMPORTANT**\n\nThe resources you configure for Red Hat OpenShift Service Mesh with these parameters, including CPUs, memory, and the number of pods, are based on the configuration of your OpenShift cluster. Configure these parameters based on the available resources in your current cluster configuration.\n\n### 3.3.2.1. Istio global example\n\nHere is an example that illustrates the Istio global parameters for the **ServiceMeshControlPlane** and a description of the available parameters with appropriate values.\n\n**NOTE**\n\nIn order for the 3scale Istio Adapter to work, `disablePolicyChecks` must be `false`.\n\n#### Example global parameters\n\n```yaml\nistio:\n global:\n tag: 1.1.0\n hub: registry.redhat.io/openshift-service-mesh/\n proxy:\n resources:\n requests:\n cpu: 10m\n memory: 128Mi\n limits:\n mtlis:\n enabled: false\n disablePolicyChecks: true\n policyCheckFailOpen: false\n imagePullSecrets:\n - MyPullSecret\n```\n\n<table>\n<thead>\n<tr>\n<th>grafana: enabled: true</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>tracing: enabled: true</td>\n</tr>\n</tbody>\n</table>\n| jaeger:\n template: all-in-one |\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>disablePolicyChecks</td>\n<td>This parameter enables/disables policy checks.</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td>policyCheckFailOpen</td>\n<td>This parameter indicates whether traffic is allowed to pass through to the Envoy sidecar when the Mixer policy service cannot be reached.</td>\n<td>true/false</td>\n<td>false</td>\n</tr>\n<tr>\n<td>tag</td>\n<td>The tag that the Operator uses to pull the Istio images.</td>\n<td>A valid container image tag.</td>\n<td>1.1.0</td>\n</tr>\n<tr>\n<td>hub</td>\n<td>The hub that the Operator uses to pull Istio images.</td>\n<td>A valid image repository.</td>\n<td>maistra/ or registry.redhat.io/openshift-service-mesh/</td>\n</tr>\n<tr>\n<td>mtlis</td>\n<td>This parameter controls whether to enable/disable Mutual Transport Layer Security (mTLS) between services by default.</td>\n<td>true/false</td>\n<td>false</td>\n</tr>\n<tr>\n<td>imagePullSecrets</td>\n<td>If access to the registry providing the Istio images is secure, list an imagePullSecret here.</td>\n<td>redhat-registry-pullsecret OR quay-pullsecret</td>\n<td>None</td>\n</tr>\n</tbody>\n</table>\n\nThese parameters are specific to the proxy subset of global parameters.\n\nTable 3.2. Proxy parameters\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Resources</td>\n<td>cpu</td>\n<td>The amount of CPU resources requested for Envoy proxy.</td>\n<td>CPU resources, specified in cores or millicores (for example, 200m, 0.5, 1) based on your environment’s configuration.</td>\n<td>10m</td>\n</tr>\n</tbody>\n</table>\nThe amount of memory requested for Envoy proxy\nAvailable memory in bytes (for example, 200Ki, 50Mi, 5Gi) based on your environment’s configuration.\n\nLimits\n\nThe maximum amount of CPU resources requested for Envoy proxy.\nCPU resources, specified in cores or millicores (for example, 200m, 0.5, 1) based on your environment’s configuration.\n\nThe maximum amount of memory Envoy proxy is permitted to use.\nAvailable memory in bytes (for example, 200Ki, 50Mi, 5Gi) based on your environment’s configuration.\n\n3.3.2.2. Istio gateway configuration\n\nHere is an example that illustrates the Istio gateway parameters for the ServiceMeshControlPlane and a description of the available parameters with appropriate values.\n\nExample gateway parameters\n\n```yaml\ngateways:\n istio-egressgateway:\n autoscaleEnabled: false\n autoscaleMin: 1\n autoscaleMax: 5\n istio-ingressgateway:\n autoscaleEnabled: false\n autoscaleMin: 1\n autoscaleMax: 5\n```\n\nTable 3.3. Istio Gateway parameters\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>istio-egressgateway</td>\n<td>autoscaleEnabled</td>\n<td>This parameter enables/disables autoscaling.</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td>Type</td>\n<td>Parameter</td>\n<td>Description</td>\n<td>Values</td>\n<td>Default value</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></td>\n<td>autoscaleMin</td>\n<td>The minimum number of pods to deploy for the egress gateway based on the</td>\n<td>A valid number of allocatable pods based on your environment’s</td>\n<td>1</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>autoscaleEnabled setting.</td>\n<td>configuration.</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>autoscaleMax</td>\n<td>The maximum number of pods to deploy for the egress gateway based on the</td>\n<td>A valid number of allocatable pods based on your environment’s</td>\n<td>5</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>autoscaleEnabled setting.</td>\n<td>configuration.</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>istio-</td>\n<td>autoscaleEnabled</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td></td>\n<td>ingressgateway</td>\n<td>This parameter enables/disables autoscaling.</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>autoscaleMin</td>\n<td>The minimum number of pods to deploy for the ingress gateway based on the</td>\n<td>A valid number of allocatable pods based on your environment’s</td>\n<td>1</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>autoscaleEnabled setting.</td>\n<td>configuration.</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>autoscaleMax</td>\n<td>The maximum number of pods to deploy for the ingress gateway based on the</td>\n<td>A valid number of allocatable pods based on your environment’s</td>\n<td>5</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>autoscaleEnabled setting.</td>\n<td>configuration.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**3.3.2.3. Istio Mixer configuration**\n\nHere is an example that illustrates the Mixer parameters for the `ServiceMeshControlPlane` and a description of the available parameters with appropriate values.\n\n**Example mixer parameters**\n\n```yaml\nmixer:\n enabled: true\npolicy:\n autoscaleEnabled: false\ntelemetry:\n autoscaleEnabled: false\nresources:\n```\nrequests:\ncpu: 10m\nmemory: 128Mi\nlimits:\n\nTable 3.4. Istio Mixer policy parameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>enabled</td>\n<td>This parameter enables/disables Mixer.</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td>autoscaleEnabled</td>\n<td>This parameter enables/disables autoscaling. Disable this for small environments.</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td>autoscaleMin</td>\n<td>The minimum number of pods to deploy based on the autoscaleEnabled setting.</td>\n<td>A valid number of allocatable pods based on your environment’s configuration.</td>\n<td>1</td>\n</tr>\n<tr>\n<td>autoscaleMax</td>\n<td>The maximum number of pods to deploy based on the autoscaleEnabled setting.</td>\n<td>A valid number of allocatable pods based on your environment’s configuration.</td>\n<td>5</td>\n</tr>\n</tbody>\n</table>\n\nTable 3.5. Istio Mixer telemetry parameters\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Resources</td>\n<td>cpu</td>\n<td>The percentage of CPU resources requested for Mixer telemetry.</td>\n<td>CPU resources in millicores based on your environment’s configuration.</td>\n<td>10m</td>\n</tr>\n<tr>\n<td></td>\n<td>memory</td>\n<td>The amount of memory requested for Mixer telemetry.</td>\n<td>Available memory in bytes (for example, 200Ki, 50Mi, 5Gi) based on your environment’s configuration.</td>\n<td>128Mi</td>\n</tr>\n<tr>\n<td>Limits</td>\n<td>cpu</td>\n<td>The maximum percentage of CPU resources Mixer telemetry is permitted to use.</td>\n<td>CPU resources in millicores based on your environment’s configuration.</td>\n<td>4800m</td>\n</tr>\n</tbody>\n</table>\nThe maximum amount of memory Mixer telemetry is permitted to use.\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>memory</td>\n<td>The maximum amount of memory requested for Pilot.</td>\n<td>Available memory in bytes (for example, 200Ki, 50Mi, 5Gi) based on your environment’s configuration.</td>\n<td>4G</td>\n</tr>\n</tbody>\n</table>\n\n### 3.3.2.4. Istio Pilot configuration\n\nHere is an example that illustrates the Istio Pilot parameters for the **ServiceMeshControlPlane** and a description of the available parameters with appropriate values.\n\n**Example pilot parameters**\n\n```yaml\npilot:\n resources:\n requests:\n cpu: 100m\n memory: 128Mi\n autoscaleEnabled: false\n traceSampling: 100\n```\n\n**Table 3.6. Istio Pilot parameters**\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>cpu</td>\n<td>The percentage of CPU resources requested for Pilot.</td>\n<td>CPU resources in millicores based on your environment’s configuration.</td>\n<td>10m</td>\n</tr>\n<tr>\n<td>memory</td>\n<td>The amount of memory requested for Pilot.</td>\n<td>Available memory in bytes (for example, 200Ki, 50Mi, 5Gi) based on your environment’s configuration.</td>\n<td>128Mi</td>\n</tr>\n<tr>\n<td>autoscaleEnabled</td>\n<td>This parameter enables/disables autoscaling. Disable this for small environments.</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td>traceSampling</td>\n<td>This value controls how often random sampling occurs. <strong>Note:</strong> Increase for development or testing.</td>\n<td>A valid percentage.</td>\n<td>1.0</td>\n</tr>\n</tbody>\n</table>\n3.3.3. Configuring Kiali\n\nWhen the Service Mesh Operator creates the ServiceMeshControlPlane it also processes the Kiali resource. The Kiali Operator then uses this object when creating Kiali instances.\n\nThe default Kiali parameters specified in the ServiceMeshControlPlane are as follows:\n\nExample Kiali parameters\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshControlPlane\nspec:\n kiali:\n enabled: true\n dashboard:\n viewOnlyMode: false\n ingress:\n enabled: true\n```\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>enabled</td>\n<td>This parameter enables/disables Kiali. Kiali is enabled by default.</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td>dashboard viewOnlyMode</td>\n<td>This parameter enables/disables view-only mode for the Kiali console. When view-only mode is enabled, users cannot use the console to make changes to the Service Mesh.</td>\n<td>true/false</td>\n<td>false</td>\n</tr>\n<tr>\n<td>ingress enabled</td>\n<td>This parameter enables/disables ingress for Kiali.</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n</tbody>\n</table>\n\n3.3.3.1. Configuring Kiali for Grafana\n\nWhen you install Kiali and Grafana as part of Red Hat OpenShift Service Mesh the Operator configures the following by default:\n\n- Grafana is enabled as an external service for Kiali\n- Grafana authorization for the Kiali console\n- Grafana URL for the Kiali console\nKiali can automatically detect the Grafana URL. However if you have a custom Grafana installation that is not easily auto-detectable by Kiali, you must update the URL value in the `ServiceMeshControlPlane` resource.\n\n**Additional Grafana parameters**\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshControlPlane\nspec:\ntemplated:\n istio:\n kiali:\n enabled: true\n dashboard:\n viewOnlyMode: false\n grafanaURL: \"https://grafana-istio-system.127.0.0.1.nip.io\"\n ingress:\n enabled: true\n```\n\n### 3.3.3.2. Configuring Kiali for Jaeger\n\nWhen you install Kiali and Jaeger as part of Red Hat OpenShift Service Mesh the Operator configures the following by default:\n\n- Jaeger is enabled as an external service for Kiali\n- Jaeger authorization for the Kiali console\n- Jaeger URL for the Kiali console\n\nKiali can automatically detect the Jaeger URL. However if you have a custom Jaeger installation that is not easily auto-detectable by Kiali, you must update the URL value in the `ServiceMeshControlPlane` resource.\n\n**Additional Jaeger parameters**\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshControlPlane\nspec:\ntemplated:\n istio:\n kiali:\n enabled: true\n dashboard:\n viewOnlyMode: false\n jaegerURL: \"http://jaeger-query-istio-system.127.0.0.1.nip.io\"\n ingress:\n enabled: true\n```\n\n### 3.3.4. Configuring Jaeger\n\nWhen the Service Mesh Operator creates the `ServiceMeshControlPlane` resource it also creates the Jaeger resource. The Jaeger Operator then uses this object when creating Jaeger instances.\n\nThe default Jaeger parameters specified in the `ServiceMeshControlPlane` are as follows:\n\n**Default all-in-one Jaeger parameters**\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshControlPlane\nspec:\n istio:\n```\ntracing:\nenabled: true\ndaeger:\ntemplate: all-in-one\n\nTable 3.8. Jaeger parameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>tracing enabled</td>\n<td>This parameter enables/disables tracing in Service Mesh. Jaeger is installed by default.</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td>jaeger template</td>\n<td>This parameter specifies which Jaeger deployment strategy to use.</td>\n<td>all-in-one, all-in-one</td>\n<td>all-in-one</td>\n</tr>\n</tbody>\n</table>\n\nNOTE\n\nThe default template in the ServiceMeshControlPlane resource is the all-in-one deployment strategy which uses in-memory storage. For production, the only supported storage option is Elasticsearch, therefore you must configure the ServiceMeshControlPlane to request the production-elasticsearch template when you deploy Service Mesh within a production environment.\n\n3.3.4.1. Configuring Elasticsearch\n\nThe default Jaeger deployment strategy uses the all-in-one template so that the installation can be completed using minimal resources. However, because the all-in-one template uses in-memory storage, it is only recommended for development, demo, or testing purposes and should NOT be used for production environments.\n\nIf you are deploying Service Mesh and Jaeger in a production environment you must change the template to the production-elasticsearch template, which uses Elasticsearch for Jaeger’s storage needs.\n\nElasticsearch is a memory intensive application. The initial set of nodes specified in the default OpenShift Container Platform installation may not be large enough to support the Elasticsearch cluster. You should modify the default Elasticsearch configuration to match your use case and the resources you have requested for your OpenShift Container Platform installation. You can adjust both the CPU and memory limits for each component by modifying the resources block with valid CPU and memory values. Additional nodes must be added to the cluster if you want to run with the recommended amount (or more) of memory. Ensure that you do not exceed the resources requested for your OpenShift Container Platform installation.\nDefault \"production\" Jaeger parameters with Elasticsearch\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshControlPlane\nspec:\n istio:\n tracing:\n enabled: true\n ingress:\n enabled: true\n jaeger:\n template: production-elasticsearch\n elasticsearch:\n nodeCount: 3\n redundancyPolicy:\n requests:\n cpu: \"1\"\n memory: \"16Gi\"\n limits:\n cpu: \"1\"\n memory: \"16Gi\"\n```\n\n### Table 3.9. Elasticsearch parameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default Value</th>\n<th>Examples</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>tracing: enabled</td>\n<td>This parameter enables/disables tracing in Service Mesh. Jaeger is installed by default.</td>\n<td>true/false</td>\n<td>true</td>\n<td></td>\n</tr>\n<tr>\n<td>ingress: enabled</td>\n<td>This parameter enables/disables ingress for Jaeger.</td>\n<td>true/false</td>\n<td>true</td>\n<td></td>\n</tr>\n<tr>\n<td>jaeger template</td>\n<td>This parameter specifies which Jaeger deployment strategy to use.</td>\n<td>all-in-one/production-elasticsearch</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>elasticsearch: nodeCount</td>\n<td>Number of Elasticsearch nodes to create.</td>\n<td>Integer value.</td>\n<td>1</td>\n<td>Proof of concept = 1, Minimum deployment = 3</td>\n</tr>\n</tbody>\n</table>\n### Parameter | Description | Values | Default Value | Examples\n--- | --- | --- | --- | ---\n**requests:** cpu | Number of central processing units for requests, based on your environment’s configuration. | Specified in cores or millicores (for example, 200m, 0.5, 1). | 1Gi | Proof of concept = 500m, Minimum deployment = 1\n**requests:** memory | Available memory for requests, based on your environment’s configuration. | Specified in bytes (for example, 200Ki, 50Mi, 5Gi). | 500m | Proof of concept = 1Gi, Minimum deployment = 16Gi*\n**limits:** cpu | Limit on number of central processing units, based on your environment’s configuration. | Specified in cores or millicores (for example, 200m, 0.5, 1). | | Proof of concept = 500m, Minimum deployment = 1\n**limits:** memory | Available memory limit based on your environment’s configuration. | Specified in bytes (for example, 200Ki, 50Mi, 5Gi). | | Proof of concept = 1Gi, Minimum deployment = 16Gi*\n\n* Each Elasticsearch node can operate with a lower memory setting though this is not recommended for production deployments. For production use, you should have no less than 16Gi allocated to each Pod by default, but preferably allocate as much as you can, up to 64Gi per Pod.\n\n### Procedure\n\n1. Log in to the OpenShift Container Platform web console as a user with the `cluster-admin` role.\n\n2. Navigate to **Operators → Installed Operators**.\n\n3. Click the Red Hat OpenShift Service Mesh Operator.\n\n4. Click the **Istio Service Mesh Control Plane** tab.\n\n5. Click the name of your control plane file, for example, `basic-install`.\n\n6. Click the **YAML** tab.\n\n7. Edit the Jaeger parameters, replacing the default `all-in-one` template with parameters for the `production-elasticsearch` template, modified for your use case. Ensure that the indentation is correct.\n\n8. Click **Save**.\n9. Click **Reload**. OpenShift Container Platform redeploy Jaeger and creates the Elasticsearch resources based on the specified parameters.\n\nFor more information about configuring Elasticsearch with OpenShift Container Platform, see Configuring Elasticsearch.\n\n### 3.3.5. 3scale configuration\n\nHere is an example that illustrates the 3scale Istio Adapter parameters for the Red Hat OpenShift Service Mesh custom resource and a description of the available parameters with appropriate values.\n\n#### Example 3scale parameters\n\n```yaml\nthreeScale:\n enabled: false\n PARAM_THREESCALE_LISTEN_ADDR: 3333\n PARAM_THREESCALE_LOG_LEVEL: info\n PARAM_THREESCALE_LOG_JSON: true\n PARAM_THREESCALE_LOG_GRPC: false\n PARAM_THREESCALE_REPORT_METRICS: true\n PARAM_THREESCALE_METRICS_PORT: 8080\n PARAM_THREESCALE_CACHE_TTL_SECONDS: 300\n PARAM_THREESCALE_CACHE_REFRESH_SECONDS: 180\n PARAM_THREESCALE_CACHE_ENTRIES_MAX: 1000\n PARAM_THREESCALE_CACHE_REFRESH_RETRIES: 1\n PARAM_THREESCALE_ALLOW_INSECURE_CONN: false\n PARAM_THREESCALE_CLIENT_TIMEOUT_SECONDS: 10\n PARAM_THREESCALE_GRPC_CONN_MAX_SECONDS: 60\n```\n\n#### Table 3.10. 3scale parameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Description</th>\n<th>Values</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>enabled</td>\n<td>Whether to use the 3scale adapter</td>\n<td><code>true/false</code></td>\n<td><code>false</code></td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_LISTEN_ADDR</td>\n<td>Sets the listen address for the gRPC server</td>\n<td>Valid port number</td>\n<td><code>3333</code></td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_LOG_LEVEL</td>\n<td>Sets the minimum log output level.</td>\n<td><code>debug, info, warn, error, or none</code></td>\n<td><code>info</code></td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_LOG_JSON</td>\n<td>Controls whether the log is formatted as JSON</td>\n<td><code>true/false</code></td>\n<td><code>true</code></td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_LOG_GRPC</td>\n<td>Controls whether the log contains gRPC info</td>\n<td><code>true/false</code></td>\n<td><code>true</code></td>\n</tr>\n<tr>\n<td>Parameter</td>\n<td>Description</td>\n<td>Values</td>\n<td>Default value</td>\n</tr>\n<tr>\n<td>---------------------------------------</td>\n<td>-----------------------------------------------------------------------------</td>\n<td>-----------------------------</td>\n<td>---------------</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_REPORT_METRICS</td>\n<td>Controls whether 3scale system and backend metrics are collected and reported to Prometheus</td>\n<td>true/false</td>\n<td>true</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_METRICS_PORT</td>\n<td>Sets the port that the 3scale /metrics endpoint can be scrapped from</td>\n<td>Valid port number</td>\n<td>8080</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_CACHE_TTL_SECONDS</td>\n<td>Time period, in seconds, to wait before purging expired items from the cache</td>\n<td>Time period in seconds</td>\n<td>300</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_CACHE_REFRESH_SECONDS</td>\n<td>Time period before expiry when cache elements are attempted to be refreshed</td>\n<td>Time period in seconds</td>\n<td>180</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_CACHE_ENTRIES_MAX</td>\n<td>Max number of items that can be stored in the cache at any time. Set to 0 to disable caching</td>\n<td>Valid number</td>\n<td>1000</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_CACHE_REFRESH_RETRIES</td>\n<td>The number of times unreachable hosts are retried during a cache update loop</td>\n<td>Valid number</td>\n<td>1</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_ALLOW_INSECURE_CONN</td>\n<td>Allow to skip certificate verification when calling 3scale APIs. Enabling this is not recommended.</td>\n<td>true/false</td>\n<td>false</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_CLIENT_TIMEOUT_SECONDS</td>\n<td>Sets the number of seconds to wait before terminating requests to 3scale System and Backend</td>\n<td>Time period in seconds</td>\n<td>10</td>\n</tr>\n<tr>\n<td>PARAM_THREESCALE_GRPC_CONN_MAX_SECONDS</td>\n<td>Sets the maximum amount of seconds (+/- 10% jitter) a connection may exist before it is closed</td>\n<td>Time period in seconds</td>\n<td>60</td>\n</tr>\n</tbody>\n</table>\nNext steps\n\n- Prepare to deploy applications on Red Hat OpenShift Service Mesh.\n\n3.4. UPDATING RED HAT OPENSHIFT SERVICE MESH\n\nIf you are updating from Red Hat OpenShift Service Mesh 1.0 to 1.1, you must update the ServiceMeshControlPlane resource to update the control plane components to the new version.\n\n1. In the web console, click the Red Hat OpenShift Service Mesh operator.\n\n2. Click the Project menu and choose the project where your ServiceMeshControlPlane is deployed from the list, for example istio-system.\n\n3. Click the name of your control plane, for example basic-install.\n\n4. Click YAML and add a version field to the spec: of your ServiceMeshControlPlane resource. For example, to update to Red Hat OpenShift Service Mesh 1.1.0, add version: v1.1.\n\n```\nspec:\n version: v1.1\n ...\n```\n\nThe version field specifies the version of ServiceMesh to install and defaults to the latest available version.\n\n3.4.1. Manual updates\n\nIf you choose to update manually, the Operator Lifecycle Manager (OLM) controls the installation, upgrade, and role-based access control (RBAC) of Operators in a cluster. OLM runs by default in OpenShift Container Platform. OLM uses CatalogSources, which use the Operator Registry API, to query for available Operators as well as upgrades for installed Operators.\n\n- For more information about how OpenShift Container Platform handled upgrades, refer to the Operator Lifecycle Manager documentation.\n\n3.5. REMOVING RED HAT OPENSHIFT SERVICE MESH\n\nThis process allows you to remove Red Hat OpenShift Service Mesh from an existing OpenShift Container Platform instance. Remove the control plane before removing the operators.\n\n3.5.1. Removing the Red Hat OpenShift Service Mesh control plane\n\nYou can remove the Service Mesh control plane by using the OpenShift Container Platform web console or the CLI.\n\n3.5.1.1. Removing the control plane with the web console\n\nFollow this procedure to remove the Red Hat OpenShift Service Mesh control plane by using the web console.\n\nPrerequisites\n\n- The Red Hat OpenShift Service Mesh control plane must be deployed.\nProcedure\n\n1. Log in to the OpenShift Container Platform web console.\n2. Click the Project menu and choose the istio-system project from the list.\n3. Navigate to Operators → Installed Operators.\n4. Click on Service Mesh Control Plane under Provided APIs.\n5. Click the ServiceMeshControlPlane menu.\n6. Click Delete Service Mesh Control Plane\n7. Click Delete on the confirmation dialog window to remove the ServiceMeshControlPlane.\n\n3.5.1.2. Removing the control plane from the CLI\n\nFollow this procedure to remove the Red Hat OpenShift Service Mesh control plane by using the CLI.\n\nPrerequisites\n\n- The Red Hat OpenShift Service Mesh control plane must be deployed.\n- Access to the OpenShift Container Platform Command-line Interface (CLI) also known as oc.\n\nPROCEDURE\n\nWhen you remove the ServiceMeshControlPlane, Service Mesh tells the Operator to begin uninstalling everything it installed.\n\nTIP\n\nYou can use the shortened smcp alias in place of servicemeshcontrolplane.\n\n1. Log in to the OpenShift Container Platform CLI.\n2. Run this command to retrieve the name of the installed ServiceMeshControlPlane:\n\n $ oc get servicemeshcontrolplanes -n istio-system\n\n3. Replace <name_of_custom_resource> with the output from the previous command, and run this command to remove the custom resource:\n\n $ oc delete servicemeshcontrolplanes -n istio-system <name_of_custom_resource>\n\n3.5.2. Removing the installed Operators\n\nYou must remove the Operators to successfully remove Red Hat OpenShift Service Mesh. Once you remove the Red Hat OpenShift Service Mesh Operator, you must remove the Jaeger Operator, Kiali Operator, and the Elasticsearch Operator.\n3.5.2.1. Removing the Red Hat OpenShift Service Mesh Operator\n\nFollow this procedure to remove the Red Hat OpenShift Service Mesh Operator.\n\n**Prerequisites**\n\n- Access to the OpenShift Container Platform web console.\n- The Red Hat OpenShift Service Mesh Operator must be installed.\n\n**Procedure**\n\n1. Log in to the OpenShift Container Platform web console.\n2. From the **Operators → Installed Operators** page, scroll or type a keyword into the *Filter by name* to find the Red Hat OpenShift Service Mesh Operator. Then, click on it.\n3. On the right-hand side of the **Operator Details** page, select **Uninstall Operator** from the **Actions** drop-down menu.\n4. When prompted by the **Remove Operator Subscription** window, optionally select the *Also completely remove the Operator from the selected namespace* check box if you want all components related to the installation to be removed. This removes the CSV, which in turn removes the Pods, Deployments, CRDs, and CRs associated with the Operator.\n\n3.5.2.2. Removing the Jaeger Operator\n\nFollow this procedure to remove the Jaeger Operator.\n\n**Prerequisites**\n\n- Access to the OpenShift Container Platform web console.\n- The Jaeger Operator must be installed.\n\n**Procedure**\n\n1. Log in to the OpenShift Container Platform web console.\n2. From the **Operators → Installed Operators** page, scroll or type a keyword into the *Filter by name* to find the Jaeger Operator. Then, click on it.\n3. On the right-hand side of the **Operator Details** page, select **Uninstall Operator** from the **Actions** drop-down menu.\n4. When prompted by the **Remove Operator Subscription** window, optionally select the *Also completely remove the Operator from the selected namespace* check box if you want all components related to the installation to be removed. This removes the CSV, which in turn removes the Pods, Deployments, CRDs, and CRs associated with the Operator.\n\n3.5.2.3. Removing the Kiali Operator\n\nFollow this procedure to remove the Kiali Operator.\n\n**Prerequisites**\n\n...\n- Access to the OpenShift Container Platform web console.\n- The Kiali Operator must be installed.\n\n**Procedure**\n\n1. Log in to the OpenShift Container Platform web console.\n\n2. From the **Operators → Installed Operators** page, scroll or type a keyword into the **Filter by name** to find the Kiali Operator. Then, click on it.\n\n3. On the right-hand side of the **Operator Details** page, select **Uninstall Operator** from the **Actions** drop-down menu.\n\n4. When prompted by the **Remove Operator Subscription** window, optionally select the **Also completely remove the Operator from the selected namespace** check box if you want all components related to the installation to be removed. This removes the CSV, which in turn removes the Pods, Deployments, CRDs, and CRs associated with the Operator.\n\n**3.5.2.4. Removing the Elasticsearch Operator**\n\nFollow this procedure to remove the Elasticsearch Operator.\n\n**Prerequisites**\n\n- Access to the OpenShift Container Platform web console.\n- The Elasticsearch Operator must be installed.\n\n**Procedure**\n\n1. Log in to the OpenShift Container Platform web console.\n\n2. From the **Operators → Installed Operators** page, scroll or type a keyword into the **Filter by name** to find the Elasticsearch Operator. Then, click on it.\n\n3. On the right-hand side of the **Operator Details** page, select **Uninstall Operator** from the **Actions** drop-down menu.\n\n4. When prompted by the **Remove Operator Subscription** window, optionally select the **Also completely remove the Operator from the selected namespace** check box if you want all components related to the installation to be removed. This removes the CSV, which in turn removes the Pods, Deployments, CRDs, and CRs associated with the Operator.\n\n**3.5.2.5. Clean up Operator resources**\n\nFollow this procedure to manually remove resources left behind after removing the Red Hat OpenShift Service Mesh Operator by using the OperatorHub interface.\n\n**Prerequisites**\n\n- An account with cluster administration access.\n- Access to the OpenShift Container Platform Command-line Interface (CLI) also known as **oc**.\nProcedure\n\n1. Log in to the OpenShift Container Platform CLI as a cluster administrator.\n\n2. Run the following commands to clean up resources after uninstalling the Operators:\n\n ```\n $ oc delete validatingwebhookconfiguration/<operator-project>.servicemesh-resources.maistra.io\n $ oc delete mutatingwebhookconfigurations/<operator-project>.servicemesh-resources.maistra.io\n $ oc delete -n <operator-project> daemonset/istio-node\n $ oc delete clusterrole/istio-admin clusterrole/istio-cni clusterrolebinding/istio-cni\n $ oc get crds -o name | grep '\\.istio\\.io' | xargs -r -n 1 oc delete\n $ oc get crds -o name | grep '\\.maistra\\.io' | xargs -r -n 1 oc delete\n ```\n\n **NOTE**\n\n Replace `<operator-project>` with the name of the project where the Red Hat OpenShift Service Mesh Operator was installed. This is typically `openshift-operators`.\nCHAPTER 4. DAY TWO\n\n4.1. DEPLOYING APPLICATIONS ON RED HAT OPENSSHIFT SERVICE MESH\n\nWhen you deploy an application into the Service Mesh, there are several differences between the behavior of applications in the upstream community version of Istio and the behavior of applications within a Red Hat OpenShift Service Mesh installation.\n\nPrerequisites\n\n- Review Comparing Red Hat OpenShift Service Mesh and upstream Istio community installations\n- Review Installing Red Hat OpenShift Service Mesh\n\n4.1.1. Creating control plane templates\n\nYou can create reusable configurations with `ServiceMeshControlPlane` templates. Individual users can extend the templates you create with their own configurations. Templates can also inherit configuration information from other templates. For example, you can create an accounting control plane for the accounting team and a marketing control plane for the marketing team. If you create a development template and a production template, members of the marketing team and the accounting team can extend the development and production templates with team specific customization.\n\nWhen you configure control plane templates, which follow the same syntax as the `ServiceMeshControlPlane`, users inherit settings in a hierarchical fashion. The Operator is delivered with a default template with default settings for Red Hat OpenShift Service Mesh. To add custom templates you must create a ConfigMap named `smcp-templates` in the `openshift-operators` project and mount the ConfigMap in the Operator container at `/usr/local/share/istio-operator/templates`.\n\n4.1.1.1. Creating the ConfigMap\n\nFollow this procedure to create the ConfigMap.\n\nPrerequisites\n\n- An installed, verified Service Mesh Operator.\n- An account with the `cluster-admin` role.\n- Location of the Operator deployment.\n- Access to the OpenShift Container Platform Command-line Interface (CLI) also known as `oc`.\n\nProcedure\n\n1. Log in to the OpenShift Container Platform CLI as a cluster administrator.\n\n2. From the CLI, run this command to create the ConfigMap named `smcp-templates` in the `openshift-operators` project and replace `<templates-directory>` with the location of the `ServiceMeshControlPlane` files on your local disk:\n\n ```bash\n $ oc create configmap --from-file=<templates-directory> smcp-templates -n openshift-operators\n ```\n3. Locate the Operator ClusterServiceVersion name.\n\n```bash\n$ oc get clusterserviceversion -n openshift-operators | grep 'Service Mesh'\nmaistra.v1.0.0 Red Hat OpenShift Service Mesh 1.0.0 Succeeded\n```\n\n4. Edit the Operator cluster service version to instruct the Operator to use the `smcp-templates` ConfigMap.\n\n```bash\n$ oc edit clusterserviceversion -n openshift-operators maistra.v1.0.0\n```\n\n5. Add a volume mount and volume to the Operator deployment.\n\n```yaml\ndeployments:\n - name: istio-operator\n spec:\n template:\n spec:\n containers:\n volumeMounts:\n - name: discovery-cache\n mountPath: /home/istio-operator/.kube/cache/discovery\n - name: smcp-templates\n mountPath: /usr/local/share/istio-operator/templates/\n volumes:\n - name: discovery-cache\n emptyDir:\n medium: Memory\n - name: smcp-templates\n configMap:\n name: smcp-templates\n```\n\n6. Save your changes and exit the editor.\n\n7. You can now use the `template` parameter in the `ServiceMeshControlPlane` to specify a template.\n\n```yaml\napiVersion: maistra.io/v1\nkind: ServiceMeshControlPlane\nmetadata:\n name: minimal-install\nspec:\n template: default\n```\n\n### 4.1.2. Red Hat OpenShift Service Mesh's sidecar injection\n\nRed Hat OpenShift Service Mesh relies on a proxy sidecar within the application’s pod to provide Service Mesh capabilities to the application. You can enable automatic sidecar injection or manage it manually. Red Hat recommends automatic injection using the annotation with no need to label projects. This ensures that your application contains the appropriate configuration for the Service Mesh upon deployment. This method requires fewer privileges and does not conflict with other OpenShift capabilities such as builder pods.\nNOTE\n\nThe upstream version of Istio injects the sidecar by default if you have labeled the project. Red Hat OpenShift Service Mesh requires you to opt in to having the sidecar automatically injected to a deployment, so you are not required to label the project. This avoids injecting a sidecar if it is not wanted (for example, in build or deploy pods).\n\nThe webhook checks the configuration of pods deploying into all projects to see if they are opting in to injection with the appropriate annotation.\n\n4.1.2.1. Enabling automatic sidecar injection\n\nWhen deploying an application into the Red Hat OpenShift Service Mesh you must opt in to injection by specifying the `sidecar.istio.io/inject` annotation with a value of \"true\". Opting in ensures that the sidecar injection does not interfere with other OpenShift features such as builder pods used by numerous frameworks within the OpenShift ecosystem.\n\nPrerequisites\n\n- Identify the deployments for which you want to enable automatic sidecar injection.\n- Locate the application’s YAML configuration file.\n\nProcedure\n\n1. Open the application’s configuration YAML file in an editor.\n\n2. Add `sidecar.istio.io/inject` to the configuration YAML with a value of \"true\" as illustrated here:\n\n```\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: sleep\nspec:\n replicas: 1\n template:\n metadata:\n annotations:\n sidecar.istio.io/inject: \"true\"\n labels:\n app: sleep\n spec:\n containers:\n - name: sleep\n image: tutum/curl\n command: [\"/bin/sleep\",\"infinity\"]\n imagePullPolicy: IfNotPresent\n```\n\n3. Save the configuration file.\n\n4.1.2.2. Updating Mixer policy enforcement\nIn previous versions of Red Hat OpenShift Service Mesh, Mixer's policy enforcement was enabled by default. Mixer policy enforcement is now disabled by default. You must enable it before running policy tasks.\n\n**Prerequisites**\n\n- Access to the OpenShift Container Platform Command-line Interface (CLI) also known as **oc**.\n\n**Procedure**\n\n1. Log in to the OpenShift Container Platform CLI.\n2. Run this command to check the current Mixer policy enforcement status:\n ```bash\n $ oc get cm -n istio-system istio -o jsonpath='{.data.mesh}' | grep disablePolicyChecks\n ```\n3. If `disablePolicyChecks: true`, edit the Service Mesh ConfigMap:\n ```bash\n $ oc edit cm -n istio-system istio\n ```\n4. Locate `disablePolicyChecks: true` within the ConfigMap and change the value to **false**.\n5. Save the configuration and exit the editor.\n6. Re-check the Mixer policy enforcement status to ensure it is set to **false**.\n\n**4.1.3. Setting the correct network policy**\n\nService Mesh creates network policies in the control plane and member namespaces to whitelist traffic between them. Before you deploy, consider the following conditions to ensure the services in your mesh that were previously exposed through an OpenShift Container Platform route.\n\n- Traffic into the mesh must always go through the ingress-gateway for Istio to work properly.\n- Deploy services external to the mesh in separate namespaces that are not in any mesh.\n- Non-mesh services that need to be deployed within a service mesh enlisted namespace should label their deployments **maistra.io/expose-route: “true”**, which ensures OpenShift Container Platform routes to these services still work.\n\n**Next steps**\n\n- Deploy Bookinfo on Red Hat OpenShift Service Mesh.\n\n**4.2. CONFIGURING YOUR SERVICE MESH FOR DISTRIBUTED TRACING**\n\nThis section describes configuration that is performed in the CRD or in the CR file.\n\n**Prerequisites**\n\n- Access to an OpenShift Container Platform cluster with cluster-admin user privileges.\n- Elasticsearch operator has been installed on the cluster.\nJaeger operator has been installed on the cluster.\n\n### 4.2.1. Configuring the Elasticsearch index cleaner job\n\nWhen the Service Mesh Operator creates the **ServiceMeshControlPlane** it also creates the custom resource (CR) for Jaeger. The Jaeger operator then uses this CR when creating Jaeger instances.\n\nWhen using Elasticsearch storage, by default a job is created to clean old traces from it. To configure the options for this job, you edit the Jaeger custom resource (CR), to customize it for your use case. The relevant options are listed below.\n\n```yaml\napiVersion: jaegertracing.io/v1\nkind: Jaeger\nspec:\n strategy: production\n storage:\n type: elasticsearch\n esIndexCleaner:\n enabled: false\n numberOfDays: 7\n schedule: \"55 23 * * *\"\n```\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Values</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>enabled</td>\n<td>true/ false</td>\n<td>Enable or disable the index cleaner job.</td>\n</tr>\n<tr>\n<td>numberOfDays</td>\n<td>integer</td>\n<td>Number of days to wait before deleting an index.</td>\n</tr>\n<tr>\n<td>schedule</td>\n<td>"55 23 * * *"</td>\n<td>Cron expression for the job to run</td>\n</tr>\n</tbody>\n</table>\n\n### 4.3. EXAMPLE APPLICATION\n\n**WARNING**\n\nThe Bookinfo example application allows you to test your Red Hat OpenShift Service Mesh 1.1.1 installation on OpenShift Container Platform.\n\nRed Hat does not provide support for the Bookinfo application.\n\n#### 4.3.1. Bookinfo application\n\nThe upstream Istio project has an example tutorial called **Bookinfo**, which is composed of four separate microservices used to demonstrate various Istio features. The Bookinfo application displays information...\nabout a book, similar to a single catalog entry of an online book store. Displayed on the page is a\n\nThe Bookinfo application consists of these microservices:\n\n- The **productpage** microservice calls the **details** and **reviews** microservices to populate the\n page.\n- The **details** microservice contains book information.\n- The **reviews** microservice contains book reviews. It also calls the **ratings** microservice.\n- The **ratings** microservice contains book ranking information that accompanies a book review.\n\nThere are three versions of the reviews microservice:\n\n- Version v1 does not call the **ratings** Service.\n- Version v2 calls the **ratings** Service and displays each rating as one to five black stars.\n- Version v3 calls the **ratings** Service and displays each rating as one to five red stars.\n\n### 4.3.2. Installing the Bookinfo application\n\nThis tutorial walks you through creating a Bookinfo project, deploying the Bookinfo application, and\nrunning Bookinfo on OpenShift Container Platform with Service Mesh 1.1.1.\n\n**Prerequisites:**\n\n- OpenShift Container Platform 4.1 or higher installed.\n- Red Hat OpenShift Service Mesh 1.1.1 installed.\n- Access to the OpenShift Container Platform Command-line Interface (CLI) also known as **oc**.\n\n**NOTE**\n\nRed Hat OpenShift Service Mesh implements auto-injection differently than the\nupstream Istio project, therefore this procedure uses a version of the **bookinfo.yaml** file\nannotated to enable automatic injection of the Istio sidecar for Red Hat OpenShift\nService Mesh.\n\n**Procedure**\n\n1. Log in to the OpenShift Container Platform web console as a user with cluster-admin rights.\n2. Click to **Home → Projects**.\n3. Click **Create Project**.\n4. Enter **bookinfo** as the **Project Name**, enter a **Display Name**, and enter a **Description**, then click **Create**.\n - Alternatively, you can run this command from the CLI to create the **bookinfo** project.\n ```\n $ oc new-project bookinfo\n ```\n5. Click **Operators** → **Installed Operators**.\n\n6. Click the **Project** menu and use the control plane namespace. In this example, use **istio-system**.\n\n7. Click the **Red Hat OpenShift Service Mesh** Operator.\n\n8. Click the **Istio Service Mesh Member Roll** link.\n \n a. If you have already created a Istio Service Mesh Member Roll, click the name, then click the YAML tab to open the YAML editor.\n \n b. If you have not created a Istio Service Mesh Member Roll, click **Create Service Mesh Member Roll**.\n\n **NOTE**\n \n You need cluster-admin rights to edit the Istio Service Mesh Member Roll.\n\n9. Edit the default Service Mesh Member Roll YAML and add **bookinfo** to the **members** list.\n\n **Bookinfo ServiceMeshMemberRoll example**\n \n ```yaml\n apiVersion: maistra.io/v1\n kind: ServiceMeshMemberRoll\n metadata:\n name: default\n spec:\n members:\n - bookinfo\n \n - Alternatively, you can run this command from the CLI to add the **bookinfo** project to the **ServiceMeshMemberRoll**. Replace `<control plane project>` with the name of your control plane project.\n \n ```bash\n $ oc -n <control plane project> patch --type='json' smmr default -p '[{\"op\": \"add\", \"path\": \"/spec/members\", \"value\": [\"bookinfo\"]}]'\n ```\n\n10. Click **Create** to save the updated Service Mesh Member Roll.\n\n11. From the CLI, deploy the Bookinfo application in the `bookinfo` project by applying the **bookinfo.yaml** file:\n\n ```bash\n $ oc apply -n bookinfo -f https://raw.githubusercontent.com/Maistra/istio/maistra-1.1/samples/bookinfo/platform/kube/bookinfo.yaml\n $ oc apply -n bookinfo -f https://raw.githubusercontent.com/Maistra/istio/maistra-1.1/samples/bookinfo/networking/bookinfo-gateway.yaml\n ```\n\n12. Create the ingress gateway by applying the **bookinfo-gateway.yaml** file:\n\n ```bash\n $ oc apply -n bookinfo -f https://raw.githubusercontent.com/Maistra/istio/maistra-1.1/samples/bookinfo/networking/bookinfo-gateway.yaml\n ```\n\n13. Set the value for the **GATEWAY_URL** parameter:\nNOTE\n\nReplace `<control_plane_project>` with the name of your control plane project. In this example, the control plane project is `istio-system`.\n\n```bash\n$ export GATEWAY_URL=$(oc -n <control_plane_project> get route istio-ingressgateway -o jsonpath='{.spec.host}')\n```\n\n4.3.3. Adding default destination rules\n\nBefore you can use the Bookinfo application, you have to add default destination rules. There are two preconfigured YAML files, depending on whether or not you enabled mutual transport layer security (TLS) authentication.\n\nProcedure\n\n1. To add destination rules, run one of the following commands:\n\n - If you did not enable mutual TLS:\n ```bash\n $ oc apply -n bookinfo -f https://raw.githubusercontent.com/Maistra/istio/maistra-1.1/samples/bookinfo/networking/destination-rule-all.yaml\n ```\n\n - If you enabled mutual TLS:\n ```bash\n $ oc apply -n bookinfo -f https://raw.githubusercontent.com/Maistra/istio/maistra-1.1/samples/bookinfo/networking/destination-rule-all-mtls.yaml\n ```\n\n4.3.4. Verifying the Bookinfo installation\n\nBefore configuring your application, verify that it successfully deployed.\n\nPrerequisites\n\n- OpenShift Container Platform 4.1 or higher installed.\n- Red Hat OpenShift Service Mesh 1.1.1 installed.\n- Access to the OpenShift Container Platform Command-line Interface (CLI) also known as `oc`.\n\nProcedure\n\n1. Log in to the OpenShift Container Platform CLI.\n\n2. Run this command to confirm that Bookinfo is deployed:\n\n ```bash\n $ curl -o /dev/null -s -w \"\\nhttp_code\\n\" http://$GATEWAY_URL/productpage\n ```\n\n Alternatively, you can open [http://$GATEWAY_URL/productpage](http://$GATEWAY_URL/productpage) in your browser.\n\n You can also verify that all pods are ready with this command:\n\n ```bash\n $ oc get pods -n bookinfo\n ```\n4.3.5. Removing the Bookinfo application\n\nFollow these steps to remove the Bookinfo application.\n\nPrerequisites\n\n- OpenShift Container Platform 4.1 or higher installed.\n- Red Hat OpenShift Service Mesh 1.1.1 installed.\n- Access to the OpenShift Container Platform Command-line Interface (CLI) also known as oc.\n\n4.3.5.1. Delete the Bookinfo project\n\nProcedure\n\n1. Log in to the OpenShift Container Platform web console.\n\n2. Click to Home → Projects.\n\n3. Click on the bookinfo menu, and then click Delete Project.\n\n4. Type bookinfo in the confirmation dialog box, and then click Delete.\n\n Alternatively, you can run this command from the CLI to create the bookinfo project.\n\n $ oc delete project bookinfo\n\n4.3.5.2. Remove the Bookinfo project from the Service Mesh member roll\n\nProcedure\n\n1. Log in to the OpenShift Container Platform web console.\n\n2. Click Operators → Installed Operators.\n\n3. Click the Project menu and choose openshift-operators from the list.\n\n4. Click the Istio Service Mesh Member Roll link under Provided APIS for the Red Hat OpenShift Service Mesh Operator.\n\n5. Click the ServiceMeshMemberRoll menu and select Edit Service Mesh Member Roll\n\n6. Edit the default Service Mesh Member Roll YAML and remove bookinfo from the members list.\n\n Alternatively, you can run this command from the CLI to remove the bookinfo project from the ServiceMeshMemberRoll. Replace <control plane project> with the name of your control plane project.\n\n $ oc -n <control plane project> patch --type='json' smmr default -p '[[\"op\": \"remove\", \"path\": \"/spec/members\", \"value\":[\"bookinfo\"]]]'\n7. Click **Save** to update Service Mesh Member Roll.\n\n### 4.4. KIALI TUTORIAL\n\nKiali works with Istio to visualize your service mesh topology to provide visibility into features like circuit breakers, request rates, and more. Kiali offers insights about the mesh components at different levels, from abstract Applications to Services and Workloads. Kiali provides an interactive graph view of your Namespace in real time. It can display the interactions at several levels (applications, versions, workloads) with contextual information and charts on the selected graph node or edge.\n\nThis tutorial uses Service Mesh and the Bookinfo tutorial to demonstrate how you can use the Kiali console to view the topography and health of your service mesh.\n\n**NOTE**\n\nThe Bookinfo example application allows you to test your Red Hat OpenShift Service Mesh 1.1.1 installation on OpenShift Container Platform.\n\nRed Hat does not provide support for the Bookinfo application.\n\n#### 4.4.1. Accessing the Kiali console\n\nThe Kiali console provides visualization and observability for your Service Mesh. The Kiali console has different views that provide insights into Service Mesh components at different levels, from Applications to Services to Workloads. It also provides validation for Istio configurations.\n\n**Prerequisites**\n\n- OpenShift Container Platform 4.1 or higher installed.\n- Red Hat OpenShift Service Mesh 1.1.1 installed.\n- Kiali enabled during the installation.\n- Bookinfo demonstration application installed.\n\nThe installation process creates a route to access the Kiali console.\n\n**Procedure from the console**\n\n1. In the OpenShift Container Platform console, navigate to **Networking → Routes** and search for the Kiali route.\n\n2. Click the URL listed under **Location**.\n \n The default login strategy is **openshift** which means that you should be automatically logged into the Kiali console using the same user name and password as you use to access the OpenShift Container Platform console. When you first log in you see the Overview page, which provides a quick overview of the health of the various Namespaces that are part of your Service Mesh.\n3. Use the left navigation or click one of the Namespace icons to view your Applications, Workloads, or Services.\n\n**Procedure from the CLI**\n\n1. Run this command from the CLI to obtain the route and Kiali URL:\n\n ```\n $ oc get routes\n ```\n\n **Sample CLI output showing routes**\n\n<table>\n<thead>\n<tr>\n<th>NAME</th>\n<th>HOST/PORT</th>\n<th>PATH</th>\n<th>SERVICES</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>grafana</td>\n<td>grafana-openshift-operators.127.0.0.1.nip.io</td>\n<td>grafana</td>\n<td></td>\n</tr>\n<tr>\n<td>http</td>\n<td>None</td>\n<td>grafana</td>\n<td></td>\n</tr>\n<tr>\n<td>istio-ingress</td>\n<td>istio-ingress-openshift-operators.127.0.0.1.nip.io</td>\n<td>istio-ingress</td>\n<td></td>\n</tr>\n<tr>\n<td>http</td>\n<td>None</td>\n<td>istio-ingress</td>\n<td></td>\n</tr>\n<tr>\n<td>istio-ingressgateway</td>\n<td>istio-ingressgateway-openshift-operators.127.0.0.1.nip.io</td>\n<td>istio-ingressgateway</td>\n<td></td>\n</tr>\n<tr>\n<td>http</td>\n<td>None</td>\n<td>istio-ingressgateway</td>\n<td></td>\n</tr>\n<tr>\n<td>jaeger-query</td>\n<td>jaeger-query-openshift-operators.127.0.0.1.nip.io</td>\n<td>jaeger-query</td>\n<td></td>\n</tr>\n<tr>\n<td>jaeger-query</td>\n<td>edge</td>\n<td>jaeger-query</td>\n<td></td>\n</tr>\n<tr>\n<td>kiali</td>\n<td>kiali-openshift-operators.127.0.0.1.nip.io</td>\n<td>kiali</td>\n<td><all></td>\n</tr>\n<tr>\n<td>None</td>\n<td></td>\n<td>kiali</td>\n<td></td>\n</tr>\n<tr>\n<td>prometheus</td>\n<td>prometheus-openshift-operators.127.0.0.1.nip.io</td>\n<td>prometheus</td>\n<td></td>\n</tr>\n<tr>\n<td>prometheus</td>\n<td>http-prometheus</td>\n<td>prometheus</td>\n<td></td>\n</tr>\n<tr>\n<td>tracing</td>\n<td>tracing-openshift-operators.127.0.0.1.nip.io</td>\n<td>tracing</td>\n<td></td>\n</tr>\n<tr>\n<td>tracing</td>\n<td>edge</td>\n<td>tracing</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n2. Launch a browser and navigate to `https://<KIALI_URL>` (in the CLI output example, this is `kiali-openshift-operators.127.0.0.1.nip.io`). You should see the Kiali console login screen.\n\n3. Log in to the Kiali console using the user name and password that you use when logging in to the OpenShift Container Platform console.\n\n**4.4.2. Exploring the Graph page**\n\nThe Graph page shows a graph of microservices, which are connected by the requests going through them. On this page, you can see how Applications, Workloads, or Services interact with each other.\n**Procedure**\n\n1. In the Kiali console, click **Graph** in the left navigation.\n\n![Diagram of Kiali console]\n\n2. If necessary, select **bookinfo** from the **Namespace** menu. The graph displays the applications in the Bookinfo application.\n\n3. Click the question mark (?) under the **Namespace** menu to take the Graph Help Tour.\n\n4. Click **Done** to close the Help Tour.\n\n5. Click **Legend** in the lower left corner. Kiali displays the graph legend.\n\n6. Close the Graph Legend.\n\n7. Hover over the **productpage** Node. Note how the graph highlights only the incoming and outgoing traffic from the Node.\n\n8. Click the **productpage** Node. Note how the details on the right side of the page change to display the **productpage** details.\n\n**4.4.3. Exploring the Applications page**\n\nThe Applications page lets you search for and view applications, their health, and other details.\n\n**Procedure**\n\n1. In the Kiali console, click **Applications** in the left navigation.\n\n2. If necessary, select **bookinfo** from the **Namespace** menu. The page displays the applications in the selected Namespace and their health.\n\n3. Hover over the Health icon to view additional health details.\n\n4. Click the **reviews** Service to view the details for that application.\nOn the Applications Details page you can view more detailed health information, and drill down for further details about the three versions of the reviews Service.\n\nFrom the Application Details page you can also click tabs to view Traffic and Inbound and Outbound Metrics for the application.\n\n4.4.4. Exploring the Workloads page\n\nThe Workloads page lets you search for and view Workloads, their health, and other details.\n\nProcedure\n\n1. In the Kiali console, click Workloads in the left navigation.\n\n2. If necessary, select bookinfo from the Namespace menu. The page displays the Workloads in the selected Namespace, their health, and labels.\n\n3. Click the reviews-v1 Workload to view the details for that Workload.\n\n4. On the Workload Details page you can view an overview of Pods and Services associated with the Workload.\n\n5. From the Workload Details page you can also click tabs to view Traffic, Logs, and Inbound and Outbound Metrics for the Workload.\n4.4.5. Exploring the Services page\n\nThe Services page lets you search for and view Services, their health, and other details.\n\nProcedure\n\n1. In the Kiali console, click Services in the left navigation.\n\n2. If necessary, select bookinfo from the Namespace menu. The page displays a listing of all the Services that are running in the selected Namespace and additional information about them, such as health status.\n\n3. Hover over the health icon for any of the Services to view health information about the Service. A Service is considered healthy when it is online and responding to requests without errors.\n\n4. Click the Reviews Service to view its details. Note that there are three different versions of this Service.\n\n5. On the Services Details page you can view an overview of Workloads, virtual Services, and destination rules associated with the Service.\n\n6. From the Services Details page you can also click tabs to view Traffic, Inbound Metrics, and Traces for the Service.\n\n7. Click the Actions menu. From here you can perform the following actions:\n - Create Weighted Routing\n - Create Matching Routing\n - Suspend Traffic\n - Delete ALL Traffic Routing\n\n8. Click the name of one of the Services to view additional details about that specific version of the Service.\n\n4.4.6. Exploring the Istio Config page\n\nThe Istio Config page lets you view all of the currently running configurations to your Service Mesh.\nThe Istio Config page lets you view all of the currently running configurations to your Service Mesh, such as Circuit Breakers, Destination Rules, Fault Injection, Gateways, Routes, Route Rules, and Virtual Services.\n\nProcedure\n\n1. In the Kiali console, click **Istio Config** in the left navigation.\n\n2. If necessary, select **bookinfo** from the **Namespace** menu. The page displays a listing of configurations running in the selected Namespace and validation status.\n\n3. Click one of the configurations to view additional information about the configuration file.\n\n4.5. DISTRIBUTED TRACING TUTORIAL\n\nJaeger is an open source distributed tracing system. You use Jaeger for monitoring and troubleshooting microservices-based distributed systems. Using Jaeger you can perform a trace, which follows the path of a request through various microservices that make up an application. Jaeger is installed by default as part of the Service Mesh.\n\nThis tutorial uses Service Mesh and the bookinfo tutorial to demonstrate how you can use Jaeger to perform distributed tracing.\nNOTE\n\nThe Bookinfo example application allows you to test your Red Hat OpenShift Service Mesh 1.1.1 installation on OpenShift Container Platform.\n\nRed Hat does not provide support for the Bookinfo application.\n\n4.5.1. Generating traces and analyzing trace data\n\nThis tutorial uses Service Mesh and the Bookinfo tutorial to demonstrate how you can perform a trace using the Jaeger component of Red Hat OpenShift Service Mesh.\n\nPrerequisites:\n\n- OpenShift Container Platform 4.1 or higher installed.\n- Red Hat OpenShift Service Mesh 1.1.1 installed.\n- Jaeger enabled during the installation.\n- Bookinfo example application installed.\n\nProcedure\n\n1. After you have deployed the Bookinfo application you will need to generate calls to the Bookinfo application so that you have some trace data to analyze. Access http://<GATEWAY_URL>/productpage and refresh the page a few times to generate some trace data.\n\n2. The installation process creates a route to access the Jaeger console.\n a. In the OpenShift Container Platform console, navigate to Networking → Routes and search for the Jaeger route, which is the URL listed under Location.\n b. Use the CLI to query for details of the route:\n\n ```\n $ export JAEGER_URL=$(oc get route -n bookinfo jaeger-query -o jsonpath='{.spec.host}')\n ```\n\n3. Launch a browser and navigate to https://<JAEGER_URL>.\n\n4. If necessary, log in using the same user name and password as you use to access the OpenShift Container Platform console.\n\n5. In the left pane of the Jaeger dashboard, from the Service menu, select \"productpage\" and click the Find Traces button at the bottom of the pane. A list of traces is displayed, as shown in the following image:\n6. Click one of the traces in the list to open a detailed view of that trace. If you click on the top (most recent) trace, you see the details that correspond to the latest refresh of the `/productpage`.\n\nThe trace in the previous figure consists of a few nested spans, each corresponding to a Bookinfo Service call, all performed in response to a `/productpage` request. Overall processing time was 2.62s, with the `details` Service taking 3.56ms, the `reviews` Service taking 2.6s, and the `ratings` Service taking 5.32ms. Each of the calls to remote Services is represented by a client-side and server-side span. For example, the `details` client-side span is labeled `productpage details.myproject.svc.cluster.local:9080`. The span nested underneath it, labeled `details details.myproject.svc.cluster.local:9080`, corresponds to the server-side processing of the request. The trace also shows calls to `istio-policy`, which reflect authorization checks made by Istio.\n\n### 4.6. AUTOMATIC ROUTE CREATION\n\nOpenShift routes for Istio Gateways are automatically managed in Red Hat OpenShift Service Mesh. Every time an Istio Gateway is created, updated or deleted inside the service mesh, an OpenShift route is created, updated or deleted.\n\n#### 4.6.1. Enabling Automatic Route Creation\n\nA Red Hat OpenShift Service Mesh control plane component called Istio OpenShift Routing (IOR) synchronizes the gateway route. Enable IOR as part of the control plane deployment.\nIf the Gateway contains a TLS section, the OpenShift Route will be configured to support TLS.\n\n1. In the **ServiceMeshControlPlane** resource, add the **ior_enabled** parameter and set it to **true**. For example, see the following resource snippet:\n\n```yaml\nspec:\nistio:\ngateways:\n istio-egressgateway:\n autoscaleEnabled: false\n autoscaleMin: 1\n autoscaleMax: 5\n istio-ingressgateway:\n autoscaleEnabled: false\n autoscaleMin: 1\n autoscaleMax: 5\n ior_enabled: true\n```\n\nFor more information, see [Istio gateway configuration](#).\n\nIf the following gateway is created:\n\n```yaml\napiVersion: networking.istio.io/v1alpha3\nkind: Gateway\nmetadata:\n name: gateway1\nspec:\n selector:\n istio: ingressgateway\n servers:\n - port:\n number: 80\n name: http\n protocol: HTTP\n hosts:\n - www.bookinfo.com\n - bookinfo.example.com\n```\n\nThen, the following OpenShift Routes are created automatically. You can check that the routes are created with the following command.\n\n```bash\n$ oc -n <your-control-plane-namespace> get routes\nNAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD\n```\n\n| gateway1-lvlfn | bookinfo.example.com | istio-ingressgateway | <all> | None |\n| gateway1-scqhv | www.bookinfo.com | istio-ingressgateway | <all> | None |\n\nIf the gateway is deleted, Red Hat OpenShift Service Mesh deletes the routes. However, routes created manually are never modified by Red Hat OpenShift Service Mesh.\nCHAPTER 5. SUPPORT\n\n5.1. COLLECTING RED HAT OPENSShift SERVICE MESH DATA FOR RED HAT SUPPORT\n\nWhen opening a support case, it is helpful to provide debugging information about your cluster to Red Hat Support.\n\nThe must-gather tool enables you to collect diagnostic information about your OpenShift Container Platform cluster, including virtual machines and other data related to Red Hat OpenShift Service Mesh.\n\nFor prompt support, supply diagnostic information for both OpenShift Container Platform and Red Hat OpenShift Service Mesh.\n\n5.1.1. About the must-gather tool\n\nThe oc adm must-gather CLI command collects the information from your cluster that is most likely needed for debugging issues, such as:\n\n- Resource definitions\n- Audit logs\n- Service logs\n\nYou can specify one or more images when you run the command by including the --image argument. When you specify an image, the tool collects data related to that feature or product.\n\nWhen you run oc adm must-gather, a new Pod is created on the cluster. The data is collected on that Pod and saved in a new directory that starts with must-gather.local. This directory is created in the current working directory.\n\nPrerequisites\n\n- Access to the cluster as a user with the cluster-admin role.\n- The OpenShift Container Platform CLI (oc) installed.\n\n5.1.2. About collecting service mesh data\n\nYou can use the oc adm must-gather CLI command to collect information about your cluster, including features and objects associated with Red Hat OpenShift Service Mesh.\n\nTo collect Red Hat OpenShift Service Mesh data with must-gather, you must specify the Red Hat OpenShift Service Mesh image:\n\n$ oc adm must-gather --image=registry.redhat.io/openshift-service-mesh/istio-must-gather-rhel7\n6.1. USING THE 3SCALE ISTIO ADAPTER\n\nThe 3scale Istio Adapter is an optional adapter that allows you to label a service running within the Red Hat OpenShift Service Mesh and integrate that service with the 3scale API Management solution. It is not required for Red Hat OpenShift Service Mesh.\n\n6.1.1. Integrate the 3scale adapter with Red Hat OpenShift Service Mesh\n\nYou can use these examples to configure requests to your services using the 3scale Istio Adapter.\n\n**Prerequisites:**\n\n- Red Hat OpenShift Service Mesh 0.12.0+\n- A working 3scale account ([SaaS](#) or [3scale 2.5 On-Premises](#))\n- Red Hat OpenShift Service Mesh prerequisites\n- Ensure Mixer policy enforcement is enabled. Update Mixer policy enforcement section provides instructions to check the current Mixer policy enforcement status and enable policy enforcement.\n\n**NOTE**\n\nTo configure the 3scale Istio Adapter, refer to Red Hat OpenShift Service Mesh custom resources for instructions on adding adapter parameters to the custom resource file.\n\n**NOTE**\n\nPay particular attention to the **kind: handler** resource. You must update this with your 3scale credentials and the service ID of the API you want to manage.\n\n1. Modify the handler configuration with your 3scale configuration.\n\n**Handler configuration example**\n\n```yaml\napiVersion: \"config.istio.io/v1alpha2\"\nkind: handler\nmetadata:\n name: threescale\nspec:\n adapter: threescale\n params:\n service_id: \"<SERVICE_ID>\"\n system_url: \"https://<organization>-admin.3scale.net/\"\n access_token: \"<ACCESS_TOKEN>\"\n connection:\n address: \"threescale-istio-adapter:3333\"\n```\nOptionally, you can provide a `backend_url` field within the `params` section to override the URL provided by the 3scale configuration. This may be useful if the adapter runs on the same cluster as the 3scale on-premise instance, and you wish to leverage the internal cluster DNS.\n\n1. Modify the rule configuration with your 3scale configuration to dispatch the rule to the threescale handler.\n\n**Rule configuration example**\n\n```yaml\napiVersion: \"config.istio.io/v1alpha2\"\nkind: rule\nmetadata:\n name: threescale\nspec:\n match: destination.labels[\"service-mesh.3scale.net\"] == \"true\"\n actions:\n - handler: threescale.handler\n instances:\n - threescale-authorization.instance\n```\n\n### 6.1.1.1. Generating 3scale custom resources\n\nThe adapter includes a tool that allows you to generate the `handler`, `instance`, and `rule` custom resources.\n\n**Table 6.1. Usage**\n\n<table>\n<thead>\n<tr>\n<th>Option</th>\n<th>Description</th>\n<th>Required</th>\n<th>Default value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>-h, --help</code></td>\n<td>Produces help output for available options</td>\n<td>No</td>\n<td></td>\n</tr>\n<tr>\n<td><code>--name</code></td>\n<td>Unique name for this URL, token pair</td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td><code>-n, --namespace</code></td>\n<td>Namespace to generate templates</td>\n<td>No</td>\n<td>istio-system</td>\n</tr>\n<tr>\n<td><code>-t, --token</code></td>\n<td>3scale access token</td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td><code>-u, --url</code></td>\n<td>3scale Admin Portal URL</td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td><code>--backend-url</code></td>\n<td>3scale backend URL. If set, it overrides the value that is read from system configuration</td>\n<td>No</td>\n<td></td>\n</tr>\n<tr>\n<td><code>-s, --service</code></td>\n<td>3scale API/Service ID</td>\n<td>No</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### 6.1.1.1. Generate templates from URL examples\n\n- This example generates templates allowing the token, URL pair to be shared by multiple services as a single handler:\n\n ```bash\n $ 3scale-gen-config --name=admin-credentials --url=\"https://<organization>-admin.3scale.net:443\" --token=\"[redacted]\"\n \n This example generates the templates with the service ID embedded in the handler:\n ```bash\n $ 3scale-gen-config --url=\"https://<organization>-admin.3scale.net\" --name=\"my-unique-id\" --service=\"123456789\" --token=\"[redacted]\"\n ```\n\n### 6.1.1.2. Generating manifests from a deployed adapter\n\n1. Run this command to generate manifests from a deployed adapter in the `istio-system` namespace:\n\n ```bash\n $ export NS=\"istio-system\" URL=\"https://replaceme-admin.3scale.net:443\" NAME=\"name\" TOKEN=\"token\"\n oc exec -n $NS $(oc get po -n $NS -o jsonpath='{.items[?(@.metadata.labels.app==\"3scale-istio-adapter\").metadata.name]}') -it -- ./3scale-config-gen\n --url $URL --name $NAME --token $TOKEN -n $NS\n ```\n\n2. This will produce sample output to the terminal. Edit these samples if required and create the objects using the `oc create` command.\n\n3. When the request reaches the adapter, the adapter needs to know how the service maps to an API on 3scale. You can provide this information in two ways:\n\n a. Label the workload (recommended)\n\n b. Hard code the handler as `service_id`\n\n4. Update the workload with the required annotations:\nNOTE\n\nYou only need to update the service ID provided in this example if it is not already embedded in the handler. **The setting in the handler takes precedence**\n\n```bash\n$ export CREDENTIALS_NAME=\"replace-me\"\nexport SERVICE_ID=\"replace-me\"\nexport DEPLOYMENT=\"replace-me\"\npatch=$(oc get deployment \"$DEPLOYMENT\" --template='{\"spec\":{\"template\":{\"metadata\":\n{\"labels\":{{ range $k,$v := .spec.template.metadata.labels }\"\n\"{{ $k }}\":\"{{ $v }}\",{{ end\n\"service-mesh.3scale.net/service-id\":\"\"\"${SERVICE_ID}\"\"\",\"service-\nmesh.3scale.net/credentials\":\"\"\"${CREDENTIALS_NAME}\"\"}}}}}'\n)\noc patch deployment \"$DEPLOYMENT\" --patch \"\"\"patch\"\"\"\n```\n\n6.1.1.3. Routing service traffic through the adapter\n\nFollow these steps to drive traffic for your service through the 3scale adapter.\n\n**Prerequisites**\n\n- Credentials and service ID from your 3scale administrator.\n\n**Procedure**\n\n1. Match the rule `destination.labels[\"service-mesh.3scale.net/credentials\"] == \"threescale\"` that you previously created in the configuration, in the **kind: rule** resource.\n\n2. Add the above label to **PodTemplateSpec** on the Deployment of the target workload to integrate a service. the value, *threescale*, refers to the name of the generated handler. This handler stores the access token required to call 3scale.\n\n3. Add the `destination.labels[\"service-mesh.3scale.net/service-id\"] == \"replace-me\"` label to the workload to pass the service ID to the adapter via the instance at request time.\n\n6.1.2. Configure the integration settings in 3scale\n\nFollow this procedure to configure the 3scale integration settings.\n\n**NOTE**\n\nFor 3scale SaaS customers, Red Hat OpenShift Service Mesh is enabled as part of the Early Access program.\n\n**Procedure**\n\n1. Navigate to **[your_API_name] → Integration → Configuration**.\n\n2. At the top of the **Integration** page click on **edit integration settings** in the top right corner.\n\n3. Under the **Service Mesh** heading, click the **Istio** option.\n\n4. Scroll to the bottom of the page and click **Update Service**.\n6.1.3. Caching behavior\n\nResponses from 3scale System APIs are cached by default within the adapter. Entries will be purged from the cache when they become older than the `cacheTTLSeconds` value. Also by default, automatic refreshing of cached entries will be attempted seconds before they expire, based on the `cacheRefreshSeconds` value. You can disable automatic refreshing by setting this value higher than the `cacheTTLSeconds` value.\n\nCaching can be disabled entirely by setting `cacheEntriesMax` to a non-positive value.\n\nBy using the refreshing process, cached values whose hosts become unreachable will be retried before eventually being purged when past their expiry.\n\n6.1.4. Authenticating requests\n\nThis release supports the following authentication methods:\n\n- **Standard API Keys**: single randomized strings or hashes acting as an identifier and a secret token.\n- **Application identifier and key pairs**: immutable identifier and mutable secret key strings.\n- **OpenID authentication method**: client ID string parsed from the JSON Web Token.\n\n6.1.4.1. Applying authentication patterns\n\nModify the `instance` custom resource, as illustrated in the following authentication method examples, to configure authentication behavior. You can accept the authentication credentials from:\n\n- Request headers\n- Request parameters\n- Both request headers and query parameters\n\n**NOTE**\n\nWhen specifying values from headers, they must be lower case. For example, if you want to send a header as `User-Key`, this must be referenced in the configuration as `request.headers[\"user-key\"]`.\n\n6.1.4.1.1. API key authentication method\n\nService Mesh looks for the API key in query parameters and request headers as specified in the `user` option in the `subject` custom resource parameter. It checks the values in the order given in the custom resource file. You can restrict the search for the API key to either query parameters or request headers by omitting the unwanted option.\n\nIn this example, Service Mesh looks for the API key in the `user_key` query parameter. If the API key is not in the query parameter, Service Mesh then checks the `user-key` header.\n\n**API key authentication method example**\n\n```yaml\napiVersion: \"config.istio.io/v1alpha2\"\nkind: instance\n```\nIf you want the adapter to examine a different query parameter or request header, change the name as appropriate. For example, to check for the API key in a query parameter named “key”, change `request.query_params['user_key']` to `request.query_params['key']`.\n\n6.1.4.1.2. Application ID and application key pair authentication method\n\nService Mesh looks for the application ID and application key in query parameters and request headers, as specified in the properties option in the subject custom resource parameter. The application key is optional. It checks the values in the order given in the custom resource file. You can restrict the search for the credentials to either query parameters or request headers by not including the unwanted option.\n\nIn this example, Service Mesh looks for the application ID and application key in the query parameters first, moving on to the request headers if needed.\n\nApplication ID and application key pair authentication method example\n\n```yaml\nmetadata:\n name: threescale-authorization\nnamespace: istio-system\nspec:\ntemplate: authorization\nparams:\n subject:\n user: request.query_params['user_key'] | request.headers['user-key'] | ''\n action:\n path: request.url_path\n method: request.method | \"get\"\n```\n\nIf you want the adapter to examine a different query parameter or request header, change the name as appropriate. For example, to check for the application ID in a query parameter named `identification`, change `request.query_params['app_id']` to `request.query_params['identification']`.\n\n6.1.4.1.3. OpenID authentication method\n\nTo use the OpenID Connect (OIDC) authentication method, use the properties value on the subject field to set client_id, and optionally app_key.\n\nYou can manipulate this object using the methods described previously. In the example configuration shown below, the client identifier (application ID) is parsed from the JSON Web Token (JWT) under the label azp. You can modify this as needed.\nOpenID authentication method example\n\n```yaml\napiVersion: \"config.istio.io/v1alpha2\"\nkind: instance\nmetadata:\n name: threescale-authorization\nspec:\n template: threescale-authorization\nparams:\n Subject:\n properties:\n app_key: request.query_params[\"app_key\"] | request.headers[\"app-key\"] | \"\"\n client_id: request.auth.claims[\"azp\"] | \"\"\n action:\n path: request.url_path\n method: request.method | \"get\"\n service: destination.labels[\"service-mesh.3scale.net/service-id\"] | \"\"\n```\n\nFor this integration to work correctly, OIDC must still be done in 3scale for the client to be created in the identity provider (IdP). You should create end-user authentication for the service you want to protect in the same namespace as that service. The JWT is passed in the Authorization header of the request.\n\nIn the sample Policy defined below, replace issuer and jwksUri as appropriate.\n\nOpenID Policy example\n\n```yaml\napiVersion: \"authentication.istio.io/v1alpha1\"\nkind: Policy\nmetadata:\n name: jwt-example\nnamespace: bookinfo\nspec:\n origins:\n - jwt:\n issuer: >-\n http://keycloak-keycloak.34.242.107.254.nip.io/auth/realms/3scale-keycloak\n jwksUri: >-\n http://keycloak-keycloak.34.242.107.254.nip.io/auth/realms/3scale-keycloak/protocol/openid-connect/certs\n principalBinding: USE_ORIGIN\n targets:\n - name: productpage\n```\n\n6.1.4.1.4. Hybrid authentication method\n\nYou can choose to not enforce a particular authentication method and accept any valid credentials for either method. If both an API key and an application ID/application key pair are provided, Service Mesh uses the API key.\n\nIn this example, Service Mesh checks for an API key in the query parameters, then the request headers. If there is no API key, it then checks for an application ID and key in the query parameters, then the request headers.\n\nHybrid authentication method example\n6.1.5. 3scale Adapter metrics\n\nThe adapter, by default reports various Prometheus metrics that are exposed on port 8080 at the /metrics endpoint. These metrics provide insight into how the interactions between the adapter and 3scale are performing. The service is labeled to be automatically discovered and scraped by Prometheus.\n\napiVersion: \"config.istio.io/v1alpha2\"\nkind: instance\nmetadata:\n name: threescale-authorization\nspec:\n template: authorization\n params:\n subject:\n user: request.query_params[\"user_key\"] | request.headers[\"user-key\"] |\n properties:\n app_id: request.query_params[\"app_id\"] | request.headers[\"app-id\"] | \"\"\n app_key: request.query_params[\"app_key\"] | request.headers[\"app-key\"] | \"\"\n client_id: request.auth.claims[\"azp\"] | \"\"\n action:\n path: request.url_path\n method: request.method | \"get\"\n service: destination.labels[\"service-mesh.3scale.net/service-id\"] | \"\""}}},{"rowIdx":158,"cells":{"id":{"kind":"string","value":"23fcbfdd119c8233160fd766f94bfbba85b7cf29"},"text":{"kind":"string","value":"Red Hat Fuse 7.8\n\nApache CXF Security Guide\n\nProtecting your services and their consumers\nProtecting your services and their consumers\nAbstract\n\nThis guide describes how to use the Apache CXF security features.\n# Table of Contents\n\n## CHAPTER 1. SECURITY FOR HTTP-COMPATIBLE BINDINGS\n- OVERVIEW ........................................... 8\n- GENERATING X.509 CERTIFICATES .............. 8\n- CERTIFICATE FORMAT .............................. 9\n- ENABLING HTTPS .................................. 9\n- HTTPS CLIENT WITH NO CERTIFICATE .......... 10\n- HTTPS CLIENT WITH CERTIFICATE ............. 11\n- HTTPS SERVER CONFIGURATION ................. 12\n\n## CHAPTER 2. MANAGING CERTIFICATES\n- 2.1. WHAT IS AN X.509 CERTIFICATE? ............ 15\n - Role of certificates ................................ 15\n - Integrity of the public key ....................... 15\n - Digital signatures ................................ 15\n - Contents of an X.509 certificate ............... 15\n - Distinguished names .............................. 16\n- 2.2. CERTIFICATION AUTHORITIES ............... 16\n - 2.2.1. Introduction to Certificate Authorities ... 16\n - 2.2.2. Commercial Certification Authorities .... 16\n - Signing certificates ........................... 16\n - Advantages of commercial CAs ............... 16\n - Criteria for choosing a CA ................... 16\n - 2.2.3. Private Certification Authorities ....... 17\n - Choosing a CA software package ............ 17\n - OpenSSL software package .................. 17\n - Setting up a private CA using OpenSSL ..... 17\n - Choosing a host for a private certification authority .... 17\n - Security precautions .......................... 17\n- 2.3. CERTIFICATE CHAINING ....................... 17\n - Certificate chain ................................ 17\n - Self-signed certificate ......................... 18\n - Chain of trust ................................... 18\n - Certificates signed by multiple CAs .......... 18\n - Trusted CAs ..................................... 18\n- 2.4. SPECIAL REQUIREMENTS ON HTTPS CERTIFICATES .... 18\n - Overview ....................................... 18\n - HTTPS URL integrity check .................... 19\n - Reference ....................................... 19\n - How to specify the certificate identity ....... 19\n - Using commonName ................................ 19\n - Using subjectAltName (multi-homed hosts) ... 19\n- 2.5. CREATING YOUR OWN CERTIFICATES ....... 20\n - 2.5.1. Prerequisites ............................. 20\n - OpenSSL utilities ............................. 20\n - Sample CA directory structure ............... 20\n - 2.5.2. Set Up Your Own CA ..................... 21\n - Substeps to perform .......................... 21\n - Add the bin directory to your PATH .......... 21\n - Create the CA directory hierarchy .......... 21\n - Copy and edit the openssl.cnf file ......... 22\n - Initialize the CA database ................... 22\nCreate a self-signed CA certificate and private key\n\n2.5.3. Use the CA to Create Signed Certificates in a Java Keystore\nSubsteps to perform\nAdd the Java bin directory to your PATH\nGenerate a certificate and private key pair\nCreate a certificate signing request\nSign the CSR\nConvert to PEM format\nConcatenate the files\nUpdate keystore with the full certificate chain\nRepeat steps as required\n\n2.5.4. Use the CA to Create Signed PKCS#12 Certificates\nSubsteps to perform\nAdd the bin directory to your PATH\nConfigure the subjectAltName extension (Optional)\nCreate a certificate signing request\nSign the CSR\nConcatenate the files\nCreate a PKCS#12 file\nRepeat steps as required\n\n(OPTIONAL) CLEAR THE SUBJECTALTNAME EXTENSION\n\nCHAPTER 3. CONFIGURING HTTPS\n\n3.1. AUTHENTICATION ALTERNATIVES\n\n3.1.1. Target-Only Authentication\nOverview\nSecurity handshake\nHTTPS example\n\n3.1.2. Mutual Authentication\nOverview\nSecurity handshake\nHTTPS example\n\n3.2. SPECIFYING TRUSTED CA CERTIFICATES\n\n3.2.1. When to Deploy Trusted CA Certificates\nOverview\nWhich applications need to specify trusted CA certificates?\n\n3.2.2. Specifying Trusted CA Certificates for HTTPS\nCA certificate format\nCA certificate deployment in the Apache CXF configuration file\n\n3.3. SPECIFYING AN APPLICATION’S OWN CERTIFICATE\n\n3.3.1. Deploying Own Certificate for HTTPS\nOverview\nProcedure\n\nCHAPTER 4. CONFIGURING HTTPS CIPHER SUITES\n\n4.1. SUPPORTED CIPHER SUITES\nOverview\nJCE/JSSE and security providers\nSunJSSE provider\nCipher suites supported by SunJSSE\nJSSE reference guide\n\n4.2. CIPHER SUITE FILTERS\nOverview\n6.2.3. Specifying an AsymmetricBinding Policy\n\nOverview\nPolicy subject\nSyntax\nSample policy\nsp:InitiatorToken\nsp:RecipientToken\nsp:AlgorithmSuite\nsp:Layout\nsp:IncludeTimestamp\nsp:EncryptBeforeSigning\nsp:EncryptSignature\nsp:ProtectTokens\nsp:OnlySignEntireHeadersAndBody\n\n6.2.4. Specifying a SymmetricBinding Policy\n\nOverview\nPolicy subject\nSyntax\nSample policy\nsp:ProtectionToken\nsp:SignatureToken\nsp:EncryptionToken\nsp:AlgorithmSuite\nsp:Layout\nsp:IncludeTimestamp\nsp:EncryptBeforeSigning\nsp:EncryptSignature\nsp:ProtectTokens\nsp:OnlySignEntireHeadersAndBody\n\n6.2.5. Specifying Parts of Message to Encrypt and Sign\n\nOverview\nPolicy subject\nProtection assertions\nSyntax\nSample policy\nsp:Body\nsp:Header\nsp:Attachments\n\n6.2.6. Providing Encryption Keys and Signing Keys\n\nOverview\nConfiguring encryption keys and signing keys\nAdd encryption and signing properties to Blueprint configuration\nDefine the WSS4J property files\nProgramming encryption keys and signing keys\nWSS4J Crypto interface\n\n6.2.7. Specifying the Algorithm Suite\n\nOverview\nSyntax\nAlgorithm suites\nTypes of cryptographic algorithm\nSymmetric key signature\nAsymmetric key signature\nCHAPTER 7. AUTHENTICATION\n\n7.1. INTRODUCTION TO AUTHENTICATION\nOverview\nSteps to set up authentication\n\n7.2. SPECIFYING AN AUTHENTICATION POLICY\nOverview\nSyntax\nSample policy\nToken types\nsp:UsernameToken\nsp:IncludeToken attribute\nSupportingTokens assertions\nsp:SupportingTokens\nsp:SignedSupportingTokens\nsp:EncryptedSupportingTokens\nsp:SignedEncryptedSupportingTokens\nsp:EndorsingSupportingTokens\nsp:SignedEndorsingSupportingTokens\nsp:EndorsingEncryptedSupportingTokens\nsp:SignedEndorsingEncryptedSupportingTokens\n\n7.3. PROVIDING CLIENT CREDENTIALS\nOverview\nClient credentials properties\nConfiguring client credentials in Blueprint XML\nProgramming a callback handler for passwords\nWSPasswordCallback class\n\n7.4. AUTHENTICATING RECEIVED CREDENTIALS\nOverview\nConfiguring a server callback handler in Blueprint XML\nImplementing the callback handler to check passwords\n\nCHAPTER 8. FUSE CREDENTIAL STORE\n\n8.1. OVERVIEW\n8.2. PREREQUISITES\n8.3. SETUP FUSE CREDENTIAL STORE ON KARAF\n\nAPPENDIX A. ASN.1 AND DISTINGUISHED NAMES\n\nA.1. ASN.1\nOverview\nBER\nDER\nReferences\n\nA.2. DISTINGUISHED NAMES\nOverview\nString representation of DN\nDN string example 95\nStructure of a DN string 95\nOID 95\nAttribute types 95\nAVA 96\nRDN 96\nCHAPTER 1. SECURITY FOR HTTP-COMPATIBLE BINDINGS\n\nAbstract\n\nThis chapter describes the security features supported by the Apache CXF HTTP transport. These security features are available to any Apache CXF binding that can be layered on top of the HTTP transport.\n\nOVERVIEW\n\nThis section describes how to configure the HTTP transport to use SSL/TLS security, a combination usually referred to as HTTPS. In Apache CXF, HTTPS security is configured by specifying settings in XML configuration files.\n\nWARNING\n\nIf you enable SSL/TLS security, you must ensure that you explicitly disable the SSLv3 protocol, in order to safeguard against the Poodle vulnerability (CVE-2014-3566). For more details, see Disabling SSLv3 in JBoss Fuse 6.x and JBoss A-MQ 6.x.\n\nThe following topics are discussed in this chapter:\n\n- the section called “Generating X.509 certificates”\n- the section called “Enabling HTTPS”\n- the section called “HTTPS client with no certificate”\n- the section called “HTTPS client with certificate”\n- the section called “HTTPS server configuration”\n\nGENERATING X.509 CERTIFICATES\n\nA basic prerequisite for using SSL/TLS security is to have a collection of X.509 certificates available to identify your server applications and, optionally, to identify your client applications. You can generate X.509 certificates in one of the following ways:\n\n- Use a commercial third-party to tool to generate and manage your X.509 certificates.\n\n- Use the free openssl utility (which can be downloaded from http://www.openssl.org) and the Java keystore utility to generate certificates (see Section 2.5.3, “Use the CA to Create Signed Certificates in a Java Keystore”).\nNOTE\n\nThe HTTPS protocol mandates a URL integrity check, which requires a certificate’s identity to match the hostname on which the server is deployed. See Section 2.4, “Special Requirements on HTTPS Certificates” for details.\n\nCERTIFICATE FORMAT\n\nIn the Java runtime, you must deploy X.509 certificate chains and trusted CA certificates in the form of Java keystores. See Chapter 3, Configuring HTTPS for details.\n\nENABLING HTTPS\n\nA prerequisite for enabling HTTPS on a WSDL endpoint is that the endpoint address must be specified as a HTTPS URL. There are two different locations where the endpoint address is set and both must be modified to use a HTTPS URL:\n\n- HTTPS specified in the WSDL contract—you must specify the endpoint address in the WSDL contract to be a URL with the https: prefix, as shown in Example 1.1, “Specifying HTTPS in the WSDL”.\n\n Example 1.1. Specifying HTTPS in the WSDL\n\n ```xml\n <wsdl:definitions name=\"HelloWorld\"\n targetNamespace=\"http://apache.org/hello_world_soap_http\"\n xmlns:soap=\"http://schemas.xmlsoap.org/wsdl/soap/\"\n xmlns:wsdl=\"http://schemas.xmlsoap.org/wsdl/\" ... >\n ...\n <wsdl:service name=\"SOAPService\">\n <wsdl:port binding=\"tns:Greeter_SOAPBinding\"\n name=\"SoapPort\">\n <soap:address location=\"https://localhost:9001/SoapContext/SoapPort\"/>\n </wsdl:port>\n </wsdl:service>\n </wsdl:definitions>\n ``\n\n Where the location attribute of the soap:address element is configured to use a HTTPS URL. For bindings other than SOAP, you edit the URL appearing in the location attribute of the http:address element.\n\n- HTTPS specified in the server code—you must ensure that the URL published in the server code by calling Endpoint.publish() is defined with a https: prefix, as shown in Example 1.2, “Specifying HTTPS in the Server Code”.\n\n Example 1.2. Specifying HTTPS in the Server Code\n\n ```java\n // Java\n package demo.hw_https.server;\n import javax.xml.ws.Endpoint;\n\n public class Server {\n protected Server() throws Exception {\n Object implementor = new GreeterImpl();\n String address = \"https://localhost:9001/SoapContext/SoapPort\";\n Endpoint.publish(address, implementor);\n ```\nHTTPS CLIENT WITH NO CERTIFICATE\n\nFor example, consider the configuration for a secure HTTPS client with no certificate, as shown in Example 1.3, \"Sample HTTPS Client with No Certificate\".\n\nExample 1.3. Sample HTTPS Client with No Certificate\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<beans xmlns=\"http://www.springframework.org/schema/beans\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:sec=\"http://cxf.apache.org/configuration/security\"\n xmlns:http=\"http://cxf.apache.org/transports/http/configuration\"\n xmlns:jaxws=\"http://java.sun.com/xml/ns/jaxws\"\n xsi:schemaLocation=\"...\">\n\n <http:conduit name=\"{http://apache.org/hello_world_soap_http}SoapPort.http-conduit\">\n <http:tlsClientParameters>\n <sec:trustManagers>\n <sec:keyStore type=\"JKS\" password=\"password\"\n file=\"certs/truststore.jks\"/>\n </sec:trustManagers>\n <sec:cipherSuitesFilter>\n <sec:include>.*_WITH_3DES_.*</sec:include>\n <sec:include>.*_WITH_DES_.*</sec:include>\n <sec:exclude>.*_WITH_NULL_.*</sec:exclude>\n <sec:exclude>.*_DH_anon_.*</sec:exclude>\n </sec:cipherSuitesFilter>\n </http:tlsClientParameters>\n </http:conduit>\n</beans>\n```\n\nThe preceding client configuration is described as follows:\n\nThe TLS security settings are defined on a specific WSDL port. In this example, the WSDL port being configured has the QName, `{http://apache.org/hello_world_soap_http}SoapPort`. The http:tlsClientParameters element contains all of the client’s TLS configuration details.\n\nThe sec:trustManagers element is used to specify a list of trusted CA certificates (the client uses this list to decide whether or not to trust certificates received from the server side).\n\nThe file attribute of the sec:keyStore element specifies a Java keystore file, truststore.jks, containing one or more trusted CA certificates. The password attribute specifies the password required to access the keystore, truststore.jks. See Section 3.2.2, \"Specifying Trusted CA Certificates for HTTPS\".\nNOTE\n\nInstead of the `file` attribute, you can specify the location of the keystore using either the `resource` attribute (where the keystore file is provided on the classpath) or the `url` attribute. In particular, the `resource` attribute must be used with applications that are deployed into an OSGi container. You must be extremely careful not to load the truststore from an untrustworthy source.\n\nThe `sec:cipherSuitesFilter` element can be used to narrow the choice of cipher suites that the client is willing to use for a TLS connection. See Chapter 4, Configuring HTTPS Cipher Suites for details.\n\nHTTPS CLIENT WITH CERTIFICATE\n\nConsider a secure HTTPS client that is configured to have its own certificate. Example 1.4, “Sample HTTPS Client with Certificate” shows how to configure such a sample client.\n\nExample 1.4. Sample HTTPS Client with Certificate\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<beans xmlns=\"http://www.springframework.org/schema/beans\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:sec=\"http://cxf.apache.org/configuration/security\"\n xmlns:http=\"http://cxf.apache.org/transports/http/configuration\"\n xmlns:jaxws=\"http://java.sun.com/xml/ns/jaxws\"\n xsi:schemaLocation=\"...\">\n <http:conduit name=\"{http://apache.org/hello_world_soap_http}SoapPort.http-conduit\">\n <http:tlsClientParameters>\n <sec:trustManagers>\n <sec:keyStore type=\"JKS\" password=\"password\"\n file=\"certs/truststore.jks\"/>\n </sec:trustManagers>\n <sec:keyManagers keyPassword=\"password\">\n <sec:keyStore type=\"JKS\" password=\"password\"\n file=\"certs/wibble.jks\"/>\n </sec:keyManagers>\n <sec:cipherSuitesFilter>\n <sec:include>.*_WITH_3DES_.*</sec:include>\n <sec:include>.*_WITH_DES_.*</sec:include>\n <sec:exclude>.*_WITH_NULL_.*</sec:exclude>\n <sec:exclude>.*_DH_anon_.*</sec:exclude>\n </sec:cipherSuitesFilter>\n </http:tlsClientParameters>\n </http:conduit>\n <bean id=\"cxf\" class=\"org.apache.cxf.bus.CXFBusImpl\"/>\n</beans>\n```\n\nThe preceding client configuration is described as follows:\n\nThe `sec:keyManagers` element is used to attach an X.509 certificate and a private key to the client. The password specified by the `keyPassword` attribute is used to decrypt the certificate’s private key.\nThe `sec:keystore` element is used to specify an X.509 certificate and a private key that are stored in a Java keystore. This sample declares that the keystore is in Java Keystore format (JKS).\n\nThe `file` attribute specifies the location of the keystore file, `wibble.jks`, that contains the client’s X.509 certificate chain and private key in a key entry. The `password` attribute specifies the keystore password which is required to access the contents of the keystore.\n\nIt is expected that the keystore file contains just one key entry, so it is not necessary to specify a key alias to identify the entry. If you are deploying a keystore file with multiple key entries, however, it is possible to specify the key in this case by adding the `sec:certAlias` element as a child of the `http:tlsClientParameters` element, as follows:\n\n```xml\n<http:tlsClientParameters>\n ...\n <sec:certAlias>CertAlias</sec:certAlias>\n ...\n</http:tlsClientParameters>\n```\n\nFor details of how to create a keystore file, see Section 2.5.3, “Use the CA to Create Signed Certificates in a Java Keystore”.\n\n**NOTE**\n\nInstead of the `file` attribute, you can specify the location of the keystore using either the `resource` attribute (where the keystore file is provided on the classpath) or the `url` attribute. In particular, the `resource` attribute must be used with applications that are deployed into an OSGi container. You must be extremely careful not to load the truststore from an untrustworthy source.\n\n### HTTPS SERVER CONFIGURATION\n\nConsider a secure HTTPS server that requires clients to present an X.509 certificate. Example 1.5, “Sample HTTPS Server Configuration” shows how to configure such a server.\n\n**Example 1.5. Sample HTTPS Server Configuration**\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<beans xmlns=\"http://www.springframework.org/schema/beans\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:sec=\"http://cxf.apache.org/configuration/security\"\n xmlns:http=\"http://cxf.apache.org/transports/http/configuration\"\n xmlns:httpj=\"http://cxf.apache.org/transports/http-jetty/configuration\"\n xmlns:jaxws=\"http://java.sun.com/xml/ns/jaxws\"\n xsi:schemaLocation=\"...\">\n <httpj:engine-factory bus=\"cxf\">\n <httpj:engine port=\"9001\">\n <httpj:tlsServerParameters secureSocketProtocol=\"TLSv1\">\n <sec:keyManagers keyPassword=\"password\">\n <sec:keyStore type=\"JKS\" password=\"password\"\n file=\"certs/cherry.jks\"/>\n </sec:keyManagers>\n <sec:trustManagers>\n <sec:keyStore type=\"JKS\" password=\"password\"\n file=\"certs/truststore.jks\"/>\n </sec:trustManagers>\n </httpj:tlsServerParameters>\n </httpj:engine>\n </httpj:engine-factory>\n</beans>\n```\nThe preceding server configuration is described as follows:\n\nThe bus attribute references the relevant CXF Bus instance. By default, a CXF Bus instance with the ID, cxf, is automatically created by the Apache CXF runtime.\n\nOn the server side, TLS is not configured for each WSDL port. Instead of configuring each WSDL port, the TLS security settings are applied to a specific TCP port, which is 9001 in this example. All of the WSDL ports that share this TCP port are therefore configured with the same TLS security settings.\n\nThe http:tlsServerParameters element contains all of the server’s TLS configuration details.\n\n**IMPORTANT**\n\nYou must set secureSocketProtocol to TLSv1 on the server side, in order to protect against the Poodle vulnerability (CVE-2014-3566)\n\nThe sec:keyManagers element is used to attach an X.509 certificate and a private key to the server. The password specified by the keyPassword attribute is used to decrypt the certificate’s private key.\n\nThe sec:keyStore element is used to specify an X.509 certificate and a private key that are stored in a Java keystore. This sample declares that the keystore is in Java Keystore format (JKS).\n\nThe file attribute specifies the location of the keystore file, cherry.jks, that contains the client’s X.509 certificate chain and private key in a key entry. The password attribute specifies the keystore password, which is needed to access the contents of the keystore.\n\nIt is expected that the keystore file contains just one key entry, so it is not necessary to specify a key alias to identify the entry. If you are deploying a keystore file with multiple key entries, however, it is possible to specify the key in this case by adding the sec:certAlias element as a child of the http:tlsClientParameters element, as follows:\n\n```xml\n<http:tlsClientParameters>\n ...\n <sec:certAlias>CertAlias</sec:certAlias>\n ...\n</http:tlsClientParameters>\n```\nInstead of the `file` attribute, you can specify the location of the keystore using either the `resource` attribute or the `url` attribute. You must be extremely careful not to load the truststore from an untrustworthy source.\n\nFor details of how to create such a keystore file, see Section 2.5.3, “Use the CA to Create Signed Certificates in a Java Keystore”.\n\nThe `sec:trustManagers` element is used to specify a list of trusted CA certificates (the server uses this list to decide whether or not to trust certificates presented by clients).\n\nThe `file` attribute of the `sec:keyStore` element specifies a Java keystore file, `truststore.jks`, containing one or more trusted CA certificates. The `password` attribute specifies the password required to access the keystore, `truststore.jks`. See Section 3.2.2, “Specifying Trusted CA Certificates for HTTPS”.\n\nInstead of the `file` attribute, you can specify the location of the keystore using either the `resource` attribute or the `url` attribute.\n\nThe `sec:cipherSuitesFilter` element can be used to narrow the choice of cipher suites that the server is willing to use for a TLS connection. See Chapter 4, Configuring HTTPS Cipher Suites for details.\n\nThe `sec:clientAuthentication` element determines the server’s disposition towards the presentation of client certificates. The element has the following attributes:\n\n- **want** attribute—If `true` (the default), the server requests the client to present an X.509 certificate during the TLS handshake; if `false`, the server does not request the client to present an X.509 certificate.\n\n- **required** attribute—If `true`, the server raises an exception if a client fails to present an X.509 certificate during the TLS handshake; if `false` (the default), the server does not raise an exception if the client fails to present an X.509 certificate.\nCHAPTER 2. MANAGING CERTIFICATES\n\nAbstract\n\nTLS authentication uses X.509 certificates—a common, secure and reliable method of authenticating your application objects. You can create X.509 certificates that identify your Red Hat Fuse applications.\n\n2.1. WHAT IS AN X.509 CERTIFICATE?\n\nRole of certificates\n\nAn X.509 certificate binds a name to a public key value. The role of the certificate is to associate a public key with the identity contained in the X.509 certificate.\n\nIntegrity of the public key\n\nAuthentication of a secure application depends on the integrity of the public key value in the application’s certificate. If an impostor replaces the public key with its own public key, it can impersonate the true application and gain access to secure data.\n\nTo prevent this type of attack, all certificates must be signed by a certification authority (CA). A CA is a trusted node that confirms the integrity of the public key value in a certificate.\n\nDigital signatures\n\nA CA signs a certificate by adding its digital signature to the certificate. A digital signature is a message encoded with the CA’s private key. The CA’s public key is made available to applications by distributing a certificate for the CA. Applications verify that certificates are validly signed by decoding the CA’s digital signature with the CA’s public key.\n\nWARNING\n\nThe supplied demonstration certificates are self-signed certificates. These certificates are insecure because anyone can access their private key. To secure your system, you must create new certificates signed by a trusted CA.\n\nContents of an X.509 certificate\n\nAn X.509 certificate contains information about the certificate subject and the certificate issuer (the CA that issued the certificate). A certificate is encoded in Abstract Syntax Notation One (ASN.1), a standard syntax for describing messages that can be sent or received on a network.\n\nThe role of a certificate is to associate an identity with a public key value. In more detail, a certificate includes:\n\n- A subject distinguished name (DN) that identifies the certificate owner.\n- The public key associated with the subject.\n- X.509 version information.\n- A serial number that uniquely identifies the certificate.\n- An issuer DN that identifies the CA that issued the certificate.\n- The digital signature of the issuer.\n- Information about the algorithm used to sign the certificate.\n- Some optional X.509 v.3 extensions; for example, an extension exists that distinguishes between CA certificates and end-entity certificates.\n\nDistinguished names\n\nA DN is a general purpose X.500 identifier that is often used in the context of security.\n\nSee Appendix A, ASN.1 and Distinguished Names for more details about DNs.\n\n2.2. CERTIFICATION AUTHORITIES\n\n2.2.1. Introduction to Certificate Authorities\n\nA CA consists of a set of tools for generating and managing certificates and a database that contains all of the generated certificates. When setting up a system, it is important to choose a suitable CA that is sufficiently secure for your requirements.\n\nThere are two types of CA you can use:\n\n- commercial CAs are companies that sign certificates for many systems.\n- private CAs are trusted nodes that you set up and use to sign certificates for your system only.\n\n2.2.2. Commercial Certification Authorities\n\nSigning certificates\n\nThere are several commercial CAs available. The mechanism for signing a certificate using a commercial CA depends on which CA you choose.\n\nAdvantages of commercial CAs\n\nAn advantage of commercial CAs is that they are often trusted by a large number of people. If your applications are designed to be available to systems external to your organization, use a commercial CA to sign your certificates. If your applications are for use within an internal network, a private CA might be appropriate.\n\nCriteria for choosing a CA\n\nBefore choosing a commercial CA, consider the following criteria:\n\n- What are the certificate-signing policies of the commercial CAs?\n- Are your applications designed to be available on an internal network only?\n• What are the potential costs of setting up a private CA compared to the costs of subscribing to a commercial CA?\n\n2.2.3. Private Certification Authorities\n\nChoosing a CA software package\n\nIf you want to take responsibility for signing certificates for your system, set up a private CA. To set up a private CA, you require access to a software package that provides utilities for creating and signing certificates. Several packages of this type are available.\n\nOpenSSL software package\n\nOne software package that allows you to set up a private CA is OpenSSL, http://www.openssl.org. The OpenSSL package includes basic command line utilities for generating and signing certificates. Complete documentation for the OpenSSL command line utilities is available at http://www.openssl.org/docs.\n\nSetting up a private CA using OpenSSL\n\nTo set up a private CA, see the instructions in Section 2.5, ”Creating Your Own Certificates“.\n\nChoosing a host for a private certification authority\n\nChoosing a host is an important step in setting up a private CA. The level of security associated with the CA host determines the level of trust associated with certificates signed by the CA.\n\nIf you are setting up a CA for use in the development and testing of Red Hat Fuse applications, use any host that the application developers can access. However, when you create the CA certificate and private key, do not make the CA private key available on any hosts where security-critical applications run.\n\nSecurity precautions\n\nIf you are setting up a CA to sign certificates for applications that you are going to deploy, make the CA host as secure as possible. For example, take the following precautions to secure your CA:\n\n• Do not connect the CA to a network.\n• Restrict all access to the CA to a limited set of trusted users.\n• Use an RF-shield to protect the CA from radio-frequency surveillance.\n\n2.3. CERTIFICATE CHAINING\n\nCertificate chain\n\nA certificate chain is a sequence of certificates, where each certificate in the chain is signed by the subsequent certificate.\n\nFigure 2.1, ”A Certificate Chain of Depth 2“ shows an example of a simple certificate chain.\nSelf-signed certificate\n\nThe last certificate in the chain is normally a self-signed certificate—a certificate that signs itself.\n\nChain of trust\n\nThe purpose of a certificate chain is to establish a chain of trust from a peer certificate to a trusted CA certificate. The CA vouches for the identity in the peer certificate by signing it. If the CA is one that you trust (indicated by the presence of a copy of the CA certificate in your root certificate directory), this implies you can trust the signed peer certificate as well.\n\nCertificates signed by multiple CAs\n\nA CA certificate can be signed by another CA. For example, an application certificate could be signed by the CA for the finance department of Progress Software, which in turn is signed by a self-signed commercial CA.\n\nFigure 2.2, “A Certificate Chain of Depth 3” shows what this certificate chain looks like.\n\nTrusted CAs\n\nAn application can accept a peer certificate, provided it trusts at least one of the CA certificates in the signing chain.\n\n2.4. SPECIAL REQUIREMENTS ON HTTPS CERTIFICATES\n\nOverview\n\nThe HTTPS specification mandates that HTTPS clients must be capable of verifying the identity of the\nserver. This can potentially affect how you generate your X.509 certificates. The mechanism for verifying the server identity depends on the type of client. Some clients might verify the server identity by accepting only those server certificates signed by a particular trusted CA. In addition, clients can inspect the contents of a server certificate and accept only the certificates that satisfy specific constraints.\n\nIn the absence of an application-specific mechanism, the HTTPS specification defines a generic mechanism, known as the **HTTPS URL integrity check**, for verifying the server identity. This is the standard mechanism used by Web browsers.\n\n**HTTPS URL integrity check**\n\nThe basic idea of the URL integrity check is that the server certificate’s identity must match the server host name. This integrity check has an important impact on how you generate X.509 certificates for HTTPS: the certificate identity (usually the certificate subject DN’s common name) must match the host name on which the HTTPS server is deployed.\n\nThe URL integrity check is designed to prevent **man-in-the-middle** attacks.\n\n**Reference**\n\n\n**How to specify the certificate identity**\n\nThe certificate identity used in the URL integrity check can be specified in one of the following ways:\n\n- **Using commonName**\n- **Using subectAltName**\n\n**Using commonName**\n\nThe usual way to specify the certificate identity (for the purpose of the URL integrity check) is through the Common Name (CN) in the subject DN of the certificate.\n\nFor example, if a server supports secure TLS connections at the following URL:\n\n```\nhttps://www.redhat.com/secure\n```\n\nThe corresponding server certificate would have the following subject DN:\n\n```\nC=IE,ST=Co. Dublin,L=Dublin,O=RedHat,\nOU=System,CN=www.redhat.com\n```\n\nWhere the CN has been set to the host name, **www.redhat.com**.\n\nFor details of how to set the subject DN in a new certificate, see Section 2.5, “Creating Your Own Certificates”.\n\n**Using subjectAltName (multi-homed hosts)**\n\nUsing the subject DN’s Common Name for the certificate identity has the disadvantage that only **one**\nhost name can be specified at a time. If you deploy a certificate on a multi-homed host, however, you might find it is practical to allow the certificate to be used with any of the multi-homed host names. In this case, it is necessary to define a certificate with multiple, alternative identities, and this is only possible using the **subjectAltName** certificate extension.\n\nFor example, if you have a multi-homed host that supports connections to either of the following host names:\n\n```markdown\nwww.redhat.com\nwww.jboss.org\n```\n\nThen you can define a **subjectAltName** that explicitly lists both of these DNS host names. If you generate your certificates using the **openssl** utility, edit the relevant line of your **openssl.cnf** configuration file to specify the value of the **subjectAltName** extension, as follows:\n\n```markdown\nsubjectAltName=DNS:www.redhat.com,DNS:www.jboss.org\n```\n\nWhere the HTTPS protocol matches the server host name against either of the DNS host names listed in the **subjectAltName** (the **subjectAltName** takes precedence over the Common Name).\n\nThe HTTPS protocol also supports the wildcard character, `*`, in host names. For example, you can define the **subjectAltName** as follows:\n\n```markdown\nsubjectAltName=DNS:*.jboss.org\n```\n\nThis certificate identity matches any three-component host name in the domain **jboss.org**.\n\n---\n\n**WARNING**\n\nYou must never use the wildcard character in the domain name (and you must take care never to do this accidentally by forgetting to type the dot, `.`, delimiter in front of the domain name). For example, if you specified `*jboss.org`, your certificate could be used on *any* domain that ends in the letters **jboss**.\n\n---\n\n### 2.5. CREATING YOUR OWN CERTIFICATES\n\n#### 2.5.1. Prerequisites\n\n**OpenSSL utilities**\n\nThe steps described in this section are based on the OpenSSL command-line utilities from the OpenSSL project. Further documentation of the OpenSSL command-line utilities can be obtained at [http://www.openssl.org/docs/](http://www.openssl.org/docs/).\n\n**Sample CA directory structure**\n\nFor the purposes of illustration, the CA database is assumed to have the following directory structure:\n2.5.2. Set Up Your Own CA\n\nSubsteps to perform\n\nThis section describes how to set up your own private CA. Before setting up a CA for a real deployment, read the additional notes in Section 2.2.3, “Private Certification Authorities”.\n\nTo set up your own CA, perform the following steps:\n\n1. the section called “Add the bin directory to your PATH”\n2. the section called “Create the CA directory hierarchy”\n3. the section called “Copy and edit the openssl.cnf file”\n4. the section called “Initialize the CA database”\n5. the section called “Create a self-signed CA certificate and private key”\n\nAdd the bin directory to your PATH\n\nOn the secure CA host, add the OpenSSL bin directory to your path:\n\nWindows\n\n> set PATH=\\OpenSSLDir\\bin;%PATH%\n\nUNIX\n\n% PATH=/OpenSSLDir/bin:$PATH; export PATH\n\nThis step makes the openssl utility available from the command line.\n\nCreate the CA directory hierarchy\n\nCreate a new directory, X509CA, to hold the new CA. This directory is used to hold all of the files associated with the CA. Under the X509CA directory, create the following hierarchy of directories:\n\n<table>\n<thead>\n<tr>\n<th>X509CA/ca</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>X509CA/certs</td>\n</tr>\n<tr>\n<td>X509CA/newcerts</td>\n</tr>\n<tr>\n<td>X509CA/crl</td>\n</tr>\n</tbody>\n</table>\n\nWhere X509CA is the parent directory of the CA database.\nCopy and edit the openssl.cnf file\n\nCopy the sample openssl.cnf from your OpenSSL installation to the X509CA directory.\n\nEdit the openssl.cnf to reflect the directory structure of the X509CA directory, and to identify the files used by the new CA.\n\nEdit the [CA_default] section of the openssl.cnf file to look like the following:\n\n```\n[ CA_default ]\ndir = X509CA # Where CA files are kept\ncerts = $dir/certs # Where issued certs are kept\ncrl_dir = $dir/crl # Where the issued crl are kept\ndatabase = $dir/index.txt # Database index file\nnew_certs_dir = $dir/newcerts # Default place for new certs\ncertificate = $dir/ca/new_ca.pem # The CA certificate\nserial = $dir/serial # The current serial number\ncrl = $dir/crl.pem # The current CRL\nprivate_key = $dir/ca/new_ca_pk.pem # The private key\nRANDFILE = $dir/ca/.rand\n# Private random number file\nx509_extensions = usr_cert # The extensions to add to the cert\n...\n```\n\nYou might decide to edit other details of the OpenSSL configuration at this point—for more details, see http://www.openssl.org/docs/.\n\nInitialize the CA database\n\nIn the X509CA directory, initialize two files, serial and index.txt.\n\nWindows\n\nTo initialize the serial file in Windows, enter the following command:\n\n```\n> echo 01 > serial\n```\n\nTo create an empty file, index.txt, in Windows start Windows Notepad at the command line in the X509CA directory, as follows:\n\n```\n> notepad index.txt\n```\nIn response to the dialog box with the text, **Cannot find the text.txt file. Do you want to create a new file?**, click **Yes**, and close Notepad.\n\n**UNIX**\n\nTo initialize the **serial** file and the **index.txt** file in UNIX, enter the following command:\n\n```\n% echo \"01\" > serial\n% touch index.txt\n```\n\nThese files are used by the CA to maintain its database of certificate files.\n\n**NOTE**\n\nThe **index.txt** file must initially be completely empty, not even containing white space.\n\n**Create a self-signed CA certificate and private key**\n\nCreate a new self-signed CA certificate and private key with the following command:\n\n```\nopenssl req -x509 -new -config X509CA/openssl.cnf -days 365 -out X509CA/ca/new_ca.pem -keyout X509CA/ca/new_ca_pk.pem\n```\n\nThe command prompts you for a pass phrase for the CA private key and details of the CA distinguished name. For example:\n\n```\nUsing configuration from X509CA/openssl.cnf\nGenerating a 512 bit RSA private key\n....++\n++.writing new private key to 'new_ca_pk.pem'\nEnter PEM pass phrase:\nVerifying password - Enter PEM pass phrase:\n.....\nYou are about to be asked to enter information that will be incorporated into your certificate request.\nWhat you are about to enter is what is called a Distinguished Name or a DN. There are quite a few fields but you can leave some blank. For some fields there will be a default value, If you enter \".\", the field will be left blank.\n.....\nCountry Name (2 letter code) []:IE\nState or Province Name (full name) []:Co. Dublin\nLocality Name (eg, city) []:Dublin\nOrganization Name (eg, company) []:Red Hat\nOrganizational Unit Name (eg, section) []:Finance\nCommon Name (eg, YOUR name) []:Gordon Brown\nEmail Address []:gbrown@redhat.com\n```\n\n**NOTE**\n\nThe security of the CA depends on the security of the private key file and the private key pass phrase used in this step.\nYou must ensure that the file names and location of the CA certificate and private key, `new_ca.pem` and `new_ca_pk.pem`, are the same as the values specified in `openssl.cnf` (see the preceding step).\n\nYou are now ready to sign certificates with your CA.\n\n### 2.5.3. Use the CA to Create Signed Certificates in a Java Keystore\n\n#### Substeps to perform\n\nTo create and sign a certificate in a Java keystore (JKS), `CertName.jks`, perform the following substeps:\n\n1. the section called “Add the Java bin directory to your PATH”\n2. the section called “Generate a certificate and private key pair”\n3. the section called “Create a certificate signing request”\n4. the section called “Sign the CSR”\n5. the section called “Convert to PEM format”\n6. the section called “Concatenate the files”\n7. the section called “Update keystore with the full certificate chain”\n8. the section called “Repeat steps as required”\n\n#### Add the Java bin directory to your PATH\n\nIf you have not already done so, add the Java `bin` directory to your path:\n\n**Windows**\n\n```\n> set PATH=JAVA_HOME\\bin;%PATH%\n```\n\n**UNIX**\n\n```\n% PATH=JAVA_HOME/bin:$PATH; export PATH\n```\n\nThis step makes the `keytool` utility available from the command line.\n\n#### Generate a certificate and private key pair\n\nOpen a command prompt and change directory to the directory where you store your keystore files, `KeystoreDir`. Enter the following command:\n\n```\nkeytool -genkey -dname \"CN=Alice, OU=Engineering, O=Progress, ST=Co. Dublin, C=IE\" -validity 365 -alias CertAlias -keypass CertPassword -keystore CertName.jks -storepass CertPassword\n```\n\nThis `keytool` command, invoked with the `-genkey` option, generates an X.509 certificate and a matching private key. The certificate and the key are both placed in a key entry in a newly created keystore, `CertName.jks`. Because the specified keystore, `CertName.jks`, did not exist prior to issuing the command, `keytool` implicitly creates a new keystore.\nThe -dname and -validity flags define the contents of the newly created X.509 certificate, specifying the subject DN and the days before expiration respectively. For more details about DN format, see Appendix A, ASN.1 and Distinguished Names.\n\nSome parts of the subject DN must match the values in the CA certificate (specified in the CA Policy section of the openssl.cnf file). The default openssl.cnf file requires the following entries to match:\n\n- Country Name (C)\n- State or Province Name (ST)\n- Organization Name (O)\n\n**NOTE**\nIf you do not observe the constraints, the OpenSSL CA will refuse to sign the certificate (see the section called “Sign the CSR”).\n\nCreate a certificate signing request\n\nCreate a new certificate signing request (CSR) for the CertName.jks certificate, as follows:\n\n```\nkeytool -certreq -alias CertAlias -file CertName_csr.pem -keypass CertPassword -keystore CertName.jks -storepass CertPassword\n```\n\nThis command exports a CSR to the file, CertName_csr.pem.\n\nSign the CSR\n\nSign the CSR using your CA, as follows:\n\n```\nopenssl ca -config X509CA/openssl.cnf -days 365 -in CertName_csr.pem -out CertName.pem\n```\n\nTo sign the certificate successfully, you must enter the CA private key pass phrase (see Section 2.5.2, “Set Up Your Own CA”).\n\n**NOTE**\nIf you want to sign the CSR using a CA certificate other than the default CA, use the -cert and -keyfile options to specify the CA certificate and its private key file, respectively.\n\nConvert to PEM format\n\nConvert the signed certificate, CertName.pem, to PEM only format, as follows:\n\n```\nopenssl x509 -in CertName.pem -outform PEM\n```\n\nConcatenate the files\n\nConcatenate the CA certificate file and CertName.pem certificate file, as follows:\n\nWindows\ncopy CertName.pem + X509CA\\ca\\new_ca.pem CertName.chain\n\n**UNIX**\n\ncat CertName.pem X509CA/\\ca/\\new_ca.pem> CertName.chain\n\n**Update keystore with the full certificate chain**\n\nUpdate the keystore, *CertName.jks*, by importing the full certificate chain for the certificate, as follows:\n\n```\nkeytool -import -file CertName.chain -keypass CertPassword -keystore CertName.jks -storepass CertPassword\n```\n\n**Repeat steps as required**\n\nRepeat steps 2 through 7, to create a complete set of certificates for your system.\n\n**2.5.4. Use the CA to Create Signed PKCS#12 Certificates**\n\n**Substeps to perform**\n\nIf you have set up a private CA, as described in Section 2.5.2, “Set Up Your Own CA”, you are now ready to create and sign your own certificates.\n\nTo create and sign a certificate in PKCS#12 format, *CertName.p12*, perform the following substeps:\n\n1. the section called “Add the bin directory to your PATH”.\n2. the section called “Configure the subjectAltName extension (Optional)”.\n3. the section called “Create a certificate signing request”.\n4. the section called “Sign the CSR”.\n5. the section called “Concatenate the files”.\n6. the section called “Create a PKCS#12 file”.\n7. the section called “Repeat steps as required”.\n8. the section called “(Optional) Clear the subjectAltName extension”.\n\n**Add the bin directory to your PATH**\n\nIf you have not already done so, add the OpenSSL *bin* directory to your path, as follows:\n\n**Windows**\n\n```\n> set PATH=OpenSSLDir\\bin;%PATH%\n```\n\n**UNIX**\n\n```\n% PATH=OpenSSLDir/bin:$PATH; export PATH\n```\nThis step makes the `openssl` utility available from the command line.\n\n### Configure the `subjectAltName` extension (Optional)\n\nPerform this step, if the certificate is intended for a HTTPS server whose clients enforce URL integrity check, and if you plan to deploy the server on a multi-homed host or a host with several DNS name aliases (for example, if you are deploying the certificate on a multi-homed Web server). In this case, the certificate identity must match multiple host names and this can be done only by adding a `subjectAltName` certificate extension (see Section 2.4, \"Special Requirements on HTTPS Certificates\").\n\nTo configure the `subjectAltName` extension, edit your CA’s `openssl.cnf` file as follows:\n\n1. Add the following `req_extensions` setting to the `[req]` section (if not already present in your `openssl.cnf` file):\n\n ```conf\n # openssl Configuration File\n ...\n [req]\n req_extensions=v3_req\n ```\n\n2. Add the `[v3_req]` section header (if not already present in your `openssl.cnf` file). Under the `[v3_req]` section, add or modify the `subjectAltName` setting, setting it to the list of your DNS host names. For example, if the server host supports the alternative DNS names, `www.redhat.com` and `jboss.org`, set the `subjectAltName` as follows:\n\n ```conf\n # openssl Configuration File\n ...\n [v3_req]\n subjectAltName=DNS:www.redhat.com,DNS:jboss.org\n ```\n\n3. Add a `copy_extensions` setting to the appropriate CA configuration section. The CA configuration section used for signing certificates is one of the following:\n\n - The section specified by the `-name` option of the `openssl ca` command,\n - The section specified by the `default_ca` setting under the `[ca]` section (usually `[CA_default]`).\n\n For example, if the appropriate CA configuration section is `[CA_default]`, set the `copy_extensions` property as follows:\n\n ```conf\n # openssl Configuration File\n ...\n [CA_default]\n copy_extensions=copy\n ```\n\n This setting ensures that certificate extensions present in the certificate signing request are copied into the signed certificate.\n\n### Create a certificate signing request\n\nCreate a new certificate signing request (CSR) for the `CertName.p12` certificate, as shown:\nopenssl req -new -config X509CA/openssl.cnf -days 365 -out X509CA/certs/CertName_csr.pem -keyout X509CA/certs/CertName_pk.pem\n\nThis command prompts you for a pass phrase for the certificate’s private key, and for information about the certificate’s distinguished name.\n\nSome of the entries in the CSR distinguished name must match the values in the CA certificate (specified in the CA Policy section of the openssl.cnf file). The default openssl.cnf file requires that the following entries match:\n\n- Country Name\n- State or Province Name\n- Organization Name\n\nThe certificate subject DN’s Common Name is the field that is usually used to represent the certificate owner’s identity. The Common Name must comply with the following conditions:\n\n- The Common Name must be distinct for every certificate generated by the OpenSSL certificate authority.\n- If your HTTPS clients implement the URL integrity check, you must ensure that the Common Name is identical to the DNS name of the host where the certificate is to be deployed (see Section 2.4, “Special Requirements on HTTPS Certificates”).\n\nNOTE\n\nFor the purpose of the HTTPS URL integrity check, the subjectAltName extension takes precedence over the Common Name.\n\nUsing configuration from X509CA/openssl.cnf\nGenerating a 512 bit RSA private key\n .+\n .+\nwriting new private key to\n ’X509CA/certs/CertName_pk.pem’\nEnter PEM pass phrase:\nVerifying password - Enter PEM pass phrase:\n-----\nYou are about to be asked to enter information that will be incorporated into your certificate request. What you are about to enter is what is called a Distinguished Name or a DN. There are quite a few fields but you can leave some blank. For some fields there will be a default value, If you enter ‘.’, the field will be left blank.\n-----\nCountry Name (2 letter code) []:IE\nState or Province Name (full name) []:Co. Dublin\nLocality Name (eg, city) []:Dublin\nOrganization Name (eg, company) []:Red Hat\nOrganizational Unit Name (eg, section) []:Systems\nCommon Name (eg, YOUR name) []:Artix\nEmail Address []:info@redhat.com\nPlease enter the following ‘extra’ attributes to be sent with your certificate request:\nA challenge password [ ]: password\nAn optional company name [ ]: Red Hat\n\nSign the CSR\n\nSign the CSR using your CA, as follows:\n\n```bash\nopenssl ca -config X509CA/openssl.cnf -days 365 -in X509CA/certs/CertName_csr.pem -out X509CA/certs/CertName.pem\n```\n\nThis command requires the pass phrase for the private key associated with the new_ca.pem CA certificate. For example:\n\n```bash\nUsing configuration from X509CA/openssl.cnf\nEnter PEM pass phrase:\nCheck that the request matches the signature\nSignature ok\nThe Subjects Distinguished Name is as follows\ncountryName: 'IE'\nstateOrProvinceName: 'Co. Dublin'\nlocalityName: 'Dublin'\norganizationName: 'Red Hat'\norganizationalUnitName: 'Systems'\ncommonName: 'Bank Server Certificate'\nemailAddress: 'info@redhat.com'\nCertificate is to be certified until May 24 13:06:57 2000 GMT (365 days)\nSign the certificate? [y/n]: y\n1 out of 1 certificate requests certified, commit? [y/n]: y\nWrite out database with 1 new entries\nData Base Updated\n```\n\nTo sign the certificate successfully, you must enter the CA private key pass phrase (see Section 2.5.2, “Set Up Your Own CA”).\n\nNOTE\n\nIf you did not set copy_extensions=copy under the [CA_default] section in the openssl.cnf file, the signed certificate will not include any of the certificate extensions that were in the original CSR.\n\nConcatenate the files\n\nConcatenate the CA certificate file, CertName.pem certificate file, and CertName_pk.pem private key file as follows:\n\nWindows\n\n```bash\ncopy X509CA\\ca\\new_ca.pem + X509CA\\certspass:quotes[_CertName_]_pem + X509CA\\certspass:quotes[_CertName_]_pk.pem X509CA\\certspass:quotes[_CertName_]_list.pem\n```\n\nUNIX\n\n```bash\n```\nCreate a PKCS#12 file\n\nCreate a PKCS#12 file from the `CertName_list.pem` file as follows:\n\n```\nopenssl pkcs12 -export -in X509CA/certs/CertName_list.pem -out X509CA/certs/CertName.p12 -name \"New cert\"\n```\n\nYou are prompted to enter a password to encrypt the PKCS#12 certificate. Usually this password is the same as the CSR password (this is required by many certificate repositories).\n\n**Repeat steps as required**\n\nRepeat steps 3 through 6, to create a complete set of certificates for your system.\n\n**(OPTIONAL) CLEAR THE SUBJECTALTNAME EXTENSION**\n\nAfter generating certificates for a particular host machine, it is advisable to clear the `subjectAltName` setting in the `openssl.cnf` file to avoid accidentally assigning the wrong DNS names to another set of certificates.\n\nIn the `openssl.cnf` file, comment out the `subjectAltName` setting (by adding a `#` character at the start of the line), and also comment out the `copy_extensions` setting.\nCHAPTER 3. CONFIGURING HTTPS\n\nAbstract\nThis chapter describes how to configure HTTPS endpoints.\n\n3.1. AUTHENTICATION ALTERNATIVES\n\n3.1.1. Target-Only Authentication\n\nOverview\nWhen an application is configured for target-only authentication, the target authenticates itself to the client but the client is not authentic to the target object, as shown in Figure 3.1, “Target Authentication Only”.\n\nFigure 3.1. Target Authentication Only\n\nSecurity handshake\nPrior to running the application, the client and server should be set up as follows:\n\n- A certificate chain is associated with the server. The certificate chain is provided in the form of a Java keystore (see Section 3.3, “Specifying an Application’s Own Certificate”).\n- One or more lists of trusted certification authorities (CA) are made available to the client. (see Section 3.2, “Specifying Trusted CA Certificates”).\nDuring the security handshake, the server sends its certificate chain to the client (see Figure 3.1, \"Target Authentication Only\"). The client then searches its trusted CA lists to find a CA certificate that matches one of the CA certificates in the server’s certificate chain.\n\n### HTTPS example\n\nOn the client side, there are no policy settings required for target-only authentication. Simply configure your client without associating an X.509 certificate with the HTTPS port. You must provide the client with a list of trusted CA certificates, however (see Section 3.2, “Specifying Trusted CA Certificates”).\n\nOn the server side, in the server’s XML configuration file, make sure that the `sec:clientAuthentication` element does not require client authentication. This element can be omitted, in which case the default policy is to not require client authentication. However, if the `sec:clientAuthentication` element is present, it should be configured as follows:\n\n```xml\n<http:destination id=\"{Namespace}PortName.http-destination\">\n <http:tlsServerParameters secureSocketProtocol=\"TLSv1\">\n ...\n <sec:clientAuthentication want=\"false\" required=\"false\"/>\n </http:tlsServerParameters>\n</http:destination>\n```\n\n**IMPORTANT**\n\nYou must set `secureSocketProtocol` to `TLSv1` on the server side, in order to protect against the Poodle vulnerability (CVE-2014-3566)\n\nWhere the `want` attribute is set to false (the default), specifying that the server does not request an X.509 certificate from the client during a TLS handshake. The `required` attribute is also set to false (the default), specifying that the absence of a client certificate does not trigger an exception during the TLS handshake.\n\n**NOTE**\n\nThe `want` attribute can be set either to `true` or to `false`. If set to `true`, the `want` setting causes the server to request a client certificate during the TLS handshake, but no exception is raised for clients lacking a certificate, so long as the `required` attribute is set to `false`.\n\nIt is also necessary to associate an X.509 certificate with the server’s HTTPS port (see Section 3.3, “Specifying an Application’s Own Certificate”) and to provide the server with a list of trusted CA certificates (see Section 3.2, “Specifying Trusted CA Certificates”).\n\n**NOTE**\n\nThe choice of cipher suite can potentially affect whether or not target-only authentication is supported (see Chapter 4, Configuring HTTPS Cipher Suites).\n\n### 3.1.2. Mutual Authentication\n\n**Overview**\nWhen an application is configured for mutual authentication, the target authenticates itself to the client and the client authenticates itself to the target. This scenario is illustrated in Figure 3.2, \"Mutual Authentication\". In this case, the server and the client each require an X.509 certificate for the security handshake.\n\nFigure 3.2. Mutual Authentication\n\nSecurity handshake\n\nPrior to running the application, the client and server must be set up as follows:\n\n- Both client and server have an associated certificate chain (see Section 3.3, “Specifying an Application’s Own Certificate”).\n- Both client and server are configured with lists of trusted certification authorities (CA) (see Section 3.2, “Specifying Trusted CA Certificates”).\nDuring the TLS handshake, the server sends its certificate chain to the client, and the client sends its certificate chain to the server—see Figure 3.1, \"Target Authentication Only\".\n\n**HTTPS example**\n\nOn the client side, there are no policy settings required for mutual authentication. Simply associate an X.509 certificate with the client’s HTTPS port (see Section 3.3, “Specifying an Application’s Own Certificate”). You also need to provide the client with a list of trusted CA certificates (see Section 3.2, “Specifying Trusted CA Certificates”).\n\nOn the server side, in the server’s XML configuration file, make sure that the `sec:clientAuthentication` element is configured to require client authentication. For example:\n\n```xml\n<http:destination id=\"{Namespace}PortName.http-destination\">\n <http:tlsServerParameters secureSocketProtocol=\"TLSv1\">\n ...\n <sec:clientAuthentication want=\"true\" required=\"true\"/>\n </http:tlsServerParameters>\n</http:destination>\n```\n\n**IMPORTANT**\n\nYou must set `secureSocketProtocol` to `TLSv1` on the server side, in order to protect against the Poodle vulnerability (CVE-2014-3566). Where the `want` attribute is set to `true`, specifying that the server requests an X.509 certificate from the client during a TLS handshake. The `required` attribute is also set to `true`, specifying that the absence of a client certificate triggers an exception during the TLS handshake.\n\nIt is also necessary to associate an X.509 certificate with the server’s HTTPS port (see Section 3.3, “Specifying an Application’s Own Certificate”) and to provide the server with a list of trusted CA certificates (see Section 3.2, “Specifying Trusted CA Certificates”).\n\n**NOTE**\n\nThe choice of cipher suite can potentially affect whether or not mutual authentication is supported (see Chapter 4, Configuring HTTPS Cipher Suites).\n\n### 3.2. SPECIFYING TRUSTED CA CERTIFICATES\n\n#### 3.2.1. When to Deploy Trusted CA Certificates\n\n**Overview**\n\nWhen an application receives an X.509 certificate during an SSL/TLS handshake, the application decides whether or not to trust the received certificate by checking whether the issuer CA is one of a pre-defined set of trusted CA certificates. If the received X.509 certificate is validly signed by one of the application’s trusted CA certificates, the certificate is deemed trustworthy; otherwise, it is rejected.\n\n**Which applications need to specify trusted CA certificates?**\nAny application that is likely to receive an X.509 certificate as part of an HTTPS handshake must specify a list of trusted CA certificates. For example, this includes the following types of application:\n\n- All HTTPS clients.\n- Any HTTPS servers that support **mutual authentication**.\n\n### 3.2.2. Specifying Trusted CA Certificates for HTTPS\n\n#### CA certificate format\n\nCA certificates must be provided in Java keystore format.\n\n#### CA certificate deployment in the Apache CXF configuration file\n\nTo deploy one or more trusted root CAs for the HTTPS transport, perform the following steps:\n\n1. Assemble the collection of trusted CA certificates that you want to deploy. The trusted CA certificates can be obtained from public CAs or private CAs (for details of how to generate your own CA certificates, see Section 2.5, “Creating Your Own Certificates”). The trusted CA certificates can be in any format that is compatible with the Java `keytool` utility; for example, PEM format. All you need are the certificates themselves—the private keys and passwords are not required.\n\n2. Given a CA certificate, `cacert.pem`, in PEM format, you can add the certificate to a JKS truststore (or create a new truststore) by entering the following command:\n\n ```\n keytool -import -file cacert.pem -alias CAAlias -keystore truststore.jks -storepass StorePass\n ```\n\n Where `CAAlias` is a convenient tag that enables you to access this particular CA certificate using the `keytool` utility. The file, `truststore.jks`, is a keystore file containing CA certificates—if this file does not already exist, the `keytool` utility creates one. The `StorePass` password provides access to the keystore file, `truststore.jks`.\n\n3. Repeat step 2 as necessary, to add all of the CA certificates to the truststore file, `truststore.jks`.\n\n4. Edit the relevant XML configuration files to specify the location of the truststore file. You must include the `sec:trustManagers` element in the configuration of the relevant HTTPS ports. For example, you can configure a client port as follows:\n\n ```xml\n <!-- Client port configuration -->\n <http:conduit id=\"{Namespace}PortName.http-conduit\">\n <http:tlsClientParameters>\n ...\n <sec:trustManagers>\n <sec:keyStore type=\"JKS\"\n password=\"StorePass\"\n file=\"certs/truststore.jks\"/>\n </sec:trustManagers>\n ...\n </http:tlsClientParameters>\n </http:conduit>\n ```\n\n Where the `type` attribute specifies that the truststore uses the JKS keystore implementation and `StorePass` is the password needed to access the `truststore.jks` keystore.\nConfigure a server port as follows:\n\n```xml\n<http:destination id=\"{Namespace}.PortName.http-destination\">\n <http:tlsServerParameters secureSocketProtocol=\"TLSv1\">\n ...<sec:trustManagers>\n <sec:keyStore type=\"JKS\"\n password=\"StorePass\"\n file=\"certs/truststore.jks\"/>\n </sec:trustManagers>\n ...</http:tlsServerParameters>\n</http:destination>\n```\n\n**IMPORTANT**\n\nYou must set secureSocketProtocol to **TLSv1** on the server side, in order to protect against the **Poodle vulnerability (CVE-2014-3566)**.\n\n**WARNING**\n\nThe directory containing the truststores (for example, `X509Deploy/truststores`) should be a secure directory (that is, writable only by the administrator).\n\n### 3.3. SPECIFYING AN APPLICATION’S OWN CERTIFICATE\n\n#### 3.3.1. Deploying Own Certificate for HTTPS\n\n**Overview**\n\nWhen working with the HTTPS transport the application’s certificate is deployed using the XML configuration file.\n\n**Procedure**\n\nTo deploy an application’s own certificate for the HTTPS transport, perform the following steps:\n\n1. Obtain an application certificate in Java keystore format, `CertName.jks`. For instructions on how to create a certificate in Java keystore format, see Section 2.5.3, “Use the CA to Create Signed Certificates in a Java Keystore”.\nSome HTTPS clients (for example, Web browsers) perform a URL integrity check, which requires a certificate’s identity to match the hostname on which the server is deployed. See Section 2.4, “Special Requirements on HTTPS Certificates” for details.\n\n2. Copy the certificate’s keystore, CertName.jks, to the certificates directory on the deployment host; for example, X509Deploy/certs. The certificates directory should be a secure directory that is writable only by administrators and other privileged users.\n\n3. Edit the relevant XML configuration file to specify the location of the certificate keystore, CertName.jks. You must include the sec:keyManagers element in the configuration of the relevant HTTPS ports.\n\nFor example, you can configure a client port as follows:\n\n```xml\n<http:conduit id=\"{Namespace}PortName.http-conduit\">\n <http:clientParameters/>\n ...\n <sec:keyManagers keyPassword=\"CertPassword\">\n <sec:keyStore type=\"JKS\">\n password=\"KeystorePassword\"\n file=\"certs/CertName.jks\"/>\n </sec:keyManagers>\n ...\n</http:conduit>\n```\n\nWhere the keyPassword attribute specifies the password needed to decrypt the certificate’s private key (that is, CertPassword), the type attribute specifies that the truststore uses the JKS keystore implementation, and the password attribute specifies the password required to access the CertName.jks keystore (that is, KeystorePassword).\n\nConfigure a server port as follows:\n\n```xml\n<http:destination id=\"{Namespace}PortName.http-destination\">\n <http:serverParameters secureSocketProtocol=\"TLSv1\">\n ...\n <sec:keyManagers keyPassword=\"CertPassword\">\n <sec:keyStore type=\"JKS\">\n password=\"KeystorePassword\"\n file=\"certs/CertName.jks\"/>\n </sec:keyManagers>\n ...\n </http:serverParameters>\n</http:destination>\n```\n\nIMPORTANT\n\nYou must set secureSocketProtocol to TLSv1 on the server side, in order to protect against the Poodle vulnerability (CVE-2014-3566).\nWARNING\n\nThe directory containing the application certificates (for example, `X509Deploy/certs/`) should be a secure directory (that is, readable and writable only by the administrator).\n\nWARNING\n\nThe directory containing the XML configuration file should be a secure directory (that is, readable and writable only by the administrator), because the configuration file contains passwords in plain text.\nCHAPTER 4. CONFIGURING HTTPS CIPHER SUITES\n\nAbstract\n\nThis chapter explains how to specify the list of cipher suites that are made available to clients and servers for the purpose of establishing HTTPS connections. During a security handshake, the client chooses a cipher suite that matches one of the cipher suites available to the server.\n\n4.1. SUPPORTED CIPHER SUITES\n\nOverview\n\nA cipher suite is a collection of security algorithms that determine precisely how an SSL/TLS connection is implemented.\n\nFor example, the SSL/TLS protocol mandates that messages be signed using a message digest algorithm. The choice of digest algorithm, however, is determined by the particular cipher suite being used for the connection. Typically, an application can choose either the MD5 or the SHA digest algorithm.\n\nThe cipher suites available for SSL/TLS security in Apache CXF depend on the particular JSSE provider that is specified on the endpoint.\n\nJCE/JSSE and security providers\n\nThe Java Cryptography Extension (JCE) and the Java Secure Socket Extension (JSSE) constitute a pluggable framework that allows you to replace the Java security implementation with arbitrary third-party toolkits, known as security providers.\n\nSunJSSE provider\n\nIn practice, the security features of Apache CXF have been tested only with SUN’s JSSE provider, which is named SunJSSE.\n\nHence, the SSL/TLS implementation and the list of available cipher suites in Apache CXF are effectively determined by what is available from SUN’s JSSE provider.\n\nCipher suites supported by SunJSSE\n\nThe following cipher suites are supported by SUN’s JSSE provider in the J2SE 1.5.0 Java development kit (see also Appendix A of SUN’s JSSE Reference Guide):\n\n- Standard ciphers:\n \n SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA\n SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA\n SSL_DHE_DSS_WITH_DES_CBC_SHA\n SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA\n SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA\n SSL_DHE_RSA_WITH_DES_CBC_SHA\n SSL_RSA_EXPORT_WITH_DES40_CBC_SHA\n SSL_RSA_EXPORT_WITH_RC4_40_MD5\n SSL_RSA_WITH_3DES_EDE_CBC_SHA\nnull encryption, integrity-only ciphers:\n\n- SSL_RSA_WITH_NULL_MD5\n- SSL_RSA_WITH_NULL_SHA\n\nAnonymous Diffie-Hellman ciphers (no authentication):\n\n- SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA\n- SSL_DH_anon_EXPORT_WITH_RC4_40_MD5\n- SSL_DH_anon_EXPORT_WITH_3DES_EDE_CBC_SHA\n- SSL_DH_anon_EXPORT_WITH_DES_CBC_SHA\n- SSL_DH_anon_EXPORT_WITH_RC4_128_MD5\n- TLS_DH_anon_EXPORT_WITH_AES_128_CBC_SHA\n- TLS_DH_anon_EXPORT_WITH_AES_256_CBC_SHA\n\n**JSSE reference guide**\n\nFor more information about SUN’s JSSE framework, please consult the *JSSE Reference Guide* at the following location:\n\nhttp://download.oracle.com/javase/1.5.0/docs/guide/security/jsse/JSSERefGuide.html\n\n### 4.2. CIPHER SUITE FILTERS\n\n**Overview**\n\nIn a typical application, you usually want to restrict the list of available cipher suites to a subset of the ciphers supported by the JSSE provider.\n\nGenerally, you should use the `sec:cipherSuitesFilter` element, instead of the `sec:cipherSuites` element to select the cipher suites you want to use.\n\nThe `sec:cipherSuites` element is not recommended for general use, because it has rather non-intuitive semantics: you can use it to require that the loaded security provider supports at least the listed cipher\nsuites. But the security provider that is loaded might support many more cipher suites than the ones that are specified. Hence, when you use the sec:cipherSuites element, it is not clear exactly which cipher suites are supported at run time.\n\nNamespaces\n\nTable 4.1, “Namespaces Used for Configuring Cipher Suite Filters” shows the XML namespaces that are referenced in this section:\n\n<table>\n<thead>\n<tr>\n<th>Prefix</th>\n<th>Namespace URI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>http</td>\n<td><a href=\"http://cxf.apache.org/transports/http/configuration\">http://cxf.apache.org/transports/http/configuration</a></td>\n</tr>\n<tr>\n<td>httpj</td>\n<td><a href=\"http://cxf.apache.org/transports/http-jetty/configuration\">http://cxf.apache.org/transports/http-jetty/configuration</a></td>\n</tr>\n<tr>\n<td>sec</td>\n<td><a href=\"http://cxf.apache.org/configuration/security\">http://cxf.apache.org/configuration/security</a></td>\n</tr>\n</tbody>\n</table>\n\nsec:cipherSuitesFilter element\n\nYou define a cipher suite filter using the sec:cipherSuitesFilter element, which can be a child of either a http:tlsClientParameters element or a httpj:tlsServerParameters element. A typical sec:cipherSuitesFilter element has the outline structure shown in Example 4.1, “Structure of a sec:cipherSuitesFilter Element”.\n\nExample 4.1. Structure of a sec:cipherSuitesFilter Element\n\n```xml\n<sec:cipherSuitesFilter>\n <sec:include>RegularExpression</sec:include>\n <sec:include>RegularExpression</sec:include>\n ...\n <sec:exclude>RegularExpression</sec:exclude>\n <sec:exclude>RegularExpression</sec:exclude>\n ...\n</sec:cipherSuitesFilter>\n```\n\nSemantics\n\nThe following semantic rules apply to the sec:cipherSuitesFilter element:\n\n1. If a sec:cipherSuitesFilter element does not appear in an endpoint’s configuration (that is, it is absent from the relevant http:conduit or httpj:engine-factory element), the following default filter is used:\n\n```xml\n<sec:cipherSuitesFilter>\n <sec:include>.*_EXPORT_.*</sec:include>\n <sec:include>.*_EXPORT1024.*</sec:include>\n</sec:cipherSuitesFilter>\n```\n2. If the sec:cipherSuitesFilter element does appear in an endpoint’s configuration, all cipher suites are excluded by default.\n\n3. To include cipher suites, add a sec:include child element to the sec:cipherSuitesFilter element. The content of the sec:include element is a regular expression that matches one or more cipher suite names (for example, see the cipher suite names in the section called “Cipher suites supported by SunJSSE”).\n\n4. To refine the selected set of cipher suites further, you can add a sec:exclude element to the sec:cipherSuitesFilter element. The content of the sec:exclude element is a regular expression that matches zero or more cipher suite names from the currently included set.\n\nNOTE\nSometimes it makes sense to explicitly exclude cipher suites that are currently not included, in order to future-proof against accidental inclusion of undesired cipher suites.\n\nRegular expression matching\n\nThe grammar for the regular expressions that appear in the sec:include and sec:exclude elements is defined by the Java regular expression utility, java.util.regex.Pattern. For a detailed description of the grammar, please consult the Java reference guide, http://download.oracle.com/javase/1.5.0/docs/api/java/util/regex/Pattern.html.\n\nClient conduit example\n\nThe following XML configuration shows an example of a client that applies a cipher suite filter to the remote endpoint, {WSDLPortNamespace}PortName. Whenever the client attempts to open an SSL/TLS connection to this endpoint, it restricts the available cipher suites to the set selected by the sec:cipherSuitesFilter element.\n\n```xml\n<beans ...>\n <http:conduit name=\"{WSDLPortNamespace}PortName.http-conduit\">\n <http:tlsClientParameters>\n ...\n <sec:cipherSuitesFilter>\n <sec:include>_WITH_3DES_.*</sec:include>\n <sec:include>_WITH_DES_.*</sec:include>\n <sec:exclude>_WITH_NULL_.*</sec:exclude>\n <sec:exclude>_DH_anon_.*</sec:exclude>\n </sec:cipherSuitesFilter>\n </http:tlsClientParameters>\n </http:conduit>\n <bean id=\"cxf\" class=\"org.apache.cxf.bus.CXFBusImpl\"/>\n</beans>\n```\n\n4.3. SSL/TLS PROTOCOL VERSION\nOverview\n\nThe versions of the SSL/TLS protocol that are supported by Apache CXF depend on the particular JSSE provider configured. By default, the JSSE provider is configured to be SUN’s JSSE provider implementation.\n\nWARNING\n\nIf you enable SSL/TLS security, you must ensure that you explicitly disable the SSLv3 protocol, in order to safeguard against the Poodle vulnerability (CVE-2014-3566). For more details, see Disabling SSLv3 in JBoss Fuse 6.x and JBoss A-MQ 6.x.\n\nSSL/TLS protocol versions supported by SunJSSE\n\nTable 4.2, “SSL/TLS Protocols Supported by SUN’s JSSE Provider” shows the SSL/TLS protocol versions supported by SUN’s JSSE provider.\n\nTable 4.2. SSL/TLS Protocols Supported by SUN’s JSSE Provider\n\n<table>\n<thead>\n<tr>\n<th>Protocol</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SSLv2Hello</td>\n<td>Do not use! (POODLE security vulnerability)</td>\n</tr>\n<tr>\n<td>SSLv3</td>\n<td>Do not use! (POODLE security vulnerability)</td>\n</tr>\n<tr>\n<td>TLSv1</td>\n<td>Supports TLS version 1</td>\n</tr>\n<tr>\n<td>TLSv1.1</td>\n<td>Supports TLS version 1.1 (JDK 7 or later)</td>\n</tr>\n<tr>\n<td>TLSv1.2</td>\n<td>Supports TLS version 1.2 (JDK 7 or later)</td>\n</tr>\n</tbody>\n</table>\n\nExcluding specific SSL/TLS protocol versions\n\nBy default, all of the SSL/TLS protocols provided by the JSSE provider are available to the CXF endpoints (except for the SSLv2Hello and SSLv3 protocols, which have been specifically excluded by the CXF runtime since Fuse version 6.2.0, because of the Poodle vulnerability (CVE-2014-3566)).\n\nTo exclude specific SSL/TLS protocols, use the <sec:excludeProtocols> element in the endpoint configuration. You can configure the <sec:excludeProtocols> element as a child of the <httpj:tlsServerParameters> element (server side).\n\nTo exclude all protocols except for TLS version 1.2, configure the <sec:excludeProtocols> element as follows (assuming you are using JDK 7 or later):\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?><beans ...>\n <beans ...>\n ...\n```\n\n```xml\n <sec:excludeProtocols>\n <sec:excludeProtocols>SSLv2Hello,SSLv3</sec:excludeProtocols>\n </sec:excludeProtocols>\n```\n\n```xml\n <httpj:tlsServerParameters>\n ...</httpj:tlsServerParameters>\n```\n<httpj:engine-factory bus=\"cxf\"> \n<httpj:engine port=\"9001\"> \n ...\n <httpj:tlsServerParameters>\n ...\n <sec:excludeProtocols>\n <sec:excludeProtocol>SSLv2Hello</sec:excludeProtocol>\n <sec:excludeProtocol>TLSv1</sec:excludeProtocol>\n </sec:excludeProtocols>\n </httpj:tlsServerParameters>\n</httpj:engine>\n</httpj:engine-factory>\n...\n</beans>\n\n**IMPORTANT**\n\nIt is recommended that you always exclude the **SSLv2Hello** and **SSLv3** protocols, to protect against the Poodle vulnerability (CVE-2014-3566).\n\n**secureSocketProtocol attribute**\n\nBoth the **http:tlsClientParameters** element and the **httpj:tlsServerParameters** element support the **secureSocketProtocol** attribute, which enables you to specify a particular protocol.\n\nThe semantics of this attribute are confusing, however: this attribute forces CXF to pick an SSL provider that supports the specified protocol, but it does not restrict the provider to use only the specified protocol. Hence, the endpoint could end up using a protocol that is different from the one specified. For this reason, the recommendation is that you do **not** use the **secureSocketProtocol** attribute in your code.\nCHAPTER 5. THE WS-POLICY FRAMEWORK\n\nAbstract\n\nThis chapter provides an introduction to the basic concepts of the WS-Policy framework, defining policy subjects and policy assertions, and explaining how policy assertions can be combined to make policy expressions.\n\n5.1. INTRODUCTION TO WS-POLICY\n\nOverview\n\nThe WS-Policy specification provides a general framework for applying policies that modify the semantics of connections and communications at runtime in a Web services application. Apache CXF security uses the WS-Policy framework to configure message protection and authentication requirements.\n\nPolicies and policy references\n\nThe simplest way to specify a policy is to embed it directly where you want to apply it. For example, to associate a policy with a specific port in the WSDL contract, you can specify it as follows:\n\n```xml\n<wsdl:definitions targetNamespace=\"http://tempuri.org/\n xmlns:wsdl=\"http://schemas.xmlsoap.org/wsdl/\n xmlns:soap=\"http://schemas.xmlsoap.org/wsdl/soap/\n xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"\n xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\" ... >\n...\n<wsdl:service name=\"PingService10\">\n <wsdl:port name=\"UserNameOverTransport_IPingService\" binding=\"BindingName\">\n <wsp:Policy> <!-- Policy expression comes here! --> </wsp:Policy>\n <soap:address location=\"SOAPAddress\"/>\n </wsdl:port>\n</wsdl:service>\n</wsdl:definitions>\n```\n\nAn alternative way to specify a policy is to insert a policy reference element, `wsp:PolicyReference`, at the point where you want to apply the policy and then insert the policy element, `wsp:Policy`, at some other point in the XML file. For example, to associate a policy with a specific port using a policy reference, you could use a configuration like the following:\n\n```xml\n<wsdl:definitions targetNamespace=\"http://tempuri.org/\n xmlns:wsdl=\"http://schemas.xmlsoap.org/wsdl/\n xmlns:soap=\"http://schemas.xmlsoap.org/wsdl/soap/\n xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"\n xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\" ... >\n...\n<wsdl:service name=\"PingService10\">\n <wsdl:port name=\"UserNameOverTransport_IPingService\" binding=\"BindingName\">\n <wsp:PolicyReference URI=\"#PolicyID\"/>\n <soap:address location=\"SOAPAddress\"/>\n </wsdl:port>\n</wsdl:service>\n```\nWhere the policy reference, `wsp:PolicyReference`, locates the referenced policy using the ID, `PolicyID` (note the addition of the `#` prefix character in the `URI` attribute). The policy itself, `wsp:Policy`, must be identified by adding the attribute, `wsu:Id=\"PolicyID\"`.\n\n**Policy subjects**\n\nThe entities with which policies are associated are called *policy subjects*. For example, you can associate a policy with an endpoint, in which case the *endpoint* is the policy subject. It is possible to associate multiple policies with any given policy subject. The WS-Policy framework supports the following kinds of policy subject:\n\n- the section called “Service policy subject”.\n- the section called “Endpoint policy subject”.\n- the section called “Operation policy subject”.\n- the section called “Message policy subject”.\n\n**Service policy subject**\n\nTo associate a policy with a service, insert either a `<wsp:Policy>` element or a `<wsp:PolicyReference>` element as a sub-element of the following WSDL 1.1 element:\n\n- `wsdl:service`—apply the policy to all of the ports (endpoints) offered by this service.\n\n**Endpoint policy subject**\n\nTo associate a policy with an endpoint, insert either a `<wsp:Policy>` element or a `<wsp:PolicyReference>` element as a sub-element of any of the following WSDL 1.1 elements:\n\n- `wsdl:portType`—apply the policy to all of the ports (endpoints) that use this port type.\n- `wsdl:binding`—apply the policy to all of the ports that use this binding.\n- `wsdl:port`—apply the policy to this endpoint only.\n\nFor example, you can associate a policy with an endpoint binding as follows (using a policy reference):\n\n```xml\n<wsp:Policy wsu:Id=\"PolicyID\">\n<!-- Policy expression comes here ... -->\n</wsp:Policy>\n</wsdl:definitions>\n```\n<wsp:Policy wsu:Id=\"PolicyID\"> ... </wsp:Policy>\n...\n</wsdl:definitions>\n\nOperation policy subject\n\nTo associate a policy with an operation, insert either a `<wsp:Policy>` element or a `<wsp:PolicyReference>` element as a sub-element of any of the following WSDL 1.1 elements:\n\n- `wsdl:portType/wsdl:operation`\n- `wsdl:binding/wsdl:operation`\n\nFor example, you can associate a policy with an operation in a binding as follows (using a policy reference):\n\n```xml\n<wsdl:definitions targetNamespace=\"http://tempuri.org/\"\n xmlns:wsdl=\"http://schemas.xmlsoap.org/wsdl/\n xmlns:soap=\"http://schemas.xmlsoap.org/wsdl/soap/\n xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"\n xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\" ... >\n...\n<wsdl:binding name=\"EndpointBinding\" type=\"i0:IPingService\">\n <wsdl:operation name=\"Ping\">\n <wsp:PolicyReference URI=\"#PolicyID\"/>\n <soap:operation soapAction=\"http://xmlsoap.org/Ping\" style=\"document\"/>\n <wsdl:input name=\"PingRequest\"> ... </wsdl:input>\n <wsdl:output name=\"PingResponse\"> ... </wsdl:output>\n </wsdl:operation>\n...\n</wsdl:binding>\n...\n<wsp:Policy wsu:Id=\"PolicyID\"> ... </wsp:Policy>\n...\n</wsdl:definitions>\n```\n\nMessage policy subject\n\nTo associate a policy with a message, insert either a `<wsp:Policy>` element or a `<wsp:PolicyReference>` element as a sub-element of any of the following WSDL 1.1 elements:\n\n- `wsdl:message`\n- `wsdl:portType/wsdl:operation/wsdl:input`\n- `wsdl:portType/wsdl:operation/wsdl:output`\n- `wsdl:portType/wsdl:operation/wsdl:fault`\n- `wsdl:binding/wsdl:operation/wsdl:input`\n- `wsdl:binding/wsdl:operation/wsdl:output`\n- `wsdl:binding/wsdl:operation/wsdl:fault`\nFor example, you can associate a policy with a message in a binding as follows (using a policy reference):\n\n```xml\n<wss:PolicyReference URI=\"#PolicyID\"/>\n```\n\n5.2. POLICY EXPRESSIONS\n\nOverview\n\nIn general, a `wsp:Policy` element is composed of multiple different policy settings (where individual policy settings are specified as policy assertions). Hence, the policy defined by a `wsp:Policy` element is really a composite object. The content of the `wsp:Policy` element is called a policy expression, where the policy expression consists of various logical combinations of the basic policy assertions. By tailoring the syntax of the policy expression, you can determine what combinations of policy assertions must be satisfied at runtime in order to satisfy the policy overall.\n\nThis section describes the syntax and semantics of policy expressions in detail.\n\nPolicy assertions\n\nPolicy assertions are the basic building blocks that can be combined in various ways to produce a policy. A policy assertion has two key characteristics: it adds a basic unit of functionality to the policy subject and it represents a boolean assertion to be evaluated at runtime. For example, consider the following policy assertion that requires a WS-Security username token to be propagated with request messages:\n\n```xml\n <sp:Policy>\n <sp:UsernameToken/>\n </sp:Policy>\n</sp:SupportingTokens>\n```\n\nWhen associated with an endpoint policy subject, this policy assertion has the following effects:\n\n- The Web service endpoint marshales/unmarshals the UsernameToken credentials.\nAt runtime, the policy assertion returns *true*, if UsernameToken credentials are provided (on the client side) or received in the incoming message (on the server side); otherwise the policy assertion returns *false*.\n\nNote that if a policy assertion returns *false*, this does not necessarily result in an error. The net effect of a particular policy assertion depends on how it is inserted into a policy and on how it is combined with other policy assertions.\n\n**Policy alternatives**\n\nA policy is built up using policy assertions, which can additionally be qualified using the *wsp:Optional* attribute, and various nested combinations of the *wsp:All* and *wsp:ExactlyOne* elements. The net effect of composing these elements is to produce a range of acceptable *policy alternatives*. As long as one of these acceptable policy alternatives is satisfied, the overall policy is also satisfied (evaluates to *true*).\n\n**wsp:All element**\n\nWhen a list of policy assertions is wrapped by the *wsp:All* element, all of the policy assertions in the list must evaluate to *true*. For example, consider the following combination of authentication and authorization policy assertions:\n\n```xml\n<wsp:Policy wsu:Id=\"AuthenticateAndAuthorizeWSSUsernameTokenPolicy\">\n <wsp:All>\n <sp:SupportingTokens>\n <wsp:Policy>\n <sp:UsernameToken/>\n </wsp:Policy>\n </sp:SupportingTokens>\n <sp:SupportingTokens>\n <wsp:Policy>\n <sp:SamlToken/>\n </wsp:Policy>\n </sp:SupportingTokens>\n </wsp:All>\n</wsp:Policy>\n```\n\nThe preceding policy will be satisfied for a particular incoming request, if the following conditions both hold:\n\n- WS-Security UsernameToken credentials must be present; and\n- A SAML token must be present.\n\n**NOTE**\n\nThe *wsp:Policy* element is semantically equivalent to *wsp:All*. Hence, if you removed the *wsp:All* element from the preceding example, you would obtain a semantically equivalent example.\n\n**wsp:ExactlyOne element**\n\nWhen a list of policy assertions is wrapped by the *wsp:ExactlyOne* element, at least one of the policy assertions in the list must evaluate to *true*. The runtime goes through the list, evaluating policy assertions until it finds a policy assertion that returns *true*. At that point, the *wsp:ExactlyOne*\nexpression is satisfied (returns `true`) and any remaining policy assertions from the list will not be evaluated. For example, consider the following combination of authentication policy assertions:\n\n```xml\n<wsp:Policy wsu:Id=\"AuthenticateUsernamePasswordPolicy\">\n <wsp:ExactlyOne>\n <sp:SupportingTokens>\n <wsp:Policy>\n <sp:UsernameToken/>\n </wsp:Policy>\n </sp:SupportingTokens>\n <sp:SupportingTokens>\n <wsp:Policy>\n <sp:SamlToken/>\n </wsp:Policy>\n </sp:SupportingTokens>\n </wsp:ExactlyOne>\n</wsp:Policy>\n```\n\nThe preceding policy will be satisfied for a particular incoming request, if **either** of the following conditions hold:\n\n- WS-Security UsernameToken credentials are present; or\n- A SAML token is present.\n\nNote, in particular, that if **both** credential types are present, the policy would be satisfied after evaluating one of the assertions, but no guarantees can be given as to which of the policy assertions actually gets evaluated.\n\n### The empty policy\n\nA special case is the **empty policy**, an example of which is shown in Example 5.1, “The Empty Policy”.\n\n**Example 5.1. The Empty Policy**\n\n```xml\n<wsp:Policy ... >\n <wsp:ExactlyOne>\n <wsp:All/>\n </wsp:ExactlyOne>\n</wsp:Policy>\n```\n\nWhere the empty policy alternative, `<wsp:All/>`, represents an alternative for which no policy assertions need be satisfied. In other words, it always returns `true`. When `<wsp:All/>` is available as an alternative, the overall policy can be satisfied even when no policy assertions are `true`.\n\n### The null policy\n\nA special case is the **null policy**, an example of which is shown in Example 5.2, “The Null Policy”.\n\n**Example 5.2. The Null Policy**\nWhere the null policy alternative, `<wsp:ExactlyOne/>`, represents an alternative that is never satisfied. In other words, it always returns `false`.\n\n**Normal form**\n\nIn practice, by nesting the `<wsp:All>` and `<wsp:ExactlyOne>` elements, you can produce fairly complex policy expressions, whose policy alternatives might be difficult to work out. To facilitate the comparison of policy expressions, the WS-Policy specification defines a canonical or normal form for policy expressions, such that you can read off the list of policy alternatives unambiguously. Every valid policy expression can be reduced to the normal form.\n\nIn general, a normal form policy expression conforms to the syntax shown in Example 5.3, “Normal Form Syntax”.\n\n**Example 5.3. Normal Form Syntax**\n\n```\n<wsp:Policy ... >\n <wsp:ExactlyOne>\n <wsp:All> <Assertion .../> ... < Assertion .../> </wsp:All>\n <wsp:All> <Assertion .../> ... < Assertion .../> </wsp:All>\n ...\n </wsp:ExactlyOne>\n</wsp:Policy>\n```\n\nWhere each line of the form, `<wsp:All>...<wsp:All>`, represents a valid policy alternative. If one of these policy alternatives is satisfied, the policy is satisfied overall.\nCHAPTER 6. MESSAGE PROTECTION\n\nAbstract\n\nThe following message protection mechanisms are described in this chapter: protection against eavesdropping (by employing encryption algorithms) and protection against message tampering (by employing message digest algorithms). The protection can be applied at various levels of granularity and to different protocol layers. At the transport layer, you have the option of applying protection to the entire contents of the message; while at the SOAP layer, you have the option of applying protection to various parts of the message (bodies, headers, or attachments).\n\n6.1. TRANSPORT LAYER MESSAGE PROTECTION\n\nOverview\n\nTransport layer message protection refers to the message protection (encryption and signing) that is provided by the transport layer. For example, HTTPS provides encryption and message signing features using SSL/TLS. In fact, WS-SecurityPolicy does not add much to the HTTPS feature set, because HTTPS is already fully configurable using Blueprint XML configuration (see Chapter 3, Configuring HTTPS). An advantage of specifying a transport binding policy for HTTPS, however, is that it enables you to embed security requirements in the WSDL contract. Hence, any client that obtains a copy of the WSDL contract can discover what the transport layer security requirements are for the endpoints in the WSDL contract.\n\nWARNING\n\nIf you enable SSL/TLS security in the transport layer, you must ensure that you explicitly disable the SSLv3 protocol, in order to safeguard against the Poodle vulnerability (CVE-2014-3566). For more details, see Disabling SSLv3 in JBoss Fuse 6.x and JBoss A-MQ 6.x.\n\nPrerequisites\n\nIf you use WS-SecurityPolicy to configure the HTTPS transport, you must also configure HTTPS security appropriately in the Blueprint configuration.\n\nExample 6.1, “Client HTTPS Configuration in Blueprint” shows how to configure a client to use the HTTPS transport protocol. The sec:keyManagers element specifies the client’s own certificate, alice.pfx, and the sec:trustManagers element specifies the trusted CA list. Note how the http:conduit element’s name attribute uses wildcards to match the endpoint address. For details of how to configure HTTPS on the client side, see Chapter 3, Configuring HTTPS.\n\nExample 6.1. Client HTTPS Configuration in Blueprint\n\n```xml\n<beans xmlns=\"https://osgi.org/xmlns/blueprint/v1.0.0/\n xmlns:http=\"http://cxf.apache.org/transports/http/configuration\"\n xmlns:sec=\"http://cxf.apache.org/configuration/security\" ... >\n\n <http:conduit name=\"https://.*/UserNameOverTransport.*\">\n```\n\n52\nExample 6.2, “Server HTTPS Configuration in Blueprint” shows how to configure a server to use the HTTPS transport protocol. The `<sec:keyManagers>` element specifies the server’s own certificate, `bob.pfx`, and the `<sec:trustManagers>` element specifies the trusted CA list. For details of how to configure HTTPS on the server side, see Chapter 3, Configuring HTTPS.\n\nExample 6.2. Server HTTPS Configuration in Blueprint\n\n```xml\n<beans xmlns=\"https://osgi.org/xmlns/blueprint/v1.0.0/\"\n xmlns:httpj=\"http://cxf.apache.org/transports/http-jetty/configuration\"\n xmlns:sec=\"http://cxf.apache.org/configuration/security\">\n <httpj:engine-factory id=\"tls-settings\">\n <httpj:engine port=\"9001\">\n <httpj:tlsServerParameters secureSocketProtocol=\"TLSv1\">\n <sec:keyManagers keyPassword=\"password\">\n <sec:keyStore type=\"pkcs12\" password=\"password\" resource=\"certs/bob.pfx\"/>\n </sec:keyManagers>\n <sec:trustManagers>\n <sec:keyStore type=\"pkcs12\" password=\"password\" resource=\"certs/alice.pfx\"/>\n </sec:trustManagers>\n </httpj:tlsServerParameters>\n </httpj:engine>\n </httpj:engine-factory>\n</beans>\n```\n\n**IMPORTANT**\n\nYou must set `secureSocketProtocol` to `TLSv1` on the server side, in order to protect against the Poodle vulnerability (CVE-2014-3566)\n\n**Policy subject**\n\nA transport binding policy must be applied to an endpoint policy subject (see the section called “Endpoint policy subject”). For example, given the transport binding policy with ID, `UserNameOverTransport_IPingService_policy`, you could apply the policy to an endpoint binding as follows:\n\n```xml\n<wSDL:binding name=\"UserNameOverTransport_IPingService\" type=\"i0:IPingService\">\n <wsp:PolicyReference URI=\"#UserNameOverTransport_IPingService_policy\"/>\n</wSDL:binding>\n```\nSyntax\n\nThe **TransportBinding** element has the following syntax:\n\n```xml\n<sp:TransportBinding xmlns:sp=\"...\"> ...\n<sp:TransportToken ...\n<sp:Policy> ...\n</wsp:Policy>\n...\n</sp:TransportToken>\n<sp:AlgorithmSuite ...\n<sp:Layout ...\n<sp:IncludeTimestamp />\n...\n</wsp:Policy>\n...\n</sp:TransportBinding>\n```\n\nSample policy\n\n**Example 6.3, “Example of a Transport Binding”** shows an example of a transport binding that requires confidentiality and integrity using the HTTPS transport (specified by the **sp:HttpsToken** element) and a 256-bit algorithm suite (specified by the **sp:Basic256** element).\n\n**Example 6.3. Example of a Transport Binding**\n\n```xml\n<wsp:Policy wsu:Id=\"UserNameOverTransport_IPVingService_policy\">\n<wsp:ExactlyOne>\n<wsp:All>\n<wsp:Policy>\n<sp:TransportToken>\n<wsp:Policy>\n<sp:HttpsToken RequireClientCertificate=\"false\"/>\n</wsp:Policy>\n</sp:TransportToken>\n<sp:AlgorithmSuite>\n<sp:Policy>\n<sp:Basic256/>\n</wsp:Policy>\n</sp:AlgorithmSuite>\n<sp:Layout>\n<sp:Lax/>\n</wsp:Policy>\n</sp:Layout>\n<sp:IncludeTimestamp/>\n</wsp:Policy>\n</sp:TransportBinding>\n...\n```\nsp:TransportToken\n\nThis element has a two-fold effect: it requires a particular type of security token and it indicates how the transport is secured. For example, by specifying the sp:HttpsToken, you indicate that the connection is secured by the HTTPS protocol and the security tokens are X.509 certificates.\n\nsp:AlgorithmSuite\n\nThis element specifies the suite of cryptographic algorithms to use for signing and encryption. For details of the available algorithm suites, see Section 6.2.7, \"Specifying the Algorithm Suite\".\n\nsp:Layout\n\nThis element specifies whether to impose any conditions on the order in which security headers are added to the SOAP message. The sp:Lax element specifies that no conditions are imposed on the order of security headers. The alternatives to sp:Lax are sp:Strict, sp:LaxTimestampFirst, or sp:LaxTimestampLast.\n\nsp:IncludeTimestamp\n\nIf this element is included in the policy, the runtime adds a wsu:Timestamp element to the wsse:Security header. By default, the timestamp is not included.\n\nsp:MustSupportRefKeyIdentifier\n\nThis element specifies that the security runtime must be able to process Key Identifier token references, as specified in the WS-Security 1.0 specification. A key identifier is a mechanism for identifying a key token, which may be used inside signature or encryption elements. Apache CXF requires this feature.\n\nsp:MustSupportRefIssuerSerial\n\nThis element specifies that the security runtime must be able to process Issuer and Serial Number token references, as specified in the WS-Security 1.0 specification. An issuer and serial number is a mechanism for identifying a key token, which may be used inside signature or encryption elements. Apache CXF requires this feature.\n\n6.2. SOAP MESSAGE PROTECTION\n\n6.2.1. Introduction to SOAP Message Protection\n\nOverview\nBy applying message protection at the SOAP encoding layer, instead of at the transport layer, you have access to a more flexible range of protection policies. In particular, because the SOAP layer is aware of the message structure, you can apply protection at a finer level of granularity— for example, by encrypting and signing only those headers that actually require protection. This feature enables you to support more sophisticated multi-tier architectures. For example, one plaintext header might be aimed at an intermediate tier (located within a secure intranet), while an encrypted header might be aimed at the final destination (reached through an insecure public network).\n\n### Security bindings\n\nAs described in the WS-SecurityPolicy specification, one of the following binding types can be used to protect SOAP messages:\n\n- **sp:TransportBinding**—the transport binding refers to message protection provided at the transport level (for example, through HTTPS). This binding can be used to secure any message type, not just SOAP, and it is described in detail in the preceding section, Section 6.1, “Transport Layer Message Protection”.\n\n- **sp:AsymmetricBinding**—the asymmetric binding refers to message protection provided at the SOAP message encoding layer, where the protection features are implemented using asymmetric cryptography (also known as public key cryptography).\n\n- **sp:SymmetricBinding**—the symmetric binding refers to message protection provided at the SOAP message encoding layer, where the protection features are implemented using symmetric cryptography. Examples of symmetric cryptography are the tokens provided by WS-SecureConversation and Kerberos tokens.\n\n### Message protection\n\nThe following qualities of protection can be applied to part or all of a message:\n\n- Encryption.\n- Signing.\n- Signing+encryption (sign before encrypting).\n- Encryption+signing (encrypt before signing).\n\nThese qualities of protection can be arbitrarily combined in a single message. Thus, some parts of a message can be just encrypted, while other parts of the message are just signed, and other parts of the message can be both signed and encrypted. It is also possible to leave parts of the message unprotected.\n\nThe most flexible options for applying message protection are available at the SOAP layer (sp:AsymmetricBinding or sp:SymmetricBinding). The transport layer (sp:TransportBinding) only gives you the option of applying protection to the whole message.\n\n### Specifying parts of the message to protect\n\nCurrently, Apache CXF enables you to sign or encrypt the following parts of a SOAP message:\n\n- **Body**—sign and/or encrypt the whole of the soap:BODY element in a SOAP message.\n- **Header(s)**—sign and/or encrypt one or more SOAP message headers. You can specify the quality of protection for each header individually.\n- Attachments—sign and/or encrypt all of the attachments in a SOAP message.\n- Elements—sign and/or encrypt specific XML elements in a SOAP message.\n\n**Role of configuration**\n\nNot all of the details required for message protection are specified using policies. The policies are primarily intended to provide a way of specifying the quality of protection required for a service. Supporting details, such as security tokens, passwords, and so on, must be provided using a separate, product-specific mechanism. In practice, this means that in Apache CXF, some supporting configuration details must be provided in Blueprint XML configuration files. For details, see Section 6.2.6, “Providing Encryption Keys and Signing Keys”.\n\n### 6.2.2. Basic Signing and Encryption Scenario\n\n**Overview**\n\nThe scenario described here is a client-server application, where an asymmetric binding policy is set up to encrypt and sign the SOAP body of messages that pass back and forth between the client and the server.\n\n**Example scenario**\n\nFigure 6.1, “Basic Signing and Encryption Scenario” shows an overview of the basic signing and encryption scenario, which is specified by associating an asymmetric binding policy with an endpoint in the WSDL contract.\n\n**Figure 6.1. Basic Signing and Encryption Scenario**\n\n![Diagram of basic signing and encryption scenario]\n\n**Scenario steps**\n\nWhen the client in Figure 6.1, “Basic Signing and Encryption Scenario” invokes a synchronous operation on the recipient’s endpoint, the request and reply message are processed as follows:\n1. As the outgoing request message passes through the WS-SecurityPolicy handler, the handler processes the message in accordance with the policies specified in the client’s asymmetric binding policy. In this example, the handler performs the following processing:\n a. Encrypt the SOAP body of the message using Bob’s public key.\n b. Sign the encrypted SOAP body using Alice’s private key.\n\n2. As the incoming request message passes through the server’s WS-SecurityPolicy handler, the handler processes the message in accordance with the policies specified in the server’s asymmetric binding policy. In this example, the handler performs the following processing:\n a. Verify the signature using Alice’s public key.\n b. Decrypt the SOAP body using Bob’s private key.\n\n3. As the outgoing reply message passes back through the server’s WS-SecurityPolicy handler, the handler performs the following processing:\n a. Encrypt the SOAP body of the message using Alice’s public key.\n b. Sign the encrypted SOAP body using Bob’s private key.\n\n4. As the incoming reply message passes back through the client’s WS-SecurityPolicy handler, the handler performs the following processing:\n a. Verify the signature using Bob’s public key.\n b. Decrypt the SOAP body using Alice’s private key.\n\n### 6.2.3. Specifying an AsymmetricBinding Policy\n\n#### Overview\n\nThe asymmetric binding policy implements SOAP message protection using asymmetric key algorithms (public/private key combinations) and does so at the SOAP layer. The encryption and signing algorithms used by the asymmetric binding are similar to the encryption and signing algorithms used by SSL/TLS. A crucial difference, however, is that SOAP message protection enables you to select particular parts of a message to protect (for example, individual headers, body, or attachments), whereas transport layer security can operate only on the **whole** message.\n\n#### Policy subject\n\nAn asymmetric binding policy must be applied to an endpoint policy subject (see the section called “Endpoint policy subject”). For example, given the asymmetric binding policy with ID, **MutualCertificate10SignEncrypt_IPingService_policy**, you could apply the policy to an endpoint binding as follows:\n\n```xml\n<wsdl:binding name=\"MutualCertificate10SignEncrypt_IPingService\" type=\"i0:IPingService\">\n <wsp:PolicyReference URI=\"#MutualCertificate10SignEncrypt_IPingService_policy\"/>\n ...\n</wsdl:binding>\n```\n\n#### Syntax\nThe **AsymmetricBinding** element has the following syntax:\n\n```\n<sp:AsymmetricBinding xmlns:sp=\"...\" ...\n<wsp:Policy xmlns:wsp=\"...\">\n ( \n <sp:InitiatorToken>\n <wsp:Policy> ... </wsp:Policy>\n </sp:InitiatorToken>\n ) ) ( \n <sp:InitiatorSignatureToken>\n <wsp:Policy> ... </wsp:Policy>\n </sp:InitiatorSignatureToken>\n <sp:InitiatorEncryptionToken>\n <wsp:Policy> ... </wsp:Policy>\n </sp:InitiatorEncryptionToken>\n ) ( \n <sp:RecipientToken>\n <wsp:Policy> ... </wsp:Policy>\n </sp:RecipientToken>\n ) ) ( \n <sp:RecipientSignatureToken>\n <wsp:Policy> ... </wsp:Policy>\n </sp:RecipientSignatureToken>\n <sp:RecipientEncryptionToken>\n <wsp:Policy> ... </wsp:Policy>\n </sp:RecipientEncryptionToken>\n )\n <sp:AlgorithmSuite ... > ... </sp:AlgorithmSuite>\n <sp:Layout ... > ... </sp:Layout> ?\n <sp:IncludeTimestamp ... /> ?\n <sp:EncryptBeforeSigning ... /> ?\n <sp:EncryptSignature ... /> ?\n <sp:ProtectTokens ... /> ?\n <sp:OnlySignEntireHeadersAndBody ... /> ?\n...\n</wsp:Policy>\n...\n</sp:AsymmetricBinding>\n```\n\n**Sample policy**\n\n**Example 6.4. Example of an Asymmetric Binding** shows an example of an asymmetric binding that supports message protection with signatures and encryption, where the signing and encryption is done using pairs of public/private keys (that is, using asymmetric cryptography). This example does not specify which parts of the message should be signed and encrypted, however. For details of how to do that, see Section 6.2.5, “Specifying Parts of Message to Encrypt and Sign”.\n\n**Example 6.4. Example of an Asymmetric Binding**\n\n```\n<wsp:Policy wsu:Id=\"MutualCertificate10SignEncrypt_IPingService_policy\">\n <wsp:ExactlyOne>\n <wsp:All>\n <sp:AsymmetricBinding\n```\n\n59\nThe initiator token refers to the public/private key-pair owned by the initiator. This token is used as follows:\n\n```xml\n<sp:InitiatorToken>\n <wsp:Policy>\n <sp:X509Token\n sp:IncludeToken=\"http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/AlwaysToRecipient\">\n <wsp:Policy>\n <sp:WssX509V3Token10/>\n </wsp:Policy>\n </sp:X509Token>\n </wsp:Policy>\n</sp:InitiatorToken>\n\n<sp:RecipientToken>\n <wsp:Policy>\n <sp:X509Token\n sp:IncludeToken=\"http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never\">\n <wsp:Policy>\n <sp:WssX509V3Token10/>\n </wsp:Policy>\n </sp:X509Token>\n </wsp:Policy>\n</sp:RecipientToken>\n\n<sp:AlgorithmSuite>\n <wsp:Policy>\n <sp:Basic256/>\n </wsp:Policy>\n</sp:AlgorithmSuite>\n\n<sp:Layout>\n <wsp:Policy>\n <sp:Lax/>\n </wsp:Policy>\n</sp:Layout>\n\n<sp:IncludeTimestamp/>\n<sp:EncryptSignature/>\n<sp:OnlySignEntireHeadersAndBody/>\n</wsp:Policy>\n</sp:AsymmetricBinding>\n\n <wsp:Policy>\n <sp:MustSupportRefKeyId/>\n <sp:MustSupportRefIssuerSerial/>\n </wsp:Policy>\n</sp:Wss10>\n</wsp:ExactlyOne>\n</wsp:Policy>\n```\nThe token’s private key signs messages sent from initiator to recipient.\n\nThe token’s public key verifies signatures received by the recipient.\n\nThe token’s public key encrypts messages sent from recipient to initiator.\n\nThe token’s private key decrypts messages received by the initiator.\n\nConfusingly, this token is used both by the initiator and by the recipient. However, only the initiator has access to the private key so, in this sense, the token can be said to belong to the initiator. In Section 6.2.2, “Basic Signing and Encryption Scenario”, the initiator token is the certificate, Alice.\n\nThis element should contain a nested wsp:Policy element and sp:X509Token element as shown. The sp:IncludeToken attribute is set to AlwaysToRecipient, which instructs the runtime to include Alice’s public key with every message sent to the recipient. This option is useful, in case the recipient wants to use the initiator’s certificate to perform authentication. The most deeply nested element, WssX509V3Token10 is optional. It specifies what specification version the X.509 certificate should conform to. The following alternatives (or none) can be specified here:\n\nsp:WssX509V3Token10\nThis optional element is a policy assertion that indicates that an X509 Version 3 token should be used.\n\nsp:WssX509Pkcs7Token10\nThis optional element is a policy assertion that indicates that an X509 PKCS7 token should be used.\n\nsp:WssX509PkiPathV1Token10\nThis optional element is a policy assertion that indicates that an X509 PKI Path Version 1 token should be used.\n\nsp:WssX509V1Token11\nThis optional element is a policy assertion that indicates that an X509 Version 1 token should be used.\n\nsp:WssX509V3Token11\nThis optional element is a policy assertion that indicates that an X509 Version 3 token should be used.\n\nsp:WssX509Pkcs7Token11\nThis optional element is a policy assertion that indicates that an X509 PKCS7 token should be used.\n\nsp:WssX509PkiPathV1Token11\nThis optional element is a policy assertion that indicates that an X509 PKI Path Version 1 token should be used.\n\nsp:RecipientToken\nThe recipient token refers to the public/private key-pair owned by the recipient. This token is used as follows:\n\n- The token’s public key encrypts messages sent from initiator to recipient.\n- The token’s private key decrypts messages received by the recipient.\n- The token’s private key signs messages sent from recipient to initiator.\n- The token’s public key verifies signatures received by the initiator.\nConfusingly, this token is used both by the recipient and by the initiator. However, only the recipient has access to the private key so, in this sense, the token can be said to belong to the recipient. In Section 6.2.2, “Basic Signing and Encryption Scenario”, the recipient token is the certificate, Bob.\n\nThis element should contain a nested wsp:Policy element and sp:X509Token element as shown. The sp:IncludeToken attribute is set to Never, because there is no need to include Bob’s public key in the reply messages.\n\n**NOTE**\n\nIn Apache CXF, there is never a need to send Bob’s or Alice’s token in a message, because both Bob’s certificate and Alice’s certificate are provided at both ends of the connection—see Section 6.2.6, “Providing Encryption Keys and Signing Keys”.\n\n**sp:AlgorithmSuite**\n\nThis element specifies the suite of cryptographic algorithms to use for signing and encryption. For details of the available algorithm suites, see Section 6.2.7, “Specifying the Algorithm Suite”.\n\n**sp:Layout**\n\nThis element specifies whether to impose any conditions on the order in which security headers are added to the SOAP message. The sp:Lax element specifies that no conditions are imposed on the order of security headers. The alternatives to sp:Lax are sp:Strict, sp:LaxTimestampFirst, or sp:LaxTimestampLast.\n\n**sp:IncludeTimestamp**\n\nIf this element is included in the policy, the runtime adds a wsu:Timestamp element to the wsse:Security header. By default, the timestamp is not included.\n\n**sp:EncryptBeforeSigning**\n\nIf a message part is subject to both encryption and signing, it is necessary to specify the order in which these operations are performed. The default order is to sign before encrypting. But if you include this element in your asymmetric policy, the order is changed to encrypt before signing.\n\n**NOTE**\n\nImplicitly, this element also affects the order of the decryption and signature verification operations. For example, if the sender of a message signs before encrypting, the receiver of the message must decrypt before verifying the signature.\n\n**sp:EncryptSignature**\n\nThis element specifies that the message signature must be encrypted (by the encryption token, specified as described in Section 6.2.6, “Providing Encryption Keys and Signing Keys”). Default is false.\nNOTE\n\nThe message signature is the signature obtained directly by signing various parts of the message, such as message body, message headers, or individual elements (see Section 6.2.5, “Specifying Parts of Message to Encrypt and Sign”). Sometimes the message signature is referred to as the primary signature, because the WS-SecurityPolicy specification also supports the concept of an endorsing supporting token, which is used to sign the primary signature. Hence, if an sp:EndorsingSupportingTokens element is applied to an endpoint, you can have a chain of signatures: the primary signature, which signs the message itself, and the secondary signature, which signs the primary signature.\n\nFor more details about the various kinds of endorsing supporting token, see the section called “SupportingTokens assertions”.\n\nsp:ProtectTokens\n\nThis element specifies that signatures must cover the token used to generate that signature. Default is false.\n\nsp:OnlySignEntireHeadersAndBody\n\nThis element specifies that signatures can be applied only to an entire body or to entire headers, not to sub-elements of the body or sub-elements of a header. When this option is enabled, you are effectively prevented from using the sp:SignedElements assertion (see Section 6.2.5, “Specifying Parts of Message to Encrypt and Sign”).\n\n6.2.4. Specifying a SymmetricBinding Policy\n\nOverview\n\nThe symmetric binding policy implements SOAP message protection using symmetric key algorithms (shared secret key) and does so at the SOAP layer. Examples of a symmetric binding are the Kerberos protocol and the WS-SecureConversation protocol.\n\nNOTE\n\nCurrently, Apache CXF supports only WS-SecureConversation tokens in a symmetric binding.\n\nPolicy subject\n\nA symmetric binding policy must be applied to an endpoint policy subject (see the section called “Endpoint policy subject”). For example, given the symmetric binding policy with ID, SecureConversation_MutualCertificate10SignEncrypt_IPingService_policy, you could apply the policy to an endpoint binding as follows:\n\n```xml\n<wssl:binding name=\"SecureConversation_MutualCertificate10SignEncrypt_IPingService\" type=\"i0:IPingService\">\n <wsp:PolicyReference\n URI=\"#SecureConversation_MutualCertificate10SignEncrypt_IPingService_policy\"/>\n ...\n</wssl:binding>\n```\nSyntax\n\nThe **SymmetricBinding** element has the following syntax:\n\n```\n<sp:SymmetricBinding xmlns:sp=\"...\" ... >\n <wsp:Policy xmlns:wsp=\"...\">...\n ( ...\n <sp:EncryptionToken ... >\n <wsp:Policy> ... </wsp:Policy>\n </sp:EncryptionToken>\n <sp:SignatureToken ... >\n <wsp:Policy> ... </wsp:Policy>\n </sp:SignatureToken>\n ) | ( ...\n <sp:ProtectionToken ... >\n <wsp:Policy> ... </wsp:Policy>\n </sp:ProtectionToken>\n )\n </wsp:Policy>\n</sp:SymmetricBinding>\n```\n\nSample policy\n\nExample 6.5, “Example of a Symmetric Binding” shows an example of a symmetric binding that supports message protection with signatures and encryption, where the signing and encryption is done using a single symmetric key (that is, using symmetric cryptography). This example does not specify which parts of the message should be signed and encrypted, however. For details of how to do that, see Section 6.2.5, “Specifying Parts of Message to Encrypt and Sign”.\n\nExample 6.5. Example of a Symmetric Binding\n\n```\n<wsp:Policy wsu:Id=\"SecureConversation_MutualCertificate10SignEncrypt_IPingService_policy\">\n <wsp:ExactlyOne>\n <wsp:All>\n <wsp:Policy>\n <sp:ProtectionToken>\n <wsp:Policy>\n <sp:SecureConversationToken>\n ...\n </sp:SecureConversationToken>\n </wsp:Policy>\n </sp:ProtectionToken>\n </wsp:Policy>\n </sp:SymmetricBinding>\n </wsp:All>\n </wsp:ExactlyOne>\n</wsp:Policy>\n```\nsp:ProtectionToken\n\nThis element specifies a symmetric token to use for both signing and encrypting messages. For example, you could specify a WS-SecureConversation token here.\n\nIf you want to use distinct tokens for signing and encrypting operations, use the sp:SignatureToken element and the sp:EncryptionToken element in place of this element.\n\nsp:SignatureToken\n\nThis element specifies a symmetric token to use for signing messages. It should be used in combination with the sp:EncryptionToken element.\n\nsp:EncryptionToken\n\nThis element specifies a symmetric token to use for encrypting messages. It should be used in combination with the sp:SignatureToken element.\n\nsp:AlgorithmSuite\n\nThis element specifies the suite of cryptographic algorithms to use for signing and encryption. For details of the available algorithm suites, see Section 6.2.7, \"Specifying the Algorithm Suite\".\n\nsp:Layout\n\nThis element specifies whether to impose any conditions on the order in which security headers are added to the SOAP message. The sp:Lax element specifies that no conditions are imposed on the order of security headers. The alternatives to sp:Lax are sp:Strict, sp:LaxTimestampFirst, or sp:LaxTimestampLast.\nsp:IncludeTimestamp\n\nIf this element is included in the policy, the runtime adds a wsu:Timestamp element to the wsse:Security header. By default, the timestamp is not included.\n\nsp:EncryptBeforeSigning\n\nWhen a message part is subject to both encryption and signing, it is necessary to specify the order in which these operations are performed. The default order is to sign before encrypting. But if you include this element in your symmetric policy, the order is changed to encrypt before signing.\n\nNOTE\n\nImplicitly, this element also affects the order of the decryption and signature verification operations. For example, if the sender of a message signs before encrypting, the receiver of the message must decrypt before verifying the signature.\n\nsp:EncryptSignature\n\nThis element specifies that the message signature must be encrypted. Default is false.\n\nsp:ProtectTokens\n\nThis element specifies that signatures must cover the token used to generate that signature. Default is false.\n\nsp:OnlySignEntireHeadersAndBody\n\nThis element specifies that signatures can be applied only to an entire body or to entire headers, not to sub-elements of the body or sub-elements of a header. When this option is enabled, you are effectively prevented from using the sp:SignedElements assertion (see Section 6.2.5, “Specifying Parts of Message to Encrypt and Sign”).\n\n6.2.5. Specifying Parts of Message to Encrypt and Sign\n\nOverview\n\nEncryption and signing provide two kinds of protection: confidentiality and integrity, respectively. The WS-SecurityPolicy protection assertions are used to specify which parts of a message are subject to protection. Details of the protection mechanisms, on the other hand, are specified separately in the relevant binding policy (see Section 6.2.3, “Specifying an AsymmetricBinding Policy”, Section 6.2.4, “Specifying a SymmetricBinding Policy”, and Section 6.1, “Transport Layer Message Protection”).\n\nThe protection assertions described here are really intended to be used in combination with SOAP security, because they apply to features of a SOAP message. Nonetheless, these policies can also be satisfied by a transport binding (such as HTTPS), which applies protection to the entire message, rather than to specific parts.\n\nPolicy subject\n\nA protection assertion must be applied to a message policy subject (see the section called “Message policy subject”). In other words, it must be placed inside a wsdl:input, wsdl:output, or wsdl:fault element in a WSDL binding. For example, given the protection policy with ID,\n**MutualCertificate10SignEncrypt_IPingService_header_input_policy**, you could apply the policy to a `wsdl:input` message part as follows:\n\n```xml\n<wSDL:operation name=\"header\">\n <soap:operation soapAction=\"http://InteropBaseAddress/interop/header\" style=\"document\"/>\n <wsdl:input name=\"headerRequest\">\n <wsp:PolicyReference\n URI=\"#MutualCertificate10SignEncrypt_IPingService_header_Input_policy\"/>\n <soap:header message=\"i0:headerRequest_Headers\" part=\"CustomHeader\" use=\"literal\"/>\n <soap:body use=\"literal\"/>\n </wsdl:input>\n ...\n</wSDL:operation>\n```\n\n**Protection assertions**\n\nThe following WS-SecurityPolicy protection assertions are supported by Apache CXF:\n\n- **SignedParts**\n- **EncryptedParts**\n- **SignedElements**\n- **EncryptedElements**\n- **ContentEncryptedElements**\n- **RequiredElements**\n- **RequiredParts**\n\n**Syntax**\n\nThe **SignedParts** element has the following syntax:\n\n```xml\n<sp:SignedParts xmlns:sp=\"...\" ... >\n <sp:Body />?\n <sp:Header Name=\"xs:NCName\"? Namespace=\"xs:anyURI\" ... />*\n <sp:Attachments />?\n ...\n</sp:SignedParts>\n```\n\nThe **EncryptedParts** element has the following syntax:\n\n```xml\n<sp:EncryptedParts xmlns:sp=\"...\" ... >\n <sp:Body />?\n <sp:Header Name=\"xs:NCName\"? Namespace=\"xs:anyURI\" ... />*\n <sp:Attachments />?\n ...\n</sp:EncryptedParts>\n```\n\n**Sample policy**\nExample 6.6, “Integrity and Encryption Policy Assertions” shows a policy that combines two protection assertions: a signed parts assertion and an encrypted parts assertion. When this policy is applied to a message part, the affected message bodies are signed and encrypted. In addition, the message header named `CustomHeader` is signed.\n\n**Example 6.6. Integrity and Encryption Policy Assertions**\n\n```xml\n<wsp:Policy wsu:Id=\"MutualCertificate10SignEncrypt_IPingService_header_Input_policy\">\n <wsp:ExactlyOne>\n <wsp:All>\n <sp:Body/>\n <sp:Header Name=\"CustomHeader\" Namespace=\"http://InteropBaseAddress/interop\"/>\n </sp:SignedParts>\n <sp:Body/>\n </sp:EncryptedParts>\n </wsp:All>\n </wsp:ExactlyOne>\n</wsp:Policy>\n```\n\n**sp:Body**\n\nThis element specifies that protection (encryption or signing) is applied to the body of the message. The protection is applied to the **entire** message body: that is, the `soap:Body` element, its attributes, and its content.\n\n**sp:Header**\n\nThis element specifies that protection is applied to the SOAP header specified by the header’s local name, using the **Name** attribute, and namespace, using the **Namespace** attribute. The protection is applied to the **entire** message header, including its attributes and its content.\n\n**sp:Attachments**\n\nThis element specifies that **all** SOAP with Attachments (SwA) attachments are protected.\n\n### 6.2.6. Providing Encryption Keys and Signing Keys\n\n#### Overview\n\nThe standard WS-SecurityPolicy policies are designed to specify security **requirements** in some detail: for example, security protocols, security algorithms, token types, authentication requirements, and so on, are all described. But the standard policy assertions do not provide any mechanism for specifying associated security data, such as keys and credentials. WS-SecurityPolicy expects that the requisite security data is provided through a proprietary mechanism. In Apache CXF, the associated security data is provided through Blueprint XML configuration.\n\n#### Configuring encryption keys and signing keys\n\nYou can specify an application’s encryption keys and signing keys by setting properties on a client’s request context or on an endpoint context (see the section called “Add encryption and signing\nproperties to Blueprint configuration”). The properties you can set are shown in Table 6.1, “Encryption and Signing Properties”.\n\nTable 6.1. Encryption and Signing Properties\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>security.signature.properties</td>\n<td>The WSS4J properties file/object that contains the WSS4J properties for configuring the signature keystore (which is also used for decrypting) and Crypto objects.</td>\n</tr>\n<tr>\n<td>security.signature.username</td>\n<td>(Optional) The username or alias of the key in the signature keystore to use. If not specified, the alias set in the properties file is used. If that is also not set, and the keystore only contains a single key, that key will be used.</td>\n</tr>\n<tr>\n<td>security.encryption.properties</td>\n<td>The WSS4J properties file/object that contains the WSS4J properties for configuring the encryption keystore (which is also used for validating signatures) and Crypto objects.</td>\n</tr>\n<tr>\n<td>security.encryption.username</td>\n<td>(Optional) The username or alias of the key in the encryption keystore to use. If not specified, the alias set in the properties file is used. If that is also not set, and the keystore only contains a single key, that key will be used.</td>\n</tr>\n</tbody>\n</table>\n\nThe names of the preceding properties are not so well chosen, because they do not accurately reflect what they are used for. The key specified by `security.signature.properties` is actually used both for signing and decrypting. The key specified by `security.encryption.properties` is actually used both for encrypting and for validating signatures.\n\n**Add encryption and signing properties to Blueprint configuration**\n\nBefore you can use any WS-Policy policies in an Apache CXF application, you must add the policies feature to the default CXF bus. Add the `<p:policies>` element to the CXF bus, as shown in the following Blueprint configuration fragment:\n\n```xml\n<beans xmlns=\"http://www.osgi.org/xmlns/blueprint/v1.0.0\"\n xmlns:jaxws=\"http://cxf.apache.org/jaxws\"\n xmlns:cxf=\"http://cxf.apache.org/core\"\n xmlns:p=\"http://cxf.apache.org/policy\" ... >\n\n <cxf:bus>\n <cxf:features>\n <p:policies/>\n <cxf:logging/>\n </cxf:features>\n </cxf:bus>\n\n...</beans>\n```\nThe following example shows how to add signature and encryption properties to proxies of the specified service type (where the service name is specified by the name attribute of the jaxws:client element). The properties are stored in WSS4J property files, where alice.properties contains the properties for the signature key and bob.properties contains the properties for the encryption key.\n\n```xml\n<beans ... >\n createdFromAPI=\"true\">\n <jaxws:properties>\n <entry key=\"ws-security.signature.properties\" value=\"etc/alice.properties\"/>\n <entry key=\"ws-security.encryption.properties\" value=\"etc/bob.properties\"/>\n </jaxws:properties>\n </jaxws:client>\n...</beans>\n```\n\nIn fact, although it is not obvious from the property names, each of these keys is used for two distinct purposes on the client side:\n\n- **alice.properties** (that is, the key specified by security.signature.properties) is used on the client side as follows:\n - For signing outgoing messages.\n - For decrypting incoming messages.\n- **bob.properties** (that is, the key specified by security.encryption.properties) is used on the client side as follows:\n - For encrypting outgoing messages.\n - For verifying signatures on incoming messages.\n\nIf you find this confusing, see Section 6.2.2, “Basic Signing and Encryption Scenario” for a more detailed explanation.\n\nThe following example shows how to add signature and encryption properties to a JAX-WS endpoint. The properties file, bob.properties, contains the properties for the signature key and the properties file, alice.properties, contains the properties for the encryption key (this is the inverse of the client configuration).\n\n```xml\n<beans ... >\n <jaxws:endpoint\n name=\"[http://InteropBaseAddress/interop]MutualCertificate10SignEncrypt_IPingService\"\n id=\"MutualCertificate10SignEncrypt\"\n address=\"http://localhost:9002/MutualCertificate10SignEncrypt\"\n serviceName=\"interop:PingService10\"\n endpointName=\"interop:MutualCertificate10SignEncrypt_IPingService\"\n implementor=\"interop.server.MutualCertificate10SignEncrypt\">\n\n <jaxws:properties>\n <entry key=\"security.signature.properties\" value=\"etc/bob.properties\"/>\n <entry key=\"security.encryption.properties\" value=\"etc/alice.properties\"/>\n </jaxws:properties>\n\n </jaxws:endpoint>\n...</beans>\n```\nEach of these keys is used for two distinct purposes on the server side:\n\n- **bob.properties** (that is, the key specified by `security.signature.properties`) is used on the server side as follows:\n - For signing outgoing messages.\n - For decrypting incoming messages.\n\n- **alice.properties** (that is, the key specified by `security.encryption.properties`) is used on the server side as follows:\n - For encrypting outgoing messages.\n - For verifying signatures on incoming messages.\n\n### Define the WSS4J property files\n\nApache CXF uses WSS4J property files to load the public keys and the private keys needed for encryption and signing. Table 6.2, “WSS4J Keystore Properties” describes the properties that you can set in these files.\n\n**Table 6.2. WSS4J Keystore Properties**\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>org.apache.ws.security.crypto.provider</code></td>\n<td>Specifies an implementation of the <a href=\"#\">Crypto</a> interface (see the section called “WSS4J Crypto interface”). Normally, you specify the default WSS4J implementation of Crypto, <code>org.apache.ws.security.components.crypto.Merlin</code>. The rest of the properties in this table are specific to the Merlin implementation of the Crypto interface.</td>\n</tr>\n<tr>\n<td><code>org.apache.ws.security.crypto.merlin keystor e.provider</code></td>\n<td><em>(Optional)</em> The name of the JSSE keystore provider to use. The default keystore provider is Bouncy Castle. You can switch provider to Sun’s JSSE keystore provider by setting this property to SunJSSE.</td>\n</tr>\n<tr>\n<td><code>org.apache.ws.security.crypto.merlin keystor e.type</code></td>\n<td>The Bouncy Castle keystore provider supports the following types of keystore: JKS and PKCS12. In addition, Bouncy Castle supports the following proprietary keystore types: BKS and UBER.</td>\n</tr>\n<tr>\n<td>Property</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>----------</td>\n<td>-------------</td>\n</tr>\n<tr>\n<td>org.apache.ws.security.crypto.merlin.keystore.file</td>\n<td>Specifies the location of the keystore file to load, where the location is specified relative to the Classpath.</td>\n</tr>\n<tr>\n<td>org.apache.ws.security.crypto.merlin.keystore.alias</td>\n<td>(Optional) If the keystore type is JKS (Java keystore), you can select a specific key from the keystore by specifying its alias. If the keystore contains only one key, there is no need to specify an alias.</td>\n</tr>\n<tr>\n<td>org.apache.ws.security.crypto.merlin.keystore.password</td>\n<td>The password specified by this property is used for two purposes: to unlock the keystore (keystore password) and to decrypt a private key that is stored in the keystore (private key password). Hence, the keystore password must be same as the private key password.</td>\n</tr>\n</tbody>\n</table>\n\nFor example, the etc/alice.properties file contains property settings to load the PKCS#12 file, certs/alice.pfx, as follows:\n\n```properties\norg.apache.ws.security.crypto.merlin.keystore.type=PKCS12\norg.apache.ws.security.crypto.merlin.keystore.password=password\norg.apache.ws.security.crypto.merlin.keystore.file=certs/alice.pfx\n```\n\nThe etc/bob.properties file contains property settings to load the PKCS#12 file, certs/bob.pfx, as follows:\n\n```properties\norg.apache.ws.security.crypto.merlin.keystore.password=password\n# for some reason, bouncycastle has issues with bob.pfx\norg.apache.ws.security.crypto.merlin.keystore.provider=SunJSSE\norg.apache.ws.security.crypto.merlin.keystore.type=PKCS12\norg.apache.ws.security.crypto.merlin.keystore.file=certs/bob.pfx\n```\n\n**Programming encryption keys and signing keys**\n\nAn alternative approach to loading encryption keys and signing keys is to use the properties shown in Table 6.3, “Properties for Specifying Crypto Objects” to specify Crypto objects that load the relevant keys. This requires you to provide your own implementation of the WSS4J Crypto interface, org.apache.ws.security.components.crypto.Crypto.\n\n**Table 6.3. Properties for Specifying Crypto Objects**\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>security.signature.crypto</td>\n<td>Specifies an instance of a Crypto object that is responsible for loading the keys for signing and decrypting messages.</td>\n</tr>\n<tr>\n<td>security.encryption.crypto</td>\n<td>Specifies an instance of a Crypto object that is responsible for loading the keys for encrypting messages and verifying signatures.</td>\n</tr>\n</tbody>\n</table>\n\n**WSS4J Crypto interface**\n\nExample 6.7, “WSS4J Crypto Interface” shows the definition of the Crypto interface that you can implement, if you want to provide encryption keys and signing keys by programming. For more information, see the WSS4J home page.\n\n**Example 6.7. WSS4J Crypto Interface**\n\n```java\n// Java\npackage org.apache.ws.security.components.crypto;\nimport org.apache.ws.security.WSSecurityException;\nimport java.io.InputStream;\nimport java.math.BigInteger;\nimport java.security.KeyStore;\nimport java.security.PrivateKey;\nimport java.security.cert.Certificate;\nimport java.security.cert.CertificateFactory;\nimport java.security.cert.X509Certificate;\npublic interface Crypto {\n X509Certificate loadCertificate(InputStream in)\n throws WSSecurityException;\n\n X509Certificate[] getX509Certificates(byte[] data, boolean reverse)\n throws WSSecurityException;\n\n byte[] getCertificateData(boolean reverse, X509Certificate[] certs)\n throws WSSecurityException;\n\n public PrivateKey getPrivateKey(String alias, String password)\n throws Exception;\n\n public X509Certificate[] getCertificates(String alias)\n throws WSSecurityException;\n\n public String getAliasForX509Cert(Certificate cert)\n throws WSSecurityException;\n\n public String getAliasForX509Cert(String issuer)\n throws WSSecurityException;\n}\n```\n6.2.7. Specifying the Algorithm Suite\n\nOverview\n\nAn algorithm suite is a coherent collection of cryptographic algorithms for performing operations such as signing, encryption, generating message digests, and so on.\n\nFor reference purposes, this section describes the algorithm suites defined by the WS-SecurityPolicy specification. Whether or not a particular algorithm suite is available, however, depends on the underlying security provider. Apache CXF security is based on the pluggable Java Cryptography Extension (JCE) and Java Secure Socket Extension (JSSE) layers. By default, Apache CXF is configured with Sun’s JSSE provider, which supports the cipher suites described in Appendix A of Sun’s JSSE Reference Guide.\n\nSyntax\n\nThe `AlgorithmSuite` element has the following syntax:\n\n```xml\n<sp:AlgorithmSuite xmlns:sp=\"...\" ...\n<wsp:Policy xmlns:wsp=\"...\">\n (<sp:Basic256 ... /> | \n <sp:Basic192 ... /> | \n <sp:Basic128 ... /> | \n <sp:TripleDes ... /> | \n <sp:Basic256Rsa15 ... /> | \n <sp:Basic192Rsa15 ... /> | \n```\nThe algorithm suite assertion supports a large number of alternative algorithms (for example, Basic256). For a detailed description of the algorithm suite alternatives, see Table 6.4, “Algorithm Suites”.\n\nAlgorithm suites\n\nTable 6.4, “Algorithm Suites” provides a summary of the algorithm suites supported by WS-SecurityPolicy. The column headings refer to different types of cryptographic algorithm, as follows: \\[\\text{[Dig]}\\] is the digest algorithm; \\[\\text{[Enc]}\\] is the encryption algorithm; \\[\\text{[Sym KW]}\\] is the symmetric key-wrap algorithm; \\[\\text{[Asym KW]}\\] is the asymmetric key-wrap algorithm; \\[\\text{[Enc KD]}\\] is the encryption key derivation algorithm; \\[\\text{[Sig KD]}\\] is the signature key derivation algorithm.\n\nTable 6.4. Algorithm Suites\n\n<table>\n<thead>\n<tr>\n<th>Algorithm Suite</th>\n<th>[\\text{[Dig]}]</th>\n<th>[\\text{[Enc]}]</th>\n<th>[\\text{[Sym KW]}]</th>\n<th>[\\text{[Asym KW]}]</th>\n<th>[\\text{[Enc KD]}]</th>\n<th>[\\text{[Sig KD]}]</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Basic256</td>\n<td>Sha1</td>\n<td>Aes256</td>\n<td>KwAes256</td>\n<td>KwRsaOaep</td>\n<td>PSha1L256</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic192</td>\n<td>Sha1</td>\n<td>Aes192</td>\n<td>KwAes192</td>\n<td>KwRsaOaep</td>\n<td>PSha1L192</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic128</td>\n<td>Sha1</td>\n<td>Aes128</td>\n<td>KwAes128</td>\n<td>KwRsaOaep</td>\n<td>PSha1L128</td>\n<td>PSha1L128</td>\n</tr>\n<tr>\n<td>TripleDes</td>\n<td>Sha1</td>\n<td>TripleDes</td>\n<td>KwTripleDes</td>\n<td>KwRsaOaep</td>\n<td>PSha1L192</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic256Rsa15</td>\n<td>Sha1</td>\n<td>Aes256</td>\n<td>KwAes256</td>\n<td>KwRsa15</td>\n<td>PSha1L256</td>\n<td>PSha1L192</td>\n</tr>\n</tbody>\n</table>\n### Types of cryptographic algorithm\n\nThe following types of cryptographic algorithm are supported by WS-SecurityPolicy:\n\n- the section called “Symmetric key signature”\n- the section called “Asymmetric key signature”\n- the section called “Digest”\n\n<table>\n<thead>\n<tr>\n<th>Algorithm Suite</th>\n<th>[Dig]</th>\n<th>[Enc]</th>\n<th>[Sym KW]</th>\n<th>[Asym KW]</th>\n<th>[Enc KD]</th>\n<th>[Sig KD]</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Basic192RSA15</td>\n<td>Sha1</td>\n<td>Aes192</td>\n<td>KwAes192</td>\n<td>KwRsa15</td>\n<td>PSha1L192</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic128RSA15</td>\n<td>Sha1</td>\n<td>Aes128</td>\n<td>KwAes128</td>\n<td>KwRsa15</td>\n<td>PSha1L128</td>\n<td>PSha1L128</td>\n</tr>\n<tr>\n<td>TripleDesRSA15</td>\n<td>Sha1</td>\n<td>TripleDes</td>\n<td>KwTripleDes</td>\n<td>KwRsa15</td>\n<td>PSha1L192</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic256SHA256</td>\n<td>Sha256</td>\n<td>Aes256</td>\n<td>KwAes256</td>\n<td>KwRsaOaep</td>\n<td>PSha1L256</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic192SHA256</td>\n<td>Sha256</td>\n<td>Aes192</td>\n<td>KwAes192</td>\n<td>KwRsaOaep</td>\n<td>PSha1L192</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic128SHA256</td>\n<td>Sha256</td>\n<td>Aes128</td>\n<td>KwAes128</td>\n<td>KwRsaOaep</td>\n<td>PSha1L128</td>\n<td>PSha1L128</td>\n</tr>\n<tr>\n<td>TripleDesSHA256</td>\n<td>Sha256</td>\n<td>TripleDes</td>\n<td>KwTripleDes</td>\n<td>KwRsaOaep</td>\n<td>PSha1L192</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic256SHA256RSA15</td>\n<td>Sha256</td>\n<td>Aes256</td>\n<td>KwAes256</td>\n<td>KwRsa15</td>\n<td>PSha1L256</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic192SHA256RSA15</td>\n<td>Sha256</td>\n<td>Aes192</td>\n<td>KwAes192</td>\n<td>KwRsa15</td>\n<td>PSha1L192</td>\n<td>PSha1L192</td>\n</tr>\n<tr>\n<td>Basic128SHA256RSA15</td>\n<td>Sha256</td>\n<td>Aes128</td>\n<td>KwAes128</td>\n<td>KwRsa15</td>\n<td>PSha1L128</td>\n<td>PSha1L128</td>\n</tr>\n<tr>\n<td>TripleDesSHA256RSA15</td>\n<td>Sha256</td>\n<td>TripleDes</td>\n<td>KwTripleDes</td>\n<td>KwRsa15</td>\n<td>PSha1L192</td>\n<td>PSha1L192</td>\n</tr>\n</tbody>\n</table>\nSymmetric key signature\n\nThe symmetric key signature property, \\([\\text{Sym Sig}]\\), specifies the algorithm for generating a signature using a symmetric key. WS-SecurityPolicy specifies that the **HmacSha1** algorithm is always used.\n\nThe **HmacSha1** algorithm is identified by the following URI:\n\n```\nhttp://www.w3.org/2000/09/xmldsig#hmac-sha1\n```\n\nAsymmetric key signature\n\nThe asymmetric key signature property, \\([\\text{Asym Sig}]\\), specifies the algorithm for generating a signature using an asymmetric key. WS-SecurityPolicy specifies that the **RsaSha1** algorithm is always used.\n\nThe **RsaSha1** algorithm is identified by the following URI:\n\n```\nhttp://www.w3.org/2000/09/xmldsig#rsa-sha1\n```\n\nDigest\n\nThe digest property, \\([\\text{Dig}]\\), specifies the algorithm used for generating a message digest value. WS-SecurityPolicy supports two alternative digest algorithms: **Sha1** and **Sha256**.\n\nThe **Sha1** algorithm is identified by the following URI:\n\n```\nhttp://www.w3.org/2000/09/xmldsig#sha1\n```\n\nThe **Sha256** algorithm is identified by the following URI:\n\n```\nhttp://www.w3.org/2001/04/xmlenc#sha256\n```\n\nEncryption\n\nThe encryption property, \\([\\text{Enc}]\\), specifies the algorithm used for encrypting data. WS-SecurityPolicy supports the following encryption algorithms: **Aes256**, **Aes192**, **Aes128**, **TripleDes**.\n\nThe **Aes256** algorithm is identified by the following URI:\n\n```\nhttp://www.w3.org/2001/04/xmlenc#aes256-cbc\n```\n\nThe **Aes192** algorithm is identified by the following URI:\nThe **Aes128** algorithm is identified by the following URI:\n\nhttp://www.w3.org/2001/04/xmlenc#aes128-cbc\n\nThe **TripleDes** algorithm is identified by the following URI:\n\nhttp://www.w3.org/2001/04/xmlenc#tripledes-cbc\n\n### Symmetric key wrap\n\nThe symmetric key wrap property, [Sym KW], specifies the algorithm used for signing and encrypting symmetric keys. WS-SecurityPolicy supports the following symmetric key wrap algorithms: **KwAes256**, **KwAes192**, **KwAes128**, **KwTripleDes**.\n\nThe **KwAes256** algorithm is identified by the following URI:\n\nhttp://www.w3.org/2001/04/xmlenc#kw-aes256\n\nThe **KwAes192** algorithm is identified by the following URI:\n\nhttp://www.w3.org/2001/04/xmlenc#kw-aes192\n\nThe **KwAes128** algorithm is identified by the following URI:\n\nhttp://www.w3.org/2001/04/xmlenc#kw-aes128\n\nThe **KwTripleDes** algorithm is identified by the following URI:\n\nhttp://www.w3.org/2001/04/xmlenc#tripledes-cbc\n\n### Asymmetric key wrap\n\nThe asymmetric key wrap property, [Asym KW], specifies the algorithm used for signing and encrypting asymmetric keys. WS-SecurityPolicy supports the following asymmetric key wrap algorithms: **KwRsaOaep**, **KwRsa15**.\n\nThe **KwRsaOaep** algorithm is identified by the following URI:\n\nhttp://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p\n\nThe **KwRsa15** algorithm is identified by the following URI:\n\nhttp://www.w3.org/2001/04/xmlenc#rsa-1_5\n\n### Computed key\n\nThe computed key property, [Comp Key], specifies the algorithm used to compute a derived key. When secure parties communicate with the aid of a shared secret key (for example, when using WS-SecureConversation), it is recommended that a derived key is used instead of the original shared key, in\norder to avoid exposing too much data for analysis by hostile third parties. WS-SecurityPolicy specifies that the \\texttt{PSha1} algorithm is always used.\n\nThe \\texttt{PSha1} algorithm is identified by the following URI:\n\n\\begin{verbatim}\nhttp://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/dk/p_sha1\n\\end{verbatim}\n\nEncryption key derivation\n\nThe encryption key derivation property, [Enc KD], specifies the algorithm used to compute a derived encryption key. WS-SecurityPolicy supports the following encryption key derivation algorithms: \\texttt{PSha1L256}, \\texttt{PSha1L192}, \\texttt{PSha1L128}.\n\nThe \\texttt{PSha1} algorithm is identified by the following URI (the same algorithm is used for \\texttt{PSha1L256}, \\texttt{PSha1L192}, and \\texttt{PSha1L128}; just the key lengths differ):\n\n\\begin{verbatim}\nhttp://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/dk/p_sha1\n\\end{verbatim}\n\nSignature key derivation\n\nThe signature key derivation property, [Sig KD], specifies the algorithm used to compute a derived signature key. WS-SecurityPolicy supports the following signature key derivation algorithms: \\texttt{PSha1L192}, \\texttt{PSha1L128}.\n\nKey length properties\n\nTable 6.5, \"Key Length Properties\" shows the minimum and maximum key lengths supported in WS-SecurityPolicy.\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Key Length</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Minimum symmetric key length [Min SKL]</td>\n<td>128, 192, 256</td>\n</tr>\n<tr>\n<td>Maximum symmetric key length [Max SKL]</td>\n<td>256</td>\n</tr>\n<tr>\n<td>Minimum asymmetric key length [Min AKL]</td>\n<td>1024</td>\n</tr>\n<tr>\n<td>Maximum asymmetric key length [Max AKL]</td>\n<td>4096</td>\n</tr>\n</tbody>\n</table>\n\nThe value of the minimum symmetric key length, [Min SKL], depends on which algorithm suite is selected.\nCHAPTER 7. AUTHENTICATION\n\nAbstract\n\nThis chapter describes how to use policies to configure authentication in an Apache CXF application. Currently, the only credentials type supported in the SOAP layer is the WS-Security UsernameToken.\n\n7.1. INTRODUCTION TO AUTHENTICATION\n\nOverview\n\nIn Apache CXF, an application can be set up to use authentication through a combination of policy assertions in the WSDL contract and configuration settings in Blueprint XML.\n\nNOTE\n\nRemember, you can also use the HTTPS protocol as the basis for authentication and, in some cases, this might be easier to configure. See Section 3.1, “Authentication Alternatives”.\n\nSteps to set up authentication\n\nIn outline, you need to perform the following steps to set up an application to use authentication:\n\n1. Add a supporting tokens policy to an endpoint in the WSDL contract. This has the effect of requiring the endpoint to include a particular type of token (client credentials) in its request messages.\n\n2. On the client side, provide credentials to send by configuring the relevant endpoint in Blueprint XML.\n\n3. (Optional) On the client side, if you decide to provide passwords using a callback handler, implement the callback handler in Java.\n\n4. On the server side, associate a callback handler class with the endpoint in Blueprint XML. The callback handler is then responsible for authenticating the credentials received from remote clients.\n\n7.2. SPECIFYING AN AUTHENTICATION POLICY\n\nOverview\n\nIf you want an endpoint to support authentication, associate a supporting tokens policy assertion with the relevant endpoint binding. There are several different kinds of supporting tokens policy assertions, whose elements all have names of the form *SupportingTokens (for example, SupportingTokens, SignedSupportingTokens, and so on). For a complete list, see the section called “SupportingTokens assertions”.\n\nAssociating a supporting tokens assertion with an endpoint has the following effects:\n\n- Messages to or from the endpoint are required to include the specified token type (where the token’s direction is specified by the sp:IncludeToken attribute).\nDepending on the particular type of supporting tokens element you use, the endpoint might be required to sign and/or encrypt the token.\n\nThe supporting tokens assertion implies that the runtime will check that these requirements are satisfied. But the WS-SecurityPolicy policies do not define the mechanism for providing credentials to the runtime. You must use Blueprint XML configuration to specify the credentials (see Section 7.3, “Providing Client Credentials”).\n\nSyntax\n\nThe *SupportingTokens elements (that is, all elements with the SupportingTokens suffix—see the section called “SupportingTokens assertions”) have the following syntax:\n\n```\n<sp:SupportingTokensElement xmlns:sp=\"...\" ...>\n <wsp:Policy xmlns:wsp=\"...\">\n [Token Assertion]+\n <sp:AlgorithmSuite ...\n xmlns:sp=\"...\">\n ...\n </sp:AlgorithmSuite> ?\n ( ...\n ) *\n ...\n </wsp:Policy>\n ...\n</sp:SupportingTokensElement>\n```\n\nWhere SupportingTokensElement stands for one of the supporting token elements, *SupportingTokens. Typically, if you simply want to include a token (or tokens) in the security header, you would include one or more token assertions, [Token Assertion], in the policy. In particular, this is all that is required for authentication.\n\nIf the token is of an appropriate type (for example, an X.509 certificate or a symmetric key), you could theoretically also use it to sign or encrypt specific parts of the current message using the sp:AlgorithmSuite, sp:SignedParts, sp:SignedElements, sp:EncryptedParts, and sp:EncryptedElements elements. This functionality is currently not supported by Apache CXF, however.\n\nSample policy\n\nExample 7.1, “Example of a Supporting Tokens Policy” shows an example of a policy that requires a WS-Security UsernameToken token (which contains username/password credentials) to be included in the security header. In addition, because the token is specified inside an sp:SignedSupportingTokens element, the policy requires that the token is signed. This example uses a transport binding, so it is the underlying transport that is responsible for signing the message.\n\nFor example, if the underlying transport is HTTPS, the SSL/TLS protocol (configured with an appropriate algorithm suite) is responsible for signing the entire message, including the security header that contains the specified token. This is sufficient to satisfy the requirement that the supporting token is signed.\n\n```\nExample 7.1. Example of a Supporting Tokens Policy\n<wsp:Policy wsu:Id=\"UserNameOverTransport_IPingService_policy\">\n```\n<wsp:ExactlyOne>\n<wsp:All>\n <sp:TransportBinding> ... </sp:TransportBinding>\n <wsp:Policy>\n <sp:UsernameToken\n sp:IncludeToken=\"http://schemas.xmlsoap.org/ws/2005/07/secpolicy/IncludeToken/AlwaysToRecipient\">\n <wsp:Policy>\n <sp:WssUsernameToken10/>\n </wsp:Policy>\n </sp:UsernameToken>\n <wsp:Policy>\n <sp:SignedSupportingTokens>\n ...\n </wsp:All>\n </wsp:Policy>\n </wsp:Policy>\n </sp:SignedSupportingTokens>\n ...\n</wsp:ExactlyOne>\n</wsp:Policy>\n\nWhere the presence of the **sp:WssUsernameToken10** sub-element indicates that the UsernameToken header should conform to version 1.0 of the WS-Security UsernameToken specification.\n\n**Token types**\n\nIn principle, you can specify any of the WS-SecurityPolicy token types in a supporting tokens assertion. For SOAP-level authentication, however, only the **sp:UsernameToken** token type is relevant.\n\n**sp:UsernameToken**\n\nIn the context of a supporting tokens assertion, this element specifies that a WS-Security UsernameToken is to be included in the security SOAP header. Essentially, a WS-Security UsernameToken is used to send username/password credentials in the WS-Security SOAP header. The **sp:UsernameToken** element has the following syntax:\n\n```xml\n<sp:UsernameToken sp:IncludeToken=\"xs:anyURI\"? xmlns:sp=\"...\" ... >\n ( \n <sp:Issuer>wsa:EndpointReferenceType</sp:Issuer> | \n <sp:IssuerName>xs:anyURI</sp:IssuerName>\n ) ?\n </wsp:Policy xmlns:wsp=\"...\"> \n <wst:Claims Dialect=\"...\"> ... </wst:Claims> ?\n</sp:UsernameToken>\n```\n\nRed Hat Fuse 7.8 Apache CXF Security Guide\nThe sub-elements of **sp:UsernameToken** are all optional and are not needed for ordinary authentication. Normally, the only part of this syntax that is relevant is the **sp:IncludeToken** attribute.\n\n### NOTE\nCurrently, in the **sp:UsernameToken** syntax, only the **sp:WssUsernameToken10** sub-element is supported in Apache CXF.\n\n#### sp:IncludeToken attribute\n\nThe value of the **sp:IncludeToken** must match the WS-SecurityPolicy version from the enclosing policy. The current version is 1.2, but legacy WSDL might use version 1.1. Valid values of the **sp:IncludeToken** attribute are as follows:\n\n**Never**\nThe token MUST NOT be included in any messages sent between the initiator and the recipient; rather, an external reference to the token should be used. Valid URI values are:\n\n<table>\n<thead>\n<tr>\n<th>Version</th>\n<th>URI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1.2</td>\n<td><a href=\"http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/Never\">http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/Never</a></td>\n</tr>\n</tbody>\n</table>\n\n**Once**\nThe token MUST be included in only one message sent from the initiator to the recipient. References to the token MAY use an internal reference mechanism. Subsequent related messages sent between the recipient and the initiator may refer to the token using an external reference mechanism. Valid URI values are:\n\n<table>\n<thead>\n<tr>\n<th>Version</th>\n<th>URI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1.2</td>\n<td><a href=\"http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/Once\">http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/Once</a></td>\n</tr>\n</tbody>\n</table>\n\n**AlwaysToRecipient**\nThe token MUST be included in all messages sent from initiator to the recipient. The token MUST NOT be included in messages sent from the recipient to the initiator. Valid URI values are:\n\n<table>\n<thead>\n<tr>\n<th>Version</th>\n<th>URI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1.2</td>\n<td><a href=\"http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/AlwaysToRecipient\">http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/AlwaysToRecipient</a></td>\n</tr>\n</tbody>\n</table>\n\n**AlwaysToInitiator**\nThe token MUST be included in all messages sent from the recipient to the initiator. The token MUST NOT be included in messages sent from the initiator to the recipient. Valid URI values are:\n\n<table>\n<thead>\n<tr>\n<th>Version</th>\n<th>URI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1.2</td>\n<td><a href=\"http://docs.oasis-open.org/ws-sx/ws-secpolicy/200702/IncludeToken/AlwaysToInitiator\">http://docs.oasis-open.org/ws-sx/ws-secpolicy/200702/IncludeToken/AlwaysToInitiator</a></td>\n</tr>\n<tr>\n<td>1.1</td>\n<td><a href=\"http://schemas.xmlsoap.org/ws/2005/07/secpolicy/IncludeToken/AlwaysToInitiator\">http://schemas.xmlsoap.org/ws/2005/07/secpolicy/IncludeToken/AlwaysToInitiator</a></td>\n</tr>\n</tbody>\n</table>\n\n**Always**\n\nThe token MUST be included in all messages sent between the initiator and the recipient. This is the default behavior. Valid URI values are:\n\n<table>\n<thead>\n<tr>\n<th>Version</th>\n<th>URI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1.2</td>\n<td><a href=\"http://docs.oasis-open.org/ws-sx/ws-secpolicy/200702/IncludeToken/Always\">http://docs.oasis-open.org/ws-sx/ws-secpolicy/200702/IncludeToken/Always</a></td>\n</tr>\n<tr>\n<td>1.1</td>\n<td><a href=\"http://schemas.xmlsoap.org/ws/2005/07/secpolicy/IncludeToken/Always\">http://schemas.xmlsoap.org/ws/2005/07/secpolicy/IncludeToken/Always</a></td>\n</tr>\n</tbody>\n</table>\n\n**SupportingTokens assertions**\n\nThe following kinds of supporting tokens assertions are supported:\n\n- the section called “sp:SupportingTokens”.\n- the section called “sp:SignedSupportingTokens”.\n- the section called “sp:EncryptedSupportingTokens”.\n- the section called “sp:SignedEncryptedSupportingTokens”.\n- the section called “sp:EndorsingSupportingTokens”.\n- the section called “sp:SignedEndorsingSupportingTokens”.\n- the section called “sp:EndorsingEncryptedSupportingTokens”.\n- the section called “sp:SignedEndorsingEncryptedSupportingTokens”.\n\n**sp:SupportingTokens**\n\nThis element requires a token (or tokens) of the specified type to be included in the `wsse:Security` header. No additional requirements are imposed.\n\n**WARNING**\n\nThis policy does not explicitly require the tokens to be signed or encrypted. It is normally essential, however, to protect tokens by signing and encryption.\nsp:SignedSupportingTokens\n\nThis element requires a token (or tokens) of the specified type to be included in the `wsse:Security` header. In addition, this policy requires that the token is signed, in order to guarantee token integrity.\n\n**WARNING**\n\nThis policy does not explicitly require the tokens to be encrypted. It is normally essential, however, to protect tokens both by signing and encryption.\n\nsp:EncryptedSupportingTokens\n\nThis element requires a token (or tokens) of the specified type to be included in the `wsse:Security` header. In addition, this policy requires that the token is encrypted, in order to guarantee token confidentiality.\n\n**WARNING**\n\nThis policy does not explicitly require the tokens to be signed. It is normally essential, however, to protect tokens both by signing and encryption.\n\nsp:SignedEncryptedSupportingTokens\n\nThis element requires a token (or tokens) of the specified type to be included in the `wsse:Security` header. In addition, this policy requires that the token is both signed and encrypted, in order to guarantee token integrity and confidentiality.\n\nsp:EndorsingSupportingTokens\n\nAn endorsing supporting token is used to sign the message signature (primary signature). This signature is known as an **endorsing signature** or **secondary signature**. Hence, by applying an endorsing supporting tokens policy, you can have a chain of signatures: the primary signature, which signs the message itself, and the secondary signature, which signs the primary signature.\n\n**NOTE**\n\nIf you are using a transport binding (for example, HTTPS), the message signature is not actually part of the SOAP message, so it is not possible to sign the message signature in this case. If you specify this policy with a transport binding, the endorsing token signs the timestamp instead.\n7.3. PROVIDING CLIENT CREDENTIALS\n\nOverview\n\nThere are essentially two approaches to providing UsernameToken client credentials: you can either set both the username and the password directly in the client’s Blueprint XML configuration; or you can set the username in the client’s configuration and implement a callback handler to provide passwords programmatically. The latter approach (by programming) has the advantage that passwords are easier to hide from view.\nClient credentials properties\n\nTable 7.1, “Client Credentials Properties” shows the properties you can use to specify WS-Security username/password credentials on a client’s request context in Blueprint XML.\n\nTable 7.1. Client Credentials Properties\n\n<table>\n<thead>\n<tr>\n<th>Properties</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>security.username</td>\n<td>Specifies the username for UsernameToken policy assertions.</td>\n</tr>\n<tr>\n<td>security.password</td>\n<td>Specifies the password for UsernameToken policy assertions. If not specified, the password is obtained by calling the callback handler.</td>\n</tr>\n<tr>\n<td>security.callback-handler</td>\n<td>Specifies the class name of the WSS4J callback handler that retrieves passwords for UsernameToken policy assertions. Note that the callback handler can also handle other kinds of security events.</td>\n</tr>\n</tbody>\n</table>\n\nConfiguring client credentials in Blueprint XML\n\nTo configure username/password credentials in a client’s request context in Blueprint XML, set the security.username and security.password properties as follows:\n\n```xml\n<beans ... >\n <jaxws:client name=\"{NamespaceName}LocalPortName\"\n createdFromAPI=\"true\">\n <jaxws:properties>\n <entry key=\"security.username\" value=\"Alice\"/>\n <entry key=\"security.password\" value=\"abcd!1234\"/>\n </jaxws:properties>\n </jaxws:client>\n ...\n</beans>\n```\n\nIf you prefer not to store the password directly in Blueprint XML (which might potentially be a security hazard), you can provide passwords using a callback handler instead.\n\nProgramming a callback handler for passwords\n\nIf you want to use a callback handler to provide passwords for the UsernameToken header, you must first modify the client configuration in Blueprint XML, replacing the security.password setting by a security.callback-handler setting, as follows:\n\n```xml\n<beans ... >\n <jaxws:client name=\"{NamespaceName}LocalPortName\"\n createdFromAPI=\"true\">\n <jaxws:properties>\n <entry key=\"security.username\" value=\"Alice\"/>\n <entry key=\"security.callback-handler\" value=\"interop.client.UTPasswordCallback\"/>\n </jaxws:properties>\n </jaxws:client>\n ...\n</beans>\n```\nIn the preceding example, the callback handler is implemented by the `UTPasswordCallback` class. You can write a callback handler by implementing the `javax.security.auth.callback.CallbackHandler` interface, as shown in Example 7.2, \"Callback Handler for UsernameToken Passwords\".\n\nExample 7.2. Callback Handler for UsernameToken Passwords\n\n```java\npackage interop.client;\n\nimport java.io.IOException;\nimport java.util.HashMap;\nimport java.util.Map;\nimport javax.security.auth.callback.Callback;\nimport javax.security.auth.callback.CallbackHandler;\nimport javax.security.auth.callback.UnsupportedCallbackException;\nimport org.apache.ws.security.WSPasswordCallback;\n\npublic class UTPasswordCallback implements CallbackHandler {\n private Map<String, String> passwords =\n new HashMap<String, String>();\n\n public UTPasswordCallback() {\n passwords.put(\"Alice\", \"ecilA\");\n passwords.put(\"Frank\", \"invalid-password\");\n // for MS clients\n passwords.put(\"abcd\", \"dcba\");\n }\n\n public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {\n for (int i = 0; i < callbacks.length; i++) {\n WSPasswordCallback pc = (WSPasswordCallback)callbacks[i];\n String pass = passwords.get(pc.getIdentifier());\n if (pass != null) {\n pc.setPassword(pass);\n return;\n }\n }\n throw new IOException();\n }\n\n // Add an alias/password pair to the callback mechanism.\n public void setAliasPassword(String alias, String password) {\n passwords.put(alias, password);\n }\n}\n```\nThe callback functionality is implemented by the `CallbackHandler.handle()` method. In this example, it is assumed that the callback objects passed to the `handle()` method are all of `org.apache.ws.security.WSPasswordCallback` type (in a more realistic example, you would check the type of the callback objects).\n\nA more realistic implementation of a client callback handler would probably consist of prompting the user to enter their password.\n\n**WSPasswordCallback class**\n\nWhen a `CallbackHandler` is called in an Apache CXF client for the purpose of setting a `UsernameToken` password, the corresponding `WSPasswordCallback` object has the `USERNAME_TOKEN` usage code.\n\nFor more details about the `WSPasswordCallback` class, see `org.apache.ws.security.WSPasswordCallback`.\n\nThe `WSPasswordCallback` class defines several different usage codes, as follows:\n\n**USERNAME_TOKEN**\n\n- Obtain the password for UsernameToken credentials. This usage code is used both on the client side (to obtain a password to send to the server) and on the server side (to obtain a password in order to compare it with the password received from the client).\n- On the server side, this code is set in the following cases:\n - **Digest password**—if the UsernameToken contains a digest password, the callback must return the corresponding password for the given user name (given by `WSPasswordCallback.getIdentifier()`). Verification of the password (by comparing with the digest password) is done by the WSS4J runtime.\n - **Plaintext password**—implemented the same way as the digest password case (since Apache CXF 2.4.0).\n - **Custom password type**—if `getHandleCustomPasswordTypes()` is `true` on `org.apache.ws.security.WSSConfig`, this case is implemented the same way as the digest password case (since Apache CXF 2.4.0). Otherwise, an exception is thrown. If no `Password` element is included in a received UsernameToken on the server side, the callback handler is not called (since Apache CXF 2.4.0).\n\n**DECRYPT**\n\n- Need a password to retrieve a private key from a Java keystore, where `WSPasswordCallback.getIdentifier()` gives the alias of the keystore entry. WSS4J uses this private key to decrypt the session (symmetric) key.\n\n**SIGNATURE**\n\n- Need a password to retrieve a private key from a Java keystore, where `WSPasswordCallback.getIdentifier()` gives the alias of the keystore entry. WSS4J uses this private key to produce a signature.\n\n**SECRET_KEY**\n\n- Need a secret key for encryption or signature on the outbound side, or for decryption or verification on the inbound side. The callback handler must set the key using the `setKey(byte[])` method.\n\n**SECURITY_CONTEXT_TOKEN**\n\n- Need the key for a `wsc:SecurityContextToken`, which you provide by calling the `setKey(byte[])` method.\n\n**CUSTOM_TOKEN**\nNeed a token as a DOM element. For example, this is used for the case of a reference to a SAML Assertion or SecurityContextToken that is not in the message. The callback handler must set the token using the `setCustomToken(Element)` method.\n\n**KEY_NAME**\n\n*(Obsolete)* Since Apache CXF 2.4.0, this usage code is obsolete.\n\n**USERNAME_TOKEN_UNKNOWN**\n\n*(Obsolete)* Since Apache CXF 2.4.0, this usage code is obsolete.\n\n**UNKNOWN**\n\nNot used by WSS4J.\n\n### 7.4. AUTHENTICATING RECEIVED CREDENTIALS\n\n#### Overview\n\nOn the server side, you can verify that received credentials are authentic by registering a callback handler with the Apache CXF runtime. You can either write your own custom code to perform credentials verification or you can implement a callback handler that integrates with a third-party enterprise security system (for example, an LDAP server).\n\n#### Configuring a server callback handler in Blueprint XML\n\nTo configure a server callback handler that verifies `UsernameToken` credentials received from clients, set the `security.callback-handler` property in the server’s Blueprint XML configuration, as follows:\n\n```xml\n<beans ... >\n <jaxws:endpoint\n id=\"UserNameOverTransport\"\n address=\"https://localhost:9001/UserNameOverTransport\"\n serviceName=\"interop:PingService10\"\n endpointName=\"interop:UserNameOverTransport_IPingService\"\n implementor=\"interop.server.UserNameOverTransport\"\n depends-on=\"tls-settings\">\n <jaxws:properties>\n <entry key=\"security.username\" value=\"Alice\"/>\n <entry key=\"security.callback-handler\" value=\"interop.client.UTPasswordCallback\"/>\n </jaxws:properties>\n </jaxws:endpoint>\n ...\n</beans>\n```\n\nIn the preceding example, the callback handler is implemented by the `UTPasswordCallback` class.\n\n#### Implementing the callback handler to check passwords\n\nTo implement a callback handler for checking passwords on the server side, implement the `javax.security.auth.callback.CallbackHandler` interface. The general approach to implementing the `CallbackHandler` interface for a server is similar to implementing a `CallbackHandler` for a client. The interpretation given to the returned password on the server side is different, however: the password from the callback handler is compared against the received client password in order to verify the client’s credentials.\nFor example, you could use the sample implementation shown in Example 7.2, “Callback Handler for UsernameToken Passwords” to obtain passwords on the server side. On the server side, the WSS4J runtime would compare the password obtained from the callback with the password in the received client credentials. If the two passwords match, the credentials are successfully verified.\n\nA more realistic implementation of a server callback handler would involve writing an integration with a third-party database that is used to store security data (for example, integration with an LDAP server).\nCHAPTER 8. FUSE CREDENTIAL STORE\n\n8.1. OVERVIEW\n\nFuse Credential Store feature allows to include passwords and other sensitive strings as masked strings. These strings are resolved from a JBoss EAP Elytron Credential store.\n\nThe Credential store has built-in support for OSGi environment, specifically for Apache Karaf and for Java system properties.\n\nYou might have specified passwords, for example javax.net.ssl.keyStorePassword, as system properties in clear text this project allows you to specify these values as references to a credential store.\n\nFuse Credential Store allows to specify the sensitive strings as references to a value stored in Credential Store. The clear text value is replaced with an alias reference, for example CS:alias referencing the value stored under the alias in a configured Credential Store.\n\nThe convention CS:alias should be followed. The CS: in the Java System property value is a prefix and alias following it will be used for looking up the value.\n\n8.2. PREREQUISITES\n\n- The Karaf container is running.\n\n8.3. SETUP FUSE CREDENTIAL STORE ON KARAF\n\n1. Create a credential store using credential-store:create command:\n\n```sh\nkaraf@root()> credential-store:create -a location=credential.store -k password=\"my password\" -k algorithm=masked-MD5-DES\n```\n\nIn order to use this credential store set the following environment variables\n\n<table>\n<thead>\n<tr>\n<th>Variable</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>CREDENTIAL_STORE_PROTECTION_ALGORITHM</td>\n<td>masked-MD5-DES</td>\n</tr>\n<tr>\n<td>CREDENTIAL_STORE_PROTECTION_PARAMS</td>\n<td>MDkEKXNvbWVhcmJpdHJhcnljcmF6eXN0cmluZ3RoYXRkb2Vzbnm90bWF0dGVyAgI6AQIsUOEqvog6XI=</td>\n</tr>\n<tr>\n<td>CREDENTIAL_STORE_PROTECTION</td>\n<td>Sf6sYy7gNpygs311zcQh8Q==</td>\n</tr>\n<tr>\n<td>CREDENTIAL_STORE_ATTR_location</td>\n<td>credential.store</td>\n</tr>\n</tbody>\n</table>\n\nOr simply use this:\n\n```sh\nexport CREDENTIAL_STORE_PROTECTION_ALGORITHM=masked-MD5-DES\necho $CREDENTIAL_STORE_PROTECTION_PARAMS\nexport CREDENTIAL_STORE_PROTECTION_PARAMS=MDkEKXNvbWVhcmJpdHJhcnljcmF6eXN0cmluZ3RoYXRkb2Vzbnm90bWF0dGVyAgI6AQIsUOEqvog6XI=\necho $CREDENTIAL_STORE_PROTECTION\nexport CREDENTIAL_STORE_PROTECTION=Sf6sYy7gNpygs311zcQh8Q==\necho $CREDENTIAL_STORE_ATTR_location\nexport CREDENTIAL_STORE_ATTR_location=credential.store\n```\n\nThis should the file credential.store which is a JCEKS KeyStore for storing the secrets.\n\n2. Exit the Karaf container:\n\n```sh\nkaraf@root()> logout\n```\n3. Set the environment variables presented when creating the credential store:\n\n```bash\n$ export CREDENTIAL_STORE_PROTECTION_ALGORITHM=masked-MD5-DES\n$ export CREDENTIAL_STORE_PROTECTION_PARAMS=MDkEKhXVvbWVhcjpHJhcnljcmluZ3Ro\n$ export CREDENTIAL_STORE_PROTECTION=Sf6sYy7gNpygs311zcQh8Q==\n$ export CREDENTIAL_STORE_ATTR_location=credential.store\n```\n\n**IMPORTANT**\n\nYou are required to set the `CREDENTIAL_STORE_*` environment variables before starting the Karaf container.\n\n4. Start the Karaf container:\n\n```bash\nbin/karaf\n```\n\n5. Add your secrets to the credential store by using `credential-store:store`:\n\n```bash\nkaraf@root()> credential-store:store -a javax.net.ssl.keyStorePassword -s \"alias is set\"\nValue stored in the credential store to reference it use: CS:javax.net.ssl.keyStorePassword\n```\n\n6. Exit the Karaf container again:\n\n```bash\nkaraf@root()> logout\n```\n\n7. Run the Karaf container again specifying the reference to your secret instead of the value:\n\n```bash\n$ EXTRA_JAVA_OPTS=\"-Djavax.net.ssl.keyStorePassword=CS:javax.net.ssl.keyStorePassword\" bin/karaf\n```\n\nThe value of `javax.net.ssl.keyStorePassword` when accessed using `System::getProperty` should contain the string \"alias is set\".\n\n**NOTE**\n\nThe `EXTRA_JAVA_OPTS` is one of the many ways to specify system properties. These system properties are defined at the start of the Karaf container.\n\n**IMPORTANT**\n\nWhen the environment variables are leaked outside of your environment or intended use along with the content of the credential store file, your secrets are compromised. The value of the property when accessed through JMX gets replaced with the string \"<sensitive>\", but there are many code paths that lead to `System::getProperty`, for instance diagnostics or monitoring tools might access it along with any 3rd party software for debugging purposes.\nAPPENDIX A. ASN.1 AND DISTINGUISHED NAMES\n\nAbstract\n\nThe OSI Abstract Syntax Notation One (ASN.1) and X.500 Distinguished Names play an important role in the security standards that define X.509 certificates and LDAP directories.\n\nA.1. ASN.1\n\nOverview\n\nThe *Abstract Syntax Notation One* (ASN.1) was defined by the OSI standards body in the early 1980s to provide a way of defining data types and structures that are independent of any particular machine hardware or programming language. In many ways, ASN.1 can be considered a forerunner of modern interface definition languages, such as the OMG’s IDL and WSDL, which are concerned with defining platform-independent data types.\n\nASN.1 is important, because it is widely used in the definition of standards (for example, SNMP, X.509, and LDAP). In particular, ASN.1 is ubiquitous in the field of security standards. The formal definitions of X.509 certificates and distinguished names are described using ASN.1 syntax. You do not require detailed knowledge of ASN.1 syntax to use these security standards, but you need to be aware that ASN.1 is used for the basic definitions of most security-related data types.\n\nBER\n\nThe OSI’s Basic Encoding Rules (BER) define how to translate an ASN.1 data type into a sequence of octets (binary representation). The role played by BER with respect to ASN.1 is, therefore, similar to the role played by GIOP with respect to the OMG IDL.\n\nDER\n\nThe OSI’s Distinguished Encoding Rules (DER) are a specialization of the BER. The DER consists of the BER plus some additional rules to ensure that the encoding is unique (BER encodings are not).\n\nReferences\n\nYou can read more about ASN.1 in the following standards documents:\n\n- ASN.1 is defined in X.208.\n- BER is defined in X.209.\n\nA.2. DISTINGUISHED NAMES\n\nOverview\n\nHistorically, distinguished names (DN) are defined as the primary keys in an X.500 directory structure. However, DNs have come to be used in many other contexts as general purpose identifiers. In Apache CXF, DNs occur in the following contexts:\n\n- X.509 certificates—for example, one of the DNs in a certificate identifies the owner of the certificate (the security principal).\nLDAP—DNs are used to locate objects in an LDAP directory tree.\n\n**String representation of DN**\n\nAlthough a DN is formally defined in ASN.1, there is also an LDAP standard that defines a UTF-8 string representation of a DN (see RFC 2253). The string representation provides a convenient basis for describing the structure of a DN.\n\n**NOTE**\n\nThe string representation of a DN does not provide a unique representation of DER-encoded DN. Hence, a DN that is converted from string format back to DER format does not always recover the original DER encoding.\n\n**DN string example**\n\nThe following string is a typical example of a DN:\n\n```\nC=US,O=IONA Technologies,OU=Engineering,CN=A. N. Other\n```\n\n**Structure of a DN string**\n\nA DN string is built up from the following basic elements:\n\n- **OID**.\n- **Attribute Types**.\n- **AVA**.\n- **RDN**.\n\n**OID**\n\nAn OBJECT IDENTIFIER (OID) is a sequence of bytes that uniquely identifies a grammatical construct in ASN.1.\n\n**Attribute types**\n\nThe variety of attribute types that can appear in a DN is theoretically open-ended, but in practice only a small subset of attribute types are used. Table A.1, \"Commonly Used Attribute Types\" shows a selection of the attribute types that you are most likely to encounter:\n\n**Table A.1. Commonly Used Attribute Types**\n\n<table>\n<thead>\n<tr>\n<th>String Representation</th>\n<th>X.500 Attribute Type</th>\n<th>Size of Data</th>\n<th>Equivalent OID</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>C</td>\n<td>countryName</td>\n<td>2</td>\n<td>2.5.4.6</td>\n</tr>\n<tr>\n<td>O</td>\n<td>organizationName</td>\n<td>1…64</td>\n<td>2.5.4.10</td>\n</tr>\n<tr>\n<td>OU</td>\n<td>organizationalUnitName</td>\n<td>1…64</td>\n<td>2.5.4.11</td>\n</tr>\n<tr>\n<td>String Representation</td>\n<td>X.500 Attribute Type</td>\n<td>Size of Data</td>\n<td>Equivalent OID</td>\n</tr>\n<tr>\n<td>-----------------------</td>\n<td>--------------------------</td>\n<td>--------------</td>\n<td>----------------</td>\n</tr>\n<tr>\n<td>CN</td>\n<td>commonName</td>\n<td>1...64</td>\n<td>2.5.4.3</td>\n</tr>\n<tr>\n<td>ST</td>\n<td>stateOrProvinceName</td>\n<td>1...64</td>\n<td>2.5.4.8</td>\n</tr>\n<tr>\n<td>L</td>\n<td>localityName</td>\n<td>1...64</td>\n<td>2.5.4.7</td>\n</tr>\n<tr>\n<td>STREET</td>\n<td>streetAddress</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>DC</td>\n<td>domainComponent</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>UID</td>\n<td>userid</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**AVA**\n\nAn attribute value assertion (AVA) assigns an attribute value to an attribute type. In the string representation, it has the following syntax:\n\n```\n<attr-type>=<attr-value>\n```\n\nFor example:\n\n```\nCN=A. N. Other\n```\n\nAlternatively, you can use the equivalent OID to identify the attribute type in the string representation (see Table A.1, “Commonly Used Attribute Types”). For example:\n\n```\n2.5.4.3=A. N. Other\n```\n\n**RDN**\n\nA relative distinguished name (RDN) represents a single node of a DN (the bit that appears between the commas in the string representation). Technically, an RDN might contain more than one AVA (it is formally defined as a set of AVAs). However, this almost never occurs in practice. In the string representation, an RDN has the following syntax:\n\n```\n<attr-type>=<attr-value>[+<attr-type>=<attr-value> ...]\n```\n\nHere is an example of a (very unlikely) multiple-value RDN:\n\n```\nOU=Eng1+OU=Eng2+OU=Eng3\n```\n\nHere is an example of a single-value RDN:\n\n```\nOU=Engineering\n```"}}},{"rowIdx":159,"cells":{"id":{"kind":"string","value":"2cae77d86c7a7b6fee3ad59050422b0420811ee2"},"text":{"kind":"string","value":"## Contents\n\n1 Introduction .................................................................................................................. 1-1 \n 1.1 Objectives of the Runtime Architecture .............................................................. 1-1 \n 1.2 About the Conventions ....................................................................................... 1-1 \n 1.3 Overview of the Itanium™ Software Conventions and Runtime Architecture Guide .......................................................... 1-2 \n 1.4 Terminology ........................................................................................................ 1-2 \n2 Processor Architecture .................................................................................................... 2-1 \n 2.1 Application State and Programming Model ........................................................ 2-1 \n 2.2 Floating-point Programming Model .................................................................. 2-2 \n 2.3 System State and Programming Model .............................................................. 2-2 \n 2.4 Addressing and Protection ................................................................................. 2-3 \n 2.5 Interruptions ....................................................................................................... 2-3 \n3 Memory Model ................................................................................................................. 3-1 \n 3.1 Program Segments ............................................................................................ 3-1 \n 3.2 Protection Areas ................................................................................................. 3-2 \n 3.3 Data Allocation ................................................................................................... 3-4 \n \n 3.3.1 Global Variables ................................................................................ 3-4 \n 3.3.2 Local Static Data ............................................................................... 3-4 \n 3.3.3 Constants and Literals ....................................................................... 3-4 \n 3.3.4 Local Memory Stack Variables .......................................................... 3-4 \n4 Data Representation ....................................................................................................... 4-1 \n 4.1 Fundamental Types ............................................................................................ 4-1 \n 4.2 Aggregate Types ................................................................................................ 4-2 \n 4.3 Bit Fields ............................................................................................................. 4-4 \n 4.4 Fortran Data Types ............................................................................................ 4-7 \n5 Register Usage ................................................................................................................ 5-1 \n 5.1 Partitioning ......................................................................................................... 5-1 \n 5.2 General Registers .............................................................................................. 5-1 \n 5.3 Floating-point Registers ..................................................................................... 5-2 \n 5.4 Predicate Registers ............................................................................................ 5-3 \n 5.5 Branch Registers ................................................................................................ 5-3 \n 5.6 Application Registers .......................................................................................... 5-4 \n 5.7 User Mask .......................................................................................................... 5-5 \n6 Register Stack ................................................................................................................ .6-1 \n 6.1 Input and Local Registers ................................................................................... 6-1 \n 6.2 Output Registers ................................................................................................ 6-1 \n 6.3 Rotating Registers .............................................................................................. 6-2 \n 6.4 Frame Markers .................................................................................................... 6-2 \n 6.5 Backing Store for Register Stack ....................................................................... 6-2 \n7 Memory Stack ................................................................................................................ 7-1 \n 7.1 Procedure Frames ............................................................................................... 7-1\n### 8 Procedure Linkage\n\n8.1 External Naming Conventions ................................................. 8-1\n8.2 The gp Register ..................................................................... 8-1\n8.3 Types of Calls ........................................................................ 8-1\n8.4 Calling Sequence ................................................................... 8-1\n8.4.1 Direct Calls ......................................................................... 8-2\n8.4.2 Indirect Calls ....................................................................... 8-4\n8.5 Parameter Passing ................................................................... 8-5\n8.5.1 Allocation of Parameter Slots ............................................... 8-6\n8.5.2 Register Parameters ............................................................. 8-7\n8.5.3 Memory Stack Parameters .................................................... 8-10\n8.5.4 Variable Argument Lists ...................................................... 8-10\n8.5.5 Pointers to Formal Parameters ............................................. 8-10\n8.5.6 Languages Other than C ...................................................... 8-10\n8.5.7 Rounding Floating-point Values .......................................... 8-11\n8.5.8 Examples ............................................................................ 8-11\n8.6 Return Values ......................................................................... 8-13\n8.7 Requirements for Unwinding the Stack .................................... 8-14\n\n### 9 Coding Conventions\n\n9.1 Sample Code Sequences .......................................................... 9-1\n9.1.1 Addressing \"own\" Data in the Short Data Area ..................... 9-1\n9.1.2 Addressing External Data or Data in a Long Data Area .......... 9-1\n9.1.3 Addressing Literals in the Text Segment ............................... 9-2\n9.1.4 Materializing Function Pointers .......................................... 9-2\n9.1.5 Direct Procedure Calls ....................................................... 9-2\n9.1.6 Indirect Procedure Calls ..................................................... 9-2\n9.1.7 Jump Tables ....................................................................... 9-3\n9.2 Speculation .............................................................................. 9-3\n9.3 Multi-threaded Code ............................................................... 9-4\n9.4 Use of Temporary Registers around the Call to setjmp .............. 9-4\n9.5 Up-level Referencing .............................................................. 9-4\n9.6 C++ Conventions ................................................................. 9-5\n\n### 10 Context Management\n\n10.1 Process/Thread Context .......................................................... 10-1\n10.2 User-level Thread Switch, Coroutines ..................................... 10-2\n10.3 setjmp/longjmp ...................................................................... 10-2\n\n### 11 Stack Unwinding and Exception Handling\n\n11.1 Unwinding the Stack ............................................................... 11-1\n11.1.1 Initial Context ................................................................. 11-2\n11.1.2 Step to Previous Frame ..................................................... 11-2\n11.2 Exception Handling Framework ........................................... 11-3\n11.3 Coding Conventions for Reliable Unwinding ......................... 11-5\n11.3.1 Conventions for Prologue Regions .................................... 11-5\n11.3.2 Conventions for Body Regions ........................................ 11-6\n11.3.3 Conventions for the Spill Area in the Memory Stack Frame .. 11-7\n11.4 Data Structures ................................................................. 11-8\n11.4.1 Unwind Table ............................................................... 11-8\n11.4.2 Unwind Descriptor Area ................................................ 11-9\n11.4.3 Language-specific Data Area .......................................... 11-19\n12 Dynamic Linking\n\n12.1 Position-independent Code\n\n12.2 Procedure Calls and Long Branch Stubs\n\n12.3 Access to the Data Segment\n\n12.3.1 Access to Constants and Literals in the Text Segment\n\n12.3.2 Materializing Function Pointers\n\n12.4 Import Stubs\n\n12.5 The Dynamic Loader\n\n13 System Interfaces\n\n13.1 Program Startup\n\n13.1.1 Initial Memory Stack\n\n13.1.2 Initial Register Values\n\n13.2 System Calls\n\n13.3 Traps and Signals\n\nA Standard Header Files\n\nA.1 Implementation Limits\n\nA.2 Floating-point Definitions\n\nA.3 Variable Argument List Macros\n\nA.4 setjmp/longjmp\n\nB Unwind Descriptor Record Format\n\nB.1 Overview\n\nB.2 Region Header Records\n\nB.3 Descriptor Records for Prologue Regions\n\nB.4 Descriptor Records for Body Regions\n\nB.5 Descriptor Records for Body or Prologue Regions\n\nFigures\n\n4-1 Structure Smaller Than a Word\n\n4-2 No Padding\n\n4-3 Internal Padding\n\n4-4 Internal and Tail Padding\n\n4-5 Union Allocation\n\n4-6 Bit Numbering\n\n4-7 Bit Field Allocation\n\n4-8 Boundary Alignment\n\n4-9 Storage Unit Sharing\n\n4-10 Union Allocation\n\n4-11 Unnamed Bit Fields\n\n6-1 Operation of the Register Stack\n\n7-1 Procedure Frame\n\n8-1 Direct Procedure Calls\n\n8-2 Indirect Procedure Calls\n\n8-3 Parameter Passing in General Registers and Memory\n\n8-4 Examples of “LSB” Alignment\n\n8-5 Example of “Byte 0” Alignment\n\n11-1 Components of the Exception Handling Mechanism\n\n11-2 Unwind Table and Example of Language-specific Data Area\nTables\n\n2-1 Software Interrupts .............................................................. 2-2\n3-1 Program Segments .......................................................... 3-1\n3-2 Protection Areas ......................................................... 3-2\n3-3 Alignment Requirements for Global Objects ..................... 3-4\n4-1 Scalar Data types Supported by Itanium™ Processors ........ 4-1\n4-2 Bit Field Base Types .................................................... 4-4\n4-3 Fortran Data Types .......................................................... 4-7\n5-1 General Registers .......................................................... 5-1\n5-2 Floating-point Registers ................................................ 5-2\n5-3 Predicate Registers ....................................................... 5-3\n5-4 Branch Registers .......................................................... 5-3\n5-5 Application Registers .................................................... 5-4\n8-1 Rules for Allocating Parameter Slots ......................... 8-6\n8-2 Rules for Return Values ............................................... 8-13\n10-1 Resources to be Saved on Context Switches ...................... 10-1\n11-1 Region Header Records ................................................. 11-10\n11-2 Prologue Descriptor Records for the Stack Frame ................ 11-11\n11-3 Prologue Descriptor Records for the Return Pointer ................ 11-11\n11-4 Prologue Descriptor Records for the Previous Function State ................ 11-12\n11-5 Prologue Descriptor Records for Predicate Registers ........... 11-12\n11-6 Prologue Descriptor Records for GRs, FRs and BRs ................ 11-13\n11-7 Prologue Descriptor Records for the User NaT Collection Register .......... 11-14\n11-8 Prologue Descriptor Records for the Loop Counter Register ...... 11-14\n11-9 Prologue Descriptor Records for the Floating-point Status Register ................ 11-14\n11-10 Prologue Descriptor Records for the Primary Unat Collection ......... 11-14\n11-11 Prologue Descriptor Records for the Backing Store ................ 11-15\n11-12 Body Region Descriptor Records .................................. 11-15\n11-13 General Unwind Descriptors ...................................... 11-16\n13-1 Initial Value of the Floating-point Status Register .......... 13-1\nB-1 Record Formats .............................................................. B-1\nB-2 Example ULEB128 Encodings ........................................ B-2\nThis document describes common software conventions for the Itanium architecture. It does not define operating-system interfaces or any conventions specific to any single operating system.\n\nThe runtime architecture defines most of the conventions necessary to compile, link, and execute a program on an operating system that supports these conventions. Its purpose is to ensure that object modules produced by different compilers can be linked together into a single application, and to specify the interfaces between compilers and linker, and between linker and operating system.\n\nThe runtime architecture does not specify the Application Programming Interface (API), the set of services provided by the operating system to the program, nor does it specify certain conventions that are specific to each operating system. Thus, conformance to the runtime architecture alone is not sufficient to produce a program that will execute on all Itanium architecture platforms. It does, however, allow many of the development tools to be shared among various operating systems.\n\nWhen combined with the instruction set architecture, an API, and system-specific conventions, this runtime architecture leads to an Application Binary Interface (ABI). In other words, an ABI is composed of an API, system-specific conventions, a hardware description, and a runtime architecture.\n\n1.1 Objectives of the Runtime Architecture\n\nThis document defines the software interfaces needed to ensure that software for Itanium architecture platforms will operate correctly together. The intent is to define as small a set of interface specifications as possible, while still meeting the following goals:\n\n- Support 64-bit addressing and data types\n- High performance\n- Ease of porting\n- Ease of interfacing with IA-32\n- Ease of implementation and use\n- Complete enough to insure software compatibility\n\n1.2 About the Conventions\n\nANSI C serves as the reference programming language. By defining the implementation of C data types, the software conventions can give precise system interface information without resorting to assembly language. Giving C language bindings for system services does not preclude bindings for other programming languages. Moreover, the examples given here are not intended to specify any particular C language implementation available on the system.\n1.3 Overview of the Itanium™ Software Conventions and Runtime Architecture Guide\n\nChapter 1, “Introduction” is this introductory material.\n\nChapter 2, “Processor Architecture” describes the features of the Itanium architecture that are relevant to this guide.\n\nChapter 3, “Memory Model” explains the memory layout of the application.\n\nChapter 4, “Data Representation” specifies the representation of a number of data types of significance to the software conventions.\n\nChapter 5, “Register Usage” presents the software conventions for using the user-mode register resources of the Itanium architecture.\n\nChapter 6, “Register Stack” presents the software conventions for using the register stack supported by the Itanium architecture.\n\nChapter 7, “Memory Stack” presents the software conventions for using the traditional memory stack.\n\nChapter 8, “Procedure Linkage” presents the procedure calling conventions.\n\nChapter 9, “Coding Conventions” presents a number of example code sequences illustrating the software conventions.\n\nChapter 10, “Context Management” identifies the processor state that makes up a process or thread context, and discusses various forms of user-level context switching.\n\nChapter 11, “Stack Unwinding and Exception Handling” explains the framework for processing exceptions and unwinding the stack.\n\nChapter 12, “Dynamic Linking” presents the software conventions related to dynamic linking.\n\nChapter 13, “System Interfaces” discusses the software conventions related to the underlying operating system.\n\nAppendix A, “Standard Header Files” provides example definitions for implementation limits, floating-point constants, variable-argument list macros, and setjmp/longjmp.\n\nAppendix B, “Unwind Descriptor Record Format” defines the internal representation of the stack unwind tables discussed in Chapter 11.\n\n1.4 Terminology\n\nThe following terms will be used in the rest of this document:\n\nAbsolute address In this document, the term absolute address refers to a virtual address, not a physical address. It is an address within the process’ address space that is computed as an absolute number, without the use of a base register.\n\nBinding The process of resolving a symbolic reference in one module by finding the definition of the symbol in another module, and substituting the\naddress of the definition in place of the symbolic reference. The linker binds relocatable object modules together, and the DLL loader binds executable load modules. When searching for a definition, the linker and DLL loader search each module in a certain order, so that a definition of a symbol in one module has precedence over a definition of the same symbol in a later module. This order is called the binding order.\n\n**Dynamic-link library (DLL)**\nA library that is prepared by the linker for quick loading and binding when a program is invoked, or while the program is running. A DLL is designed so that its code is shared by all processes that are bound to it. (Also called shared library.)\n\n**Execution time**\nThe time during which a program is actually executing, not including the time during which it and its DLLs are being loaded.\n\n**External alignment**\nThe property of an array or structure that specifies the minimum alignment boundary for the array or structure as a whole. The array or structure must begin at a memory address that is a multiple of its external alignment. In general, a structure’s external alignment must be no less than the largest of the internal alignment of its elements.\n\n**Function pointer**\nA reference or pointer to a function. A function pointer takes the form of a pointer to a special descriptor (a function descriptor) that uniquely identifies the function. The function descriptor contains the address of the function’s actual entry point as well as its global data pointer (gp).\n\n**Global data pointer (gp)**\nThe address of a reference location in a load module’s data segment, usually kept in a specified general register during execution. Each load module has a single such reference point, typically near the middle of the load module’s linkage table. Applications use this pointer as a base register to access linkage table entries, and data that is local to the load module.\n\n**Internal alignment**\nThe property of an element of an array or structure that specifies the minimum alignment boundary for that element relative to the whole array or structure. The element must begin at an offset that is a multiple of its internal alignment. (compare with external alignment.)\n\n**Link time**\nThe time when a program or DLL is processed by the linker. Any activity taking place at link time is static.\n\n**Linkage table**\nA table of addresses that contains pointers to code or data that is external to the load module, or that cannot be addressed directly. Each load module contains a linkage table in its data segment, which allows external references to be bound dynamically without modifying the application’s code.\n\n**Load module**\nAn executable unit produced by the linker, either a main program or a DLL. A program consists of at least a main program, and may also require one or more DLLs to be loaded to satisfy its dependencies.\n\n**Own data**\nData belonging to a load module that is referenced directly from that load module and that is not subject to the binding order. If a module references a data item symbolically, and another module earlier in the binding order defines an item with the same symbolic name, the reference is bound to the data item in the earlier module. If this is the case, the data is not “own.” Typically, own data is local in scope.\nPC-relative addressing Code that uses its own address (commonly called the program counter, or “PC”; this is called the instruction pointer, or IP, in the IA-64 architecture) as a base register for addressing other code and data.\n\nPosition-independent code (PIC) This term has a dual meaning. First, position-independent code is designed so that it contains no dependency on its own load address; usually, this is accomplished by using pc-relative addressing so that the code does not contain any absolute addresses. Second, it also implies that the code is also designed for dynamic binding to global data; this is usually done by using indirect addressing through a linkage table.\n\nPreserved register A register that is guaranteed to be preserved across a procedure call.\n\nProgram invocation time The time when a program or DLL is loaded into memory in preparation for execution. Activities taking place at program invocation time are generally performed by the system loader or dynamic loader.\n\nProtection area A portion of a segment that shares common access protections.\n\nRegion The IA-64 architecture divides the address space into four or eight regions. In general, the runtime architecture is independent of which segments are assigned to which region.\n\nScratch register A register that is not preserved across a procedure call.\n\nSegment An area of memory that has specific attributes, and behaves as a fixed unit at runtime. All items within a segment have a fixed address relationship to one another at execution time, and have a common set of attributes. Items in different segments do not necessarily bear this relationship, and an application may not depend on one. For example, the program text segment is defined to contain the main program code, unwind information, and read-only data. The use of this term is not related to the concept of a segment in the IA-32 architecture, nor is it directly related to the concept of a segment in an object file.\n\nStatic (1) Any data or code object that is allocated at a fixed location in memory and whose lifetime is that of the entire process, regardless of its scope.\n\n(2) A binding that takes place at link time rather than program invocation or execution time.\nProcessor Architecture\n\nIt is assumed that applications conforming to this specification will run in a software environment provided by some operating system, and that additional conventions will be specified as part of the Application Binary Interface (ABI) for that operating system. It is further assumed that the operating system will restrict the application’s access to the physical resources of the machine, by limiting the privilege level of the application and by using virtual memory to define the address space available to the application.\n\nThe Intel® IA-64 Architecture Software Developer’s Manual defines the IA-64 application instruction set architecture. Programs intended to execute directly on an IA-64 processor use the instruction set, instruction encodings, and instruction semantics defined in the Intel® IA-64 Architecture Software Developer’s Manual. Three points deserve explicit mention:\n\n- A program may assume all documented instructions exist.\n- A program may assume all documented instructions work.\n- A program may use only the instructions defined by the architecture.\n\nIn other words, from a program’s perspective, the execution environment provides a complete and working implementation of IA-64. This does not imply that the underlying implementation provides all instructions in hardware, only that the instructions perform the specified operations and produce the specified results. The software conventions neither place performance constraints on systems nor specify what instructions must be implemented in hardware. A software emulation of the architecture could conform to these conventions.\n\nSome processors might support IA-64 as a subset, providing additional instructions or capabilities. Programs that use those capabilities explicitly do not conform to these conventions. Executing those programs on machines without the additional capabilities results in undefined behavior.\n\nThese conventions are intended for application use, and so use only features found in user mode. Applications should assume that they will execute in user mode (privilege level 1, 2, or 3), and that any attempt to use processor resources restricted to privilege level 0 will cause a trap that may terminate the process.\n\n2.1 Application State and Programming Model\n\nAn application may use all features of IA-64 that are described in the Application State and Programming Model section of the Intel® IA-64 Architecture Software Developer’s Manual.\n\nApplication use of the break instruction is subject to the following conventions:\n\n- Immediate operands whose three highest-order bits are 000 are reserved for architected software interrupts. These software interrupts are listed in Table 2-1. Application programs (typically language runtime support libraries) may check for these conditions and raise these interrupts, but are not required to do so. Immediate operands in this range, and not listed in the table, are reserved for future use.\n- Immediate operands whose three highest-order bits are 001 are available for application use as software interrupts. The behavior of these interrupts, however, is ABI specific.\n• Immediate operands whose two highest-order bits are 01 are reserved for debugger breakpoints. Use of debugger breakpoints is ABI specific.\n\n• Immediate operands whose highest-order bit is 1 are reserved for definition by each ABI. It is expected that some operating systems may use values in this range for system-level debugging features and system calls.\n\n**Note:** Itanium™ processors do not deliver the immediate operand of a `break.b` instruction to the cr.iim register. The operating system software must therefore decode the `break.b` instruction to obtain the immediate operand.\n\n### Table 2-1. Software Interrupts\n\n<table>\n<thead>\n<tr>\n<th>Operand</th>\n<th>Software Interrupt</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>Unknown program error (typically an indirect branch through an uninitialized pointer, which often leads to a bundle containing all zeroes)</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Integer divide by zero</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Integer overflow</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Range check/bounds check error</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Nil pointer dereference</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Misaligned data</td>\n</tr>\n<tr>\n<td>6</td>\n<td>Decimal overflow</td>\n</tr>\n<tr>\n<td>7</td>\n<td>Decimal divide by zero</td>\n</tr>\n<tr>\n<td>8</td>\n<td>Packed decimal error</td>\n</tr>\n<tr>\n<td>9</td>\n<td>Invalid ASCII digit (unpacked decimal arithmetic)</td>\n</tr>\n<tr>\n<td>10</td>\n<td>Invalid decimal digit (packed decimal arithmetic)</td>\n</tr>\n<tr>\n<td>11</td>\n<td>Paragraph stack overflow (COBOL)</td>\n</tr>\n</tbody>\n</table>\n\n### 2.2 Floating-point Programming Model\n\nAn application may use all features of the processor architecture that are described in the Floating-Point Programming Model section of the *Intel® IA-64 Architecture Software Developer’s Manual*.\n\n### 2.3 System State and Programming Model\n\nThe features of the processor architecture that are described in the System State and Programming Model section of the *Intel® IA-64 Architecture Software Developer’s Manual* are intended for the exclusive use of the operating system software, with the following exceptions:\n\n- The Interval Time Counter application register may be read by applications, except when running in a secure operating environment that explicitly restricts this access.\n\n- The explicit serialization instructions may be used by an application.\n\n- An application may read and modify the user mask portion of the PSR, although some changes may result in unexpected and incorrect interactions with the operating system software. Changes to the user mask should be done only as allowed by the ABI.\n• An application may use the RSE-related instructions, and may read and modify the resources\nassociated with the register stack engine that are not restricted to privilege level 0.\n\nNote that the debug and performance monitor control registers are restricted for use by the\noperating system software, which may provide access to the capabilities provided by these\nhardware features through its APIs. Although the performance monitor counter registers are\nreadable by user-mode code, effective use of the registers is dependent on ABI-specific services.\n\n2.4 Addressing and Protection\n\nThe features of the processor architecture that are described in the Addressing and Protection\nsection of the Intel® IA-64 Architecture Software Developer’s Manual are intended for the\nexclusive use of the operating system software, with the following exceptions:\n\n• An application may use the addp4 and shladdp4 instructions to convert a 32-bit virtual\naddress to a 64-bit virtual address.\n\n• The operating system software may provide access to certain page attributes, including\ncaching and ordering attributes, through its API. The use of such features is ABI specific.\n\n• Applications may use the probe instructions, but a failure result does not necessarily indicate\na lack of permission. In particular, a probe for write access to a copy-on-write page is not\nguaranteed to return a success result. The operating system software is permitted to nullify a\nfaulting probe instruction, so application software must pre-initialize the target register in order\nto distinguish a success result from a nullified probe instruction.\n\n2.5 Interruptions\n\nThe features of the processor architecture that are described in the Interruptions section of the\nIntel® IA-64 Architecture Software Developer’s Manual are intended for the exclusive use of the\noperating system software.\nThese conventions define a virtual memory system with a 64-bit virtual address space per process. Each operating system may divide this address space into different portions, and assign specific uses to each portion.\n\nThis chapter describes the types of memory segments and protection areas that an application process uses, and documents the assumptions that an application may make about those segments. From a different perspective, it documents the minimum requirements that must be satisfied by an operating system with respect to its allocation of these program segments in the virtual address space.\n\nThe term *segment* is used here to identify an area of memory that has a specific use within an application and has no fixed address relationship to any other segment. Thus, relative distances between any two items belonging to the same segment are constant once the program has been linked, but the distance between two items in different segments is not fixed. It does not imply the use of hardware segmentation, or any specific allocation of segments to hardware regions. In particular, this definition of segment has no relation to the traditional IA-32 segment, nor does it necessarily correspond exactly to the definition of a segment in an object file.\n\nSegments may cross region boundaries. Region IDs should be transparent to the application. Note that more than one region register may point to the same region.\n\nSegments are composed of one or more protection areas. The term *protection area* is used to indicate an area of memory that has common protection attributes.\n\n### 3.1 Program Segments\n\nTable 3-1 lists the types of program segments that are defined by the runtime architecture, and defines the minimum set of attributes that an operating system must provide for these segments.\n\n<table>\n<thead>\n<tr>\n<th>Segment Type</th>\n<th>Sharable</th>\n<th>Quantity</th>\n<th>Address by</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Text</td>\n<td>Yes</td>\n<td>1 per load module</td>\n<td>IP or linkage table</td>\n<td>Text, unwind information, constants and literals</td>\n</tr>\n<tr>\n<td>Short Data</td>\n<td>No</td>\n<td>1 per load module</td>\n<td>gp</td>\n<td>Static data, bss, linkage tables</td>\n</tr>\n<tr>\n<td>Long Data</td>\n<td>No</td>\n<td>any</td>\n<td>linkage table</td>\n<td>Long data, bss</td>\n</tr>\n<tr>\n<td>Heap</td>\n<td>No</td>\n<td>any</td>\n<td>pointer</td>\n<td>Heap data</td>\n</tr>\n<tr>\n<td>Stack</td>\n<td>No</td>\n<td>1 per thread</td>\n<td>sp</td>\n<td>Memory stacks</td>\n</tr>\n<tr>\n<td>Backing Store</td>\n<td>No</td>\n<td>1 per thread</td>\n<td>bsp</td>\n<td>Backing store for register stacks</td>\n</tr>\n<tr>\n<td>Thread Data</td>\n<td>No</td>\n<td>1 per thread</td>\n<td>tp</td>\n<td>Thread-local storage</td>\n</tr>\n<tr>\n<td>Shared Data</td>\n<td>Yes</td>\n<td>any</td>\n<td>pointer</td>\n<td>Shared memory</td>\n</tr>\n</tbody>\n</table>\nThe sharable attribute indicates whether or not the memory contained within such a segment may be shared between two or more processes. For text segments, this implies that an operating system will probably not grant write access, in order to make the text segment pure. For this reason, the runtime architecture does not place anything into the text segment that may need to be written at either program invocation time or execution time.\n\nThe runtime architecture does not specify how an operating system will make a particular segment sharable. It may place sharable segments in separate regions, or it may place the entire program in a process-private address space and use address aliasing to share memory. The runtime architecture is designed to be neutral with respect to this operating system design parameter. Segments may cross hardware region boundaries, but only if transparent to the application. Code is not aware of region IDs.\n\nA program consists of several load modules: the main program, and one for each DLL that it uses. Each load module consists of at least a text segment and a short data segment. The addresses of these segments are not fixed at link time, so all accesses to these segments must be either ip-relative (for text), gp-relative (for short data and the linkage table), or indirect via the linkage table. The gp register and its conventions are described in Chapter 8, “Procedure Linkage”.\n\nDLL data may be allocated at execution time. This implies that DLL data segment sizes need not be fixed at link time.\n\nEach operating system is expected to provide some form of heap management, although the runtime architecture does not have any explicit dependencies on such. The API for obtaining heap memory, however, is operating system dependent, and the runtime architecture places no restrictions on the locations or contiguity of separately-allocated items from the heap.\n\nEach thread is provided with two stacks: one for the classical memory stack, and one for the register stack backing store. Each thread also has a separate data segment for thread-local storage. These segments must all be allocated from the process’ virtual address space, so that one thread may use a pointer that refers to another thread’s local storage. The sp register and its conventions are described in Chapter 7, “Memory Stack,” and the bsp register is described in Chapter 6, “Register Stack”. The tp register is reserved to provide a handle for accessing thread-local storage, but this usage is ABI dependent.\n\nLike the heap, shared data segments are obtained through an operating system-specific API. The runtime architecture places no restrictions on the locations of these segments.\n\n### 3.2 Protection Areas\n\nTable 3-2 lists the minimum access protection for the protection areas defined in the runtime architecture:\n\n<table>\n<thead>\n<tr>\n<th>Segment</th>\n<th>Protection Area</th>\n<th>Min. Access</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Text</td>\n<td>Text</td>\n<td>X</td>\n</tr>\n<tr>\n<td></td>\n<td>Constants</td>\n<td>R</td>\n</tr>\n<tr>\n<td></td>\n<td>Unwind Tables</td>\n<td>R</td>\n</tr>\n<tr>\n<td>Short data</td>\n<td>Static Data</td>\n<td>R, W</td>\n</tr>\n<tr>\n<td></td>\n<td>Short Bss</td>\n<td>R, W</td>\n</tr>\n<tr>\n<td></td>\n<td>Linkage Tables</td>\n<td>R, W</td>\n</tr>\n</tbody>\n</table>\nIn order to make the most effective use of the addressing modes available in IA-64, each load module’s data is partitioned into one short and some number of long data segments. The short data segment, addressed by the gp register in each load module, contains the following areas:\n\n- A linkage table, containing pointers to imported data symbols and functions, and to data in the text segments and long data segments.\n- A short data area, containing small initialized “own” data items.\n- A short bss area, containing small uninitialized “own” data items.\n\nThe long data segments contain either or both of the following areas:\n\n- A long data area, containing large initialized data items, and initialized non-“own” data items of any size.\n- A long bss area, containing large uninitialized “own” data items.\n\n“Own” data items are those that are either local to a load module, or are such that all references to these items from the same load module will always refer to these items. That is, they are not subject to being overridden by an exported symbol of the same name in another load module. All data items in the main program satisfy this definition, since the main program is always the first load module in the binding sequence. Since non-“own” variables cannot be referenced directly, there is no benefit to placing them in the short data or bss area.\n\nSmall “own” data items are placed in the short bss or short data, and are guaranteed to be within 2 megabytes, in either direction, of the gp address, so compilers may use a short direct addressing sequence (using the add with 22-bit immediate instruction) to access any data item allocated in these areas. The compiler should place all “own” data items that are 8 bytes or less in size, regardless of structure, in the short data or short bss areas.\n\nAll other data items, including items that are larger than 8 bytes in size, or that require indirect addressing because of load-time binding, must be placed in the long data or long bss area. The compiler must address these items indirectly, using a linkage table entry. Linkage table entries are typically allocated by the linker in response to a relocation request generated by the compiler; an entry in the linkage table is either an 8-byte pointer to a data item, or a 16-byte function descriptor. A function descriptor placed in the linkage table is a local copy of an “official” function descriptor that is generally allocated by the linker or dynamic loader.\n\nThis design allows for a maximum size of 4 megabytes for the short data segment, since everything must be addressable via the gp register using the 22-bit add immediate instruction. Given that linkage table entries are 8-byte pointers for data references, and 16 bytes long for procedure references, this allows for up to 256,000 individually-named variables and functions. If a load module requires more than this, the compilers will need to support a “huge” memory model, which is not described here.\n\nProtection areas are required to be aligned only as strictly as their contents.\n\nTable 3-2. Protection Areas (Cont’d)\n\n<table>\n<thead>\n<tr>\n<th>Segment</th>\n<th>Protection Area</th>\n<th>Min. Access</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Long data</td>\n<td>Long Data</td>\n<td>R, W</td>\n</tr>\n<tr>\n<td></td>\n<td>Bss</td>\n<td>R, W</td>\n</tr>\n<tr>\n<td>Heap</td>\n<td>Heap</td>\n<td>R, W</td>\n</tr>\n<tr>\n<td>Stack</td>\n<td>Stack</td>\n<td>R, W</td>\n</tr>\n<tr>\n<td>Backing store</td>\n<td>Backing store</td>\n<td>R, W</td>\n</tr>\n<tr>\n<td>Thread data</td>\n<td>Thread data</td>\n<td>R, W</td>\n</tr>\n<tr>\n<td>Shared data</td>\n<td>Shared data</td>\n<td>R, W</td>\n</tr>\n</tbody>\n</table>\n3.3 Data Allocation\n\n3.3.1 Global Variables\n\nCommon blocks, dynamically allocated regions (for example, from malloc), and external data items greater than 8 bytes must all be aligned on a 16-byte boundary. Smaller data items must be aligned on the next larger power-of-two boundary. Table 3-3 shows the alignment requirements for different size objects.\n\nTable 3-3. Alignment Requirements for Global Objects\n\n<table>\n<thead>\n<tr>\n<th>Size in Bytes</th>\n<th>Alignment Required</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>none</td>\n</tr>\n<tr>\n<td>2</td>\n<td>0 mod 2 (even addresses)</td>\n</tr>\n<tr>\n<td>3–4</td>\n<td>0 mod 4</td>\n</tr>\n<tr>\n<td>5–8</td>\n<td>0 mod 8</td>\n</tr>\n<tr>\n<td>9 and up</td>\n<td>0 mod 16</td>\n</tr>\n</tbody>\n</table>\n\nAccess to global variables that are not known (at compile time) to be defined in the same load module must be indirect. Each load module has a linkage table in its data segment, pointed to by the gp register; code must load a pointer to the global variable from the linkage table, then access the global variable through the pointer. Access to globals known to be defined in the same load module or to static locals that are placed in short-data section may be made with a gp-relative offset.\n\n3.3.2 Local Static Data\n\nAccess to short local static data can be made with a gp-relative offset; access to long local static data must be indirect.\n\n3.3.3 Constants and Literals\n\nConstants and literals may be placed in the text segment or in the data segment. If placed in the text segment, the access must be ip-relative or indirect using a linkage table entry.\n\nLiterals placed in the data segment may be placed in the short initialized data area if they are 8 bytes or less in size. Larger literals must be placed in the long initialized data area or in the text segment. Literals in the long initialized data area require an indirect access using a linkage table entry.\n\n3.3.4 Local Memory Stack Variables\n\nAccess is sp-relative.\n\nStack frames must always be aligned on a 16-byte boundary. The stack pointer register must always be aligned on a 16-byte boundary.\nApplications running in a 64-bit environment use either the “P64” or “LP64” data model: integers are always 32 bits, while pointers are 64 bits. Long integers may be either 32 or 64 bits, depending on the data model: they are 32 bits in “P64” and 64 bits in “LP64”.\n\nWithin this specification, the term *halfword* refers to a 16-bit object, the term *word* refers to a 32-bit object, the term *doubleword* refers to a 64-bit object, and the term *quadword* refers to a 128-bit object.\n\nThe following sections define the size, alignment requirements, and hardware representation of the standard C and Fortran data types.\n\n**Note:** The Itanium™ architecture does not require hardware support for misaligned data access. If provided by a processor implementation, the support may be disabled by the alignment check (ac) bit in the user mask. Whether supported directly by hardware, by software emulation, or by a combination, misaligned data accesses will cause a substantial performance penalty, and these conventions do not require the hardware or the OS to support them. The alignment rules in this chapter have been chosen to maximize performance, and to guarantee that programs will execute correctly on systems with no support for misaligned data accesses.\n\n### 4.1 Fundamental Types\n\nTable 4-1 lists the scalar data types supported by the architecture. Sizes and alignments are shown in bytes. A null pointer (for all types) has the value zero.\n\nThe types __int64, __int128, __float80, and __float128 are used in this document for notational convenience only; they are not meant to imply that any implementation must support these specific type names. Each ABI specification is expected to specify these specific type names for whichever of these types are supported by that ABI.\n\n**Table 4-1. Scalar Data types Supported by Itanium™ Processors**\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>C</th>\n<th>Size</th>\n<th>Align</th>\n<th>Hardware Representation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>integral</td>\n<td>char</td>\n<td>1</td>\n<td>1</td>\n<td>signed byte</td>\n</tr>\n<tr>\n<td></td>\n<td>signed char</td>\n<td>1</td>\n<td>1</td>\n<td>signed byte</td>\n</tr>\n<tr>\n<td></td>\n<td>unsigned char</td>\n<td>1</td>\n<td>1</td>\n<td>unsigned byte</td>\n</tr>\n<tr>\n<td></td>\n<td>short</td>\n<td>2</td>\n<td>2</td>\n<td>signed halfword</td>\n</tr>\n<tr>\n<td></td>\n<td>signed short</td>\n<td>2</td>\n<td>2</td>\n<td>signed halfword</td>\n</tr>\n<tr>\n<td></td>\n<td>unsigned short</td>\n<td>2</td>\n<td>2</td>\n<td>unsigned halfword</td>\n</tr>\n<tr>\n<td></td>\n<td>int</td>\n<td>4</td>\n<td>4</td>\n<td>signed word</td>\n</tr>\n<tr>\n<td></td>\n<td>signed int</td>\n<td>4</td>\n<td>4</td>\n<td>signed word</td>\n</tr>\n<tr>\n<td></td>\n<td>enum</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>unsigned int</td>\n<td>4</td>\n<td>4</td>\n<td>unsigned word</td>\n</tr>\n<tr>\n<td></td>\n<td>__int64</td>\n<td>8</td>\n<td>8</td>\n<td>signed doubleword</td>\n</tr>\n<tr>\n<td></td>\n<td>signed __int64</td>\n<td>8</td>\n<td>8</td>\n<td>signed doubleword</td>\n</tr>\n<tr>\n<td></td>\n<td>unsigned __int64</td>\n<td>8</td>\n<td>8</td>\n<td>unsigned doubleword</td>\n</tr>\n<tr>\n<td></td>\n<td>__int128 b</td>\n<td>16</td>\n<td>16</td>\n<td>signed 128-bit integer</td>\n</tr>\n<tr>\n<td></td>\n<td>signed __int128 b</td>\n<td>16</td>\n<td>16</td>\n<td>signed 128-bit integer</td>\n</tr>\n<tr>\n<td></td>\n<td>unsigned __int128 b</td>\n<td>16</td>\n<td>16</td>\n<td>unsigned 128-bit integer</td>\n</tr>\n</tbody>\n</table>\n4.2 Aggregate Types\n\nAggregates (structures and arrays) and unions assume the alignment of their most strictly aligned component. The size of any object, including aggregates and unions, is always a multiple of the object’s alignment. An array uses the same alignment as its elements. Structure and union objects can require padding to meet size and alignment constraints. The contents of any padding is undefined.\n\n- An entire structure or union object is aligned on the same boundary as its most strictly aligned member.\n- Each member is assigned to the lowest available offset with the appropriate alignment. This may require internal padding, depending on the previous member.\n- A structure’s size is increased, if necessary, to make it a multiple of the alignment. This may require tail padding, depending on the last member.\n\nIn the following figures, members’ byte offsets appear in the upper right corners for little-endian, in the upper left for big-endian.\n\nFigure 4-1. Structure Smaller Than a Word\n\n```\nstruct {\n char c;\n};\n```\n\nByte aligned, sizeof is 1\n\n```\n c\n```\n\n```\n| |\n```\n\nTable 4-1. Scalar Data types Supported by Itanium™ Processors (Cont’d)\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>C</th>\n<th>Size</th>\n<th>Align</th>\n<th>Hardware Representation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Pointer</td>\n<td>any-type *</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>any-type (*) ()</td>\n<td>8</td>\n<td>8</td>\n<td>unsigned doubleword</td>\n</tr>\n<tr>\n<td>Floating-point</td>\n<td>float</td>\n<td>4</td>\n<td>4</td>\n<td>IEEE single precision</td>\n</tr>\n<tr>\n<td></td>\n<td>double</td>\n<td>8</td>\n<td>8</td>\n<td>IEEE double precision</td>\n</tr>\n<tr>\n<td></td>\n<td>__float80 c</td>\n<td>16</td>\n<td>16</td>\n<td>IEEE double-extended precision</td>\n</tr>\n<tr>\n<td></td>\n<td>__float128 d</td>\n<td>16</td>\n<td>16</td>\n<td>quad precision</td>\n</tr>\n</tbody>\n</table>\n\na. Shift right of signed data types sign-extends.\nb. _int128 is not directly supported by the hardware, and these conventions do not require an operating system environment to support this type through emulation. Size and alignment conventions are specified here, however, for those implementations that do choose to support this type. Note also that the (non-standard) long long data type is not specified by these conventions, and its definition is ABI specific. It may be implemented as a 64-bit integer, a 128-bit integer, or not at all.\nc. __float80 is the IA-64 extended 80-bit quantity, but the software standard is to treat it as a 16-byte quantity. It is referenced using ldfe and stfe instructions. This type has the same precision and range as the 80 bit extended data type of the IA-32 architecture, but with different size and alignment.\nd. __float128 is not directly supported by the hardware, and these conventions do not require an operating system environment to support this type through emulation. Size, representation, and alignment conventions are specified here, however, for those implementations that do choose to support this type. A quad-precision floating-point number is a 128-bit quantity with a sign bit, a 15-bit biased exponent, and a 112-bit mantissa with an implicit integer bit.\nFigure 4-2. No Padding\n\n```\nstruct {\n char c;\n char d;\n short s;\n int n;\n};\n```\n\nLittle endian, word aligned, sizeof is 8\n```\n+--------+--------+--------+\n| s | d | c |\n+--------+--------+--------+\n| | | 0 |\n+--------+--------+--------+\n| n |\n```\n\nBig endian, word aligned, sizeof is 8\n```\n+--------+--------+--------+\n| c | 1 | d |\n+--------+--------+--------+\n| 0 | 2 | s |\n+--------+--------+--------+\n| n |\n```\n\nFigure 4-3. Internal Padding\n\n```\nstruct {\n char c;\n short s;\n};\n```\n\nLittle endian, halfword aligned, sizeof is 4\n```\n+--------+\n| s |\n+--------+\n| pad |\n+--------+\n| c |\n+--------+\n```\n\nBig endian, halfword aligned, sizeof is 4\n```\n+--------+\n| c |\n+--------+\n| pad |\n+--------+\n| s |\n+--------+\n```\n\nFigure 4-4. Internal and Tail Padding\n\n```\nstruct {\n char c;\n double d;\n short s;\n};\n```\n\nLittle endian, doubleword aligned, sizeof is 24\n```\n+----------+\n| pad |\n+----------+\n| pad |\n+----------+\n| d (low) |\n+----------+\n| d (high) |\n+----------+\n| pad |\n+----------+\n| s |\n+----------+\n| pad |\n+----------+\n\nBig endian, doubleword aligned, sizeof is 24\n```\n+----------+\n| c |\n+----------+\n| pad |\n+----------+\n| pad |\n+----------+\n| d (high) |\n+----------+\n| d (low) |\n+----------+\n| s |\n+----------+\n| pad |\n+----------+\n| pad |\n4.3 Bit Fields\n\nC `struct` and `union` definitions may have *bit-fields* that define integral objects with a specified number of bits. Table 4-2 defines the allowable widths and corresponding range of values for bit fields of each base type.\n\n**Table 4-2. Bit Field Base Types**\n\n<table>\n<thead>\n<tr>\n<th>Base Type</th>\n<th>Width w</th>\n<th>Range</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>unsigned char</td>\n<td>1 to 8</td>\n<td>0 to $2^w-1$</td>\n</tr>\n<tr>\n<td>signed char</td>\n<td>1 to 8</td>\n<td>$-2^{w-1}$ to $2^{w-1}-1$</td>\n</tr>\n<tr>\n<td>unsigned short</td>\n<td>1 to 16</td>\n<td>0 to $2^{w-1}$</td>\n</tr>\n<tr>\n<td>signed short</td>\n<td>1 to 16</td>\n<td>$-2^{w-1}$ to $2^{w-1}-1$</td>\n</tr>\n<tr>\n<td>unsigned int</td>\n<td>1 to 32</td>\n<td>0 to $2^{w-1}$</td>\n</tr>\n<tr>\n<td>signed int</td>\n<td>1 to 32</td>\n<td>$-2^{w-1}$ to $2^{w-1}-1$</td>\n</tr>\n<tr>\n<td>unsigned long</td>\n<td>1 to 64</td>\n<td>0 to $2^{w-1}$</td>\n</tr>\n<tr>\n<td>signed long</td>\n<td>1 to 64</td>\n<td>$-2^{w-1}$ to $2^{w-1}-1$</td>\n</tr>\n</tbody>\n</table>\n\nBit-fields obey the same size and alignment rules as other structure and union members, with the following additions:\n\n- Bit-fields are allocated from right to left (least to most significant) for little endian. They are allocated left to right (most to least significant) for big-endian.\n- A bit-field must entirely reside in a storage unit appropriate for its declared type. For example, a bit field of type `short` must never cross a halfword boundary.\n- Bit-fields may share a storage unit with other `struct/union` members, including members that are not bit-fields. Of course, each `struct` member occupies a different part of the storage unit.\n- Unnamed bit-fields do not affect the alignment of a structure or union.\nZero-length bit-fields force the alignment of following member of a structure to the next alignment boundary corresponding to the type of the bit field. An un-named zero-length bit field, however, will not force the external alignment of the structure to that boundary.\n\nIf an unnamed bit field is used to establish an internal alignment more restrictive than the external alignment, it is possible that the stricter alignment will not be maintained when the structure or union is allocated in memory.\n\nThe following figures show struct and union member byte offsets in the upper corners; bit numbers appear in the lower corners.\n\n**Figure 4-6. Bit Numbering**\n\n```\n0xF1F2F3F4\n```\n\n```\nLittle endian\n\n<table>\n<thead>\n<tr>\n<th>31</th>\n<th>F1</th>\n<th>24</th>\n<th>F2</th>\n<th>16</th>\n<th>F3</th>\n<th>8</th>\n<th>F4</th>\n<th>0</th>\n</tr>\n</thead>\n</table>\n\nBig endian\n\n<table>\n<thead>\n<tr>\n<th>0</th>\n<th>F1</th>\n<th>7</th>\n<th>F2</th>\n<th>15</th>\n<th>F3</th>\n<th>23</th>\n<th>F4</th>\n<th>31</th>\n</tr>\n</thead>\n</table>\n```\n\n**Figure 4-7. Bit Field Allocation**\n\n```\nstruct {\n int j:5;\n int k:6;\n int m:7;\n};\n```\n\n```\nLittle Endian, word aligned, sizeof is 4\n\n<table>\n<thead>\n<tr>\n<th>31</th>\n<th>pad</th>\n<th>18</th>\n<th>m</th>\n<th>11</th>\n<th>k</th>\n<th>5</th>\n<th>j</th>\n<th>0</th>\n</tr>\n</thead>\n</table>\n\nBig Endian, word aligned, sizeof is 4\n\n<table>\n<thead>\n<tr>\n<th>0</th>\n<th>j</th>\n<th>4</th>\n<th>k</th>\n<th>10</th>\n<th>m</th>\n<th>18</th>\n<th>pad</th>\n<th>31</th>\n</tr>\n</thead>\n</table>\n```\n\n**Figure 4-8. Boundary Alignment**\n\n```\nstruct {\n short s:9;\n __int64 j:9;\n char c;\n short t:9;\n short u:9;\n char d;\n};\n```\n\n```\nLittle Endian, doubleword aligned, sizeof is 16\n\n<table>\n<thead>\n<tr>\n<th>31</th>\n<th>pad</th>\n<th>23</th>\n<th>c</th>\n<th>18</th>\n<th>j</th>\n<th>17</th>\n<th>s</th>\n<th>8</th>\n<th>0</th>\n</tr>\n</thead>\n</table>\n\nBig Endian, doubleword aligned, sizeof is 16\n\n<table>\n<thead>\n<tr>\n<th>0</th>\n<th>s</th>\n<th>8</th>\n<th>j</th>\n<th>17</th>\n<th>pad</th>\n<th>23</th>\n<th>c</th>\n<th>4</th>\n</tr>\n</thead>\n</table>\n```\n\n```\nData Representation\n\n**Note:** Unnamed bit fields do not affect the alignment of the structure.\n\nAs the examples show, `int` and `__int64` bit-fields (including `signed` and `unsigned`) usually pack more densely than smaller base types. One can use `char` and `short` bit-fields to force allocation within those types, but `int` is generally more efficient.\n4.4 Fortran Data Types\n\nTable 4-3 shows the correspondence between ANSI Fortran’s scalar types and the processor’s data types. ANSI Fortran requires REAL and INTEGER to be the same size. Many Fortran compilers allow INTEGER*n, LOGICAL*n, and REAL*n to specify specific processor sizes. (\"n\" is in bytes). The COMPLEX data type is treated exactly the same as a C structure composed of two float members.\n\n**Table 4-3. Fortran Data Types**\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Fortran</th>\n<th>Size</th>\n<th>Align (bytes)</th>\n<th>Hardware Representation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Character</td>\n<td>CHARACTER*n</td>\n<td>n</td>\n<td>1</td>\n<td>byte</td>\n</tr>\n<tr>\n<td>Integral</td>\n<td>LOGICAL</td>\n<td>4</td>\n<td>4 word</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>INTEGER</td>\n<td>4</td>\n<td>4 signed word</td>\n<td></td>\n</tr>\n<tr>\n<td>Floating-point</td>\n<td>REAL</td>\n<td>4</td>\n<td>4 IEEE single-precision</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>DOUBLE PRECISION</td>\n<td>8</td>\n<td>8 IEEE double-precision</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>COMPLEX</td>\n<td>8</td>\n<td>4 2 IEEE single-precision</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n5.1 Partitioning\n\nRegisters are partitioned into the following classes:\n\n- **Scratch** registers may be modified by a procedure call; the caller must save these registers before a call if needed (“caller save”).\n- **Preserved** registers must not be modified by a procedure call; the callee must save and restore these registers if used (“callee-save”).\n- **Automatic** registers are saved and restored automatically by the call/return mechanism.\n- **Constant** or **Read-only** registers contain a fixed value that cannot be changed by the program.\n- **Special** registers are used in the call/return mechanism. The conventions for these registers are described individually below.\n\n5.2 General Registers\n\nGeneral registers are used for integer arithmetic and other general-purpose computations. Table 5-1 lists the general registers.\n\n<table>\n<thead>\n<tr>\n<th>Register</th>\n<th>Class</th>\n<th>Usage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>r0</td>\n<td>constant</td>\n<td>Always 0</td>\n</tr>\n<tr>\n<td>r1</td>\n<td>special</td>\n<td>Global data pointer (gp)</td>\n</tr>\n<tr>\n<td>r2–r3</td>\n<td>scratch</td>\n<td>Use with 22-bit immediate add</td>\n</tr>\n<tr>\n<td>r4–r7</td>\n<td>preserved</td>\n<td></td>\n</tr>\n<tr>\n<td>r8</td>\n<td>scratch</td>\n<td>Return value; structure/union return pointer</td>\n</tr>\n<tr>\n<td>r8–11</td>\n<td>scratch</td>\n<td>Return values</td>\n</tr>\n<tr>\n<td>r12</td>\n<td>special</td>\n<td>Memory stack pointer (sp)</td>\n</tr>\n<tr>\n<td>r13</td>\n<td>special</td>\n<td>Reserved as a thread pointer (tp)</td>\n</tr>\n<tr>\n<td>r14–r31</td>\n<td>scratch</td>\n<td></td>\n</tr>\n<tr>\n<td>in0–in95</td>\n<td>automatic</td>\n<td>Stacked input registers (see below)</td>\n</tr>\n<tr>\n<td>loc0–loc95</td>\n<td>automatic</td>\n<td>Stacked local registers (see below)</td>\n</tr>\n<tr>\n<td>out0–out95</td>\n<td>scratch</td>\n<td>Stacked output registers (see below)</td>\n</tr>\n</tbody>\n</table>\n\n- **r1** is the global data pointer (gp), which is designated to hold the address of the currently addressable global data segment. Its use is subject to the following conventions:\n - **a.** On entry to a procedure, gp is guaranteed valid for that procedure.\n - **b.** At any direct procedure call, gp must be valid (for the caller). This guarantees that an import stub (see Section 8.4.1) can access the linkage table.\nc. Any procedure call (indirect or direct) may modify \\textit{gp}—unless the call is known to be local to the load module.\n\nd. At procedure return, \\textit{gp} must be valid (for the returning procedure). This allows the compiler to optimize calls known to be local (i.e., the exceptions to Rule ‘c’).\n\nThe effect of these rules is that \\textit{gp} must be treated as a scratch register at a point of call (i.e., it must be saved by the caller), and it must be preserved from entry to exit.\n\n- \\textit{r4–r7} are general-purpose preserved registers, and can be used for any value that needs to be preserved across a procedure call. A procedure using one of the preserved general registers must save and restore the caller’s original contents, including the NaT bits associated with the registers, without generating a NaT consumption fault. This can be done by either copying the register to a stacked register or by using the \\texttt{st8.spill} and \\texttt{ld8.fill} instructions and then saving \\texttt{ar.unat}.\n\n- \\textit{r8} is used as the \\texttt{struct/union} return pointer register. If the function being called returns a \\texttt{struct} or \\texttt{union} value larger than 32 bytes, then register \\texttt{GR 8} contains, on entry, the appropriately-aligned address of the caller-allocated area to contain the value being returned. (See Section 8.6.)\n\n- \\textit{r8–r11} are used for non-floating-point return values up to 32 bytes. Functions do not have to preserve their values for the caller.\n\n- \\textit{r12} is the \\textit{stack pointer}, which holds the limit of the current stack frame, the address of the stack’s bottom-most valid word. At all times, the stack pointer must point to a 0 mod 16 aligned area. The stack pointer is also used to access any memory arguments upon entry to a function. Except in the case of dynamic stack allocation (e.g., \\texttt{alloca}), this register is preserved across any functions called by the current function. A call to a function that does not preserve the stack pointer must notify the compiler, to cause the generation of code that behaves properly. Failure to notify the compiler leads to undefined behavior. The standard function calling sequence does not include any method to detect such failures. This allows the compiler to use the stack pointer to reference stack items without having to set up a frame pointer for this purpose.\n\n- \\textit{r13} is reserved for use as a \\textit{thread pointer}. The usage of this register is ABI specific. Programs conforming to these conventions may not modify this register.\n\n- \\textit{r32–r39 (in0–in7)} are used as incoming argument registers. Arguments beyond these registers appear in memory, as explained in Chapter 8. Refer to the discussion below on structures and unions.\n\n- \\textit{r32–r127} are stacked registers. Code may allocate a register stack frame of up to 96 registers with the \\texttt{alloc} instruction, and partition this frame into three regions: input registers (\\texttt{in0}, \\texttt{in1}, ...), local registers (\\texttt{loc0}, \\texttt{loc1}, ...), and output registers (\\texttt{out0}, \\texttt{out1}, ...). The input and local regions are automatic, and the output region is scratch. See Chapter 6, “Register Stack” for more information.\n\n### 5.3 Floating-point Registers\n\nFloating-point registers are used for floating-point computations and certain integer computations, such as multiply and divide. Table 5-2 lists the floating-point registers.\n\n<table>\n<thead>\n<tr>\n<th>Register</th>\n<th>Class</th>\n<th>Usage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>f0</td>\n<td>constant</td>\n<td>Always 0.0</td>\n</tr>\n<tr>\n<td>f1</td>\n<td>constant</td>\n<td>Always 1.0</td>\n</tr>\n</tbody>\n</table>\nRegister Usage\n\nTable 5-2. Floating-point Registers (Cont’d)\n\n<table>\n<thead>\n<tr>\n<th>Register</th>\n<th>Class</th>\n<th>Usage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>f2–f5</td>\n<td>preserved</td>\n<td></td>\n</tr>\n<tr>\n<td>f6–f7</td>\n<td>scratch</td>\n<td></td>\n</tr>\n<tr>\n<td>f8–f15</td>\n<td>scratch</td>\n<td>Argument/return registers</td>\n</tr>\n<tr>\n<td>f16–f31</td>\n<td>preserved</td>\n<td></td>\n</tr>\n<tr>\n<td>f32–f127</td>\n<td>scratch</td>\n<td>Rotating registers or scratch</td>\n</tr>\n</tbody>\n</table>\n\n- **f2–f5** and **f16–f31** are preserved floating-point registers, and can be used for any value that needs to be preserved across a procedure call. A procedure using one of the preserved floating-point registers must save and restore the caller’s original contents without generating a NaT consumption fault. This can be done by using the `stf.spill` and `ldf.fill` instructions.\n\n- **f8–f15** are used as incoming floating-point argument registers. Floating-point arguments are placed in these registers when possible. Arguments beyond the registers appear in memory, as explained in Section 8.5. Within the called function, these are local scratch registers and are not preserved for the caller.\n\n Floating-point return values also appear in these registers. Single, double, and extended values are all returned using the appropriate format.\n\n- **f32–f127** can be used as rotating registers. They are available as normal scratch registers if rotation is not being used.\n\n### 5.4 Predicate Registers\n\nPredicate registers are single-bit-wide registers used for controlling the execution of predicated instructions. Table 5-3 lists the predicate registers.\n\nTable 5-3. Predicate Registers\n\n<table>\n<thead>\n<tr>\n<th>Register</th>\n<th>Class</th>\n<th>Usage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>p0</td>\n<td>constant</td>\n<td>always 1</td>\n</tr>\n<tr>\n<td>p1–p5</td>\n<td>preserved</td>\n<td>fixed</td>\n</tr>\n<tr>\n<td>p6–p15</td>\n<td>scratch</td>\n<td>fixed</td>\n</tr>\n<tr>\n<td>p16–p63</td>\n<td>preserved</td>\n<td>rotating</td>\n</tr>\n</tbody>\n</table>\n\n### 5.5 Branch Registers\n\nBranch registers are used for making indirect branches. Table 5-4 lists the branch registers.\n\nTable 5-4. Branch Registers\n\n<table>\n<thead>\n<tr>\n<th>Register</th>\n<th>Class</th>\n<th>Usage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>b0</td>\n<td>scratch</td>\n<td>Return link</td>\n</tr>\n<tr>\n<td>b1–b5</td>\n<td>preserved</td>\n<td></td>\n</tr>\n<tr>\n<td>b6–b7</td>\n<td>scratch</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n- **b0** contains the return address on entry to a procedure; it is a scratch register otherwise.\n5.6 Application Registers\n\nApplication registers are special-purpose registers designated for application use. Table 5-5 lists the application registers.\n\nTable 5-5. Application Registers\n\n<table>\n<thead>\n<tr>\n<th>Register</th>\n<th>Class</th>\n<th>Usage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ar.fpsr</td>\n<td>see below</td>\n<td>Floating-point status register</td>\n</tr>\n<tr>\n<td>ar.rnat</td>\n<td>automatic</td>\n<td>RSE NaT collection register</td>\n</tr>\n<tr>\n<td>ar.unat</td>\n<td>preserved</td>\n<td>User NaT collection register</td>\n</tr>\n<tr>\n<td>ar.pfs</td>\n<td>special</td>\n<td>Previous function state</td>\n</tr>\n<tr>\n<td>ar.bsp</td>\n<td>read-only</td>\n<td>Backing store pointer</td>\n</tr>\n<tr>\n<td>ar.bspstore</td>\n<td>special</td>\n<td>Backing store store pointer</td>\n</tr>\n<tr>\n<td>ar.rsc</td>\n<td>see below</td>\n<td>RSE control</td>\n</tr>\n<tr>\n<td>ar.lc</td>\n<td>preserved</td>\n<td>Loop counter</td>\n</tr>\n<tr>\n<td>ar.ec</td>\n<td>automatic</td>\n<td>Epilog counter (preserved in ar.pfs)</td>\n</tr>\n<tr>\n<td>ar.ccv</td>\n<td>scratch</td>\n<td>Compare and Exchange comparison value</td>\n</tr>\n<tr>\n<td>ar.itc</td>\n<td>read-only</td>\n<td>Interval time counter</td>\n</tr>\n<tr>\n<td>ar.k0–ar.k7</td>\n<td>read-only</td>\n<td>Kernel registers</td>\n</tr>\n<tr>\n<td>ar.csd</td>\n<td>scratch</td>\n<td>Reserved for future use</td>\n</tr>\n<tr>\n<td>ar.ssd</td>\n<td>scratch</td>\n<td>Reserved for future use</td>\n</tr>\n</tbody>\n</table>\n\n- **ar.fpsr** is the floating-point status register. This register is divided into several fields:\n - **Trap Disable Bits (bits 5–0).** The trap disable bits must be preserved by the callee, except for procedures whose documented purpose is to change these bits.\n - **Status Field 0.** The control bits must be preserved by the callee; except for procedures whose documented purpose is to change these bits. The flag bits are the IEEE floating point standard sticky bits and are part of the static state of the machine.\n - **Status Field 1.** This status field is dedicated for use by divide and square root code, and must always be set to standard values at any procedure call boundary (including entry to exception handlers). These standard values are: trap disable set, round-to-nearest mode, 80-bit (extended) precision, widest range for exponent on, and flush-to-zero mode off. The flag bits are scratch.\n - **Status Fields 2 and 3.** The control bits in these status fields must agree with the control bits in status field 0, and the trap disable bits should always be set at procedure calls and returns. The flag bits are always available for scratch use.\n\n- **ar.rnat** holds the NaT bits for values stored by the register stack engine. These bits are saved automatically in the register stack backing store.\n\n- **ar.unat** holds the NaT bits for values stored by the st8.spill instruction. As a preserved register, it must be saved before a procedure can issue any st8.spill instructions. The saved copy of ar.unat in a procedure’s frame hold the NaT bits from the registers spilled by its caller; these NaT bits are thus associated with values local to the caller’s caller.\n\n- **ar.pfs** contains information that records the state of the caller’s register stack frame and epilog counter. It is overwritten on a procedure call; therefore, it must be saved before issuing any procedure calls, and restored prior to returning.\n**ar.bsp** contains the address in the backing store corresponding to the base of the current frame. This register may be modified only as a side effect of writing **ar.bspstore** while the Register Stack Engine (RSE) is in enforced lazy mode.\n\n**ar.bspstore** contains the address of the next RSE store operation. It may be read or written only while the RSE is in enforced lazy mode. Under normal operation, this register is managed by the RSE, and application code should not write to it, except when performing a stack switching operation.\n\n**ar.rsc** is the register stack configuration register. This register is divided into several fields:\n\n- **Mode.** This field controls the RSE behavior, and has scratch behavior. On a return, this field may be set to a standard value.\n- **Privilege level.** This field controls the privilege level at which the RSE operates, and may not be changed by non-privileged software.\n- **Endian mode.** This field controls the byte ordering used by the RSE, and should not be changed by an application.\n\n**ar.csrd** and **ar.ssd** are reserved for use as implicit operand registers in future extensions to the Itanium architecture. To ensure forward compatibility, software must treat these registers as part of the process state.\n\n### 5.7 User Mask\n\nThe User Mask register contains five bits that may be modified by an application program. These bits are subject to the following conventions:\n\n- **be** (Big Endian Memory Access Enable) When an application program starts, the system will set/clear the be bit will according to the programming model for which the program was compiled. The application must not change the value of this bit. If it does, the behavior is undefined.\n\n- **up** (User Performance Monitor Enable) The use of this bit by an application program is ABI dependent.\n\n- **ac** (Alignment Check) The application may set or clear this bit as desired. If the ac bit is clear, an unaligned memory reference may cause the system to deliver an exception to the application, or the system may emulate the unaligned reference. If the ac bit is set, an unaligned reference will always cause the system to deliver an exception to the application. The initial value of this bit is ABI dependent.\n\n- **mfl/mfh** (Lower/Upper floating-point registers written) The application should not clear either of these bits unless the values in the corresponding registers are no longer needed (for example, it may clear the mfh bit when returning from a procedure, since the upper set of floating-point registers is all scratch). Doing so otherwise may cause unpredictable behavior.\nGeneral registers 32 through 127 form a register stack that is automatically managed across procedure calls and returns. Each procedure frame on the register stack is divided into two dynamically-sized regions—one for input parameters and local variables, and one for output parameters. On a procedure call, the registers are automatically renamed by the hardware so that the caller’s output registers form the base of the callee’s new register stack frame. On return, the registers are restored to the previous state, so that the input and local registers are preserved across the call.\n\nThe **alloc** instruction is used at the beginning of a procedure to allocate the input, local, and output regions; the sizes of these regions are supplied as immediate operands. A procedure is not required to issue an **alloc** instruction if it does not need to store any values in its register stack frame. It may still read values from input registers, but it may not write to a stack register without first issuing an **alloc** instruction.\n\n**Figure 6-1** illustrates the operation of the register stack across an example procedure call. In this example, the caller allocates eight input, twelve local, and four output registers, and the callee allocates four input, six local, and five output registers.\n\nThe actual registers to which the stacking registers are physically mapped are not directly addressable by the application software.\n\n### 6.1 Input and Local Registers\n\nThe hardware makes no distinction between input and local registers. The caller’s output registers automatically become the callee’s entire register stack frame on a procedure call, with all registers initially allocated as output registers. An **alloc** instruction may increase or decrease the total size of the register stack frame, and may adjust the boundary between the input and local region and the output region.\n\nThe software conventions specify that up to eight registers are used for parameter passing. Any registers in the input and local region beyond those eight may be allocated for use as preserved locals. Floating-point parameters may produce “holes” in the parameter list that is passed in the general registers; those unused input registers may also be used for preserved locals.\n\nThe caller’s output registers do not need to be preserved for the caller. Once an input parameter is no longer needed, or has been copied elsewhere, that register may be reused for any other purpose within the procedure.\n\n### 6.2 Output Registers\n\nUp to eight output registers are used for passing parameters. If a procedure call requires fewer than eight general registers for its parameters, the calling procedure does not need to allocate more than are needed. If the called procedure expects more parameters, it will allocate extra input registers; these registers will be uninitialized.\nA procedure may also allocate more than eight registers in the output region. While the extra registers may not be used for passing parameters, they can be used as extra scratch registers. On a procedure call, they will show up in the called procedure’s output area as excess registers, and may be modified by that procedure. The called procedure may also allocate few enough total registers in its stack frame that the top of the called procedure’s frame is lower than the caller’s top of frame, but those registers will become available again when control returns to the caller.\n\n6.3 Rotating Registers\n\nA subset of the registers in the procedure frame may be designated as rotating registers. The rotating register region always starts with $r32$, and may be any multiple of eight registers in number, up to a maximum of 96 rotating registers. The renaming is under control of the Rotating Register Base (RRB).\n\nIf the rotating registers include any or all of the output registers, software must be careful when using the output registers for passing parameters, since a non-zero RRB will change the virtual register numbers that are part of the output region. In general, software should either ensure that the rotating region does not overlap the output region, or that the RRB is cleared to zero before setting output parameter registers.\n\n6.4 Frame Markers\n\nThe current application-visible state of the stack frame is stored in an architecturally inaccessible register called the current frame marker. On a procedure call, this register is automatically saved by copying it to an application register, the previous function state ($ar.pfs$). The current frame marker is modified to describe a new stack frame whose input and local area is initially zero size, and whose output area is equal in size to the previous output area. On return, the previous frame state register is used to restore the current frame marker to its earlier value, and the base of the register stack is adjusted accordingly.\n\nIt is the responsibility of a procedure to save the previous function state register before issuing any procedure calls of its own, and to restore it before returning.\n\n6.5 Backing Store for Register Stack\n\nWhen the depth of the procedure call stack exceeds the capacity of the physical register file, the hardware frees physical registers by saving them into a memory stack. This backing store is distinct from the memory stack described in the next chapter.\n\nAs returns unwind the procedure call stack, the hardware also restores previously-saved physical registers from the backing store.\n\nThe operation of this register stack engine (RSE) is mostly transparent to application software. While the RSE is running, application software may not examine the contents of the backing store, and may not make any assumptions about how much of the register stack is still in physical registers or in the backing store. In order to examine previous stack frames, application software must synchronize the RSE with the flushrs instruction. Synchronizing the RSE forces all stack frames up to, but not including, the current frame to be saved in backing store, allowing the software to examine the contents of the backing store without asynchronous operations modifying the memory. Modifications to the backing store require setting the RSE to “enforced lazy mode”\nafter synchronizing it, which prevents the RSE from doing any operations other than those required by calls and returns. The procedure for synchronizing the RSE and setting the mode is described in Section 10.2, “User-level Thread Switch, Coroutines” on page 10-2.\n\n**Figure 6-1. Operation of the Register Stack**\n\nThe backing store grows towards higher addresses. When the RSE is synchronized and in enforced lazy mode, the top of the stack corresponding to the top of the previous procedure frame is available in the Backing Store Pointer (bsp) application register.\n\nEven when the RSE is in enforced lazy mode, the bsp must always point to a valid backing store address, since the operating system may need to start the RSE to process an exception.\n\nA NaT collection register is stored into the backing store after each group of 63 physical registers. For each register stored, its NaT bit is shifted into the collection register. When the bsp reaches the doubleword just before a 64 doubleword boundary, the RSE stores the collection register. Software can determine the position of the NaT collection registers in the backing store by examining the memory address. This process is described in greater detail in the *Intel® IA-64 Architecture Software Developer’s Manual*. \nThe memory stack is used for local dynamic storage, spilled registers, and parameter passing. It is organized as a stack of *procedure frames*, beginning with the main program’s frame at the base of the stack, and continuing towards the top of the stack with nested procedure calls. At the top of the stack is the frame for the currently active procedure. (There may be some system-dependent frames at the base of the stack, prior to the main program’s frame, but an application program may not make any assumptions about them.)\n\nThe memory stack begins at an address determined by the operating system, and grows towards lower addresses in memory. The stack pointer register, *sp*, always points to the lowest address in the current, top-most, frame on the stack.\n\nEach procedure creates its frame on entry by subtracting its frame size from the stack pointer, and removes its frame from the stack on exit by restoring the previous value of *sp* (usually by adding its frame size, but a procedure may save the original value of *sp* when its frame size may vary).\n\nBecause the register stack is also used for the same purposes, not all procedures will need a stack frame. Every non-leaf procedure, however, needs to save at least its return link and the previous frame marker either on the register stack or in the memory stack, so there is an activation record for every non-leaf procedure on one or both of the stacks.\n\n### 7.1 Procedure Frames\n\nA procedure frame consists of five regions, as illustrated in Figure 7-1.\n\n*Figure 7-1. Procedure Frame*\n\nThese regions are:\n\n- **Local storage.** A procedure may store local variables, temporaries, and spilled registers in this region. For conventions affecting the layout of this area for spilled register (see Section 11.3, “Coding Conventions for Reliable Unwinding” on page 11-5).\n\n- **Dynamically-allocated stack storage.** This is a variable-sized region (initially zero length), that can be created by the C library *alloca* routine and similar routines.\n\n- **Frame marker.** This optional region may contain information required for unwinding through the stack (for example, a copy of the previous stack pointer).\n• **Outgoing parameters.** Parameters in excess of those passed in registers are stored in this region of the stack frame. A procedure accesses its incoming parameters in the outgoing parameter region of its caller’s stack frame.\n\n• **Scratch area.** This 16-byte region is provided as scratch storage for procedures that are called by the current procedure. Leaf procedures do not need to allocate this region. A procedure may use the 16 bytes at the top of its own frame as scratch memory, but the contents of this area are not preserved by a procedure call.\n\nThe stack pointer must always be aligned at a 16-byte boundary. This implies that all stack frames must be a multiple of 16 bytes in size.\n\nAn application may not write to memory below the stack pointer, since this memory area may be written to asynchronously (for example, as a result of exception processing).\n\nMost procedures are expected to have a fixed size frame, and the conventions are biased in favor of this. A procedure with a fixed size frame may reference all regions of the frame with a compile-time constant offset relative to the stack pointer. Compilers should determine the total size required for each region, and pad the local storage area to make the total frame size a multiple of 16 bytes. The procedure may then create the frame by subtracting an immediate constant from the stack pointer in the prologue, and remove the frame by adding the same immediate to the stack pointer in the epilogue.\n\nIf a procedure has a variable-size frame (for example, it contains a call to `alloca`), it should make a copy of `sp` to serve as a frame pointer before subtracting the initial frame size from the stack pointer. It may then restore the previous value of the stack pointer in the epilogue without regard for how much dynamic storage has been allocated within the frame. It may also use the frame pointer to access the local storage region, since offsets from `sp` will vary.\n\nA frame pointer, as described above, is not required, however, provided that the compiler uses an equivalent method of addressing the local storage region correctly before and after dynamic allocation, and provided that the code satisfies conditions imposed by the stack unwind mechanism.\n\nTo expand a stack frame dynamically, the scratch area, outgoing parameters, and frame marker regions, which are always located relative to the current stack pointer must be relocated to the new top of stack. If the scratch area and outgoing parameter area are both clear of any live values, there is no actual work involved in relocating these areas. For procedures with dynamically-sized frames, it is recommended that the previous stack pointer value be stored in a local stacked general register instead of the frame marker, so that the frame marker is also empty. If the previous stack pointer is stored in the frame marker, the code must take care to ensure that the stack is always unwindable while the stack is being expanded (see Chapter 11, “Stack Unwinding and Exception Handling”).\n\nOther issues depend on the compiler and the code being compiled. The standard calling sequence does not define a maximum stack frame size, nor does it restrict how a language system uses any stack frame region beyond those purposes described here. For example, the outgoing parameter region may be used as scratch storage whenever it is not needed for passing parameters.\n8.1 External Naming Conventions\n\nThe standard naming convention, referred to as the “C” convention, specifies that all external symbols have linkage names identical to the source language identifier. There are no leading or trailing underscores. Other languages may establish other conventions, but they should provide a mechanism to define and reference symbols with “C” linkage.\n\n8.2 The gp Register\n\nEvery procedure that references statically-allocated data or calls another procedure requires a pointer to its data segment in the gp register, so that it can access its static data and its linkage tables. Each load module has its own data segment, and the gp register must be set correctly prior to calling any entry point within that load module.\n\nThe linkage conventions require that each load module define exactly one gp value to refer to a location within its short data segment. It is expected that this location will be chosen to maximize the usefulness of short-displacement immediate instructions for addressing scalars and linkage table entries. The DLL loader will determine the absolute value of the gp register for each load module after loading its data segment into memory.\n\nFor calls within a load module, the gp register will remain unchanged, so calls known to be local can be optimized accordingly.\n\nFor calls between load modules, the gp register must be initialized with the correct gp value for the new load module, and the calling function must ensure that its own gp value is saved and restored.\n\n8.3 Types of Calls\n\nThe following types of procedure calls are defined:\n\n- **Direct calls.** Direct calls within the same load module may be made directly to the entry point of the target procedure. In this case, the gp register does not need to be changed.\n\n- **Direct dynamically-linked calls.** These calls are routed through an import stub (which may be inlined at compile time if the call is known or suspected to be to another load module). The import stub obtains the address of the main entry point and the gp register value from the linkage table. Although coded in source as a direct call, dynamically-linked calls become indirect.\n\n- **Indirect calls.** A function pointer must point to a descriptor that contains both the address of the function entry point and the gp register value for the target function. The compiler must generate code for an indirect call that sets the new gp value before transferring control to the target procedure.\n\n- **Special calls.** Other special calling conventions are allowed to the extent that the compiler and the runtime library agree on convention, and provided that the stack may be unwound through such a call. Such calls are outside the scope of this document. See Section 8.7 for a discussion of stack unwind requirements.\n8.4 Calling Sequence\n\nDirect and indirect procedure calls are described in the following sections. Since the compiler is not required to know whether any given call is local or to another load module, the two types of direct calls are described together in the first section.\n\n8.4.1 Direct Calls\n\nDirect procedure calls follow the sequence of steps shown in Figure 8-1. The following paragraphs describe these steps in detail.\n\nFigure 8-1. Direct Procedure Calls\n\nPreparation for call. Values in scratch registers that must be kept live across the call must be saved. They can be saved by copying them into local dynamic registers, or by saving them on the memory stack. If the NaT bits associated with any live scratch registers must be saved, the compiler should use st8.spill or stf.spill instructions. The User NaT collection register itself is preserved by the call, so the NaT bits need no further treatment at this point.\n\nIf the call is not known (at compile time) to be within the same load module, the gp register must be saved.\n\nThe parameters must be set up in registers and memory as described in Section 8.5.\n\nProcedure call. All direct calls are made with a br.call instruction, specifying BR 0 (also known as rp) for the return link.\n\nFor direct local calls, the pc-relative displacement to the target is computed at link time. Compilers may assume that the standard displacement field in the br.call instruction is sufficiently wide to reach the target of the call. If the displacement is too large, the linker must supply a branch stub at\nsome convenient point in the code; compilers must guarantee the existence of such a point by ensuring that code sections in the relocatable object files are no larger than the maximum reach of the \\texttt{br.call} instruction. With a 25-bit displacement, the maximum reach is 16 megabytes in either direction from the point of call.\n\nDirect calls to other load modules cannot be statically bound at link time, so the linker must supply an import stub for the target procedure; the import stub obtains the address of the target procedure from the linkage table. The \\texttt{br.call} instruction can then be statically bound using the pc-relative displacement to the import stub.\n\nThe \\texttt{br.call} instruction saves the return link in the return BR, saves the current frame marker in the \\texttt{ar.pfs} register, and sets the base of the new register stack frame to the beginning of the output region of the old frame.\n\n**Import stub (direct external calls only).** The import stub is allocated in the load module of the caller, so that the \\texttt{br.call} instruction may be statically bound to the address of the import stub. It must access the linkage table via the current \\texttt{gp} (which means that \\texttt{gp} must be valid at the point of call), and obtain the address of the target procedure’s entry point and its \\texttt{gp} value. The import stub then establishes the new \\texttt{gp} value and branches to the target entry point.\n\nIf the compiler knows or suspects that the target of a call is in a separate load module, it may wish to generate calling code that performs the functions of the import stub, saving an extra branch. The detailed operation of an import stub, however, is ABI specific.\n\nWhen the target of a call is in the same load module, an import stub is not used (which also means that \\texttt{gp} must be valid at the point of call).\n\n**Procedure entry.** The prologue code in the target procedure is responsible for allocating the register stack frame, and a frame on the memory stack, if necessary. It may use the 16 bytes at the top of its caller’s memory stack frame as scratch area.\n\nA non-leaf procedure must save the return BR and previous function state, either in the memory stack frame or in a local dynamic GR.\n\nThe prologue must also save any preserved registers that will be used in this procedure. The NaT bits for those registers must be preserved as well, by copying to local stacked general registers, or by using \\texttt{st8.spill} or \\texttt{stf.spill} instructions. The User NaT collection register (\\texttt{ar.unat}) must be saved first, however, since it is guaranteed to be preserved by the call.\n\n**Procedure exit.** The epilogue code is responsible for restoring the return BR and previous function state, if necessary, and any preserved registers that were saved. The NaT bits must be restored using the \\texttt{ld8.fill} or \\texttt{ldf.fill} instructions. The User NaT collection register must also be restored if it was saved.\n\nIf a memory stack frame was allocated, the epilogue code must deallocate it.\n\nFinally, the procedure exits by branching through the return BR with the \\texttt{br.ret} instruction.\n\n**After the call.** Any saved values (including \\texttt{gp}) should be restored.\n8.4.2 Indirect Calls\n\nIndirect procedure calls follow nearly the same sequence, except that the branch target is established indirectly. This sequence is illustrated in Figure 8-2.\n\n**Figure 8-2. Indirect Procedure Calls**\n\n**Function Pointers.** A function pointer is always the address of a function descriptor for the target procedure. The function descriptor must be allocated in the data segment of the target procedure, because it contains pointers that must be relocated by the DLL loader.\n\nThe function descriptor contains at least two 64-bit double-words: the first is the entry point address, and the second is the \\( gp \\) value for the target procedure. An indirect call will load the \\( gp \\) value into the \\( gp \\) register before branching to the entry point address.\n\nIn order to guarantee the uniqueness of a function pointer, and because its value is determined at program invocation time, code must materialize function pointers only by loading a pointer from the data segment. The object file format will provide appropriate relocations for this pointer.\n\n**Preparation for call.** Indirect calls are made by first loading the function pointer into a general register, loading the entry point address and the new \\( gp \\) value, then using the Move to Branch Register operation to move the address of the procedure entry point into the BR to be used for the call.\n\nValues in scratch registers that must be kept live across the call must be saved. They can be saved by copying them into local dynamic registers, or by saving them on the memory stack. If the NaT bits associated with any live scratch registers must be saved, the compiler should use `st8.spill` or `stf.spill` instructions. The User NaT collection register itself is preserved by the call, so the NaT bits need no further treatment at this point.\nUnless the call is known (at compile time) to be within the same load module, the gp register must be saved before the new gp value is loaded.\n\nThe parameters must be set up in registers and memory as described in Section 8.5.\n\n**Figure 8-3. Parameter Passing in General Registers and Memory**\n\n**Procedure call.** All indirect calls are made with the indirect form of the br.call instruction, specifying BR 0 (also known as rp) for the return link.\n\nThe br.call instruction saves the return link in the return BR, saves the current frame marker in the ar.pfs register, and sets the base of the new register stack frame to the beginning of the output region of the old frame. Because the indirect call sequence obtains the entry point address and new gp value from the function descriptor, control flows directly to the target procedure, without the need for any intervening stubs.\n\n**Procedure entry, exit, and return.** The remainder of the calling sequence is the same as for direct calls.\n\n### 8.5 Parameter Passing\n\nParameters are passed in a combination of general registers, floating-point registers, and memory, as described below, and as illustrated in Figure 8-3.\n\nThe parameter list is formed by placing each individual parameter into fixed-size elements of the parameter list, referred to as parameter slots. Each parameter slot is 64 bits wide; parameters larger than 64 bits are placed in as many consecutive parameter slots as are needed to contain the entire parameter. The rules for allocation and alignment of parameter slots are given later in this section.\n\nThe contents of the first eight parameter slots are always passed in registers, while the remaining parameters are always passed on the memory stack, beginning at the caller’s stack pointer plus 16 bytes. The caller uses up to eight of the registers in the output region of its register stack for integer parameters, and up to eight floating-point registers for floating-point parameters.\nTo accommodate variable argument lists in the C language, there is a fixed correspondence between parameter slots and output registers used for general register arguments. This allows a procedure to spill its register parameters easily to memory before stepping through the parameter list with a pointer. Also because of variable argument lists, floating-point parameters are sometimes passed in both general output registers and in floating-point registers.\n\nThere is no fixed correspondence between parameter slots and floating-point parameter registers. Parameters passed in floating-point registers always use the next available floating-point parameter register, starting with f8.\n\nA procedure may assume that the NaT bits on its incoming general register arguments are clear, and that the incoming floating-point register arguments are not NaTVals. A procedure making a call must ensure only that registers containing actual parameters are clear of NaT bits or NaTVals; registers not used for actual parameters may contain garbage.\n\n### 8.5.1 Allocation of Parameter Slots\n\nParameters slots are allocated for each parameter, based on the parameter type and size, treating each parameter in sequence, from left to right. The rules for allocating parameter slots and placing the contents within the slot are given in Table 8-1.\n\n#### Table 8-1. Rules for Allocating Parameter Slots\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Size (Bits)</th>\n<th>Allocation</th>\n<th>Number of Slots</th>\n<th>Alignment</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Integer/Pointer</td>\n<td>1–64</td>\n<td>Next Available</td>\n<td>1</td>\n<td>LSB</td>\n</tr>\n<tr>\n<td>Integer</td>\n<td>65–128</td>\n<td>Next Even</td>\n<td>2</td>\n<td>LSB</td>\n</tr>\n<tr>\n<td>Single-Precision Floating-Point</td>\n<td>32</td>\n<td>Next Available</td>\n<td>1</td>\n<td>LSB</td>\n</tr>\n<tr>\n<td>Double-Precision Floating-Point</td>\n<td>64</td>\n<td>Next Available</td>\n<td>1</td>\n<td>LSB</td>\n</tr>\n<tr>\n<td>Double-Extended Floating-Point</td>\n<td>80</td>\n<td>Next Even</td>\n<td>2</td>\n<td>Byte 0</td>\n</tr>\n<tr>\n<td>Quad-Precision Floating-Point</td>\n<td>128</td>\n<td>Next Even</td>\n<td>2</td>\n<td>Byte 0</td>\n</tr>\n<tr>\n<td>Aggregates</td>\n<td>any</td>\n<td>Next Aligned (size+63)/64</td>\n<td>1</td>\n<td>Byte 0</td>\n</tr>\n</tbody>\n</table>\n\n**NOTE:** These rules are applied based on the type of the parameter after any type promotion rules specified by the language have been applied. For example, a short integer passed without a function prototype in C would be promoted to the `int` type, and would be passed according to the rules for the `int` type.\n\nThe allocation column of the table indicates how parameter slots are allocated for each type of parameter.\n\n- “Next Available” means that the parameter is placed in the slot immediately following the last slot used.\n- “Next Even” means that the parameter is placed in the next available even-numbered slot, skipping an odd-numbered slot if necessary. If an odd-numbered slot is skipped, it will not be used for any subsequent parameters.\n- “Next Aligned” means that the allocation is dependent on the external alignment of the aggregate; that is, on the alignment boundary required for the aggregate as a whole. For aggregates with an external alignment of 1–8 bytes, the “Next Available” policy is used; for aggregates with an external alignment of 16 bytes, the “Next Even” policy is used.\n\nThis placement policy ensures that parameters will fall on a natural alignment boundary if passed in memory.\nThe alignment column of the table indicates how parameters are aligned within a parameter slot. There are two kinds of alignment, “LSB” and “Byte 0.”\n\n- “LSB” alignment specifies that the least-significant bit of the parameter is aligned with the least-significant bit of the argument slot or slots (i.e., right aligned). Parameters shorter than 64 or 128 bits are padded on the left; the padding is undefined (unless specified otherwise). When a pair of parameter slots is required, the even-numbered parameter slot contains the most-significant bits in big-endian environments, and the least-significant bits in little-endian environments. See Figure 8-4 for examples.\n\n- “Byte 0” alignment specifies that byte 0 of the parameter is aligned with byte 0 of the parameter slot. Parameters that are not a multiple of 64 bits in length are padded at the end; the padding is undefined. In big-endian environments, the padding will be at the right end of the final parameter slot; in little-endian environments, the padding will be at the left end of the final parameter slot. See Figure 8-5 for an example.\n\n8.5.2 Register Parameters\n\nThe first eight parameter slots (64 bytes) are passed in registers, according to the rules in this section.\n\n- These eight argument slots are associated, one-to-one, with the stacked output GRs, as shown in Figure 8-3.\n- Integral scalar parameters, quad-precision (128-bit) floating-point parameters, and aggregate parameters in these slots are passed only in the corresponding output GRs. Aggregates consisting solely of floats, of doubles, or of double-extended values are an exception; see below.\n- If an aggregate parameter straddles the boundary between slot 7 and slot 8, the part that lies within the first eight slots is passed in GRs, and the remainder is passed in memory, as described in the next section.\n\nSingle-precision, double-precision, and double-extended-precision floating-point scalar parameters in these slots are passed according to the available formal parameter information at the point of call (for example, from a function prototype).\n\nIf an actual parameter is known to correspond to a floating-point formal parameter, the following rules apply:\n\n- The actual parameter is passed in the next available floating-point parameter register, if one is available. Floating-point parameter registers are allocated as needed from the range f8–f15, starting with f8.\n- If all available floating-point parameter registers have been used, the actual parameter is passed in the appropriate general register(s). (This case can occur only as a result of homogeneous floating-point aggregates, described below.)\n\nIf a floating-point actual parameter is known to correspond to a variable-argument specification in the formal parameter list, the following rule applies:\n\n- The actual parameter is passed in the appropriate general register(s).\n\nIf the compiler cannot determine, at the point of call, whether the corresponding formal parameter is a varargs parameter, it must generate code that satisfies both of the above conditions. (The compiler’s determination may be based on prototype declarations, language standard assumptions, analysis, or other user options or information.)\nWhen floating-point parameters are passed in floating-point registers, they are passed in the register format, rounded to the appropriate precision. When passed in general registers, floating-point values are passed in their memory format.\n\nParameters allocated beyond the eighth parameter slot are never passed in registers, even when floating-point parameter registers remain unused.\n\n**Figure 8-4. Examples of “LSB” Alignment**\nAggregates whose elements are all single-precision, all double-precision, or all double-extended-precision values (but not quad-precision), are treated specially. These “homogeneous floating-point aggregates” (HFAs) may be arrays of one of these types, structures whose only members are all one of these types, or structures that contain other structures, provided that all lowest-level members are one of these types, and all are the same type. (This definition includes Fortran COMPLEX data, except COMPLEX*32.)\n\nThe following additional rules apply to these types of parameters (but only to the portion of an aggregate that lies within the first eight argument slots):\n\n- If an actual parameter is known to correspond to an HFA formal parameter, each element is passed in the next available floating-point argument register, until the eight argument registers are exhausted. The remaining elements of the aggregate are passed in output GRs, according to the normal conventions.\n- If an actual parameter is known to correspond to a variable-argument specification, the aggregate is passed as any other aggregate.\n\nIf the compiler cannot determine, at the point of call, whether the corresponding formal parameter is a varargs parameter, the elements of the aggregate must be passed in both the corresponding output GRs and in floating-point argument registers.\n\n**Note:** Because HFAs are mapped to parameter slots as aggregates, single-precision HFAs will be allocated with two floating-point values in each parameter slot, but only one value per register. Thus, the available floating-point parameter registers may become exhausted before the end of the first eight parameter slots, and additional members of the HFA must be passed in general registers.\n\nIt is possible for the first of two values in a parameter slot to occupy the last available floating-point parameter register. In this case, the second value is passed in its designated GR, but the half of the GR that would have contained the first value is undefined.\n8.5.3 Memory Stack Parameters\n\nThe remainder of the parameter list, beginning with slot 8, is passed in the outgoing parameter area of the memory stack frame, as described in Section 7.1, “Procedure Frames” on page 7-1. Parameters are mapped directly to memory, with slot 8 placed at location sp+16, slot 9 at sp+24, and so on. Each argument slot is stored in memory as a 64-bit storage unit according to the byte order of the current environment.\n\n8.5.4 Variable Argument Lists\n\nThe rules above support variable-argument list functions in both the K&R and the ANSI dialects of the C language. When an ANSI prototype is in scope, any register parameters corresponding to a variable-argument specification are passed in GRs. When no prototype is in scope, a strict ANSI compilation may pass parameters as if a non-variable argument prototype were in scope, while a K&R (or more relaxed ANSI) compilation may pass floating-point parameters in both GRs and FRs to deal with the possibility that the callee may be expecting either a variable or a non-variable argument list.\n\nThus, a function with variable arguments may assume that the variable arguments that lie within the first eight argument slots can all be found in the stacked input GRs, in0–in7. It may then store these registers to memory, using the 16-byte scratch area for in6 and in7, and using up to 48 bytes at the base of its own stack frame for in0–in5, as necessary. This arrangement places all the variable parameters in one contiguous block of memory.\n\nWhen storing registers to memory for this purpose, the code must use the st8.spill instruction, since the registers are not guaranteed to contain valid values.\n\nIn a big-endian environment, the alignment and padding rules require the code that steps through the argument list to distinguish between aggregates and integers smaller than 8 bytes. Aggregates will be left-aligned within an 8-byte slot, while integers will be right-aligned.\n\nExamples of the macros from the <stdarg.h> header file are given in Appendix A.\n\n8.5.5 Pointers to Formal Parameters\n\nWhenever the address is formed of a formal parameter that is passed in a register, the compiler must store the parameter to the stack, as it would for a variable argument list.\n\n8.5.6 Languages Other than C\n\nMost languages other than C can usually be treated as if prototypes are always in scope, avoiding the need to pass floating-point parameters in both GRs and FRs. For example, because Fortran passes floating-point parameters by value only when calling an intrinsic function, it may safely assume that the callee is expecting the parameter in an FR.\n\nA compiler for another language may need to honor the variable-argument list conventions, however, if it provides a mechanism for calling C procedures that may have variable-argument lists.\n8.5.7 Rounding Floating-point Values\n\nFloating-point parameters passed in floating-point registers should always be explicitly rounded to the proper precision expected by the language. There should be no difference in behavior between a floating-point parameter passed directly in registers and a floating-point parameter that has been stored to memory and reloaded.\n\n8.5.8 Examples\n\nThe following examples illustrate the parameter passing conventions.\n\nScalar integers and floats, with prototype:\n\nextern int func(int, double, double, int);\nfunc(i, a, b, j);\n\nThe parameters are passed as follows:\n\n\\[\n\\begin{align*}\ni & \\quad \\text{out0} \\\\\na & \\quad f8 \\\\\nb & \\quad f9 \\\\\nj & \\quad \\text{out3}\n\\end{align*}\n\\]\n\nScalar integers and floats, without prototype:\n\nextern int func();\nfunc(i, a, b, j);\n\nThe parameters are passed as follows:\n\n\\[\n\\begin{align*}\ni & \\quad \\text{out0} \\\\\na & \\quad \\text{out1 and f8} \\\\\nb & \\quad \\text{out2 and f9} \\\\\nj & \\quad \\text{out3}\n\\end{align*}\n\\]\n\nAggregates passed by value:\n\nextern int func();\nstruct { int array[20]; } a;\nfunc(i, a);\n\nThe structure’s external alignment is only 4 bytes, so no padding is required in the parameter list. The parameters are passed as follows:\n\n\\[\n\\begin{align*}\ni & \\quad \\text{out0} \\\\\na.array[0–13] & \\quad \\text{out1–out7} \\\\\na.array[14–19] & \\quad \\text{In memory, at sp+16 through sp+39}\n\\end{align*}\n\\]\n\nAggregates passed by value:\n\nextern int func();\nstruct { __float128 x; int array[20]; } a;\nfunc(i, a);\nThe structure’s external alignment is 16 bytes, so parameter slot 1 is skipped. The parameters are passed as follows:\n\n```\ni out0\na.x out2-out3\na.array[0-7] out4-out7\na.array[8-19] In memory, at sp+16 through sp+63\n```\n\n**Floating-point aggregates, without prototype:**\n\n```c\ndefine struct s { float a, b, c; } x;\ndefine extern func();\ndefine func(x);\n```\n\nThe parameters are passed as follows:\n\n```\nx.a out0 and f8\nx.b out0 and f9\nx.c out1 and f10\n```\n\nIn little-endian environments, x.a and x.c are in the least-significant bits of out0 and out1, respectively, while x.b is in the most-significant bits of out0. In big-endian environments, x.a and x.c are in the most-significant bits of out0 and out1, respectively, while x.b is in the least-significant bits of out0. The figure below illustrates this.\n\n\n\n**Floating-point aggregates, with prototype:**\n\n```c\ndefine struct s { float a, b, c; } x;\ndefine extern void func(struct s); \ndefine func(x);\n```\n\nThe parameters are passed as follows:\n\n```\nx.a f8\nx.b f9\nx.c f10\n```\n8.6 Return Values\n\nValues up to 256 bits and certain aggregates are returned directly in registers, according to the rules in Table 8-2.\n\nTable 8-2. Rules for Return Values\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Size (Bits)</th>\n<th>Location of Return Value</th>\n<th>Alignment</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Integer/Pointer</td>\n<td>1–64</td>\n<td>r8</td>\n<td>LSB</td>\n</tr>\n<tr>\n<td>Integer</td>\n<td>65–128</td>\n<td>r8, r9</td>\n<td>LSB</td>\n</tr>\n<tr>\n<td>Single-Precision Floating-Point</td>\n<td>32</td>\n<td>f8</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Double-Precision Floating-Point</td>\n<td>64</td>\n<td>f8</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Double-Extended Floating-Point</td>\n<td>80</td>\n<td>f8</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Quad-Precision Floating-Point</td>\n<td>128</td>\n<td>r8, r9</td>\n<td>Byte 0</td>\n</tr>\n<tr>\n<td>Single-Precision HFA</td>\n<td>32–256</td>\n<td>f8–f15</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Double-Precision HFA</td>\n<td>64–512</td>\n<td>f8–f15</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Double-Extended HFA</td>\n<td>128–1024</td>\n<td>f8–f15</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Aggregates 1–64</td>\n<td>1–64</td>\n<td>r8</td>\n<td>Byte 0</td>\n</tr>\n<tr>\n<td>Aggregates 65–256</td>\n<td>65–256</td>\n<td>r8–r11</td>\n<td>Byte 0</td>\n</tr>\n<tr>\n<td>Aggregates >256</td>\n<td>>256</td>\n<td>Memory</td>\n<td>Byte 0</td>\n</tr>\n</tbody>\n</table>\n\nWhen multiple registers are used to return a numeric value, the lowest-numbered register contains the most-significant bits in big-endian environments, and the least-significant bits in little-endian environments. When multiple registers are used to return an aggregate, the lowest-numbered register contains the first eight bytes of the aggregate. In big-endian environments, the padding will be at the right end of the final register used; in little-endian environments, the padding will be at the left end of the final register used.\n\nIntegral return values smaller than 32 bits must be zero-filled (if unsigned) or sign-extended (if signed) to at least 32 bits.\n\nWhen floating-point parameters are returned in floating-point registers, they are returned in the register format, rounded to the appropriate precision. When they are returned in general registers (e.g., as part of an aggregate), they are returned in their memory format.\n\nHomogeneous floating-point aggregates, as defined in Section 8.5, are returned in floating-point registers, provided the array or structure contains no more than eight individual values. The elements of the aggregate are placed in successive floating-point registers, beginning with f8. If the array or structure contains more than eight elements, it is returned according to the rule below for aggregates larger than 256 bits.\n\nReturn values larger than 256 bits (except HFAs of up to 8 elements) are returned in a buffer allocated by the caller. A pointer to the buffer is passed to the called procedure in r8. This register is not guaranteed to be preserved by the called procedure (that is, the caller must preserve the address of the buffer through some other means). The return buffer must be aligned at a 16-byte boundary. A procedure may assume that the return buffer does not overlap any data that is visible to it through any other names.\n\nA procedure may assume that any procedure it calls will return a valid value (i.e., the NaT bits are clear if the return is in general registers, and floating-point values returned are not NaTVals).\n8.7 Requirements for Unwinding the Stack\n\nCertain constraints must be met in order to unwind the stack successfully at any time, both by standard procedure calls as described here, and by special-purpose calling conventions. Chapter 11, “Stack Unwinding and Exception Handling,” describes how the unwind process works and the format of the unwind data structures. To meet the needs of the stack unwind mechanism, the following rules must be followed at all times:\n\n- The previous function state register (sr.pfs) must be preserved prior to any call. The compiler must record, in the unwind data structures, where this register is stored, and over what range of code the saved value is valid.\n\n- For special calls using a return BR other than b0, the compiler must record the BR number used for the return link.\n\n- The return BR must be preserved prior to any call involving the same BR. The compiler must record where the return BR is stored and over what range of code the saved value is valid.\n\n- If a procedure has a memory stack frame, the compiler must record either: (1) how large the frame is, or (2) that a previous frame pointer is stored on the stack or in a general register.\n\n- The return BR must contain an address that can be used to determine the unwind state of the calling procedure. For example, a compiler may choose to optimize calls to procedures that do not return. If it does so, however, it must ensure that the unwind information for the procedure properly describes the unwind state at the return point, even though the return pointer will never be used. This may require the insertion of an otherwise unnecessary nop or break instruction.\nThis chapter discusses general coding conventions and presents some example code sequences for various tasks. The code sequences shown in this chapter are intended to serve as guidelines and examples rather than as required coding conventions. The requirements are documented in other chapters in this document.\n\n9.1 Sample Code Sequences\n\nIn the sample code sequences in this section, registers of the form \\( t1 \\), \\( t2 \\), etc., are temporary registers, and may be assigned to any available scratch register. The code sequences show necessary cycle breaks, but no other scheduling considerations have been made. It is assumed that these code sequences will be scheduled with surrounding code to make best use of the processor resources.\n\n9.1.1 Addressing “own” Data in the Short Data Area\n\n“Own” short data may be addressed with a simple direct reference relative to the \\( gp \\) register, as illustrated below.\n\n```\naddl t1=@gprel(var),gp ;; // calc. address of var\nld8 loc0=[t1] // load contents of var\n```\n\n“Own” long data may be addressed either via the linkage table, as shown in Section 9.1.2, or directly as illustrated below.\n\n```\nmovl t1=@ltoff(var),gp ;; // form gp-relative offset of var\nadd t2=t1,gp ;; // calc. address of var\nld8 loc0=[t2] // load contents of var\n```\n\n9.1.2 Addressing External Data or Data in a Long Data Area\n\nWhen data is not known to be defined in the current load module (i.e., it is not “own”), or if it is too large for the short data region, it must be accessed indirectly through the linkage table, as shown below.\n\n```\naddl t1=@ltoff(var),gp ;; // calc. address of LT entry\nld8 t2=[t1] ;; // load address of var\nld8 loc0=[t2] // load contents of var\n```\n9.1.3 Addressing Literals in the Text Segment\n\nLiterals in the text segment may be addressed either through the linkage table, as in Section 9.1.2 above, or with pc-relative addressing, as shown below. Note that the first two instructions may be moved towards the beginning of the procedure, and the base address of the literal area, in loc0, can be shared by other literal references in the same procedure.\n\nL1: mov r3=ip ;; // get current IP\n addl loc0=litbase-L1,r3 ;; // calc. addr. of lit. area\n add s t2=(lit-litbase),loc0 ;; // calc. address of lit.\n ld8 loc1=[t2] // load value of literal\n\n9.1.4 Materializing Function Pointers\n\nFunction pointers must always be obtained from the data segment, either as an initialized word or through the linkage table, as shown in the following examples:\n\nMaterializing function pointers through linkage table:\n\n addl t1=@@loff(@fptr(func)),gp ;; // calc address of LT entry\n ld8 loc0=[t1] // load function pointer\n\nMaterializing function pointers in data:\n\nfptr:\n data8 @fptr(func) // initialize function ptr\n\n9.1.5 Direct Procedure Calls\n\nThe following code sequence illustrating a direct procedure call assumes that the parameters have already been placed in the proper locations.\n\n mov loc0=gp ;; // save current gp\n br.call rp=func ;; // make the call\n mov gp=loc0 // restore gp\n\n9.1.6 Indirect Procedure Calls\n\nThe indirect procedure call sequence must load the function’s entry point and gp value from the function descriptor. In this example, the function pointer is assumed to have been loaded into register loc0.\n\n mov loc1=gp ;; // save current gp\n ld8 t1=[loc0],8 ;; // load entry point\n ld8 gp=[loc0] ;; // load new gp value\n mov b6=t1 ;; // move ep to call BR\n br.call rp=b6 ;; // make the call\n mov gp=loc1 // restore gp\n9.1.7 Jump Tables\n\nHigh-level language constructs such as case and switch statements, where there are several possible local targets of a branch, may use a number of different code generation strategies, ranging from sequential conditional branches to a direct-lookup branch table.\n\nIf the compiler chooses to generate a branch table, the table should be placed in the text segment, and each table entry should be a 64-bit byte displacement from the base of the branch table to the branch target for that entry. This allows the displacements to be statically determined at link time, and no relocations will need to be applied at program invocation time. With displacements relative to the base address of the branch table, the code can easily add the displacement obtained from the table to the base address of the table to compute the target branch address.\n\nA sample indirect branch is shown below. The branch table is assumed to be an array of 64-bit entries, each of which is an offset, relative to the beginning of the branch table, to the branch target. The branch table index is assumed to have been computed or loaded into register loc0.\n\n```assembly\naddl loc1=@ltoff(brtab),gp ;; // calc. address of\n // linkage table entry\nld8 loc2=[loc1] ;; ;; // load addr. of br. table\nshladd loc3=loc0,3,loc2 ;; ;; // calc. address of branch\n // table entry\nld8 loc4=[loc3] ;; ;; // load branch table entry\nadd loc5=loc4,loc2 ;; ;; // calc. target address\nmov b6=loc5 ;; ;; // move address to b6...\nbr.cond b6 ;; ;; // ...and branch\n```\n\nAlternatively, the code could use a pc-relative addressing sequence to obtain the base address of the jump table, using code similar to that in Section 9.1.3.\n\n9.2 Speculation\n\nData speculation, using advanced load instructions, across procedure calls will not work correctly if the target of the advanced load is not one of the registers in the in/local region of the register stack frame. Upon return from the procedure call, the information in the ALAT could refer to an unchecked (or uncleared) advanced load to the same register from within the called procedure, rather than the information from the original load prior to the call.\n\nSpeculation recovery code may be placed within the procedure, outside the procedure but contiguous with it, or in a completely different section of memory. In any case, the target of the check instruction must be placed in or contiguous with the procedure in order to guarantee that a 22-bit pc-relative displacement in the check instruction will reach the target. If the recovery code is distant, the target of the check instruction may be a small piece of “trampoline” code that branches to the recovery code.\n\nIf a speculative load is issued to an unaligned address, the OS may deliver a NaT. An application cannot expect to use a user-level trap handler to emulate the unaligned load unless the code is compiled with recovery code.\n9.3 Multi-threaded Code\n\nIn multi-threaded applications, the use of the `volatile` type qualifier should be interpreted to mean that the variables designated with that type may be modified asynchronously by any thread. The compiler must observe ordering restrictions with respect to loads and stores, and should not remove otherwise unnecessary memory references to these variables.\n\nIn addition, the compiler must generate appropriate ordered load and store instructions to prevent the hardware from executing volatile references out of order. All loads to a volatile type must use acquire semantics (using the “.acq” completer), and all stores to a volatile type must use release semantics (using the “.rel” completer). These completers ensure that no load will complete prior to an earlier load with acquire, and all earlier stores will complete prior to a subsequent store with release.\n\nThe use of a memory fence operation prior to a load with acquire implements stronger ordering, but is not required by these conventions.\n\n9.4 Use of Temporary Registers around the Call to `setjmp`\n\n*Implementation Note:* The contents of a procedure’s register stack frame are not preserved in a jump buffer by a call to `setjmp`. If the compiler has a temporary value live in a stacked register before the call to `setjmp`, with a subsequent use after the call to `setjmp`, that value will not be saved and restored by a `setjmp/longjmp`. Instead, after a `longjmp`, the register will have whatever value it had at the point in time when `longjmp` was called. If the original value reaches all subsequent call points in the procedure, the code will behave as expected. If the register is reused or otherwise modified, however, the value in that register following a `longjmp` is unpredictable.\n\nTo keep a stacked register live across a call to `setjmp`, the compiler can do one of three things: (1) dedicate that register for the rest of the procedure, (2) copy it to a real preserved register (`r4–r7`), or (3) spill it to a dedicated memory stack location. Alternatively, the compiler can simply rematerialize it after the call to `setjmp`.\n\nSee Section 10.3 for more information on `setjmp` and `longjmp`.\n\n9.5 Up-level Referencing\n\nLocal variables visible to nested procedures must be saved in memory at any procedure call or exception control point; a procedure’s local registers are not visible to its nested procedures.\n\nThese conventions suggest, but do not require, the use of a static link passed as an implicit parameter to nested procedures. The static link can be used by the nested procedure to access local variables in its enclosing scope. The rules for forming and passing static links are as follows:\n\n- A level-one procedure (outermost) calling a level-two procedure should pass, as the static link, the address of a known reference point within its stack frame (for example, its frame pointer).\n- A nested procedure calling another procedure at the same level should pass, as the static link, the static link that it received.\n• A nested procedure calling a procedure nested within it should store the static link that it received at a known place within its own stack frame, then pass, as the static link to the new procedure, the address of a known reference point within its own stack frame (for example, a pointer to the static link that it saved).\n\n• A nested procedure calling a less-deeply nested procedure must follow the chain of static links to obtain the correct static link to pass.\n\nWhen forming function pointers that refer to nested procedures, the same rules apply. The static link must be determined at the time the function pointer is materialized, and stored with the function pointer.\n\nTo reference local variables in enclosing scopes, the chain of static links must be followed to obtain a pointer to the enclosing scope’s stack frame. The compiler can determine statically the offset of the desired local variable relative to the reference point used for the static link.\n\nAn alternate implementation is a display pointer, also passed as an implicit parameter to each nested procedure.\n\n## 9.6 C++ Conventions\n\nLanguage specific conventions for C++ are beyond the scope of this document, although they must be built upon the base set of software conventions provided here.\n\n<Move the below to ABI document>\n\nThe “this” pointer is passed as an implicit first parameter to all non-static class member functions.\n\nAny object that requires a copy constructor must be passed by copy-reference rather than by value (that is, the compiler must copy it to a temporary location in memory and pass the address of this location in the argument list). This guarantees that the object will have a valid memory address as required by the copy constructor. The temporary location should be in the caller’s memory stack frame.\n10.1 Process/Thread Context\n\nThe following table lists the resources that constitute the context that is visible to the user-mode process or thread (not including the program’s address space). These are the registers that must be saved and restored on an asynchronous context switch (i.e. a context switch triggered by an outside event, such as a signal). For a synchronous context switch (i.e. a direct call to a context-switch routine), scratch registers do not need to be saved.\n\n<table>\n<thead>\n<tr>\n<th>Resource</th>\n<th>Synchronous</th>\n<th>Asynchronous</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Instruction pointer (ip)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Global data pointer (gp)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Stack pointer (sp)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Thread pointer (tp)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Backing store pointer (ar.bsp/ar.bspstore)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Floating-point status register (ar.fpsr)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>RSE NaT collection register (ar.rnat)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>User NaT collection register (ar.unat)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Previous function state (ar.pfs)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Current frame marker</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>RSE control register (ar.rsc)</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Loop counter (ar.lc)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Epilogue counter (ar.ec)</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Compare and exchange comparison value (ar.ccv)</td>\n<td></td>\n<td>•</td>\n</tr>\n<tr>\n<td>Preserved general registers (r4-r7) (including NaT bits)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Scratch general registers (r2-r3, r8-r11, r14-r31) (including NaT bits)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Preserved floating-point registers (f2-f5, f16-f31)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Scratch floating-point registers (f6-f15, f32-f127)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Preserved predicate registers (p1-p5, p16-p63)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Scratch predicate registers (p6-p15)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Preserved branch registers (b1-b5)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Scratch branch registers (b0, b6-b7)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Scratch reserved for future use (ar.cssd)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n<tr>\n<td>Scratch reserved for future use (ar.ssd)</td>\n<td>•</td>\n<td>•</td>\n</tr>\n</tbody>\n</table>\n\n**Note:** The User NaT collection register must be saved separately from the NaT bits for the general registers, since it contains the NaT bits for preserved general registers that a procedure has spilled on behalf of its caller. This register must be saved before any general registers are saved, as the\nsaving of general registers writes to this register. Once the general registers have been saved as part of the state save procedure, the User NaT collection register will contain the NaT bits for the newly-saved registers, and can then be saved again.\n\n10.2 User-level Thread Switch, Coroutines\n\nThread switches and coroutine calls can be done with a procedure call, so no scratch registers need to be saved as part of the context. The first part of this routine saves the current thread context on the stack:\n\n1. Save ar.rsc, ar.bsp and ar.pfs.\n2. Use flushrs instruction to flush dirty registers to the backing store.\n3. Set the RSE in enforced lazy mode by clearing both rsc.mode bits.\n4. Save ar.rnat and other registers that must be saved for a synchronous context switch.\n\nAt this point, the RSE is frozen, and all dynamic registers up to the current procedure frame are saved in the backing store. We can now change the memory stack pointer (sp) to point to the new thread’s stack, and restore the new thread’s context from there:\n\n1. Invalidate the ALAT using the invala instruction.\n2. Restore ar.bspstore (the saved ar.bsp).\n3. Restore ar.rnat and ar.pfs.\n4. Restore ar.rsc. If eager loads are enabled, it will begin restoring dynamic registers from previous stack frames. Otherwise, it will restore registers from the backing store when needed for a return branch.\n5. Restore the remaining preserved registers.\n6. Return to the new thread.\n\n10.3 setjmp/longjmp\n\nThe setjmp and longjmp routines provide a mechanism to save and restore a particular context within a running thread. The effect is similar to a synchronous thread switch, except that the new context must always be a frame that is still active on the stack of the current thread. Set jmp must save, and long jmp must restore, all of the resources listed in Table 10-1 for a synchronous context switch, with the following exceptions:\n\n- The thread pointer need not be saved and restored, because long jmp may not be used to jump to a context established by a different thread.\n- The state of the RSE needs to be saved only to the extent that long jmp can reestablish the same register stack frame that was active when set jmp was called. The contents of the local stacked registers do not need to be saved and restored.\n\nImplementation Note: The values of the backing store pointer (ar.bsp) and the previous function state (ar.pfs, which preserves the current frame marker associated with the caller of set jmp) are sufficient to record the RSE state for a subsequent long jmp. Set jmp need not, and should not, flush the RSE. Long jmp should determine if\nthe target frame lies partially in the physical registers or not; if so, it must then flush the RSE before restoring the saved register stack frame.\n\nThe \\texttt{gp} register does not need to be saved in the \\texttt{jmpbuf}, because the compiler must always restore \\texttt{gp} after the call to \\texttt{setjmp}, as it must after a call to any other non-local procedure.\n\nThe RSE NaT collection register (\\texttt{ar.rnat}) must not be saved in the \\texttt{jmpbuf}, because that could put the NaT bits out of sync with the local stacked registers. If \\texttt{ar.rnat} were saved in the \\texttt{jmpbuf}, but a local stacked register is modified later in the same procedure that called \\texttt{setjmp} but before \\texttt{longjmp} is called, the change to the value of the register would be visible after the \\texttt{longjmp}, but the change in the NaT bit would not be. Thus, the NaT bits must come from the backing store at the time of the \\texttt{longjmp}; if the current \\texttt{ar.rnat} is valid for the target frame, \\texttt{longjmp} does not need to change it.\n\nThe user NaT collection register (\\texttt{ar.unat}) is itself a preserved register, and must be saved in the jump buffer before any preserved general registers are spilled. The bits in this register represent the NaT bits for registers that were preserved by the caller of \\texttt{setjmp}.\n\nThe NaT bits for the preserved registers will be copied to \\texttt{ar.unat} as each register is spilled to the \\texttt{jmpbuf}. Once the preserved registers have been spilled, \\texttt{ar.unat} must be saved once again to preserve the NaT bits corresponding to the registers preserved by \\texttt{setjmp} itself. When saving this set of NaT bits, care must be taken that the representation is not dependent on the address of the jump buffer itself: the \\texttt{st8.spill} instruction saves the NaT bit in \\texttt{ar.unat} based on the memory address.\n\nThe implementation of \\texttt{longjmp} must invalidate the ALAT.\nStack unwinding is the process of tracing backwards through a process’ stack of activation records. Every procedure in an Itanium architecture program has at least a frame on the register stack, and may also have a frame on the memory stack. In order to print a stack trace, debuggers require the ability to identify every frame on these stacks, and to show the process context associated with each one. Exception handling often requires the ability to remove a number of frames from the stack and to transfer control to an exception handling routine that may have been far down the stack.\n\nFor the register stack, the ar.pfs register contains sufficient information to identify the previous frame, given the state of the current register stack frame. This works for only one level of nesting, however, since there is no architected stack of ar.pfs registers. Thus, in order to unwind the register stack, we must impose a convention for saving and recovering the ar.pfs register in each frame.\n\nFor the memory stack, there is no architected mechanism for recording the sp value for each stack frame, or for associating memory stack frames with register stack frames. While different procedures will need differently-sized stack frames, we expect that most procedures will allocate a frame whose size does not change while the procedure is active. Thus, for most procedures, we can simply record this fixed frame size in a static table, and use the instruction pointer (IP) as a key to this table. For procedures whose frames can vary in size, we must impose a convention for saving and recovering the sp value for the previous frame on the stack.\n\nAs the stacks are unwound, it is also necessary to recover the values of preserved registers that were saved by each procedure in the activation stack, so that debuggers have access to correct values of local variables, and so that exception handlers can operate correctly. This requirement also imposes conventions for saving and recovering the values of these preserved registers.\n\nIn all cases, we wish to retain as much flexibility as possible for the compiler in its use of registers and code generation. Thus, these conventions allow the compiler to save the necessary values in a variety of locations, and with a variety of code sequences. We use the IP as a key for locating an unwind table entry that describes everything necessary for locating the previous register and memory stack frames, as well as the previous IP. The compiler is responsible for generating this static unwind table entry for each procedure that it generates code for.\n\nIn most operating environments, unwinding the stack will be done via an unwind library that can be called from the process itself, from a debugger, or for exception handling. It operates on context records; the primary routine reconstructs the context for a previous frame given the context for its descendent frame. Because the structure of a context record, and the interface between the operating system and exception handling mechanism is environment dependent, this unwind library is also environment-dependent, and is not defined as part of the runtime architecture. This chapter describes the framework for unwinding the stack and for processing exceptions, including the format of the static unwind tables constructed by the compilers, and the code generation conventions imposed as a result.\n11.1 Unwinding the Stack\n\nThe process of unwinding the stack begins with an initial context record describing the process state in the most recent procedure activation, at the point of interruption. From this initial state, the stack is unwound one procedure frame at a time, using static information generated by the compilers about each procedure to help it reconstruct a context record describing the previous procedure, which is suspended at a point just after the procedure call or an asynchronous interruption.\n\n11.1.1 Initial Context\n\nEvery stack unwind starts with an initial context, obtained from one of three sources:\n\n- The debugger. The context record is obtained from the operating system through the debugging API.\n- The unwind library. The context is constructed as for the first half of a user-mode thread switch.\n- From exception handler. The context is constructed by the operating system and passed to the exception handler.\n\n11.1.2 Step to Previous Frame\n\nThis process builds a context record corresponding to the next older frame on the stack. This context record can, in turn, be used to unwind to the next frame. The following steps will reconstruct the context for the previous frame:\n\n1. Find the return link in the current context, and set IP in the previous context to that address.\n2. Find the previous frame marker in the current context (e.g., in the ar.pfs register), and copy it to the current frame marker (cfm) in the previous context.\n3. Determine the value of gp for the new IP, and set gp in the previous context to that value.\n4. Set sp in previous context to sp from current context plus the current memory frame size.\n5. Set ar.bsp in the previous context to ar.bsp from the current context minus size of the input/local region of the frame (taking NaT collections that may have been saved to the backing store into account). The frame size can be calculated from the frame marker.\n6. Find the saved copies of the preserved registers in the current context, and copy them to the previous context.\n\nThe bottom of the call stack is identified by a saved return link of 0.\n\nThe information needed to execute these steps correctly is recorded by the compilers in static unwind information, stored in the text segment of the program itself. The structure of this information is described in Section 11.4. Each text segment contains a table of unwind information, and the dynamic loader is expected to provide an API for finding the unwind table, given a known IP. This API is specific to the operating environment, and is not described here.\n\nWhen a process is delivered an asynchronous interruption (via a mechanism that is environment dependent), the full process context needs to be saved so that the process can continue executing correctly once the interruption has been handled. Typically, this context will be saved on the memory stack, and a new procedure frame will be constructed for the interruption handler. The first procedure frame in the interruption processing must be marked in such a way that the unwind\nroutine can recognize that unwinding past the point of interruption requires a restoration of the full context. This, unfortunately, is also an environment-dependent operation, and cannot be described in the runtime architecture.\n\nWhen the operating system delivers a context to the application, it may be necessary for the register stack backing store to be split into two or more non-contiguous pieces. An application that examines its backing store should be prepared to deal with this; this also is an environment-dependent operation.\n\n### 11.2 Exception Handling Framework\n\nThe exception handling model for Itanium architecture is partitioned into a language-independent component and a language-dependent component. The language-independent component is responsible for fielding an exception, searching for an exception handler, and unwinding the stack prior to processing an exception. Each source language that supports exception handling must provide, as part of its runtime library, a “personality” routine that implements the language-dependent component of this model.\n\n*This document uses the C++ exception handling mechanism as an example of the language-dependent component. The description of the C++-specific data structures and routines should be treated as an example, rather than a specification of the C++ design. Text that discusses language-specific implementation appears indented and italicized like this paragraph.*\n\nThe exception handling model is oriented around procedure frames on the memory and register stacks. Each frame corresponds to an activation of a procedure, which may or may not have associated exception handling requirements. A procedure may have two kinds of exception handling requirements:\n\n- It may allocate some objects that require deallocation or some other form of cleanup if the procedure or any of its blocks are terminated abnormally.\n- It may have one or more try regions, which are regions of code that specify an action to be taken if an exception occurs while control is within them.\n\nIn either of these cases, the compiler records the requirements in the static unwind information for the procedure, and stores a reference to the personality routine for that procedure. Typically, a language will use a single personality routine for all procedures, but this is not a requirement (for example, a language may define a separate personality routine for procedures that require cleanup, but have no try regions.)\n\nTry regions may be nested both statically, within the procedure, and dynamically, through procedure calls. When an exception occurs, each try region is inspected to determine if it has specified an action for that particular exception. The try regions are inspected in order, beginning with the innermost region.\n\n*In C++, a try/catch statement defines a try region, and the filter controls which exceptions are to be caught and handled within that region.*\n\nExceptions are raised by invoking a routine in the language-independent component called the exception dispatcher, which initiates the process of handling the exception. Synchronous exceptions may be raised directly by the application through a language-specific construct; asynchronous exceptions may be raised in response to hardware-detected traps or faults.\nIn C++, synchronous exceptions can be raised with the `throw` statement. This statement creates an exception object, which is matched against the prototype in each `catch` clause for each active `try` statement. C++ does not define asynchronous exceptions.\n\nThe dispatcher unwinds each frame on the stack non-destructively, beginning with the topmost frame, searching for frames with one or more `try` regions. For each frame that has exception handling information, the dispatcher invokes the personality routine, which determines which `try` regions, if any, are currently active. For each active `try` region, starting with the most deeply nested one, the personality routine determines whether to dismiss the exception, handle it, or continue the search with the next `try` region, or with the previous frame on the stack. If the personality routine does find a `try` region with a handler for the exception, it invokes the unwinder to unwind the stack a second time. During this second unwind, the unwinder invokes the personality routines for each frame again so that cleanup actions may be executed as necessary. When the unwind reaches the frame that contains the exception handler, control is transferred to the handler.\n\nThe relationships among these components are illustrated in Figure 11-1. The shaded boxes identify the components that are specific to C++.\n\n**Figure 11-1. Components of the Exception Handling Mechanism**\n\n\n11.3 Coding Conventions for Reliable Unwinding\n\nThis section describes the coding conventions that must be observed to guarantee unwindability from every point in the program. For the purposes of unwinding, we divide every procedure up into one or more regions, which are classified as either “prologue” or “body” regions.\n\nA “prologue” region is one where the register stack and memory stack frames are established and where key registers are saved. In order to unwind correctly when the IP is in one of these regions, the unwinder must have a detailed description of the order of operations within the region, so that it knows what state has changed, and which registers have been saved at any given point in that region.\n\nA “body” region may change the state of the stack frame and save and restore preserved registers (for example, to “shrink-wrap” the save and restore of a register), but the unwind data structures are tuned for body regions that have few such operations.\n\nFor both types of regions, the unwinder needs to know the state of the stack frames and preserved registers upon entry to the region. There are four ways to establish the entry state for an unwind region:\n\n- The first region in the procedure assumes that both stack frames are unallocated, and no registers have been saved upon entry to the region.\n- A region may modify the state of the stack frames and preserved registers; each subsequent region takes the previous region’s exit state as its entry state.\n- When control does not flow into a region from directly above it, the region may copy the entry state from an alternate region that has been described earlier.\n- Zero-length prologue regions may be inserted just prior to a prologue or body region to set up the correct entry state.\n\nRegions may begin and end at arbitrary instructions, without regard to bundle boundaries or cycle breaks.\n\n11.3.1 Conventions for Prologue Regions\n\nA typical prologue region will do some or all of the following steps:\n\n- Allocate a new register stack frame. The placement of this step is not important to the unwind process (although it must precede any other operations in the prologue that require the use of local stack registers).\n- Allocate a new memory stack frame. For fixed-size frames, the stack pointer (sp) must be modified in a single instruction (either with a single add immediate, or by performing intermediate calculations in a scratch register before modifying sp). The location of this instruction and the fixed frame size must be recorded in the unwind descriptor. For variable-size frames, the stack pointer must be saved in a general register that is kept valid throughout the remainder of the prologue region and the following body region(s). This copy of the previous stack pointer is called psp. The location of the copy instruction, and the GR number must be recorded in the unwind descriptor.\n- Save the previous function state (ar.pfs), either in a general register or on the memory stack. The location of this instruction, and the GR number or stack offset must be recorded in the unwind descriptor. Normally, the previous function state is copied to a GR by the alloc instruction that allocates a new register stack frame. If the previous function state is to be stored in the memory stack, however, the location of the instruction that stores the GR to memory should be recorded, and the original pfs may not be modified until after the store.\n• Save the return pointer (rp), either in a general register or on the memory stack. The location of this instruction, and the GR number or stack offset must be recorded in the unwind descriptor. Saving to the memory stack requires two steps—one to copy it to a GR, and another to store it; the location of the store is the one to record, and the original rp may not be modified before the store.\n\n• Save preserved registers, either on the memory stack or in local registers in the current register stack frame. In general, the location of each instruction used to save a preserved register, and the GR number or stack offset must be recorded. There are five groups of preserved registers: GRs, FRs, BRs, predicates, and ARs (ar.unat, ar.rnat, ar.lc, ar.fpsr, ar.bsp, and ar.bspstore). The predicates must be copied as a whole to a GR with a single Move from Predicates instruction; if they are to be stored on the memory stack, the Store instruction is the one to record. Any arbitrary subset of preserved GRs, FRs, and BRs may be saved in a prologue, but they must be saved in ascending order by register number within each group (saves from different groups may be interleaved). Saving a BR to memory (other than rp) requires two steps—a move to GR, and a store; the location of the store is the one to record, and the value of the BR may not be modified until the store is completed.\n\nThe unwinder must also know where preserved registers are saved in the memory stack frame, because it needs to reconstruct the values of these registers as it unwinds the stack. The conventions for the spill area are discussed below.\n\nA prologue region may also contain any amount of other code that is irrelevant to the unwind process. For better efficiency during the unwind process, however, the size of the prologue region should be kept as small as possible, and it should be defined to end immediately after the last of the above steps.\n\nPrologue regions may occur in the interior of a procedure. These typically represent register spill sequences that have been “shrink-wrapped” into a small block of conditional code.\n\nThe encoding of the unwind descriptors for prologue regions recognizes several common cases that reduce the size of the unwind information significantly. Compilers are encouraged to observe these conventions for low optimization levels and whenever it would not adversely affect the quality of optimization. These cases include:\n\n• The prologue saves rp, ar.pfs, psp, and the predicates (as needed) in consecutive registers in the ins/locals area of the current register stack frame.\n\n• The prologue saves all of its subset of preserved registers before modifying any of them. In this case, the locations of individual save instructions do not need to be recorded, and the restrictions on their relative ordering are eliminated.\n\n• A leaf procedure that does not create a memory stack frame or save any preserved registers does not require any unwind descriptors.\n\n11.3.2 Conventions for Body Regions\n\nIn general, body regions may do anything that does not invalidate the state of the stack frames and preserved registers as recorded for that region. In particular, a body region must obey the following restrictions:\n\n• If the memory stack frame is fixed size, it may not modify the sp register.\n\n• If the memory stack frame is variable size, it may modify sp at any point, but the unwind descriptors must indicate where a valid psp value can be found at any point within the body region.\nStack Unwinding and Exception Handling\n\n- The unwind descriptors must indicate where a valid copy of the previous frame marker can be found at any point within a body region. The body region code may not make a procedure call while the previous frame marker remains in \\texttt{ar.pfs}.\n\n- The unwind descriptors must indicate where a valid copy of the return IP can be found at any point within the body region. The body region code may not make a procedure call while the saved return IP remains in \\texttt{rp}.\n\n- The unwind descriptors must indicate where a valid copy of each preserved register can be found at any point within the body region.\n\nAt every point in a body region, the unwind descriptors identify a single location where a valid value for every item listed above can be found. The code must not modify a register or memory location while the unwind descriptors indicate that one of these items is currently stored there.\n\nGenerally, the locations of the saved values listed above remain constant throughout the body region, in locations specified in the prologue descriptor records. When this is not the case, however, the general unwind descriptors described in Table 11-13 may be used to mark changes in the unwind state within a body region.\n\nA body region may restore \\texttt{ar.pfs}, \\texttt{rp}, and any preserved registers. The unwinder does not need a specific “epilogue” region that is distinct from the body region.\n\nThe memory stack pointer (\\texttt{sp}) is typically restored just before executing a return branch. In a normal epilogue at the end of a body region, the compiler may place the instruction that restores the previous \\texttt{sp} value anywhere within a few instructions of the end of the region; the unwind descriptor format provides a place to record the exact location of this instruction. If the procedure has a memory stack frame, and has returns in the middle of the body, the compiler must separate the procedure into separate body regions, each ending at the point of each return.\n\n### 11.3.3 Conventions for the Spill Area in the Memory Stack Frame\n\nThe spill area for preserved general registers, floating-point registers, and branch registers is near the base of the stack frame, in a continuous range ending, by default, at the base of the stack frame plus 16 bytes (\\texttt{psp+16}). In other words, the 16-byte scratch area in the caller’s stack frame normally contains the last 16 bytes of the spill area. If the scratch area is needed for saving register parameters for a variable-argument list procedure, the spill area may be moved so that it ends at a lower address, but the ending address must be a fixed location relative to the base of the frame (\\texttt{psp}).\n\nLocations in the spill area are reserved for each preserved GR, FR, and BR that is saved anywhere within the procedure (including shrink-wrapped regions). Locations are allocated, from low address to high, first for general registers, then for branch registers, and finally for floating-point registers. Registers are saved in numerical order, lower-numbered registers at lower addresses. The spill area must end at a 16-byte boundary, so that all the floating-point spill locations are 16-byte aligned.\n\nIt is not required that all registers preserved in the spill area be consecutive from each register file. If, for example, GR 4 and GR 7 are preserved, but GR 5 and GR 6 are not, space is allocated only for GR 4 and GR 7.\n\nA compiler may need to spill scratch registers in addition to preserved registers. There are no required conventions for spilling scratch registers, since they do not need to be recovered during a stack unwind. It is expected, however, that general register spills will be adjacent to the preserved general register spill area in order to make the best use of the User NaT collection register.\n\nNormally, the unwinder expects to find the NaT bits for the preserved registers in the User NaT collection register, \\texttt{ar.unat}. If the total spill area for general registers (scratch and preserved\nStack Unwinding and Exception Handling\n\ncombined) exceeds 64 double-words, the compiler may be forced to save the User NaT collection register in order to spill up to an additional 64 general registers. In this overflow situation, the compiler must manage two or more NaT collections by swapping them in and out of the single collection register. The NaT collection that contains the NaT bits for the preserved registers is called the “primary unat collection,” and the unwinder must know where to find these bits. In procedures where the NaT collection register is multiplexed, the compiler must record the location of the primary unat collection in the unwind information.\n\n11.4 Data Structures\n\nThe exception handling mechanism uses three data structures:\n\n- An unwind table, which allows the dispatcher and unwinder to associate an IP value with a procedure and its unwind and exception handling information. Every procedure that has either a memory stack frame or exception handling requirements, or both, has one entry in this table. (If the compiler has generated more than one non-contiguous region of code for a procedure, there will be one entry in this table for each region.) Each unwind table entry points to an information block that contains the other two data structures.\n- A set of unwind descriptors for each procedure.\n- An optional language-specific data area for each procedure.\n\nThe dispatcher and unwinder both use the unwind table to locate an unwind entry for a procedure, given an IP value. The unwinder also uses the unwind descriptor list so that it can properly unwind the stack from any point in the procedure.\n\nThe language-specific data area is used to store cleanup actions and a try region table.\n\n11.4.1 Unwind Table\n\nThe unwind table entries contain three fields, as illustrated in Figure 11-2; each field is a 64-bit doubleword. The first two fields define the starting and ending addresses of the procedure, respectively, and the third field points to a variable-size information block containing the unwind descriptor list and language-specific data area. The ending address is the address of the first bundle beyond the end of the procedure. These values are all segment-relative offsets, not absolute addresses, so they do not require run-time relocations. The unwind table is sorted by the procedure start address. The shaded area in the figure represents the language-specific data area.\n\nFigure 11-2. Unwind Table and Example of Language-specific Data Area\n\n<table>\n<thead>\n<tr>\n<th>Unwind Table</th>\n<th>Info. Block</th>\n<th>tcnt</th>\n<th>ccnt</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>start</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>end</td>\n<td>v</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>info ptr.</td>\n<td>f</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>ulen</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>unwind</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>descriptors</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>personality</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>language</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>specific</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>data area</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>try/catch</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>region table</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>start</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>end</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>catch</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>handler</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>cleanup</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>action table</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>start</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>end</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>action</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\nIf a leaf procedure has no stack frame, no exception handling requirements, and keeps its return pointer in \\( b_0 \\), no unwind table entry is necessary for the procedure. The unwinder must assume these conditions when the IP does not correspond to any procedure table entry.\n\nThe first doubleword of the information block consists of three fields: a 16-bit version number for the unwind descriptors, 16 flag bits, and a 32-bit length field. These fields may be accessed with the following macros:\n\n- `UNW_VER(x)` \\((x) \\gg 48\\)\n- `UNW_FLAG_MASK` \\(0x0000ffff00000000L\\)\n- `UNW_FLAG_OSMASK` \\(0x0000f00000000000L\\)\n- `UNW_FLAG_EHANDLER(x)` \\((x) \\& 0x0000000100000000L\\)\n- `UNW_FLAG_UHANDLER(x)` \\((x) \\& 0x0000000200000000L\\)\n- `UNW_LENGTH(x)` \\((x) \\& 0x00000000ffffffffL\\)\n\nThe unwind version number identifies the version of the unwind descriptor format. For this specification, the version number is 1.\n\nThe unwind length field identifies the length (in doublewords) of the unwind descriptor area.\n\nTwo flag bits are currently defined, and the four defined by `UNW_FLAG_OSMASK` are reserved for implementation-specific use; the remaining bits are reserved for future use. The `EHANDLER` flag is set if the personality routine should be called during search for an exception handler. The `UHANDLER` flag is set if this routine should be called during the second unwind. If neither bit is set, there is no frame handler for this procedure, and the personality routine identifier should be omitted, along with the entire language-specific data area.\n\n*In C++, the `EHANDLER` bit is set if the procedure contains any try/catch regions, and the `UHANDLER` bit is set if there are any cleanup actions.*\n\nThe personality routine identifier is accessed by adding the size of the unwind descriptor area (ulen, which is the count of doublewords, not bytes), plus the size of the header doubleword, to the information block pointer. The format and contents of this identifier are ABI-specific, and enable the implementation to obtain a function pointer to the personality routine. The dispatcher should call this routine during the first unwind only if the `EHANDLER` bit is set, and during the second unwind only if the `UHANDLER` bit is set. The language specific data immediately follows the personality routine identifier, so the address of this area must be made available to the personality routine.\n\nThe unwind table and the unwind information block must each be aligned at an 8-byte boundary. Within the information block, the personality routine pointer must also be aligned at an 8-byte boundary.\n\n### 11.4.2 Unwind Descriptor Area\n\nThe unwind descriptor area contains a contiguous sequence of records describing the unwind regions in the procedure. Each group of records begins with a region header record identifying the type and length of the region. The region header record is followed by any number of descriptor records that supply additional unwind information about the region.\n\nThe unwind descriptor records are divided into three categories: region header records, descriptor records for prologue regions, and descriptor records for body regions. This section describes the record types in each of these categories, lists rules for using unwind descriptor records, and explains how the records should be processed.\nThe information is encoded in variable-length records with a record type and one or more additional fields. The length of each record is implicit from the record type and its fields. All records are an integral number of bytes in length. In the descriptor record tables in the next three sections, the third column lists the format of each record type. These record formats are described in Appendix B.\n\nSince the unwind descriptor area must be a multiple of 8 bytes, the last unwind descriptor must be followed by zero bytes as necessary to pad the area to an 8-byte boundary. These zero bytes will be interpreted as prologue region header records, specifying a zero-length prologue region, and serve as no-ops.\n\n### 11.4.2.1 Region Header Records\n\nThe region header records are listed in Table 11-1.\n\n**Table 11-1. Region Header Records**\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>body</td>\n<td>rlen</td>\n<td>R1/R3</td>\n<td>Defines a body region.</td>\n</tr>\n<tr>\n<td>prologue</td>\n<td>rlen</td>\n<td>R1/R3</td>\n<td>Defines a general prologue region.</td>\n</tr>\n<tr>\n<td>prologue_gr</td>\n<td>rlen, mask, grsave</td>\n<td>R2</td>\n<td>Defines a prologue region with a mask of saved registers, and a set of GRs used for saving preserved registers.</td>\n</tr>\n</tbody>\n</table>\n\nThe fields in these records are used as follows:\n\n- **rlen** contains the length of the region, measured in instruction slots (three slots per bundle, counting X-unit instructions as two slots).\n- **mask** indicates which registers are saved in the prologue. The `prologue_gr` region type is used for entry prologues that save one or more preserved registers in the local register area of the register stack frame. This field defines what combination of `rp`, `ar.pfs`, `psp`, and the predicates are preserved in standard GRs in the local area of the register stack frame. This mask is four bits; see Appendix B, “Unwind Descriptor Record Format,” for the allocation of these bits. Other registers may be preserved in the prologue, but additional descriptor records are required for registers other than these four.\n- **grsave** identifies the first GR used to save the preserved registers identified in the `mask` field. Normally, this should identify a register in the procedure’s local stack frame (i.e., it should be greater than or equal to 32). Leaf procedures, however, may choose to use any consecutive sequence of scratch registers.\n\nThe entry state for a region matches the exit state of the preceding region, except for body regions that contain a “copy_state” descriptor record, described in Table 11-12.\n\nThe exit state of a region is determined as follows:\n\n- For prologue regions, and for body regions with no epilogue code, the exit state is the logical combination of the entry state with the modifications described by the descriptor records for the region.\n- For body regions with epilogue code, the exit state is the same as the entry state of the corresponding prologue whose effect is being undone. When shrink-wrap regions are nested, it is possible to reverse the effects of multiple prologues at once.\n11.4.2.2 Descriptor Records for Prologue Regions\n\nThis section lists the descriptor records that may be used to describe prologue regions. In the absence of any descriptor records or information in the region header record, a prologue is assumed to create no memory stack frame and save no registers. Descriptors need to be supplied only to override these defaults.\n\nThe following descriptor records are used to record information about the stack frame and the state of the previous stack pointer (psp).\n\n<table>\n<thead>\n<tr>\n<th>Table 11-2. Prologue Descriptor Records for the Stack Frame</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Record Type</strong></td>\n</tr>\n<tr>\n<td>mem_stack_f</td>\n</tr>\n<tr>\n<td>mem_stack_v</td>\n</tr>\n<tr>\n<td>psp_gr</td>\n</tr>\n<tr>\n<td>psp_sprel</td>\n</tr>\n</tbody>\n</table>\n\nThe fields in these records are used as follows:\n\n- **t** describes a time, t, when a particular action occurs within the prologue. The time is specified as an instruction slot number, counting three slots per bundle. The first instruction slot in the prologue is numbered 0. For procedures with a memory stack frame, the instruction that modifies sp (fixed-size frame) or that saves psp (variable-size frame) must be identified with either a mem_stack_f or a mem_stack_v record. In all other cases, if the time is not specified, the unwinder may assume that the original contents of the register is valid through the end of the prologue, and that the saved copy is valid by the end of the prologue. In a zero-length prologue region, the time parameter is irrelevant, and should be specified as 0.\n\n- **size** contains the fixed size of the memory stack frame, measured in 16-byte units.\n\n- **gr** identifies a general register, or the first in a consecutive group of general registers, that is used for preserving the value of another register (as implied by the record type). Typically, this field will identify a general register in the procedure’s local stack frame. A leaf procedure, however, may choose to use scratch registers. (A non-leaf procedure may also use scratch registers through a body region that makes no calls, but it would need to move any values saved in scratch registers to a more permanent save location prior to making any calls. It would need a second prologue region to describe this movement.)\n\n- **spoff** identifies a location in the memory stack where a register or group of registers are spilled to memory. This location is specified relative to the current stack pointer. See Appendix B, “Unwind Descriptor Record Format,” for the encoding of this field.\n\nThe following descriptor records are used to record the state of the return pointer (rp).\n\n<table>\n<thead>\n<tr>\n<th>Table 11-3. Prologue Descriptor Records for the Return Pointer</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Record Type</strong></td>\n</tr>\n<tr>\n<td>rp_when</td>\n</tr>\n<tr>\n<td>rp_gr</td>\n</tr>\n</tbody>\n</table>\nTable 11-3. Prologue Descriptor Records for the Return Pointer (Cont’d)\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>rp_br</td>\n<td>br</td>\n<td>P3</td>\n<td>Specifies alternate BR used as return pointer.</td>\n</tr>\n<tr>\n<td>rp_psprel</td>\n<td>pspoff</td>\n<td>P7</td>\n<td>Specifies memory location where rp is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>rp_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where rp is saved, as an sp-relative offset.</td>\n</tr>\n</tbody>\n</table>\n\nThe fields in these records are used as follows:\n\n- **br** identifies a branch register that contains the return link, when the return link is not either in b0 or saved to another location.\n- **pspoff** identifies a location in the memory stack where a register or group of registers are spilled to memory. The location is specified relative to the previous stack pointer (which is equal to the current stack pointer plus the frame size). See Appendix B, “Unwind Descriptor Record Format,” for the encoding of this field.\n\nThe following descriptor records are used to record the state of the previous function state register (ar.pfs).\n\nTable 11-4. Prologue Descriptor Records for the Previous Function State\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>pfs_when</td>\n<td>t</td>\n<td>P7</td>\n<td>Specifies when ar.pfs is saved.</td>\n</tr>\n<tr>\n<td>pfs_gr</td>\n<td>gr</td>\n<td>P3</td>\n<td>Specifies GR where ar.pfs is saved.</td>\n</tr>\n<tr>\n<td>pfs_psprel</td>\n<td>pspoff</td>\n<td>P7</td>\n<td>Specifies memory location where ar.pfs is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>pfs_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where ar.pfs is saved, as an sp-relative offset.</td>\n</tr>\n</tbody>\n</table>\n\nThe following descriptor records are used to record the state of the preserved predicates.\n\nTable 11-5. Prologue Descriptor Records for Predicate Registers\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>preds_when</td>\n<td>t</td>\n<td>P7</td>\n<td>Specifies when the predicates are saved.</td>\n</tr>\n<tr>\n<td>preds_gr</td>\n<td>gr</td>\n<td>P3</td>\n<td>Specifies GR where predicates are saved.</td>\n</tr>\n<tr>\n<td>preds_psprel</td>\n<td>pspoff</td>\n<td>P7</td>\n<td>Specifies memory location where predicates are saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>preds_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where predicates are saved, as an sp-relative offset.</td>\n</tr>\n</tbody>\n</table>\n\nThe following descriptor records are used to record the state of the preserved general registers, floating-point registers, and branch registers.\nStack Unwinding and Exception Handling\n\nTable 11-6. Prologue Descriptor Records for GRs, FRs and BRs\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>fr_mem</td>\n<td>rmask</td>\n<td>P6</td>\n<td>Specifies which preserved floating-point registers are spilled to memory by this prologue, as a bit mask.</td>\n</tr>\n<tr>\n<td>frgr_mem</td>\n<td>grmask, frmask</td>\n<td>P5</td>\n<td>Specifies which preserved general and floating-point registers are spilled to memory by this prologue, as a bit mask.</td>\n</tr>\n<tr>\n<td>gr_gr</td>\n<td>grmask, gr</td>\n<td>P9</td>\n<td>Specifies which preserved general registers are saved in other general registers, as a bit mask, and GR where first preserved GR is saved.</td>\n</tr>\n<tr>\n<td>gr_mem</td>\n<td>rmask</td>\n<td>P6</td>\n<td>Specifies which preserved general registers are spilled to memory by this prologue, as a bit mask.</td>\n</tr>\n<tr>\n<td>br_mem</td>\n<td>brmask</td>\n<td>P1</td>\n<td>Specifies which preserved branch registers are spilled to memory by this prologue, as a bit mask.</td>\n</tr>\n<tr>\n<td>br_gr</td>\n<td>brmask, gr</td>\n<td>P2</td>\n<td>Specifies which preserved branch registers are saved in general registers by this prologue, as a bit mask, and GR where first BR is saved.</td>\n</tr>\n<tr>\n<td>spill_base</td>\n<td>pspoff</td>\n<td>P7</td>\n<td>Specifies base of spill area in memory stack frame, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>spill_mask</td>\n<td>imask</td>\n<td>P4</td>\n<td>Specifies when preserved registers are spilled, as a bit mask.</td>\n</tr>\n</tbody>\n</table>\n\nThe fields in these records are used as follows:\n\n- **rmask, frmask, grmask, brmask** identify which preserved FRs, GRs, and BRs are saved by the prologue region. The `fr_mem` record uses a short `rmask` field, which can be used when a subset of floating-point registers from the range `f2–f5` is saved. The `frgr_mem` record can be used for any number of saved floating-point and general registers. The `gr_mem` record can be used when only general registers (`r4–r7`) are saved.\n\n- **imask** identifies when each preserved FR, GR, and BR is saved. It contains a two-bit field for each instruction slot in the prologue, indicating whether the instruction in that slot saves one of these preserved registers. The length of this field is implied by the size of the prologue region as given in the region header record. It contains two bits for each instruction slot in the region, and the length of the field is rounded up to the next whole byte boundary.\n\nIf a prologue saves one or more preserved FRs, GRs, or BRs, and the `spill_mask` record is omitted, the unwinder may assume that the original contents of those preserved registers are valid through the end of the prologue, and that the saved copies are valid by the end of the prologue.\n\nThere may be only one `spill_base` and one `spill_mask` record per prologue region.\n\nEach `gr_gr` and `br_gr` record describes a set of registers that is saved to a consecutive set of general registers (typically in the local register stack frame). To represent registers saved to non-consecutive general registers, two or more of each of these records may be used.\n\nThe following descriptor records are used to record the state of the User NaT Collection register (`ar.unat`).\nThe following descriptor records are used to record the state of the Loop Counter register \\(\\text{ar.lc}\\).\n\n### Table 11-8. Prologue Descriptor Records for the Loop Counter Register\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>lc_when</td>\n<td>t</td>\n<td>P7</td>\n<td>Specifies when (\\text{ar.lc}) is saved.</td>\n</tr>\n<tr>\n<td>lc_gr</td>\n<td>gr</td>\n<td>P3</td>\n<td>Specifies GR where (\\text{ar.lc}) is saved.</td>\n</tr>\n<tr>\n<td>lc_psprel</td>\n<td>pspoff</td>\n<td>P7</td>\n<td>Specifies memory location where (\\text{ar.lc}) is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>lc_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where (\\text{ar.lc}) is saved, as an sp-relative offset.</td>\n</tr>\n</tbody>\n</table>\n\nThe following descriptor records are used to record the state of the floating-point status register \\(\\text{ar.fpsr}\\).\n\n### Table 11-9. Prologue Descriptor Records for the Floating-point Status Register\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>fpsr_when</td>\n<td>t</td>\n<td>P7</td>\n<td>Specifies when the floating-point status register is saved.</td>\n</tr>\n<tr>\n<td>fpsr_gr</td>\n<td>gr</td>\n<td>P3</td>\n<td>Specifies GR where the floating-point status register is saved.</td>\n</tr>\n<tr>\n<td>fpsr_psprel</td>\n<td>pspoff</td>\n<td>P7</td>\n<td>Specifies memory location where the floating-point status register is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>fpsr_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where the floating-point status register is saved, as an sp-relative offset.</td>\n</tr>\n</tbody>\n</table>\n\nThe following descriptor records are used to record the state of the primary unat collection.\n\n### Table 11-10. Prologue Descriptor Records for the Primary Unat Collection\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>priunat_when_gr</td>\n<td>t</td>\n<td>P8</td>\n<td>Specifies when the primary unat collection is copied to a GR.</td>\n</tr>\n<tr>\n<td>priunat_when_mem</td>\n<td>t</td>\n<td>P8</td>\n<td>Specifies when the primary unat collection is saved in memory.</td>\n</tr>\n<tr>\n<td>priunat_gr</td>\n<td>gr</td>\n<td>P3</td>\n<td>Specifies GR where the primary unat collection is copied.</td>\n</tr>\n<tr>\n<td>priunat_psprel</td>\n<td>pspoff</td>\n<td>P8</td>\n<td>Specifies memory location where the primary unat collection is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>priunat_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where the primary unat collection is saved, as an sp-relative offset.</td>\n</tr>\n</tbody>\n</table>\nThe following descriptor records are used to record the state of the backing store, when it is necessary to record a discontinuity.\n\nTable 11-11. Prologue Descriptor Records for the Backing Store\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bsp_when</td>\n<td>t</td>\n<td>P8</td>\n<td>Specifies when ar.bsp is saved. The backing store pointer may be saved, along with the ar.bspstore pointer and the ar.rnat register, to indicate a discontinuity in the backing store.</td>\n</tr>\n<tr>\n<td>bsp_gr</td>\n<td>gr</td>\n<td>P3</td>\n<td>Specifies GR where ar.bsp is saved.</td>\n</tr>\n<tr>\n<td>bsp_psprel</td>\n<td>pspoff</td>\n<td>P8</td>\n<td>Specifies memory location where ar.bsp is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>bsp_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where ar.bsp is saved, as an sp-relative offset.</td>\n</tr>\n<tr>\n<td>bspstore_when</td>\n<td>t</td>\n<td>P8</td>\n<td>Specifies when ar.bspstore is saved.</td>\n</tr>\n<tr>\n<td>bspstore_gr</td>\n<td>gr</td>\n<td>P3</td>\n<td>Specifies GR where ar.bspstore is saved.</td>\n</tr>\n<tr>\n<td>bspstore_psprel</td>\n<td>pspoff</td>\n<td>P8</td>\n<td>Specifies memory location where ar.bspstore is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>bspstore_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where ar.bspstore is saved, as an sp-relative offset.</td>\n</tr>\n<tr>\n<td>rnat_when</td>\n<td>t</td>\n<td>P8</td>\n<td>Specifies when ar.rnat is saved.</td>\n</tr>\n<tr>\n<td>rnat_gr</td>\n<td>gr</td>\n<td>P3</td>\n<td>Specifies GR where ar.rnat is saved.</td>\n</tr>\n<tr>\n<td>rnat_psprel</td>\n<td>pspoff</td>\n<td>P8</td>\n<td>Specifies memory location where ar.rnat is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>rnat_sprel</td>\n<td>spoff</td>\n<td>P8</td>\n<td>Specifies memory location where ar.rnat is saved, as an sp-relative offset.</td>\n</tr>\n</tbody>\n</table>\n\nTable 11-12. Body Region Descriptor Records\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>epilogue</td>\n<td>t, ecount</td>\n<td>B2/B3</td>\n<td>Body region contains epilogue code for one or more prologues.</td>\n</tr>\n<tr>\n<td>label_state</td>\n<td>label</td>\n<td>B1/B4</td>\n<td>Labels the entry state for future reference.</td>\n</tr>\n<tr>\n<td>copy_state</td>\n<td>label</td>\n<td>B1/B4</td>\n<td>Use labeled entry state as entry state for this region.</td>\n</tr>\n</tbody>\n</table>\n\n- **t** indicates the location of the instruction that restores the previous sp value, relative to the end of the region. The number is a count of the remaining instruction slots to the end of the region (thus, a value of 0 indicates the final slot in the region).\n- **ecount** indicates how many additional levels of nested shrink-wrap regions are being popped at the end of a body region with epilogue code. A value of 0 indicates that one level should be popped.\n- **label** identifies a previously-specified body region, whose entry state should be copied for this body region.\nPrologue regions nest within other prologue regions, and are balanced by body regions with an epilogue descriptor. An epilogue descriptor with an ecount of n serves to balance (n+1) earlier prologue regions.\n\nWhen the label_state descriptor is used to label an entry state, it must appear prior to any general unwind descriptors in the same body region.\n\nA copy_state descriptor must appear prior to any general unwind descriptors in the same body region.\n\nA labelled entry state not only includes the record of where current valid copies of all preserved values can be found, but also references the states that are currently on the stack of nested prologues. For example, consider the following sequence of regions:\n\nPrologue region A\nBody region B (no epilogue)\nPrologue region C\nBody region C (label_state 1, epilogue count 2)\nBody region D (copy_state 1, epilogue count 2)\n\nThe effect of the copy_state in body region D restores the entry state of body region C, as well as the two prologue regions within which the body region is nested.\n\nThe scope of a label is restricted to a single unwind descriptor area.\n\n11.4.2.4 Descriptor Records for Body or Prologue Regions\n\nThis section lists the descriptor records that may be used to describe either prologue or body regions. These descriptors provide complete generality for compilers to perform register spills and restores anywhere in the procedure, without creating an arbitrary boundary between prologue and body.\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>Fields</th>\n<th>Format</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>spill_psprel</td>\n<td>t, reg, pspoff</td>\n<td>X1</td>\n<td>Specifies when and where reg is saved, as a psp-relative offset.</td>\n</tr>\n<tr>\n<td>spill_sprel</td>\n<td>t, reg, spoff</td>\n<td>X1</td>\n<td>Specifies when and where reg is saved, as an sp-relative offset.</td>\n</tr>\n<tr>\n<td>spill_reg</td>\n<td>t, reg, treg</td>\n<td>X2</td>\n<td>Specifies when and where reg is saved in another register, treg, or restored.</td>\n</tr>\n<tr>\n<td>spill_psprel_p</td>\n<td>qp, t, reg, pspoff</td>\n<td>X3</td>\n<td>Specifies when and where reg is saved, as a psp-relative offset, under predicate qp.</td>\n</tr>\n<tr>\n<td>spill_spref_p</td>\n<td>qp, t, reg, spoff</td>\n<td>X3</td>\n<td>Specifies when and where reg is saved, as an sp-relative offset, under predicate qp.</td>\n</tr>\n<tr>\n<td>spill_reg_p</td>\n<td>qp, t, reg, treg</td>\n<td>X4</td>\n<td>Specifies when and where reg is saved in another register, treg, or restored, under predicate qp.</td>\n</tr>\n</tbody>\n</table>\n\n- **reg** identifies the register being spilled or restored at the given point in the code. This field may indicate any of the preserved GRs, FRs, BRs, ARs, predicates, previous sp, primary unat, or return pointer. See Appendix B, “Unwind Descriptor Record Format,” for the encoding of this field.\n- **treg** identifies a target register to which the value being spilled is copied. This field may indicate any GR, FR, or BR; it may also contain the special “Restore” target, indicating the...\npoint at which a register is restored. See Appendix B, “Unwind Descriptor Record Format,” for the encoding of this field.\n\n- **qp** identifies a qualifying predicate, which determines whether the indicated spill or restore instruction executes. The qualifying predicate must be a preserved predicate if there are any procedure calls in the range between the spill and restore, and it must remain live throughout the range.\n\nIf a body region contains any general descriptors and an epilogue descriptor, the effects of the general descriptors are undone when the unwind state is restored by popping one or more prologues. By the end of the body region, the code must have restored any preserved registers that the new unwind state indicates are restored. It is not necessary, however, to record the points at which registers are restored unless the locations used to save the values are modified before the end of the region.\n\n11.4.2.5 Rules for Using Unwind Descriptors\n\nPreserved registers that are saved in the prologue region must be specified with one or more of the following descriptor records:\n\n- **prologue_gr** (rp, ar.pfs, psp, and the predicates).\n- **mem_stack_v** (psp is saved in a GR).\n- **rp_when**, **rp_gr**, **rp_psprel**, or **rp_sprel** (rp).\n- **pfs_when**, **pfs_gr**, **pfs_psprel**, or **pfs_sprel** (ar.pfs).\n- **unat_when**, **unat_gr**, **unat_psprel**, or **unat_sprel** (ar.unat).\n- **lc_when**, **lc_gr**, **lc_psprel**, or **lc_sprel** (ar.lc).\n- **fpsr_when**, **fpsr_gr**, **fpsr_psprel**, or **fpsr_sprel** (ar.fpsr).\n- **fr_mem**, **frgr_mem**, or **gr_mem** (FRs and GRs).\n- **br_mem** or **br_gr** (BRs).\n\nIf a preserved register is not named by one or more of these records, it is assumed that the prologue does not save or modify that register.\n\nThe locations where preserved registers are saved are determined as follows:\n\n1. Certain descriptor records explicitly name a save location for a register (records whose names end with “_gr,” “_psprel,” or “_sprel”). If a register is described by one of these records, the unwinder uses the named location.\n2. Some descriptor records specify that registers are saved to the spill area (fr_mem, frgr_mem, gr_mem, br_mem). These locations are determined by the conventions for the spill area.\n3. Any remaining registers that are named as saved, but do not have an explicit save location, are assigned consecutive GRs, beginning with the GR identified by the prologue_gr region header record. If the prologue region uses a prologue header record, the first GR is assumed to be GR 32. The registers are saved as needed in the following order:\n a. Return pointer, rp.\n b. Previous function state, ar.pfs.\n c. Previous stack pointer, psp.\nd. Predicates.\n\ne. User NaT collection register, ar.unat.\n\nf. Loop counter, ar.ic.\n\ng. Floating-point status register, ar.fpsr.\n\nh. Primary unat collection.\n\nNote that the only way to indicate that any of the last four groups of registers are saved, without explicitly specifying a save location, is to use one of the corresponding _when descriptor records.\n\n11.4.2.6 Processing Unwind Descriptors\n\nThe unwind process for a frame begins by locating the unwind table entry for a given IP. If there is no unwind table entry, the unwinder should use the default conditions for this frame: leaf procedure, no memory stack frame, and no saved registers.\n\nIf there is an unwind table entry, the unwinder thenLocates the unwind information block and checks the size of the unwind descriptor area. If this area is zero length, the unwinder should use the default conditions as above.\n\nIn preparation for reading the unwind descriptor records, the unwinder should start with an initial current state record, and an empty stack of state records. A state record describes the locations of all preserved registers at entry to a region. The initial value of the current state record should describe the frame in its default conditions.\n\nThe unwind descriptor records should be read and processed sequentially, beginning with the first descriptor record for a procedure, continuing until the IP is contained within the current region. For each prologue region header, the current state record should be pushed on the stack, and the descriptor records for the prologue region should be applied to the current state record. When a body region with epilogue code is seen, one or more states should be popped from the stack, and the entry state for the next region is taken as the last state popped. This restores the current state to the entry state of the matching prologue.\n\nWhen a body region contains a label_state descriptor, the unwind processor should replicate the current unwind state, including the current stack of prologues. When a body region contains a copy_state descriptor, the unwind processor should discard the current state and stack, and restore the replicated state and stack that corresponds with the label.\n\nWhen the current IP is within a body region, the unwinder can generate the context of the previous frame by restoring registers as indicated by the current state record. If the body region has epilogue code, and the IP is beyond the indicated point where sp is restored, the unwinder should assume that sp has already been restored, and that all registers spilled to the memory stack frame except those between psp and psp+16 have also been restored. Registers spilled to the scratch area in the caller’s frame may not have been restored at that point, and the unwinder should use the values in memory.\n\nWhen the current IP is within a prologue region, the unwinder must look for descriptor records that specify a time parameter that is at or beyond the current IP. It should ignore these state modifications when applying descriptor records to the current state. If a register is saved but does not have a specified time, the unwind may assume that the original value is not modified within the prologue, so it may ignore it.\n\nThe layout and size of the preserved register spill area cannot be determined without reading all the prologue region descriptor records in the procedure, and merging the save masks for the general registers, floating-point registers, and branch registers.\n11.4.3 Language-specific Data Area\n\nThe try region table for C++ could be divided into two parts: a try/catch table and a cleanup action table. As illustrated in Figure 11-2, the table consists of two 32-bit integers followed by the two tables. The first field, tcnt, contains the number of try/catch table entries, and the second field, ccnt, contains the number of cleanup action table entries. The try/catch table consists of a list of four-word entries, sorted by the region end address. The first two words of each entry identify the starting and ending addresses of the region, the third word points to the catch clause, and the fourth word points to the exception handler. The cleanup action table consists of a list of three-word entries, also sorted by the region end address. The first two words of each entry identify the starting and ending addresses of the region, and the third word points to a list of cleanup actions.\n12.1 Position-independent Code\n\nAll code conforming to these conventions must be position independent (PIC). This allows their text segments to remain pure so they can be shared among many processes. Position-independence imposes two requirements on generated code:\n\n- Code that forms an absolute address referring to any address in the load module’s text or data segments is not allowed, since the code would have to be relocated at load time, making it non-sharable. All branches must be pc-relative, references to constants and literals in the text segment must be either pc-relative or indirect via the linkage table, and references to the data segment must be relative to a base register (typically \\texttt{gp}).\n- Code that references symbols that are or may be imported from other load modules must use indirect addressing through a linkage table. The linker is expected to resolve procedure calls by creating import stubs, but the compilers must generate indirect loads and stores for data items that may be dynamically bound. In both cases, the indirection is made through the linkage table, allocated by the linker, and initialized by the dynamic loader; the linkage table is described below.\n\n12.2 Procedure Calls and Long Branch Stubs\n\nNormal procedure calls can be made with the \\texttt{br.call} instruction, which uses pc-relative addressing. There are three possible cases at link time:\n\n- If the target is not within the same load module, or if it is subject to pre-emption by an earlier definition from another load module, the linker must allocate an import stub and resolve the \\texttt{br.call} instruction to the stub.\n- If the target is known to be within the same load module and the displacement is small enough, this instruction can be statically resolved to the call target.\n- If the target is within the same load module, but the displacement is too large for the \\texttt{br.call} instruction, the linker must allocate a long branch stub, as described in Section 8.4, “Calling Sequence” on page 8-2. The long branch stub itself must satisfy the PIC requirements. If the target is within range of the stub, the stub may use a pc-relative \\texttt{br} instruction; otherwise, it must load the address of the target from the linkage table.\n\n12.3 Access to the Data Segment\n\nThe DLL’s short data segment must be accessed through the \\texttt{gp} register, which is defined to point to the short data segment on entry to any DLL procedure. The \\texttt{gp} register is used to access both the linkage tables and statically-allocated data. The DLL’s long data segments must be accessed via the linkage table.\n\nThere are several cases here:\n\n- Global variables that are imported from another load module, or that are subject to pre-emption by an earlier definition in another load module, must be accessed indirectly through\nthe linkage table. The compiler must generate code to load a pointer from the linkage table, using gp-relative addressing, then access the data item using that pointer. The compiler does not have to allocate the linkage table; there are relocations defined in the object file format that instruct the linker to allocate a linkage table slot and supply the gp-relative address of that slot.\n\n- Small, statically-allocated variables of local scope, or global variables whose definitions are not subject to pre-emption, may be placed in the short data segment and accessed directly with gp-relative addressing.\n- Large variables, regardless of scope or pre-emption, must be placed in a long data segment, and accessed via the linkage table or pointer table.\n\nThe partitioning of the data into the short and long data segments is described in Section 3.2, “Protection Areas” on page 3-2.\n\n12.3.1 Access to Constants and Literals in the Text Segment\n\nConstants and literals allocated in the text segment should be accessed with pc-relative addressing, or with indirect addressing via the linkage table.\n\n12.3.2 Materializing Function Pointers\n\nFunction pointers must be materialized by loading a word from the data segment. They may not be materialized from immediate operands.\n\n12.4 Import Stubs\n\nWhen the linker determines that a procedure call refers to an entry point in a different load module, it resolves the reference locally by building an import stub with the same name as the intended target. The import stub contains code that obtains the entry point and gp value from the linkage table, then transfers control, as described in Section 8.4, “Calling Sequence” on page 8-2.\n\nIf the compiler is provided with enough information to know that a particular entry point is in a different load module, it may generate a calling sequence that obviates the need for the linker to build an import stub. This calling sequence, however, is ABI specific, and is not specified in this document.\n\n12.5 The Dynamic Loader\n\nThe dynamic loader is a component of the operating system software that locates all the load modules belonging to an application, loads them into memory, and binds the symbolic references among them. Most of the operation of the dynamic loader is specific to the particular operating system environment, and is further described in the ABIs for those environments. The common runtime architecture has been designed to minimize the amount of work involved in the binding process, by concentrating most of the relocation required in the linkage tables, and by prohibiting any items in the text segment that may require dynamic relocation.\n13.1 Program Startup\n\nAn application begins its execution at a specified program entry point, which depends on the primary language in which the application is written. For C programs, the function \\texttt{main} is the program entry point. On most operating systems, however, some system-dependent initialization must take place before control is transferred to this entry point. This initialization may take place in the operating system or in the DLL loader.\n\nThis section presents a general overview of what an application expects when its program entry point receives control. The ABI document for each operating system is expected to contain the details.\n\n13.1.1 Initial Memory Stack\n\nThe memory stack pointer, \\texttt{sp}, must be properly aligned, and must contain an address that is suitable for allocation of the program’s first stack frame. There must be a 16-byte scratch area available for use, beginning at the address in \\texttt{sp}, but the application may make no further assumptions about the contents of the memory stack beyond the scratch area.\n\n13.1.2 Initial Register Values\n\nThe \\texttt{sp} and \\texttt{gp} registers must be initialized correctly, \\texttt{sp} as described above and \\texttt{gp} to the global pointer value for the main program’s short data segment.\n\nThe floating-point status register should be initialized as shown in Table 13-1. The global trap disable bits (\\texttt{ar.fpsr} bits 0–5) should all be initialized to ones.\n\n\\textbf{Table 13-1. Initial Value of the Floating-point Status Register}\n\n<table>\n<thead>\n<tr>\n<th>Status Field</th>\n<th>Flags</th>\n<th>td</th>\n<th>rc</th>\n<th>pc</th>\n<th>wre</th>\n<th>ftz</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>\\texttt{sf0}</td>\n<td>000000</td>\n<td>0</td>\n<td>00</td>\n<td>11</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>\\texttt{sf1}</td>\n<td>000000</td>\n<td>1</td>\n<td>00</td>\n<td>11</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>\\texttt{sf2 and sf3}</td>\n<td>000000</td>\n<td>1</td>\n<td>00</td>\n<td>11</td>\n<td>0</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\nThe initial stack frame must be setup with 0 input and local registers, and at least 4 output registers (as if the program entry point had been called with at least four parameters). The contents of the parameter registers, \\texttt{in0–in7}, are system-dependent, and are typically used for transmitting the program arguments.\n\n13.2 System Calls\n\nSystem API routines are called using the standard calling conventions described in Chapter 8, “Procedure Linkage.” Any special interfaces between these API routines and the operating system itself is system-dependent, and these API routines are typically supplied in a system DLL.\n13.3 Traps and Signals\n\nWhen the operating system delivers a signal or an exception to a user process, it must make the following available to the process:\n\n- A context record, containing the full user-visible context, as described in Chapter 10, “Context Management.”.\n- The cause of the trap. If the trap was caused by an instruction, the information must be sufficient to identify the bundle and slot.\n\nWhen a trap or signal handler returns, operating system help is necessary for restoring the complete context (via RFI). Thus, the operating system must build a dummy stack frame for the handler, so that a return from the handler will transfer to an operating system entry point that can restore the full context.\n\nThe operating system must provide a new 16-byte scratch area prior to the stack frame created for the signal handler, so that the scratch area belonging to the interrupted procedure is not disturbed during signal processing.\n\nThe operating system must also set the floating-point status register to the initial value specified in Table 13-1 prior to delivering a signal or exception.\n\nTrap handlers will often need to look at the state of the registers at the time of the trap. Since the dynamic general registers are all hidden in the register stack backing store in memory, the application may need to perform some careful calculations to obtain access to the values of these registers. In addition, the operating system may deliver a context in which the backing store is split into two non-contiguous areas. The system-specific runtime library should provide an API routine to build an image of the dynamic registers from the context record.\nA.1 Implementation Limits\n\nThe following constants are defined in the `<limits.h>` header file:\n\n```c\n#define CHAR_BIT 8\n#define SCHAR_MIN (-128)\n#define SCHAR_MAX 127\n#define UCHAR_MAX 255\n/* MB_LEN_MAX determined by locale information */\n#define CHAR_MIN SCHAR_MIN\n#define CHAR_MAX SCHAR_MAX\n#define SHRT_MIN (-32768)\n#define SHRT_MAX 32767\n#define USHRT_MAX 65535\n#define INT_MIN (-2147483647-1)\n#define INT_MAX 2147483647\n#define UINT_MAX 4294967295\n#define __INT64_MIN (-9223372036854775807-1)\n#define __INT64_MAX 9223372036854775807\n#define __UINT64_MAX 18446744073709551615\n```\n\nA.2 Floating-point Definitions\n\nThe following constants are defined in the `<float.h>` header file. The constants beginning with “EXT_” and “QUAD_” are shown here to provide the values of the respective parameters for 80-bit and 128-bit floating-point types; the names of these constants are a notational convenience only. Each ABI is expected to specify an appropriate set of constants. Similarly, the suffixes “W” and “Q” should be replaced by the appropriate suffixes for each ABI.\n\n```c\n#define FLT_DIG 6 /* Max (decimal) digits of prec. */\n#define FLT_EPSILON 1.19209290E-07F\n#define FLT_MANT_DIG 24\n#define FLT_MAX 3.40282347E+38F\n#define FLT_MAX_10_EXP 38\n#define FLT_MAX_EXP 128\n#define FLT_MIN 1.17549435E-38F\n#define FLT_MIN_10_EXP (-37)\n#define FLT_MIN_EXP (-125)\n#define FLT_RADIX 2\n#define DBL_DIG 15 /* Max (decimal) digits of prec. */\n#define DBL_EPSILON 2.2204460492503131E-16\n#define DBL_MANT_DIG 53\n#define DBL_MAX 1.7976931348623157E+308\n#define DBL_MAX_10_EXP 308\n```\nA.3 Variable Argument List Macros\n\nThe following definitions roughly define the operation of the variable argument list macros provided in the `<stdarg.h>` header file. Similar definitions for K&R C may be found in `<varargs.h>`.\n\ntypedef char *va_list;\n#define _VA_ALIGN(list, align) \\n (va_list)((unsigned __int64)(list) + (align) - 1) & ~((align) - 1))\n\n#define va_start(list, parmN) (list = (va_list)(&parmN + 1))\n\n#ifdef __LITTLE_ENDIAN__\n#define va_arg(list, mode) ( \\n list = _VA_ALIGN(list, ((__alignof(mode) > 8) ? 16 : 8)) + sizeof(mode), \\n ((mode *)list)[-1] \\\n) \n#else /* __BIG_ENDIAN__ */\n#define va_arg(list, mode) ( \\n list = _VA_ALIGN(list, ((__alignof(mode) > 8) ? 16 : 8)) +\\n ( ((sizeof(mode) < 8) && !__is_aggregate(mode)) ?\\n 8 - sizeof(mode) : 0 ) + sizeof(mode), \\n ((mode *)list)[-1] \\\n) \n#endif /* __BIG_ENDIAN__ */\n\nThe big endian version of the va_arg macro requires built-in __alignof and __is__aggregate functions in the compiler; the latter returns true if the type given as the argument is an aggregate type.\nA.4 setjmp/longjmp\n\nThe following definition is provided in the `<setjmp.h>` header file:\n\n```c\ntypedef __float80 jmp_buf[_JBLEN];\n```\n\nThe jump buffer must be long enough to contain the context defined in Section 10.3, and should include additional space reserved for future use. It must be declared to guarantee 16-byte alignment (for example, as an array of __float80). Its contents include the following registers:\n\n- Instruction address (ip)—the return BR from the call to `setjmp`\n- Stack pointer (sp)\n- Frame state—the ar.pfs register from the call to `setjmp`\n- Backing store pointer (ar.bsp)\n- General registers r4-r7\n- NaT bits for general registers r4-r7 (shifted to a consistent position independent of the jump buffer address)\n- Floating-point registers f2-f5 and f16-f31\n- Floating-point status register (ar.fpsr)\n- Predicates p1-p5 and p16-p63\n- Branch registers b1-b5\n- User NaT collection register (ar.unat)\n- Loop counter (ar.lc)\n\nNote that the epilog counter (ar.ec) is automatically preserved with the ar.pfs register.\n\nThe jump buffer contents should also include a “signature” to identify its version number and architecture for compatibility with future hardware and software releases.\n\nThe size of the jump buffer (the value of _JBLEN) and the locations of individual items within the jump buffer are ABI specific.\nUnwind Descriptor Record Format\n\nB\n\nB.1 Overview\n\nThe unwind descriptor records are encoded in variable-length byte strings. The various record formats are described in this appendix.\n\nThe first byte of each record is sufficient to determine its format. The high-order bit of this byte determines whether it is a header record (if the bit is zero), or a region descriptor record (if the bit is one). The remaining bits and any subsequent bytes are divided into separate fields. In most formats, the first field, r, identifies the record type. The record formats are listed by the bit pattern of the first byte in Table B-1.\n\nTable B-1. Record Formats\n\n<table>\n<thead>\n<tr>\n<th>Region Header Records</th>\n<th>Prologue Descriptor Records</th>\n<th>Body Descriptor Records</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Bit Pattern</td>\n<td>Format</td>\n<td>Bit Pattern</td>\n</tr>\n<tr>\n<td>00-- ----</td>\n<td>R1</td>\n<td>100-- ----</td>\n</tr>\n<tr>\n<td>0100 0---</td>\n<td>R2</td>\n<td>1010 ----</td>\n</tr>\n<tr>\n<td>0110 00--</td>\n<td>R3</td>\n<td>1011 0---</td>\n</tr>\n<tr>\n<td>1011 1000</td>\n<td>P4</td>\n<td></td>\n</tr>\n<tr>\n<td>1011 1001</td>\n<td>P5</td>\n<td></td>\n</tr>\n<tr>\n<td>110-- ----</td>\n<td>P6</td>\n<td>110-- ----</td>\n</tr>\n<tr>\n<td>1110 ----</td>\n<td>P7</td>\n<td>1110 0000</td>\n</tr>\n<tr>\n<td>1111 0000</td>\n<td>P8</td>\n<td>1111 0000</td>\n</tr>\n<tr>\n<td>1111 0001</td>\n<td>P9</td>\n<td></td>\n</tr>\n<tr>\n<td>1111 1001</td>\n<td>X1</td>\n<td>1111 1001</td>\n</tr>\n<tr>\n<td>1111 1010</td>\n<td>X2</td>\n<td>1111 1010</td>\n</tr>\n<tr>\n<td>1111 1011</td>\n<td>X3</td>\n<td>1111 1011</td>\n</tr>\n<tr>\n<td>1111 1100</td>\n<td>X4</td>\n<td>1111 1100</td>\n</tr>\n<tr>\n<td>1111 1111</td>\n<td>P10</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nSome fields in the unwind descriptor records are variable in length. The variable-length encoding uses the ULEB128 (Unsigned Little-Endian Base 128) encoding, described below:\n\n- Divide the number into groups of 7 bits, beginning at the low-order end.\n- Discard all groups of leading zeroes, but keep at least the first (low-order) group if the number is all zeroes.\n- Place a 1 bit to the left of all but the last group; place a 0 bit to the left of the last group. This forms one or more 8-bit groups.\nThe following table shows example ULEB128 encodings for several numbers:\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Encoding</th>\n<th>Interpretation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>00000000</td>\n<td>0</td>\n</tr>\n<tr>\n<td>127</td>\n<td>01111111</td>\n<td>127</td>\n</tr>\n<tr>\n<td>128</td>\n<td>10000000 00000001</td>\n<td>0 + (1 << 7)</td>\n</tr>\n<tr>\n<td>1544</td>\n<td>10001000 00001100</td>\n<td>8 + (12 << 7)</td>\n</tr>\n<tr>\n<td>49,802</td>\n<td>10001010 10000101 00000011</td>\n<td>10 + (5 << 7) + (3 << 14)</td>\n</tr>\n</tbody>\n</table>\n\nFields in the ULEB128 format always follow the fixed fields, and begin on a byte boundary.\n\n### B.2 Region Header Records\n\nThe prologue and body region header records can appear in either format R1 or R3, depending on the magnitude of the region length field. If the region length is no greater than 31 instructions, the R1 format may be used; otherwise, format R3 must be used.\n\n**Format R1**\n\n```\nByte 0\n7 6 5 4 3 2 1 0\n```\n\n```\n0 0 r rlen\n```\n\nThis format is used for the short forms of the prologue and body region header records. The `r` bit identifies the record type, as shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>r</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>prologue</td>\n<td>0</td>\n</tr>\n<tr>\n<td>body</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\n**Format R2**\n\n```\nByte 0\n7 6 5 4 3 2 1 0\n```\n\n```\n0 1 0 0 0 0 0\n```\n\n```\nmask grsave rlen (ULEB128)\n```\n\nThis format is used only for the prologue_gr region header record. The following table shows the meaning of the bits in the `mask` field:\n\n<table>\n<thead>\n<tr>\n<th>Mask bit</th>\n<th>Meaning when bit is set</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>byte 0, bit 2</td>\n<td><code>rp</code> is saved in standard GR</td>\n</tr>\n<tr>\n<td>byte 0, bit 1</td>\n<td><code>ar.pfs</code> is saved in standard GR</td>\n</tr>\n<tr>\n<td>byte 0, bit 0</td>\n<td><code>psp</code> is saved in standard GR</td>\n</tr>\n<tr>\n<td>byte 1, bit 7</td>\n<td>Predicates are saved in standard GR</td>\n</tr>\n</tbody>\n</table>\nThe `grsave` field identifies the general register in which the first of these values is stored. Additional general registers are used as needed. For example, assume that `rp`, `ar.pfs`, and the predicates are stored, but not `psp`. The mask bits would be 1101, and `grsave` might be set to 39, indicating that the three values are stored in `r39`, `r40`, and `r41`, respectively.\n\n```\n01234567\n011000 r\n```\n\nThis format is used for the long forms of the `prologue` and `body` region header records. The `r` field identifies the record type, as shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>r</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>prologue</td>\n<td>00</td>\n</tr>\n<tr>\n<td>body</td>\n<td>01</td>\n</tr>\n</tbody>\n</table>\n\n### B.3 Descriptor Records for Prologue Regions\n\n```\n01234567\n100 b r m a s k\n```\n\nThis format is used only for the `br_mem` descriptor record.\n\nThe five bits in the `brmask` field are used to indicate which of the five preserved branch registers (`b1`–`b5`) are saved in the prologue. Bit 0 corresponds to `b1`; bit 4 corresponds to `b5`. If the bit is clear, the corresponding register is not saved; if the bit is set, the corresponding register is saved.\n\n```\n01234567\n1010 b r m a s k\n```\n\n```\n01234567\ngr\n```\n\nThis format is used only for the `br_gr` descriptor record.\n\nThe five bits in the `brmask` field are used to indicate which of the five preserved branch registers (`b1`–`b5`) are saved in the prologue. Bit 7 of byte 1 corresponds to `b1`; bit 3 of byte 0 corresponds to `b5`. If the bit is clear, the corresponding register is not saved; if the bit is set, the corresponding register is saved.\n\nThe `gr` field identifies the general register in which the first of these registers is stored. Additional general registers are used as needed. For example, assume that `b1`, `b4`, and `b5` are stored. The mask bits would be 11001, and `gr` might be set to 37, indicating that the three branch registers are stored in `r37`, `r38`, and `r39`, respectively.\nThis format is used by the group of descriptor records that specify a GR or BR number. The record type is identified by the \\( r \\) field, which is read as a four bit number whose low-order bit is bit 7 of byte 1. The following table shows the record types:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>( r )</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>psp_gr</td>\n<td>0</td>\n</tr>\n<tr>\n<td>rp_gr</td>\n<td>1</td>\n</tr>\n<tr>\n<td>pfs_gr</td>\n<td>2</td>\n</tr>\n<tr>\n<td>preds_gr</td>\n<td>3</td>\n</tr>\n<tr>\n<td>unat_gr</td>\n<td>4</td>\n</tr>\n<tr>\n<td>lc_gr</td>\n<td>5</td>\n</tr>\n<tr>\n<td>rp_br</td>\n<td>6</td>\n</tr>\n<tr>\n<td>rnat_gr</td>\n<td>7</td>\n</tr>\n<tr>\n<td>bsp_gr</td>\n<td>8</td>\n</tr>\n<tr>\n<td>bspstore_gr</td>\n<td>9</td>\n</tr>\n<tr>\n<td>fpsr_gr</td>\n<td>10</td>\n</tr>\n<tr>\n<td>priunat_gr</td>\n<td>11</td>\n</tr>\n</tbody>\n</table>\n\nThe high-order (leftmost) two bits of the first byte of the imask field correspond to the preserved general registers (r4–r7). The bits are read from right to left: bit 4 of byte 1 corresponds to r4, and bit 7 corresponds to r7.\n\nThis format is used only by the spill_mask descriptor record. The first byte is followed by the imask field, whose length is determined by the length of the current prologue region as given by the region header record. The imask field contains two bits for each instruction slot in the region, and the size is rounded up to the next whole number of bytes, if necessary.\n\nThe high-order (leftmost) two bits of the first byte of the imask field correspond to the first instruction slot of the region. Bit pairs are read from left to right (high-order bits to low-order bits) within each byte, and bytes are read from increasing memory addresses. Each bit field describes the behavior of the corresponding instruction slot as follows:\n\n<table>\n<thead>\n<tr>\n<th>Bit Pair</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>00</td>\n<td>The instruction slot does not save one of these registers</td>\n</tr>\n<tr>\n<td>01</td>\n<td>the instruction slot saves the next floating-point register</td>\n</tr>\n<tr>\n<td>10</td>\n<td>the instruction slot saves the next general register</td>\n</tr>\n<tr>\n<td>11</td>\n<td>the instruction slot saves the next branch register</td>\n</tr>\n</tbody>\n</table>\n\nThis format is used only by the frgr_mem descriptor record.\nUnwind Descriptor Record Format\n\nThe bits in the frmask field correspond to the preserved floating-point registers ($f_2$–$f_5$ and $f_{16}$–$f_{31}$). The bits are read from right to left: bit 0 of byte 3 corresponds to $f_2$, and bit 3 of byte 1 corresponds to $f_{31}$.\n\nA value of 1 in each bit position indicates that the corresponding register is saved.\n\n**Byte 0**\n\n```\n 7 6 5 4 3 2 1 0\nFormat P6 1 1 0 r rmask\n```\n\nThis format is used by the fr_mem and gr_mem descriptor records. The r bit identifies the record type, as shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>r</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>fr_mem</td>\n<td>0</td>\n</tr>\n<tr>\n<td>gr_mem</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\nThe bits in the rmask field correspond to either the preserved general registers ($r_4$–$r_7$) or the set of the first four preserved floating-point registers ($f_2$–$f_5$). The bits are read from right to left: bit 0 corresponds to $r_4$ or $f_2$, and bit 3 corresponds to $r_7$ or $f_5$. A value of 1 in each bit position indicates that the corresponding register is saved.\n\n**Byte 0**\n\n```\n 7 6 5 4 3 2 1 0\nFormat P7 1 1 1 0 r t/spoff/pspoff (ULEB128) size (ULEB128)\n```\n\nThis format is used for a number of descriptor records. The r field identifies the record type, as shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>r</th>\n<th>Additional ULEB128 Fields</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>mem_stack_f</td>\n<td>0</td>\n<td>t, size</td>\n</tr>\n<tr>\n<td>mem_stack_v</td>\n<td>1</td>\n<td>t</td>\n</tr>\n<tr>\n<td>spill_base</td>\n<td>2</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>psp_sprel</td>\n<td>3</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>rp_when</td>\n<td>4</td>\n<td>t</td>\n</tr>\n<tr>\n<td>rp_psprel</td>\n<td>5</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>pfs_when</td>\n<td>6</td>\n<td>t</td>\n</tr>\n<tr>\n<td>pfs_psprel</td>\n<td>7</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>preds_when</td>\n<td>8</td>\n<td>t</td>\n</tr>\n<tr>\n<td>preds_psprel</td>\n<td>9</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>lc_when</td>\n<td>10</td>\n<td>t</td>\n</tr>\n<tr>\n<td>lc_psprel</td>\n<td>11</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>unat_when</td>\n<td>12</td>\n<td>t</td>\n</tr>\n<tr>\n<td>unat_psprel</td>\n<td>13</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>fpsr_when</td>\n<td>14</td>\n<td>t</td>\n</tr>\n<tr>\n<td>fpsr_psprel</td>\n<td>15</td>\n<td>pspoff</td>\n</tr>\n</tbody>\n</table>\nStack pointer offsets (spoff) are represented as positive word offsets from the top of the stack frame (i.e., the location is \\( sp + 4 \\times spoff \\)). Previous stack pointer offsets (pspoff) are encoded as positive numbers representing a negative word offset relative to psp+16 (i.e., the location is psp + 16 - 4 * pspoff).\n\nThis format is used for a number of descriptor records. The \\( r \\) field identifies the record type, as shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>r</th>\n<th>Additional ULEB128 Fields</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>rp_sprel</td>\n<td>1</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>pfs_sprel</td>\n<td>2</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>preds_sprel</td>\n<td>3</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>lc_sprel</td>\n<td>4</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>unat_sprel</td>\n<td>5</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>lpsr_sprel</td>\n<td>6</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>bsp_when</td>\n<td>7</td>\n<td>t</td>\n</tr>\n<tr>\n<td>bsp_psprel</td>\n<td>8</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>bsp_sprel</td>\n<td>9</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>bspstore_when</td>\n<td>10</td>\n<td>t</td>\n</tr>\n<tr>\n<td>bspstore_psprel</td>\n<td>11</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>bspstore_sprel</td>\n<td>12</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>rmat_when</td>\n<td>13</td>\n<td>t</td>\n</tr>\n<tr>\n<td>rmat_psprel</td>\n<td>14</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>rmat_sprel</td>\n<td>15</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>priunat_when_gr</td>\n<td>16</td>\n<td>t</td>\n</tr>\n<tr>\n<td>priunat_psprel</td>\n<td>17</td>\n<td>pspoff</td>\n</tr>\n<tr>\n<td>priunat_sprel</td>\n<td>18</td>\n<td>spoff</td>\n</tr>\n<tr>\n<td>priunat_when_mem</td>\n<td>19</td>\n<td>t</td>\n</tr>\n</tbody>\n</table>\n\nStack pointer offsets (spoff) are represented as positive word offsets from the top of the stack frame (i.e., the location is \\( sp + 4 \\times spoff \\)). Previous stack pointer offsets (pspoff) are encoded as positive numbers representing a negative word offset relative to psp+16 (i.e., the location is psp + 16 - 4 * pspoff).\n\nThis format is used only by the gr_gr descriptor record.\nThe bits in the grmask field correspond to the preserved general registers (r4–r7). The bits are read from right to left: bit 0 of byte 1 corresponds to r4, and bit 3 corresponds to r7.\n\nThe gr field identifies the general register in which the first of these registers is stored. Additional general registers are used as needed. For example, assume that r4, r5, and r7 are stored. The mask bits would be 1011, and gr might be set to 37, indicating that the three preserved general registers are stored in r37, r38, and r39, respectively.\n\n\n\nThis format is reserved for ABI-specific unwind descriptor records, typically to identify a region whose stack frame indicates some saved context record (e.g., a Unix signal context).\n\nThe values currently defined for the abi field are shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>ABI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>Unix SVR4</td>\n</tr>\n<tr>\n<td>1</td>\n<td>HP-UX</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Windows NT</td>\n</tr>\n</tbody>\n</table>\n\nThe interpretation of the context field is ABI dependent.\n\n### B.4 Descriptor Records for Body Regions\n\nThe epilogue, label_state, and copy_state descriptor records can each appear in two formats, depending on the magnitudes of their fields.\n\n\n\nThis record is used for the short form of label_state and copy_state descriptor records. If the label is no greater than 31, this format may be used; otherwise, format B4 must be used. The record types are shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>r</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>label_state</td>\n<td>0</td>\n</tr>\n<tr>\n<td>copy_state</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\nThis format is used only for the long form of the epilogue descriptor record. If the ecoun t field is no greater than 31, this format may be used; otherwise, format B3 must be used.\n\nThis format is used only for the long form of the label_state and copy_state descriptor records. The record types are shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>r</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>label_state</td>\n<td>0</td>\n</tr>\n<tr>\n<td>copy_state</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\n**B.5 Descriptor Records for Body or Prologue Regions**\n\nThe record formats listed here describe general spills and restores, and may appear in either body or prologue regions.\n\nThis format is used by the spill_psprel and spill_sprel descriptor records, which identify when a register is saved by spilling to the memory stack. The r bit identifies the record type, as shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>r</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>spill_psprel</td>\n<td>0</td>\n</tr>\n<tr>\n<td>spill_sprel</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\nThe a, b, and reg fields identify the register being spilled. The encodings are given in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>a</th>\n<th>b</th>\n<th>reg</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GR 4–7</td>\n<td>0</td>\n<td>0</td>\n<td>gr</td>\n</tr>\n<tr>\n<td>FR 2–5 or 16–31</td>\n<td>0</td>\n<td>1</td>\n<td>fr</td>\n</tr>\n<tr>\n<td>BR 1–5</td>\n<td>1</td>\n<td>0</td>\n<td>br</td>\n</tr>\n<tr>\n<td>Predicates</td>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>psp</td>\n<td>1</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>priunat</td>\n<td>1</td>\n<td>1</td>\n<td>2</td>\n</tr>\n<tr>\n<td>rp</td>\n<td>1</td>\n<td>1</td>\n<td>3</td>\n</tr>\n<tr>\n<td>ar.bsp</td>\n<td>1</td>\n<td>1</td>\n<td>4</td>\n</tr>\n<tr>\n<td>ar.bspstore</td>\n<td>1</td>\n<td>1</td>\n<td>5</td>\n</tr>\n<tr>\n<td>ar.mat</td>\n<td>1</td>\n<td>1</td>\n<td>6</td>\n</tr>\n<tr>\n<td>ar.unat</td>\n<td>1</td>\n<td>1</td>\n<td>7</td>\n</tr>\n<tr>\n<td>ar.fpsr</td>\n<td>1</td>\n<td>1</td>\n<td>8</td>\n</tr>\n<tr>\n<td>ar.pls</td>\n<td>1</td>\n<td>1</td>\n<td>9</td>\n</tr>\n<tr>\n<td>ar.lc</td>\n<td>1</td>\n<td>1</td>\n<td>10</td>\n</tr>\n</tbody>\n</table>\n\nThis format is used only by the spill_reg descriptor record, which identifies when a register is saved by copying to another register, or when a register is restored from its spill location. The register being saved or restored is identified by the a, b, and reg fields, using the same encodings given above for Format X1. The target register to which the saved register is copied is identified by the x, y, and treg fields; a special encoding also indicates the “restore” operation. The encodings for these fields are given in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th>x</th>\n<th>y</th>\n<th>treg</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Restore</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>GR 1–127</td>\n<td>0</td>\n<td>0</td>\n<td>gr</td>\n</tr>\n<tr>\n<td>FR 2–127</td>\n<td>0</td>\n<td>1</td>\n<td>fr</td>\n</tr>\n<tr>\n<td>BR 0–7</td>\n<td>1</td>\n<td>0</td>\n<td>br</td>\n</tr>\n</tbody>\n</table>\n\nFormat X2\n\nThis format is used only by the spill_reg descriptor record, which identifies when a register is saved by copying to another register, or when a register is restored from its spill location. The register being saved or restored is identified by the a, b, and reg fields, using the same encodings given above for Format X1. The target register to which the saved register is copied is identified by the x, y, and treg fields; a special encoding also indicates the “restore” operation. The encodings for these fields are given in the following table:\nThis format is used by the `spill_psprel_p` and `spill_sprel_p` descriptor records, which identify when a register is saved under control of a predicate. The `r` bit identifies the record type, as shown in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Record Type</th>\n<th><code>r</code></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>spill_psprel_p</code></td>\n<td>0</td>\n</tr>\n<tr>\n<td><code>spill_sprel_p</code></td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\nThe `qp` field identifies the controlling predicate. The remaining fields are encoded the same as Format X1.\n\nThis format is used only by the `spill_reg_p` descriptor record, which identifies when a register is saved to another register under control of a predicate, or when a register is restored under control of a predicate.\n\nThe `qp` field identifies the controlling predicate. The remaining fields are encoded the same as Formats X1 and X2."}}},{"rowIdx":160,"cells":{"id":{"kind":"string","value":"51c6204e5fb648a42030e29ccbe018d33a575ddf"},"text":{"kind":"string","value":"Package ‘iSEE’\n\nMay 8, 2024\n\nTitle Interactive SummarizedExperiment Explorer\nVersion 2.16.0\nDate 2024-04-04\nDescription Create an interactive Shiny-based graphical user interface for exploring data stored in SummarizedExperiment objects, including row- and column-level metadata. The interface supports transmission of selections between plots and tables, code tracking, interactive tours, interactive or programmatic initialization, preservation of app state, and extensibility to new panel types via S4 classes. Special attention is given to single-cell data in a SingleCellExperiment object with visualization of dimensionality reduction results.\n\nDepends SummarizedExperiment, SingleCellExperiment\nImports methods, BiocGenerics, S4Vectors, utils, stats, shiny, shinydashboard, shinyAce, shinyjs, DT, rintrojs, ggplot2, ggrepel, colourpicker, igraph, vipor, mgcv, graphics, grDevices, viridisLite, shinyWidgets, listviewer, ComplexHeatmap, circlize, grid\nSuggests testthat, covr, BiocStyle, knitr, rmarkdown, scRNAseq, TENxPBMCData, scater, DelayedArray, HDF5Array, RColorBrewer, viridis, htmltools\n\nURL https://github.com/iSEE/iSEE\nBugReports https://github.com/iSEE/iSEE/issues\nbiocViews CellBasedAssays, Clustering, DimensionReduction, FeatureExtraction, GeneExpression, GUI, ImmunoOncology, ShinyApps, SingleCell, Transcription, Transcriptomics, Visualization\nLicense MIT + file LICENSE\nVignetteBuilder knitr\nEncoding UTF-8\nRoxygenNote 7.3.1\ngit_url https://git.bioconductor.org/packages/iSEE\nContents\n\n.git_branch RELEASE_3_19\n.git_last_commit ef6667f\n.git_last_commit_date 2024-04-30\nRepository Bioconductor 3.19\nDate/Publication 2024-05-08\n\nAuthor Kevin Rue-Albrecht [aut, cre] (<https://orcid.org/0000-0003-3899-3872>),\n Federico Marini [aut] (<https://orcid.org/0000-0003-3252-7758>),\n Charlotte Soneson [aut] (<https://orcid.org/0000-0003-3833-2169>),\n Aaron Lun [aut] (<https://orcid.org/0000-0002-3564-4813>)\n\nMaintainer Kevin Rue-Albrecht <kevinrue67@gmail.com>\n\nContents\n\n.. addCustomLabelsCommands ........................................... 4\n.. addLabelCentersCommands ........................................... 4\n.. addMultiSelectionPlotCommands ..................................... 5\n.. addTourStep .......................................................... 6\n.. buildLabs ............................................................ 7\n.. conditionalOnRadio .................................................. 8\n.. createCustomDimnamesModalObservers ................................ 9\n.. createUnprotectedParameterObservers ............................... 10\n.. extractAssaySubmatrix ............................................... 11\n.. fullName ............................................................ 12\n.. panelColor .......................................................... 13\n.. processMultiSelections .............................................. 14\n.. removeInvalidChoices ................................................ 15\n.. replaceMissingWithFirst ............................................ 16\n.. requestUpdate ....................................................... 17\n.. retrieveOutput ...................................................... 18\n.. setCachedCommonInfo ................................................ 19\n.. aes-utils ............................................................ 20\n.. cache-utils .......................................................... 21\n.. checkColormapCompatibility ....................................... 22\n.. class-utils .......................................................... 23\n.. cleanDataset ........................................................ 24\n.. collapseBox .......................................................... 25\n.. ColumnDataPlot-class ............................................... 26\n.. ColumnDataTable-class ............................................... 29\n.. ColumnDotPlot-class ............................................... 30\n.. columnSelectionColorMap .......................................... 33\n.. ColumnTable-class .................................................. 34\n.. ComplexHeatmapPlot-class ......................................... 35\n.. constants ........................................................... 39\n.. createCustomPanels .................................................. 40\n.. createLandingPage ................................................... 42\n.. defaultTour .......................................................... 44\n.addCustomLabelsCommands\n\nAdd custom label plotting commands\n\nDescription\n\nAdd ggplot instructions to add custom labels to specified points in a DotPlot. This is a utility function that is intended for use in .generateDotPlot.\n\nUsage\n\n.addCustomLabelsCommands(x, commands, plot_type)\n\nArguments\n\nx An instance of a DotPlot class.\ncommands A character vector representing the sequence of commands to create the ggplot object.\nplot_type String specifying the type of plot, e.g., \"scatter\", \"square\", \"violin\".\n\nValue\n\nA character vector containing commands plus any additional commands required to generate the labels.\n\nAuthor(s)\n\nKevin Rue-Albrecht, Aaron Lun\n\n.addLabelCentersCommands\n\nAdd centered label plotting commands\n\nDescription\n\nAdd ggplot instructions to label the center of each group on a scatter plot. This is a utility function that is intended for use in .generateDotPlot.\n\nUsage\n\n.addLabelCentersCommands(x, commands)\nArguments\n\nx An instance of a DotPlot class.\ncommands A character vector representing the sequence of commands to create the ggplot object.\n\nValue\n\nA character vector containing commands plus any additional commands required to generate the labels.\n\nAuthor(s)\n\nAaron Lun\n\nDescription\n\nAdd ggplot instructions to create brushes and lassos for both saved and active multiple selections in a DotPlot panel.\n\nUsage\n\n.addMultiSelectionPlotCommands(x, envir, commands, flip = FALSE)\n\nArguments\n\nx An instance of a DotPlot class.\nenvir The environment in which the ggplot commands are to be evaluated.\ncommands A character vector representing the sequence of commands to create the ggplot object.\nflip A logical scalar indicating whether the x- and y-axes are flipped, only relevant to horizontal violin plots.\n\nDetails\n\nThis is a utility function that is intended for use in .generateDotPlot. It will modify envir by adding all_active and all_saved variables, so developers should not use these names for their own variables in envir.\n\nIf no self-selection structures exist in x, commands is returned directly without modification.\n\nValue\n\nA character vector containing commands plus any additional commands required to draw the self selections.\nAuthor(s)\nAaron Lun\n\nDescription\nUtility to add a step to the panel-specific `rintrojs` tour, generating the element tag automatically.\n\nUsage\n`.addTourStep(x, field, text, is_selectize = FALSE)`\n\nArguments\n- `x`: A `Panel` object to be toured.\n- `field`: String containing the name of the slot of `x`, itself corresponding to an interface element to highlight.\n- `text`: String containing the text to show in the corresponding step of the tour.\n- `is_selectize`: Logical scalar indicating whether `field` corresponds to a selectize element.\n\nValue\nCharacter vector of length two. The first entry contains the element tag to identify the interface element to highlight, while the second entry contains the text.\n\nAlternatively, NULL may be returned if `.hideInterface(x, field)` indicates that the corresponding interface element has been hidden.\n\nAuthor(s)\nAaron Lun\n.buildLabs\n\nGenerate ggplot title and label instructions\n\nDescription\n\nGenerate ggplot title and label instructions\n\nUsage\n\n.buildLabs(\n x = NULL,\n y = NULL,\n color = NULL,\n shape = NULL,\n size = NULL,\n fill = NULL,\n group = NULL,\n title = NULL,\n subtitle = NULL\n)\n\nArguments\n\nx The character label for the horizontal axis.\ny x The character label for the vertical axis.\ncolor The character title for the color scale legend.\nshape The character title for the point shape legend.\nsize The character title for the point size legend.\nfill The character title for the color fill legend.\ngroup The character title for the group legend.\ntitle The character title for the plot title.\nsubtitle The character title for the plot subtitle\n\nDetails\n\nIf any argument is NULL, the corresponding label is not set.\n\nValue\n\nTitle and label instructions for ggplot as a character value.\n\nAuthor(s)\n\nKevin Rue-Albrecht\nExamples\n\n```r\ncat(.buildLabs(y = \"Title for Y axis\", color = \"Color label\"))\n```\n\nDescription\n\nCreates a conditional UI element that appears when the user picks a certain choice in a radio button, single checkbox or checkbox group interface element.\n\nUsage\n\n```r\n.conditionalOnRadio(id, choice, ...)\n.conditionalOnCheckSolo(id, on_select = TRUE, ...)\n.conditionalOnCheckGroup(id, choice, ...)\n```\n\nArguments\n\n- `id` String containing the ID of the UI element controlling the relevant choice.\n- `choice` String containing the choice for the radio button or checkbox group on which to show the conditional element(s).\n- `...` UI elements to show conditionally.\n- `on_select` Logical scalar specifying whether the conditional element should be shown upon selection in a check box, or upon de-selection (if FALSE).\n\nDetails\n\nThese functions are just wrappers around `conditionalPanel`, with the added value coming from the pre-written conditional expressions in Javascript. They are useful for hiding elements that are only relevant when the right radio button or checkbox is selected. This means that we avoid cluttering the UI with options that are not immediately useful to the user.\n\nValue\n\nA HTML object containing interface elements in ... that only appear when the relevant condition is satisfied.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\n`conditionalPanel`, which is used under the hood.\nDescription\n\nCreate observers to launch a modal where users can input a list of custom row or column names. These observers register input changes in the app’s memory and request an update to the affected panel.\n\nUsage\n\n```r\n.createCustomDimnamesModalObservers(\n plot_name,\n slot_name,\n button_name,\n se,\n input,\n session,\n pObjects,\n rObjects,\n source_type\n)\n```\n\nArguments\n\n- `plot_name`: String containing the name of the current panel.\n- `slot_name`: String specifying the slot of containing the names of the custom features. This will be modified by user interactions with the modal.\n- `button_name`: String containing the name of the button in the panel UI that launches the modal.\n- `se`: A `SummarizedExperiment` object after running `.cacheCommonInfo`.\n- `input`: The Shiny input object from the server function.\n- `session`: The Shiny session object from the server function.\n- `pObjects`: An environment containing global parameters generated in the iSEE app.\n- `rObjects`: A reactive list of values generated in the iSEE app.\n- `source_type`: String specifying the type of the panel that is source of the selection, either \"row\" or \"column\".\n\nDetails\n\nThis should be called in `.createObservers` for the target panel. It assumes that a button element with the suffix `button_name` is available in the UI (i.e., the full name is created by concatenated `plot_name` with `button_name`).\nThe modal UI provides options to sort the dimnames, validate them, clear the current text and import a selection from a specified row transmitter. These are all transient until “Apply” is clicked, at which point the app’s memory is modified and an update is requested.\n\nThe custom names are stored in the slot_name as a single string with names separated by newlines. Hashes are treated as comments and any content after a hash is ignored when interpreting the names. Any leading and trailing whitespace is also ignored during interpretation.\n\nValue\nObservers are set up to launch the modal and monitor its UI elements. A NULL is invisibly returned.\n\nAuthor(s)\nKevin Rue-Albrecht\n\n---\n\n**.createUnprotectedParameterObservers**\n\n*Define parameter observers*\n\n---\n\n**Description**\n\nDefine a series of observers to track “protected” or “unprotected” parameters for a given panel. These will register input changes to each specified parameter in the app’s memory and request an update to the output of the affected panel.\n\n**Usage**\n\n```\n.createUnprotectedParameterObservers(\n panel_name, \n fields, \n input, \n pObjects, \n rObjects, \n ignoreInit = TRUE, \n ignoreNULL = TRUE\n)\n```\n\n```\n.createProtectedParameterObservers(\n panel_name, \n fields, \n input, \n pObjects, \n rObjects, \n ignoreInit = TRUE, \n ignoreNULL = TRUE\n)\n```\nArguments\n\n- `panel_name` - String containing the name of the panel.\n- `fields` - Character vector of names of parameters for which to set up observers.\n- `input` - The Shiny input object from the server function.\n- `pObjects` - An environment containing global parameters generated in the iSEE app.\n- `rObjects` - A reactive list of values generated in the iSEE app.\n- `ignoreInit`, `ignoreNULL` - Further arguments to pass to `observeEvent`.\n\nDetails\n\nA protected parameter is one that breaks existing multiple selections, e.g., by changing the actual data being plotted. Alterations to protected parameters will clear all active and saved selections in the panel, as those existing selections are assumed to not make any sense in the context of the modified output of that panel.\n\nBy comparison, an unprotected parameter only changes the aesthetics and will not clear existing selections.\n\nValue\n\nObservers are set up to monitor the UI elements that can change the protected and non-fundamental parameters. A NULL is invisibly returned.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\n- `.requestUpdate` and `.requestCleanUpdate`, used to trigger updates to the panel output.\n\nDescription\n\nExtract an assay submatrix based on the multiple row/column selection and any custom specifications from `.createCustomDimnamesModalObservers`.\n\nUsage\n\n```\n.extractAssaySubmatrix(x, se, envir, use_custom_row_slot, custom_row_text_slot)\n```\nArguments\n\n- **x**: A Panel instance that uses the row selection modal.\n- **se**: The current SummarizedExperiment object.\n- **envir**: The evaluation environment. This assumes that `.processMultiSelections` has already been run.\n- **use_custom_row_slot**: String specifying the name of the slot indicating whether to use custom rows.\n- **custom_row_text_slot**: String specifying the name of the slot holding the custom row names. This is expected to be of the same format as described in `.createCustomDimnamesModalObservers`.\n\nDetails\n\nThis is designed to extract a matrix of assay values for a subset of rows/columns of interest, most typically for a ComplexHeatmapPlot. It assumes that the class of `x` contains a slot indicating whether custom rows should be used, plus a slot to hold the selected custom row names (usually from a modal, see `.createCustomDimnamesModalObservers`).\n\nIf a multiple row selection is present in `envir` and custom rows are not to be used, that selection is used to define the rows of the submatrix. All columns are returned in the submatrix unless a multiple column selection is present in `envir` and the SelectEffect in `x` is “Restrict”, in which case only the selected columns are returned.\n\nValue\n\nA character vector of commands to set up the assay submatrix. The submatrix itself is generated within `envir` as the `plot.data` variable.\n\nAuthor(s)\n\nKevin Rue-Albrecht\n\n---\n\n**.fullName** \n*Get panel names*\n\nDescription\n\nGet panel names\n\nUsage\n\n- `.fullName(x)`\n- `.getEncodedName(x)`\n- `.getFullName(x)`\nArguments\n\nx An instance of a Panel class.\n\nDetails\n\nThe encoded name is used internally as the name of various fields in input, output and reactive lists.\n\nThe full name is what should be shown in the interface and visible to the end-user.\n\nValue\n\nFor .getEncodedName, a string containing the encoded panel name of x.\n\nFor .fullName, a string containing the full (plain-English) name of the class.\n\nFor .getFullName, a string containing the full name of x.\n\nAuthor(s)\n\nAaron Lun\n\nDescription\n\nFunctions to get/set panel colors at the user and developer level. This determines the color of the panel header as well as (for DotPlots) the color and fill of the brush.\n\nUsage\n\n.panelColor(x)\n\n.getPanelColor(x)\n\nArguments\n\nx An instance of a Panel class.\n\nDetails\n\nFor developers: .panelColor is a method that should be subclassed for each Panel subclass. This determines the color theme for all instances of that class for use in, e.g., headers and box shadings. Developers should choose a color that is dark enough to serve as a background for white text. We recommend defining colors as hex color codes for full compatibility with both HTML elements and R plots.\n\nFor users: by default, .getPanelColor will return the default color of each panel as specified by the developer in .panelColor. However, users can override this by setting the panel.color global\noption to a named character vector of colors (see Examples). This can be used to customize the color scheme for any given call to iSEE. The names of the vector should be set to the name of class to be overridden; if a class is not named here, its default color is used.\n\nValue\n\nA string containing the color assigned to the class of x.\n\nAuthor(s)\n\nAaron Lun\n\nExamples\n\n```r\ndp <- ReducedDimensionPlot()\n\n# Default color, as specified by the developer:\n.panelColor(dp)\n\n# Still the default color:\n.getPanelColor(dp)\n\n# Overriding the default colors:\nsce <- SingleCellExperiment(list(logcounts=matrix(rnorm(1000), ncol=100)))\nreducedDim(sce, \"PCA\") <- matrix(runif(200), ncol=2)\n\nsce <- registerAppOptions(sce, panel.color=c(ReducedDimensionPlot=\"#1e90ff\"))\nif (interactive()) {\n iSEE(sce, initial=list(dp))\n}\n```\n\n.processMultiSelections\n\nProcess multiple selections\n\nDescription\n\nGenerate and execute commands to process multiple selections, creating variables in the evaluation environment with the identity of the selected rows or columns.\n\nUsage\n\n```r\n.processMultiSelections(x, all_memory, all_contents, envir)\n```\n.removeInvalidChoices\n\nArguments\n\nx An instance of a Panel class.\nall_memory A named list of Panel instances containing parameters for the current app state.\nall_contents A named list of arbitrary contents with one entry per panel.\nenvir The evaluation environment. This is assumed to already contain se, the SummarizedExperiment object for the current dataset.\n\nDetails\n\nThis function is primarily intended for use by developers of new panels. It should be called inside .generateOutput to easily process row/column multiple selections. Developers can check whether row_selected or col_selected exists in envir to determine whether any row or column selection was performed (and adjust the behavior of .generateOutput accordingly).\n\nValue\n\nenvir is populated with one, none or both of col_selected and/or row_selected, depending on whether x is receiving a multiple selection on the rows and/or columns. The return value is the character vector of commands required to construct those variables.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\n.generateOutput and its related generic .renderOutput, where this function should generally be used.\n\nDescription\n\nRemoves invalid values in a slot of a Panel object. This is usually called in .refineParameters.\n\nUsage\n\n.removeInvalidChoices(x, field, choices)\n\nArguments\n\nx An instance of a Panel class.\nfield String containing the name of the relevant slot.\nchoices Character vector of permissible values for this slot.\nValue\n\nx where the slot named field is replaced only with the values that exist in choices.\n\nAuthor(s)\n\nKevin Rue-Albrecht\n\nDescription\n\nReplace an NA or invalid value in a slot of a Panel object with the first valid choice. This is usually called in `refineParameters`.\n\nUsage\n\n```r\n.replaceMissingWithFirst(x, field, choices)\n```\n\nArguments\n\n- **x**: An instance of a Panel class.\n- **field**: String containing the name of the relevant slot.\n- **choices**: Character vector of permissible values for this slot.\n\nValue\n\nx where the slot named field is replaced with choices[1] if its value was previously NA or did not exist in choices.\n\nAuthor(s)\n\nAaron Lun\n.requestUpdate\n\nDescription\n\nRequest a re-rendering of the Panel output via reactive variables.\n\nUsage\n\n.requestUpdate(panel_name, rObjects)\n\n.requestCleanUpdate(panel_name, pObjects, rObjects)\n\n.requestActiveSelectionUpdate(\n panel_name,\n session,\n pObjects,\n rObjects,\n update_output = TRUE\n)\n\nArguments\n\npanel_name String containing the panel name.\nrObjects A reactive list of values generated in the iSEE app.\npObjects An environment containing global parameters generated in the iSEE app.\nsession The Shiny session object from the server function.\nupdate_output A logical scalar indicating whether to call .requestUpdate as well.\n\nDetails\n\n.requestUpdate should be used in various observers to request a re-rendering of the panel, usually in response to user-driven parameter changes in .createObservers.\n\n.requestCleanUpdate is used for changes to protected parameters that invalidate existing multiple selections, e.g., if the coordinates change in a DotPlot, existing brushes and lassos are usually not applicable.\n\n.requestActiveSelectionUpdate should be used in the observer expression that implements the panel’s multiple selection mechanism.\n\nValue\n\n.requestUpdate will modify rObjects to request a re-rendering of the specified panel.\n\n.requestCleanUpdate will also remove all active/saved selections in the chosen panel.\n.retrieveOutput will modify rObjects to indicate that the active multiple selection for panel_name has changed. If update_output=TRUE, it will also request a re-rendering of the panel.\n\nAll functions will invisibly return NULL.\n\nAuthor(s)\nAaron Lun\n\nSee Also\n.retrieveOutput, for examples where the update-requesting functions are used.\n\nDescription\nRetrieve the results of a previous .generateOutput call on this panel.\n\nUsage\n.retrieveOutput(panel_name, se, pObjects, rObjects)\n\nArguments\npanel_name String containing the panel name.\nse A SummarizedExperiment object containing the current dataset.\npObjects An environment containing global parameters generated in the iSEE app.\nrObjects A reactive list of values generated in the iSEE app.\n\nDetails\nThis function should be used in the rendering expression in .renderOutput. It takes care of a number of house-keeping tasks required to satisfy .renderOutput's requirements, e.g., responding to .requestUpdate modifications to rObjects, setting the commands and contents and varname in pObjects.\n\nThis function will attempt to retrieve the cached output of .generateOutput if it was used elsewhere in the app. After retrieval, the cached value is wiped to ensure that it does not go stale. If no cached value is found, .generateOutput is called directly.\n\nValue\nThe output of running .generateOutput for the current panel. Several fields in pObjects are also modified as a side-effect.\n.setCachedCommonInfo\n\nAuthor(s)\n Aaron Lun\n\nSee Also\n .renderOutput, where this function should be called.\n .generateOutput, which is called by this function.\n\nDescription\n Get and set common cached information for each class. The setter should only ever be called in\n .cacheCommonInfo. The getter can be called anywhere but most usually in .defineInterface.\n\nUsage\n .setCachedCommonInfo(se, cls, ...)\n .getCachedCommonInfo(se, cls)\n\nArguments\n se A SummarizedExperiment object containing the current dataset.\n cls String containing the name of the class for which this information is cached.\n ... Any number of named R objects to cache.\n\nValue\n .setCachedCommonInfo returns se with ... added to its int_metadata.\n .getCachedCommonInfo retrieves the cached common information for class cls.\n\nAuthor(s)\n Aaron Lun\n\nSee Also\n ?\"cache-utils\", for utilities to define some cached variables.\n\nExamples\n se <- SummarizedExperiment()\n se <- .setCachedCommonInfo(se, \"SomePanelClass\",\n something=1, more_things=TRUE, something_else=\"A\")\n .getCachedCommonInfo(se, \"SomePanelClass\")\nGenerate ggplot aesthetic instructions\n\nUsage\n\n```r\n.buildAes(\n x = TRUE,\n y = TRUE,\n color = FALSE,\n shape = FALSE,\n size = FALSE,\n fill = FALSE,\n group = FALSE,\n alt = NULL\n)\n```\n\nArguments\n\n- **x**: A logical that indicates whether to enable `x` in the aesthetic instructions (default: `TRUE`).\n- **y**: A logical that indicates whether to enable `y` in the aesthetic instructions (default: `TRUE`).\n- **color**: A logical that indicates whether to enable `color` in the aesthetic instructions (default: `FALSE`).\n- **shape**: A logical that indicates whether to enable `shape` in the aesthetic instructions (default: `FALSE`).\n- **size**: A logical that indicates whether to enable `size` in the aesthetic instructions (default: `FALSE`).\n- **fill**: A logical that indicates whether to enable `fill` in the aesthetic instructions (default: `FALSE`).\n- **group**: A logical that indicates whether to enable `group` in the aesthetic instructions (default: `FALSE`).\n- **alt**: Alternative aesthetics, supplied as a named character vector.\n\nValue\n\nAesthetic instructions for `ggplot` as a character value.\n\nAuthor(s)\n\nKevin Rue-Albrecht\nExamples\n\n`.buildAes()`\n\n---\n\n**cache-utils**\n\n*Caching utilities*\n\n**Description**\n\nUtility functions to be used in a `.cacheCommonInfo` method, usually to identify names of elements of the `SummarizedExperiment` for later use in `.defineInterface` to populate the user interface.\n\n**Usage**\n\n`.findAtomicFields(x)`\n\n`.whichGroupable(x, max_levels = Inf)`\n\n`.whichNumeric(x)`\n\n`.isAssayNumeric(se, i)`\n\n**Arguments**\n\n- **x**: A data.frame or DataFrame, most typically the `rowData` or `colData`\n- **max_levels**: Integer scalar specifying the maximum number unique values for `x` to be categorical.\n- **se**: The `SummarizedExperiment` object.\n- **i**: An integer scalar or string specifying the assay of interest in `se`.\n\n**Details**\n\n`.findAtomicFields` is necessary as many of the widgets used by `iSEE` (e.g., `ggplot`, `datatable`) do not know how to handle more complex types being stored as columns. Similarly, `.whichNumeric` and `.whichGroupable` can be used to specify options for visualization modes that only make sense for continuous or discrete variables respectively (e.g., sizing, faceting).\n\n**Value**\n\nFor `.findAtomicFields`, a character vector of names of columns in `x` containing atomic R types.\nFor `.whichNumeric`, an integer vector containing the indices of the numeric columns.\nFor `.whichGroupable`, an integer vector containing the indices of the categorical columns.\nFor `.isAssayNumeric`, a logical scalar indicating whether the specified assay as numeric.\n\n**Author(s)**\n\nAaron Lun, Kevin Rue-Albrecht, Charlotte Soneson\nExamples\n\n```r\nx <- DataFrame(\n A = rnorm(10),\n B = sample(letters, 10),\n DataFrame = I(DataFrame(\n C = rnorm(10),\n D = sample(letters, 10)\n ))\n)\n\n.findAtomicFields(x)\n.whichGroupable(x)\n.whichNumeric(x)\n```\n\nDescription\n\nThis function compares a pair of `ExperimentColorMap` and `SingleCellExperiment` objects, and examines whether all of the assays, `colData`, and `rowData` defined in the `ExperimentColorMap` object exist in the `SingleCellExperiment` object.\n\nUsage\n\n```r\ncheckColormapCompatibility(ecm, se)\n```\n\nArguments\n\n- `ecm` An `ExperimentColorMap`.\n- `se` A `SingleCellExperiment`.\n\nValue\n\nA character vector of incompatibility error messages, if any.\n\nAuthor(s)\n\nKevin Rue-Albrecht\nExamples\n\n# Example colormaps ----\n\ncount_colors <- function(n){\n c(\"black\",\"brown\",\"red\",\"orange\",\"yellow\")\n}\n\nqc_color_fun <- function(n){\n qc_colors <- c(\"forestgreen\", \"firebrick1\")\n names(qc_colors) <- c(\"Y\", \"N\")\n return(qc_colors)\n}\n\necm <- ExperimentColorMap(\n assays = list(\n tophat_counts = count_colors\n ),\n colData = list(\n passes_qc_checks_s = qc_color_fun\n )\n)\n\n# Example SingleCellExperiment ----\n\nlibrary(scRNAseq)\nsce <- ReprocessedAllenData(assays=\"tophat_counts\")\n\n# Test for compatibility ----\n\ncheckColormapCompatibility(ecm, sce)\n\nDescription\n\nA utility function to set slots to default values if their values are not provided to initialize methods.\n\nUsage\n\n.emptyDefault(args, field, default)\n\nArguments\n\nargs A named list of arguments to pass to the initialize method for a given class.\nfield String specifying the field to set.\ndefault The default value of the slot in field.\nA more natural approach would be to have the default values in the arguments of the initialize method. However, this would require us to hard-code the slot names in the function signature, which would break our current DRY model of only specifying the slot names once.\n\nValue\n\nargs is returned with the named field set to default if it was previously absent.\n\nAuthor(s)\n\nAaron Lun, Kevin Rue-Albrecht\n\nExamples\n\nshowMethods(\"initialize\", classes = \"ReducedDimensionPlot\", includeDefs = TRUE)\n\ncleanDataset Clean the dataset\n\nDescription\n\nClean the SummarizedExperiment by making sure that names of various fields are available and unique.\n\nUsage\n\ncleanDataset(se)\n\n## S4 method for signature 'SummarizedExperiment'\ncleanDataset(se)\n\n## S4 method for signature 'SingleCellExperiment'\ncleanDataset(se)\n\nArguments\n\nse A SummarizedExperiment object or one of its subclasses.\n\nDetails\n\nVarious Panels assume that the row and column names of the input SummarizedExperiment are available and unique. This function enforces that, adding consecutive integer names if not available and calling make.unique if they are duplicated.\n\nVarious Panels further assume that the assay, rowData, colData names are unique; if this is not the case, selectInput behaves in unexpected (and incorrect) ways. This function enforces that as well by running them through make.unique.\n\nFor SingleCellExperiment object, we enforce uniqueness in the reducedDims.\n\nAll changes result in warnings as a “sensible” object is not expected to require any work.\nValue\n\nA cleaned version of se.\n\nAuthor(s)\n\nAaron Lun\n\nExamples\n\n# Creating a very naughty SE.\nses <- SummarizedExperiment(list(cbind(1:10, 2:11), cbind(2:11, 3:12)),\ncolData=DataFrame(A=1:2, A=3:4, check.names=FALSE),\nrowData=DataFrame(B=1:10, B=1:10, check.names=FALSE))\nse\n\ncleanDataset(se)\n\nDescription\n\nA custom collapsible box with Shiny inputs upon collapse, more or less stolen from shinyBS.\n\nUsage\n\ncollapseBox(id, title, ..., open = FALSE, style = NULL)\n\nArguments\n\nid String specifying the identifier for this object, to use as a field of the Shiny input.\ntitle String specifying the title of the box for use in the UI.\n... Additional UI elements to show inside the box.\nopen Logical scalar indicating whether this box should be open upon initialization.\nstyle String specifying the box style, defaults to \"default\".\n\nDetails\n\nCollapsible boxes are used to hold parameters in the “parameter boxes” described in defineInterface. It is recommended to format the id as PANEL_SLOT where PANEL is the name of the panel associated with the box and SLOT is the name of the slot that specifies whether this box should be open or not at initialization. (See Panel for some examples with DataBoxOpen.)\n\nDo not confuse these boxes with the shinydashboard::boxes, which are used to hold the plot and table panels. Adding to the nomenclature confusion is the fact that our collapsible boxes are implemented in Javascript using the Bootstrap “panel” classes, which in turn has nothing to do with our Panel classes.\nValue\n\nA HTML tag object containing a collapsible box.\n\nComments on shinyBS\n\nWe would have preferred to use bsCollapse from shinyBS. However, that package does not seem to be under active maintenance, and there are several aspects that make it difficult to use. Specifically, it does not seem to behave well with conditional elements inside the box, and it also does needs a Depends: relationship with shinyBS.\n\nFor these reasons, we created our own collapsible box, taking code from shinyBS where appropriate. The underlying Javascript code for this object is present in inst/www and is attached to the search path for Shiny resources upon loading iSEE.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\nshinyBS, from which the Javascript code was derived.\n\n.defineInterface, which should return a list of these collapsible boxes.\n\nExamples\n\nlibrary(shiny)\ncollapseBox(\"SomePanelType1_ParamBoxOpen\",\n title=\"Custom parameters\",\n open=FALSE,\n selectInput(\"SomePanelType1_Thing\",\n label=\"What thing?\",\n choices=LETTERS, selected=\"A\")\n)\n\nColumnDataPlot-class\n\nThe ColumnDataPlot panel\n\nDescription\n\nThe ColumnDataPlot is a panel class for creating a ColumnDotPlot where the y-axis represents a variable from the colData of a SummarizedExperiment object. It provides slots and methods for specifying which variable to use on the y-axis (and, optionally, also the x-axis), as well as a method to create the data.frame in preparation for plotting.\nSlot overview\n\nThe following slots control the column data information that is used:\n\n- **YAxis**, a string specifying the column of the `colData` to show on the y-axis. If NA, defaults to the first valid field (see ?\\`\\`refineParameters,ColumnDotPlot-method\\`\\`).\n- **XAxis**, string specifying what should be plotting on the x-axis. This can be any one of \"None\", \"Column data\" or \"Column selection\". Defaults to \"None\".\n- **XAxisColumnData**, string specifying the column of the `colData` to show on the x-axis. If NA, defaults to the first valid field.\n\nIn addition, this class inherits all slots from its parent ColumnDotPlot, DotPlot and Panel classes.\n\nConstructor\n\nColumnDataPlot(...) creates an instance of a ColumnDataPlot class, where any slot and its value can be passed to ... as a named argument.\n\nSupported methods\n\nIn the following code snippets, x is an instance of a ColumnDataPlot class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- `.refineParameters(x, se)` returns x after replacing any NA value in YAxis or XAxisColumnData with the name of the first valid colData variable. This will also call the equivalent ColumnDotPlot method for further refinements to x. If no valid column metadata variables are available, NULL is returned instead.\n\nFor defining the interface:\n\n- `.defineDataInterface(x, se, select_info)` returns a list of interface elements for manipulating all slots described above.\n- `.panelColor(x)` will return the specified default color for this panel class.\n- `.allowableXAxisChoices(x, se)` returns a character vector specifying the acceptable variables in `colData(se)` that can be used as choices for the x-axis. This consists of all variables with atomic values.\n- `.allowableYAxisChoices(x, se)` returns a character vector specifying the acceptable variables in `colData(se)` that can be used as choices for the y-axis. This consists of all variables with atomic values.\n\nFor monitoring reactive expressions:\n\n- `.createObservers(x, se, input, session, pObjects, rObjects)` sets up observers for all slots described above and in the parent classes. This will also call the equivalent ColumnDotPlot method.\n\nFor controlling selections:\n- `.multiSelectionInvalidated(x)` returns `TRUE` if the x-axis uses multiple column selections, such that the point coordinates may change upon updates to upstream selections in transmitting panels. Otherwise, it dispatches to the `ColumnDotPlot` method.\n\nFor defining the panel name:\n- `.fullName(x)` will return \"Column data plot\".\n\nFor creating the plot:\n- `.generateDotPlotData(x, envir)` will create a data.frame of column metadata variables in `envir`. It will return the commands required to do so as well as a list of labels.\n\nFor documentation:\n- `.definePanelTour(x)` returns an data.frame containing a panel-specific tour.\n\n**Subclass expectations**\nSubclasses do not have to provide any methods, as this is a concrete class.\n\n**Author(s)**\nAaron Lun\n\n**See Also**\n- `ColumnDotPlot`, for the immediate parent class.\n\n**Examples**\n\n```\n# For end-users #\nx <- ColumnDataPlot()\nx[\"XAxis\"]\nx[\"XAxis\"] <- \"Column data\"\n\n# For developers #\nlibrary(scater)\nsce <- mockSCE()\nsce <- logNormCounts(sce)\nold_cd <- colData(sce)\ncolData(sce) <- NULL\n\n# Spits out a NULL and a warning if there is nothing to plot.\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n```\n# Replaces the default with something sensible.\ncolData(sce) <- old_cd\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n\nColumnDataTable-class\n\nThe ColumnDataTable panel\n\nDescription\n\nThe ColumnDataTable is a panel class for creating a ColumnTable where the value of the table\nis defined as the colData of the SummarizedExperiment. It provides functionality to extract the\ncolData to coerce it into an appropriate data.frame in preparation for rendering.\n\nSlot overview\n\nThis class inherits all slots from its parent ColumnTable and Table classes.\n\nConstructor\n\nColumnDataTable(...) creates an instance of a ColumnDataTable class, where any slot and its\nvalue can be passed to ... as a named argument.\n\nNote that ColSearch should be a character vector of length equal to the total number of columns in\nthe colData, though only the entries for the atomic fields will actually be used.\n\nSupported methods\n\nIn the following code snippets, x is an instance of a ColumnDataTable class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n* .cacheCommonInfo(x) adds a \"ColumnDataTable\" entry containing valid.colData.names,\na character vector of names of atomic columns of the colData. This will also call the equivalent ColumnTable method.\n\n* .refineParameters(x, se) adjusts ColSearch to a character vector of length equal to the\nnumber of atomic fields in the colData. This will also call the equivalent ColumnTable\nmethod for further refinements to x.\n\nFor defining the interface:\n\n* .fullName(x) will return \"Column data table\".\n\n* .panelColor(x) will return the specified default color for this panel class.\n\nFor creating the output:\n• \\texttt{.generateTable}(x, \\texttt{envir}) will modify \\texttt{envir} to contain the relevant \\texttt{data.frame} for display, while returning a character vector of commands required to produce that \\texttt{data.frame}. Each row of the \\texttt{data.frame} should correspond to a column of the \\texttt{SummarizedExperiment}.\n\nFor documentation:\n\n• \\texttt{.definePanelTour}(x) returns a \\texttt{data.frame} containing the steps of a panel-specific tour.\n\nUnless explicitly specialized above, all methods from the parent class \\texttt{Panel} are also available.\n\n**Author(s)**\n\nAaron Lun\n\n**Examples**\n\n```\n# For end-users\nx <- ColumnDataTable()\nx[[\"Selected\"]]\nx[[\"Selected\"]]\n<- \"SOME_SAMPLE_NAME\"\n```\n\n```\n# For developers\nlibrary(scater)\nsce <- mockSCE()\n```\n\n# Search column refinement works as expected.\nsce0 <- \\texttt{.cacheCommonInfo}(x, sce)\n\\texttt{.refineParameters}(x, sce0)\n\n---\n\n**ColumnDotPlot-class** \\textit{The ColumnDotPlot virtual class}\n\n**Description**\n\nThe ColumnDotPlot is a virtual class where each column in the \\texttt{SummarizedExperiment} is represented by no more than one point (i.e., a “dot”) in a brushable \\texttt{ggplot} plot. It provides slots and methods to extract \\texttt{colData} fields to control the per-point aesthetics on the plot. This panel will transmit column identities in both its single and multiple selections, and it can receive multiple column selections but not multiple row selections.\nSlot overview\n\nThe following slots control coloring of the points:\n\n- **ColorByColumnData**, a string specifying the `colData` field for controlling point color, if `ColorBy=\"Column data\"` (see the `Panel` class). Defaults to the first valid field (see `.cacheCommonInfo` below).\n\n- **ColorByFeatureNameAssay**, a string specifying the assay of the SummarizedExperiment object containing values to use for coloring, if `ColorBy=\"Feature name\"`. Defaults to \"logcounts\" in `getPanelDefault`, falling back to the name of the first valid assay (see `?`.cacheCommonInfo,DotPlot-method\" for the definition of validity).\n\n- **ColorBySampleNameColor**, a string specifying the color to use for coloring an individual sample on the plot, if `ColorBy=\"Sample name\"`. Defaults to \"red\" in `getPanelDefault`.\n\nThe following slots control other metadata-related aesthetic aspects of the points:\n\n- **ShapeByColumnData**, a string specifying the `colData` field for controlling point shape, if `ShapeBy=\"Column data\"` (see the `Panel` class). The specified field should contain categorical values; defaults to the first such valid field.\n\n- **SizeByColumnData**, a string specifying the `colData` field for controlling point size, if `SizeBy=\"Column data\"` (see the `Panel` class). The specified field should contain continuous values; defaults to the first such valid field.\n\n- **TooltipColumnData**, a character vector specifying `colData` fields to show in the tooltip. Defaults to `character(0)`, which displays only the `colnames` value of the data point.\n\nIn addition, this class inherits all slots from its parent `DotPlot` and `Panel` classes.\n\nSupported methods\n\nIn the following code snippets, `x` is an instance of a `ColumnDotPlot` class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- **.cacheCommonInfo(x)** adds a \"ColumnDotPlot\" entry containing `valid.colData.names`, a character vector of names of columns that are valid (i.e., contain atomic values); `discrete.colData.names`, a character vector of names for columns with discrete atomic values; and `continuous.colData.names`, a character vector of names of columns with continuous atomic values. This will also call the equivalent `DotPlot` method.\n\n- **.refineParameters(x, se)** replaces NA values in `ColorByFeatAssay` with the first valid assay name in `se`. This will also call the equivalent `DotPlot` method.\n\nFor defining the interface:\n\n- **.hideInterface(x, field)** returns a logical scalar indicating whether the interface element corresponding to `field` should be hidden. This returns TRUE for row selection parameters (\"RowSelectionSource\" and \"RowSelectionRestrict\"), otherwise it dispatches to the `Panel` method.\n\nFor monitoring reactive expressions:\n- **createObservers**(x, se, input, session, pObjects, rObjects) sets up observers for all slots described above and in the parent classes. This will also call the equivalent DotPlot method.\n\nFor controlling selections:\n\n- **multiSelectionRestricted**(x) returns a logical scalar indicating whether x is restricting the plotted points to those that were selected in a transmitting panel.\n- **multiSelectionDimension**(x) returns \"column\" to indicate that a multiple column selection is being transmitted.\n- **multiSelectionInvalidated**(x) returns TRUE if the faceting options use multiple column selections, such that the point coordinates/domain may change upon updates to upstream selections in transmitting panels.\n- **singleSelectionDimension**(x) returns \"sample\" to indicate that a sample identity is being transmitted.\n\nFor documentation:\n\n- **definePanelTour**(x) returns an data.frame containing the steps of a tour relevant to subclasses, mostly tuning the more generic descriptions from the same method of the parent DotPlot.\n- **getDotPlotColorHelp**(x, color_choices) returns a data.frame containing the documentation for the \"ColorBy\" UI element, specialized for column-based dot plots.\n\nUnless explicitly specialized above, all methods from the parent classes DotPlot and Panel are also available.\n\n**Subclass expectations**\n\nSubclasses are expected to implement methods for, at least:\n\n- **generateDotPlotData**\n- **fullName**\n- **panelColor**\n\nThe method for **generateDotPlotData** should create a plot.data data.frame with one row per column in the SummarizedExperiment object.\n\n**Author(s)**\n\nAaron Lun\n\n**See Also**\n\nDotPlot, for the immediate parent class that contains the actual slot definitions.\ncolumnSelectionColorMap\n\n*Define the selection colormap*\n\n**Description**\n\nDefine the colormap when coloring points in a DotPlot based on their assigned multiple row/column selection.\n\n**Usage**\n\n\\[\n\\text{columnSelectionColorMap}(x, \\text{levels}) \\\\\n\\text{rowSelectionColorMap}(x, \\text{levels})\n\\]\n\n**Arguments**\n\n- **x**\n - An ExperimentColorMap object.\n- **levels**\n - Character vector containing the available levels of a ColorBy column derived from a series of multiple selections, usually generated by `multiSelectionToFactor` on the selection information in `row_selected` or `col_selected`.\n\n**Details**\n\nThe \"unselected\" level is always assigned the grey color; colors for all other levels are generated by `colDataColorMap(x)` or `rowDataColorMap(x)`. The \"active\" level is always assigned the first color from these functions, regardless of whether it is present in `levels`. This aims to provide some consistency in the coloring when the selections change.\n\n**Value**\n\nA named character vector of colors for each level in `levels`.\n\n**Author(s)**\n\nAaron Lun\n\n**Examples**\n\n```r\necm <- ExperimentColorMap()\ncolumnSelectionColorMap(ecm, c(\"active\", \"unselected\"))\ncolumnSelectionColorMap(ecm, c(\"active\", \"saved1\", \"unselected\"))\ncolumnSelectionColorMap(ecm, c(\"saved1\", \"unselected\"))\ncolumnSelectionColorMap(ecm, c(\"saved1\"))\n```\nThe ColumnTable class\n\nDescription\n\nThe ColumnTable is a virtual class where each column in the SummarizedExperiment is represented by no more than row in a datatable widget. In panels of this class, single and multiple selections can only be transmitted on the samples.\n\nSlot overview\n\nNo new slots are added. All slots provided in the Table parent class are available.\n\nSupported methods\n\nIn the following code snippets, x is an instance of a ColumnTable class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- **.refineParameters(x, se)** replaces NA values in Selected with the first column name of se. This will also call the equivalent Table method.\n\nFor defining the interface:\n\n- **.hideInterface(x, field)** returns a logical scalar indicating whether the interface element corresponding to field should be hidden. This returns TRUE for row selection parameters (\"RowSelectionSource\" and \"RowSelectionRestrict\"), otherwise it dispatches to the Panel method.\n\nFor monitoring reactive expressions:\n\n- **.createObservers(x, se, input, session, pObjects, rObjects)** sets up observers to propagate changes in the Selected to linked plots. This will also call the equivalent Table method.\n\nFor controlling selections:\n\n- **.multiSelectionDimension(x)** returns \"column\" to indicate that a column selection is being transmitted.\n\n- **.singleSelectionDimension(x)** returns \"sample\" to indicate that a sample identity is being transmitted.\n\nFor rendering output:\n\n- **.showSelectionDetails(x)** returns a HTML element containing details about the selected row. This requires a function to be registered by registerAppOptions under the option name \"ColumnTable.select.details\". The function should take a string containing the name of a feature (i.e., the current selection in the ColumnTable) and returns a HTML element. If no function is registered, NULL is returned.\n\nUnless explicitly specialized above, all methods from the parent classes Table and Panel are also available.\nSubclass expectations\n\nSubclasses are expected to implement methods for:\n\n- `.generateTable`\n- `.fullName`\n- `.panelColor`\n\nThe method for `.generateTable` should create a tab data.frame where each row corresponds to a column in the `SummarizedExperiment` object.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\nTable, for the immediate parent class that contains the actual slot definitions.\n\nThe ComplexHeatmapPlot panel\n\nDescription\n\nThe ComplexHeatmapPlot is a panel class for creating a Panel that displays an assay of a `SummarizedExperiment` object as a Heatmap with features as rows and samples and columns, respectively. It provides slots and methods for specifying the features of interest, which assay to display in the main heatmap, any transformations to perform on the data, and which metadata variables to display as row and column heatmap annotations.\n\nComplexHeatmapPlot slot overview\n\nThe following slots control the rows that are used:\n\n- `CustomRows`, a logical scalar indicating whether the custom list of rows should be used. If FALSE, the incoming selection is used instead. Defaults to TRUE.\n- `CustomRowsText`, string containing newline-separated row names. This specifies which rows of the `SummarizedExperiment` object are to be shown in the heatmap. If NA, defaults to the first row name of the SummarizedExperiment.\n\nThe following slots control the metadata variables that are used:\n\n- `ColumnData`, a character vector specifying columns of the `colData` to show as `columnAnnotation`. Defaults to character(0).\n- `RowData`, a character vector specifying columns of the `rowData` to show as `rowAnnotation`. Defaults to character(0).\n- **ShowColumnSelection**, a logical vector indicating whether the column selection should be shown as an extra annotation bar. Defaults to TRUE.\n- **OrderColumnSelection**, a logical vector indicating whether the column selection should be used to order columns in the heatmap. Defaults to TRUE.\n\nThe following slots control the choice of assay values:\n\n- **Assay**, string specifying the name of the assay to use for obtaining expression values. Defaults to \"logcounts\" in **getPanelDefault**, falling back to the first valid assay name (see .cacheCommonInfo below).\n\nThe following slots control the clustering of rows:\n\n- **ClusterRows**, a logical scalar indicating whether rows should be clustered by their assay values. Defaults to FALSE.\n- **ClusterRowsDistance**, string specifying a distance measure to use. This can be any one of \"euclidean\", \"maximum\", \"manhattan\", \"canberra\", \"binary\", \"minkowski\", \"pearson\", \"spearman\", or \"kendall\". Defaults to \"spearman\".\n- **ClusterRowsMethod**, string specifying a linkage method to use. This can be any one of \"ward.D\", \"ward.D2\", \"single\", \"complete\", \"average\", \"mcquitty\", \"median\", or \"centroid\". Defaults to \"ward.D2\".\n\nThe following control transformations applied to rows:\n\n- **AssayCenterRows** is a logical scalar indicating whether assay values should be centered for each row.\n- **AssayScaleRows** is a logical scalar indicating whether assay values should be scaled for each row. This transformation is only applicable if **AssayCenterRows** is TRUE.\n\nThe following slots control the color scale:\n\n- **CustomBounds** is logical scale indicating whether the color scale should be constrained by an upper and/or a lower bounds.\n- **LowerBound** is a numerical value setting the lower bound of the color scale; or NA to disable the lower bound when **CustomBounds** is TRUE.\n- **UpperBound** is a numerical value setting the lower bound of the color scale; or NA to disable the upper bound when **CustomBounds** is TRUE.\n- **DivergentColormap** is a character scalar indicating a 3-color divergent colormap to use when **AssayCenterRows** is TRUE.\n\nThe following slots refer to general plotting parameters:\n\n- **ShowDimNames**, a character vector specifying the dimensions for which to display names. This can contain zero or more of \"Rows\" and \"Columns\". Defaults to \"Rows\".\n- **NamesRowFontSize**, a numerical value setting the font size of the row names.\n- **NamesColumnFontSize**, a numerical value setting the font size of the column names.\n- **LegendPosition**, string specifying the position of the legend on the plot. Defaults to \"Bottom\" in **getPanelDefault** but can also be \"Right\".\n- LegendDirection, string specifying the orientation of the legend on the plot for continuous covariates. Defaults to \"Horizontal\" in getPanelDefault but can also be \"Vertical\".\n\nThe following slots control some aspects of the user interface:\n\n- DataBoxOpen, a logical scalar indicating whether the data parameter box should be open. Defaults to FALSE.\n- VisualBoxOpen, a logical scalar indicating whether the visual parameter box should be open. Defaults to FALSE.\n\nIn addition, this class inherits all slots from its parent Panel class.\n\n**Constructor**\n\nComplexHeatmapPlot(...) creates an instance of a ComplexHeatmapPlot class, where any slot and its value can be passed to ... as a named argument.\n\n**Supported methods**\n\nIn the following code snippets, x is an instance of a ComplexHeatmapPlot class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- .cacheCommonInfo(x) adds a \"ComplexHeatmapPlot\" entry containing valid.assay.names, a character vector of valid (i.e., non-empty) assay names; discrete.assay.names, a character vector of valid assay names with discrete atomic values; continuous.assay.names, a character vector of valid assay names with continuous atomic values; valid.colData.names, a character vector of names of columns in colData that are valid; discrete.colData.names, a character vector of names for columns in colData with discrete atomic values; continuous.colData.names, a character vector of names of columns in colData with continuous atomic values; valid.rowData.names, a character vector of names of columns in rowData that are valid; discrete.rowData.names, a character vector of names for columns in rowData with discrete atomic values; continuous.rowData.names, a character vector of names of columns in rowData with continuous atomic values. Valid assay names are defined as those that are non-empty, i.e., not \"\"; valid columns in colData and rowData are defined as those that contain atomic values. This will also call the equivalent Panel method.\n\n- .refineParameters(x, se) replaces any NA value in \"Assay\" with the first valid assay name; and NA value in \"CustomRowsText\" with the first row name. This will also call the equivalent Panel method for further refinements to x. If no valid column metadata fields are available, NULL is returned instead.\n\nFor defining the interface:\n\n- .defineInterface(x, se, select_info) defines the user interface for manipulating all slots described above and in the parent classes. TODO It will also create a data parameter box that can respond to specialized .defineDataInterface, and a visual parameter box and a selection parameter box both specific to the ComplexHeatmapPlot panel. This will override the Panel method.\n\n- .defineDataInterface(x, se, select_info) returns a list of interface elements for manipulating all slots described above.\n- `.defineOutput(x)` returns a UI element for a brushable plot.\n- `.panelColor(x)` will return the specified default color for this panel class.\n- `.hideInterface(x, field)` returns a logical scalar indicating whether the interface element corresponding to `field` should be hidden. This returns `TRUE` for the selection history (\"SelectionHistory\"), otherwise it dispatches to the Panel method.\n\nFor generating the output:\n- `.generateOutput(x, se, all_memory, all_contents)` returns a list containing `plot`, a Heatmap object; `commands`, a list of character vector containing the R commands required to generate contents and plot; and `contents` and `varname`, both set to NULL as this is not a transmitting panel.\n- `.exportOutput(x, se, all_memory, all_contents)` will create a PDF file containing the current plot, and return a string containing the path to that PDF. This assumes that the plot field returned by `.generateOutput` is a Heatmap object.\n\nFor monitoring reactive expressions:\n- `.createObservers(x, se, input, session, pObjects, rObjects)` sets up observers for all slots described above and in the parent classes. This will also call the equivalent Panel method.\n- `.renderOutput(x, se, output, pObjects, rObjects)` will add a rendered plot element to `output`. The reactive expression will add the contents of the plot to `pObjects$contents` and the relevant commands to `pObjects$commands`. This will also call the equivalent Panel method to render the panel information text boxes.\n\nFor defining the panel name:\n- `.fullName(x)` will return \"Complex heatmap\".\n\nFor documentation:\n- `.definePanelTour(x)` returns an data.frame containing a panel-specific tour.\n\n**Author(s)**\n\nKevin Rue-Albrecht\n\n**See Also**\n\n`Panel`, for the immediate parent class.\n\n**Examples**\n\n```\n# For end-users\nx <- ComplexHeatmapPlot()\nx[['ShowDimNames']] \nx[['ShowDimNames']] <- c(\"Rows\", \"Columns\")\n```\nlibrary(scater)\nsce <- mockSCE()\nsce <- logNormCounts(sce)\n\nold_cd <- colData(sce)\ncolData(sce) <- NULL\n\n# Spits out a NULL and a warning if there is nothing to plot.\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n\n# Replaces the default with something sensible.\ncolData(sce) <- old_cd\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n\n---\n\nconstants Constants\n\nDescription\nConstant values used throughout iSEE panels and extensions.\n\nPanel slot names\n.dataParamBoxOpen Name of slot that indicates whether the 'Data parameter' box is open.\n.multiSelectHistory Name of slot that stores the list of saved selections.\n.organizationHeight Name of slot that stores the panel height.\n.organizationWidth Name of slot that stores the panel width.\n\nMultiple selection parameters\n.noSelection Value displayed in the absence of selection.\n\nAuthor(s)\nKevin Rue-Albrecht\ncreateCustomPanels Create custom panels\n\nDescription\n\nHelper functions for quick-and-dirty creation of custom panels, usually in the context of a one-off application. This creates a new class with specialized methods for showing content based on a user-specified function.\n\nUsage\n\ncreateCustomTable(\n FUN,\n restrict = NULL,\n className = \"CustomTable\",\n fullName = \"Custom table\",\n FUN.selection.details = NULL,\n where = toplevel(parent.frame())\n)\n\ncreateCustomPlot(\n FUN,\n restrict = NULL,\n className = \"CustomPlot\",\n fullName = \"Custom plot\",\n where = toplevel(parent.frame())\n)\n\nArguments\n\nFUN A function that generates a data.frame or a ggplot, for createCustomTable and createCustomPlot respectively. See Details for the expected arguments.\nrestrict Character vector of names of optional arguments in FUN to which the UI is restricted. If specified, only the listed arguments receive UI elements in the interface.\nclassName String containing the name of the new Panel class.\nfullName String containing the full name of the new class.\nFUN.selection.details Function generating a UI element that displays details about the current selection, if any.\nwhere An environment indicating where the class and method definitions should be stored.\nDetails\n\nFUN is expected to have the following first 3 arguments:\n\n- `se`, a SummarizedExperiment object for the current dataset of interest.\n- `rows`, a list of row selections received from the transmitting panel. This contains one or more character vectors of row names in active and saved selections. Alternatively, this may be NULL if no selection has been made in the transmitter.\n- `columns`, a list of column selections received from the transmitting panel. This contains one or more character vectors of column names in active and saved selections. Alternatively, this may be NULL if no selection has been made in the transmitter.\n\nAny number of additional named arguments may also be present in FUN. All such arguments should have default values, as these are used to automatically generate UI elements in the panel:\n\n- Character vectors will get a `selectInput`.\n- Strings will get a `textInput`.\n- Numeric scalars will get a `numericInput`.\n- Logical scalars will get a `checkBoxInput`.\n\nArguments with other types of default values are ignored. If `restrict` is specified, arguments will only have corresponding UI elements if they are listed in `restrict`. All user interactions with these elements will automatically trigger regeneration of the panel contents.\n\nClasses created via these functions are extremely limited. Only scalar inputs are supported via the UI and all panels cannot transmit to the rest of the app. We recommend only using these functions for one-off applications to quickly prototype concepts; serious Panel extensions should be done explicitly.\n\nValue\n\nA new class and its methods are defined in the global environment. A generator function for creating new instances of the class is returned.\n\nAuthor(s)\n\nAaron Lun\n\nExamples\n\n```\nlibrary(scater)\nCUSTOM_DIMRED <- function(se, rows, columns, ntop=500, scale=TRUE, mode=c(\"PCA\", \"TSNE\", \"UMAP\"))\n{\n if (is.null(columns)) {\n return(\n ggplot() + theme_void() + geom_text(\n aes(x, y, label=label),\n data.frame(x=0, y=0, label=\"No column data selected.\"),\n size=5)\n )\n }\n```\ncreateLandingPage\n\nCreate a landing page\n\nDescription\n\nDefine a function to create a landing page in which users can specify or upload SummarizedExperiment objects.\n\nUsage\n\ncreateLandingPage(\n seUI = NULL,\n seLoad = NULL,\n initUI = NULL,\n initLoad = NULL,\n requireButton = TRUE\n)\ncreateLandingPage\n\nArguments\n\n- seUI: Function that accepts a single id argument and returns a UI element for specifying the SummarizedExperiment.\n- seLoad: Function that accepts the input value of the UI element from seUI and returns a SummarizedExperiment object.\n- initUI: Function that accepts a single id argument and returns a UI element for specifying the initial state.\n- initLoad: Function that accepts the input value of the UI element from initUI and returns a list of Panels.\n- requireButton: Logical scalar indicating whether the app should require an explicit button press to initialize, or if it should initialize upon any modification to the UI element in seUI.\n\nDetails\n\nBy default, this function creates a landing page in which users can upload an RDS file containing a SummarizedExperiment, which is subsequently read by readRDS to launch an instance of iSEE. However, any source of SummarizedExperiment objects can be used; for example, we can retrieve them from databases by modifying seUI and seLoad appropriately.\n\nThe default landing page also allows users to upload a RDS file containing a list of Panels that specifies the initial state of the iSEE instance (to be used as the initial argument in iSEE). Again, any source can be used to create this list if initUI and initLoad are modified appropriately.\n\nThe UI elements for the SummarizedExperiment and the initial state are named \"se\" and \"initial\" respectively. This can be used in Shiny bookmarking to initialize an iSEE in a desired state by simply clicking a link, provided that requireButton=FALSE so that reactive expressions are immediately triggered upon setting se= and initial= in the URL. We do not use bookmarking to set all individual iSEE parameters as we will run afoul of URL character limits.\n\nValue\n\nA function that generates a landing page upon being passed to iSEE as the landingPage argument.\n\nDefining a custom landing page\n\nWe note that createLandingPage is just a limited wrapper around the landing page API. In iSEE, landingPage can be any function that accepts the following arguments:\n\n- FUN, a function to initialize the iSEE observer architecture. This function expects to be passed:\n - SE, a SummarizedExperiment object.\n - INITIAL, a list of Panel objects describing the initial application state. If NULL, the initial state from initial in the top-level iSEE call is used instead.\n - TOUR, a data.frame containing a tour to be attached to the app - see defaultTour for an example. If NULL (the default), no tour is added.\n - COLORMAP, an ExperimentColorMap object that defines the colormaps to use in the application.\n- input, the Shiny input list.\n• output, the Shiny output list.\n• session, the Shiny session object.\n\nThe `landingPage` function should define a `renderUI` expression that is assigned to `output$allPanels`. This should define a UI that contains all widgets necessary for a user to set up an iSEE session interactively. We suggest that all UI elements have IDs prefixed with \"initialize_INTERNAL\" to avoid conflicts.\n\nThe function should also define observers to respond to user interactions with the UI elements. These are typically used to define a SummarizedExperiment object and an input state as a list of Panels; any one of these observers may then call `FUN` on those arguments to launch the main iSEE instance.\n\nNote that, once the main app is launched, the UI elements constructed here are lost and observers will never be called again. There is no explicit “unload” mechanism to return to the landing page from the main app, though a browser refresh is usually sufficient.\n\nAuthor(s)\n\nAaron Lun\n\nExamples\n\ncreateLandingPage()\n\n# Alternative approach, to create a landing page\n# that opens one of the datasets from the scRNAseq package.\nlibrary(scRNAseq)\nall.data <- ls(\"package:scRNAseq\")\nall.data <- all.data[grep(\"Data\\$\", all.data)]\n\nlpfun <- createLandingPage(\n seUI=function(id) selectInput(id, \"Dataset:\", choices=all.data),\n seLoad=function(x) get(x, as.environment(\"package:scRNAseq\"))()\n)\n\napp <- iSEE(landingPage=lpfun)\nif (interactive()) {\n shiny::runApp(app, port=1234)\n}\n\n---\n\n**defaultTour**\n\n*Define the default tour*\n\n**Description**\n\nDefine the default tour for the subset of the Allen brain dataset. This is only available when run on the iSEE(sce) example in ?\"iSEE\".*\ndocumentation-generics\n\nUsage\n\ndefaultTour()\n\nValue\n\nA data.frame where each row is a tour step. The first column specifies the UI element to be highlighted by the tour, while the second column contains the tour text.\n\nAuthor(s)\n\nAaron Lun\n\nExamples\n\ndefaultTour()\n\n---\n\ndocumentation-generics\n\nDocumentation generics\n\nDescription\n\nThe generics power the creation of panel-specific documentation within the iSEE app. Users can click on an icon next to the panel name to open a self-guided tour for that panel’s functionality.\n\nDefining the panel tour\n\n.definePanelTour(x) takes a Panel x and is expected to return a data.frame with the character fields “element” and “intro”. Each row corresponds to a step of an rintrojs tour; the “element” specifies the active UI element to be highlighted in that step, while the “intro” element contains the HTML-formatted text to show in the tour pop-up.\n\nIt is a good idea to callNextMethod() to obtain the tour steps for the parent class to append onto the current class’s data.frame. In some cases, modification of the parent class’s tour steps may be necessary if some of the parent’s functionality has been overwritten. Some communication with the parent’s maintainers may be necessary to establish a stable way to identify the rows corresponding to the steps to be written, e.g., based on the row names of the data.frame.\n\nA tour for a Panel x is expected to only highlight UI elements on the same panel. This is very important as other panels cannot be assumed to exist in an arbitrary instance of iSEE. As such, these tours are not well-suited to highlighting interactions between different panels.\n\nThe observer set-up for the panel tour is done in .createObservers for the base Panel class. No further action is required on behalf of developers to set up the triggers to launch the tour.\nDefining UI-specific tours\n\nIt is possible to provide tours for individual UI elements, which can be more helpful than a single large tour for the entire panel. A documented element has a clickable icon (usually generated by functions like `.selectInput.iSEE`) that launches a specific tour, typically explaining the behavior and effects of the associated parameter. The tours themselves should be registered by `.addSpecificTour`. This is best done inside the various interface-defining functions (e.g., `.defineInterface` and related methods) where the documentation can be written adjacent to the definition of the UI element itself.\n\nFor a DotPlot instance `x`, the `.getDotPlotColorHelp(x, color_choices)` generic should return a function that returns a data.frame containing the `rnormjs` tour for the color choice UI element, i.e., \"ColorBy\". This allows downstream Panels to tune the wording of the color documentation, given that this is commonly specialized. `color_choices` is a character vector that contains the valid choices for the \"ColorBy\" radio button; some input datasets will not have, e.g., any column data, so the corresponding button will not be shown and its associated tour can be omitted.\n\nAuthor(s)\n\nAaron Lun\n\nDotPlot-class\n\nThe DotPlot virtual class\n\nDescription\n\nThe DotPlot is a virtual class for all panels where each row or column in the SummarizedExperiment is represented by no more than one point (i.e., a “dot”) in a brushable ggplot plot. It provides slots and methods to create the plot, to control various aesthetics of the dots, and to store the brush or lasso selection.\n\nSlot overview\n\nThe following slots are relevant to coloring of the points:\n\n- **ColorBy**, a string specifying how points should be colored. This should be one of \"None\", \"Feature name\", \"Sample name\" and either \"Column data\" (for ColumnDotPlots) or \"Row data\" (for RowDotPlots). Defaults to \"None\".\n- **ColorByDefaultColor**, a string specifying the default color to use for all points if ColorBy=\"None\". Defaults to \"black\" in `getPanelDefault`.\n- **ColorByFeatureName**, a string specifying the feature to be used for coloring points when ColorBy=\"Feature name\". For RowDotPlots, this is used to highlight the point corresponding to the selected feature; for ColumnDotPlots, this is used to color each point according to the expression of that feature. If NA, this defaults to the name of the first row.\n- **ColorByFeatureSource**, a string specifying the name of the panel to use for transmitting the feature selection to ColorByFeatureName. Defaults to \"---\".\n• **ColorBySampleName**, a string specifying the sample to be used for coloring points when ColorBy=\"Sample name\". For **RowDotPlots**, this is used to color each point according to the expression of that sample; for **ColumnDotPlots**, this is used to highlight the point corresponding to the selected sample. If NA, this defaults to the name of the first column.\n\n• **ColorBySampleSource**, a string specifying the name of the panel to use for transmitting the sample selection to **ColorBySampleName**. Defaults to \"---\".\n\n• **ColorByFeatureDynamicSource**, a logical scalar indicating whether x should dynamically change its selection source when coloring by feature. Defaults to FALSE in getPanelDefault.\n\n• **ColorBySampleDynamicSource**, a logical scalar indicating whether x should dynamically change its selection source when coloring by feature. Defaults to FALSE in getPanelDefault.\n\n• **SelectionAlpha**, a numeric scalar in [0, 1] specifying the transparency to use for non-selected points. Defaults to 0.1 in getPanelDefault.\n\nThe following slots control other metadata-related aesthetic aspects of the points:\n\n• **ShapeBy**, a string specifying how the point shape should be determined. This should be one of \"None\" and either \"Column data\" (for **ColumnDotPlots**) or \"Row data\" (for **RowDotPlots**). Defaults to \"None\".\n\n• **SizeBy**, a string specifying the metadata field for controlling point size. This should be one of \"None\" and either \"Column data\" (for **ColumnDotPlots**) or \"Row data\" (for **RowDotPlots**). Defaults to \"None\".\n\nThe following slots control the faceting:\n\n• **FacetRowBy**, a string indicating what to use for creating row facets. For **RowDotPlots**, this should be one of \"None\", \"Row data\" or \"Row selection\". For **ColumnDotPlots**, this should be one of \"None\", \"Column data\" or \"Column selection\". Defaults to \"None\", i.e., no row faceting.\n\n• **FacetByColumn**, a string indicating what to use for creating column facets. For **RowDotPlots**, this should be one of \"None\", \"Row data\" or \"Row selection\". For **ColumnDotPlots**, this should be one of \"None\", \"Column data\" or \"Column selection\". Defaults to \"None\", i.e., no column faceting.\n\nThe following slots control any text to be shown on the plot:\n\n• **LabelCenters**, a logical scalar indicating whether the label the centers (technically medoids) of all cells in each group, where groups are defined by a discrete covariate in the relevant metadata field. Defaults to FALSE.\n\n• **LabelCentersBy**, a string specifying the metadata field to define the groups when LabelCenters is TRUE. This should be a discrete variable in rowData or colData for **RowDotPlots** and **ColumnDotPlots**, respectively. Defaults to the name of the first column.\n\n• **LabelCentersColor**, a string specifying the color used for the labels at the center of each group. Only used when LabelCenters is TRUE. Defaults to \"black\".\n\n• **CustomLabels**, a logical scalar indicating whether custom labels should be inserted on specific points. Defaults to FALSE.\n\n• **CustomLabelsText**, a (possibly multi-line) string with the names of the points to label when CustomLabels is set to TRUE. Each line should contain the name of a row or column for **RowDotPlots** and **ColumnDotPlots**, respectively. Leading and trailing whitespace are stripped, and all text on a line after # is ignored. Defaults to the name of the first row/column.\nThe following slots control interactions with the plot image:\n\n- **ZoomData**, a named numeric vector of plot coordinates with \"xmin\", \"xmax\", \"ymin\" and \"ymax\" elements parameterizing the zoom boundaries. Defaults to an empty vector, i.e., no zoom.\n- **BrushData**, a list containing either a Shiny brush (see ?brushedPoints) or an iSEE lasso (see ?lassoPoints). Defaults to an empty list, i.e., no brush or lasso.\n- **HoverInfo**, a logical scalar indicating whether the feature/sample name should be shown upon mouse-over of the point. Defaults to TRUE.\n\nThe following slots control some aspects of the user interface:\n\n- **DataBoxOpen**, a logical scalar indicating whether the data parameter box should be open. Defaults to FALSE.\n- **VisualBoxOpen**, a logical scalar indicating whether the visual parameter box should be open. Defaults to FALSE.\n- **VisualChoices**, a character vector specifying the visible interface elements upon initialization. This can contain zero or more of \"Color\", \"Shape\", \"Size\", \"Point\", \"Facet\", \"Text\", and \"Other\". Defaults to \"Color\".\n\nThe following slots control the addition of a contour:\n\n- **ContourAdd**, logical scalar indicating whether a contour should be added to a (scatter) plot. Defaults to FALSE.\n- **ContourColor**, string specifying the color to use for the contour lines. Defaults to \"blue\".\n\nThe following slots control the general appearance of the points.\n\n- **PointSize**, positive numeric scalar specifying the relative size of the points. Defaults to 1.\n- **PointAlpha**, non-negative numeric scalar specifying the transparency of the points. Defaults to 1, i.e., not transparent.\n- **Downsample**, logical scalar indicating whether to downsample points for faster plotting. Defaults to FALSE in getPanelDefault.\n- **DownsampleResolution**, numeric scalar specifying the resolution of the downsampling grid (see ?subsetPointsByGrid) if Downsample=TRUE. Larger values correspond to reduced downsampling at the cost of plotting speed. Defaults to 200 in getPanelDefault.\n\nThe following slots refer to general plotting parameters:\n\n- **FontSize**, positive numeric scalar specifying the relative font size. Defaults to 1 in getPanelDefault.\n- **PointSize**, positive numeric scalar specifying the relative point size. Defaults to 1 in getPanelDefault.\n- **LegendPosition**, string specifying the position of the legend on the plot. Defaults to \"Bottom\" in getPanelDefault. The other valid choice is \"Right\".\n\nIn addition, this class inherits all slots from its parent Panel class.\n\n\n**Supported methods**\n\nIn the following code snippets, `x` is an instance of a DotPlot class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up the objects:\n\n- `.cacheCommonInfo(x)` adds a \"DotPlot\" entry containing `valid.assay.names`, a character vector of valid assay names. Valid names are defined as those that are non-empty, i.e., not \"\". This method will also call the equivalent Panel method.\n\n- `.refineParameters(x, se)` replaces NA values in `ColorByFeatureName` and `ColorBySampleNameColor` with the first row and column name, respectively, of `se`. This will also call the equivalent Panel method.\n\nFor defining the interface:\n\n- `.defineInterface(x, se, select_info)` defines the user interface for manipulating all slots described above and in the parent classes. It will also create a data parameter box that can respond to specialized .defineDataInterface. This will override the Panel method.\n\n- `.defineVisualColorInterface(x, se, select_info)` defines the user interface subpanel for manipulating the color of the points.\n\n- `.defineVisualShapeInterface(x, se)` defines the user interface subpanel for manipulating the shape of the points.\n\n- `.defineVisualSizeInterface(x, se)` defines the user interface subpanel for manipulating the size of the points.\n\n- `.defineVisualPointInterface(x, se)` defines the user interface subpanel for manipulating other point-related parameters.\n\n- `.defineVisualFacetInterface(x, se)` defines the user interface subpanel for manipulating facet-related parameters.\n\n- `.defineVisualTextInterface(x, se)` defines the user interface subpanel for manipulating text-related parameters.\n\n- `.defineVisualOtherInterface(x, se)` defines the user interface subpanel for manipulating other parameters. Currently this returns NULL.\n\n- `.defineOutput(x)` returns a UI element for a brushable plot.\n\n- `.allowableColorByDataChoices(x, se)` returns a character vector containing all atomic variables in the relevant *Data dimension.\n\nFor generating the output:\n\n- `.generateOutput(x, se, all_memory, all_contents)` returns a list containing `contents`, a data.frame with one row per point currently present in the plot; `plot`, a `ggplot` object; `commands`, a list of character vector containing the R commands required to generate contents and `plot`; and `varname`, a string containing the name of the variable in `commands` that was used to obtain contents.\n\n- `.generateDotPlot(x, labels, envir)` returns a list containing `plot` and `commands`, as described above. This is called within .generateOutput for all DotPlot instances by default. Methods are also guaranteed to generate a dot.plot variable in `envir` containing the `ggplot` object corresponding to `plot`. \n.prioritizeDotPlotData(x, envir) returns NULL.\n.colorByNoneDotPlotField(x) returns NULL.\n.colorByNoneDotPlotScale(x) returns NULL.\n.exportOutput(x, se, all_memory, all_contents) will create a PDF file containing the current plot, and return a string containing the path to that PDF. This assumes that the plot field returned by .generateOutput is a ggplot object.\n\nFor defining reactive expressions:\n\n.createObservers(x, se, input, session, pObjects, rObjects) sets up observers for some (but not all!) of the slots. This will also call the equivalent Panel method.\n.renderOutput(x, se, output, pObjects, rObjects) will add a rendered plot element to output. The reactive expression will add the contents of the plot to pObjects$contents and the relevant commands to pObjects$commands. This will also call the equivalent Panel method to render the panel information text boxes.\n\nFor controlling selections:\n\n.multiSelectionCommands(x, index) returns a character vector of R expressions that - when evaluated - returns a character vector of the names of selected points in the active and/or saved selections of x. The active selection is returned if index=NA, otherwise one of the saved selection is returned.\n.multiSelectionActive(x) returns x[\"BrushData\"] or NULL if there is no brush or closed lasso.\n.multiSelectionClear(x) returns x after setting the BrushData slot to an empty list.\n.singleSelectionValue(x, contents) returns the name of the first selected element in the active brush. If no brush is active, NULL is returned instead.\n.singleSelectionSlots(x) will return a list specifying the slots that can be updated by single selections in transmitter panels, mostly related to the choice of coloring parameters. This includes the output of callNextMethod.\n\nFor documentation:\n\n.definePanelTour(x) returns an data.frame containing the steps of a tour relevant to subclasses, mostly describing the specification of visual effects and the creation of a brush or lasso.\n\nUnless explicitly specialized above, all methods from the parent class Panel are also available.\n\nSubclass expectations\n\nThe DotPlot is a rather vaguely defined class for which the only purpose is to avoid duplicating code for ColumnDotPlots and RowDotPlots. We recommend extending those subclasses instead.\n\nAuthor(s)\nAaron Lun\n\nSee Also\nRowDotPlot and ColumnDotPlot, which are more amenable to extension.\nExperimentColorMap-class\n\nExperimentColorMap class\n\nDescription\n\nExperimentColorMap class\n\nUsage\n\nExperimentColorMap(\n assays = list(),\n colData = list(),\n rowData = list(),\n all_discrete = list(assays = NULL, colData = NULL, rowData = NULL),\n all_continuous = list(assays = NULL, colData = NULL, rowData = NULL),\n global_discrete = NULL,\n global_continuous = NULL,\n ...\n)\n\nArguments\n\nassays List of colormaps for assays.\ncolData List of colormaps for colData.\nrowData List of colormaps for rowData.\nall_discrete Colormaps applied to all undefined categorical assays, colData, and rowData, respectively.\nall_continuous Colormaps applied to all undefined continuous assays, colData, and rowData, respectively.\nglobal_discrete Colormap applied to all undefined categorical covariates.\nglobal_continuous Colormap applied to all undefined continuous covariates.\n... additional arguments passed on to the ExperimentColorMap constructor\n\nDetails\n\nColormaps must all be functions that take at least one argument: the number of (named) colours to return as a character vector. This argument may be ignored in the body of the colormap function to produce constant colormaps.\n\nValue\n\nAn object of class ExperimentColorMap\nCategorical colormaps\n\nThe default categorical colormap emulates the default ggplot2 categorical color palette (Credit: https://stackoverflow.com/questions/8197559/emulate-ggplot2-default-color-palette). This palette returns a set of colors sampled in steps of equal size that correspond to approximately equal perceptual changes in color:\n\n```r\nfunction(n) {\n hues=seq(15, 375, length=(n + 1))\n hcl(h=hues, l=65, c=100)[seq_len(n)]\n}\n```\n\nTo change the palette for all categorical variables, users must supply a colormap that returns a similar value; namely, an unnamed character vector of length \\( n \\). For instance, using the base R palette `rainbow.colors`\n\n```r\nfunction(n) {\n rainbow(n)\n}\n```\n\n**Accessors**\n\nIn the following code snippets, \\( x \\) is an `ExperimentColorMap` object.\n\n```r\nassayColorMap(x, i, ..., discrete=FALSE): Get an assays colormap for the specified assay \\( i \\).\ncolDataColorMap(x, i, ..., discrete=FALSE): Get a colData colormap for the specified colData column \\( i \\).\nrowDataColorMap(x, i, ..., discrete=FALSE): Get a rowData colormap for the specified rowData column \\( i \\).\n```\n\nIf the colormap for \\( i \\) cannot be found, one of the default colormaps is returned. In this case, `discrete` is a logical scalar that indicates whether the colormap should be categorical. The more specialized default is first attempted - e.g., for `assayColorMap`, this would be the assay colormap specified in `assays` of `all_discrete` or `all_continuous` - before falling back to the global default in `global_discrete` or `global_continuous`. Similarly, if \\( i \\) is missing, the default discrete/continuous colormap is returned.\n\n**Setters**\n\nIn the following code snippets, \\( x \\) is an `ExperimentColorMap` object, and \\( i \\) is a character or numeric index.\n\n```r\nassayColorMap(x, i, ...) <- value: Set an assays colormap.\ncolDataColorMap(x, i, ...) <- value: Set a colData colormap.\nrowDataColorMap(x, i, ...) <- value: Set a rowData colormap.\nassay(x, i, ...) <- value: Alias. Set an assays colormap.\n```\nExamples\n\n# Example colormaps ----\n\ncount_colors <- function(n)\n c(\"black\", \"brown\", \"red\", \"orange\", \"yellow\")\n} \nfpkm_colors <- viridis::inferno \ntpm_colors <- viridis::plasma \n\nqc_color_fun <- function(n)\n qc_colors <- c(\"forestgreen\", \"firebrick1\")\n names(qc_colors) <- c(\"Y\", \"N\")\n return(qc_colors)\n} \n\n# Constructor ----\n\necm <- ExperimentColorMap(\n assays=list(\n counts=count_colors,\n tophat_counts=count_colors,\n cufflinks_fpkm=fpkm_colors,\n rsem_tpm=tpm_colors\n ),\n colData=list(\n passes_qc_checks_s=qc_color_fun\n )\n)\n\n# Accessors ----\n\n# assay colormaps\nassayColorMap(ecm, \"logcounts\") # [undefined --> default]\nassayColorMap(ecm, \"counts\")\nassayColorMap(ecm, \"cufflinks_fpkm\")\nassay(ecm, \"cufflinks_fpkm\") # alias\n\n# colData colormaps\ncolDataColorMap(ecm, \"passes_qc_checks_s\")\ncolDataColorMap(ecm, \"undefined\")\n\n# rowData colormaps\nrowDataColorMap(ecm, \"undefined\")\n\n# generic accessors\nassays(ecm)\nnames(ecm)\n\n# Setters ----\n\nassayColorMap(ecm, \"counts\") <- function(n){c(\"blue\", \"white\", \"red\")}\nassay(ecm, 1) <- function(n){c(\"blue\", \"white\", \"red\")}\ncolDataColorMap(ecm, \"passes_qc_checks_s\") <- function(n)NULL\nrowDataColorMap(ecm, \"undefined\") <- function(n)NULL\n\n# Categorical colormaps ----\n\n# Override all discrete colormaps using the base rainbow palette\necm <- ExperimentColorMap(global_discrete = rainbow)\nn <- 10\nplot(1:n, col=assayColorMap(ecm, \"undefined\", discrete = TRUE)(n), pch=20, cex=3)\n\nFeatureAssayPlot-class\n\nThe FeatureAssayPlot panel\n\nDescription\n\nThe FeatureAssayPlot is a panel class for creating a ColumnDotPlot where the y-axis represents the expression of a feature of interest, using the assay values of the SummarizedExperiment. It provides slots and methods to specify the feature and what to plot on the x-axis, as well as a method to actually create a data.frame containing those pieces of data in preparation for plotting.\n\nSlot overview\n\nThe following slots control the values on the y-axis:\n\n- **YAxisFeatureName**, a string specifying the name of the feature to plot on the y-axis. If NA, defaults to the first row name of the SummarizedExperiment object.\n- **Assay**, string specifying the name of the assay to use for obtaining expression values. Defaults to \"logcounts\" in getPanelDefault, falling back to the name of the first valid assay (see ?.cacheCommonInfo,DotPlot-method for the definition of validity).\n- **YAxisFeatureSource**, string specifying the encoded name of the transmitting panel to obtain a single selection that replaces YAxisFeatureName. Defaults to \"---\", i.e., no transmission is performed.\n- **YAxisFeatureDynamicSource**, a logical scalar indicating whether x should dynamically change its selection source for the y-axis. Defaults to FALSE in getPanelDefault.\n\nThe following slots control the values on the x-axis:\n\n- **XAxis**, string specifying what should be plotting on the x-axis. This can be any one of \"None\", \"Feature name\", \"Column data\" or \"Column selection\". Defaults to \"None\".\n- **XAxisColumnData**, string specifying which column of the colData should be shown on the x-axis, if XAxis=\"Column data\". Defaults to the first valid colData field (see ?.refineParameters,ColumnDotPlot-method for details).\n- **XAxisFeatureName**, string specifying the name of the feature to plot on the x-axis, if XAxis=\"Feature name\". Defaults to the first row name.\n• **XAxisFeatureSource**, string specifying the encoded name of the transmitting panel to obtain a single selection that replaces **XAxisFeatureName**. Defaults to \"---\", i.e., no transmission is performed.\n\n• **XAxisFeatureDynamicSource**, a logical scalar indicating whether x should dynamically change its selection source for the x-axis. Defaults to FALSE in `getPanelDefault`.\n\nIn addition, this class inherits all slots from its parent **ColumnDotPlot**, **DotPlot** and **Panel** classes.\n\n**Constructor**\n\n`FeatureAssayPlot(...)` creates an instance of a **FeatureAssayPlot** class, where any slot and its value can be passed to ... as a named argument.\n\n**Supported methods**\n\nIn the following code snippets, x is an instance of a **FeatureAssayPlot** class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n• `.refineParameters(x, se)` replaces any NA values in **XAxisFeatureName** and **YAxisFeatureName** with the first row name; any NA value in **Assay** with the first valid assay name; and any NA value in **XAxisColumnData** with the first valid column metadata field. This will also call the equivalent **ColumnDotPlot** method for further refinements to x. If no rows or assays are present, NULL is returned instead.\n\nFor defining the interface:\n\n• `.defineDataInterface(x, se, select_info)` returns a list of interface elements for manipulating all slots described above.\n\n• `.panelColor(x)` will return the specified default color for this panel class.\n\nFor monitoring reactive expressions:\n\n• `.createObservers(x, se, input, session, pObjects, rObjects)` sets up observers for all slots described above and in the parent classes. This will also call the equivalent **ColumnDotPlot** method.\n\nFor defining the panel name:\n\n• `.fullName(x)` will return \"Feature assay plot\".\n\nFor creating the plot:\n\n• `.generateDotPlotData(x, envir)` will create a data.frame of feature expression values in *envir*. It will return the commands required to do so as well as a list of labels.\n\nFor managing selections:\n\n• `.singleSelectionSlots(x)` will return a list specifying the slots that can be updated by single selections in transmitter panels, mostly related to the choice of feature on the x- and y-axes. This includes the output of the method for the parent **ColumnDotPlot** class.\n• `.multiSelectionInvalidated(x)` returns `TRUE` if the x-axis uses multiple column selections, such that the point coordinates may change upon updates to upstream selections in transmitting panels. Otherwise, it dispatches to the `ColumnDotPlot` method.\n\nFor documentation:\n\n• `.definePanelTour(x)` returns a data.frame containing a panel-specific tour.\n\n**Author(s)**\n\nAaron Lun\n\n**See Also**\n\n`ColumnDotPlot`, for the immediate parent class.\n\n**Examples**\n\n```\n# For end-users #\n#...\nx <- FeatureAssayPlot()\nx[['XAxis']] = x[['Assay']] = \"logcounts\"\nx[['XAxisColumnData']] = \"stuff\"\n# For developers #\n#\nlibrary(scater)\nsce <- mockSCE()\nsce <- logNormCounts(sce)\nold_assay_names <- assayNames(sce)\nassayNames(sce) <- character(length(old_assay_names))\n\n# Spits out a NULL and a warning if no assays are named.\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n\n# Replaces the default with something sensible.\nassayNames(sce) <- old_assay_names\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n```\nFilter a data.frame based on the DT datatable widget column search string.\n\n**Usage**\n\nfilterDTColumn(x, search)\n\nfilterDT(df, column, global)\n\n**Arguments**\n\n- **x**: A numeric or character vector, usually representing a column of a data.frame.\n- **search**: A string specifying the search filter to apply to x.\n- **df**: A data.frame that was used in the datatable widget.\n- **column**: A character vector of per-column search strings to apply to df. If any entry is an empty string, the corresponding column is not used for any filtering.\n- **global**: String containing a regular expression to search for across all columns in df (and row names, if present). If an empty string, no filtering is performed.\n\n**Details**\n\nFor character x, search is treated as a regular expression.\n\nFor numeric x, search should have the form LOWER ... UPPER where all elements in [LOWER, UPPER] are retained.\n\nFor factor x, search should have the form [\"choice_1\", \"choice_2\", etc.]. This is also the case for logical x, albeit with the only choices being \"true\" or \"false\".\n\nfilterDT will retain all rows where (i) any value in any column (after coercion to a string) matches global, and (ii) the value in each column satisfies the filter specified in the corresponding entry of column. Setting global to an empty string will skip requirement (i) while setting any entry of column to an empty string will skip requirement (ii) for the affected column.\n\nIdeally, ncol(df) and length(searches) would be the same, but if not, filterDT will simply filter on the first N entries where N is the smaller of the two.\n\nAny NA element in x will be treated as a no-match. The same applies for each column of df that has non-empty column. Note that a no-match in one column does not preclude a successful match in another column by global.\n\n**Value**\n\nA logical vector indicating which entries of x or rows of df are to be retained.\nAuthor(s)\nAaron Lun\n\nSee Also\ndatatable and associated documentation for more details about column searches.\n\nExamples\n\n# Regular expression:\nfilterDTColumn(LETTERS, \"A|B|C\")\n\n# Range query:\nfilterDTColumn(runif(20), \"0.1 ... 0.5\")\n\n# Factor query:\nfilterDTColumn(factor(letters), \"['a', 'b', 'c']\")\n\n# Works on DataFrames:\nX <- data.frame(row.names=LETTERS, thing=runif(26),\n stuff=sample(letters[1:3], 26, replace=TRUE),\n stringsAsFactors=FALSE)\nfilterDT(X, c(\"0 ... 0.5\", \"a|b\"), global=\"\")\nfilterDT(X, \",\", global=\"A\")\nMethods for this generic are expected to return a list of collapseBox elements. Each parameter box can contain arbitrary numbers of additional UI elements, each of which is expected to modify one slot of x upon user interaction.\n\nThe ID of each interface element should follow the form of PANEL_SLOT where PANEL is the panel name (from .getEncodedName(x)) and SLOT is the name of the slot modified by the interface element, e.g., \"ReducedDimensionPlot1_Type\". Each interface element should have an equivalent observer in .createObservers unless they are hidden by .hideInterface (see below).\n\nIt is the developer’s responsibility to call callNextMethod to obtain interface elements for parent classes. A common strategy is to combine the output of callNextMethod with additional collapseBox elements to achieve the desired UI structure.\n\n**Defining the data parameter interface**\n\n.defineDataInterface(x, se, select_info) defines the UI for data-related (i.e., non-aesthetic) parameters. The required arguments are the same as those for .defineInterface. Methods for this generic are expected to return a list of UI elements for altering data-related parameters, which are automatically placed inside the “Data parameters” collapsible box. Each element's ID should still follow the PANEL_SLOT pattern described above.\n\nThis generic aims to provide a simpler alternative to specializing .defineInterface for the most common use case. New panels can write methods for this generic to add their own interface elements for altering the contents of the panel, without needing to reimplement other UI elements in the parent class’s .defineInterface method. Conversely, there is no obligation to write a method for this generic if one is planning to specialize .defineInterface.\n\nIt is the developer’s responsibility to call callNextMethod to obtain interface elements for parent classes.\n\n**Hiding interface elements**\n\n.hideInterface(x, field) determines whether certain UI elements should be hidden from the user. The required arguments are:\n\n- x, an instance of a Panel class.\n- field, string containing the name of a slot of x.\n\nMethods for this generic are expected to return a logical scalar indicating whether the interface element corresponding to field should be hidden from the user. This is useful for hiding UI elements that cannot be changed or have no effect, especially in highly specialized subclasses where some concepts in the parent class may no longer be relevant. (The alternative would be to reimplement all of the parent’s .defineInterface method just to omit a handful of UI elements!)\n\nIt is the developer's responsibility to call callNextMethod to hide the same interface elements as parent classes. This is not strictly required if one wishes to expose previously hidden elements.\n\n**Author(s)**\n\nAaron Lun\nDescription\n\nWrapper functions to create the standard shiny user interface elements, accompanied by an optional help icon that opens an interactive tour describing the purpose of the element. Also responds to requests to hide a particular element via .hideInterface.\n\nUsage\n\n.selectInput.iSEE(x, field, label, ..., help = TRUE)\n.selectizeInput.iSEE(x, field, label, ..., help = TRUE)\n.checkboxInput.iSEE(x, field, label, ..., help = TRUE)\n.checkboxGroupInput.iSEE(x, field, label, ..., help = TRUE)\n.sliderInput.iSEE(x, field, label, ..., help = TRUE)\n.numericInput.iSEE(x, field, label, ..., help = TRUE)\n.radioButtons.iSEE(x, field, label, ..., help = TRUE)\n\nArguments\n\nx A Panel object for which to construct an interface element.\nfield String containing the name of the parameter controlled by the interface element.\nlabel String specifying the label to be shown.\n... Further arguments to be passed to the corresponding shiny function.\nhelp Logical scalar indicating whether a help icon should be added to the label.\n\nValue\n\nThe output of FUN(id, ..) is returned where FUN is set the corresponding shiny function, e.g., selectInput for .selectInput.iSEE. id is defined by concatenating .getEncodedName(x) and field (separated by an underscore).\n\nIf .hideInterface(x, field) is TRUE, the output is wrapped inside a hidden call.\n\nAuthor(s)\n\nAaron Lun\nDescription\n\nInteractive and reproducible visualization of data contained in a `SummarizedExperiment` object, using a Shiny interface.\n\nUsage\n\n```r\niSEE(\n se,\n initial = NULL,\n extra = NULL,\n colormap = ExperimentColorMap(),\n landingPage = createLandingPage(),\n tour = NULL,\n appTitle = NULL,\n runLocal = TRUE,\n voice = FALSE,\n bugs = FALSE,\n saveState = NULL,\n ...\n)\n```\n\nArguments\n\n- `se` A `SummarizedExperiment` object, ideally with named assays. If missing, an app is launched with a landing page generated by the `landingPage` argument.\n- `initial` A list of `Panel` objects specifying the initial state of the app. The order of panels determines the sequence in which they are laid out in the interface. Defaults to one instance of each panel class available from `iSEE`.\n- `extra` A list of additional `Panel` objects that might be added after the app has started. Defaults to one instance of each panel class available from `iSEE`.\n- `colormap` An `ExperimentColorMap` object that defines custom colormaps to apply to individual assays, `colData` and `rowData` covariates.\n- `landingPage` A function that renders a landing page when `iSEE` is started without any specified `se`. Ignored if `se` is supplied.\n- `tour` A data.frame with the content of the interactive tour to be displayed after starting up the app. Ignored if `se` is not supplied.\n- `appTitle` A string indicating the title to be displayed in the app. If not provided, the app displays the version info of `iSEE`.\n- `runLocal` A logical indicating whether the app is to be run locally or remotely on a server, which determines how documentation will be accessed.\n- `voice` A logical indicating whether the voice recognition should be enabled.\nbugs Set to TRUE to enable the bugs Easter egg. Alternatively, a named numeric vector control the respective number of each bug type (e.g., `c(bugs=3L, spiders=1L)`).\n\nsaveState A function that accepts a single argument containing the current application state and saves it to some appropriate location.\n\n... Further arguments to pass to shinyApp.\n\nDetails\n\nConfiguring the initial state of the app is as easy as passing a list of Panel objects to initial. Each element represents one panel and is typically constructed with a command like `ReducedDimensionPlot()`.\n\nPanels are filled from left to right in a row-wise manner depending on the available width. Each panel can be easily customized by modifying the parameters in each object.\n\nThe extra argument should specify Panel classes that might not be shown during initialization but can be added interactively by the user after the app has started. The first instance of each new class in extra will be used as a template when the user adds a new panel of that class. Note that initial will automatically be appended to extra to form the final set of available panels, so it is not strictly necessary to re-specify instances of those initial panels in extra. (unless we want the parameters of newly created panels to be different from those at initialization).\n\nValue\n\nA Shiny app object is returned for interactive data exploration of se, either by simply printing the object or by explicitly running it with runApp.\n\nSetting up a tour\n\nThe tour argument allows users to specify a custom tour to walk their audience through various panels. This is useful for describing different aspects of the dataset and highlighting interesting points in an interactive manner.\n\nWe use the format expected by the rintrojs package - see https://github.com/carlganz/rintrojs#usage for more information. There should be two columns, element and intro, with the former describing the element to highlight and the latter providing some descriptive text. The defaultTour also provides the default tour that is used in the Examples below.\n\nCreating a landing page\n\nIf se is not supplied, a landing page is generated that allows users to upload their own RDS file to initialize the app. By default, the maximum request size for file uploads defaults to 5MB (https://shiny.rstudio.com/reference/shiny/0.14/shiny-options.html). To raise the limit (e.g., 50MB), run options(shiny.maxRequestSize=50*1024^2).\n\nThe landingPage argument can be used to alter the landing page, see createLandingPage for more details. This is useful for creating front-ends that can retrieve SummarizedExperiments from a database on demand for interactive visualization.\n\nSaving application state\n\nIf users want to record the application state, they can download an RDS file containing a list with the entries:\n• memory, a list of Panel objects containing the current state of the application. This can be\ndirectly re-used as the initial argument in a subsequent iSEE call.\n• se, the SummarizedExperiment object of interest. This is optional and may not be present in\nthe list, depending on the user specifications.\n• colormap, the ExperimentColorMap object being used. This is optional and may not be\npresent in the list, depending on the user specifications.\n\nWe can also provide a custom function in saveState that accepts a single argument containing this\nlist. This is most useful when iSEE is deployed in an enterprise environment where sessions can\nbe saved in a persistent location; combined with a suitable landingPage specification, this allows\nusers to easily reload sessions of interest. The idea is very similar to Shiny bookmarks but is more\ncustomizable and can be used in conjunction with URL-based bookmarking.\n\nReferences\n\nRue-Albrecht K, Marini F, Soneson C, Lun ATL. iSEE: Interactive SummarizedExperiment Ex-\nplorer F1000Research 7.\nJavascript code for bugs was based on https://github.com/Auz/Bug.\n\nExamples\n\nlibrary(scRNAseq)\n\n# Example data ----\nsce <- ReprocessedAllenData(assays=\"tophat_counts\")\nclass(sce)\n\nlibrary(scater)\nsce <- logNormCounts(sce, exprs_values=\"tophat_counts\")\n\nsce <- runPCA(sce, ncomponents=4)\nsce <- runTSNE(sce)\nrowData(sce)$ave_count <- rowMeans(assay(sce, \"tophat_counts\"))\nrowData(sce)$n_cells <- rowSums(assay(sce, \"tophat_counts\") > 0)\nsce\n\n# launch the app itself ----\n\napp <- iSEE(sce)\nif (interactive()) {\n shiny::runApp(app, port=1234)\n}\nDescription\n\niSEE is a Bioconductor package that provides an interactive Shiny-based graphical user interface for exploring data stored in SummarizedExperiment objects, including row- and column-level metadata. Particular attention is given to single-cell data in a SingleCellExperiment object with visualization of dimensionality reduction results, e.g., from principal components analysis (PCA) or t-distributed stochastic neighbour embedding (t-SNE).\n\nAuthor(s)\n\nAaron Lun <infinite.monkeys.with.keyboards@gmail.com>\nCharlotte Soneson <charlottesoneson@gmail.com>\nFederico Marini <marinif@uni-mainz.de>\nKevin Rue-Albrecht <kevinrue67@gmail.com>\n\nSee Also\n\nUseful links:\n- [https://github.com/iSEE/iSEE](https://github.com/iSEE/iSEE)\n- Report bugs at [https://github.com/iSEE/iSEE/issues](https://github.com/iSEE/iSEE/issues)\n\n---\n\niSEEOptions\n\nGlobal iSEE options\n\nDescription\n\nGet or set global values that are used by relevant panels during construction and application initialization. This has been deprecated in favor of panelDefaults (for options that apply during Panel construction) and registerAppOptions (for options that apply during application runtime).\n\nUsage\n\niSEEOptions\n\nFormat\n\nAn object of class list of length 4.\n\nCommands\n\nstr(iSEEOptions$get()) will show the default values for all options.\niSEEOptions$set(name=value) will set the named option to value.\niSEEOptions$restore() will reset the global options to the package default values.\nAvailable options\n\npoint.color Default color of data points in DotPlot panels (character).\npoint.size Default size of data points in DotPlot panels (numeric).\npoint.alpha Default alpha level controlling transparency of data points in DotPlot panels (numeric).\ndownsample Enable visual downsampling in DotPlot panels (logical).\ndownsample.resolution Resolution of the visual downsampling, if active (numeric).\nselected.color Color of selected data points in DotPlot panels (character).\nselected.alpha Alpha level controlling transparency of data points not selected in DotPlot panels (numeric).\nselection.dynamic.single Toggle dynamic single selections for all panels (logical).\nselection.dynamic.multiple Toggle dynamic multiple selections for all panels (logical).\ncontour.color Color of the 2d density estimation contour in DotPlot panels (character).\nfont.size Global multiplier controlling the magnification of plot title and text elements in DotPlot panels (numeric).\nlegend.position Position of the legend in DotPlot and ComplexHeatmapPlot panels (one of \"Bottom\", \"Right\").\nlegend.direction Position of the legend in DotPlot and ComplexHeatmapPlot panels (one of \"Horizontal\", \"Vertical\").\npanel.width Default panel grid width (must be between 1 and 12).\npanel.height Default panel height (in pixels).\npanel.color Named character vector of colors. The names of the vector should be set to the name of class to be overridden; if a class is not named here, its default color is used. It is highly recommended to define colors as hex color codes (e.g., \"#1e90ff\"), for full compatibility with both HTML elements and R plots.\ncolor.maxlevels Maximum number of levels for a categorical variable used for coloring. Variables with more levels are coerced to numeric to avoid problems with an overly-large legend. Defaults to 24.\nfactor.maxlevels Maximum number of levels for a categorical variable to be used anywhere in the app. Variables with more levels are coerced to numeric to avoid rendering delays. Defaults to 100.\nassay Character vector of assay names to use if available, in order of preference.\nRowTable.select.details A function that takes a string containing the name of a feature (i.e., the current selection in the RowTable) and returns a HTML element with more details.\nColumnTable.select.details A function that takes a string containing the name of a sample (i.e., the current selection in the ColumnTable) and returns a HTML element with more details.\n\nAuthor(s)\n\nKevin Rue-Albrecht\n\nExamples\n\niSEEOptions$get('downsample'); iSEEOptions$get('selected.color')\njitterSquarePoints Jitter points for categorical variables\n\nDescription\n\nAdd quasi-random jitter on the x-axis for violin plots when the x-axis variable is categorical. Add random jitter within a rectangular area for square plots when both x- and y-axis variables are categorical.\n\nUsage\n\njitterSquarePoints(X, Y, grouping = NULL)\n\njitterViolinPoints(X, Y, grouping = NULL, ...)\n\nArguments\n\n- **X**: A factor corresponding to a categorical variable.\n- **Y**: A numeric vector of the same length as X for jitterViolinPoints, or a factor of the same length as X for jitterSquarePoints.\n- **grouping**: A named list of factors of the same length as X, specifying how elements should be grouped.\n- **...**: Further arguments to be passed to offsetX.\n\nDetails\n\nThe jitterViolinPoints function calls offsetX to obtain quasi-random jittered x-axis values. This reflects the area occupied by a violin plot, though some tuning of arguments in ... may be required to get an exact match.\n\nThe jitterSquarePoints function will uniformly jitter points on both the x- and y-axes. The jitter area is a square with area proportional to the frequency of the paired levels in X and Y. If either factor only has one level, the jitter area becomes a rectangle that can be interpreted as a bar plot.\n\nIf grouping is specified, the values corresponding to each point defines a single combination of levels. Both functions will then perform jittering separately within each unique combination of levels. This is useful for obtaining appropriate jittering when points are split by group, e.g., during faceting.\n\nIf grouping!=NULL for jitterSquarePoints the statistics in the returned summary data.frame will be stratified by unique combinations of levels. To avoid clashes with existing fields, the names in grouping should not be \"X\", \"Y\", \"Freq\", \"XWidth\" or \"YWidth\".\n\nValue\n\nFor jitterViolinPoints, a numeric vector is returned containing the jittered x-axis coordinates for all points.\n\nFor jitterSquarePoints, a list is returned with numeric vectors X and Y, containing jittered coordinates on the x- and y-axes respectively for all points; and summary, a data.frame of frequencies and side lengths for each unique pairing of X/Y levels.\nlassoPoints\n\nAuthor(s)\nAaron Lun\n\nExamples\n\n```r\nX <- factor(sample(LETTERS[1:4], 100, replace=TRUE))\nY <- rnorm(100)\n(out1 <- jitterViolinPoints(X=X, Y=Y))\n\nY2 <- factor(sample(letters[1:3], 100, replace=TRUE))\n(out2 <- jitterSquarePoints(X=X, Y=Y2))\n\ngrouped <- sample(5, 100, replace=TRUE)\n(out3 <- jitterViolinPoints(X=X, Y=Y, grouping=list(FacetRow=grouped)))\n(out4 <- jitterSquarePoints(X=X, Y=Y2, grouping=list(FacetRow=grouped)))\n```\n\nDescription\n\nIdentify the rows of a data.frame lying within a closed lasso polygon, analogous to `brushedPoints`.\n\nUsage\n\n```r\nlassoPoints(df, lasso)\n```\n\nArguments\n\n- `df`: A data.frame from which to select rows.\n- `lasso`: A list containing data from a lasso.\n\nDetails\n\nThis function uses `in.out` from the `mgcv` package to identify points within a polygon. This involves a boundary crossing algorithm that may not be robust in the presence of complex polygons with intersecting edges.\n\nValue\n\nA subset of rows from `df` with coordinates lying within `lasso`.\n\nAuthor(s)\nAaron Lun\n\nSee Also\n`brushedPoints`\nExamples\n\nlasso <- list(coord=rbind(c(0, 0), c(0.5, 0), c(0, 0.5), c(0, 0)),\n closed=TRUE, mapping=list(x=\"X\", y=\"Y\"))\nvalues <- data.frame(X=runif(100), Y=runif(100),\n row.names=sprintf(\"VALUE_%i\", seq_len(100)))\nlassoPoints(values, lasso)\n\n# With faceting information:\nlasso <- list(coord=rbind(c(0, 0), c(0.5, 0), c(0, 0.5), c(0, 0)),\n panelvar1=\"A\", panelvar2=\"B\", closed=TRUE,\n mapping=list(x=\"X\", y=\"Y\",\n panelvar1=\"FacetRow\", panelvar2=\"FacetColumn\"))\nvalues <- data.frame(X=runif(100), Y=runif(100),\n FacetRow=sample(LETTERS[1:2], 100, replace=TRUE),\n FacetColumn=sample(LETTERS[1:4], 100, replace=TRUE),\n row.names=sprintf(\"VALUE_%i\", seq_len(100)))\nlassoPoints(values, lasso)\n\nmanage_commands\n\nManage commands to be evaluated\n\nDescription\n\nFunctions to manage commands to be evaluated.\n\nUsage\n\n.textEval(cmd, envir)\n\nArguments\n\ncmd A character vector containing commands to be executed.\nenvir An environment in which to execute the commands.\n\nValue\n\n.textEval returns the output of eval(parse(text=cmd), envir), unless cmd is empty in which case it returns NULL.\n\nAuthor(s)\n\nAaron Lun, Kevin Rue-Albrecht\n\nExamples\n\nmyenv <- new.env()\nmyenv$x <- \"Hello world!\"\n.textEval(\"print(x)\", myenv)\n**metadata-plot-generics**\n\n*Generics for row/column metadata plots*\n\n---\n\n**Description**\n\nThese generics allow subclasses to refine the choices of allowable variables on the x- and y-axes of a `ColumnDataPlot` or `RowDataPlot`. This is most useful for restricting the visualization to a subset of variables, e.g., only taking log-fold changes in a y-axis of a MA plot.\n\n**Allowable y-axis choices**\n\n`.allowableYAxisChoices(x, se)` takes `x`, a `Panel` instance; and `se`, the `SummarizedExperiment` object. It is expected to return a character vector containing the names of acceptable variables to show on the y-axis. For `ColumnDataPlots`, these should be a subset of the variables in `colData(se)`, while for `RowDataPlots`, these should be a subset of the variables in `rowData(se)`.\n\nGiven a constant `se`, the output of this function should be constant for all instances of the same panel class. As such, it is a good idea to make use of information precomputed by `.cacheCommonInfo`. For example, `.cacheCommonInfo,ColumnDotPlot-method` will add vectors specifying whether a variable in the `colData` is valid and discrete or continuous, which can be intersected with any additional requirements in a subclass’s method for this generic.\n\nThis generic is called by `.defineDataInterface` for `ColumnDataPlots` and `RowDataPlots`. Thus, developers wanting to restrict those choices for subclasses can simply specialize `.allowableYAxisChoices` rather than reimplementing `.defineDataInterface`.\n\n**Allowable x-axis choices**\n\n`.allowableXAxisChoices(x, se)` is the same as above but controls the variables that can be shown on the x-axis. This need not return the same subset of variables as `.allowableYAxisChoices`. However, again, the output of this function should be constant for all instances of the same class and a constant `se`.\n\n**Author(s)**\n\nAaron Lun\n\n---\n\n**multi-select-generics** \n*Generics for controlling multiple selections*\n\n---\n\n**Description**\n\nA panel can create a multiple selection on either the rows or columns and transmit this selection to another panel to affect its set of displayed points. For example, users can brush on a `DotPlots` to select a set of points, and then the panel can transmit the identities of those points to another panel for highlighting.\n\nThis suite of generics controls the behavior of these multiple selections. In all of the code chunks shown below, `x` is assumed to be an instance of the `Panel` class.\nPossibility of selection\n\n`.isBrushable(x)` should return a logical specifying whether the panel supports selection using a Shiny brush or lasso waypoints. The output should be constant for all instances of `x` and is used to govern the reporting of multiple selections in the code tracker.\n\nSpecifying the dimension\n\n`.multiSelectionDimension(x)` should return a string specifying whether the selection contains rows (\"row\"), columns (\"column\") or if the Panel in `x` does not perform multiple selections at all (\"none\"). The output should be constant for all instances of `x` and is used to govern the interface choices for the selection parameters.\n\nSpecifying the active selection\n\n`.multiSelectionActive(x)` should return some structure containing all parameters required to identify all points in the active multiple selection of `x`. For example, the `DotPlot` method for this generic would return the contents of the `BrushData` slot, usually a list containing a Shiny brush or lasso waypoints for `DotPlot` classes. If `.multiSelectionActive(x)` returns `NULL`, `x` is assumed to have no active multiple selection.\n\nThe active selection is considered to be the one that can be directly changed by the user, as compared to saved selections that are not modifiable (other than being deleted on a first-in-last-out basis). This generic is primarily used to bundle up selection parameters to be stored in the `SelectionHistory` slot when the user saves the current active selection.\n\nEvaluating the selection\n\n`.multiSelectionCommands(x, index)` is expected to return a character vector of commands to generate a character vector of row or column names in the desired multiple selection of `x`. If `index=NA`, the desired selection is the currently active one; developers can assume that `.multiSelectionActive(x)` returns a non-NULL value in this case. Otherwise, for an integer `index`, it refers to the corresponding saved selection in the `SelectionHistory`.\n\nThe commands will be evaluated in an environment containing:\n\n- `select`, a variable of the same type as returned by `.multiSelectionActive(x)`. This will contain the active selection if `index=NA` and one of the saved selections otherwise. For example, for `DotPlots`, `select` will be either a Shiny brush or a lasso structure.\n- `contents`, some arbitrary content saved by the rendering expression in `.renderOutput(x)`. This is most often a data.frame but can be anything as long as `.multiSelectionCommands` knows how to process it. For example, a data.frame of coordinates is stored by `DotPlots` to identify the points selected by a brush/lasso.\n- `se`, the `SummarizedExperiment` object containing the current dataset.\n\nThe output commands are expected to produce a character vector named `selected` in the evaluation environment. All other variables generated by the commands should be prefixed with `.` to avoid name clashes.\nDetermining the available points for selection\n\n.mcMultiSelectionAvailable(x, contents) is expected to return an integer scalar specifying the number of points available for selection in the the current instance of the panel x. The contents field in the output of .generateOutput is passed to the contents argument of this generic.\n\nThe default method for this generic returns nrow(contents) for all Panel subclasses, assuming that contents is a data.frame where each row represents a point. If not, this method needs to be specialized in order to return an accurate total of available points, which is ultimately used to compute the percentage selected in the multiple selection information panels.\n\nDestroying selections\n\n.mcMultiSelectionClear(x) should return x after removing the active selection, i.e., so that nothing is selected. This is used internally to remove multiple selections that do not make sense after protected parameters have changed. For example, a brush or lasso made on a PCA plot in Reduced-DimensionPlots would not make sense after switching to t-SNE coordinates, so the application will automatically erase those selections to avoid misleading conclusions.\n\nResponding to selections\n\nThese generics control how x responds to a transmitted multiple selection, not how x itself transmits selections.\n\n.mcMultiSelectionRestricted(x) should return a logical scalar indicating whether x’s displayed contents will be restricted to the selection transmitted from another panel. This is used to determine whether child panels of x need to be re-rendered when x’s transmitter changes its multiple selection. For example, the method for RowDotPlots and ColumnDotPlots would return TRUE if RowSelectionRestrict=TRUE or ColumnSelectionRestrict=TRUE, respectively. Otherwise, it would be FALSE as the transmitted selection is only used for aesthetics, not for changing the identity of the displayed points.\n\n.mcMultiSelectionInvalidated(x) should return a logical scalar indicating whether a transmission of a multiple selection to x invalidates x’s own existing selections. This should only be TRUE in special circumstances, e.g., if receipt of a new multiple selection causes recalculation of coordinates in a DotPlot.\n\n.mcMultiSelectionResponsive(x, dims) should return a logical scalar indicating whether x is responsive to an incoming multiple selection on dimensions dims. For example, the method for ComplexHeatmapPlot would return TRUE when an incoming selection originates from a row-oriented panel and CustomRows=FALSE. Otherwise, it would be FALSE as the dimension of the transmitted selection is dismissed by the options of the child panel.\n\nAuthor(s)\n\nAaron Lun\nmultiSelectionToFactor\n\nConvert multiple selections into a factor\n\nDescription\n\nConvert multiple selection information into a factor, typically for use as a covariate or for coloring.\n\nUsage\n\nmultiSelectionToFactor(selected, all.names)\n\nArguments\n\n- `selected`: A named list of character vectors, containing the names of selected observations for different selections. Vectors for different selections may overlap.\n- `all.names`: Character vector of all observations.\n\nValue\n\nA factor containing the set(s) to which each observation is assigned. Multiple sets are encoded as comma-separated strings. Unselected observations are listed as \"unselected\".\n\nAuthor(s)\n\nAaron Lun\n\nExamples\n\n```r\nmultiSelectionToFactor(list(active=c(\"A\", \"B\"),\n saved1=c(\"B\", \"C\"),\n saved2=c(\"D\", \"E\", \"F\")),\n all.names=LETTERS[1:10])\n```\n\nobserver-generics\n\nGeneric for the panel observers\n\nDescription\n\nThe workhorse generic for defining the Shiny observers for a given panel, along with recommendations on its implementation.\nCreating parameter observers\n\nIn `.createObservers(x, se, input, session, pObjects, rObjects)`, the required arguments are:\n\n- `x`, an instance of a `Panel` class.\n- `se`, a `SummarizedExperiment` object containing the current dataset. This can be assumed to have been produced by running `.refineParameters(x, se)`.\n- `input`, the Shiny input object from the server function.\n- `session`, the Shiny session object from the server function.\n- `pObjects`, an environment containing global parameters generated in the `iSEE` app.\n- `rObjects`, a reactive list of values generated in the `iSEE` app.\n\nMethods for this generic are expected to set up all observers required to respond to changes in the interface elements set up by `.defineInterface`. Recall that each interface element has an ID of the form of `PANEL_SLOT`, where `PANEL` is the panel name (from `.getEncodedName`) and `SLOT` is the name of the slot modified by the interface element. Thus, observers should respond to changes in those elements in `input`. The return value of this generic is not used; only the side-effect of observer set-up is relevant.\n\nIt is the developer’s responsibility to call `callNextMethod` to set up the observers required by the parent class. This is best done by calling `callNextMethod` at the top of the method before defining up additional observers. Each parent class should implement observers for its slots, so it is usually only necessary to implement observers for any newly added slots in a particular class.\n\nModifying the memory\n\nConsider an observer for an interface element that modifies a slot of `x`. The code within this observer is expected to modify the “memory” of the app state in `pObjects`, via:\n\n```r\nnew_value <- input[[paste0(PANEL, \"_\", SLOT)]]\npObjects$memory[[PANEL]][[SLOT]] <- new_value\n```\n\nThis enables `iSEE` to keep a record of the current state of the application. In fact, any changes must go through `pObjects$memory` before they change the output in `.renderOutput`; there is no direct interaction between input and output in this framework.\n\nWe suggest using `.createProtectedParameterObservers` and `.createUnprotectedParameterObservers`, which create simple observers that update the memory in response to changes in the UI elements.\n\nFor handling selectize elements filled with server-side row/column names, we can use `.createCustomDimnamesModalObservers`.\n\nDevelopers should not attempt to modify `x` in any observer expression. This value does not have pass-by-reference semantics and any changes will not propagate to other parts of the application. Rather, modifications should occur to the version of `x` in `pObjects$memory`, as described in the code chunk above.\n\nTriggering re-rendering\n\nTo trigger re-rendering of an output, observers should call `.requestUpdate(PANEL, rObjects)` where `PANEL` is the name of the current panel. This will request a re-rendering of the output with no additional side effects and is most useful for responding to aesthetic parameters.\nIn some cases, changes to some parameters may invalidate existing multiple selections, e.g., brushes and lassos are no longer valid if the variable on the axes are altered. Observers responding to such changes should instead call `requestCleanUpdate(PANEL, pObjects, rObjects)`, which will destroy all existing selections in order to avoid misleading conclusions.\n\n**Author(s)**\n\nAaron Lun\n\n**Description**\n\nAn overview of the generics for defining the panel outputs, along with recommendations on their implementation.\n\n**Defining the output element**\n\n`.defineOutput(x)` defines the output element of the panel (e.g., a plot or table widget), given an instance of a `Panel` subclass in `x`.\n\nMethods for this generic are expected to return a HTML element containing the visual output of the panel, such as the return value of `plotOutput` or `dataTableOutput`. This element will be shown in the `iSEE` interface above the parameter boxes for `x`. Multiple elements can be returned via a `tagList`.\n\nThe IDs of the output elements are expected to be prefixed with the panel name from `.getEncodedName(x)` and an underscore, e.g., \"ReducedDimensionPlot1_someOutput\". One of the output elements may simply have the ID set to `PANEL` alone; this is usually the case for simple panels with one primary output like a `DotPlot`.\n\n**Defining the rendered output**\n\n`.renderOutput(x, se, ..., output, pObjects, rObjects)` will create an expression to render the panel’s output. The following arguments are required:\n\n- `x`, an instance of a `Panel` class.\n- `se`, a `SummarizedExperiment` object containing the current dataset.\n- `...`, further arguments that may be used by specific methods.\n- `output`, the Shiny output object from the server function.\n- `pObjects`, an environment containing global parameters generated in the `iSEE` app.\n- `rObjects`, a reactive list of values generated in the `iSEE` app.\n\nIt is expected to attach one or more reactive expressions to `output` to render the output element(s) defined by `.defineOutput`. This is typically done by calling `shiny` rendering functions like `renderPlot` or the most appropriate equivalent for the panel’s output. The return value of this generic is not used; only the side-effect of the reactive output set-up is relevant.\n\nThe rendering expression inside the chosen rendering function is expected to:\noutput-generics\n\n1. Call `force(rObjects[[PANEL]])`, where PANEL is the output of `.getEncodedName(x)`. This ensures that the output is rerendered upon requesting changes in `.requestUpdate`.\n\n2. Call `.generateOutput` to generate the output content to be rendered.\n\n3. Fill `pObjects$contents[[PANEL]]` with some content related to the displayed output that allows cross-referencing with single/multiple selection structures. This will be used in other generics like `.multiSelectionCommands` and `.singleSelectionValue` to determine the identity of the selected point(s). As a result, it is only strictly necessary if the panel is a potential transmitter, as determined by the return value of `.multiSelectionDimension`.\n\n4. Fill `pObjects$commands[[PANEL]]` with a character vector of commands required to produce the displayed output. This should minimally include the commands required to generate `pObjects$contents[[PANEL]]`; for plotting panels, the vector should also include code to create the plot.\n\n5. Fill `pObjects$varname[[PANEL]]` with a string containing the R expression in `pObjects$commands[[PANEL]]` that holds the contents stored in `pObjects$contents[[PANEL]]`. This is used for code reporting, and again, is only strictly necessary if the panel is a potential transmitter.\n\nWe strongly recommend calling `.retrieveOutput` within the rendering expression, which will automatically perform all of the tasks above, rather than calling `.generateOutput` manually. By doing so, the only extra work required of the rendering expression is to actually render the output (e.g., by printing a `ggplot` object). Of course, the rendering expression must itself be encapsulated by an appropriate rendering function assigned to output.\n\nDevelopers should not attempt to modify `x` in any rendering expression. This does not have pass-by-reference semantics and any changes will not propagate to other parts of the application. Similarly, the rendering expression should treat `pObjects$memory` as read-only. Any adjustment of parameters should be handled elsewhere, e.g., by the observer expressions in `.createObservers`.\n\nGenerating content\n\n`.generateOutput(x, se, all_memory, all_contents)` actually generates the panel’s output to be used in the rendering expression. The following arguments are required:\n\n- `x`, an instance of a `Panel` class.\n- `se`, a `SummarizedExperiment` object containing the current dataset.\n- `all_memory`, a named list containing `Panel` objects parameterizing the current state of the app.\n- `all_contents`, a named list containing the contents of each panel.\n\nMethods for this generic should return a list containing:\n\n- `contents`, some arbitrary content for the panel (usually a data.frame). The values therein are used by `.multiSelectionCommands` to determine the multiple row/column selection in `x` to be transmitted to other (child) panels. The app will ensure that the `pObjects$contents` of each panel is populated before attempting to render their children. `contents` may be set to `NULL` if `x` does not transmit, i.e., `.multiSelectionDimension` returns \"none\".\n- `commands`, a list of character vectors of R commands that, when executed, produces the contents of the panel and any displayed output (e.g., a `ggplot` object). Developers should write these commands as if the evaluation environment only contains the `SummarizedExperiment` `se` and `ExperimentColorMap` `colormap`. It may also contain `col_selected`, if a multiple column selection is being transmitted to `x`; and possibly `row_selected`, if a multiple row selection is being transmitted to `x`. \n• varname, a string specifying the name of the variable in commands used to generate contents. This is used to fulfill code tracking obligations. If the current panel is not a transmitter, this may be set to NULL instead.\n\nThe output list may contain any number of other fields that can be used by .renderOutput but are otherwise ignored.\n\nWe suggest implementing this method using eval(parse(text=...)) calls, which enables easy construction and evaluation of the commands and contents at the same time. A convenient wrapper for this call is provided by the .textEval utility.\n\nThe all_memory and all_contents arguments are provided for the sole purpose of determining what multiple selections are being received by x. We strongly recommend passing them onto .processMultiSelections to do the heavy lifting. It would be unusual and inadvisable to use these arguments for any other information sharing across panels.\n\nExporting content\n.\n.exportOutput(x, se, all_memory, all_contents) converts the panel output into a downloadable form. The following arguments are required:\n\n• x, an instance of a Panel class.\n• se, a SummarizedExperiment object containing the current dataset.\n• all_memory, a named list containing Panel objects parameterizing the current state of the app.\n• all_contents, a named list containing the contents of each panel.\n\nMethods for this generic should generate appropriate files containing the content of x. (For example, plots may create PDFs while tables may create CSV files.) All files should be created in the working directory at the time of the function call, possibly in further subdirectories. Each file name should be prefixed with the .getEncodedName. The method itself should return a character vector containing relative paths to all newly created files.\n\nTo implement this method, we suggest simply passing all arguments onto .generateOutput and then converting the output into an appropriate file.\n\nAuthor(s)\n\nAaron Lun\n\nPanel-class\n\nThe Panel virtual class\n\nDescription\n\nThe Panel is a virtual base class for all iSEE panels. It provides slots and methods to control the height and width of each panel, as well as functionality to control the choice of “transmitting” panels from which to receive a multiple row/column selection.\nSlot overview\n\nThe following slots are relevant to panel organization:\n\n--panelId, an integer scalar specifying the identifier for the panel. This should be unique across panels of the same concrete class.\n-PanelWidth, an integer scalar specifying the width of the panel. Bootstrap coordinates are used so this value should lie between 2 and 12; defaults to 4 in `getPanelDefault`\n-PanelHeight, an integer scalar specifying the height of the panel in pixels. This is expected to lie between 400 and 1000; defaults to 500 in `getPanelDefault`\n\nThe following slots are relevant to receiving a multiple selection on the rows:\n\n-RowSelectionSource, a string specifying the name of the transmitting panel from which to receive a multiple row selection (e.g., \"RowDataPlot1\"). Defaults to \"---\".\n-RowSelectionDynamicSource, a logical scalar indicating whether x should dynamically change its selection source for multiple row selections. Defaults to FALSE in `getPanelDefault`\n-RowSelectionRestrict, a logical scalar indicating whether the display of x should be restricted to the rows in the multiple selection received from a transmitting panel. Defaults to FALSE.\n\nThe following slots are relevant to receiving a multiple selection on the columns:\n\n-ColumnSelectionSource, a string specifying the name of the transmitting panel from which to receive a multiple column selection (e.g., \"ColumnDataPlot1\"). Defaults to \"---\".\n-ColumnSelectionDynamicSource, a logical scalar indicating whether x should dynamically change its selection source for multiple column selections. Defaults to FALSE in `getPanelDefault`\n-ColumnSelectionRestrict, a logical scalar indicating whether the display of x should be restricted to the columns in the multiple selection received from a transmitting panel. Defaults to FALSE.\n\nThere are also the following miscellaneous slots:\n\n-SelectionBoxOpen, a logical scalar indicating whether the selection parameter box should be open at initialization. Defaults to FALSE.\n-SelectionHistory, a list of arbitrary elements that contain parameters for saved multiple selections. Each element of this list corresponds to one saved selection in the current panel. Defaults to an empty list.\n-VersionInfo, a named list of `package_version` objects specifying the versions of packages used to create a given `Panel` instance. This information is used to inform `updateObject` of any updates that need to be applied. By default, it is filled with a single \"iSEE\" entry containing the current version of iSEE.\n\nGetting and setting slots\n\nIn all of the following code chunks, x is an instance of a Panel, and i is a string containing the slot name:\n\n- `x[[i]]` returns the value of a slot named i.\n- `x[[i]] <- value` modifies x so that the value in slot i is replaced with value.\n- `show(x)` will print a summary of all (non-hidden) slots and their values.\n**Supported methods**\n\nIn the following code snippets, x is an instance of a ColumnDotPlot class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- `.refineParameters(x, se)` calls `updateObject(x)`. If x is up to date, this operation is a no-op and returns x without modification.\n- `.cacheCommonInfo(x, se)` is a no-op, returning se without modification.\n\nFor defining the interface:\n\n- `.defineInterface(x, se, select_info)` will return a list of collapsible boxes for changing data and selection parameters. The data parameter box will be populated based on `.defineDataInterface`.\n- `.defineDataInterface(x, se, select_info)` will return an empty list.\n- `.hideInterface(x, field)` will always return `FALSE`.\n\nFor monitoring reactive expressions:\n\n- `.createObservers(x, se, input, session, pObjects, rObjects)` will add observers to respond to changes in multiple selection options. It will also call `.singleSelectionSlots(x)` to set up observers for responding to transmitted single selections.\n- `.renderOutput(x, se, output, pObjects, rObjects)` will add elements to output for rendering the information textboxes at the bottom of each panel. Each panel should specialize this method to add rendering expressions for the actual output (e.g., plots, tables), followed by a `callNextMethod` to create the textboxes.\n\nFor generating output:\n\n- `.exportOutput(x, se, all_memory, all_contents)` is a no-op, i.e., it will return an empty character vector and create no files.\n\nFor documentation:\n\n- `.definePanelTour(x)` returns a data.frame containing the selection-related steps of the tour.\n\nFor controlling selections:\n\n- `.multiSelectionRestricted(x)` will always return `TRUE`.\n- `.multiSelectionDimension(x)` will always return \"none\".\n- `.multiSelectionActive(x)` will always return `NULL`.\n- `.multiSelectionClear(x)` will always return x.\n- `.multiSelectionInvalidated(x)` will always return `FALSE`.\n- `.multiSelectionAvailable(x, contents)` will return `nrow(contents)`.\n- `.singleSelectionDimension(x)` will always return \"none\".\n- `.singleSelectionValue(x)` will always return `NULL`.\n- `.singleSelectionSlots(x)` will always return an empty list.\nSubclass expectations\n\nSubclasses are required to implement methods for:\n\n- .defineOutput\n- .generateOutput\n- .renderOutput\n- .fullName\n- .panelColor\n\nSubclasses that transmit selections should also implement specialized methods for selection-related parameters listed above.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\nDotPlot and Table, for examples of direct subclasses.\n\npanelDefaults\n\nPanel defaults\n\nDescription\n\nGet or set default parameters that are used by certain Panel during their construction. This allows users to easily change the defaults for multiple panels simultaneously without having to manually specify them in the constructor.\n\nUsage\n\npanelDefaults(...)\n\ngetPanelDefault(name, error = TRUE)\n\nArguments\n\n- ... Named options to set. Alternatively a single named list containing the options to set.\n- name String containing the name of the option to retrieve. Alternatively NULL, in which case the current values of all options are returned as a named list.\n- error Logical scalar indicating whether an error should be raised if name cannot be found.\nDetails\n\nAll options set by `panelDefaults` will only affect `Panel` construction and have no effect on the behavior of Panels that are already constructed. Most options are named after the affected slot in the relevant Panel subclass.\n\nFor general `Panels`:\n- `PanelWidth`, defaults to 4.\n- `PanelHeight`, defaults to 500.\n\nFor `DotPlots`:\n- `ColorByDefaultColor`, defaults to \"black\".\n- `PointSize`, defaults to 1.\n- `PointAlpha`, defaults to 1.\n- `Downsample`, defaults to FALSE.\n- `DownsampleResolution`, defaults to 200.\n- `SelectionAlpha`, defaults to 0.1.\n- `ContourColor`, defaults to \"blue\".\n- `FontSize`, defaults to 1.\n- `LegendPointSize`, defaults to 1.\n\nFor `RowDotPlots`:\n- `TooltipRowData`, defaults to character(0).\n\nFor `ColumnDotPlots`:\n- `TooltipColumnData`, defaults to character(0).\n\nFor `ComplexHeatmapPlots`:\n- `LegendDirection`, defaults to \"Horizontal\".\n\nA few options affect multiple subclasses that independently define the same slot:\n- `LegendPosition`, defaults to \"Bottom\". Affects `DotPlots` and `ComplexHeatmapPlots`.\n- `Assay`, defaults to \"logcounts\". Affects `FeatureAssayPlots`, `SampleAssayPlots` and `ComplexHeatmapPlots`.\n\nA few options are not named after any particular slot as they affect different slots in different subclasses:\n- `ColorByNameColor`, defaults to \"red\". This affects `ColorByFeatureNameColor` in `RowDotPlots` and `ColorBySampleNameColor` in `ColumnDotPlots`.\n- `ColorByNameAssay`, defaults to \"logcounts\". This affects `ColorByFeatureNameAssay` in `RowDotPlots` and `ColorBySampleNameAssay` in `ColumnDotPlots`.\n- `SingleSelectionDynamicSource`, defaults to FALSE. This affects `ColorByFeatureDynamicSource`, `ColorBySampleDynamicSource`, `XAxisFeatureDynamicSource`, `YAxisFeatureDynamicSource`, `XAxisSampleDynamicSource` and `YAxisSampleDynamicSource` in the relevant panels.\n- `MultipleSelectionDynamicSource`, defaults to FALSE. This affects `RowSelectionDynamicSource` and `ColumnSelectionDynamicSource`. \nValue\n\n`panelDefaults` will return a named list of the values of all options. If ... is non-empty, `panelDefaults` will modify the global options that are used during the constructors for the relevant `Panel` classes. (Note that the return value still contains the values before the modification is applied.)\n\n`getPanelDefault` will return the current value of the requested option. If `error=TRUE` and name is not present, an error is raised; otherwise `NULL` is returned.\n\nFor developers\n\nDevelopers of Panel subclasses may add more options to this list, typically by calling `panelDefaults` in the `.onLoad` expressions of the package containing the subclass. We recommend prefixing any options with the name of the package in the form of `<PACKAGE>_<OPTION>`, so as to avoid conflicts with other options (in the base classes, or in other downstream packages) that have the same name. Any options added in this manner should correspond to parameters that are already present as slots in the panel class. If this is not the case, consider using `registerAppOptions` instead.\n\nAuthor(s)\n\nKevin Rue-Albrecht\n\nExamples\n\n```r\nold <- panelDefaults(Assay=\"WHEE\")\ngetPanelDefault(\"Assay\")\n\nold <- panelDefaults(Assay=\"FOO\", PointSize=5)\ngetPanelDefault(\"Assay\")\ngetPanelDefault(\"PointSize\")\n\n# We can also list out all options:\npanelDefaults()\n\n# Restoring the previous defaults.\npanelDefaults(old)\ngetPanelDefault(\"Assay\")\ngetPanelDefault(\"PointSize\")\n```\n\nDescription\n\nA series of generics for controlling how plotting is performed in `DotPlot` panels. `DotPlot` subclasses can specialize one or more of them to modify the behavior of `.generateOutput`.\nGenerating plotting data\n\n`.generateDotPlotData(x, envir)` sets up the data to use in the `DotPlot` plot. The following arguments are required:\n\n- `x`, an instance of a `DotPlot` subclass.\n- `envir`, the evaluation environment in which the data.frame is to be constructed. This can be assumed to have `se`, the `SummarizedExperiment` object containing the current dataset; possibly `col_selected`, if a multiple column selection is being transmitted to `x`; and possibly `row_selected`, if a multiple row selection is being transmitted to `x`.\n\nA method for this generic should add a `plot.data` variable in `envir` containing a data.frame with columns named \"X\" and \"Y\", denoting the variables to show on the x- and y-axes respectively. It should return a list with commands, a character vector of commands that produces `plot.data` when evaluated in `envir`; and labels, a list of strings containing labels for the x-axis (named \"X\"), y-axis (\"Y\") and plot (\"title\").\n\nEach row of the `plot.data` data.frame should correspond to one row or column in the SummarizedExperiment `envir$se` for `RowDotPlots` and `ColumnDotPlots` respectively. Note that, even if only a subset of rows/columns in the SummarizedExperiment are to be shown, there must always be one row in the data.frame per row/column of the SummarizedExperiment, and in the same order. All other rows of the data.frame should be filled in with NAs rather than omitted entirely. This is necessary for correct interactions with later methods that add other variables to `plot.data`.\n\nAny internal variables that are generated by the commands in `commands` should be prefixed with `.` to avoid potential clashes with reserved variable names in the rest of the application.\n\nThis generic is called by `.generateDotPlot` (see below), which is in turn called by `.generateOutput`. The idea is that developers can specialize `.generateDotPlotData` to change the data source for a `DotPlot` subclass without needing to reimplement the entirety of `.generateDotPlot`.\n\nGenerating the ggplot object\n\n`.generateDotPlot(x, labels, envir)` creates the plot to be shown in the interface. The following arguments are required:\n\n- `x`, an instance of a `DotPlot` subclass.\n- `labels`, a list of labels corresponding to the columns of `plot.data`. This is typically used to define axis or legend labels in the plot.\n- `envir`, the evaluation environment in which the `ggplot` object is to be constructed. This can be assumed to have `plot.data`, a data.frame of plotting data.\n\nNote that `se`, `row_selected` and `col_selected` will still be present in `envir`, but it is simplest to only use information that has already been incorporated into `plot.data` where possible. This is because the order and number of rows in `plot.data` may have changed since `.generateDotPlotData`.\n\nMethods for this generic should return a list with `plot`, a `ggplot` object; and `commands`, a character vector of commands to produce that object when evaluated inside `envir`. This plot will subsequently be the rendered output in `.renderOutput`. Note that `envir` should contain a copy of the plot object in a variable named `dot.plot` - see below for details.\nMethods are expected to respond to the presence of various fields in the plot.data. The data.frame will contain, at the very least, the fields \"X\" and \"Y\" from .generateDotPlotData. Depending on the parameters of x, it may also have the following columns:\n\n- \"ColorBy\", the values of the covariate to use to color each point.\n- \"ShapeBy\", the values of the covariate to use for shaping each point. This is guaranteed to be categorical.\n- \"SizeBy\", the values of the covariate to use for sizing each point. This is guaranteed to be continuous.\n- \"FacetRow\", the values of the covariate to use to create row facets. This is guaranteed to be categorical.\n- \"FacetColumn\", the values of the covariate to use to create column facets. This is guaranteed to be categorical.\n- \"SelectBy\", a logical field indicating whether the point was included in a multiple selection (i.e., transmitted from another plot with x as the receiver). Note that if RowSelectionRestrict=TRUE or ColumnSelectionRestrict=TRUE (for RowDotPlots and ColumnDotPlots, respectively), plot.data will already have been subsetted to only retain TRUE values of this field.\n\nenvir may also contain the following variables:\n\n- plot.data.all, present when a multiple selection is transmitted to x and RowSelectionRestrict=TRUE or ColumnSelectionRestrict=TRUE (for RowDotPlots and ColumnDotPlots, respectively). This is a data.frame that contains all points prior to subsetting and is useful for defining the boundaries of the plot such that they do not change when the transmitted multiple selection changes.\n- plot.data.pre, present when downsampling is turned on. This is a data.frame that contains all points prior to downsampling (but after subsetting, if that was performed) and is again mainly used to fix the boundaries of the plot.\n\nDevelopers may wish to use the .addMultiSelectionPlotCommands utility to draw brushes and lassos of x. Note that this refers to the brushes and lassos made on x itself, not those transmitted from another panel to x.\n\nIt would be very unwise for methods to alter the x-axis, y-axis or faceting values in plot.data. This will lead to unintuitive discrepancies between apparent visual selections for a brush/lasso and the actual multiple selection that is evaluated by downstream functions like .processMultiSelections. In certain situations, a DotPlot subclass may be able to build off a ggplot generated by its parent class. This is easily done by exploiting the fact that methods for this generic are expected to store a copy of their plot ggplot object as a dot.plot variable in envir. A specialized method for the subclass can callNextMethod() to populate envir with the initial dot.plot, and then just construct and execute commands to add more ggplot2 layers as desired.\n\nThis generic is called by .generateOutput for DotPlot subclasses. Again, the idea here is that developers can specialize .generateDotPlot to change the plot aesthetics without needing to reimplement the entirety of .generateOutput.\n\n**Prioritizing points**\n\n`.prioritizeDotPlotData(x, envir)` specifies the “priority” of points to be plotted, where high-priority points are plotted last so that they will not be masked by other points. The following arguments are required:\n• x, an instance of a DotPlot subclass.\n• envir, the evaluation environment in which the ggplot object is to be constructed. This can be assumed to have plot.data, a data.frame of plotting data.\n\nAgain, note that se, row_selected and col_selected will still be present in envir, but it is simplest to only use information that has already been incorporated into plot.data where possible. This is because the order and number of rows in plot.data may have changed since .generateDotPlotData.\n\nMethods for this generic are expected to generate a .priority variable in envir, an ordered factor of length equal to nrow(plot.data) indicating the priority of each point. They may also generate a .rescaled variable, a named numeric vector containing the scaling factor to apply to the downsampling resolution for each level of .priority.\n\nThe method itself should return a list containing commands, a character vector of R commands required to generate these variables; and rescaled, a logical scalar indicating whether a .rescaled variable was produced.\n\nPoints assigned the highest level in .priority are regarded as having the highest visual importance. Such points will be shown on top of other points if there are overlaps on the plot, allowing developers to specify that, e.g., DE genes should be shown on top of non-DE genes. Scaling of the resolution enables developers to perform more aggressive downsampling for unimportant points.\n\nMethods for this generic may also return NULL, in which case no special action is taken.\n\nThis generic is called by .generateDotPlot, which is in turn called by .generateOutput. Thus, developers of DotPlot subclasses can specialize this generic to change the point priority without needing to reimplement the entirety of .generateDotPlot.\n\nControlling the “None” color scale\n\nIn some cases, it is desirable to insert a default scale when ColorBy=”None”. This is useful for highlighting points in a manner that is integral to the nature of the plot, e.g., up- or down-regulated genes in a MA plot. We provide a few generics to help control which points are highlighted and how they are colored.\n\n.colorByNoneDotPlotField(x) expects x, an instance of a DotPlot subclass, and returns a string containing a name of a column in plot.data to use for coloring in the ggplot mapping. This assumes that the relevant field was added to plot.data by a method for .generateDotPlotData.\n\n.colorByNoneDotPlotScale(x) expects x, an instance of a DotPlot subclass, and returns a string containing a ggplot2 scale_color_* call, e.g., scale_color_manual. This string should end with a “+” operator as additional ggplot2 layers will be added by iSEE.\n\nThis generic is called by .generateDotPlot, which is in turn called by .generateOutput. Thus, developers of DotPlot subclasses can specialize this generic to change the default color scheme without needing to reimplement the entirety of .generateDotPlot.\n\nAuthor(s)\n\nKevin “K-pop” Rue-Albrecht, Aaron “A-bomb” Lun\nProcess faceting choices\n\nDescription\nGenerate ggplot instructions to facet a plot by row and/or column\n\nUsage\n.plot-utils\n\nArguments\nx A single-row DataFrame that contains all the input settings for the current panel.\n\nValue\nA string containing a command to define the row and column faceting covariates.\n\nExamples\nx <- ReducedDimensionPlot(\n FacetRowBy = \"Column data\", FacetRowByColData=\"Covariate_1\",\n FacetColumnBy = \"Column data\", FacetColumnByColData=\"Covariate_2\")\n.plot-utils(x)\n\nReducedDimensionPlot-class\n\nThe ReducedDimensionPlot panel\n\nDescription\nThe ReducedDimensionPlot is a panel class for creating a ColumnDotPlot where the coordinates of each column/sample are taken from the reducedDims of a SingleCellExperiment object. It provides slots and methods to specify which dimensionality reduction result to use and to create the data.frame with the coordinates of the specified results for plotting.\nReducedDimensionPlot slot overview\n\nThe following slots control the dimensionality reduction result that is used:\n\n- **Type**, a string specifying the name of the dimensionality reduction result. If NA, defaults to the first entry of `reducedDims`.\n- **XAxis**, integer scalar specifying the dimension to plot on the x-axis. Defaults to 1.\n- **YAxis**, integer scalar specifying the dimension to plot on the y-axis. Defaults to 2.\n\nIn addition, this class inherits all slots from its parent `ColumnDotPlot`, `DotPlot` and `Panel` classes.\n\n**Constructor**\n\n`ReducedDimensionPlot(...)` creates an instance of a `ReducedDimensionPlot` class, where any slot and its value can be passed to `...` as a named argument.\n\n**Supported methods**\n\nIn the following code snippets, `x` is an instance of a `ReducedDimensionPlot` class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- **`.cacheCommonInfo(x)`** adds a \"ReducedDimensionPlot\" entry containing `valid.reducedDim.names`, a character vector of names of valid dimensionality reduction results (i.e., at least one dimension). This will also call the equivalent `ColumnDotPlot` method.\n- **`.refineParameters(x, se)`** replaces NA values in `RedDimType` with the first valid dimensionality reduction result name in `se`. This will also call the equivalent `ColumnDotPlot` method for further refinements to `x`. If no dimensionality reduction results are available, `NULL` is returned instead.\n\nFor defining the interface:\n\n- **`.defineDataInterface(x, se, select_info)`** returns a list of interface elements for manipulating all slots described above.\n- **`.panelColor(x)`** will return the specified default color for this panel class.\n\nFor monitoring reactive expressions:\n\n- **`.createObservers(x, se, input, session, pObjects, rObjects)`** sets up observers for all slots described above and in the parent classes. This will also call the equivalent `ColumnDotPlot` method.\n\nFor defining the panel name:\n\n- **`.fullName(x)`** will return \"Reduced dimension plot\".\n\nFor creating the plot:\n\n- **`.generateDotPlotData(x, envir)`** will create a data.frame of reduced dimension coordinates in `envir`. It will return the commands required to do so as well as a list of labels.\n\nFor documentation:\n• `.definePanelTour(x)` returns a data.frame containing a panel-specific tour.\n\nSubclasses do not have to provide any methods, as this is a concrete class.\n\n**Author(s)**\n\nAaron Lun\n\n**See Also**\n\n`ColumnDotPlot`, for the immediate parent class.\n\n**Examples**\n\n```r\n# For end-users #\nReducedDimensionPlot()\n[['Type']] <- \"TSNE\"\n\n# For developers #\nlibrary(scater)\nsce <- mockSCE()\nsce <- logNormCounts(sce)\n```\n\n---\n\n**Description**\n\nSet and get global options for the iSEE application. These are options that do not correspond to any Panel slot and cannot be changed by the user after initialization.\nregisterAppOptions\n\nUsage\n\nregisterAppOptions(se, ...)\n\ngetAppOption(name, se, default = NULL)\n\ngetAllAppOptions(se)\n\nArguments\n\nse\nThe SummarizedExperiment object to be supplied to iSEE.\n\n...\nNamed options to register. Alternatively a single named list containing the options to register.\n\nname\nString containing the name of the option to retrieve.\n\ndefault\nValue to return if name is not present in the available options.\n\nDetails\n\nregisterAppOptions provides an alternative mechanism for setting global options, separate from panelDefaults. The primary difference is that registerAppOptions allows tuning of options that do not have a corresponding slot in any Panel subclass. This makes it useful for parameters that the user should not or cannot change within the application, as well as for fine-tuning parameters that are too rarely used to have their own interface elements.\n\nKnown options include:\n\n• panel.color Named character vector of colors. The names of the vector should be set to the name of class to be overridden; if a class is not named here, its default color is used. It is highly recommended to define colors as hex color codes (e.g., \"#1e90ff\"), for full compatibility with both HTML elements and R plots.\n\n• color.maxlevels Maximum number of levels for a categorical variable used for coloring. Variables with more levels are coerced to numeric to avoid problems with an overly-large legend. Defaults to 24.\n\n• factor.maxlevels Maximum number of levels for a categorical variable to be used anywhere in the app. Variables with more levels are coerced to numeric to avoid rendering delays. Defaults to 100.\n\n• RowTable.select.details A function that takes a string containing the name of a feature (i.e., the current selection in the RowTable) and returns a HTML element with more details.\n\n• ColumnTable.select.details A function that takes a string containing the name of a sample (i.e., the current selection in the ColumnTable) and returns a HTML element with more details.\n\n• tooltip.signif Number of significant digits to display in the tooltip. Defaults to 6.\n\nThe registered options are stored in the SummarizedExperiment to ensure that we can recover the application state with the combination of the SummarizedExperiment and list of Panel settings. By comparison, if we had used a global cache as in panelDefaults, we would need to save them separately to ensure that we can recover a particular application state.\n\nBy default, registerAppOptions will add or replace individual arguments specified by .... This means that users can call the function multiple times to accumulate registered options in se. The exception is if ... contains a single list, in which case the entire set of options is directly replaced by that list. For example, one could supply a single empty list to clear se of all existing options.\nregisterAppOptions\n\nValue\n\nregisterAppOptions will return se, modified with the application-level options.\n\ngetAppOption will return the value of the specified option, or default if that option is not available.\n\ngGetAllAppOptions will return a named list of all registered options.\n\nFor developers\n\nDevelopers of Panel subclasses can add arbitrary options to ... to help control the behavior of their Panel instances. We recommend prefixing any options with the name of the package in the form of <PACKAGE>_<OPTION>, so as to avoid conflicts with other options (in the base classes, or in other downstream packages) that have the same name.\n\nFor calls to getAppOption that occur after the iSEE app has started, it is not actually necessary to supply se. The options in se are transferred to a global option store when the app starts, allowing us to call getAppOption without se in various Panel methods. This is useful for some generics where se is not part of the function signature. Developers can mimic this state (e.g., for unit testing) by calling .activateAppOptionRegistry on the SummarizedExperiment produced by registerAppOptions. Conversely, calling .deactivateAppOptionRegistry will reset the global option store.\n\nAuthor(s)\n\nAaron Lun\n\nExamples\n\nse <- SummarizedExperiment()\nse <- registerAppOptions(se, factor.maxlevels=10, color.maxlevels=10)\n\ngetAppOption(\"factor.maxlevels\", se)\ngetAppOption(\"color.maxlevels\", se)\ngetAppOption(\"random_other.thing\", se, default=10)\n\ngGetAllAppOptions(se)\n\n# For developers: you don't actually need to pass 'se' to the getters\n# if they are being called inside Panel methods.\n.activateAppOptionRegistry(se)\ngetAppOption(\"factor.maxlevels\")\ngetAppOption(\"color.maxlevels\")\n.deactivateAppOptionRegistry()\n\n# Wiping out all options.\nse <- registerAppOptions(se, list())\ngetAllAppOptions(se)\nThe RowDataPlot class\n\nDescription\n\nThe RowDataPlot is a panel class for creating a RowDotPlot where the y-axis represents a variable from the `rowData` of a SummarizedExperiment object. It provides slots and methods for specifying which variable to use on the y-axis (and, optionally, also the x-axis), as well as a method to create the data.frame in preparation for plotting.\n\nSlot overview\n\nThe following slots control the variables to be shown:\n\n- `YAxis`, a string specifying the row of the `rowData` to show on the y-axis. If NA, defaults to the first valid field (see `?\".refineParameters,RowDotPlot-method\"`).\n- `XAxis`, string specifying what should be plotting on the x-axis. This can be any one of \"None\", \"Row data\" and \"Row selection\". Defaults to \"None\".\n- `XAxisRowData`, string specifying the row of the `rowData` to show on the x-axis. If NA, defaults to the first valid field.\n\nIn addition, this class inherits all slots from its parent RowDotPlot, DotPlot and Panel classes.\n\nConstructor\n\nRowDataPlot(...) creates an instance of a RowDataPlot class, where any slot and its value can be passed to ... as a named argument.\n\nSupported methods\n\nIn the following code snippets, x is an instance of a RowDataPlot class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- `refineParameters(x, se)` returns x after replacing any NA value in `YAxis` or `XAxisRowData` with the name of the first valid `rowData` variable. This will also call the equivalent RowDotPlot method for further refinements to x. If no valid row metadata variables are available, NULL is returned instead.\n\nFor defining the interface:\n\n- `defineDataInterface(x, se, select_info)` returns a list of interface elements for manipulating all slots described above.\n- `panelColor(x)` will return the specified default color for this panel class.\n- `allowableXAxisChoices(x, se)` returns a character vector specifying the acceptable variables in `rowData(se)` that can be used as choices for the x-axis. This consists of all variables with atomic values.\n• `.allowableYAxisChoices(x, se)` returns a character vector specifying the acceptable variables in `rowData(se)` that can be used as choices for the y-axis. This consists of all variables with atomic values.\n\nFor monitoring reactive expressions:\n\n• `.createObservers(x, se, input, session, pObjects, rObjects)` sets up observers for all slots described above and in the parent classes. This will also call the equivalent RowDotPlot method.\n\nFor controlling selections:\n\n• `.multiSelectionInvalidated(x)` returns TRUE if the x-axis uses multiple row selections, such that the point coordinates may change upon updates to upstream selections in transmitting panels. Otherwise, it dispatches to the RowDotPlot method.\n\nFor defining the panel name:\n\n• `.fullName(x)` will return \"Row data plot\".\n\nFor creating the plot:\n\n• `.generateDotPlotData(x, envir)` will create a data.frame of row metadata variables in `envir`. It will return the commands required to do so as well as a list of labels.\n\nFor documentation:\n\n• `.definePanelTour(x)` returns an data.frame containing a panel-specific tour.\n\nSubclass expectations\n\nSubclasses do not have to provide any methods, as this is a concrete class.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\nRowDotPlot, for the immediate parent class.\n\nExamples\n\n```\n# For end-users\nx <- RowDataPlot()\nx[[\"XAxis\"]]\nx[[\"XAxis\"]]<- \"Row data\"\n```\n\n```\n# For developers\n```\nlibrary(scater)\nsce <- mockSCE()\nsce <- logNormCounts(sce)\n\n# Spits out a NULL and a warning if is nothing to plot.\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n\n# Replaces the default with something sensible.\nrowData(sce)$Stuff <- runif(nrow(sce))\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n\n---\n\n**RowDataTable-class** \n*The RowDataTable panel*\n\n**Description**\n\nThe RowDataTable is a panel class for creating a `ColumnTable` where the value of the table is defined as the `rowData` of the `SummarizedExperiment`. It provides functionality to extract the `rowData` to coerce it into an appropriate data.frame in preparation for rendering.\n\n**Slot overview**\n\nThis class inherits all slots from its parent `ColumnTable` and `Table` classes.\n\n**Constructor**\n\n`RowDataTable(...)` creates an instance of a RowDataTable class, where any slot and its value can be passed to `...` as a named argument.\n\nNote that `ColSearch` should be a character vector of length equal to the total number of columns in the `rowData`, though only the entries for the atomic fields will actually be used.\n\n**Supported methods**\n\nIn the following code snippets, `x` is an instance of a `RowDataTable` class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- `cacheCommonInfo(x)` adds a \"RowDataTable\" entry containing `valid.rowData.names`, a character vector of names of atomic columns of the `rowData`. This will also call the equivalent `ColumnTable` method.\n- `refineParameters(x, se)` adjusts `ColSearch` to a character vector of length equal to the number of atomic fields in the `rowData`. This will also call the equivalent `ColumnTable` method for further refinements to `x`. \nFor defining the interface:\n - `.fullName(x)` will return \"Row data table\".\n - `.panelColor(x)` will return the specified default color for this panel class.\n\nFor creating the output:\n - `.generateTable(x, envir)` will modify `envir` to contain the relevant data.frame for display, while returning a character vector of commands required to produce that data.frame. Each row of the data.frame should correspond to a row of the SummarizedExperiment.\n\nFor documentation:\n - `.definePanelTour(x)` returns a data.frame containing the steps of a panel-specific tour.\n\nUnless explicitly specialized above, all methods from the parent class `Panel` are also available.\n\n**Author(s)**\n\nAaron Lun\n\n**Examples**\n\n```\n# For end-users\n\nx <- RowDataTable()\nx[[\"Selected\"]]\nx[[\"Selected\"]]<- \"SOME_ROW_NAME\"\n\n# For developers\n\nlibrary(scater)\nsce <- mockSCE()\n\n# Sets the search columns appropriately.\nsce <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce)\n```\nSlot overview\n\nThe following slots control coloring of the points:\n\n- **ColorByRowData**, a string specifying the `rowData` field for controlling point color, if `ColorBy`=\"Row data\" (see the `Panel` class). Defaults to the first valid field (see `.cacheCommonInfo` below).\n- **ColorBySampleNameAssay**, a string specifying the assay of the `SummarizedExperiment` object containing values to use for coloring, if `ColorBy=\"Sample name\"`. Defaults to \"logcounts\" in `getPanelDefault`, falling back to the name of the first valid assay (see ?`.cacheCommonInfo,DotPlot-method` for the definition of validity).\n- **ColorByFeatureNameColor**, a string specifying the color to use for coloring an individual sample on the plot, if `ColorBy=\"Feature name\"`. Defaults to \"red\" in `getPanelDefault`.\n\nThe following slots control other metadata-related aesthetic aspects of the points:\n\n- **ShapeByRowData**, a string specifying the `rowData` field for controlling point shape, if `ShapeBy=\"Row data\"` (see the `Panel` class). The specified field should contain categorical values; defaults to the first such field.\n- **SizeByRowData**, a string specifying the `rowData` field for controlling point size, if `SizeBy=\"Row data\"` (see the `Panel` class). The specified field should contain continuous values; defaults to the first such field.\n- **TooltipRowData**, a character vector specifying `rowData` fields to show in the tooltip. Defaults to 'character(0)', which displays only the 'rownames' value of the data point.\n\nIn addition, this class inherits all slots from its parent `DotPlot` and `Panel` classes.\n\nSupported methods\n\nIn the following code snippets, `x` is an instance of a `RowDotPlot` class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- `.cacheCommonInfo(x)` adds a “RowDotPlot” entry containing `valid.rowData.names`, a character vector of valid column data names (i.e., containing atomic values); `discrete.rowData.names`, a character vector of names for discrete columns; and `continuous.rowData.names`, a character vector of names of continuous columns. This will also call the equivalent `DotPlot` method.\n- `.refineParameters(x, se)` replaces NA values in `ColorByFeatAssay` with the first valid assay name in `se`. This will also call the equivalent `DotPlot` method.\n\nFor defining the interface:\n\n- `.hideInterface(x, field)` returns a logical scalar indicating whether the interface element corresponding to `field` should be hidden. This returns TRUE for row selection parameters (\"RowSelectionSource\" and \"RowSelectionRestrict\"), otherwise it dispatches to the `Panel` method.\n\nFor monitoring reactive expressions:\n\n- `.createObservers(x, se, input, session, pObjects, rObjects)` sets up observers for all slots in the `RowDotPlot`. This will also call the equivalent `DotPlot` method.\nFor controlling selections:\n\n- `.multiSelectionRestricted(x)` returns a logical scalar indicating whether x is restricting the plotted points to those that were selected in a transmitting panel.\n- `.multiSelectionDimension(x)` returns \"row\" to indicate that a multiple row selection is being transmitted.\n- `.multiSelectionInvalidated(x)` returns TRUE if the faceting options use the multiple row selections, such that the point coordinates/domain may change upon updates to upstream selections in transmitting panels.\n- `.singleSelectionDimension(x)` returns \"feature\" to indicate that a feature identity is being transmitted.\n\nFor documentation:\n\n- `.definePanelTour(x)` returns a data.frame containing the steps of a tour relevant to subclasses, mostly tuning the more generic descriptions from the same method of the parent DotPlot.\n- `.getDotPlotColorHelp(x, color_choices)` returns a data.frame containing the documentation for the \"ColorBy\" UI element, specialized for row-based dot plots.\n\nUnless explicitly specialized above, all methods from the parent classes DotPlot and Panel are also available.\n\n**Subclass expectations**\n\nSubclasses are expected to implement methods for, at least:\n\n- `.generateDotPlotData`\n- `.fullName`\n- `.panelColor`\n\nThe method for `.generateDotPlotData` should create a plot.data data.frame with one row per row in the SummarizedExperiment object.\n\n**Author(s)**\n\nAaron Lun\n\n**See Also**\n\nDotPlot, for the immediate parent class that contains the actual slot definitions.\nDescription\n\nThe RowTable is a virtual class where each row in the SummarizedExperiment is represented by no more than one row in a datatable widget. In panels of this class, single and multiple selections can only be transmitted on the features.\n\nSlot overview\n\nNo new slots are added. All slots provided in the Table parent class are available.\n\nSupported methods\n\nIn the following code snippets, x is an instance of a RowTable class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- `.refineParameters(x, se)` replaces NA values in Selected with the first row name of se. This will also call the equivalent Table method.\n\nFor defining the interface:\n\n- `.hideInterface(x, field)` returns a logical scalar indicating whether the interface element corresponding to field should be hidden. This returns TRUE for column selection parameters (\"ColumnSelectionSource\" and \"ColumnSelectionRestrict\"), otherwise it dispatches to the Panel method.\n\nFor monitoring reactive expressions:\n\n- `.createObservers(x, se, input, session, pObjects, rObjects)` sets up observers to propagate changes in the Selected to linked plots. This will also call the equivalent Table method.\n\nFor controlling selections:\n\n- `.multiSelectionDimension(x)` returns \"row\" to indicate that a row selection is being transmitted.\n\n- `.singleSelectionDimension(x)` returns \"feature\" to indicate that a feature identity is being transmitted.\n\nFor rendering output:\n\n- `.showSelectionDetails(x)` returns a HTML element containing details about the selected row. This requires a function to be registered by registerAppOptions under the option name \"RowTable.select.details\". The function should take a string containing the name of a feature (i.e., the current selection in the RowTable) and returns a HTML element. If no function is registered, NULL is returned.\n\nUnless explicitly specialized above, all methods from the parent classes DotPlot and Panel are also available.\nSampleAssayPlot-class\n\nSubclass expectations\n\nSubclasses are expected to implement methods for:\n\n- .generateTable\n- .fullName\n- .panelColor\n\nThe method for .generateTable should create a tab data.frame where each row corresponds to a row in the SummarizedExperiment object.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\nTable, for the immediate parent class that contains the actual slot definitions.\n\nSampleAssayPlot-class The SampleAssayPlot panel\n\nDescription\n\nThe SampleAssayPlot is a panel class for creating a RowDotPlot where the y-axis represents the expression of a sample of interest, using the assay values of the SummarizedExperiment. It provides slots and methods for specifying the sample and what to plot on the x-axis, as well as a method to actually create a data.frame containing those pieces of data in preparation for plotting.\n\nSlot overview\n\nThe following slots control the values on the y-axis:\n\n- YAxisSampleName, a string specifying the name of the sample to plot on the y-axis. If NA, defaults to the first column name of the SummarizedExperiment object.\n- Assay, string specifying the name of the assay to use for obtaining expression values. Defaults to \"logcounts\" in getPanelDefault, falling back to the name of the first valid assay (see ?.cacheCommonInfo, DotPlot-method\" for the definition of validity).\n- YAxisSampleSource, string specifying the encoded name of the transmitting panel to obtain a single selection that replaces YAxisSampleName. Defaults to \"---\", i.e., no transmission is performed.\n- YAxisSampleDynamicSource, a logical scalar indicating whether x should dynamically change its selection source for the y-axis. Defaults to FALSE in getPanelDefault.\n\nThe following slots control the values on the x-axis:\n\n- XAxis, string specifying what should be plotted on the x-axis. This can be any one of \"None\", \"Sample name\", \"Row data\" or \"Row selection\". Defaults to \"None\".\nSampleAssayPlot-class\n\n- **XAxisColumnData**, string specifying which column of the colData should be shown on the x-axis, if XAxis=\"Column data\". Defaults to the first valid colData field (see ?\".refineParameters,ColumnDotPlot-method for details).\n\n- **XAxisSampleName**, string specifying the name of the sample to plot on the x-axis, if XAxis=\"Sample name\". Defaults to the first column name.\n\n- **XAxisSampleSource**, string specifying the encoded name of the transmitting panel to obtain a single selection that replaces XAxisSampleName. Defaults to \"---\", i.e., no transmission is performed.\n\n- **XAxisSampleDynamicSource**, a logical scalar indicating whether x should dynamically change its selection source for the x-axis. Defaults to FALSE in getPanelDefault.\n\nIn addition, this class inherits all slots from its parent ColumnDotPlot, DotPlot and Panel classes.\n\n**Constructor**\n\nSampleAssayPlot(...) creates an instance of a SampleAssayPlot class, where any slot and its value can be passed to ... as a named argument.\n\n**Supported methods**\n\nIn the following code snippets, x is an instance of a SampleAssayPlot class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor setting up data values:\n\n- **.refineParameters(x, se)** replaces any NA values in XAxisSampleName and YAxisSampleName with the first column name; any NA value in Assay with the first valid assay name; and any NA value in XAxisColumnData with the first valid column metadata field. This will also call the equivalent ColumnDotPlot method for further refinements to x. If no columns or assays are present, NULL is returned instead.\n\nFor defining the interface:\n\n- **.defineDataInterface(x, se, select_info)** returns a list of interface elements for manipulating all slots described above.\n\n- **.panelColor(x)** will return the specified default color for this panel class.\n\nFor monitoring reactive expressions:\n\n- **.createObservers(x, se, input, session, pObjects, rObjects)** sets up observers for all slots described above and in the parent classes. This will also call the equivalent ColumnDotPlot method.\n\nFor defining the panel name:\n\n- **.fullName(x)** will return \"Sample assay plot\".\n\nFor creating the plot:\n\n- **.generateDotPlotData(x, envir)** will create a data.frame of sample assay values in envir. It will return the commands required to do so as well as a list of labels.\nFor managing selections:\n\n- `.singleSelectionSlots(x)` will return a list specifying the slots that can be updated by single selections in transmitter panels, mostly related to the choice of sample on the x- and y-axes. This includes the output of the method for the parent `RowDotPlot` class.\n\n- `.multiSelectionInvalidated(x)` returns `TRUE` if the x-axis uses multiple row selections, such that the point coordinates may change upon updates to upstream selections in transmitting panels. Otherwise, it dispatches to the `RowDotPlot` method.\n\nFor documentation:\n\n- `.definePanelTour(x)` returns an `data.frame` containing a panel-specific tour.\n\n**Author(s)**\n\nAaron Lun\n\n**See Also**\n\n`ColumnDotPlot`, for the immediate parent class.\n\n**Examples**\n\n```\n# For end-users #\n\nx <- SampleAssayPlot()\nx[[\"XAxis\"]]\nx[[\"Assay\"]]\n<- \"logcounts\"\nx[[\"XAxisRowData\"]]\n<- \"stuff\"\n\n# For developers #\n\nlibrary(scater)\nsce <- mockSCE()\nsce <- logNormCounts(sce)\n\nold_assay_names <- assayNames(sce)\nassayNames(sce) <- character(length(old_assay_names))\n\n# Spits out a NULL and a warning if no assays are named.\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n\n# Replaces the default with something sensible.\nassayNames(sce) <- old_assay_names\nsce0 <- .cacheCommonInfo(x, sce)\n.refineParameters(x, sce0)\n```\nDescription\n\nThese generics are related to the initial setup of the iSEE application.\n\nCaching common information\n\n`.cacheCommonInfo(x, se)` computes common values that can be re-used for all panels with the same class as `x`. The following arguments are required:\n\n- `x`, an instance of a Panel class.\n- `se`, the SummarizedExperiment object containing the current dataset.\n\nIt is expected to return `se` with (optionally) extra fields added to `int_metadata(se)$iSEE`. Each field should be named according to the class name and contain some common information that is constant for all instances of the class of `x` - see `.setCachedCommonInfo` for an appropriate setter utility. The goal is to avoid repeated recomputation of required values when creating user interface elements or observers that respond to those elements.\n\nMethods for this generic should start by checking whether the metadata already contains the class name, and returning `se` without modification if this is the case. Otherwise, it should call `nextMethod` to fill in the cache values from the parent classes, before adding cached values under the class name for `x`. This means that any modification to `se` will only be performed once per class, so any cached values should be constant for all instances of the same class.\n\nValues from the cache can also be deparsed and used to assemble rendering commands in `generateOutput`. However, those same commands should not make any use of the cache itself, i.e., they should not call `.getCachedCommonInfo`. This is because the code tracker does not capture the code used to construct the cache, so the commands that are shown to the user will make use of a cache that is not present in the original `se` object.\n\nRefining parameters\n\n`.refineParameters(x, se)` enforces appropriate settings for each parameter in `x`. The following arguments are required:\n\n- `x`, an instance of a Panel class.\n- `se`, the SummarizedExperiment object containing the current dataset.\n\nMethods for this generic should return a copy of `x` where slots with invalid values are replaced with appropriate entries from `se`. This is necessary because the constructor and validity methods for `x` do not know about `se`; thus, certain slots (e.g., for the row/column names) cannot be set to a reasonable default or checked by the validity method. By comparison, `.refineParameters` can catch and correct invalid values as it has access to `se`.\n\nWe recommend specializing `initialize` to fill any yet-to-be-determined slots with `NA` defaults. `.refineParameters` can then be used to sweep across these slots and replace them with appropriate entries, typically by using `.getCachedCommonInfo` to extract the cached set of potential valid\nvalues. Of course, any slots that are not se-dependent should just be set at construction and checked by the validity method.\n\nIt is also possible for this generic to return NULL, which is used as an indicator that se does not contain information to meaningfully show any instance of the class of x in the iSEE app. For example, the method for ReducedDimensionPlot will return NULL if se is not a SingleCellExperiment containing some dimensionality reduction results.\n\n**Author(s)**\n\nAaron Lun\n\n**single-select-generics**\n\n*Generics for controlling single selections*\n\n**Description**\n\nA panel can create a single selection on either the rows or columns and transmit this selection to another panel for use as an aesthetic parameter. For example, users can click on a RowTable to select a gene of interest, and then the panel can transmit the identities of that row to another panel for coloring by that selected gene’s expression. This suite of generics controls the behavior of these single selections.\n\n**Specifying the nature of the selection**\n\nGiven an instance of the Panel class x, .singleSelectionDimension(x) should return a string specifying whether the panel’s single selection would contain a “feature”, \"sample\", or if the Panel in x does not perform single selections at all (\"none\"). The output should be constant for all instances of x.\n\n**Obtaining the selected element**\n\n.singleSelectionValue(x, contents) should return a string specifying the selected row or column in x that is to be transmitted to other panels. If no row or column is selected, it should return NULL.\n\ncontents is any arbitrary structure returned by .generateOutput for x in the field of the same name. This should contain all of the information necessary to determine the name of the selected row/column. For example, a data.frame of coordinates is stored by DotPlots to identify the point selected by a brush/lasso.\n\n**Indicating the receiving slots**\n\n.singleSelectionSlots(x) controls how x should respond to a single selection. It should return a list of lists, where each internal list describes a set of slots in x that might respond to a single selection from a transmitting panel. This internal list should contain at least entries with the following names:\n• param, the name of the slot of `x` that can potentially respond to a single selection in a transmitting panel, e.g., `ColorByFeatureName` in `DotPlots`.\n\n• source, the name of the slot of `x` that indicates which transmitting panel to respond to, e.g., `ColorByFeatureSource` in `DotPlots`.\n\nFor each set of responsive slots, the expected paradigm is that the user interface will contain two `selectInput` elements, one for each of the param and source slots. Users are free to manually alter the choice of feature/sample in the param's `selectInput`. Users are also allowed to change the identity of the transmitting panel via the source's `selectInput`, which will automatically update the chosen entry in the param's `selectInput` when the transmitter's single selection changes.\n\nDevelopers are strongly recommended to follow the above paradigm. In fact, the observers to perform these updates are automatically set up by `.createObservers,Panel-method` if the internal list also contains the following named entries:\n\n• dimension, a string set to either \"feature\" or \"sample\". This specifies whether the slot specified by param contains the identity of a single feature or a single sample. If this is not present, no observers will be set up.\n\n• dynamic, the name of the slot indicating whether the choice of transmitting panel should change dynamically. One example would be \"ColorByFeatureDynamicSource\" for `DotPlots`. If supplied, a `checkboxInput` should also be present in the UI to turn on/off dynamic choices for this parameter. This field can be missing if the current panel does not support dynamic selection sources.\n\n• use_mode, the name of the slot of `x` containing the current usage mode. This is used in cases where there are multiple choices of which only one involves using information held in source. An example would be `ColorBy` in `DotPlots` where coloring by feature name is only one of many options, such that the panel should only respond to transmitted single selections when the user intends to color by feature name. If the value of this field is `NA`, the usage mode for `x` is assumed to be such that the panel should always respond to transmitted single selections.\n\n• use_value, a string containing the relevant value of the slot specified by `use_mode` in order for the panel to respond to transmitted single selections. An example would be \"Feature name\" in `DotPlots`. This field can be missing if `use_mode` is `NA`.\n\n• protected, a logical scalar indicating whether the slot specified by param is \"protected\", i.e., changing this value will cause all existing selections to be invalidated and will trigger re-rendering of the children receiving multiple selections. This is `FALSE` for purely aesthetic parameters (e.g., coloring) and `TRUE` for data-related parameters (e.g., `XAxisFeatureName` in `FeatureAssayPlot`).\n\nAuthor(s)\n\nAaron Lun\nDescription\nUtilities to manage the tours specific to individual UI elements for each Panel. This is done via a global tour cache that is updated by each Panel's interface-generating methods, so that developers can easily put the UI documentation next to the element definition.\n\nUsage\n.addSpecificTour(cls, field, fun, force = FALSE)\n.getSpecificTours(cls)\n.clearSpecificTours()\n\nArguments\ncls String containing the name of the Panel class containing the relevant UI element.\nfield String containing the slot of the cls class that is controlled by the UI element.\nfun Function that accepts a string containing the encoded Panel name, and returns a data.frame compatible with introjs, i.e., with a element and intro column.\nforce Logical scalar indicating whether fun should forcibly overwrite an existing function in the tour cache for cls and field.\n\nDetails\nBy default, .addSpecificTour will have no effect if a function is already registered for a particular combination of cls and field. However, users can force a replacement with force=TRUE.\n.clearSpecificTours is intended for use by the iSEE app itself and should not be used by Panel methods.\n\nValue\n.addSpecificTour registers the provided function in the tour cache for the provided cls and field. A NULL is invisibly returned.\n.getSpecificTours returns a list of registered tour-generating functions for the specified cls.\n.clearSpecificTours removes all functions in the tour cache.\n\nAuthor(s)\nAaron Lun\n\nSee Also\n.selectInput.iSEE and friends, which provide modified UI elements that can be clicked to launch a helpful tour.\nsubsetPointsByGrid Subset points for faster plotting\n\nDescription\n\nSubset points using a grid-based system, to avoid unnecessary rendering when plotting.\n\nUsage\n\nsubsetPointsByGrid(X, Y, resolution = 200, grouping = NULL)\n\nArguments\n\nX A numeric vector of x-coordinates for all points.\nY A numeric vector of y-coordinates for all points, of the same length as X.\nresolution A positive integer specifying the number of bins on each axis of the grid. Alternatively, if grouping is specified, this may be a named integer vector containing the number of bins to be used for each level.\ngrouping A character vector of length equal to X specifying the group to which each point is assigned. By default, all points belong to the same group.\n\nDetails\n\nThis function will define a grid of the specified resolution across the plot. Each point is allocated to a grid location (i.e., pair of bins on the x- and y-axes). If multiple points are allocated to a given location, only the last/right-most point is retained. This mimics the fact that plotting will overwrite earlier points with later points. In this manner, we can avoid unnecessary rendering of earlier points that would not show up anyway.\n\nIf grouping is specified, redundant points are only identified within each unique level. The resolution of downsampling within each level can be varied by passing an integer vector to resolution. This can be useful for tuning the downsampling when points differ in importance, e.g., in a MA plot, points corresponding to non-DE genes can be aggressively downsampled while points corresponding to DE genes should generally be retained.\n\nFor plots where X and Y are originally categorical, use the jittered versions as input to this function.\n\nValue\n\nA logical vector indicating which points should be retained.\n\nAuthor(s)\n\nAaron Lun\nExamples\n\n```r\nX <- rnorm(100000)\nY <- X + rnorm(100000)\nsummary(subsetPointsByGrid(X, Y, resolution=100))\nsummary(subsetPointsByGrid(X, Y, resolution=200))\nsummary(subsetPointsByGrid(X, Y, resolution=1000))\n```\n\nsynchronizeAssays Synchronize assay colormaps to match those in a SummarizedExperiment\n\nDescription\n\nThis function returns an updated ExperimentColorMap in which colormaps in the assays slot are ordered to match the position of their corresponding assay in the SingleCellExperiment object. Assays in the SingleCellExperiment that do not have a colormap defined in the ExperimentColorMap are assigned the appropriate default colormap.\n\nUsage\n\n```r\nsynchronizeAssays(ecm, se)\n```\n\nArguments\n\n- `ecm` - An ExperimentColorMap.\n- `se` - A SingleCellExperiment.\n\nDetails\n\nIt is highly recommended to name all assays in both ExperimentColorMap and SummarizedExperiment prior to calling this function, as this will facilitate the identification of matching assays between the two objects. In most cases, unnamed colormaps will be dropped from the new ExperimentColorMap object.\n\nThe function supports three main situations:\n\n- If all assays in the SingleCellExperiment are named, this function will populate the assays slot of the new ExperimentColorMap with the name-matched colormap from the input ExperimentColorMap, if available. Assays in the SingleCellExperiment that do not have a colormap defined in the ExperimentColorMap are assigned the appropriate default colormap.\n\n- If all assays in the SingleCellExperiment are unnamed, this function requires that the ExperimentColorMap supplies a number of assay colormaps identical to the number of assays in the SingleCellExperiment object. In that case, the ExperimentColorMap object will be returned as is.\n- If only a subset of assays in the SingleCellExperiment are named, this function will ignore unnamed colormaps in the ExperimentColorMap; It will populate the assays slot of the new ExperimentColorMap with the name-matched colormap from the input ExperimentColorMap, if available. Assays in the SingleCellExperiment that are unnamed, or that do not have a colormap defined in the ExperimentColorMap are assigned the appropriate default colormap.\n\n**Value**\n\nAn `ExperimentColorMap` with colormaps in the assay slot synchronized to match the position of the corresponding assay in the SingleCellExperiment.\n\n**Author(s)**\n\nKevin Rue-Albrecht\n\n**Examples**\n\n```r\n# Example ExperimentColorMap ----\ncount_colors <- function(n){\n c(\"black\",\"brown\",\"red\",\"orange\",\"yellow\")\n}\nfpkm_colors <- viridis::inferno\necm <- ExperimentColorMap(\n assays = list(\n counts = count_colors,\n tophat_counts = count_colors,\n cufflinks_fpkm = fpkm_colors,\n rsem_counts = count_colors,\n orphan = count_colors,\n orphan2 = count_colors,\n count_colors,\n fpkm_colors\n )\n)\n# Example SingleCellExperiment ----\nlibrary(scRNAseq)\nsce <- ReprocessedAllenData(assays=\"tophat_counts\")\nlibrary(scater)\nsce <- logNormCounts(sce, exprs_values=\"tophat_counts\")\nsce <- runPCA(sce)\nsce <- runTSNE(sce)\n# Example ----\necm_sync <- synchronizeAssays(ecm, sce)\n```\nTable-class\n\nThe Table class\n\nDescription\n\nThe Table is a virtual class for all panels containing a \\texttt{datatable} widget from the \\texttt{DT} package, where each row \\textit{usually} corresponds to a row or column of the \\texttt{SummarizedExperiment} object. It provides observers for rendering the table widget, monitoring single selections, and applying global and column-specific searches (which serve as multiple selections).\n\nSlot overview\n\nThe following slots control aspects of the \\texttt{DT::datatable} selection:\n\n- \\texttt{Selected}, a string containing the name of the currently selected row of the data.frame. Defaults to \\texttt{NA}, in which case the value should be chosen by the subclass’ \\texttt{.refineParameters} method.\n- \\texttt{Search}, a string containing the regular expression for the global search. Defaults to \\texttt{\"\"}, i.e., no search.\n- \\texttt{SearchColumns}, a unnamed character vector of length equal to the number of columns of the data.frame, where each entry contains the search string for its corresponding column. Alternatively, a character vector of variable length, containing search strings for one or more columns. Defaults to an character vector of length zero, which is internally expanded to an vector of zero-length strings, i.e., no search.\n\nThe following slots control the appearance of the table:\n\n- \\texttt{HiddenColumns}, a character vector containing names of columns to hide. Defaults to an empty vector.\n\nIn addition, this class inherits all slots from its parent \\texttt{Panel} class.\n\nSupported methods\n\nIn the following code snippets, \\texttt{x} is an instance of a \\texttt{Table} class. Refer to the documentation for each method for more details on the remaining arguments.\n\nFor defining the interface:\n\n- \\texttt{.defineOutput(x)} returns a UI element for a \\texttt{dataTableOutput} widget.\n- \\texttt{.defineDataInterface(x)} will create interface elements for modifying the table, namely to choose which columns to hide. Note that this is populated by \\texttt{.generateOutput} upon table rendering, as we do not know the available columns before that point.\n\nFor defining reactive expressions:\n\n- \\texttt{.createObservers(x, se, input, session, pObjects, rObjects)} sets up observers for all of the slots. This will also call the equivalent \\texttt{Panel} method.\n.renderOutput(x, se, output, pObjects, rObjects) will add a rendered datatable object to output. This will also call the equivalent Panel method to render the panel information text boxes.\n\n.generateOutput(x, se, all_memory, all_contents) returns a list containing contents, a data.frame with one row per point currently present in the table; commands, a list of character vector containing the R commands required to generate contents and plot; and varname, a string specifying the name of the variable in commands used to generate contents.\n\n.exportOutput(x, se, all_memory, all_contents) will create a CSV file containing the current table, and return a string containing the path to that file. This assumes that the contents field returned by .generateOutput is a data.frame or can be coerced into one.\n\nFor controlling selections:\n\n.multiSelectionRestricted(x) returns TRUE. Transmission of a selection to a Table will manifest as a subsetting of the rows.\n\n.multiSelectionActive(x) returns a list containing the contents of x[\"Search\"] and x[\"ColumnSearch\"]. If both contain only empty strings, a NULL is returned instead.\n\n.multiSelectionCommands(x, index) returns a character vector of R expressions that - when evaluated - return a character vector of the row names of the table after applying all search filters. The value of index is ignored.\n\n.singleSelectionValue(x, contents) returns the name of the row that was last selected in the datatable widget.\n\nFor documentation:\n\n.definePanelTour(x) returns an data.frame containing the steps of a tour relevant to sub-classes, mostly describing the effect of selection from other panels and the use of row filters to transmit selections.\n\nUnless explicitly specialized above, all methods from the parent class Panel are also available.\n\nSubclass expectations\n\nThe Table is a rather vaguely defined class for which the only purpose is to avoid duplicating code for ColumnDotPlots and RowDotPlots. We recommend extending those subclasses instead.\n\nAuthor(s)\n\nAaron Lun\n\nSee Also\n\nPanel, for the immediate parent class.\nGenerics for table construction\n\nDescription\n\nGeneric to control the creation of a data.frame to show in the datatable widget of a Table panel. Table subclasses can specialize methods to modify the behavior of generateOutput.\n\nConstructing the table\n\n.generateTable(x, envir) generates the data.frame to use in the datatable widget. The following arguments are required:\n\n• x, an instance of a Table subclass.\n• envir, the evaluation environment in which the data.frame is to be constructed. This can be assumed to have se, the SummarizedExperiment object containing the current dataset; possibly col_selected, if a multiple column selection is being transmitted to x; and possibly row_selected, if a multiple row selection is being transmitted to x.\n\nIn return, the method should add a tab variable in envir containing the relevant data.frame. This will automatically be passed to the datatable widget as well as being stored in pObjects$contents. The return value should be a character vector of commands that produces tab when evaluated in envir.\n\nEach row of the tab data.frame should correspond to one row or column in the SummarizedExperiment envir$se for RowTables and ColumnTables respectively. Unlike .generateDotPlotData, it is not necessary for all rows or columns to be represented in this data.frame.\n\nIdeally, the number and names of the columns of the data.frame should be fixed for all calls to .generateTable. Violating this principle may result in unpredictable interactions with existing values in the SearchColumns slot. Nonetheless, the app will be robust to mismatches, see filterDT for more details.\n\nAny internal variables that are generated by the commands should be prefixed with . to avoid potential clashes with reserved variable names in the rest of the application.\n\nThis generic is called by .generateOutput for Table subclasses. Thus, developers of such subclasses only need to specialize .generateTable to change the table contents, without needing to reimplement the entirety of .generateOutput.\n\nAdding details on the selection\n\n.showSelectionDetails(x) should return a HTML element containing details on the currently selected row, given an instance of a Table subclass x. The identity of the selected row should be extracted from x[\"Selected\"]. The element will only be rerendered upon a single selection in the Table. Alternatively, it may return NULL in which case no selection details are shown in the interface.\n\nAuthor(s)\n\nAaron Lun\nDescription\nUtility functions to track internal events for a panel by monitoring the status of reactive variables in `rObjects`.\n\nUsage\n.trackUpdate(panel_name, rObjects)\n.trackSingleSelection(panel_name, rObjects)\n.trackMultiSelection(panel_name, rObjects)\n.trackRelinkedSelection(panel_name, rObjects)\n\nArguments\npanel_name String containing the panel name.\nrObjects A reactive list of values generated in the iSEE app.\n\nDetails\n.trackUpdate will track whether an update has been requested to the current panel via `.requestUpdate`.\n.trackSingleSelection will track whether the single selection in the current panel has changed. Note that this will not cause a reaction if the change involves cancelling a single selection.\n.trackMultiSelection will track whether the multiple selections in the current panel have changed. This will respond for both active and saved selections.\n.trackRelinkedSelection will track whether the single or multiple selection sources have changed.\nThese functions should be called within observer or rendering expressions to trigger their evaluation upon panel updates. It is only safe to call these functions within expressions for the same panel, e.g., to synchronize multiple output elements. Calling them with another panel_name would be unusual, not least because communication between panels is managed by the iSEE framework and is outside of the scope of the per-panel observers.\n\nValue\nAll functions will cause the current reactive context to respond to the designated event. NULL is returned invisibly.\n\nAuthor(s)\nAaron Lun\nvalidate-utils\n\nValidation error utilities\n\nDescription\n\nHelper functions to implement `setValidity` methods for Panel subclasses.\n\nUsage\n\n- `.singleStringError(msg, x, fields)`\n- `.validLogicalError(msg, x, fields)`\n- `.validStringError(msg, x, fields)`\n- `.allowableChoiceError(msg, x, field, allowable)`\n- `.multipleChoiceError(msg, x, field, allowable)`\n- `.validNumberError(msg, x, field, lower, upper)`\n\nArguments\n\n- `msg` Character vector containing the current error messages.\n- `x` An instance of a Panel subclass.\n- `fields` Character vector containing the names of the relevant slots.\n- `field` String containing the name of the relevant slot under investigation.\n- `allowable` Character vector of allowable choices for a multiple-choice selection.\n- `lower` Numeric scalar specifying the lower bound of possible values.\n- `upper` Numeric scalar specifying the upper bound of possible values.\n\nDetails\n\n- `.singleStringError` adds an error message if any of the slots named in `fields` does not contain a single string.\n- `.validStringError` adds an error message if any of the slots named in `fields` does not contain a single non-NA string.\n- `.validLogicalError` adds an error message if any of the slots named in `fields` does not contain a non-NA logical scalar.\n- `.allowableChoiceError` adds an error message if the slot named `field` does not have a value in `allowable`, assuming it contains a single string.\n- `.multipleChoiceError` adds an error message if the slot named `field` does not have all of its values in `allowable`, assuming it contains a character vector of any length.\n- `.validNumberError` adds an error message if the slot named `field` is not a non-NA number within `[lower, upper]`. \nValue\n\nAll functions return a character vector containing `msg`, possibly appended with additional error messages.\n\nAuthor(s)\n\nAaron Lun\n\nGenerics for visual DotPlot parameters\n\nDescription\n\nThese generics allow subclasses to override the user interface elements controlling visual parameters of DotPlot panels.\n\nInterface definition\n\nIn all of the code snippets below, `x` is a `Panel` instance and `se` is the `SummarizedExperiment` object.\n\n- `.defineVisualColorInterface(x, se, select_info)` should return a HTML tag definition that contains UI input elements controlling the color aesthetic of `ggplot` objects. Here, `select_info` is a list of two character vectors named `row` and `column`, which specifies the names of panels available for transmitting single selections on the rows/columns respectively. A common use case would involve adding elements to change the default color of the points or to color by a chosen metadata field/assay values.\n\n- `.defineVisualShapeInterface(x, se)` should return a HTML tag definition that contains UI input elements controlling the shape aesthetic of `ggplot` objects. A common use case would involve adding elements to change the shape of each point according to a chosen metadata field.\n\n- `.defineVisualSizeInterface(x, se)` should return a HTML tag definition that contains UI input elements controlling the size aesthetic of `ggplot` objects. A common use case would involve adding elements to change the size of each point according to a chosen metadata field or assay values.\n\n- `.defineVisualPointInterface(x, se)` should return a HTML tag definition that contains UI input elements controlling other aesthetics of `ggplot` objects. This might include controlling the transparency or downsampling.\n\n- `.defineVisualFacetInterface(x, se)` should return a HTML tag definition that contains UI input elements controlling the `facet_grid` applied to `ggplot` objects. This typically involves providing UI elements to choose the metadata variables to use for faceting.\n\n- `.defineVisualTextInterface(x, se)` should return a HTML tag definition that contains UI input elements controlling the appearance of non-data text elements of `ggplot` objects. This typically involves matters such as the font size and legend position.\n• `.defineVisualOtherInterface(x)` should a HTML tag definition that contains UI inputs elements to display in the \"Other\" section of the visual parameters. This is a grab-bag of other parameters that don't fit into the more defined categories above.\n\nA method for any of these generics may also return NULL, in which case the corresponding section of the visual parameter box is completely hidden.\n\nAll of these generics are called by `.defineInterface` for DotPlot subclasses. Developers of subclasses can simply specialize these generics to change the UI instead of reimplementing `.defineInterface` itself.\n\nWhen implementing methods for these generics, it is a good idea to make use of information pre-computed by `.cacheCommonInfo`. For example, `.cacheCommonInfo,ColumnDotPlot-method` will add vectors specifying whether a variable in the `colData` is valid and discrete or continuous.\n\n**Controlling ColorBy*Data choices**\n\n`.allowableColorByDataChoices(x, se)` should return a character vector of the allowable row/column data variables to use when `ColorBy` is set to \"Row data\" or \"Column data\" for `RowDotPlots` and `ColumnDotPlots`, respectively. The default method will use all available (atomic) variables, but subclasses can specialize this to only allow, e.g., continuous or discrete variables.\n\n**Controlling hover choices**\n\n`.getTooltipUI(x, se, name)` should return an HTML tag definition representing information to display in the tooltip that is displayed in DotPlot panels when hovering over a data point. The data point is identified by `name`, its `rownames` or `colnames` value in `se`.\n\n**Author(s)**\n\nKevin Rue-Albrecht\nIndex\n\n* datasets\n - iSEEOptions, 64\n - activateAppOptionRegistry, 89\n - activateAppOptionRegistry (registerAppOptions), 87\n - addCustomLabelsCommands, 4\n - addFacets (plot-utils), 85\n - addLabelCentersCommands, 4\n - addMultiSelectionPlotCommands, 5, 83\n - addSpecificTour, 46\n - addSpecificTour (specific-tours), 102\n - addTourStep, 6\n - allowableChoiceError (validate-utils), 111\n - allowableColorByDataChoices, 49\n - allowableColorByDataChoices (visual-parameters-generics), 112\n - allowableColorByDataChoices, DotPlot-method (DotPlot-class), 46\n - allowableXAxisChoices, 27, 90\n - allowableXAxisChoices (metadata-plot-generics), 69\n - allowableXAxisChoices, ColumnDataPlot-method (ColumnDataPlot-class), 26\n - allowableXAxisChoices, RowDataPlot-method (RowDataPlot-class), 90\n - allowableYAxisChoices, 27, 91\n - allowableYAxisChoices (metadata-plot-generics), 69\n - allowableYAxisChoices, ColumnDataPlot-method (ColumnDataPlot-class), 26\n - allowableYAxisChoices, RowDataPlot-method (RowDataPlot-class), 90\n - buildAes (aes-utils), 20\n - buildLabs, 7\n - cacheCommonInfo, 9, 19, 21, 29, 31, 37, 49, 69, 78, 86, 92, 94, 113\n - cacheCommonInfo (setup-generics), 100\n - cacheCommonInfo, ColumnDataTable-method (ColumnDataTable-class), 29\n - cacheCommonInfo, ColumnDotPlot-method (ColumnDotPlot-class), 30\n - cacheCommonInfo, ComplexHeatmapPlot-method (ComplexHeatmapPlot-class), 35\n - cacheCommonInfo, DotPlot-method (DotPlot-class), 46\n - cacheCommonInfo, Panel-method (Panel-class), 76\n - cacheCommonInfo, ReducedDimensionPlot-method (ReducedDimensionPlot-class), 85\n - cacheCommonInfo, RowDataTable-method (RowDataTable-class), 92\n - cacheCommonInfo, RowDotPlot-method (RowDotPlot-class), 93\n - checkboxGroupInput.iSEE (interface-wrappers), 60\n - checkboxInput.iSEE (interface-wrappers), 60\n - clearSpecificTours (specific-tours), 102\n - colorByNoneDotPlotField, 50\n - colorByNoneDotPlotField (plot-generics), 81\n - colorByNoneDotPlotField, DotPlot-method (DotPlot-class), 46\n - colorByNoneDotPlotScale, 50\n - colorByNoneDotPlotScale (plot-generics), 81\n - colorByNoneDotPlotScale, DotPlot-method (DotPlot-class), 46\n - conditionalOnCheckGroup (.conditionalOnRadio), 8\n - conditionalOnCheckSolo (.conditionalOnRadio), 8\n - conditionalOnRadio, 8\n - createCustomDimnamesModalObservers, 9\ncreateObservers, ColumnDataPlot-method\n(ColumnDataPlot-class), 26\n\ncreateObservers, ColumnDotPlot-method\n(ColumnDotPlot-class), 30\n\ncreateObservers, ColumnTable-method\n(ColumnTable-class), 34\n\ncreateObservers, ComplexHeatmapPlot-method\n(ComplexHeatmapPlot-class), 35\n\ncreateObservers, DotPlot-method\n(DotPlot-class), 46\n\ncreateObservers, FeatureAssayPlot-method\n(FeatureAssayPlot-class), 54\n\ncreateObservers, Panel-method\n(Panel-class), 76\n\ncreateObservers, ReducedDimensionPlot-method\n(ReducedDimensionPlot-class), 85\n\ncreateObservers, RowDataPlot-method\n(RowDataPlot-class), 90\n\ncreateObservers, RowDotPlot-method\n(RowDotPlot-class), 93\n\ncreateObservers, RowTable-method\n(RowTable-class), 96\n\ncreateObservers, SampleAssayPlot-method\n(SampleAssayPlot-class), 97\n\ncreateObservers, Table-method\n(Table-class), 107\n\ncreateProtectedParameterObservers, 18, 73\n\ncreateUnprotectedParameterObservers\n\ncreateUnprotectedParameterObservers\n\n.dataParamBoxOpen (constants), 39\n.deactivateAppOptionRegistry, 89\n.deactivateAppOptionRegistry\n(registerAppOptions), 87\n\n.defineDataInterface, 27, 37, 49, 55, 69, 78, 86, 90, 98, 107\n\n.defineDataInterface\n(interface-generics), 58\n\n.defineDataInterface, ColumnDataPlot-method\n(ColumnDataPlot-class), 26\n\n.defineDataInterface, ComplexHeatmapPlot-method\n(ComplexHeatmapPlot-class), 35\n\n.defineDataInterface, FeatureAssayPlot-method\n(FeatureAssayPlot-class), 54\n\n.defineDataInterface, Panel-method\n(Panel-class), 76\n\n.defineDataInterface, ReducedDimensionPlot-method\n(ReducedDimensionPlot-class), 85\n\n.defineDataInterface, RowDataPlot-method\n(RowDataPlot-class), 90\n\n.defineDataInterface, SampleAssayPlot-method\n(SampleAssayPlot-class), 97\n\n.defineDataInterface, Table-method\n(Table-class), 107\n\n.defineInterface, 19, 21, 25, 26, 37, 46, 49, 73, 78, 113\n\n.defineInterface (interface-generics), 58\n\n.defineInterface, ColumnDotPlot-method\n(ColumnDotPlot-class), 30\n\n.defineInterface, ColumnTable-method\n(ColumnTable-class), 34\n\n.defineInterface, ComplexHeatmapPlot-method\n(ComplexHeatmapPlot-class), 35\n\n.defineInterface, DotPlot-method\n(DotPlot-class), 46\n\n.defineInterface, Panel-method\n(Panel-class), 76\n\n.defineInterface, RowDotPlot-method\n(RowDotPlot-class), 93\n\n.defineInterface, RowTable-method\n(RowTable-class), 96\n\n.defineOutput, 38, 49, 79, 107\n\n.defineOutput (output-generics), 74\n\n.defineOutput, ComplexHeatmapPlot-method\n(ComplexHeatmapPlot-class), 35\n\n.defineOutput, DotPlot-method\n(DotPlot-class), 46\n\n.defineOutput, Table-method\n(Table-class), 107\n\n.definePanelTour, 28, 30, 32, 38, 50, 56, 78, 87, 91, 93, 95, 99, 108\n\n.definePanelTour\n(documentation-generics), 45\n\n.definePanelTour, ColumnDataPlot-method\n(ColumnDataPlot-class), 26\n.singleSelectionSlots, 50, 55, 78, 99\n/singleSelectionSlots\n (single-select-generics), 101\n.singleSelectionSlots, DotPlot-method\n (DotPlot-class), 46\n.singleSelectionSlots, FeatureAssayPlot-method\n (FeatureAssayPlot-class), 54\n.singleSelectionSlots, Panel-method\n (Panel-class), 76\n.singleSelectionSlots, SampleAssayPlot-method\n (SampleAssayPlot-class), 97\n.singleSelectionValue, 50, 73, 78, 108\n.singleSelectionValue\n (single-select-generics), 101\n.singleSelectionValue, DotPlot-method\n (DotPlot-class), 46\n.singleSelectionValue, Panel-method\n (Panel-class), 76\n.singleSelectionValue, Table-method\n (Table-class), 107\n.singleStringError (validate-utils), 111\n-sliderInput.iSEE (interface-wrappers), 60\n.textEval, 76\ntextEval (manage_commands), 68\n.trackMultiSelection (track-utils), 110\n.trackRelinkedSelection (track-utils), 110\n.trackSingleSelection (track-utils), 110\n.trackUpdate (track-utils), 110\n.validLogicalError (validate-utils), 111\n.validNumberError (validate-utils), 111\n.validStringError (validate-utils), 111\n.whichGroupable (cache-utils), 21\n.whichNumeric (cache-utils), 21\nPRESS, 32\n[[, ColumnDotPlot, ANY, ANY-method\n (ColumnDotPlot-class), 30\n[[, ColumnDotPlot-method\n (ColumnDotPlot-class), 30\n[[, ComplexHeatmapPlot, ANY, ANY-method\n (ComplexHeatmapPlot-class), 35\n[[, ComplexHeatmapPlot-method\n (ComplexHeatmapPlot-class), 35\n[[, DotPlot, ANY, ANY-method\n (DotPlot-class), 46\n[[, DotPlot-method (DotPlot-class), 46\n[[, Panel, ANY, ANY-method (Panel-class), 76\n[ assay, ExperimentColorMap, character-method\n (ExperimentColorMap-class), 51\nassay, ExperimentColorMap, numeric-method\n (ExperimentColorMap-class), 51\nassayColorMap\n (ExperimentColorMap-class), 51\nassayColorMap, ExperimentColorMap, character-method\n (ExperimentColorMap-class), 51\nassayColorMap, ExperimentColorMap, missing-method\n (ExperimentColorMap-class), 51\nassayColorMap, ExperimentColorMap, numeric-method\n (ExperimentColorMap-class), 51\nassayColorMap<-\n (ExperimentColorMap-class), 51\nassayColorMap<-, ExperimentColorMap, character-method\n (ExperimentColorMap-class), 51\nassayColorMap<-, ExperimentColorMap, numeric-method\n (ExperimentColorMap-class), 51\nassayNames, ExperimentColorMap-method\n (ExperimentColorMap-class), 51\nassayNames<-, ExperimentColorMap, ANY-method\n (ExperimentColorMap-class), 51\nvalidLogicalError (validate-utils), 111\nvalidNumberError (validate-utils), 111\nvalidStringError (validate-utils), 111\nwhichGroupable (cache-utils), 21\nwhichNumeric (cache-utils), 21\nwhichRelinkable (track-utils), 111\nwhichSelection (track-utils), 111\nINDEX\n\nassays, ExperimentColorMap-method (ExperimentColorMap-class), 51\nassays-<-, ExperimentColorMap, list-method (ExperimentColorMap-class), 51\nbrushedPoints, 48, 67\ncache-utils, 21\ncallNextMethod, 45, 59, 73, 83, 100\ncheckboxInput, 41, 102\ncheckColormapCompatibility, 22\nclass-utils, 23\nclass: ExperimentColorMap (ExperimentColorMap-class), 51\ncleanDataset, 24\ncleanDataset, SingleCellExperiment-method (cleanDataset), 24\ncleanDataset, SummarizedExperiment-method (cleanDataset), 24\ncolData, 21, 24, 26, 27, 29–31, 35, 47, 54, 69, 98, 113\ncolData, ExperimentColorMap-method (ExperimentColorMap-class), 51\ncolData-<-, ExperimentColorMap, ANY-method (ExperimentColorMap-class), 51\ncolDataColorMap, 33\ncolDataColorMap (ExperimentColorMap-class), 51\ncolDataColorMap, ExperimentColorMap, character-method (ExperimentColorMap-class), 51\ncolDataColorMap, ExperimentColorMap, missing-method (ExperimentColorMap-class), 51\ncolDataColorMap-<-, ExperimentColorMap-class), 51\ncollapseBox, 25, 59\ncolumnAnnotation, 35\nColumnDataPlot, 27, 69\nColumnDataPlot (ColumnDataPlot-class), 26\nColumnDataPlot-class, 26\nColumnDataTable, 29\nColumnDataTable (ColumnDataTable-class), 29\nColumnDataTable-class, 29\nColumnDotPlot-class, 30\ncolumnSelectionColorMap, 33\nColumnTable, 29, 34, 65, 88, 92, 109\nColumnTable-class, 34\nComplexHeatmapPlot, 12, 37, 71, 80\nComplexHeatmapPlot (ComplexHeatmapPlot-class), 35\nComplexHeatmapPlot-class, 35\nconditionalPanel, 8\nconstants, 39\ncreateCustomPanels, 40\ncreateCustomPlot (createCustomPanels), 40\ncreateCustomTable (createCustomPanels), 40\ncreateLandingPage, 42, 62\nDataFrame, 21\ndatatable, 21, 34, 57, 58, 96, 107–109\ndataTableOutput, 74, 107\ndefaultTour, 43, 44, 62\ndeparse, 100\ndocumentation-generics, 45\nDotPlot, 4, 5, 13, 17, 27, 31–33, 46, 49, 55, 69–71, 74, 79–84, 86, 90, 94–96, 98, 101, 102, 112\nDotPlot-class, 46\neval, 74\nExhibitColorMap, 22, 33, 43, 61, 63, 105, 106\nExhibitColorMap-class, 51\nFeatureAssayPlot, 55, 80, 102\nFeatureAssayPlot (FeatureAssayPlot-class), 54\nFeatureAssayPlot-class, 54\nfilterDT, 57, 109\nfilterDT (filterDTColumn), 57\nfilterDTColumn, 57\ngetAllAppOptions (registerAppOptions), 87\ngetAppOption, 89\ngetAppOption (registerAppOptions), 87\ngetPanelDefault, 31, 36, 37, 46–48, 54, 55, 77, 94, 97, 98\ngetPanelDefault (panelDefaults), 79\nggplot, 4, 5, 7, 20, 21, 30, 40, 46, 49, 50, 75, 82–84, 93\nHeatmap, 35, 38\nhidden, 60\nin.out, 67\ninitialize, 23, 100\ninitialize, ColumnDataPlot-method (ColumnDataPlot-class), 26\ninitialize, ColumnDataTable-method (ColumnDataTable-class), 29\ninitialize, ColumnDotPlot-method (ColumnDotPlot-class), 30\ninitialize, ColumnTable-method (ColumnTable-class), 34\ninitialize, ComplexHeatmapPlot-method (ComplexHeatmapPlot-class), 35\ninitialize, DotPlot-method (DotPlot-class), 46\ninitialize, FeatureAssayPlot-method (FeatureAssayPlot-class), 54\ninitialize, Panel-method (Panel-class), 76\ninitialize, ReducedDimensionPlot-method (ReducedDimensionPlot-class), 85\ninitialize, RowDataPlot-method (RowDataPlot-class), 90\ninitialize, RowDataTable-method (RowDataTable-class), 92\ninitialize, RowDotPlot-method (RowDotPlot-class), 93\ninitialize, RowTable-method (RowTable-class), 96\ninitialize, SampleAssayPlot-method (SampleAssayPlot-class), 97\ninitialize, Table-method (Table-class), 107\nint_metadata, 19, 100\ninterface-generics, 58\ninterface-wrappers, 60\niSEE, 9, 11, 14, 17, 18, 21, 43–45, 61, 61, 63, 73, 74, 87–89, 110\niSEE-package (iSEE-pkg), 63\niSEE-pkg, 63\niSEEOptions, 64\njitterSquarePoints, 66\njitterViolinPoints (jitterSquarePoints), 66\nlassoPoints, 48, 67\nmake.unique, 24\nmanage_commands, 68\nmetadata-plot-generics, 69\nmulti-select-generics, 69\nmultiSelectionToFactor, 33, 72\nnumericInput, 41\nobserveEvent, 11\nobserver-generics, 72\noffsetX, 66\noutput-generics, 74\npackage_version, 77\nPanel-class, 76\npanelDefaults, 64, 79, 88\nparse, 76\nplot-generics, 81\nplot-utils, 85\nplotOutput, 74\nreadRDS, 43\nReducedDimensionPlot, 62, 71, 86, 101\nReducedDimensionPlot (ReducedDimensionPlot-class), 85\nReducedDimensionPlot-class, 85\nreducedDims, 24, 85, 86\nregisterAppOptions, 34, 64, 81, 87, 89, 96\nrenderPlot, 74\nrenderUI, 44\nrowAnnotation, 35\nrowData, 21, 24, 35, 47, 69, 90–94\nrowData, ExperimentColorMap-method (ExperimentColorMap-class), 51\nrowData<-, ExperimentColorMap, ANY-method (ExperimentColorMap-class), 51\nrowDataColorMap, 33\nrowDataColorMap\n (ExperimentColorMap-class), 51\nrowDataColorMap, ExperimentColorMap, character-method\n (ExperimentColorMap-class), 51\nrowDataColorMap, ExperimentColorMap, missing-method\n (ExperimentColorMap-class), 51\nrowDataColorMap<-\n (ExperimentColorMap-class), 51\nrowDataColorMap<-, ExperimentColorMap, character-method\n (ExperimentColorMap-class), 51\nRowDataPlot, 69, 90\nRowDataPlot (RowDataPlot-class), 90\nRowDataTable, 92\nRowDataTable (RowDataTable-class), 92\nRowDataTable-class, 92\nRowDotPlot, 46, 47, 50, 71, 80, 82, 83, 90, 91, 94, 97, 99, 108, 113\nRowDotPlot-class, 93\nrowSelectionColorMap\n (columnSelectionColorMap), 33\nRowTable, 65, 88, 96, 101, 109\nRowTable-class, 96\nrunApp, 62\nSampleAssayPlot, 80, 98\nSampleAssayPlot\n (SampleAssayPlot-class), 97\nSampleAssayPlot-class, 97\nscale_color_manual, 84\nselectInput, 24, 41, 60, 102\nsetup-generics, 100\nsetValidity, 111\nshinyApp, 62\nshow, ExperimentColorMap-method\n (ExperimentColorMap-class), 51\nshow, Panel-method (Panel-class), 76\nsingle-select-generics, 101\nSingleCellExperiment, 22, 24, 85, 101, 105\nspecific-tours, 102\nsubsetPointsByGrid, 48, 104\nSummarizedExperiment, 9, 12, 15, 18, 19, 21,\n 24, 26, 29, 30, 32, 34, 35, 41–43, 46,\n 54, 58, 61–63, 69, 70, 73–76, 82, 88,\n 90, 92, 93, 95–97, 100, 107, 109, 112\nsynchronizeAssays, 105\nTable, 29, 34, 35, 79, 92, 96, 97, 107, 109\nTable-class, 107\ntable-generics, 109\ntagList, 74\ntextInput, 41\ntrack-utils, 110\nupdateObject, 77, 78\nupdateObject, ColumnDotPlot-method\n (ColumnDotPlot-class), 30\nupdateObject, ComplexHeatmapPlot-method\n (ComplexHeatmapPlot-class), 35\nupdateObject, DotPlot-method\n (DotPlot-class), 46\nupdateObject, Panel-method\n (Panel-class), 76\nupdateObject, RowDotPlot-method\n (RowDotPlot-class), 93\nupdateObject, Table-method\n (Table-class), 107\nvalidate-utils, 111\nvisual-parameters-generics, 112"}}},{"rowIdx":161,"cells":{"id":{"kind":"string","value":"ae732d96c3e411d4763105927728e4d47d0df155"},"text":{"kind":"string","value":"PM-1 3½\" x 4\" PHOTOGRAPHIC MICROCOPY TARGET\nNBS 1010a ANSI/ISO #2 EQUIVALENT\n\n1.0 1.25 2.5\n1.1 1.4 2.2\n1.25 1.6 2.0\n\nPRECISION™ RESOLUTION TARGETS\nPOWERS PHOTOGRAPHIC TESTING SINCE 1912\nMICROD\nNOTICE\n\nThe quality of this microform is heavily dependent upon the quality of the original thesis submitted for microfilming. Every effort has been made to ensure the highest quality of reproduction possible.\n\nIf pages are missing, contact the university which granted the degree.\n\nSome pages may have indistinct print especially if the original pages were typed with a poor typewriter ribbon or if the university sent us an inferior photocopy.\n\nReproduction in full or in part of this microform is governed by the Canadian Copyright Act, R.S.C. 1970, c. C-30, and subsequent amendments.\n\nAVIS\n\nLa qualité de cette microforme dépend grandement de la qualité de la thèse soumise au microfilmage. Nous avons tout fait pour assurer une qualité supérieure de reproduction.\n\nS'il manque des pages, veuillez communiquer avec l'université qui a conféré le grade.\n\nLa qualité d'impression de certaines pages peut laisser à désirer, surtout si les pages originales ont été dactylographiées à l'aide d'un ruban usé ou si l'université nous a fait parvenir une photocopie de qualité inférieure.\n\nLa reproduction, même partielle, de cette microforme est soumise à la Loi canadienne sur le droit d'auteur, SRC 1970, c. C-30, et ses amendements subséquents.\nA Graphical User Interface Server for Graph Algorithm Programs\n\nby\n\nJanet B. Noye, BSc(CS)\n\nA thesis submitted to\nthe Faculty of Graduate Studies and Research\nin partial fulfillment of\nthe requirements for the degree of\n\nMaster of Computer Science\n\nSchool of Computer Science\n\nCarleton University\nOttawa, Ontario\nJanuary 17, 1992\n© copyright\n1992, Janet B. Noye\nThe author has granted an irrevocable non-exclusive licence allowing the National Library of Canada to reproduce, loan, distribute or sell copies of his/her thesis by any means and in any form or format, making this thesis available to interested persons.\n\nThe author retains ownership of the copyright in his/her thesis. Neither the thesis nor substantial extracts from it may be printed or otherwise reproduced without his/her permission.\n\nISBN 0-315-75977-1\nThe undersigned hereby recommend to the Faculty of Graduate Studies and Research acceptance of the thesis,\n\nA Graphical User Interface Server for Graph Algorithm Programs\n\nsubmitted by Janet B. Noye, BSc(CS)\nin partial fulfillment of the requirements\nfor the degree of Master of Computer Science\n\n[Signature]\nThesis Supervisor\n\n[Signature]\nDirector, School of Computer Science\n\nCarleton University\nJanuary 17, 1992\nAbstract\n\nThis thesis describes a user interface facility for creating and manipulating graphs that can be used in the development of graph algorithm programs. The facility described is an adaptable graph user interface program, GraphUI, that runs on Macintosh computers. GraphUI provides a complete separation of its graphical user interface from programs which use it. GraphUI can be used by a graph program to obtain input, display output, and animate algorithms.\n\nPrograms access the user interface capabilities of GraphUI through a set of commands which may be sent to GraphUI across a variety of mediums. The commands have been designed to allow graph programmers to use graph knowledge rather than use graphical knowledge when interacting with GraphUI.\n\nThis thesis focuses on the development of an open architecture to allow graph programs from different fields, different development environments, and different platforms to make simultaneous use of a centralized interactive graph user interface.\nAcknowledgements\n\nThank you Gordie for everything.\n\nI would like to thank my supervisor Lou Nel for his continued support and friendship throughout my thesis. He made what could have been a very frustrating time for me much more bearable and most often a lot of fun.\n\nThank you Aubrey, Barb, Harold, Marlene, Debi, Nancy, Heather, Rob, and Carolyn.\n\nThank you to Janet for helping to get rid of lots of errors the first time through and for many good talks. I hope the world looks better when you get back from seeing it.\n\nThanks to Rob and Rajiv for friendship and many great cups of coffee and for humoring me by not talking about school. To Erwin for numerous good lunches.\n# Table of Contents\n\nAcceptance Sheet................................................................................................. ii\nAbstract............................................................................................................... iii\nAcknowledgements......................................................................................... iv v\nTable of Contents .............................................................................................. v\nList of Tables....................................................................................................... vii\nList of Figures..................................................................................................... viii\n\nCHAPTER 1 : Introduction ...................................................................................... 1\n 1.1 State of the Art in Graphical User Interfaces for Graph Programs .............. 3\n 1.1.1 Drawing Graphs .................................................................................... 4\n 1.1.2 Graph Applications with Graphical User Interfaces ......................... 5\n 1.1.3 Adaptable Graph User Interface Tools ............................................. 5\n 1.3 Problem Definition ...................................................................................... 10\n 1.4 Thesis Layout .............................................................................................. 11\n\nCHAPTER 2 : Design of GraphUI .......................................................................... 13\n 2.1 Requirements of GraphUI ........................................................................ 13\n 2.2 Design Goals for GraphUI ........................................................................ 14\n 2.3 Communication Design ........................................................................... 16\n 2.4 User Interface Design .............................................................................. 18\n 2.5 Application Interface Design .................................................................... 23\n 2.6 GraphUI Programming Model .................................................................. 31\n\nCHAPTER 3 : Implementation of GraphUI ............................................................ 33\n 3.1 Introduction .............................................................................................. 33\n 3.2 Object Hierarchy ....................................................................................... 33\n 3.3 Notable Implementation Details .................................................................. 37\n\nCHAPTER 4 : User Interface ................................................................................ 46\n 4.1 Creating Graphs ....................................................................................... 46\n 4.2 Modifying Graphs ..................................................................................... 53\n 4.3 Displaying and Setting Attributes of Graphs ............................................ 59\n 4.4 Printing From GraphUI ........................................................................... 65\n 4.5 Clipboard Support .................................................................................... 66\n 4.6 Connecting to and Using Graph Applications .......................................... 69\n\nCHAPTER 5 : Application Interface ..................................................................... 74\n 5.1 GraphUI Commands ................................................................................ 75\n 5.2 GraphUI Information Messages ............................................................... 101\n 5.3 Suggested Animation Techniques ............................................................ 108\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>2.1</td>\n<td>Definition of Graph Attributes</td>\n<td>25</td>\n</tr>\n<tr>\n<td>2.2</td>\n<td>Definition of Node Attributes</td>\n<td>25</td>\n</tr>\n<tr>\n<td>2.3</td>\n<td>Definition of Edge Attributes</td>\n<td>26</td>\n</tr>\n<tr>\n<td>3.1</td>\n<td>Object Classes With.71 GraphUI</td>\n<td>34</td>\n</tr>\n<tr>\n<td>5.1</td>\n<td>Format of the Change Graph Attributes Flag</td>\n<td>91</td>\n</tr>\n<tr>\n<td>5.2</td>\n<td>Format of the Change Node Attributes Flag</td>\n<td>93</td>\n</tr>\n<tr>\n<td>5.3</td>\n<td>Format of the Change Edge Attributes Flag</td>\n<td>95</td>\n</tr>\n</tbody>\n</table>\n## List of Figures\n\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>2.1</td>\n<td>QuickDraw versus Bitmap Output</td>\n<td>15</td>\n</tr>\n<tr>\n<td>2.2</td>\n<td>Logical Connections Between GraphUI and Graph Programs</td>\n<td>17</td>\n</tr>\n<tr>\n<td>2.3</td>\n<td>Pictorial Representation of a Graph</td>\n<td>19</td>\n</tr>\n<tr>\n<td>2.4</td>\n<td>Drawing Syntax for Multiple Edges Between Two Nodes</td>\n<td>20</td>\n</tr>\n<tr>\n<td>2.5</td>\n<td>GraphUI's Drawing Representation of Arcs</td>\n<td>20</td>\n</tr>\n<tr>\n<td>2.6</td>\n<td>Minimum and Maximum Node and Edge Sizes in GraphUI</td>\n<td>21</td>\n</tr>\n<tr>\n<td>2.7</td>\n<td>A Graph With Node and Edge Labels</td>\n<td>21</td>\n</tr>\n<tr>\n<td>2.8</td>\n<td>Model of the GraphUI Program</td>\n<td>32</td>\n</tr>\n<tr>\n<td>3.1</td>\n<td>Node Extent</td>\n<td>39</td>\n</tr>\n<tr>\n<td>3.2</td>\n<td>Edge Extent</td>\n<td>39</td>\n</tr>\n<tr>\n<td>3.3</td>\n<td>Representation of Multiple Edges</td>\n<td>41</td>\n</tr>\n<tr>\n<td>3.4</td>\n<td>How a Bent Edge is Drawn</td>\n<td>41</td>\n</tr>\n<tr>\n<td>3.5</td>\n<td>A Pair of Nodes With Many Edges Connecting Them</td>\n<td>41</td>\n</tr>\n<tr>\n<td>3.6</td>\n<td>Computing the Bendpoint of Bent Edges</td>\n<td>43</td>\n</tr>\n<tr>\n<td>3.7</td>\n<td>Algorithm Used to Determine the Bend Point of an Edge</td>\n<td>43</td>\n</tr>\n<tr>\n<td>4.1</td>\n<td>Empty GraphUI Window</td>\n<td>47</td>\n</tr>\n<tr>\n<td>4.2</td>\n<td>Graph With One Node</td>\n<td>49</td>\n</tr>\n<tr>\n<td>4.3</td>\n<td>What the User Sees when Creating an Edge</td>\n<td>50</td>\n</tr>\n<tr>\n<td>4.4</td>\n<td>GraphUI's Representation of an Edge</td>\n<td>50</td>\n</tr>\n<tr>\n<td>4.5</td>\n<td>Multiple Edges Between a Pair of Nodes</td>\n<td>50</td>\n</tr>\n<tr>\n<td>4.6</td>\n<td>Completing a Graph</td>\n<td>51</td>\n</tr>\n<tr>\n<td>4.7</td>\n<td>A Complete Graph on 6 Nodes</td>\n<td>52</td>\n</tr>\n<tr>\n<td>4.8a</td>\n<td>The Feedback Displayed While a User Makes a Selection</td>\n<td>55</td>\n</tr>\n<tr>\n<td>4.8b</td>\n<td>The Selection Set Created in Figure 4.8a</td>\n<td>55</td>\n</tr>\n<tr>\n<td>4.9a</td>\n<td>Graph Before Edge 4 is Contracted</td>\n<td>58</td>\n</tr>\n<tr>\n<td>4.9b</td>\n<td>Graph After Edge 4 is Contracted</td>\n<td>58</td>\n</tr>\n<tr>\n<td>4.10</td>\n<td>Change Graph Attributes Window</td>\n<td>60</td>\n</tr>\n<tr>\n<td>4.11</td>\n<td>Change Node Attributes Window</td>\n<td>62</td>\n</tr>\n<tr>\n<td>4.12</td>\n<td>Change Edge Attributes Window</td>\n<td>64</td>\n</tr>\n<tr>\n<td>4.13</td>\n<td>Page Setup for LaserWriter</td>\n<td>65</td>\n</tr>\n<tr>\n<td>4.14a</td>\n<td>Graph to be Copied/Cut</td>\n<td>67</td>\n</tr>\n<tr>\n<td>4.14b</td>\n<td>Portion of Graph Copied</td>\n<td>68</td>\n</tr>\n<tr>\n<td>4.14c</td>\n<td>Remainder of Graph After a Cut Command</td>\n<td>68</td>\n</tr>\n<tr>\n<td>4.15</td>\n<td>AppleTalk ADSP Tool Connection Settings</td>\n<td>71</td>\n</tr>\n<tr>\n<td>4.16</td>\n<td>Applications' Transcript After Running Shortest Path</td>\n<td>73</td>\n</tr>\n<tr>\n<td>5.1</td>\n<td>Format of All GraphUI Messages</td>\n<td>74</td>\n</tr>\n<tr>\n<td>6.1</td>\n<td>Static Window Displayed by GraphApp</td>\n<td>114</td>\n</tr>\n<tr>\n<td>6.2</td>\n<td>Selecting AppleTalk Connection Tool</td>\n<td>115</td>\n</tr>\n</tbody>\n</table>\n1. Introduction\n\nBecause graphs are used to represent relationships in many domains, it is necessary for people and programs to create and manipulate graph models. To this end, work has been done on graph editing tools which users can use to create pictures of graph models. These pictures of graph models can be used to design graph data structures for application programs. Unfortunately, this is a two-step process, create a picture of the graph model then use it to create the appropriate graph data structures.\n\nTo combine this two-step process into one, work has been done on graph programs which have interactive graphical user interfaces, (GUI). In such programs, the pictures of graph models created by a user are automatically converted to the correct graph data structures used by the program. Unfortunately, the GUIs of these programs have been designed to suit the needs of a specific application domain and cannot easily be reused for graph programs from a different application domain.\n\nSince building a GUI requires considerable effort, a number of graph tools have been created which provide GUI capabilities that can be used by graph programs. The graph tools are termed adaptable graph user interface tools because the tools can be modified for new graph programs. These tools help to reduce the overall time required to build a graph program with an appropriate GUI. The manner in which graph programs access the GUI capabilities of an adaptable graph user interface tool is termed its application\ninterface. The application interface dictates both how a program uses the tool and the capabilities the tool provides.\n\nThe application interfaces of existing adaptable graph user interface tools are achieved by combining the tool and a graph program into a single program. To combine an adaptable graph user interface tool with a graph program requires modifying the tool's code to integrate it with the graph program. Unfortunately, this means the programmer must have knowledge of both the implementation of the tool and its development environment. Only programs which can be linked directly with the tool can make use of it. This limits the graph programs that can use the existing tools to particular development environments and platforms.\n\nThis thesis addresses the problem of how to design an application interface architecture for an adaptable graph user interface tool that does not require reprogramming the tool and does not limit the programs that use it to a specific development environment and platform. In particular we look at the problem of how to design an application interface so that it separates an adaptable graph user interface tool completely from the graph programs that use it.\n\nIn our solution to this problem, an adaptable graph user interface tool which can meet the user interface requirements of graph programs from a myriad of application domains, is designed and implemented. The application interface to our tool, which is called GraphUI, uses a graph command language that is communicated through inter-application message passing. GraphUI's graph command language uses graph entities such as nodes and edges rather than GUI entities such as circles and lines thereby isolating programmers from GUI implementation details. Message passing\nallows GraphUI to provide user interface capabilities to graph programs which are running on the same computer or on different computers. This provides a centralized graph GUI that can be used simultaneously by multiple graph applications.\n\nGraphUI has been designed to assist academic researchers in three areas: implementation, publication, and presentation. GraphUI helps the researcher implement graph algorithms by supplying the graphical user interface. To aid researchers in describing the results of an algorithm, the pictures of graphs displayed by GraphUI can be copied directly into documents. Because GraphUI can be used to animate the progress of an algorithm, researchers can show how an algorithm operates during presentations or classes.\n\nThe following section outlines current and related work in GUIs for graph programs including a number of adaptable graph user interface tools. It is followed by a section outlining the research problems addressed by this thesis.\n\n1.1 State of the Art in Graphical User Interfaces for Graph Programs\n\nThis section describes current research in graphical user interfaces for graph programs. We look at programs that can be used to create pictures of graph models and graph applications which have graphical user interfaces that allow users to enter graph models by drawing them. We concentrate on describing existing adaptable graph user interface tools which have been designed to provide ready-made user interfaces for new graph applications.\nSuch tools reduce the overall development time required to build new graph programs.\n\n1.1.1 Drawing Graphs\n\nThere are many commercial generic drawing programs such as MacDraw [12] and MacPaint [13] which can be used to create pictures of graph models. MacDraw and MacPaint are programs which allow users to draw pictures using components such as circles, squares, rectangles, lines, polygons and text. In pictures of graph models, circles or rectangles are often used to represent nodes whereas lines are often used to represent edges.\n\nOther applications like DAG [6] have been designed specifically for drawing directed graphs. DAG automatically layouts graphs for users so that the number of edge intersections is minimized. Graph drawing programs allow users to build pictures of graph models by interactively creating nodes and edges rather than the circles and lines users of generic drawing programs must use. Thus graph drawing programs provide users with graphical abstractions for nodes and edges.\n\nPictures of graph models are useful both for designing input to graph programs and displaying output from graph programs. To design input, a picture of a graph model is often created and then interpreted by a user to create the correct graph data structure for a graph program. To display output the process is reversed, a graph data structure is used to draw a picture of the graph model it represents. Pictures of graph models are not necessary for creating input and conveying output, they are just make it easier for people to comprehend the models.\n1.1.2 Graph Applications with Graphical User Interfaces\n\nGraphs can be used to model many different types of relationships. Because graph models have diverse applications, there is a great number of programs that use graphs as input and output. There are so many applications which use graphs in modeling data it is impossible to list them all. Some representative example applications are: basic graph theory programs [10], network design [11], parallel processing [4], software engineering [16], and statistical modeling [18]. The referenced applications have GUIs which display pictures of graph models and allow graph models to be built pictorially. The pictures of graph models created with an application’s GUI automatically generates the correct data structures for the application. The user interfaces of the applications referenced were all well suited to the needs of each application but their use was restricted to their particular application domain.\n\n1.1.3 Adaptable Graph User Interface Tools\n\nAdaptable graph user interface tools are graphical user interfaces that can be altered to provide new graph programs use of its GUI. This section outlines the current research in adaptable graph user interface tools which enable graph programmers to use the tools with their graph applications. Although the functionality of these user interfaces vary, they all attempt to provide user interface capabilities to programs which use graph models, regardless of the application domain of the program. The application\ninterface describes the way a tool is accessed by graph programs and the functionality it provides. The application interface used to adapt the following user interface tools to new graph programs varies and is the primary subject of this subsection.\n\nGraph Browsers allow users to navigate through, observe and change graphs. The GRAB graph browser [15] can be used to browse arbitrary directed graphs and can be integrated with other applications that allow browsing of information. GRAB displays the nodes of a graph as icons and the edges as lines connecting nodes. It permits users to add and delete nodes and edges, move nodes and change node and edge labels.\n\nOne existing application of GRAB is a program browser which displays the call-graph of a program. The nodes of the graph displayed by GRAB represent the procedures of a program and the edges represent the CALLS relationship. The vi text editor has been integrated into the program browser so that GRAB invokes vi with the name of the routine to be edited whenever a node is selected by the user. The major contribution of GRAB is its ability to perform automatic layout of directed graphs and that it may be altered to invoke editors, like vi, to display information about the components of a graph displayed by GRAB.\n\nThe graph manager/browser, GMB, [8] has been designed to manage a graph abstract data type called a GMB graph and act as a graph browser to display these graphs. Application programs can use graph manager routines to create and edit GMB graphs. To help manage graphs for different applications, the graph manager can store and retrieve arbitrary information about nodes and edges on an application’s behalf. This allows GMB graphs to be tailored to the needs of different applications.\nThe graph browser portion of GMB displays GMB graphs created by a program. It automatically lays out graphs hierarchically with a minimum number of edge crossings. Programs and users can affect the way graphs are displayed by the browser. Programs can perform the entire graph layout or issue layout directives, such as place nodes n1 and n2 at the same level. Layout directives allow programs to control the placement of critical nodes. Labels may be used to display information about nodes and edges using annotations. Annotations are a few lines of text which can be set by programs. Unfortunately, the arbitrary graph, node and edge information that GMB saves for programs cannot be directly displayed by the GMB browser. Associated with every GMB graph and every node and edge is a state variable. The value of a state variable can be set by programs and is used to specify display attributes. Users can associate node and edge type, colour, and visibility (i.e. is this node or edge visible?), with state variable values in order to control the appearance of a graph. Programs are able to animate their execution by changing the value of state variables and effectively alter a graphs picture as the program executes.\n\nGraph editors are tools with which graphs may be created and altered. The GraphEd [7] interactive graph editor allows graphs to be constructed and displays nodes as icons and edges as line segments. Users can create different node types by creating new node icons. Cut, copy and paste operations are supported to make it easier to edit graphs displayed by GraphEd. Like GRAB and GMB, labels can be displayed for nodes and edges. GraphEd interacts with programs through an adjacency list type of file format. The editor will display graphs written in this format on behalf of graph programs. The research does not mention if graph programs can directly affect the manner in which\ngraphs are displayed by GraphEd or respond to user actions through the user interface of GraphEd.\n\nKnowledge-based graph editors are graph editors which,\n\n\"... embody a rich and diverse amount of information about how to deal with directed graphs, and because it is possible to alter or extend this information to suit a particular application\". [19]\n\nThe EDGE [14] graph editor and its predecessor kb-edit [19] are knowledge-based graph editors. Both are editor kernels which can be adapted to new graph applications.\n\nThe kb-edit editor performs automatic graph layout for both users and programs. The user interface supports graph editing and graph browsing through popup menus. The user interface may be altered by replacing function calls within the editor, or by adding new functions and new menu items. Kb-edit is adapted to new applications by specifying the shape of icon to be used to display nodes, the type of line to be used to display edges, extending menus to contain new entries, and filling in pointers to routines that are to be called at specific events. User events that can cause the editor to invoke graph application procedures include adding or selecting nodes and edges, and selecting menu entries. Kb-edit is written in Knowledge Craft on Symbolics Lisp machines and relies on inheritance to reduce the amount of work required to alter it to suit the needs of new graph applications.\n\nBecause kb-edit's automatic graph layout ran too slowly and was not easily portable to new platforms, its successor, EDGE, was written in C++ with X Windows. EDGE solves the kb-edit performance problems and can be ported easily to most UNIX platforms. Adapting EDGE to suit the\nrequirements of a new graph application is similar to the method used to alter kb-edit. Programmers can override base functionality of the editor allowing programs to alter operations such as add and delete nodes and edges, edit, draw graph, and select action. To make it easier to alter EDGE for new application instances, a program generator has been created which reads in node and edge class definitions and creates the appropriate constructors and destructors for the new classes and creates appropriate source code for new menu entries.\n\nA graph representation language, GRL, can be used to input graphs to EDGE. GRL permits specification of the nodes and edges of a graph and display information such as labels, node and edge styles, and layout constraints (directives).\n\nThe Networks editor [9] is a graph-based modeling system (GBMS) instance editor which allows network modelers to create new instances of graph editors, called scheme editors, to accommodate applications which use graph models. Scheme editors can be used as graphical user interfaces for applications which use a particular type of graph. To manage the node and edge information required by different graph applications, the Network editor enables users to assign variables to node and edge types called attributes. The values of attributes can be set for particular nodes and edges by users with the resulting scheme editor. New operations may be added to a scheme editor and changes may be made to existing editor functionality by linking in external functions.\n1.3 Problem Definition\n\nA user interface dictates the manner which input is obtained, output is displayed, and how a user controls a program. The graph browsers and editors described in the previous section can be adapted to suit the user interface requirements of graph applications. Each of the browsers and editors described can be used to obtain input in the form of graphs, draw graphs as output and provide varying degrees of user control over graph programs. Unfortunately, these existing tools must be modified if a programmer wishes to alter the default user control over the graph programs that use them. For example, the Networks scheme editor must have new operations linked into the editor whenever new operations are added to the editor. This results in different versions of the Networks editor for different programs. The Edge editor must have certain methods altered or overridden to allow a graph program to respond to user actions such as node or edge selection.\n\nThe goal of this thesis is to overcome the problem, that the application interfaces of existing adaptable graph user interface tools require reprogramming the tools when a programmer wishes to alter the default user control of the program. We wish to present a solution to the problem of how to design an application interface for an adaptable graph user interface tool that provides flexible user control of graph programs but does not rely upon altering the code of the tool.\n\nWe propose that an application interface which relies upon message-passing will allow us to completely separate an adaptable graph user interface tool from the programs that use it. Message passing provides a decoupling of the GUI capabilities and the graph programs which use them, allowing\nthem to co-exist as separate executing processes. Additionally, if the user interface is a program that is not part of the code of the applications it serves, its application interface can't rely upon changing its code. Consequently, programmers will not have to change the user interface to use it with a new graph application.\n\nTo explore our application interface design, we design and implement an adaptable graph user interface tool, GraphUI, which uses our application interface. The emphasis of the GraphUI is on providing graph user interface capabilities which enable programs to obtain user input, affect the display of output to users and provide users direct access to manage the execution of graph programs using the tool.\n\nThe expected benefits of our application interface are: 1) graph application programmers will not have to work in the development environment of the adaptable graph user interface tool; 2) GUI coding issues such as graphics and graph data structures will not impact graph programs that use the tool; and 3) it will be possible to have one centralized user interface from which many graph programs can be simultaneously accessed.\n\n1.4 Thesis Layout\n\nThe remainder of this thesis describes our proposed application interface and the adaptable graph user interface tool, GraphUI, which makes use of the interface. The first part of this thesis describes the design and implementation of GraphUI and are found in Chapters 2 and 3 respectively. Included in the description of the design are: the application interface which allows GraphUI to be separated from the applications that use it; the user\ninterface functionality necessary in GraphUI; the goals of the system design; the manner in which each goal was satisfied; and an overview of the programming model of GraphUI. The object hierarchy and the implementation difficulties which arose are the focus of Chapter 3. A detailed description of the user interface that GraphUI provides is found in Chapter 4. The application interface to GraphUI consists of its command set and the protocol used to interact with it and is described in Chapter 5.\n\nA sample program called GraphApp has been created which illustrates how to use GraphUI's application interface, highlighting both low level communications and a philosophy for using GraphUI. GraphApp provides a number of data structures that manage graphs and routines which communicate GraphUI's command set. The sample program was written for a Macintosh computer and connects to GraphUI through the AppleTalk ADSP connection tool [2]. Chapter 6 describes GraphApp to illustrate how to use GraphUI's application interface. The final chapter discusses contributions and future work planned for GraphUI.\n2. Design of GraphUI\n\nThe purpose of this chapter is to describe the design of our adaptable graph user interface tool, GraphUI. In particular, we look at the design of the application user interface which allows GraphUI to be separated from the programs that use it. Included is a description of the functionality required for GraphUI, the design goals that GraphUI must satisfy, and a description of the resulting design which meets the identified goals.\n\n2.1 Requirements of GraphUI\n\nGraphUI was created to explore an application interface to graph programs that does not require programming changes to GraphUI. The first requirement that GraphUI must satisfy is providing this application interface. The application interface relies upon message passing to communicate with programs using it. To provide a flexible interface, it is required that GraphUI communicate with programs through a variety of connections to afford programs running on different platforms access to GraphUI. This gives graph programmers the opportunity to work on computers and in development environments that suit the needs of their programs.\n\nGraphUI must provide user interface capabilities to the programs it serves. Rather than focus on one graph operation such as automatic graph layout like similar tools do [7,8,9,14,15,19], GraphUI concentrates on providing a simple means for programs to obtain user input, display output and control\naccess to the programs. This provides user interface capabilities which are useful to a variety of graph applications including tools which perform automatic graph layout.\n\nIt is required that GraphUI provide an intuitive graphical user interface that can be used for graph algorithm programs from different domains. To make it easier for users to comprehend graph algorithms, it is required that programs be able to interactively affect changes to a graph during progress of their algorithms. This permits a user to observe an algorithm by watching the changes. The goal of GraphUI is to manage the user interface for graph programs so that graph programmers can use a graphical user interface but do not have to change GraphUI.\n\nThe final requirement of this thesis is to provide an example graph program that uses GraphUI for its user interface. The purpose of the example program is to show graph programmers how to use GraphUI’s application interface, and to provide a program that graph algorithms can be added directly to that uses GraphUI.\n\n2.2 Design Goals for GraphUI\n\nThe application interface is to be designed such that the programs that use GraphUI do not have to be written in the same development environment or even on the same computer. Thus the choice of computer and development environment of GraphUI will not greatly impact its use by other programs. We choose to implement GraphUI on Macintosh computers to take advantage of their graphical user interface capabilities.\nMacintosh computers are renowned for their ease of use. This is partially due to the Macintosh's graphical user interface and moreover to the consistency between applications. A program that follows the Macintosh User Interface Guidelines [1] operates in a manner that is similar to other programs adhering to the guidelines. One design goal is to ensure that GraphUI, as all good Macintosh programs, follows the Macintosh User Interface Guidelines. In following the guidelines, GraphUI ensures that undo of commands is provided, cut, copy, and paste into the clipboard are supported, standard file conventions for creating, opening, printing, and saving documents are supported, area and point selection mechanisms are provided, and printing uses QuickDraw routines for high quality printing. In short, support the things which have made the Macintosh user interface popular. Figure 2.2 shows the difference between a printed bitmap and a picture printed using QuickDraw routines.\n\n\n\nFigure 2.1: QuickDraw versus Bitmap Output\n\nAnother design goal of GraphUI is to establish a reasonable and well defined representation for drawing pictures of graphs, similar to those of\nexisting adaptable graph user interface tools. To provide a clear user interface, the pictures must make sense to the observer.\n\nThe final design goal of GraphUI is to make the application interface use a graph command language rather than use a graphical command language. To a person writing a program using the application interface, a graph should be a data structure rather than a picture and this must be reflected in the command language. For example, the application interface should add a node to a graph by sending the command \"add node\" not \"draw circle at (x, y) with radius w\". Thus the programmer does not need a thorough understanding of user interface programming and its terminology.\n\nIn summary the design goals for GraphUI are as follows:\n\n1. Adhere to the Macintosh User Interface Guidelines;\n2. Establish a reasonable and well defined representation for drawing pictures of graphs; and\n3. Ensure the application interface uses a graph language that is easily understood by graph programmers.\n\nThe remainder of this chapter discusses the manner in which GraphUI has been designed to satisfy the necessary requirements and to meet each of the design goals.\n\n2.3 Communication Design\n\nTo satisfy the requirement of providing an application interface which has the ability to communicate with programs through a variety of connections, GraphUI was designed to communicate using the Macintosh\nCommunications Toolbox Connection Manager [2]. The communications toolbox allows programmers to implement basic connections without being concerned with the underlying connection protocols. Connection tools handle the underlying protocols.\n\nThe Connection Manager provides a program with channels that carry data between the program and another computer process running on the same computer or any other computer. GraphUI uses channels to exchange messages by sending and receiving blocks of data. Figure 2.2 shows the logical connection of GraphUI to graph programs through channels.\n\n\n\nFigure 2.2: Logical Connections Between GraphUI and Graph Programs\nBy allowing the user of GraphUI to interactively create connection channels that use different connection tools, the application interface of GraphUI has the potential to communicate with programs running on a variety of computers without altering GraphUI. If the connection tools provided with the Communications Toolbox do not handle the underlying protocol required to connect to a particular computer, a connection tool may be written to handle the protocol without changing the code of GraphUI.\n\n2.4 User Interface Design\n\nThe following section describes the design of GraphUI with respect to the user interface. It concentrates on the representation used in drawing graphs and the operations that users are able to perform using GraphUI. Drawing and manipulating graphs is a necessary component in any graph user interface tool. The operations which we permit users are straightforward and designed to make it easy for users to create graph input models for graph programs and to access programs using the application interface transparently.\n\n2.4.1 Drawing Conventions\n\nGraphs are drawn in windows. A separate window is provided for each graph thereby allowing multiple graphs to be displayed simultaneously. As far as the user is concerned, a graph is a window containing a picture of the graph, see Figure 2.3. The physical entity that a graph models can be a map of highways connecting cities, a telephone network, a person's family\nhistory, or many other things. Rather than attempt to accommodate all\ndifferent graphical representations of nodes and edges, GraphUI uses a fixed\nrepresentation.\n\n\n\n**Figure 2.3**: Pictorial Representation of a Graph\n\nAll nodes are represented by circles, all edges by lines. It is possible to\nhave more than one edge between a pair of nodes. To ensure that all edges\nare visible, multiple edges between a pair of nodes are drawn by bending the\nadditional edges between a pair of nodes, see Figure 2.4.\n\nMany graphs distinguish between arcs and edges, arcs have direction\nwhereas edges do not. To illustrate that an arc is directed and thus not an\nedge, an arrow is drawn on the arc, pointing to its head node. Figure 2.5 illustrates the representation of arcs.\n\n\n\n**Figure 2.4**: Drawing Syntax for Multiple Edges Between Two Nodes\n\n\n\n**Figure 2.5**: GraphUI's Drawing Representation of Arcs\n\nWhen explaining an algorithm using a picture of a graph, it is often necessary to distinguish particular nodes or edges. Examples of this are marking the edges that form a cutset isolating two nodes and distinguishing the source node of a search operation. The representation used to indicate that a node or edge is marked, or selected, is to draw the node or edge in gray rather than black.\n\nIt is likely that two states, marked and unmarked, are not enough to convey detailed information about nodes and edges. For this reason, the sizes of nodes and edges are variable, allowing nodes to have a radius from 0 to 20 and edges to have a thickness of 1 to 10. Figure 2.6 shows two graph components, the left component has edges with thickness 1 and nodes of radius 0, the right component has edges with thickness 10 and nodes of radius 20.\nThe final means of distinguishing nodes and edges drawn with GraphUI are labels. There is a mechanism with which labels can be drawn for any node or edge. Any alphanumeric value is a valid label. Figure 2.7 shows a graph in which nodes are labeled with the city they represent and arcs are labeled with the distance between the cities.\n2.4.2 User Interface Operations\n\nThe set of operations a user can perform on a graph has been designed to allow users to create, edit, save, and print graphs. The manner in which a user performs the functions is left to the user interface description in Chapter 4.\n\nTo create a graph the user adds nodes and edges. GraphUI requires that an edge have a distinct tail and head node when it is added. Once created, the user can modify a graph. Two different types of graph modifications can be made using GraphUI.\n\nThe first type of graph modification changes the topology, or structure, of a graph. The most obvious way to change the structure is to add additional nodes and edges. The structure of a graph can also be modified by deleting nodes and edges. Since an edge cannot exist without both its head and tail nodes, deleting a node also deletes all edges connected to it. Adding and deleting nodes and edges are the only two fundamental ways to alter the structure of a graph. There is no structural alteration that cannot be simplified into some combination of adds and deletes.\n\nThe second type of graph modification is to change the graph’s appearance but not its structure. One method of altering a graph’s appearance is to reposition its nodes. Since an edge is a connection between two nodes, a graph is repositioned by moving nodes; the edges attached to a node always follow it. To further alter the appearance of a graph, users are allowed to set the size of nodes and edges, change labels, mark, or select, edges and nodes, and show or hide the direction of edges.\nOnce created, graphs are stored in application documents which the user can save or print. Since GraphUI is a Macintosh application, users can copy graphs to the clipboard and paste them directly into word processing or drawing package documents.\n\nGraphUI includes commands to contract edges and to complete a graph. These two graph operations were included in GraphUI because they are often used to construct graphs and were viewed as user interface shortcuts.\n\n2.5 Application Interface Design\n\nIn order to create our application interface we must know the functionality that GraphUI provides applications. In this section we discuss the user interface capabilities of GraphUI and in chapters 5 and 6 we discuss exactly how our application interface affords programs these capabilities.\n\nGraphUI was required to provide a graphical user interface which can be used by a variety of graph programs. A user interface is the method in which a user interacts with a program. The responsibilities of a user interface are: to manage the way input is entered by the user, to manage access to the functions of the program, and to manage the display of output presented to the user.\n\nTo provide a user interface, there are four things that GraphUI does for a graph algorithm program: obtain input, display output, animate algorithms, provide users access to the graph program's algorithms. Each of these is accomplished with a command language.\nTo ensure that GraphUI can accommodate graph programs from different domains of graph theory, it has been designed to manage only the user interface. User interface tools such as GMB [8] or EDGE [14,19] could make use of GraphUI to provide the user interface to their programs which perform automatic graph layout. GraphUI does not include graph algorithms or enforce a specific graph data structure because these depend upon the requirements of individual graph algorithms.\n\n2.5.1 Graph Information Managed by GraphUI\n\nGraph programs are able to obtain their input from GraphUI. Most graph algorithms require a graph as input but the necessary graph information differs from algorithm to algorithm. Because GraphUI is designed to work with graph algorithms from different domains, it is not possible to accurately predict all possible input requirements.\n\nTo accommodate differing input requirements, GraphUI manages graph information in the following manner. All graphs, nodes, and edges have a set of static attributes maintained by GraphUI. The attributes are composed of information commonly used in graph algorithms. In addition to the static attributes, are four general purpose attributes: two integers and two real numbers are available. These predefined general purpose attributes are used to avoid altering GraphUI to include new attributes required by a specific graph algorithm. They allow users to set and observe values of attributes that programs require unlike the attributes implementation in GMB which only give programs access to the attributes [8]. Finally if the static and general purpose attributes do not provide all of the information required by an\nalgorithm, a means of obtaining integers and real numbers directly from the user is provided.\n\nThe attributes which describe graphs, nodes and edges are as follows in Tables 2.1, 2.2, and 2.3.\n\n<table>\n<thead>\n<tr>\n<th>Attribute</th>\n<th>Definition</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Generic Integer 1</td>\n<td>a general purpose integer</td>\n</tr>\n<tr>\n<td>Generic Integer 2</td>\n<td>a general purpose integer</td>\n</tr>\n<tr>\n<td>Generic Float 1</td>\n<td>a general purpose real number</td>\n</tr>\n<tr>\n<td>Generic Float 2</td>\n<td>a general purpose real number</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.1: Definition of Graph Attributes\n\n<table>\n<thead>\n<tr>\n<th>Attribute</th>\n<th>Definition</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>probability</td>\n<td>the probability of the node</td>\n</tr>\n<tr>\n<td>label</td>\n<td>which of the attributes of the node should it be labeled with</td>\n</tr>\n<tr>\n<td>name</td>\n<td>text string representing the name of the node</td>\n</tr>\n<tr>\n<td>radius</td>\n<td>radius of the circle used to represent the node when it is displayed</td>\n</tr>\n<tr>\n<td>cost</td>\n<td>a real number cost of the node</td>\n</tr>\n<tr>\n<td>capacity</td>\n<td>a real number capacity of the node for use with flow problems</td>\n</tr>\n<tr>\n<td>weight</td>\n<td>a real number that is generally associated with the value of a particular node</td>\n</tr>\n<tr>\n<td>visited</td>\n<td>has this node been visited?</td>\n</tr>\n<tr>\n<td>source</td>\n<td>is this node a source node?</td>\n</tr>\n<tr>\n<td>target</td>\n<td>is this node a target node?</td>\n</tr>\n<tr>\n<td>Generic Integer 1</td>\n<td>a general purpose integer</td>\n</tr>\n<tr>\n<td>Generic Integer 2</td>\n<td>a general purpose integer</td>\n</tr>\n<tr>\n<td>Generic Float 1</td>\n<td>a general purpose real number</td>\n</tr>\n<tr>\n<td>Generic Float 2</td>\n<td>a general purpose real number</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.2: Definition of Node Attributes\n<table>\n<thead>\n<tr>\n<th>Attribute</th>\n<th>Definition</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>probability</td>\n<td>the probability of the edge</td>\n</tr>\n<tr>\n<td>label</td>\n<td>which of the attributes of the node should it be labeled with</td>\n</tr>\n<tr>\n<td>name</td>\n<td>text string representing the name of the edge</td>\n</tr>\n<tr>\n<td>thickness</td>\n<td>the thickness of the line used to represent the edge when it is displayed</td>\n</tr>\n<tr>\n<td>head node</td>\n<td>a reference to the head node of the edge</td>\n</tr>\n<tr>\n<td>tail node</td>\n<td>a reference to the tail node of the edge</td>\n</tr>\n<tr>\n<td>distance</td>\n<td>a real number normally used to represent the cost of travelling the edge or the length of the edge. An edge's distance does not have an affect on the length of line used to represent the edge.</td>\n</tr>\n<tr>\n<td>flow</td>\n<td>a real number capacity of the node for use with flow problems</td>\n</tr>\n<tr>\n<td>cost</td>\n<td>a real number cost of the edge</td>\n</tr>\n<tr>\n<td>capacity</td>\n<td>a real number capacity of the edge for use with flow problems</td>\n</tr>\n<tr>\n<td>is directed</td>\n<td>is this edge an arc? If it is it will be drawn with an arrow pointing to its head node</td>\n</tr>\n<tr>\n<td>Generic Integer 1</td>\n<td>a general purpose integer</td>\n</tr>\n<tr>\n<td>Generic Integer 2</td>\n<td>a general purpose integer</td>\n</tr>\n<tr>\n<td>Generic Float 1</td>\n<td>a general purpose real number</td>\n</tr>\n<tr>\n<td>Generic Float 2</td>\n<td>a general purpose real number</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.3: Definition of Edge Attributes\n\n### 2.5.2 Design of GraphUI’s Command Language\n\nGraphUI has been designed to communicate with graph programs using bi-directional channels through which blocks of data may be exchanged. These channels are used to communicate two different types of information between graph programs and GraphUI. The first type of information that is communicated are requests sent from graph programs to GraphUI. These requests are called commands and are used by graph programs to control the\noperation of GraphUI. Commands allow programs to control the display of information to users and to manage the input which is required from users. It is the command set which determines the capabilities GraphUI affords programs and as a result is fundamental to the application interface.\n\nThe second type of data that is communicated are information messages and are sent from GraphUI to graph programs. Information messages are included so programs can monitor the effect users and programs have on graphs managed by GraphUI. These messages are intended for those programs wanting to maintain up-to-date copies of the graphs open in GraphUI and those programs wishing to react to user actions or changes in the graphs displayed by GraphUI. It is possible to react to changes which are made by programs as well as those made by users thus allowing different applications to be integrated. For example it is possible for an automatic graph layout program to react to the addition of a new node from a project management program by redrawing the graph according to layout constraints.\n\nInformation messages provide programs with control similar to the control provided in EDGE and kb-edit which allow routines to be invoked when particular use actions occur [14,19]. These routines however must be added directly to the editors in order to invoke them.\n\nIt was previously noted that GraphUI provides programs with a means of obtaining input, displaying output, animating algorithms, and making a program's algorithms accessible to users. The following section discusses the types of commands included in GraphUI which enable it to manage user interface requirements of graph programs. The actual command language is found in the application interface description in Chapter 5.\nObtaining Input:\n\nInput to a graph algorithm is very often a graph. Unfortunately the structure of the graph (i.e. the manner in which nodes are connected by edges) is often not sufficient information for an algorithm to run. To allow programs to obtain the input they require, GraphUI has a command that allows a program to obtain a description of a graph, including the attributes of each component of the graph. Also included in GraphUI are commands which allow a program to directly prompt the user to enter specific information that is not contain in the attributes. The adaptable user interface tools discussed in section 1.1.3 allowed for graphs as input but made no note of providing a means for programs to obtain information that was not part of their graph data structures.\n\nThe way in which a program interprets the values of the attributes does not matter to GraphUI. Programs must be documented as to what values they expect attributes to have before and after an algorithm has run to enable users to set the attributes correctly and to interpret the output of the algorithm. GraphUI allows both users and programs to view and set the attributes values.\n\nMessages provide a different means of obtaining input. Messages inform a program when a graph has been altered. This includes any additions, deletions, node movements, selection of edges and nodes, and changes in attributes of nodes, edges, and graphs. A program can monitor these messages and keep an accurate account of the graphs displayed by GraphUI and to react appropriately to changes.\n**Displaying Output:**\n\nOutput from a graph program is often a graph data structure. To make it easier for a user to interpret output, GraphUI allows programs to display output as the pictorial representation of a graph. The user interface graph manipulation commands that were discussed in section 2.5.2 are available to programs. GraphUI's command language contains commands for creating graphs and modifying both the structure and appearance of graphs. A picture of a graph may not be sufficient to represent all the results of an algorithm. To compensate for this, GraphUI allows a program to display text to the user. A text output window provides a place for algorithms to display additional information in textual format.\n\n**Altering Graphs from Programs:**\n\nOne of the requirements of GraphUI is to allow a graph program to interactively alter a graph displayed by GraphUI while an algorithm is running. GMB allows programs to do this through state variables which can be set to particular display attributes [8]. We do this using graph editing commands of GraphUI which allow both a graph's structure and its appearance to be changed. Structure editing commands let programs add and delete edges, nodes, and graphs, and contract edges which are echoed to the user through the picture of the graph. These commands can be used to show how an algorithm is affecting a graph's structure. They may also be used to build a new graph to reflect what the algorithm is doing.\n\nThe physical attributes of nodes and edges such as size, position, and colour, black and gray, can be changed by a program through a number of commands that alter the appearance of graphs. Labels of nodes and edges can\nbe changed to new values through commands to relay information when a program runs. For example a shortest path algorithm can display the cost of reaching each node in the node’s label as it is calculated. This shows not only the cost, but the order in which each node is reached. Programs can choose to label nodes and edge with any alphanumeric string or they can label nodes and edges with any attribute of the node or edge. Allowing programs to label nodes and edges with their attributes makes it easy for programs to draw users attentions to attributes which are important to the program. Programs can also move nodes to new positions in a number of steps thereby making the movement more apparent to the user and control the placement of nodes on the display.\n\nBy supplying commands that alter the user’s picture of a graph, GraphUI provides graph programmers basic animation capabilities. Algorithm animation in itself is an expansive area of research [5]. There is no one agreed upon best way to animate an algorithm so that it is clear to a user what the algorithm is doing but it is agreed that animation aids in user comprehension.\n\n**Accessing Algorithms From GraphUI:**\n\nGraphUI provides users access to a graph program’s algorithms. To do this GraphUI provides a menu in which graph programs can post the names of their algorithms. The menu is built dynamically, permitting programs to add and remove algorithm names from the menu as they execute. When a user selects an algorithm from the menu, a message is sent to the corresponding program requesting the algorithm be run for the user.\nOnly some algorithms need a graph as input. To help manage availability of algorithms, a program is able to specify whether an algorithm requires a graph as input. If a graph is required, the algorithm is only selectable if there is a graph displayed by GraphUI.\n\n2.6 GraphUI Programming Model\n\nIn the previous sections of this chapter the manner in which GraphUI was designed to meet the design goals and to satisfy the functional requirements was described. This chapter closes with a description of the programming model used to construct GraphUI. GraphUI is logically divided into four components, a User Interface Interpreter, a GraphUI Command Interpreter, a Graph and Display Manager, and a Communication Manager, see Figure 2.8. These components together form GraphUI.\n\nThe Communication Manager is required to manage low-level communications between GraphUI and graph programs. It is responsible for receiving commands, sending replies and sending information messages. When commands are received it is the job of the Command Interpreter to process the command and perform the requested operation. The Command Interpreter was needed to translate program requests for the Graph and Display Manager.\n\nThe Graph and Display Manager controls all drawing of graphs for users and programs alike. This component is necessary to manage the appearance of the graph and its internal data structure. The User Interface Interpreter translates user interactions with the computer, such as mouse\nmovements, mouse clicks, and key presses, into display commands processed by the Graph and Display Manager.\n\nFigure 2.8: Model of the GraphUI Program\n3. Implementation of GraphUI\n\n3.1 Introduction\n\nTo make it easier to adhere to the Macintosh user interface guidelines, GraphUI was written in C++ using the MacApp® application framework. MacApp is a framework of Object Pascal code that helps to manage Macintosh programs. Since MacApp provides a frame for constructing applications, including basic window management, mouse handling, and menu management, it is difficult to describe GraphUI's implementation without elaborating on intricacies of MacApp. A thorough discussion of MacApp is beyond the scope of this thesis but several books are available on the subject [3,21]. Included in this chapter is a description of the object hierarchy used in implementing GraphUI and a discussion of some of the portions of code that were particularly difficult to implement. This chapter provides insight into the way GraphUI has been constructed without concentrating on Macintosh specific issues.\n\n3.2 Object Hierarchy\n\nSome of the objects used to build GraphUI were MacApp objects, others were subclasses of MacApp objects created to handle the specific needs of this program. Twenty five objects with a total of over three hundred methods\nwere created in the development of GraphUI. Of these classes there are a number which warrant explanation. Table 3.1 contains all of the objects in GraphUI and their superclasses. Superclasses in plain type are MacApp superclasses; those in bold are GraphUI superclasses. The objects that have an asterisk beside their entry in Table 3.1 are described in this section.\n\n<table>\n<thead>\n<tr>\n<th>Object Class</th>\n<th>Superclass</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>TObject*</td>\n<td>TObject</td>\n</tr>\n<tr>\n<td>TIcon</td>\n<td>TControl</td>\n</tr>\n<tr>\n<td>TControl</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TCommand</td>\n<td>TObject</td>\n</tr>\n<tr>\n<td>TConnection*</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TContractEdgeCommand</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TDeleteCommand</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TDragNodeCommand</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TEdgeAttrDialog</td>\n<td>TDialog</td>\n</tr>\n<tr>\n<td>TEdgeView*</td>\n<td>TGraphComponentView</td>\n</tr>\n<tr>\n<td>TDialog</td>\n<td>TDialog</td>\n</tr>\n<tr>\n<td>TGraphAttrDialog</td>\n<td>TView</td>\n</tr>\n<tr>\n<td>TGraphComponentView*</td>\n<td>TApplication</td>\n</tr>\n<tr>\n<td>TGraphUIApplication*</td>\n<td>TDocument</td>\n</tr>\n<tr>\n<td>TGraphUIDocument*</td>\n<td>TWindow</td>\n</tr>\n<tr>\n<td>TGraphUIWindow</td>\n<td>TView</td>\n</tr>\n<tr>\n<td>TGraphView*</td>\n<td>TStringText</td>\n</tr>\n<tr>\n<td>TLabel</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TMakeEdgeCommand</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TMakeNodeCommand</td>\n<td>TDialog</td>\n</tr>\n<tr>\n<td>TNodeAttrDialog</td>\n<td>TGraphComponentView</td>\n</tr>\n<tr>\n<td>TNodeView*</td>\n<td>TEditText</td>\n</tr>\n<tr>\n<td>TRealText*</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TSelectAllCommand</td>\n<td>TCommand</td>\n</tr>\n<tr>\n<td>TSelectorCommand</td>\n<td>TList</td>\n</tr>\n<tr>\n<td>TSet*</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTable 3.1 : Object Classes Within GraphUI\n\n* - Discussed in this section\n\nBold - GraphUI Superclasses\n\n34\nTGraphUIApplication : its purpose is to manage anything that the application should be able to do regardless of whether it has any documents (graphs) opened. It handles opening documents, creating documents, managing open and close of connections with other programs, acting on GraphUI commands received from connected programs, sending messages to all connected programs, and giving connections and the connection manager time to manage themselves.\n\nTGraphUIDocument : its purpose is to manage the data of a document. This management includes reading and writing documents to disk, creating the necessary views required to display a graph when it is opened, printed, or copied to the clipboard, and managing user access to commands graph editing commands.\n\nTGraphView : its purpose is to manage the display of graphs within GraphUI's windows. Management of the display includes creation of nodes and edges, selection of nodes and edges by point and area selection, and handling the user feedback when nodes are dragged. The graph view is a part of the window that contains a graph. TGraphView contains any number of subviews which are the components of the graph. Currently there are only two components, nodes and edges, implemented respectively as TNodeView and TEdgeView.\n\nTGraphComponentView : is an abstract class which is the superclass of all components of a graph. A graph component is any part of the graph that is displayed, not including labels. Currently there are two components, nodes\nand edges. If different classes of nodes and edges are implemented they should be subclasses of TGraphComponentView. TGraphComponentView handles common features of nodes and edges including determining if a node or edge has been selected by the user and what happens if a component is dragged by a user.\n\nTNodeView: its purpose is to manage a node that is displayed on the screen. It takes care of deleting and undeleting itself, managing its memory, and displaying itself as specified by a user or program.\n\nTEdgeView: its purpose is to manage an edge that is displayed on the screen. It takes care of deleting and undeleting itself, contracting and uncontracting itself, managing its memory, and displaying itself as specified by a user or program.\n\nTSet: is an extension of the MacApp TList object. Sets and lists are used to store objects that are related. A set differs from a list in that duplicate objects are not permitted in a set. Provided with TSet are the common set operations membership, union, intersection, and difference. A useful method of TSet, called MakeClassSubSet is used to create a new set containing all of its elements of a particular object class.\n\nTRealText: MacApp provides object classes to help obtain and edit user input. There is a TEditText object used to obtain text from a user. The TNumberEdit object is used to obtain an integer from a user. TRealText was created as an extension to TEditText to allow users to enter real numbers as text.\n**TAlgorithm** : its purpose is to hold information about an algorithm appearing in GraphUI's algorithm menu. The algorithm information is the name of algorithm to appear in the menu, the connection to the program which owns the algorithm, the ID of the algorithm, a flag determining if there must be a graph to run the algorithm, and a flag indicating if the algorithm name has been added to the algorithms menu. All of the algorithms displayed by GraphUI are placed into a set managed by TGraphUIApplication.\n\n**TConnection** : is an object for managing connections created with the Communications Toolbox. This object handles the low-level sending and receiving of data for GraphUI on behalf of TGraphUIApplication.\n\n### 3.3 Notable Implementation Details\n\nIn this section some of the more interesting aspects of the code are discussed. It is not meant to document the entire system; rather to discuss some of the novel parts of the code.\n\n#### 3.3.1 Communications\n\nLow-level communications are implemented with TConnection objects. To understand the workings of connection objects we must look at the physical means used by GraphUI to communicate with other programs.\nThe Macintosh Communication Toolbox Connection Manager [2] allows programs to be written independent of how computers are connected. Communication is through abstract connections called channels which provide bi-directional data streams. Programs manage reading from and writing to channels and the connection manager uses connection tools to transmit data between the two ends of a connection. The Communications Toolbox provides three standard connection tools: a modem connection tool, a serial connection tool, and an AppleTalk ADSP connection tool. Facilities are provided to help write customized tools to work with the Communications Toolbox. GraphUI maintains one connection for each program with which it communicates. Each connection is managed by a separate TConnection object. All of the open connections are stored in a set of active connections stored as an instance variable of the application. When a connection is closed by either GraphUI or the program on the other end, it is removed from the set of active connections. New connections are always added to the set. Each time through GraphUI's main event loop it tests for newly opened and newly closed connections. Processing time is provided for each connection allowing it to manage itself.\n\nReading from and writing to connections is done asynchronously by the TConnection object. This object sends replies and messages for GraphUI and receives commands from connected graph programs. When it receives a command, the command is passed to a TGraphUIApplication method, called ExecuteCommand, for processing.\n3.3.2 Point Object Selection\n\nPoint selection is done by moving the cursor over a graph component and clicking. To make it easier to determine if a mouse click in the graph view is on a graph component, TGraphComponentView uses a method called IsPointOnView. This method is passed a mouse position and returns true if the mouse is in the view.\n\nThe default IsPointOnView method returns true if the mouse point is within the extent of the view. This default is used for nodes because nodes occupy most of their extent, see Figure 3.1. Edges must use a different technique because simply being within the extent is not accurate enough, see Figure 3.2. The method that is used is taken from \"C++ Programming With MacApp\" [21].\n\nThe IsPointOnView method of an edge, draws the edge in off screen memory to determine if the current mouse position is on the edge. If the pixel corresponding to the mouse position is set in memory, the edge has been selected. To make it easier to hit thin edges with the mouse, edges with thickness less than 4 are drawn with thickness 4.\n3.3.3 Dragging Nodes\n\nThe method GraphUI uses to drag nodes deviates from the way which is recommended by the user interface guidelines. The user interface guidelines suggest that an object be dragged by leaving the object where it is and moving around a gray rectangle of the area the object occupies. This was not seen as satisfactory because when a node moves, the edges attached to the node must move. Nodes are usually moved to reposition the graph and make it look better. To make it easier to reposition the graph, a node and its edges are dragged, not an outline of the affected area.\n\n3.3.4 Drawing Edges\n\nMost of the drawing in GraphUI is straightforward; circles are used to represent nodes and edges are represented as lines. The challenge comes when drawing the bent lines that are used to represent multiple edges connecting a single pair of nodes.\n\nThe ideal way to draw the bent lines used to represent multiple edges between a pair of nodes, such as those in Figure 3.3 is as follows. Compute the midpoint of the straight line connecting the head and tail nodes of the edge. Compute a point \\((x,y)\\) from which a straight line connecting \\((x,y)\\) and the midpoint is perpendicular to the straight line and has a fixed length \\(l\\), see Figure 3.4. To draw the bent edge, draw a line from the head node to \\((x,y)\\) and a line from \\((x,y)\\) to the tail node. When drawing more than two edges between the same pair of nodes, \\(l\\) is made positive and negative to bend the\nlines on either side of the edge, and $l$ is increased by a fixed amount, see Figure 3.5.\n\n\n\n\n\n\n\nThere was a practical problem with using this method. In order to compute $(x, y)$, the bendpoint, the following equation had to be solved:\n\n$$l = \\sqrt{(x \\text{ coord of midpoint} - x)^2 + (y \\text{ coord of midpoint} - y)^2}$$\n\nSince $l$ is known, $y$ or $x$ can easily be computed by fixing the other. When a node is dragged by the user, the edges connected to the node are redrawn many times. Unfortunately the square root calculation is slow. When a node is dragged the recalculations of the bendpoints slows the feedback of the dragging so much that the redrawing cannot keep up with the user.\nAs a practical solution to the problem of drawing bent edges, the following approach is taken in GraphUI. The calculation of \\((x,y)\\) is approximated. The first step computes the slope and the midpoint of the straight line from the head to the tail node. If the line has a slope of between -0.5 and 0.5, the bend point is computed by adding a constant amount to the y coordinate of the midpoint, thus raising the bendpoint directly above the line, see Figure 3.6. If the slope of the line is greater than 2.0 or less than -2.0, the bend point is computed by subtracting a constant amount from the x coordinate of the midpoint, thus moving the bendpoint directly to the left, see Figure 3.6. If the slope of the line is between 0.5 and 2.0, the bendpoint is computed by subtracting a constant amount from the x coordinate of the midpoint and adding a constant amount to the y coordinate of the midpoint, see Figure 3.6. This moves the bendpoint counter clockwise from the midpoint, above and to the left of the line. Finally, if the slope of the line is between -2.0 and -0.5, the bendpoint is computed by adding a constant amount to the x coordinate of the midpoint and adding a constant amount from the y coordinate of the midpoint, see Figure 3.6. This moves the bendpoint counter clockwise from the midpoint, above and to the right of the line. See also Figures 3.7.\nFigure 3.6: Computing the Bendpoint of Bent Edges\n\nif \\(-0.5 < \\text{slope} < 0.5\\) then the bend point is \n\\(\\text{midPoint.h} + 0, \\text{midPoint.v} + \\text{Amount to bend by}\\)\n\nif \\(0.5 < \\text{slope} < 2\\) then the bend point is \n\\(\\text{midPoint.h} - \\text{Amount to bend by}, \\text{midPoint.v} + \\text{Amount to bend b}\\)\n\nif \\(2 < \\text{slope} \\land \\text{slope} < -2\\) then the bend point is \n\\(\\text{midPoint.h} - \\text{Amount to bend by}, \\text{midPoint.v} + 0\\)\n\nif \\(-2 < \\text{slope} < -0.5\\) then the bend point is \n\\(\\text{midPoint.h} + \\text{Amount to bend by}, \\text{midPoint.v} + \\text{Amount to bend b}\\)\n\nFigure 3.7: Algorithm Used to Determine the Bend Point of an Edge\nThe constant amount that an edge is bent is altered from a positive to a negative number to make the edges bend on either side of the straight line connecting the head node and the tail node and is increased to move additional edges farther and farther from the midpoint, see figure 3.5.\n\n3.3.5 Building the Algorithms Menu\n\nThe algorithms menu is altered dynamically when programs want algorithms added or removed from the menu. The menu is rebuilt in the DoSetupMenus method of TGraphUIApplication. In DoSetupMenus, the algorithms menu is reset, removing all of the menu items from the menu. In resetting the menu, each algorithm in the set of registered algorithms has its fAddedToMenu flag assigned false to indicate that it has not been added to the menu. Next each algorithm in the set of registered algorithms is added to the menu. The menu item number which is the number passed to DoMenuCommand when the user selects the algorithm, is computed. Each menu item is enabled or disabled depending on its need for a graph and if there is one active.\n\nThe interesting calculation is that of the menu item number for each of the menu entries. A menu item number is the menu number multiplied by 256 plus the position at which the item was placed in the menu. The menu is set up each time an algorithm is added or deleted by a program. What follows is the section of code for building the menu from the set of registered menus.\n\n```cpp\n// if there are any algorithm names to be displayed, enable and setup the menu\nif ((fAlgorithms->GetSize() > 0) |\n aMenuHandle = MACGetMenu(mAlgorithms); // get reference to the algorithms menu\nEnableItem(aMenuHandle, THE_MENU); // enable the menu\n```\n// for each algorithm name to be displayed, compute its menu item number\nfor (int i = 1; i <= fAlgorithms->GetSize(); i++) {\n anAlgorithm = (TAlgorithm *)fAlgorithms->At(i);\n\n if (!anAlgorithm->fAddedToMenu) { // has the algorithm been added yet?\n anAlgorithm->fAddedToMenu = TRUE; // if it has not, add it.\n anAlgorithm->Lock(TRUE);\npstrcpy(aName, anAlgorithm->fName);\nanAlgorithm->Lock(FALSE);\n AppendMenu(aMenuHandle,aName); // adds the name to the menu\n anAlgorithm->fAlgorithmNumber = -(mAlgorithms*256 + i); // ** menu item number\n } // if (!anAlgorithm->fAddedToMenu)\n\n if (anAlgorithm->fNeedsGraph) {\n if (the active window is a graph)\n EnableItem(aMenuHandle, i); // enable the menu item - there is a graph\n } else { // there are no graphs, don't enable the algorithm\n DisableItem(aMenuHandle, i); // disable the menu item - there is no graph\n } // else\n\n} else { // does not need the graph so enable the item\n EnableItem(aMenuHandle, i);\n}\n\n} // for (int i = 1; i <= fAlgorithms->GetSize(); i++)\n\n} // if (fAlgorithms->GetSize() > 0)\n4. Use: Interface\n\nGraphUI can be used by both people and programs. Although both can use GraphUI to perform similar tasks, the interaction with GraphUI is different. Programs use our application interface to interact with GraphUI while people use the keyboard and mouse.\n\nThis chapter explores how GraphUI is used by a user. It is assumed that the reader is familiar with using Macintosh programs and a number of Macintosh conventions such as dragging and resizing windows are not discussed. The chapter is divided into sections describing how to use GraphUI with respect to building and modifying graphs, printing and copying to other types of documents, and accessing graph programs from GraphUI.\n\nAlthough the user interface is not part of the research problem addressed by this thesis, we feel it is necessary to include a description of the user interface to provide readers with a clear understanding of the interaction between GraphUI and application programs by showing how a user uses GraphUI to access other programs.\n\n4.1 Creating Graphs\n\nWhen GraphUI is launched a window similar to the one in Figure 4.1 is opened. The palette that appears down the left side of the window is used to control the action taken when the mouse is pressed in the graph view.\nThere are three icons which from top to bottom are: pointer, node, and edge. The icon which is active is drawn in white with a black background - the others appear in black with a white background. There can only be one icon active at a time. To make an icon active, press the mouse over the corresponding icon.\n\n\n\nFigure 4.1: Empty GraphUI Window\n\nWhen the pointer icon is active, nodes and edges can be selected. When the node icon is active, nodes can be created, and when the edge icon is\nactive edges can be created. When the pointer, node, or edge icon is active, GraphUI is respectively in pointer mode, node creation mode, or edge creation mode.\n\nThe area that appears to the right of the palette is the graph view in which graphs are drawn. This is referred to as simply the graph. The scroll bars that are along the right and bottom of this window are used to position the graph. The window is similar to many Macintosh windows with a document title, close box, zoom box and resize box.\n\nCreating Nodes\n\nTo create a node in the graph, enter node creation mode by selecting the node icon from the palette. Position the cursor at the point in the graph to place the node and press the mouse button. This will create a node centered at the mouse position. Figure 4.2 shows a graph with one node. The number appearing just below the node is its unique ID. This label may be altered to show different information about the node. Node labels are described in detail in section 4.3. The create node operation can be undone by selecting Undo from the Edit Menu before another undoable command is issued. Once undone, the node can be brought back by selecting Redo from the Edit Menu.\nCreating Edges\n\nEdges are created while in edge creation mode. An edge is created by positioning the mouse over the tail node of the edge and pressing the mouse button. With the mouse pressed, move the mouse so that it is positioned over the desired head node and release the mouse button. Figure 4.3 shows an edge as it is being created; Figure 4.4 shows the finished edge whose tail node has ID = 1 and head node ID = 2. The number which appears just below the middle of the edge is its label displaying the ID of the edge. This label can be changed to show different information about the edge and is described in detail in section 4.3. Multiple edges between a pair of nodes are \"bent\" so that all edges are visible, see Figure 4.5. The create edge operation is undoable from the Edit Menu.\nFigure 4.3: What the User Sees when Creating an Edge\n\nFigure 4.4: GraphUI's Representation of an Edge\n\nFigure 4.5: Multiple Edges Between a Pair of Nodes\nCompleting Graphs\n\nTo make it easier to create graphs, a method for completing a graph has been provided. A complete graph is a graph in which there is an edge between every pair of nodes. To complete the graph shown in Figure 4.6, select the Complete Graph command from the Edit menu of GraphUI. Figure 4.7 shows the resulting complete graph. Please note that this command completes a graph as if it were undirected; if the graph is considered directed, additional edges must be added manually.\n\nFigure 4.6: Completing a Graph\nSaving and Closing Graphs\n\nOnce a graph has been created it can be saved in a GraphUI document for later use. To save a graph, use the Save or Save As command in the File Menu. These commands open a Macintosh Standard File Save Dialog for saving the Document. Notice that once a graph has been saved, the name in the title bar changes to the name of the document the graph was stored in. When a graph is closed or GraphUI is terminated, the user able to save any graph which has been altered since it was last saved. A graph is closed by clicking on the close box or selecting the Close command from the File Menu. GraphUI is terminated by selecting Quit from the File Menu.\nOpening Graphs\n\nOpening a previously saved graph can be done in two ways. A graph will be opened and GraphUI launched if a GraphUI document is double clicked with the mouse from the Finder or the MultiFinder. To open a graph once GraphUI is running, select the Open command from the File Menu. This brings up a Macintosh Standard File Open Dialog box. An empty graph such as the one in Figure 4.1 is opened when GraphUI is launched without a document and when New is selected from the File Menu.\n\n4.2 Modifying Graphs\n\nOnce a graph has been created, it is often necessary to edit it. The structure of a graph can be changed by adding nodes, deleting nodes, adding edges, and deleting edges. Nodes can be repositioned in the graph, not affecting the graph's structure, only its appearance. This section describes the ways that GraphUI allows a user to modify the structure of a graph. It also details how to alter the graph's appearance by moving nodes and edges and how to select nodes and edges of a graph.\n\nSelecting nodes and edges change their appearance and indicate which nodes and/or edges commands are to be operated on. The standard cut, copy and paste commands can also be used to modify a graph. These commands are included in the description of clipboard support found in section 4.5.\nSelecting Nodes and Edges\n\nThe nodes and edges of a graph must be selected to indicate which components a particular operation is to be performed on. Any number of nodes and edges may be selected at the same time. To show that a particular node or edge is selected, it is drawn in gray rather than black and its label is written in italics. The set of selected nodes and edges is called the selection set. There are two methods provided in GraphUI for selecting nodes and edges, range selection and point selection. Both selection methods require GraphUI be in pointer mode.\n\nPoint selection is the simplest method of selection: a node or edge is selected by clicking on it. Clicking on the label of a node or edge does not select it. Range selection is done by selecting any node or edge completely enclosed in an area specified with the mouse. To specify the area, click the mouse at one corner of the area and drag the mouse to the opposite corner of the area. The enclosing area is shown by a rectangle that appears as the mouse is dragged. Any node or edge that is completely within the rectangle is selected. Figure 4.8 shows an example of range selection.\n\nThe selection set may be altered to add or remove nodes and edges. Clicking on a node or edge with the shift key pressed reverses its selection state, selecting it if it was not selected and unselecting it if it was selected. Using the shift key in conjunction with range selection toggles the selection state of each node or edge within the selected area.\nFigure 4.8a: The Feedback Displayed While a User Makes a Selection\n\nFigure 4.8b: The Selection Set Created in Figure 4.8a\nRepositioning Nodes\n\nGraphUI must be in pointer mode to reposition nodes. To move a single node, click the mouse on the node and with the mouse button down drag the node to its new position and release the mouse button. As the node is being dragged, all of the edges attached to the node are moved. Neither node nor edge labels are shown while the node is dragged but reappear once the move is complete.\n\nIf nodes or edges were selected and the node being dragged is not selected, the selected items are unselected before the drag operation begins. If the node that is being dragged is selected and there are other selected nodes, all of the selected nodes are moved. The nodes that are selected move relative to the node being dragged, so that they remain the same distance from the dragged node. If the shift key is pressed at the start of the drag operation, its action is applied before the drag begins. This means that if the node was selected, it is unselected first and then dragged, resulting in it being the only node moved. An unselected node is selected first and then it and any other selected nodes are moved.\n\nIf the repositioning was not satisfactory, the operation can be undone by selecting Undo from the edit menu.\n\nDeleting Nodes and Edges\n\nDeleting a node removes not only the node but all edges connected to the node because an edge cannot exist without both its head and tail nodes. Deleting an edge only removes the edge. To delete both nodes and edges from a graph, select the nodes and edges to be deleted and press the delete or backspace key or select Clear from the Edit Menu. To delete only selected\nnodes, issue the Delete Node(s) command from the Edit Menu and to delete only selected edges, issue the Delete Edge(s) command from the Edit Menu.\n\n**Contracting Edges**\n\nThe Contract Edge(s) command in the Edit Menu is used to contract selected edges. If one edge is selected, it is contracted by dragging the tail node so that it is on top of the head node in six steps to animate the drag, deleting all edges that connect the head node to the tail node, moving all of the tail node's remaining edges to the head node, and deleting the tail node. When the contract is undone, the uncontract operation is done in the reverse order of the contract. If multiple edges are selected, each edge is contracted in the order they were selected starting with the first selected edge. If one of the selected edges is deleted as a result of a previous contraction, it is ignored by the contract operation. Undoing a contract with several edges, uncontracts the edges in the reverse order they were contracted in. Figure 4.9a and 4.9b shows a graph before and after edge 4 is contracted.\nFigure 4.9a: Graph Before Edge 4 is Contracted\n\nFigure 4.9b: Graph After Edge 4 is Contracted\n4.3 Displaying and Setting Attributes of Graphs\n\nThe structure of a graph is described by the way nodes are connected by edges. Algorithms which require graphs as input often require more than structural information. Information specific to a graph, a node or an edge is managed by GraphUI through sets of attributes. This information can be accessed from programs using GraphUI.\n\nThe following describes how information can be viewed and modified by a user, enabling a user to enter input and view output from algorithms. A complete discussion of the information managed by GraphUI for graphs, nodes and edges is found in Chapter 2. The information is saved when a graph is saved and does not get reset when graphs are opened unless the user specifically changes the values.\n\nGraph Attributes\n\nThe information about a specific graph is called the graph's attributes. The attributes of a graph are initialized from a set of default graph attributes when a new graph is created. The default values for new graphs can be set by selecting the Default Graph Values command from the Info Menu. This command opens a change graph attributes window as in Figure 4.10.\n\nFrom a change graph attributes window any of the attributes can be altered by selecting the attribute and entering the new value. The four graph attributes are general purpose variables. To provide a more accurate description of what the attribute is used for, the labels of these four attributes can be changed by selecting the text of the label and typing a new name. Once\nthe attributes have been set to the correct values, clicking OK sets the default graph attributes to the values of the attributes in the window, clicking CANCEL leaves the default graph attributes as they were before the window was opened.\n\n\n\nFigure 4.10 : Change Graph Attributes Window\n\nTo set the attributes of a specific graph, make the window containing the graph the active window, ensure that there are no selected edges or nodes in the graph, and select Get Info from the Info Menu. This opens a change graph attributes window which contains the values of the attributes of the active graph. The attribute values are set as they were for default attributes.\n\nTo set the value of some of the attributes for every open graph to the same value, the Set Value For All Graphs menu item can be used. With this command if the window is closed with the OK button, only those attributes and labels whose values were changed between opening and closing the window are affected.\n**Node Attributes**\n\nA *change node attributes* window is used to alter the attributes of particular nodes and default node values. Figure 4.11 shows a change node attributes window. Attributes are changed if the window is closed with the OK button and not changed if the window is closed with the Cancel button.\n\nThe majority of attributes are changed by selecting the current value and typing in a new value. The exceptions to this are the visited, source, target and label attributes. The visited, source and target attributes are changed by clicking in the box beside the name of the attribute or directly on the name. This toggles the value between TRUE, indicated with an X in the box, and FALSE, indicated by an empty box.\n\nThe label attribute is used to determine what, if any, attribute to label the node with. This attribute is set by pressing the mouse on the word label, positioning the mouse so that the desired label value is highlighted and releasing the mouse. The Integer 1 and 2 and the Float 1 and 2 attributes may have their labels changed to reflect the value they represent.\nTo set the attributes of an individual node or a number of nodes, select the nodes to be affected, and select Get Info from the Info Menu. This presents, beginning with the first selected node, a change node attributes window for each of the selected nodes. The ID of the node appears in the title of the window to help distinguish which node the window represents.\n\nTo change some of the attributes for every node in a graph to the same value, select the Set Value For All Nodes command from the Info Menu. This command sets only those attributes whose values are different after the window is closed and it sets those changed values for every node in the active graph.\nEach graph has a set of default attributes that nodes are assigned when they are created. To alter the default node attributes for a particular graph, make the graph the active window, select Default Node Values from the Info Menu and set the attributes to their desired values. The default node attributes are saved with the graph.\n\n**Edge Attributes**\n\nA *change edge attributes* window is used to alter the attributes of edges and default edge values. Figure 4.12 shows a change edge attributes window. Attributes are changed if the window is closed with the OK button and not changed if the window is closed with the Cancel button. Most of the attributes are changed by selecting the current value and typing in a new value. The exceptions to this are the isDirected and Label attributes.\n\nThe isDirected attribute is changed by clicking in the box beside the word Directed? or directly on the word Directed?. This toggles the value of isDirected between TRUE, indicated with an X in the box, and FALSE, indicated by an empty box. The Label attribute is used to determine what, if any, attribute to label the edge with. This attribute is set by pressing the mouse on the word Label and positioning the mouse so the desired label value is highlighted and releasing the mouse. The Integer 1 and 2 and the Float 1 and 2 attributes can have their labels changed to reflect the value they represent.\nFigure 4.12: Change Edge Attributes Window\n\nTo set the attributes of an individual edge or a number of edges, select the edges and choose Get Info from the Info Menu. This presents, beginning with the first selected edge, a change edge attributes window for each of the selected edges. The ID of the edge appears in the title of the window to help distinguish which edge the attributes window represents.\n\nTo change some of the attributes for every edge in a graph to the same value, select Set Value For All Edges from the Info Menu. This command sets only those attributes whose values are different after the window is closed, and it sets those changed values for every edge in the active graph.\n\nEach graph has a set of default attribute values that edges are assigned when they are created. To alter the default edge attributes for a particular\ngraph, make the graph the active window, select Default Edge Values from\nthe Info Menu, and set the attributes to their desired values. The default edge\nattributes are saved with a graph.\n\n4.4 Printing From GraphUI\n\nA graph created with GraphUI can be printed from the Finder and from\nwithin GraphUI. To print a graph from finder, select the document\ncontaining the graph and choose Print from the Finder’s File Menu. This\nprints the graph to the default printer.\n\nTo set up for different types of printing from within GraphUI use the\nPage Setup in the File Menu. The values that can be set with this command\nare dependent upon the default printer selected with Chooser. Generally, the\nquality of print and the orientation of the page can be specified and any\nreduction/enlargements permitted by the printer. Figure 4.13 shows the page\nset up when using a LaserWriter printer.\n\n\n\nFigure 4.13 : Page Setup for LaserWriter\nThere are two methods of printing a graph from within GraphUI. Both methods require the window containing the graph be the active window. The first method is to select Print One from the File Menu. This prints the graph according to the options specified in Page Setup. The second method is to use the Print ... command from the File Menu which manages a number of preferences depending upon the printer (e.g. the number of copies and the portion of the graph to be printed).\n\nA graph larger than a single page is printed on multiple pages. The pages of a graph are printed so that they can be pasted together to form a rectangle containing the entire graph.\n\nThe Applications' Transcript window which is described in section 4.6 can also be printed by making it the active window and selecting the Print One or the Print ... command.\n\n4.5 Clipboard Support\n\nFull clipboard support of cut, copy and paste are included in GraphUI. The copy command duplicates each selected node and edge, and removes all extra space around this copied subgraph. In order for an edge to exist, it must have a head and tail node; thus if the head or tail node of a selected edge is not selected, it is still copied to the clipboard. Figure 4.14a and 4.14b show a graph with a selection and the resulting subgraph copied to the clipboard.\n\nThe cut command is similar to the copy command except every selected node and edge is deleted from the graph once it has been copied. Figure 4.14c shows what is left of the graph in Figure 4.14a after a Cut\ncommand. If the head or tail node of a selected edge is not selected, the node remains in the graph. All edges of a selected node are deleted when the node is cut from the graph.\n\nThe paste command pastes any subgraph in the clipboard into the active graph. The top left corner of the subgraph is pasted into the center of the active graph. The entire subgraph is selected so it is easy to reposition the nodes and edges pasted into the graph.\n\nWhen a graph is pasted into a drawing package the individual components of the graph (nodes, edges and labels) are editable. Nodes are simply filled ovals, edges are lines and labels are text. It is easier to edit the location of nodes and their edges using GraphUI. A drawing package is useful for adding extra text to the graph and repositioning node and edge labels. Once a graph has been edited in a drawing package, it cannot be pasted into a GraphUI graph.\n\n\n\nFigure 4.14a : Graph to be Copied/Cut\n\n67\nEntire graphs can be copied to the clipboard with Copy Graph so they can be pasted directly into a document such as a report. Unlike the Copy and Cut commands, Copy Graph copies the entire graph, not just the selected portion. Nodes and edges that were selected when the graph was copied, remain gray. The Copy Graph command allows selection information that may have been used in animating an algorithm to be preserved when copied into documents. To copy the active graph, select Copy Graph from the Edit Menu. This gets rid of extra white space around the graph making it fit into\nas small a rectangle as possible. Graphs which have been copied into the\nclipboard with the Copy Graph command can be pasted directly into a graph\ncreated with GraphUI.\n\nThe Applications’ Transcript, described in the following section, can\nalso be copied to the clipboard and pasted into other documents as text. This\nis done by making the transcript active, selecting the desired text, and issuing\nthe Copy command from the Edit Menu. The Show Clipboard command in\nthe Edit Menu displays the contents of the clipboard.\n\n4.6 Connecting to and Using Graph Applications\n\nGraphUI alone provides a useful graph editor for drawing graphs.\nConnecting GraphUI to applications that perform algorithms on graphs,\nallows it to become the user interface to the graph program. Chapter 5\ndescribes in detail the application interface used to gain access to GraphUI\nfrom a program. This section describes how a user gains access to an\napplication using GraphUI as its user interface. The instructions for running\nan application’s algorithms will differ and must be provided with the\ndocumentation of the application.\n\nCreating A Connection\n\nThe name supplied by a graph algorithms program and the connection\ntool required to connect to the program must be known to connect GraphUI\nto the graph algorithms program. This information should be provided in the\ninstructions for running the program. For now, consider only that there is at\nleast one graph program which uses GraphUI running somewhere that can be accessed by a Communications Toolbox connection and that GraphUI is running.\n\nBefore establishing a connection between GraphUI and a graph application, the Communications Toolbox Connection Manager must know how to connect to the application. The Connection Settings command in the Comm Menu is used to set the type of connection being made. The default connection type is the AppleTalk ADSP tool which can connect GraphUI to another application on the same computer or a different computer on the same AppleTalk network.\n\nClicking on the Method field in the connection settings window provides a list of all possible connection types. Select the type which is appropriate for the application and make certain the connection parameters in the window are set correctly. Figure 4.15 shows an AppleTalk connection being set with the local name of the connection set to GraphUI. The values for each of the different connection tools are described in the Macintosh® Communications Toolbox Manual [2].\n\nEach connection created between an application and GraphUI has two ends. One of the ends waits for a connection and the other opens to a waiting connection. If the application is waiting to be connected to, set up the connection and issue an Open Connection command from the Comm Menu. If the application wants to open a connection to a waiting GraphUI, set up the connection settings for the type of connection required and select Wait for Connection from the Comm Menu. Wait for Connection will wait until another program does an open to it or the connection is closed.\nOnce one connection has been established, additional connections can be created in the same way.\n\n\n\n**Figure 4.15: AppleTalk ADSP Tool Connection Settings**\n\n**Closing a Connection**\n\nConnections are closed in the order they were opened. The first connection opened is the first connection closed. A connection can be closed from either end. To close the oldest connection from GraphUI, select the Close Connection command from the Comm Menu. Connections closed from an application are disposed of by GraphUI.\nExecuting an Algorithm of a Graph Program\n\nApplications connected to GraphUI can add menu items to GraphUI’s Algorithms Menu. If an application permits execution of any of its algorithms from GraphUI directly, the names of the available algorithms will appear in the Algorithms Menu. Algorithms which do not require a graph as input are always available, algorithms that require a graph as input are not available unless the active window contains a graph. What happens once an algorithm has been selected from the Algorithms Menu is determined by the application program and the specific algorithm.\n\nConnected applications can request information from a user through GraphUI. They can request an integer value or a real number. These requests are presented in a modal dialog box. The request will have a message describing the data to be provided. Simply enter the requested value and press OK. If the value is not acceptable, an error message will be displayed. The window will not close until an acceptable value has been entered.\n\nThe Applications’ Transcript Window\n\nThe Applications’ Transcript window is a window into which text may be written on behalf of a connected application. Each time an application writes to the window, the window is opened if it is not already open. The window can be opened at any time by selecting Open Transcript from the File Menu. The window can be closed with the close box of the window, the Close Transcript command from the File Menu, and, if the transcript is the active window, with the Close command.\n\nText may be entered and edited using standard text editing techniques and cut, copy and paste to and from the clipboard. Regardless of the cursor\nposition, text from an application is added to the end of the text in the window.\n\nThis window can be printed with the Print One and Print command but the contents cannot be saved; thus text to be kept should be printed or copied to the clipboard and pasted into a word processing document. Figure 4.16 shows the contents of the transcript window after executing the shortest path algorithm described in Chapter 6.\n\n| Starting Shortest Path Algorithm --- |\n| Finished Shortest Path Algorithm --- |\n\nFigure 4.16 : Applications’ Transcript After Running Shortest Path\n5. Application Interface\n\nMessage passing is the basis of our application interface to GraphUI. It is used to send information between GraphUI and graph programs. A message is a sequence of bytes that can be sent and received. Message passing enables GraphUI to be used from a separate running program. The message set describes the application interface to GraphUI.\n\nFor now let us consider the format of messages. Each message has a start of message character, a length byte, an opcode and additional information (if any) required for the command contained in the message, Figure 5.1. The start of message character is a single byte with value 0X02. The length field, an unsigned long (8 bytes), is the number of bytes in the message not including the start of message character or the length field. These are followed by a 4 byte opcode describing the contents of the message.\n\nThere are three different types of messages: commands, replies, and information messages. Commands are sent to GraphUI to be acted upon, replies are sent by GraphUI in response to a command and information messages are sent from GraphUI to inform programs that a graph has been altered.\n\n<table>\n<thead>\n<tr>\n<th>STX</th>\n<th>Length</th>\n<th>Opcode</th>\n<th>(Additional Info)</th>\n</tr>\n</thead>\n</table>\n\nFigure 5.1: Format of All GraphUI Messages\n\n74\nMany of the messages refer to graph, node and edge IDs. IDs are integer values that distinguish individual graphs, and nodes and edges within a graph. All graphs have a unique ID. Every edge in a graph has a different ID from every other edge and every node has an ID which is different from every other node in the graph. To identify a node, both the node ID and the graph ID are required. To identify an edge, both the edge ID and the graph ID are required.\n\nThe next two sections in this chapter describe the command set and the set of information messages. They assume that the start of message and length fields are included in the message and describe the opcode and the additional information in the message. There is not one fixed method for using commands and messages. Programs can choose to act on or ignore any information sent to them by GraphUI. Some suggestions are made at the end of the chapter to help with algorithm animation and methods of using information sent by GraphUI.\n\n5.1 GraphUI Commands\n\nMessages sent to GraphUI are called commands. Each command has a reply which is a message sent from GraphUI to the program that sent the command. Commands enable a program to use GraphUI to perform tasks similar to those a user can do directly from GraphUI, such as create and modify graphs. Each reply has an opcode and an error code.\nThe value of the opcode of each reply is the same as the opcode of the command it responds to. The error code tells the program if GraphUI was able to execute its last command. The values of the opcodes, error codes, and the data types used to describe the format of commands, replies and information messages are included in Appendix A.\n\nA number of errorCodes may be returned in response to any command. BAD_OPCODE is returned if the opcode specified in the command is not a valid command opcode. BAD_COMMAND_SIZE is returned if the size of the command received does not match the size expected for the command. The NO_COMMAND error code is returned if the command’s length field is zero. Finally if the command was received and executed without problem, NO_ERROR is returned as the errorCode. Other error codes returned for specific commands are documented for each command.\n\n5.1.1 Creation Commands\n\nCreation commands are used to build new graphs and to add nodes and edges to a graph. When a new graph, node or edge is created, the reply to the command includes the ID to be used to refer to the graph, node or edge in subsequent commands. This ID must be used to reference a graph, node or edge in subsequent commands.\n\nCreating New Graphs\n\nTo create a new graph which, in effect, opens a new untitled window like the one in Figure 4.1, the add graph command is used. This command\ncreates a new graph which receives the default graph attributes as set in GraphUI. The add graph command and its reply have the following formats:\n\ndefine struct {\n OpType opcode;\n AddGraphCmd;\n}\ndefine struct {\n OpType opcode;\n ErrorCodeType errorCode;\n GraphIDType graphID;\n AddGraphReply;\n}\n\nWhere:\nopcode - ADD_GRAPH\n\ngraphID - the numeric ID of the graph that was created.\n\nPossible errorCodes:\nNACK - if a window could not be opened.\n\nCreating New Nodes\n\nA new node is added to a graph with the add node command. A node cannot be added to a graph that does not exist. When a new node is created, its attributes are set to the default node attributes of the graph it is added to.\nThe following structures describe the format of the add node command and its reply:\n\ndefine struct {\n OpType opcode;\n GraphIDType graphID;\n NodeLocationType location;\n AddNodeCmd;\n}\ndefine struct {\n OpType opcode;\n ErrorCodeType errorCode;\n NodeIDType nodeId;\n AddNodeReply;\n\n77\nWhere:\n\nopcode - ADD_NODE\ngraphID - the ID of the graph to add the node to\nlocation - the X, Y coordinate in the graph view to position the center of the node at. If this value is (0, 0), the node is placed at a random location within the visible portion of the graph view.\nnodeID - the numeric ID of the node that was created\n\nPossible error codes:\nBAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\nNACK - an unexpected error occurred.\n\nCreating New Edges\n\nThe add edge command is used to add an edge to a graph. An edge cannot be added to a graph that does not exist. The edge must have a head and tail node in the graph. The following structures describe the format of the add edge command and its reply:\n\ntypedef struct {\n OpCode\n GraphIDType\n NodeIDType\n AddEdgeCmd;\n}\n\ntypedef struct {\n OpCode\n ErrorCodeType\n EdgeIDType\n AddEdgeReply;\n}\n\nWhere:\n\nopcode - ADD_EDGE\ngraphID - the ID of the graph to add the edge to\nheadNode - the ID of the head node of the edge\ntailNode - the ID of the tail node of the edge\nedgeID - the numeric ID of the edge that was created\n\nPossible error codes are:\nBAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\nBAD_NODE_ID - the ID specified for the head or tail node did not exist.\nNACK - an unexpected error occurred.\n5.1.2 Modification Commands\n\nModification commands are used to alter the appearance and/or the structure of graphs.\n\nDeleting / Closing Graphs\n\nTo close an open graph in GraphUI, the delete graph command is provided. The delete graph command closes a graph and lets the user save the graph if changes have been made since it was last saved. The following is the format of the delete graph command and its reply.\n\n```c\ntypedef struct {\n Opcode opcode;\n GraphIDType graphID;\n }DeleteGraphCmd;\n```\n\n```c\ntypedef struct {\n Opcode opcode;\n ErrorCodeType errorCode;\n }DeleteGraphReply;\n```\n\nWhere:\n- `opcode` - `DELETE_GRAPH`\n- `graphID` - the ID of the graph to be deleted\n\nPossible errorCodes are:\n- `BAD_GRAPH_ID` - the graphID specified did not match one of the open graphs.\n- `NACK` - an unexpected error occurred.\n\nMoving Nodes\n\nA node is moved to a new location within a graph with the move node command. This command animates the move if the number of steps to move the node is greater than 1. The location specified is the position to\nplace the center of the node in the graph. When a node is moved its edges are adjusted to the new position. The format of the command and its reply are as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n NodeIDType nodeID;\n NodeLocationType location;\n StepsType steps;\n} MoveNodeCmd;\n```\n\n```c\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n} MoveNodeReply;\n```\n\nWhere:\n- **opcode** - MOVE_NODE\n- **graphID** - the ID of the graph containing the node to be moved.\n- **nodeID** - the ID of the node to be moved.\n- **location** - the new X, Y coordinate for the center of the node\n- **steps** - the number of steps to perform the move in. For each step the node is moved 1/steps of the way to the new position so it appears the node is being dragged to the new location.\n\nPossible errorCodes are:\n- **BAD_GRAPH_ID** - the graphID specified did not match one of the open graphs.\n- **BAD_NODE_ID** - the node ID specified was not in the graph.\n- **NACK** - an unexpected error occurred.\n\n**Deleting Nodes**\n\nA node is deleted from a graph with the delete node command. Deleting a node also deletes any edge connected to it. Once a node and its edges have been deleted from a graph, their IDs are no longer valid.\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n NodeIDType nodeID;\n} DeleteNodeCmd;\n```\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n } DeleteNodeReply;\n\nWhere :\n opcode - DELETE_NODE\n graphID - the ID of the graph containing the node to be deleted.\n nodeID - the ID of the node to be deleted.\n\nPossible errorCodes are :\n BAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\n BAD_NODE_ID - the node ID specified was not in the specified graph.\n NACK - an unexpected error occurred.\n\nContracting Edges\n\nAn edge is contracted in two steps. First all edges which connect the edge’s head node and tail node including the edge being contracted are deleted. Next either all of the edges which were connected to the tail node are moved to the head node and the tail node is deleted, or all of the edges attached to the head node are moved to the tail node and the head node is deleted.\n\nThe contract edge command lets an edge be contracted to either its head or tail node. When the contract edge command is used, GraphUI animates the move of the head node to the tail node or vice versa in six steps. The following is the format of the contract edge command and its reply.\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n EdgeIDType edgeID;\n Boolean headToTail;\n } ContractEdgeCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n } ContractEdgeReply;\nWhere:\n\n- **opcode - CONTRACT_EDGE**\n- **graphID** - the ID of the graph containing the edge to be contracted\n- **edgeID** - the ID of the edge to be contracted\n- **headToTail** - flag that dictates which way to contract the edge. If the value is TRUE, the head node’s edges are moved to the tail node and the head node is deleted; if FALSE, the tail node’s edges are moved to the head node and the tail node is deleted.\n\nPossible errorCodes are:\n\n- **BAD_GRAPH_ID** - the graphID specified did not match one of the open graphs.\n- **BAD_EDGE_ID** - the edge ID specified was not in the graph.\n- **NACK** - an unexpected error occurred.\n\nDeleting Edges\n\nAn edge is deleted from a graph with the delete edge command. Once an edge has been deleted by GraphUI it may no longer be referenced. The format of the delete edge command is as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n EdgeIDType edgeID;\n} DeleteEdgeCmd;\n```\n\n```c\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n} DeleteEdgeReply;\n```\n\nWhere:\n\n- **opcode - DELETE_EDGE**\n- **graphID** - the ID of the graph to containing the edge to be deleted\n- **edgeID** - the ID of the specific edge to be deleted\n\nPossible errorCodes are:\n\n- **BAD_GRAPH_ID** - the graphID specified did not match one of the open graphs.\n- **BAD_EDGE_ID** - the edge ID specified was not in the graph\n- **NACK** - an unexpected error occurred.\nSelection Commands\n\nSelecting nodes and edges of a graph is a method of changing the appearance of the graph. Every selected node or edge is drawn in gray rather than black. There are four commands that affect which nodes and edges are selected: get selection, add to selection, remove from selection, and clear selection.\n\nGet Selection\n\nThe get selection command returns the nodes and edges that are currently selected in the specified graph. This set of selected components of a graph is a useful form of input to a graph program as indicated in section 4.4. The format of the get selection command is as follows:\n\n```c\ntypedef struct {\n OpCode opcode; \n GraphID graphID; \n 1 GetSelectionCmd;\n} GetSelectionCmd;\n\ntypedef struct {\n OpCode opcode; \n ErrorCode errorCode; \n Counter numberOfNodes; \n Counter numberOfEdges; \n NodeID selectedNodes[numberOfNodes]; \n EdgeID selectedEdges[numberOfEdges]; \n 1 GetSelectionReply;\n} GetSelectionReply;\n```\n\nWhere:\n- `opcode`: GET_SELECTION\n- `graphID`: the ID of the graph whose selection is to be returned\n- `numberOfNodes`: the number of nodes that are selected in the graph\n- `numberOfEdges`: the number of edges that are selected in the graph\n- `selectedNodes`: a list of the IDs of each node in the graph that is selected\n- `selectedEdges`: a list of the IDs of each edge in the graph that is selected\n\nPossible errorCodes are:\nBAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\nNACK - an unexpected error occurred.\n\nAdd To Selection Command\n\nThis command selects the nodes and edges specified in the command if they are not already selected. Nodes or edges selected prior to receipt of this command remain selected. Selection changes the colour of the node or edge from black to gray. The nodes and edges added to the selection are considered part of the selection set and are used with user interface commands that require selected nodes and/or edges. The format of the add to selection command is:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n CounterType numberOfNodes;\n CounterType numberOfEdges;\n NodeIDType nodesToSelect[numberOfNodes];\n EdgeIDType edgesToSelect[numberOfEdges];\n} AddToSelectionCmd;\n```\n\n```c\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n} AddToSelectionReply;\n```\n\nWhere:\n- opcode - ADD_TO_SELECTION\n- graphID - the ID of the graph whose selection is to be added to\n- numberOfNodes - the number of nodes to be selected\n- numberOfEdges - the number of edges to be selected\n- nodesToSelect - a list of the IDs of each node to be selected\n- edgesToSelect - a list of the IDs of each edge to be selected\n\nPossible errorCodes are:\n- BAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\n- BAD_NODE_ID - one or more of the nodes specified does not exist\n- BAD_EDGE_ID - one or more of the edges specified does not exist.\n- NACK - an unexpected error occurred.\nRemove From Selection Command\n\nThis command unselects the nodes and edges specified if they are selected. If any specified node or edge was not selected, it remains unselected. Other selected nodes or edges not specified in this command remain selected. This changes the colour of the node or edge from gray to black. The nodes and edges removed from the selection are no longer in the graph's selection set. The format of the remove from selection command is:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n CounterType numberOfNodes;\n CounterType numberOfEdges;\n NodeIDType nodesToUnselect(numberOfNodes);\n EdgeIDType edgesToUnselect(numberOfEdges);\n} RemoveFromSelectionCmd;\n```\n\n```c\ntypedef struct {\n OpType (opcode;\n ErrorCodeType errorCode;\n} RemoveFromSelectionReply;\n```\n\nWhere:\n- **opcode** - REMOVE_FROM_SELECTION\n- **graphID** - the ID of the graph whose selection is to have items removed from it.\n- **numberOfNodes** - the number of nodes that are to be removed from the graph's selection (i.e. unselected) by this command\n- **numberOfEdges** - the number of edges that are to be removed from the graph's selection (i.e. unselected) by this command\n- **nodesToUnselect** - a list of the IDs of each node in the graph that is to be removed from the graph's selection\n- **edgesToUnselect** - a list of the IDs of each edge in the graph that is to be removed from the graph's selection\n\nPossible errorCodes are:\n- BAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\n- BAD_NODE_ID - at least one of the nodes specified does not exist\n- BAD_EDGE_ID - at least one of the edges specified does not exist.\n- NACK - an unexpected error occurred.\nClear Selection Command\n\nThis command unselects every selected node and edge in a graph. The format of the command and its reply is as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n} ClearSelectionCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n} ClearSelectionReply;\n```\n\nWhere:\n- `opcode` - CLEAR_SELECTION\n- `graphID` - the ID of the graph whose selection set is to be cleared\n\nPossible errorCodes are:\n- BAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\n- NACK - an unexpected error occurred.\n\n5.1.3 Commands that Manage Information with GraphUI\n\nThere are a number of different commands that get information from GraphUI for a graph program. These commands provide graph programs with a means of obtaining user input through GraphUI.\n\nSpecific information about a graph, node or edge is called its attributes. Attributes provide extra information other than structural about a graph, node or edge. Graph attributes, the information maintained by GraphUI about each graph, are fixed, as are node and edge attributes. Attributes are used to provide information that is common among many graph domains.\n\nUnfortunately, the set of attributes may not contain sufficient information for all programs using GraphUI. If information cannot be\nsupplied by attributes there are two commands for prompting the user to supply information directly from GraphUI's user interface. What follows is a description of the commands used to manage graph information.\n\nGet Graph Command\n\nThe get graph command is probably the most useful of all of the commands used with GraphUI. Given the ID of a graph, the get graph command returns a description of the graph and its nodes and edges. The description of the graph includes the attributes of the graph and the ID and attributes of each node and edge in the graph. The following is the format of the get graph command:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n } GetGraphCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n CounterType numberOfNodes;\n CounterType numberOfEdges;\n GraphAttributesType attr;\n NodeInfoType nodeInfo[numberOfNodes];\n EdgeInfoType edgeInfo[numberOfEdges];\n } GetGraphReply;\n```\n\nWhere:\n- opcode - GET_GRAPH\n- graphID - the ID of the graph to be returned\n- numberOfNodes - the number of nodes in the graph\n- numberOfEdges - the number of edges in the graph\n- attr - the attributes of the graph. The actual contents of the attributes are described in the attributes section in Chapter 2 and the graph attributes structure type in Appendix A.\n- nodeInfo - a list of the node ID followed by the attributes of each node in the graph. The actual contents of the node attributes are described in the attributes section in Chapter 2 and the node attributes structure type in Appendix A.\n\n87\nedgeInfo - a list of the edge ID followed by the attributes of each edge in the graph. The actual contents of the edge attributes are described in the attributes section in Chapter 2 and the edge attributes structure type in Appendix A.\n\nPossible errorCodes are:\nBAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\nNACK - an unexpected error occurred.\n\nGet Graph Attributes Command\n\nThe get graph attributes command returns the attributes of the graph specified. The format of the command and reply are as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n} GetGraphAttrCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n GraphAttributesType attributes;\n} GetGraphAttrReply;\n\nWhere:\nopcode - GET_GRAPH_ATTRIBUTES\ngraphID - the ID of the graph whose attributes are requested\nattributes - the attributes of the graph as defined in Chapter 2\n\nPossible errorCodes are:\nBAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\nNACK - an unexpected error occurred.\n\nGet Node Attributes Command\n\nThe get node attributes command returns the attributes of the node specified in the command. The format of the command and reply are as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n}\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n NodeAttributesType attributes;\n} GetNodeAttrReply;\n\nWhere:\n\nopcode - GET_NODE_ATTRIBUTES\ngraphID - the ID of the graph containing the node\nnodeID - the ID of the node whose attributes are to be obtained\nattributes - the attributes of the node as defined in appendix A\n\nPossible errorCodes are:\n\nBAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\nBAD_NODE_ID - the node specified in the command was not in the graph\nNACK - an unexpected error occurred.\n\nGet Edge Attributes Command\n\nThe get edge attributes command returns the attributes of the edge specified in the command. The format of the command and reply are as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n EdgeIDType edgeID;\n} GetEdgeAttrCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n EdgeAttributesType attributes;\n} GetEdgeAttrReply;\n\nWhere:\n\nopcode - GET_EDGE_ATTRIBUTES\ngraphID - the ID of the graph containing the edge\nnodeID - the ID of the edge whose attributes are to be obtained\nattributes - the attributes of the node as defined in Chapter 2 and Appendix A\nPossible errorCodes are:\nBAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\nBAD_EDGE_ID - the edge ID specified in the command was not in the graph\nNACK - an unexpected error occurred.\n\nSet Graph Attributes Command\n\nThe set graph attributes command is used to set the values of a graph's attributes, the default graph attributes, and the attributes for all open graphs. The attributes that are changed depend upon the changed attributes flag in the command. This enables a program to change the attributes it is using, leaving other attributes unaffected.\n\nThe graphID field of the command is used to determine the action of the command. If the graphID is set to 0, the default attributes are set; if the graphID is set to 0xFFFFFFFF, the attributes for all open graphs are set; otherwise the graphID is the ID of the graph whose attributes are set. The following is the structure of the command and its response:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n AttrFlagType changedAttributes;\n GraphAttributesType attributes;\n} SetGraphAttrCmd;\n```\n\n```c\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n} SetGraphAttrReply;\n```\n\nWhere:\n\n- **opcode** - \\textit{SET\\_GRAPH\\_ATTRIBUTES}\n- **graphID** - 0 - set the default graph attributes\n- **0xFFFFFFFF** - set attributes of all open graphs\n- **otherwise** - the ID of the graph whose attributes are to be set\n- **changedAttributes** - a 64 bit flag used to determine which attributes are to be set. Only those attributes whose bit is set to 1 in this flag are set. Table 5.1 shows the bit positions in the flag for each graph attribute that can be set, other bit positions are reserved for future use.\nattributes - the values of the attributes to be set. Only the values of the attributes set to be changed with the changedAttributes flag are used.\n\nPossible errorCodes are:\nBAD_GRAPH_ID - the graphID specified did not match one of the open graphs.\nNACK - an unexpected error occurred in GraphUI while executing the command\n\n<table>\n<thead>\n<tr>\n<th>Attribute</th>\n<th>Bit Position*</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>generic integer 1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>generic integer 2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>generic float 1</td>\n<td>3</td>\n</tr>\n<tr>\n<td>generic float 2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>generic integer 1 label</td>\n<td>5</td>\n</tr>\n<tr>\n<td>generic integer 2 label</td>\n<td>6</td>\n</tr>\n<tr>\n<td>generic float 1 label</td>\n<td>7</td>\n</tr>\n<tr>\n<td>generic float 2 label</td>\n<td>8</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.1: Format of the Change Graph Attributes Flag\n\n*(bit positions are from least significant to most significant)\n\nSet Node Attributes Command\n\nThe set node attributes command is used to set the values of a node’s attributes, the default node attributes for a particular graph, and the attributes for all nodes in a graph. The attributes that are changed depend upon the changed attributes flag in the command. This enables a program to change the attributes it is using, leaving other attributes unaffected.\n\nThe nodeID field of the command is used to determine the action of the command. If the nodeID is set to 0, the default node attributes are set for the graph specified in graphID; if the nodeID is set to 0xFFFF, the attributes\nfor all nodes in the graph specified in graphID are set; otherwise the nodeID is the ID of the node in the specified graph whose attributes are set. The following is the structure of the command and its response:\n\n```c\ntypedef struct {\n Opcode opcode;\n GraphIDType graphID;\n NodeIDType nodeID;\n AttrFlagType changedAttributes;\n NodeAttributesType attributes;\n} SetNodeAttrCmd;\n\ntypedef struct {\n Opcode opcode;\n ErrorCodeType errorCode;\n} SetNodeAttrReply;\n```\n\nWhere:\n\n- **opcode** - SET_NODE_ATTRIBUTES\n- **graphID** - the ID of the graph containing the node(s) or the default node attributes that are to be set.\n- **nodeID** -\n - 0 - set the default node attributes of the graph\n - 0xFFFF - set attributes of all nodes in the graph\n - otherwise - the ID of the node whose attributes are to be set\n- **changedAttributes** - a 64 bit flag used to determine which attributes are to be set. Only those attributes whose bit is set to 1 in this flag are set. Table 5.2 shows the bit positions in the flag for each node attribute that can be set, other bit positions are reserved for future use.\n- **attributes** - the values of the attributes to be set. Only the values of the attributes set to be changed with the changedAttributes flag are used.\n\nPossible errorCodes are:\n\n- **BAD_GRAPH_ID** - the graphID specified did not match one of the open graphs.\n- **BAD_NODE_ID** - the nodeID specified was not in the graph.\n- **NACK** - an unexpected error occurred in GraphUI while executing the command\n<table>\n<thead>\n<tr>\n<th>Attribute</th>\n<th>Bit Position*</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>generic integer 1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>generic integer 2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>generic float 1</td>\n<td>3</td>\n</tr>\n<tr>\n<td>generic float 2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>generic integer 1 label</td>\n<td>5</td>\n</tr>\n<tr>\n<td>generic integer 2 label</td>\n<td>6</td>\n</tr>\n<tr>\n<td>generic float 1 label</td>\n<td>7</td>\n</tr>\n<tr>\n<td>generic float 2 label</td>\n<td>8</td>\n</tr>\n<tr>\n<td>probability</td>\n<td>9</td>\n</tr>\n<tr>\n<td>name</td>\n<td>10</td>\n</tr>\n<tr>\n<td>label</td>\n<td>11</td>\n</tr>\n<tr>\n<td>radius</td>\n<td>12</td>\n</tr>\n<tr>\n<td>cost</td>\n<td>13</td>\n</tr>\n<tr>\n<td>capacity</td>\n<td>14</td>\n</tr>\n<tr>\n<td>weight</td>\n<td>15</td>\n</tr>\n<tr>\n<td>visited</td>\n<td>16</td>\n</tr>\n<tr>\n<td>source</td>\n<td>21</td>\n</tr>\n<tr>\n<td>target</td>\n<td>22</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.2: Format of the Change Node Attributes Flag\n\n*(bit positions are from least significant to most significant)*\n\n**Set Edge Attributes Command**\n\nThe set edge attributes command is used to set the values of an edge's attributes, the default edge attributes for a particular graph, and the attributes for all edges in a graph. The attributes that are changed depends upon the changed attributes flag in the command. This enables a program to change the attributes it is using, leaving other attributes unaffected.\n\nThe edgeID field of the command is used to determine the action of the command. If the edgeID is set to 0, the default edge attributes are set for the\ngraph specified in graphID; if the edgeID is set to 0xFFF, the attributes for all edges in the graph specified in graphID are set; otherwise the edgeID is the ID of the edge in the specified graph whose attributes are set. The following is the structure of the command and its response:\n\n```c\ntypedef struct {\n OpCode opcode;\n GraphID graphID;\n EdgeID edgeID;\n AttrFlag changedAttributes;\n EdgeAttr attributes;\n SetEdgeAttrCmd;\n} SetEdgeAttrCmd;\n\ntypedef struct {\n OpCode opcode;\n ErrorCode errorCode;\n SetEdgeAttrReply;\n} SetEdgeAttrReply;\n```\n\nWhere:\n- **opcode**: `SET_EDGE_ATTRIBUTES`\n- **graphID**: the ID of the graph containing the edge(s) or the default edge attributes that are to be set.\n- **edgeID**: 0 - set the default edge attributes of the graph\n 0xFFF - set attributes of all edges in the graph\n otherwise - the ID of the edge whose attributes are to be set\n- **changedAttributes**: a 64 bit flag used to determine which attributes are to be set. Only those attributes whose bit is set to 1 in this flag are set. Table 5.3 shows the bit positions in the flag for each edge attribute that can be set, other bit positions are reserved for future use.\n- **attributes**: the values of the attributes to be set. Only the values of the attributes set to be changed with the changedAttributes flag are used.\n\nPossible errorCodes are:\n- **BAD_GRAPH_ID**: the graphID specified did not match one of the open graphs.\n- **BAD_EDGE_ID**: the edgeID specified was not in the graph.\n- **NACK**: an unexpected error occurred in GraphUI while executing the command.\n<table>\n<thead>\n<tr>\n<th>Attribute</th>\n<th>Bit Position*</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>generic integer 1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>generic integer 2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>generic float 1</td>\n<td>3</td>\n</tr>\n<tr>\n<td>generic float 2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>generic integer 1 label</td>\n<td>5</td>\n</tr>\n<tr>\n<td>generic integer 2 label</td>\n<td>6</td>\n</tr>\n<tr>\n<td>generic float 1 label</td>\n<td>7</td>\n</tr>\n<tr>\n<td>generic float 2 label</td>\n<td>8</td>\n</tr>\n<tr>\n<td>probability</td>\n<td>9</td>\n</tr>\n<tr>\n<td>name</td>\n<td>10</td>\n</tr>\n<tr>\n<td>label</td>\n<td>11</td>\n</tr>\n<tr>\n<td>cost</td>\n<td>13</td>\n</tr>\n<tr>\n<td>capacity</td>\n<td>14</td>\n</tr>\n<tr>\n<td>thickness</td>\n<td>17</td>\n</tr>\n<tr>\n<td>is directed?</td>\n<td>18</td>\n</tr>\n<tr>\n<td>distance</td>\n<td>19</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.3: Format of the Change Edge Attributes Flag\n\n*(bit positions are from least significant to most significant)*\n\n**Get Integer Command**\n\nThe get integer command is used to obtain an integer value from the GraphUI user. This command opens a dialog box with a prompt explaining the desired value and a place to input the value. When the user closes the dialog box, a reply containing the number the user entered is returned in response to this command. The amount of time before the reply to this command is received is dependent upon how long the user takes before closing the dialog box. The format of this command and its reply are as follows:\n\n```c\ntypedef struct {\n```\ntypedef struct {\n OpType opcode;\n PromptType prompt;\n } GetIntegerCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n int number;\n } GetIntegerReply;\n\nWhere:\n\nopcode - GET_INTEGER\nprompt - the Pascal type string to be displayed in the dialog to prompt the user to enter the desired value.\nnumber - the number that the user entered in the dialog.\n\nPossible errorCodes are:\n\nNACK - an unexpected error occurred in GraphUI while executing the command.\n\nGet Real Number Command\n\nThe get real number command is used to obtain a real number from the GraphUI user. The command opens a dialog box with a prompt explaining the desired value and a place to input the number. When the user closes the dialog box, a reply containing the number the user entered is returned in response to this command. The amount of time before the reply to this command is received is dependent upon how long the user takes before closing the dialog box. The format of this command and its reply are as follows:\n\ntypedef struct {\n OpType opcode;\n PromptType prompt;\n } GetRealCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n float number;\n } GetRealReply;\nWhere:\n - opcode - `GET_REAL`\n - prompt - the Pascal type string to be displayed in the dialog to prompt the user to enter the real number.\n - number - the number that the user entered in the dialog.\n\nPossible errorCodes are:\n - NACK - an unexpected error occurred in GraphUI while executing the command\n\n5.1.4 Algorithms\n\nAlgorithms in a program can be made available to GraphUI users through GraphUI's Algorithms menu. This menu is built dynamically by connected programs with menu items added and removed with the add algorithm and remove algorithm commands. Making a program's algorithm available through GraphUI's user interface means the program does not have to manage algorithms from its own user interface.\n\nThe set and remove algorithm commands are provided to help manage the size of the menu. The algorithms menu is linear and can grow to a maximum of 255 menu items. Large menus are cumbersome for a user and it is recommended that menu items be added and removed based upon the user's needs.\n\nWhen a user selects an algorithm that was added to GraphUI, GraphUI sends a message to the associated program requesting the corresponding algorithm be run for the user. The execution of the algorithm is the responsibility of the program providing the algorithm.\n**Add Algorithm Command**\n\nThe add algorithm command is used to add the name of an algorithm to GraphUI's algorithm menu. The name of the algorithm is not guaranteed to be unique. If other connected programs have algorithms with the same name, the name simply appears twice in the menu. The set algorithm command supplies GraphUI with an integer ID to use as a reference to the algorithm. If a program uses the same integer ID for two or more algorithms, the program will not be able to distinguish which algorithm was requested. Duplicate algorithm IDs between applications using GraphUI do not cause a discrepancy. The following is the format of the add algorithm command and its reply.\n\n```c\ntypedef struct {\n OpType opcode;\n NameType algorithmName;\n AlgorithmIDType algorithmID;\n Boolean needsGraph;\n} SetAlgorithmCmd;\n```\n\n```c\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n} SetAlgorithmReply;\n```\n\nWhere:\n- `opcode` - *SET_ALGORITHM*\n- `algorithmName` - the name for the algorithm to be place in GraphUI's algorithm menu.\n- `algorithmID` - the ID to be used by GraphUI to refer to the algorithm when the user requests that the algorithm be executed.\n- `needsGraph` - is a flag which if set to TRUE means the algorithm cannot be run unless the active window is a graph window (the ID of the active graph is sent with the request to run the command). If the flag is set to FALSE, the algorithm is not dependent on having a graph active and the algorithm should be available for execution at all times. Algorithms that are not available to be run because there is no active graph, appear in the algorithms menu but can not be selected.\n\nPossible errorCodes are:\n- NACK - an unexpected error occurred in GraphUI while executing the command\nDelete Algorithm Command\n\nThe delete algorithm command is used to remove the name of an algorithm displayed in GraphUI's algorithm menu. Any algorithm names added by the program with algorithm ID matching the one specified in the command are removed from the menu.\n\nA program does not have to use this command before it closes as GraphUI always removes the algorithms of a program when the connection to it is closed. The following is the format of the command and its reply.\n\n```\ntypedef struct {\n OpType opcode;\n AlgorithmIDType algorithmID;\n} DeleteAlgorithmCmd;\n```\n\n```\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n} DeleteAlgorithmReply;\n```\n\nWhere:\n- opcode - DELETE_ALGORITHM\n- algorithmID - the ID of the algorithm to be removed from the menu.\n\nPossible errorCodes are:\n- NACK - an unexpected error occurred in GraphUI while executing the command.\n\nRun Algorithm Message\n\nThe run algorithm message is not a command sent to GraphUI; rather it is an unsolicited message that is sent from GraphUI when a program's algorithm has been selected by the user. The format of this command is described in the next section of this chapter but the message is mentioned here to remind programmers that if algorithms are added to GraphUI's menu\nwith the set algorithm message, the program must be prepared to watch for execute algorithm messages and handle the messages accordingly.\n\n**Display Text Command**\n\nGraphUI has a window, called the Applications' Transcript window where programs and users can write text. In this window algorithms can write results that cannot be conveyed by looking at a graph. Text that is written to the Applications' Transcript is appended to the end of the window regardless of the position of the cursor in the window. Carriage returns are not added after each display text command and should be included as necessary in the text (carriage return is 0x0D). The format of the display text command is as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n PromptType text;\n} DisplayTextCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorCode;\n} DisplayTextReply;\n```\n\nWhere:\n- opcode - **DISPLAY_TEXT**\n- text - the text to be written to the Applications' Transcript window\n\nPossible errorCodes are:\n- NACK - *an unexpected error occurred in GraphUI while executing the command*\n\n**Set Messaging Command**\n\nThe Set Messaging command is used to allow a program to select whether it wishes to have information messages sent to it. When a program\nfirst connects to GraphUI the default is not to send the messages. The format of the set messaging command is as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n Boolean wantsMessages;\n} DisplayTextCmd;\n\ntypedef struct {\n OpType opcode;\n ErrorCodeType errorcode;\n} DisplayTextReply;\n```\n\nWhere:\n- `opcode` - SET_MESSAGING\n- `wantsMessages` - if TRUE then send information messages; if FALSE do not send information messages\n\nPossible errorCodes are:\n- NACK - an unexpected error occurred in GraphUI while executing the command\n\n5.2 GraphUI Information Messages\n\nInformation messages are messages that are sent from GraphUI to connected programs when a graph changes. These can be used by a program to keep accurate information about open graphs in GraphUI. A program can select whether or not it wants to receive information messages with the Set Messaging command.\n\nRun Algorithm Message\n\nThe run algorithm message is sent to a program whenever a user selects an algorithm from GraphUI’s menu that was added by the program. The run algorithm message is the only message sent by GraphUI that is not sent as information only. It is sent even if the program is not receiving\ninformation messages. This message must be handled by a program if it makes algorithms available through GraphUI's algorithm menu. The remaining messages can be used or ignored at a program's discretion. It is recommended that a program with algorithms added to GraphUI's menu look for run algorithm messages at least once through its main event loop.\n\nThe format of a run algorithm message is as follows.\n\n```c\ntypedef struct {\n OpType opcode;\n AlgorithmIDType algorithmID;\n GraphIDType graphID;\n} RunAlgorithmMsg;\n```\n\nWhere:\n- opcode - RUN_ALGORITHM\n- algorithmID - the ID of the algorithm that the user asked to run\n- graphID - the ID of the active graph if the algorithm needs a graph; 0 otherwise.\n\n**Graph Added Message**\n\nThe purpose of the graph added message is to inform programs that a new graph has been added or opened. It is sent whenever a new graph is created or an old graph opened. The format of the message is as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n} GraphAddedMsg;\n```\n\nWhere:\n- opcode - GRAPH_ADDED\n- graphID - the numeric ID of the graph that was added (opened)\nGraph Deleted (Closed) Message\n\nThe graph deleted message is sent each time a graph is closed to inform all programs using the graph that it is no longer available. The format of the graph deleted message is as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n IGraphDeletedMsg;\n}\n\nWhere:\nopcode - GRAPH_DELETED\ngraphID - the numeric ID of the graph that was deleted (closed)\n\nNode Added Message\n\nThe node added message is sent to programs to inform of the addition of a new node in an existing graph. The message includes the location of the node for those programs maintaining graph appearances. The format of the node added message is as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n NodeIDType nodeID;\n NodeLocationType location;\n INodeAddedMsg;\n}\n\nWhere:\nopcode - NODE_ADDED\ngraphID - the numeric ID of the graph into which the node was added\nnodeID - the numeric ID of the node that was added to the graph\nlocation - the (X,Y) position at which the new node is centered\n\nNode Deleted Message\n\nThe node deleted message is sent to all programs whenever a node of a graph is deleted. The format of the node deleted message is as follows:\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n NodeIDType nodeID;\n} NodeDeletedMsg;\n\nWhere:\nopcode - NODE_DELETED\ngraphID - the numeric ID of the graph containing the node that was deleted\nnodeID - the numeric ID of the node that was removed from the graph\n\nEdge Added Message\n\nThe edge added message is sent to programs to inform them of the addition of a new edge to an existing graph. The message includes the head and tail node of the edge to help programs manage graph structure. The format of the edge added message is as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n EdgeIDType edgeID;\n NodeIDType headNode;\n NodeIDType tailNode;\n} EdgeAddedMsg;\n\nWhere:\nopcode - EDGE_ADDED\ngraphID - the numeric ID of the graph into which the edge was added\nedgeID - the numeric ID of the edge that was added to the graph\nheadNode - the ID of the head node of the new edge\ntailNode - the ID of the tail node of the new edge\n\nEdge Deleted Message\n\nThe edge deleted message is sent to programs whenever an edge of a graph is deleted. The format of the edge deleted message is as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n EdgeIDType edgeID;\n} EdgeDeletedMsg;\nWhere:\n- **opcode** - `EDGE_DELETED`\n- **graphID** - the numeric ID of the graph containing the edge that was deleted\n- **edgeID** - the numeric ID of the edge that was removed from the graph\n\n**Node Moved Message**\n\nThe node moved message informs programs whenever a node in a graph moves to a new location in the graph. It is intended for use by programs managing the physical appearance of graphs. The new location is the new center point of the node. The format of the node moved message is as follows:\n\n```c\ntypedef struct {\n OpCode opcode;\n GraphID graphID;\n NodeID nodeID;\n NodeLocation location;\n} NodeMovedMsg;\n```\n\nWhere:\n- **opcode** - `NODE_MOVED`\n- **graphID** - the numeric ID of the graph which contains the node that was moved\n- **nodeID** - the numeric ID of the node that was moved\n- **location** - the new (X,Y) position of the center of the node\n\n**Graph Attributes Changed Message**\n\nThe graph attributes changed message is sent to inform programs whenever an individual graph's attributes or the default graph attributes are changed. The format of the graph attributes changed message is as follows:\n\n```c\ntypedef struct {\n OpCode opcode;\n GraphID graphID;\n GraphAttributes attributes;\n} GraphAttrChangedMsg;\n```\n\nWhere:\n- **opcode** - `GRAPH_ATTR_CHANGED`\ngraphID - 0 - default graph attributes were changed\n otherwise - ID of the graph whose attributes were changed\nattributes - the values of the attributes due to the change.\n\nNode Attributes Changed Message\n\nThe node attributes changed message is sent to inform programs whenever an individual node's attributes or the default node attributes of a graph are changed. The format of the node attributes changed message is as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n NodeIDType nodeID;\n NodeAttributesType attributes;\n} NodeAttrChangedMsg;\n\nWhere:\nopcode - NODE_ATTR_CHANGED\ngraphID - the ID of the graph containing the node(s) or the default node attributes that were changed.\nnodeID - 0 - default node attributes of the graph were changed\n otherwise - ID of the node whose attributes were changed\nattributes - the values of the attributes or default attributes due to the change.\n\nEdge Attributes Changed Message\n\nThe edge attributes changed message is sent to inform programs whenever an individual edge's attributes or the default edge attributes of a graph are changed. The format of the edge attributes changed message is as follows:\n\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n EdgeIDType edgeID;\n EdgeAttributesType attributes;\n} EdgeAttrChangedMsg;\n\nWhere:\nopcode - EDGEATTR_CHANGED\ngraphID - the ID of the graph containing the edge(s) or the default edge attributes that were changed.\nedgeID - 0 - default edge attributes of the graph were changed\n otherwise - ID of the edge whose attributes were changed\nattributes - the attributes values of the changed attributes. Only the values of the attributes set to have changed with the changedAttributes flag are guaranteed to be correct.\n\n### Added To Selection Message\n\nThe added to selection message is sent to inform programs that nodes and edges have been selected in a graph. The format of the added to selection message is as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n CounterType numberOfNodes;\n CounterType numberOfEdges;\n NodeIDType nodesSelected[numberOfNodes];\n EdgeIDType edgesSelected[numberOfEdges];\n} AddedToSelectionMsg;\n```\n\nWhere :\n\n- opcode - ADDED_TO_SELECTION\n- graphID - the ID of the graph in which the nodes and edges were selected\n- numberOfNodes - the number of nodes that were selected in the graph\n- numberOfEdges - the number of edges that were selected in the graph\n- nodesSelected - a list of the IDs of each node that was selected in the graph\n- edgesSelected - a list of the IDs of each edge that was selected in the graph\n\n### Removed From Selection Message\n\nThe removed from selection message is sent to inform programs that nodes and edges have been removed from a graph's selection. The format of the remove from selection message is as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n CounterType numberOfNodes;\n} RemovedFromSelectionMsg;\n```\nCounterType numberOfEdges;\nNodeType removedNodes[numberOfNodes];\nEdgeIDType removedEdges[numberOfEdges];\n} RemovedFromSelectionMsg;\n\nWhere:\n- **opcode** - REMOVED_FROM_SELECTION\n- **graphID** - the ID of the graph containing the nodes and edges that were removed from the selection\n- **numberOfNodes** - the number of nodes that were removed from the selection\n- **numberOfEdges** - the number of edges that were removed from the selection\n- **removedNodes** - a list of the IDs of each node that was removed from the graph's selection\n- **removedEdges** - a list of the IDs of each edge that was removed from the graph's selection\n\n**Selection Cleared Message**\n\nThe selection cleared message is sent to inform programs that there are no longer any selected nodes or edges in a graph. The format of the selection cleared message is as follows:\n\n```c\ntypedef struct {\n OpType opcode;\n GraphIDType graphID;\n} SelectionClearedMsg;\n```\n\nWhere:\n- **opcode** - SELECTION_CLEARED\n- **graphID** - the ID of the graph whose selection set was cleared\n\n### 5.3 Suggested Animation Techniques\n\nThis section describes a few of the techniques that can be used to animate algorithms when they are being run with GraphUI. The techniques are founded on two ideas, graph creation and graph modification.\nCreation of Graphs\n\nSome algorithms create graphs based upon a graph provided as input to the algorithm, such as an algorithm which produces a random spanning tree of a given graph. Other algorithms simply produce graphs as part of their output, such as an algorithm that creates data flow diagrams. Programs that create graphs can use GraphUI to build new graphs. This has the advantage that it permits the user to watch as a graph is built and to save the results of an algorithm as a picture.\n\nManipulation of Graphs\n\nGraphs that are used as input or created as output of an algorithm can be manipulated by programs to give the user a better understanding of what the algorithm is doing. Having GraphUI visually manipulate a graph as an algorithm manipulates it, can effectively animate the operation of the algorithm. Here are a few suggestions of how to visually manipulate a graph when programming with GraphUI.\n\nSend the appropriate commands to GraphUI to echo any operations in the algorithm that alter the structure of the graph. In echoing additions or deletions of nodes and edges, the user is made aware of how the algorithm is affecting the input graph.\n\nUse the selection set of the graph to single out particular nodes and edges from the rest of the graph by clearing the selection and selecting the nodes and edges of interest. These selected nodes and edges appear in gray and are easily distinguished from their unselected black counterparts.\n\nChange the radius of nodes to make them larger or smaller. This is a change that is readily apparent to a user, as is changing the thickness of edges.\nMoving nodes is also useful for illustration to the user. The contract edge command provided with GraphUI is much easier to understand when the operation is animated by moving the tail node of an edge to the head node. One can determine which edges should be attached to the head node as the operation is being done.\n\nLabel nodes and edges with attributes that are being changed by the algorithm. This way a user may watch the new values as they are set by the algorithm.\n\nAnimation can be very useful in the early stages of algorithm development to help in debugging the algorithm. Although, animation requires extra work on the part of the programmer to send the appropriate commands to GraphUI, the extra work will result in a user interface for graph programs that is both powerful and easy to use.\n\n5.4 Suggested Protocol Techniques\n\nInteraction between GraphUI and a program can be done in a variety of ways. The design of GraphUI is such that it can be used from a number of different programs running on different computers connected in different ways. There is more than one way to use GraphUI once a program has connected to it. Programs can use the information messages sent from GraphUI and manage all of the graphs open in GraphUI. Programs can ignore all information messages except run algorithm messages and get the information they require once they have been asked to execute an algorithm. Programs can send commands synchronously, waiting for each reply before\ncontinuing, or asynchronously continuing and getting replies later when they have arrived.\n\nExperiments with protocol techniques for using GraphUI with applications that run on Macintosh computers were done and the following observations were made. If a single computer is used to run both GraphUI and the graph program, the application must not request synchronous reads and writes when using the connection manager. Synchronous reads and writes do not give other running applications processing time and deadlock results. If a read is issued before the reply is sent by GraphUI, the machine locks.\n\nOne solution to the problem of not being able to specify that a read is synchronous is to never wait for replies. This method works but it precludes the use of any GraphUI command that returns information, greatly reducing the use of GraphUI.\n\nA second solution is to wait for GraphUI to send its reply before attempting to read it. This is achieved by a polling loop that continually polls the connection manager waiting for that data that is to be read. For polling to work when both GraphUI and the graph program are running on the same computer, the WaitNextEvent system call must be invoked from within the polling loop. This call relinquishes the processor to give other programs processor time. This method allows the entire command set of GraphUI to be used.\n\nA third alternative combines the first and second approaches by using a polling loop so that a program can receive replies but only waiting for replies that provide information about the graph. For example wait for the reply to a get graph command but do not wait for the reply to a delete node command.\nThis approach minimizes the amount of time a graph program sends waiting while providing the complete command set. This does ignore error codes and should only be used with connections tools that handle error correction such as the AppleTalk ADSP connection tool.\n6. GraphApp: A Sample Program\n\nA sample program, GraphApp, was written to illustrate one method of writing a program that uses GraphUI's application interface. GraphApp is designed to be used as a framework for creating Macintosh graph programs that interface to GraphUI. New graph algorithms can be added directly to GraphApp.\n\nThe sample program performs three uncomplicated graph operations: Dijkstra's shortest path algorithm which computes the lengths of the shortest paths from a source node to all other nodes in a graph; an algorithm to compute the degree of each selected node; and an operation to complete a directed graph by adding edges. The purpose of GraphApp is twofold; show how to use GraphUI's application interface; and illustrate some of the different ways that an algorithm can be animated using GraphUI.\n\nThis chapter describes the expected use of GraphUI, by both a user and a programmer. This is accomplished by describing how GraphApp's algorithms are accessed through GraphUI's application interface and how GraphApp has been designed to help the programmer to easily include new graph algorithms.\n\n6.1 Running GraphApp\n\nAlone, GraphApp has a very limited user interface. The only operation it supports is the quit command which terminates the program.\nThe remainder of user interaction with GraphApp is done through GraphUI. This section describes the user's interaction with GraphApp via GraphUI.\n\nWhen GraphApp is launched a static window is opened, see Figure 6.1. This window does not change or accept input and serves only to remind a user that GraphApp is running. There are no documents associated with this application and the File Menu contains only one item, Quit.\n\n**GraphApp - A Graph Program**\n\nFigure 6.1 : Static Window Displayed by GraphApp\n\nGraphApp is run by launching it and GraphUI in either order. From GraphUI select Connection Settings from the Comm menu. A dialog box describing the configuration of the connection is displayed. If the method is not set to AppleTalk ADSP Tool, select the Method field and select \"AppleTalk ADSP Tool\" from the pop up menu presented, see Figure 6.2. In the scrollable area under the Name field, the word GraphApp should appear. If it does not appear, make certain GraphApp is running. Finish setting the connection by typing GraphApp in the name field or select GraphApp from the list of waiting connections, which automatically sets the Name field, and click the OK button. This operation tells the connection manager which application to connect to GraphUI. Finally, select Open Connection from the Comm menu to open the connection to GraphApp.\nTo confirm the connection is made, pull down GraphUI's Comm Menu and Close Connection should now be an available menu option. If Close Connection is not available, make sure AppleTalk is active. Once the connection is opened, GraphApp sends the commands to register its the names of its algorithms in GraphUI's Algorithms menu. \"Shortest Path\", \"Complete Graph - Directed\", and \"Node Degrees\" are all registered in the Algorithms menu, see Figure 6.3. These three algorithms are now available to the user.\n6.1.1 Shortest Path Algorithm\n\nThe shortest path algorithm computes the cost of the shortest paths from a source node to all other nodes in a graph. A path is a series of edges which connect one node to another node. An edge is a path from its tail node to its head node. The cost of travelling a particular edge is stored in the edge's distance attribute. For each node the shortest distance from it to the source node is computed and stored in the node's cost attribute. The cost of a node\nwhich is unreachable from the source node is infinity, represented by 9999999.0000 in this algorithm.\n\nTo run the shortest path algorithm, create the desired input graph, see Figure 6.4, set the distance of each edge to its appropriate value, and make note of the ID of the source node. Ensure the graph is the active window and select Shortest Path from the Algorithms menu.\n\nThe algorithm begins by writing a start of algorithm message in the Applications' Transcript. The user is then prompted with a dialog box to enter the ID of the source node. If the ID entered does not correspond to the ID of a node in the graph, an error message is written in the Applications' Transcript and the algorithm terminates. Next, the shortest path algorithm ensures that the graph is directed by making any edges arcs. Shortest path converts an edge to an arc by setting the isDirected attribute. GraphUI draws the arc with an arrow pointing to its head node. It then labels the arcs with their corresponding distances, similar to Figure 6.4. Node labels are set to the node's cost attribute and each node is initially set to a cost of infinity, implying the node has not been reached. The source node is assigned a cost of zero. As the cost of reaching each node is computed, the node's label is updated with the cost and the node is selected.\n\nWhen the algorithm has finished an end of algorithm message is written in the Applications' Transcript and the selection is cleared. Figure 6.5 shows the result of running shortest path on the graph in Figure 6.4 using Boston as the source node.\nFigure 6.4: Input Graph to Shortest Path Algorithm\n\nFigure 6.5: Results of Shortest Path Algorithm\n6.1.2 Complete Graph Algorithm\n\nGraphUI has an editing short cut command to complete an undirected graph. When GraphUI completes a graph, if there is no edge connecting two nodes it creates an edge to connect them. A command to complete a directed graph has been included in GraphApp to illustrate that algorithms can be animated by echoing any changes an algorithm makes to a graph in GraphUI. The complete graph algorithm of GraphApp completes a graph as if it were directed.\n\nFor each pair of nodes A and B, if there is no arc connecting node A to node B, an arc connects its tail node to its head node, it adds an arc connecting A to B. Likewise if there is no arc connecting B to A, it adds an arc connecting B to A. All arcs added by complete graph are added to both the GraphApp data structure and GraphUI's displayed graph.\n\nTo use GraphApp's complete graph command, make the graph to be completed the active window and select Complete Graph - Directed from the Algorithms menu. The arcs required to complete the graph are added one at a time. The algorithm writes a start and end of algorithm message in the Applications' Transcript. Figures 6.6a, 6.6b, 6.6c show a graph before it is completed, after it has been completed by GraphUI and after it has been completed by GraphApp.\nFigure 6.6a: Graph Before Being Completed\n\nFigure 6.6b: Graph After Being Completed By GraphUI\n6.1.3 Node Degrees Algorithm\n\nThe node degrees algorithm computes the degree of nodes. The degree of a node is the number of edges that are incident to it. To use the node degrees algorithm, select the nodes for which the degree is to be computed and choose Node Degrees from the Algorithms menu.\n\nThe algorithm begins by writing a start of algorithm message in the Applications' Transcript. If no nodes are selected, a warning is written to the Applications' Transcript and the algorithm ends. The label of each selected node is set to the integer 1 field which represents the degree of the node. The integer 1 field of each selected node is set to the value of the node's degree as the degree is computed. The algorithm terminates by writing an end of algorithm message in the Applications' Transcript. Figures 6.7a and 6.7b show a graph before and after the node degrees algorithm has run.\n6.1.4 Quitting GraphApp\n\nWhen finished with GraphApp the connection to GraphUI must be closed with GraphUI's Close Connection command or by quitting either GraphApp or GraphUI. To use GraphApp again from GraphUI open a new connection to GraphApp as described previously. Once GraphApp use of\nGraphApp is no longer required, use the Quit command in GraphApp's File menu to terminate it.\n\n6.2 Using GraphApp as a Programming Platform\n\nTo use GraphApp to build a new graph application it is necessary to understand: the graph data structures used in GraphApp, how GraphApp communicates with GraphUI, and what steps must be followed to add a new graph algorithm to GraphApp. The purpose of this section is to provide this information.\n\n6.2.1 Graph Data Structures\n\nGraphApp has been implemented using a hierarchy of C++ objects which serve as graph data structures, see Figure 6.8. Objects which appear in bold in Figure 6.8 are MacApp objects. The TObject class is the superclass of all MacApp objects. The TGraphModel and the TGraphComponent classes are abstract classes used to model graphs and their component parts. Neither class is directly instantiated.\n\nIn addition to providing a set of data structures, the graph objects provide programmers with methods that communicate with GraphUI. It should not be assumed that the graph classes provide all methods required to manipulate graphs for algorithms. These methods will have to be written as new algorithms require them. The few methods that are not used to communicate with GraphUI were necessary for the three graph algorithms contained in GraphApp.\n\n123\nTSet - a descendent of the MacApp TList object. TSet is a container object into which groups of related objects may be placed. It is modeled after a mathematical set. It differs from TList in that an object may only be added to a set once; duplicate members are not permissible.\n\n**Instance Variables:**\n\n*None*\n\n**Methods:**\n\n- Union(set, resultingSet)\n\n *Fills resultingSet with the union of set and itself*\n\n- Intersection(set, resultingSet)\nFills resultingSet with the intersection of set and itself\nDifference(set, resultingSet)\nFills resultingSet with any objects in it that are not in set.\nInsert(theElement)\nAdds theElement to the set if it is not already in the set.\nDelete(theElement)\nRemoves theElement from the set.\nIsMember(theElement)\nReturns TRUE if theElement is in the set\nCountClassMembers(classID)\nReturns the number of objects in it whose class ID = classID\nMakeClassSubSet(classID, subSet)\nFills subSet with all elements in it whose class ID = classID.\n\nTNodeSet - a descendent of the TSet object which can only contain TNode Objects.\n\nInstance Variables:\nNone\n\nMethods:\n(See TSet)\n\nTEdgeSet - a descendent of the TSet object which can only contain TEdge Objects.\n\nInstance Variables:\nNone\n\nMethods:\n(See TSet)\n\nTGraphComponent: an abstract data class used to group common features of\nany component of a graph.\n\nInstance Variables:\n\nfID - the numeric ID of the component used to refer to its graphical representation in\nGraphUI.\nfGraph - is the TGraph object that this component is in.\n\nMethods:\nGetID()\nReturns the fID instance variable\nSetID(theID)\n Sets the fID instance variable\nGetGraph()\n Returns the graph object this component is in\nGetGraphID()\n returns the numeric ID of its graph which is used to refer to the graphs graphical\n representation in GraphUI.\nSelect()\n Sends a message to GraphUI to select the component\nUnselect()\n Sends a message to GraphUI to unselect the component\n\nTNode: is a descendent of TGraphComponent and is the object used to\nrepresent nodes in a graph.\n\nInstance Variables:\n fEdgeList - the TEdgeSet containing all of the edges incident to this node\n fProb - the node’s probability attribute\n fLabel - the node’s label attribute\n fName - the node’s name attribute\n fRadius - the node’s radius attribute\n fCost - the node’s cost attribute\n fCapacity - the node’s capacity attribute\n fWeight - the node’s weight attribute\n fVisited - the node’s visited attribute\n fSource - the node’s source attribute\n fTarget - the node’s target attribute\n fint1 - the node’s generic integer 1 attribute\n fint2 - the node’s generic integer 2 attribute\n fReal1 - the node’s generic real 1 attribute\n fReal2 - the node’s generic real 2 attribute\n fint1Label - the node’s generic integer 1 label attribute\n fint2Label - the node’s generic integer 2 label attribute\n fReal1Label - the node’s generic real 1 label attribute\n fReal2Label - the node’s generic real 2 label attribute\n\nMethods:\n MoveNodeTo(theLocation)\n Moves this node to the new location in GraphUI.\n AddEdge(theEdge)\n Adds the edge to the edge set of the node\n RemoveEdge(theEdge)\n Removes the edge from the edge set of the node\n Degree()\nReturns the degree of the node (used in Node Degrees algorithm)\nSetAttributes(theAttributes, echo)\n Sets all of the node's attributes and tell GraphUI to set them if echo = TRUE\nEchoAttributes(void)\n Sends all of the node's attributes to GraphUI (faster than setting one at a time)\nGetAttributes(theAttributes)\n Puts the attributes of this node into a NodeAttributesType structure.\n\nThe remaining attributes of TNode are Setxxx and Getxxx methods. Setxxx(attribute, echo) methods set the value of the corresponding attribute and has GraphUI set the value if echo = TRUE. For example SetProbability(prob, echo), sets the node's probability attribute. Getxxx methods return the value of a given attribute. These commands get the value as stored by GraphApp, they do not go to GraphUI for the value. A complete list of the Setxxx and Getxxx methods is provided in Appendix B.\n\nTEdge:\n\nInstance Variables:\n fHead - the TNode object that is the head node of this edge\n fTail - the TNode object that is the tail node of this edge\n fProb - the edge's probability attribute\n fLabel - the edge's label attribute\n fName - the edge's name attribute\n fThickness - the edge's thickness attribute\n fIsDirected - the edge's isDirected attribute\n fFlow - the edge's flow attribute\n fDistance - the edge's distance attribute\n fCost - the edge's cost attribute\n fCapacity - the edge's capacity attribute\n fInt1 - the edge's generic integer 1 attribute\n fInt2 - the edge's generic integer 2 attribute\n fReal1 - the edge's generic real 1 attribute\n fReal2 - the edge's generic real 2 attribute\n fInt1Label - the edge's generic integer 1 label attribute\n fInt2Label - the edge's generic integer 2 label attribute\n fReal1Label - the edge's generic real 1 label attribute\n fReal2Label - the edge's generic real 2 label attribute\n\nMethods:\n GetHead()\n Returns the TNode object that is the head node of this edge\n GetTail()\n Returns the TNode object that is the tail node of this edge\n\n127\nSetHead(theHead)\nSets the head node of this edge to theHead\n\nSetTail(theTail)\nSets the tail node of this edge to theTail\n\nSetAttributes(theAttributes, echo)\nSets all of the edge's attributes and tell GraphUI to set them if echo = TRUE\n\nEchoAttributes(void)\nSends all of the edge's attributes to GraphUI (faster than setting one at a time)\n\nGetAttributes(theAttributes)\nPuts the attributes of this edge into a EdgeAttributesType structure.\n\nThe remaining attributes of TEdge are Setxxx and Getxxx methods. Setxxx(attribute, echo) methods set the value of the corresponding attribute and has GraphUI set the value if echo = TRUE. For example SetThickness(thickness, echo), sets the edge's thickness attribute. Getxxx methods return the value of a given attribute. These commands get the value as stored by GraphApp, they do not go to GraphUI for the value. A complete list of the Setxxx and Getxxx methods is provided in Appendix B.\n\nTGraphModel: is an abstract data class used to hide graph interaction with GraphUI from the programmer.\n\n**Instance Variables:**\n\n- fID - the numeric ID of the corresponding graph open in GraphUI.\n- fInt1 - the graph's generic integer 1 attribute\n- fInt2 - the graph's generic integer 2 attribute\n- fReal1 - the graph's generic real 1 attribute\n- fReal2 - the graph's generic real 2 attribute\n- fIntLabel - the graph's generic integer 1 label attribute\n- fInt2Label - the graph's generic integer 2 label attribute\n- fReal1Label - the graph's generic real 1 label attribute\n- fReal2Label - the graph's generic real 2 label attribute\n\n**Methods:**\n\n- GetID()\n Returns the fID instance variable\n- AddNode()\n Adds a node to the corresponding GraphUI graph and returns the ID of the new node.\n- AddEdge(head, tail)\n Adds an edge to the corresponding GraphUI graph and returns the ID to refer to the edge as\n- DeleteNode(theNode)\n Deletes the node from the corresponding GraphUI graph\n- DeleteEdge(theEdge)\n Deletes the edge from the corresponding GraphUI graph\n\n128\nSelect(theselection)\n Selects every graph component in theSelection set in the corresponding GraphUI graph\nUnselect(theselection)\n Unselects every graph component in theSelection set from the corresponding GraphUI graph\nGetSelection()\n Get the GraphUI selection set for this graph and returns a set of every selected graph component\nClearSelection()\n Clears the GraphUI selection set for this graph\nsetAttributestheAttributes, echo)\n Sets all of the graph’s attributes and tell GraphUI to set them if echo = TRUE\nEchoAttributes(void)\n Sends all of the graph’s attributes to GraphUI (faster than setting one at a time)\nGetAttributes(theAttributes)\n Puts the attributes of this graph into a GraphAttributesType structure.\n\nThe remaining attributes of TGraphModel are Setxxx and Getxxx methods. Setxxx(attribute, echo) methods set the value of the corresponding attribute and has GraphUI set the value if echo = TRUE. For example SetInt1(int1, echo), sets the graph’s probability generic integer 1 attribute. Getxxx methods return the value of a given attribute. These commands get the value as stored by GraphApp, they do not go to GraphUI for the value. A complete list of the Setxxx and Getxxx methods is provided in Appendix B.\n\nTGraph: is the basic graph class. This class type does not make any assumptions as to whether or not the graph is directed and can thus accommodate graphs obtained directly from GraphUI.\n\nInstance Variables:\n fNodeList - a TNodeSet object containing all of the TNode objects in this graph.\n fEdgeList - a TEdgeSet object containing all of the TEdge objects in this graph.\n\nMethods:\n NewNode()\n Creates a new node for this graph, sends correct commands to add the new node in the corresponding GraphUI graph, and returns the newly create TNode object.\n NewEdge(head, tail)\n Creates a new edge which has head node, head, and tail node, tail, and sends the command to add the new edge in the corresponding GraphUI graph. It returns the newly create TEdge object.\n RemoveNode(theNode)\n Removes the node from the node set and deletes the node from the GraphUI graph.\n RemoveEdge(theEdge)\n Removes the edge from the edge set and deletes the edge from the GraphUI graph.\nGetEdgesBetween(node1, node2)\n\nReturns an edge set containing each edge that connects node1 and node2.\n\nGetNodeFromID(nodeID)\n\nReturns the TNode object whose GraphUI ID is equal to nodeID.\n\nGetEdgeFromID(edgeID)\n\nReturns the TEdge object whose GraphUI ID is equal to edgeID.\n\nAdjacent(node1, node2)\n\nReturns TRUE if there is an edge in which node1 is the tail node and node2 is the head node. Otherwise it returns FALSE. (This is used by the complete graph algorithm)\n\nMakeAdjacent(node1, node2)\n\nCreates an edge in which node1 is the tail node and node2 is the head node if one does not exist. The edge is added to the corresponding GraphUI graph.\n\nTDiGraph: is the directed graph class which is descendent of TGraph.\n\nInstance Variables:\n(See TGraph)\n\nMethods:\nNewEdge(head, tail)\n\nCreates a new edge which has head node, head, and tail node, tail, for this graph, and sends command to add the new edge in the corresponding GraphUI graph. It ensures the edge is directed, and returns the newly create TEdge object.\n\nInitializeFromGraph(graph)\n\nThis method initializes the DiGraph from a TGraph object passed to it. It clones each of the nodes and edges in graph and adds them to the node list and edge list of this directed graph. The GraphUI graph that corresponds is not duplicated; rather each edge is made directed and the isDirected default edge attribute is set. The node and edge IDs of this directed graph correspond to the same GraphUI graph as the original TGraph did.\n\nGetAdjacentEdge(node1, node2)\n\nReturns the TEdge in which node1 is the tail node and node2 is the head node or NULL if there is no such edge.\n\nTUndirectedGraph: is the undirected graph class which is descendent of TGraph.\n\nInstance Variables:\n(See TGraph)\n\nMethods:\nNewEdge(head, tail)\n\nCreates a new edge which has head node, head, and tail node, tail, for this graph, sends correct commands to add the new edge in the corresponding GraphUI graph, ensuring that the edge is not set to directed, and returns the newly create TEdge object.\nAdjacent(node1, node2)\nReturns TRUE if there is an edge in which node1 is connected to node2 regardless of which is the head and which is the tail. Otherwise it returns FALSE.\n\nMakeAdjacent(node1, node2)\nCreates an edge in which node1 is the tail node and node2 is the head node if node1 and node2 are not adjacent. The edge is added to the corresponding GraphUI graph.\n\n6.2.2 Communicating With GraphUI\n\nPrograms that use GraphUI’s application interface do so through message passing. Each time GraphApp wants GraphUI to do some action, for example, change a node’s label, it must send a command to GraphUI. To make it easier to access GraphUI, a set of routines were written that create, format and send all of the GraphUI commands discussed in Chapter 5. Each GraphUI command has been implemented as a method of the TGraphAppApplication object and is described in detail in Appendix B.\n\nEach command whose reply provides information, such as the GetSelection or GetGraph commands, return the replied information in an appropriate format. Functions that obtain information do not return to its caller until a reply has been received from GraphUI. Functions that do not obtain information do not wait for a reply.\n\nInformation messages that can be received from GraphUI to inform a program when a graph has been altered are not used by GraphApp. The only unsolicited message that GraphApp waits for is an ExecuteAlgorithm message.\n6.2.3 Adding Algorithms to GraphApp\n\nTwo steps must be followed to add a new algorithm to GraphApp: the algorithm must be written and the algorithm must be made available to the user. GraphApp has been divided into a number of different source code files to make it easier to add algorithms. Only the UAlgorithms.cp and UGraphApp.h files must be changed to add a new algorithm. To show how an algorithm is added to GraphApp, the method used to add Dijkstra’s shortest path algorithm to GraphApp is outlined.\n\nThe first step was to assign the algorithm a name that would appear in GraphUI’s Algorithms menu and an ID that was unique among the algorithms in GraphApp. The name and ID of the algorithms that are in GraphApp are found in the defines at the start of the UAlgorithms.cp file. The algorithm name was set to \"Shortest Path\" and the ID of the algorithm to 3, Figure 6.9. The name of the algorithm could have been any string but the algorithm ID had to be different from the other two algorithm IDs in GraphApp and not equal to zero, (algorithm ID = 0 is reserved).\n\n```\n// Algorithm IDs Currently in GraphApp. Add new algorithms here\n// NOTE: algorithm ID of 0 is reserved to indicate no algorithm to run\n#define COMPLETE_GRAPH 1\n#define NODE_DEGREES 2\n#define SHORTEST_PATH 3\n\n// Names of algorithms that appear in the GraphUI algorithms menu\n#define COMPLETE_GRAPH_ALG_NM \\\"pComplete Graph - Directed\\\"\n#define NODE_DEGREES_ALG_NM \\\"pNode Degrees\\\"\n#define SHORTEST_PATH_ALG_NM \\\"pShortest Path\\\"\n```\n\nFigure 6.9: List of Algorithm Names and IDs from UAlgorithms.cp\nOnce an algorithm name and ID have been assigned a command must be sent to GraphUI to add the name of the algorithm to GraphUI’s Algorithms menu. The DoSetupAlgorithmsMenu method registers the names of GraphApp’s algorithms when GraphApp connects to GraphUI. An AddAlgorithm call must be added to the DoSetupAlgorithmsMenu to make Shortest Path appear in the menu. The syntax for the add algorithm call is AddAlgorithm(algorithm name, algorithm ID, does the algorithm need a graph). Figure 6.10 shows the AddAlgorithm calls for the algorithms in GraphApp after Shortest Path was added. The NEEDS_GRAPH flag tells GraphUI that the shortest path algorithm must be run on a graph.\n\n```c\n// Add each of the algorithms to GraphUI's menu\nAddAlgorithm(COMplete_GRAPH_ALG_NM, COMPLETE_GRAPH, NEEDS_GRAPH);\nAddAlgorithm(NODE_DEGREES_ALG_NM, NODE_DEGREES, NEEDS_GRAPH);\nAddAlgorithm(SHORTEST_PATH_ALG_NM, SHORTEST_PATH, NEEDS_GRAPH);\n```\n\nFigure 6.10: Setting GraphUI’s Algorithms Menu\n\nGraphUI sends a RUN_ALGORITHM message when the user selects one of GraphApp’s algorithm names from its algorithms menu. Upon receipt of a RUN_ALGORITHM message GraphApp calls ExecuteAlgorithm, a method found in UAlgorithms.cp. ExecuteAlgorithm looks at the ID of the algorithm to be run and calls the appropriate routine to perform the algorithm, see Figure 6.11. A new case statement had to be added to include the shortest path algorithm.\n// Execute the algorithm for the user - Add additional algorithms here based upon algorithm ID\n\nswitch (id) { // What algorithm do we execute?\n\n case COMPLETE_GRAPH:\n this->CompleteGraph(graphID);\n break;\n case NODE_DEGREES:\n this->NodeDegrees(graphID);\n break;\n case SHORTEST_PATH:\n this->ShortestPath(graphID);\n break;\n\n default:\n DisplayText(\"p— Invalid Algorithm ID —\");\n break;\n}\n\nFigure 6.11: The ExecuteAlgorithm Method Handles Run Algorithm Cmds\n\nThe final step to add a new algorithm to GraphApp is to write the algorithm. The algorithm can be a function or a method of the application object. Shortest Path has been implemented as a method of the application object. A description of the syntax of the method was added to UGraphApp.h. This must be done for any new method. Figure 6.12 shows the definitions of the methods that handle the algorithms presently in GraphApp. Place other new methods' descriptions just below the existing definitions.\n\n// Methods which implement the graph algorithms in GraphApp\nvirtual pascal void CompleteGraph(GraphIDType graphID);\nvirtual pascal void NodeDegrees(GraphIDType graphID);\nvirtual pascal void ShortestPath(GraphIDType graphID);\n\nFigure 6.12: Algorithm Method Definitions from UGraphApp.h\n\n134\nAn algorithm can do anything using the methods provided to send commands to GraphUI for managing the user interface and using the graph data structures. Shortest Path begins by obtaining the graph to run the algorithm on. Once it has a TGraph object, it changes the graph to a directed graph, because the shortest path algorithm operates on a directed graph.\n\nThe next step the shortest path algorithm takes is to determine which node is the source node. There are a number of different ways this could have been done. The source node could have been selected, or its source attribute set, or either of the two graph generic integer attributes could have been set to the ID of the source node. The way the source node is obtained in shortest path is by prompting the user for the ID of the source node. If the ID supplied does not correspond to a node of the graph the algorithm issues a warning and terminates.\n\nOnce the algorithm has the source node, it sets the source node's source attribute to true and labels the node with the source attributes so that the user has visual confirmation of the entered source node. The edges of the graph are labeled with their distances so the user is aware of the distance of each edge. The final preparation before starting Dijkstra's algorithm is to set each node to not visited and the cost attribute to the distance of the edge from the source node to the node. If there is no edge connecting the source node to it, the cost is set to infinity. The source node is set to visited, it is selected, and its cost is set to zero (there is no cost to reach the source node).\n\nThe algorithm runs by finding the node with the smallest cost from the unvisited nodes, marking it as visited, and selecting it to indicate that its shortest path has been found. It then updates the costs of the unvisited nodes and continues with the algorithm until the cost of the shortest path has been\ncomputed for each node or the smallest cost is infinity which means the remaining nodes are not reachable from the source node.\n\nBy implementing the graph data structures so they hide most of the communication with GraphUI, the resulting shortest path program, is coded similarly to a shortest path program that does not use GraphUI. What follows is source code of Dijkstra's shortest path algorithm of a program not using GraphUI and the shortest path algorithm as taken from GraphApp. The two versions of the shortest path algorithm are included to show that GraphApp's version looks like graph code not user interface code, satisfying a criteria of the design. Finally the GraphApp's Complete Directed Graph and Node Degrees algorithms are included as two additional examples of programming with GraphUI.\nShortest Path Algorithm Without GraphUI:\n\n```pascal\nvoid TGraphAppApplication::ShortestPath(GraphIDType graphID) {\n float graph[MAX][MAX]; // the current graph\n Boolean visited[MAX]; // visited[i] - was node i visited?\n float cost[MAX]; // cost[i] - cost of reaching node i\n int sourceNode; // number of the source node\n int nodeWithSmallestDist; // node with the smallest cost value\n int numberOfNodes; // number of nodes in the graph\n int i,j; // loop counters\n\n // Tell the user we are starting the algorithm\n printf(\"Starting Shortest Path Algorithm — \\n\");\n\n // Get the graph from the user in the form of a distance adjacency matrix, this call\n // returns the number of nodes in the graph\n numberOfNodes = GetGraphFromUser(&graph);\n\n // Get the source node to run the algorithm from\n printf(\"Enter number of source node\\n\");\n scanf(\"%i\", &sourceNode);\n\n // Make certain the node the user specified exists\n if ((sourceNode < 0) || (sourceNode >= numberOfNodes)) {\n printf(\"Source node specified does not exist, algorithm terminating\\n\");\n return;\n }\n\n // Set up for the algorithm, we use the visited array to indicate that the\n // shortest path to a node has been found, and the cost array to save the\n // costs of reaching each node.\n for (i = 0; i < numberOfNodes; i++) {\n visited[i] = FALSE;\n cost[i] = INFINITY;\n // Determine if this node has an edge from the source node to this one\n if (graph[sourceNode,i] != INFINITY) {\n cost[i] = graph[sourceNode,i];\n }\n }\n\n // Set the source node to visited and cost to zero since we are here\n visited[sourceNode] = TRUE;\n cost[sourceNode] = 0;\n\n // Find the node with the smallest cost and add that node to the set of visited nodes, then\n // update the costs of the remaining unvisited nodes\n for (i = 0; i < numberOfNodes; i++) {\n // find the node with the smallest distance which has not yet been visited\n float smallestDist = INFINITY;\n nodeWithSmallestDist = MAX;\n // additional code...\n }\n\n // additional code...\n}\n```\n\nfor (j = 0; j < numberOfNodes; j++) {\n if (!visited[j] && (cost[j] < smallestDist)) {\n smallestDist = cost[j];\n nodeWithSmallestDist = j;\n }\n}\n\n// if the nodeWithSmallestDist is not set, then we are through, set i and get out of main\n// loop\nif (nodeWithSmallestDist == MAX) {\n i = numberOfNodes;\n}\nelse {\n // else keep going\n\n // Got the node with the smallest distance not yet visited, mark that node as visited\n visited[nodeWithSmallestDist] = TRUE;\n printf(\"Cost of reaching node %i is %f\\n\", nodeWithSmallestDist, smallestDist);\n\n // Update all of the distances\n for (j = 0; j < numberOfNodes; j++) {\n if (visited[j]) {\n if (graph[nodeWithSmallestDist, aNode] + cost[nodeWithSmallestDist] < cost[j]) {\n cost[j] = graph[nodeWithSmallestDist, aNode] + cost[nodeWithSmallestDist];\n }\n }\n }\n\n // Tell the user we have completed the algorithm\n printf(\"Finished Shortest Path Algorithm — \\n\");\n}\nShortest Path Algorithm Using GraphUI:\n\npascal void TGraphAppApplication::ShortestPath(GraphIDType graphID) {\n\n TGraph *graph;\n TDiGraph *directedGraph;\n TNodeIDType sourceID;\n TNode *sourceNode;\n TNode *nodeWithSmallestDist;\n TNode *aNode;\n TEdge *anEdge;\n EdgeAttributesType edgeAttr;\n NodeAttributesType nodeAttr;\n AttrFlagType changeAttr;\n CostType cost;\n int i, j;\n\n // Tell the user we are starting the algorithm\n DisplayText(\"pStarting Shortest Path Algorithm -- \");\n\n // Get the graph that the user is looking at\n graph = this->GetGraph(graphID);\n\n // Make the graph directed for this algorithm\n directedGraph = new TDiGraph;\n FailNIL(directedGraph);\n directedGraph->InitializeFromGraph(graph);\n graph->Free(); // get rid of the graph\n\n // Get the source node to run the algorithm from\n sourceID = (TNodeIDType)GetInteger(\"pEnter ID of Source Node\");\n sourceNode = directedGraph->GetNodeFromID(sourceID);\n\n // Make certain the node the user specified exists\n if (sourceNode == NULL) {\n DisplayText(\"pSource node specified does not exist, algorithm terminating\");\n return;\n }\n\n // show the user which node is the source node\n sourceNode->SetSource(TRUE, !ECHO);\n sourceNode->setLabel(kNodeSourceLabel, !ECHO);\n sourceNode->EchoAttributes();\n\n // Label all of the edges with their distances\n edgeAttr.label = kEdgeDistanceLabel;\n changeAttr = LABEL_FLAG;\n SetEdgeAttr(graphID, ALL_EDGES, edgeAttr, changeAttr);\n\n // Label all of the nodes with their costs so we can observe as they are computed\nnodeAttr.label = kNodeCostLabel;\nnodeAttr.cost = -1;\nchangeAttr = LABEL_FLAG | COST_FLAG;\nSetNodeAttr(graphID, ALL_EDGES, nodeAttr, changeAttr);\n\n// Set up for the algorithm. We use the visited attribute to indicate that the\n// shortest path to a node has been found, and cost to save the\n// cost of reaching a node. These these two variable changes are not echoed\n// to GraphUI and are used as intermediate variables for this algorithm\n// Cost is only echoed after we have determined that it is the cheapest way\n\nfor (i = 1; i <= directedGraph->fNodeList->GetSize(); i++) {\n aNode = (TNode *)directedGraph->fNodeList->At(i);\n aNode->SetVisited(FALSE, !ECHO);\n cost = INFINITY;\n aNode->SetCost(&cost, !ECHO);\n // Determine if this node has an edge from the source node to this one\n anEdge = directedGraph->GetAdjacentEdge(sourceNode, aNode);\n if (anEdge != NULL) {\n cost = (CostType)anEdge->GetDistance();\n aNode->SetCost(&cost, !ECHO);\n }\n}\n\n// Set the source node to visited and cost is zero since we are here\nsourceNode->SetVisited(TRUE, !ECHO);\nsourceNode->SetCost(0, ECHO);\n\nfor (i = 2; i <= directedGraph->fNodeList->GetSize(); i++) {\n // find the node with the smallest distance which has not yet been visited\n float smallestDist = INFINITY;\n nodeWithSmallestDist = NULL;\n for (j = 1; j <= directedGraph->fNodeList->GetSize(); j++) {\n aNode = (TNode *)directedGraph->fNodeList->At(j);\n if (!aNode->GetVisited() && (aNode->GetCost() < smallestDist)) {\n smallestDist = aNode->GetCost();\n nodeWithSmallestDist = aNode;\n }\n }\n\n // if the nodeWithSmallestDist is not set, then we are through, set i and get out of main\n // loop\n if (nodeWithSmallestDist == NULL) {\n i = (int)(directedGraph->fNodeList->GetSize() + 1);\n } else { // else keep going\n\n // Got the node with the smallest distance not yet visited, Mark that node as visited\n nodeWithSmallestDist->SetVisited(TRUE, !ECHO);\n cost = nodeWithSmallestDist->GetCost();\n\n // Check if there is an edge from the node with the smallest distance not yet visited to another node\n anEdge = directedGraph->GetAdjacentEdge(nodeWithSmallestDist, aNode);\n if (anEdge != NULL) {\n cost = (CostType)anEdge->GetDistance();\n aNode->SetCost(&cost, !ECHO);\n }\n\n // Mark the node as visited\n nodeWithSmallestDist->SetVisited(TRUE, !ECHO);\n cost = nodeWithSmallestDist->GetCost();\n }\n}\n\n}\nnodeWithSmallestDist->SetCost(&cost, ECHO);\n\n// Update all of the distances\nfor (j = 1; j <= directedGraph->fNodeList->GetSize(); j++) {\n aNode = (TNode *)directedGraph->fNodeList->At(j);\n if (!aNode->GetVisited()) {\n anEdge = directedGraph->GetAdjacentEdge(nodeWithSmallestDist, aNode);\n if (anEdge != NULL) {\n if (anEdge->GetDistance() + nodeWithSmallestDist->GetCost()) < \n aNode->GetCost() {\n cost = (anEdge->GetDistance() + nodeWithSmallestDist->GetCost());\n aNode->SetCost(&cost, !ECHO);\n }\n }\n }\n}\n\n// All done with the graph so free it\ndirectedGraph->Free();\n\n// Tell the user we have completed the algorithm\nDisplayText(\"Finished Shortest Path Algorithm — \");\n}\nComplete Graph Algorithm:\n\npascal void TGraphAppApplication::CompleteGraph(GraphIDType graphID) {\n\n // The purpose of this command is to complete a directed graph\n TGraph *graphToComplete;\n TDiGraph *directedGraph;\n\n // Tell user we are starting the algorithm\n DisplayText(\"\\pStarting Complete Graph Algorithm \");\n\n // Get the graph from GraphUI\n graphToComplete = this->GetGraph(graphID);\n\n // Make the graph into a directed graph\n directedGraph = new TDiGraph;\n FailNIL(directedGraph);\n directedGraph->InitializeFromGraph(graphToComplete);\n graphToComplete->Free();\n\n // For each node in the graph see if it is connected to ever other node\n // in the graph. If they are not connected, connect them.\n for (int i = 1; i < directedGraph->fNodeList->GetSize(); i++) {\n TNode *aNode = (TNode *)directedGraph->fNodeList->At(i);\n for (int j = i+1; j <= directedGraph->fNodeList->GetSize(); j++) {\n TNode *anotherNode = (TNode *)directedGraph->fNodeList->At(j);\n directedGraph->MakeAdjacent(aNode,anotherNode);\n directedGraph->MakeAdjacent(anotherNode, aNode);\n }\n }\n\n // We no longer need the graph so free it\n directedGraph->Free();\n\n DisplayText(\"\\pFinished Complete Graph Algorithm \");\n}\nNode Degrees Algorithm:\n\npascal void TGraphAppApplication::NodeDegrees(GraphIDType graphID) {\n\n // Compute and display the node degrees\n TGraph *graph; // Graph to operate on\n TNode *node; // a node of the graph\n NodeAttributesType nodeAttributes; // attributes for setting node attributes\n AttrFlagType changeLabel; // change the attributes label\n TSet *selection; // all selected nodes and edges\n TNodeSet *selectedNodes; // Nodes selected by the user\n\n // Tell user we are starting the algorithm\n DisplayText(\"Starting Node Degree Algorithm — \");\n\n // Get the graph to do the algorithm on\n graph = GetGraph(graphID);\n\n // Get the selection set of the Graph\n selection = GetSelection(graph);\n\n // Get a subset of containing only selected nodes\n node = new TNode;\n FailNIL(node);\n selectedNodes = NewNodeSet();\n selection->MakeClassSubSet(node->GetClass(), (TSet *)selectedNodes);\n\n // Calculate the degree of each selected node\n if (selectedNodes->GetSize() > 0) {\n\n // label each node with genericInt1, which contains the degree\n changeLabel = GENERIC_INT1_FLAG | LABEL_FLAG;\n nodeAttributes.label = kNodeInt1Label;\n\n // For each selected node get its degree and set its int1 variable to the degree\n for (int i = 1; i <= selectedNodes->GetSize(); i++) {\n node = (TNode *)selectedNodes->At(i);\n nodeAttributes.genericInt1 = node->Degree();\n SetNodeAttr(graphID, node->GetID(), nodeAttributes, changeLabel);\n }\n } else { // else there were no selected nodes\n DisplayText(\"Only computes degrees of selected nodes\");\n }\n\n // Tell user we are finished the algorithm\n DisplayText(\"Completed Node Degree Algorithm — \");\n\n //Node Degrees\n\n143\n6.3 Epilogue\n\nIn developing GraphApp, experiments were done to determine the overhead caused by communicating with GraphUI, taking note of the speed of the animation of algorithms. GraphApp's communication was initially programmed using asynchronous message passing, not waiting for a reply from any command. While this method made an algorithm and its animation run very quickly, full use of GraphUI was not possible. Any command that required a reply could not be used and special states had to be created in GraphApp to obtain the active graph before running an algorithm.\n\nThe next method of communication tried was synchronous message passing. GraphApp waited for the reply to each command before continuing. This second method made all of GraphUI's commands available but the animation ran much slower.\n\nThe method of communication finally used in GraphApp was a combination of the first two methods. When sending commands whose reply only provides an error message, GraphApp does not wait for the reply and ignores it when it does arrive. When sending commands that provide information in their reply such as AddNode, GetGraph or GetInteger, GraphApp waits until the reply is received before continuing. By combining both synchronous and asynchronous message passing, speed versus functionality is optimized.\n\nIt is important to note that these experiments performed to determine the most efficient way to communicate with GraphUI required no changes to GraphUI. This shows that different types of interface experiments can be\nperformed but do not require the experimenter to have intimate knowledge of GraphUI.\n7. Conclusions\n\nWe have demonstrated through the application interface of GraphUI that we can provide an application interface to an adaptable graph user interface tool that does not require altering the tool. Message passing with a command set and information messages allows our adaptable graph user interface tool, GraphUI, to be completely separated from the programs that use it. Programs are able to use GraphUI’s application interface and run not only on the same computer as GraphUI but on other computers which can physically connect to GraphUI. The command language and information messages permit applications to control the manner in which input is obtained from users, to control how graphs and other textual information are displayed to users, and to respond appropriately to user or other program actions.\n\nGraphUI is a completed Macintosh graph user interface server program which affords graph programs a centralized graph user interface. It was important that GraphUI adhered to the Macintosh user interface guidelines so the user interface it provides behaves in a consistent manner. Adhering to the guidelines also ensured that our program could be integrated with word processors and drawing packages for reporting results of algorithms using GraphUI’s application interface.\nIt was discovered through experimenting with the application interface that communicating with GraphUI using a combination of asynchronous and synchronous message passing optimizes the performance of the application interface.\n\n7.1 Future Work\n\nWith GraphUI complete there are a number of new areas that may be pursued. Most of the future work outlined for GraphUI is in specific graph theory domains and in particular in developing graph algorithm programs that use GraphUI's application interface. The following section outlines areas for additional research using GraphUI.\n\n7.1.1 Graph Programs\n\nThe full benefits of GraphUI's application interface will not be realized until a number of different domain specific graph programs have been written to use it. There is a need for a set of fundamental graph theory algorithms to use with GraphUI. From a base of fundamental graph algorithms, domain specific applications can be constructed. Presently, plans are being made to begin work on a suite of network reliability tools to work with GraphUI. Network reliability was the original motivation for building our adaptable user interface tool.\n\nAnother area of program development which should not be overlooked is existing code. Taking an existing graph program which does not\nhave a satisfactory user interface and modifying it to use GraphUI or to take an existing library of graph routines and change it to animate its algorithms through GraphUI would be worthwhile.\n\nWork can also be done with GraphUI on the animation of algorithms, in particular to animate a number of algorithms used in courses to make them easier for students to comprehend.\n\nGraphUI has a command language that is designed to be flexible and to allow GraphUI to be used in diversified domains. Only through programming with GraphUI can it be determined if there are any features that are lacking or not well handled in the interface.\n\n7.1.2 Communication Platforms\n\nCurrently the programs that have been written for GraphUI have been developed for Macintosh computers. The sample program included in this thesis provides a starting point for writing graph programs which run on Macintosh computers. Similar sample programs must be developed for other computers. To be included in each sample program is code that manages a physical connection to GraphUI, code that automates the sending of commands, and code that manages information messages from GraphUI.\n\nA good starting point is to develop a sample program which communicates serially on a Unix workstation such as the Sun or the HP. No changes to GraphUI would be necessary. There is a connection manager serial tool so no programming would be necessary for the Macintosh end of the communications. The Unix sample program would be responsible for handling communications through the serial port of the computer.\nIt will take considerable work to implement the communications for each new platform, but once the initial program has been written, others for the same platform will be much easier, especially if the first program is designed as a platform for constructing new graph programs.\n\n7.1.3 Extensions to GraphUI\n\nThe representation used by GraphUI to display nodes and edges is fixed. To provide a more accurate picture for a user, it is worthwhile to provide a means of changing what nodes and edges look like. This is particularly important for displaying nodes. Nodes of a graph can represent almost any form of physical data, a circle may not be sufficient to represent the data. One representation that would be worthwhile to network reliability programmers is to display nodes as subgraphs. Factoring algorithms often build graphs of subgraph components, a representation for subgraphs would therefore be useful.\n\nThe design of GraphUI focused on the application interface and the commands and information messages which it is comprised of. As programs are developed which use GraphUI, commands may need to be changed or added. One such change that is foreseen is an improved means of managing the algorithms menu. The linear algorithms menu is not well suited for programs that contain many different algorithms. A hierarchical menu system for the algorithms would help to rectify this drawback.\n\nAs program development begins, it may become apparent that certain attributes are missing from the sets of attributes and others are not being used. The attribute set should be adjusted according to the findings.\nGraphUI was designed to allow graph programs to potentially run on computers other than Macintoshes by forcing the separation of user interface from graph algorithms. For Macintosh graph algorithm applications, it is possible to incorporate their algorithms directly into GraphUI, resulting in a single application. This can be done using the already defined application interface to GraphUI but forgoing the sending of messages.\n\n7.2 Contributions\n\nIn closing we would like to summarize the contributions that were made by the work described in this thesis.\n\n1. We have proposed and implemented a solution to the problem that existing adaptable graph user interface tools require modifying the tool's code when graph programs use their GUI capabilities and alter the default user control over graph programs. Our solution presents an adaptable graph user interface tool, GraphUI, which uses message passing to provide graph programs GUI capabilities. Programmers do not have to use the same development environment used to implement GraphUI because graph programs and GraphUI are not combined into a single program.\n\n2. Our application interface provides an open architecture which permits several graph programs running on different computers to simultaneously access GraphUI's user interface capabilities. The open architecture of GraphUI allows users to access the functionality of different programs, possibly...\nrunning on different computers, transparently from one standardized user interface. For example, an application which specializes in graph layout can be run together with another graph application.\nAppendix A: GraphUI Detailed Message Information\n\n************** Message Error Codes\nNO_ERROR = 0\nBAD_COMMAND_SIZE = -1\nINVALID_OPCODE = -2\nBAD_GRAPH_ID = -3\nBAD_NODE_ID = -4\nBAD_EDGE_ID = -5\nNO_COMMAND = -6\nNACK = -9999\n\n************** Message Opcodes\nADD_GRAPH = 0x0000\nDELETE_GRAPH = 0x0001\nADD_NODE = 0x0002\nDELETE_NODE = 0x0003\nADD_EDGE = 0x0004\nDELETE_EDGE = 0x0005\nCONTRACT_EDGE = 0x0006\nMOVE_NODE = 0x0007\nGET_GRAPH = 0x0008\nSET_GRAPH_ATTRIBUTES = 0x0009\nGET_GRAPH_ATTRIBUTES = 0x000A\nSET_NODE_ATTRIBUTES = 0x000B\nGET_NODE_ATTRIBUTES = 0x000C\nSET_EDGE_ATTRIBUTES = 0x000D\nGET_EDGE_ATTRIBUTES = 0x000E\nGET_REAL = 0x000F\nGET_INTEGER = 0x0010\nSET_ALGORITHM = 0x0011\nDISPLAY_TEXT = 0x0013\nADD_TO_SELECTION = 0x0014\nREMOVE_FROM_SELECTION = 0x0016\nCLEAR_SELECTION = 0x0018\nGET_SELECTION = 0x0019\nDELETE_ALGORITHM = 0x001A\nSET_MESSAGING = 0x001B\n\n// The following are the opcodes of information messages\n\nRUN_ALGORITHM = 0x0012\n\nGRAPH_ADDED = 0x8000\nGRAPH_DELETED = 0x8001\nNODE_ADDED = 0x8002\n**Variable types in messages**\n\ntypedef short OpType\n\ntypedef *OpPtr\n\ntypedef short GraphIDType\n\ntypedef short NodeIDType\n\ntypedef short EdgeIDType\n\ntypedef short AlgorithmIDType\n\ntypedef short ErrorCodeType\n\ntypedef short StepsType\n\ntypedef Point NodeLocationType\n\ntypedef float ProbabilityType\n\ntypedef float CostType\n\ntypedef float CapacityType\n\ntypedef float WeightType\n\ntypedef int NodeRadiusType\n\ntypedef short EdgeThicknessType\n\ntypedef float FlowType\n\ntypedef float DistanceType\n\ntypedef short LabelType\n\ntypedef Str255 NameType\n\ntypedef Str255 PromptType\n\ntypedef int CounterType\n\ntypedef long AttrFlagType\n\n// ** Attributes of Graphs, Nodes, and Edges **\n\ntypedef struct {\n int genericInt1;\n int genericInt2;\n float genericFloat1;\n float genericFloat2;\n NameType genericInt1Label;\n NameType genericInt2Label;\n NameType genericFloat1Label;\n NameType genericFloat2Label;\n} GraphAttributesType;\n\ntypedef struct {\n ProbabilityType prob;\n}\ntypedef struct {\n ProbabilityType prob;\n LabelType label;\n NameType name;\n EdgeThicknessType thickness;\n Boolean isDirected;\n NodeIDType headNode;\n NodeIDType tailNode;\n FlowType flow;\n DistanceType distance;\n CostType cost;\n CapacityType capacity;\n int genericInt1;\n int genericInt2;\n float genericFloat1;\n float genericFloat2;\n NameType genericInt1Label;\n NameType genericInt2Label;\n NameType genericFloat1Label;\n NameType genericFloat2Label;\n | EdgeAttributesType;\n | NodeAttributesType;\n\nAppendix B: GraphApp Implementation Details\n\nSetxxx and Getxxx Methods of TNode\n\nSetProbability(prob, echo)\nGetProbability()\nSetLabel(label, echo)\nGetLabel()\nSetName(name, echo)\nGetName()\nSetRadius(radius, echo)\nGetRadius()\nSetCost(cost, echo)\nGetCost()\nSetCapacity(capacity, echo)\nGetCapacity()\nSetWeight(weight, echo)\nGetWeight()\nSetVisited(visited, echo)\nGetVisited()\nSetSource(source, echo)\nGetSource()\nSetTarget(target, echo)\nGetTarget()\nSetInt1(int1, echo)\nGetInt1()\nSetInt2(int2, echo)\nGetInt2()\nSetReal1(real1, echo)\nGetReal1()\nSetReal2(real2, echo)\nGetReal2()\nSetInt1Label(label, echo)\nGetInt1Label()\nSetInt2Label(label, echo)\nGetInt2Label()\nSetReal1Label(label, echo)\nGetReal1Label()\nSetReal2Label(label, echo)\nGetReal2Label()\nSetxxx and Getxxx Methods of TEdge\n\nSetProbability(prob, echo)\nGetProbability()\nSetLabel(label, echo)\nGetLabel()\nSetName(name, echo)\nNameType GetName(void)\nSetThickness(radius, echo)\nGetThickness()\nSetDistance(distance, echo)\nGetDistance()\nSetFlow (flow, echo)\nGetFlow()\nSetCapacity(capacity, echo)\nGetCapacity()\nSetCost(cost, echo)\nGetCost()\nSetIsDirected(isDirected, echo)\nGetIsDirected()\nSetInt1(int1, echo)\nGetInt1()\nSetInt2(int2, echo)\nGetInt2()\nSetReal1(real1, echo)\nGetReal1()\nSetReal2(real2, echo)\nGetReal2()\nSetInt1Label(label, echo)\nGetInt1Label()\nSetInt2Label(label, echo)\nGetInt2Label()\nSetReal1Label(label, echo)\nGetReal1Label()\nSetReal2Label(label, echo)\nGetReal2Label()\n**Setxxx and Getxxx Methods of TGraphModel**\n\nSetInt1(int1, echo)\nGetInt1()\nSetInt2(int2, echo)\nGetInt2()\nSetReal1(real1, echo)\nGetReal1()\nSetReal2(real2, echo)\nGetReal2()\nSetInt1Label(label, echo)\nGetInt1Label()\nSetInt2Label(label, echo)\nGetInt2Label()\nSetReal1Label(label, echo)\nGetReal1Label()\nSetReal2Label(label, echo)\nGetReal2Label()\nCommunicating with GraphUI\n\nThe following are TGraphAppApplication methods which are used to communicate with GraphUI\n\nAddGraph()\n - returns : ID of the newly created graph\n\nAddNode(theGraph)\n - theGraph is the ID of the graph to add the node to\n - returns : ID of the newly created node\n\nAddEdge(theGraph, head, tail)\n - theGraph is the ID of the graph to add the edge to\n - head is the ID of the edge's head node\n - tail is the ID of the edge's tail node\n - returns : ID of the newly created edge\n\nRemoveGraph(theGraph)\n - theGraph is the ID of the graph to be closed\n - returns : nothing\n\nRemoveNode(theGraph, theNode)\n - theGraph is the ID of the graph containing the node to be deleted\n - theNode is the ID of the node to be deleted\n - returns : nothing\n\nRemoveEdge(theGraph, theEdge)\n - theGraph is the ID of the graph containing the edge to be deleted\n - theEdge is the ID of the edge to be deleted\n - returns : nothing\n\nDisplayText(theText)\n - a Pascal string to be appended to the applications' transcript\n - returns : nothing\n\nAddAlgorithm(theAlgorithm, ID, needsGraph)\n - theAlgorithm is the name of the algorithm for the algorithm menu\n - ID is the numeric ID to specify when asking to run the algorithm\n - needsGraph if TRUE must execute on a graph, FALSE no graph\n - returns : nothing\n\nDeleteAlgorithm(algorithmID)\n - algorithmID is the ID of the algorithm to remove from the menu\n - returns : nothing\n\nGetGraph(graphID)\n- graphID is the ID of the graph to return\n- returns: a TGraph object which is the graph that was obtained\n\nGetInteger(thePrompt)\n- thePrompt is the Pascal string to prompt the user with\n- returns: the integer the user entered\n\nGetReal(thePrompt)\n- thePrompt is the Pascal string to prompt the user with\n- returns: the real number the user entered\n\nMoveNode(theGraph, theNode, newLoc)\n- theGraph is the ID of the graph containing the node to be moved\n- theNode is the ID of the node to be moved\n- newLoc is the (X,Y) window coordinate to move the node to\n- returns: nothing\n\nContractEdge(theGraph, theEdge)\n- theGraph is the ID of the graph containing the edge to be contracted\n- theEdge is the ID of the edge to be contracted\n- returns: nothing\n\nSetGraphAttr(theGraph, attr, whichAttrs)\n- theGraph is the ID used to determine which attributes are to be set\n (see GraphUI's SET_GRAPH_ATTRIBUTES command)\n- attr are the attribute values\n- whichAttrs is a flag indicating which attributes to set\n- returns: nothing\n\nSetNodeAttr(theGraph, nodeID, attr, whichAttrs)\n- theGraph is the ID of the graph containing the node\n- theNode is the ID used to determine which attributes are to be set\n (see GraphUI's SET_NODE_ATTRIBUTES command)\n- attr are the attribute values\n- whichAttrs is a flag indicating which attributes to set\n- returns: nothing\n\nSetEdgeAttr(theGraph, edgeID, attr, whichAttrs)\n- theGraph is the ID of the graph containing the edge\n- theEdge is the ID used to determine which attributes are to be set\n (see GraphUI's SET_EDGE_ATTRIBUTES command)\n- attr are the attribute values\n- whichAttrs is a flag indicating which attributes to set\n- returns: nothing\n\nGetGraphAttr(theGraph, attr)\n- theGraph is the ID used to determine which attributes are to be gotten\n (see GraphUI's GET_GRAPH_ATTRIBUTES command)\n- attr are the returned attribute values\n- returns: nothing\n\nGetNodeAttr(ograph, nodeID, attr)\n - theGraph is the ID of the graph containing the node\n - theNode is the ID used to determine which attributes are to be gotten\n (see GraphUI's GET_NODE_ATTRIBUETES command)\n - attr are the returned attribute values\n - returns: nothing\n\nGetEdgeAttr(ograph, edgeID, attr)\n - theGraph is the ID of the graph containing the edge\n - theEdge is the ID used to determine which attributes are to be gotten\n (see GraphUI's GET_EDGE_ATTRIBUETES command)\n - attr are the returned attribute values\n - returns: nothing\n\nClearSelection(ograph)\n - theGraph is the ID of the graph whose selection is to be cleared\n - returns: nothing\n\nAddToSel(graphID, numNodes, numEdges, theNodes, theEdges)\n - theGraph is the ID of the graph whose selection is to be added to\n - numNodes is the number of nodes to be selected\n - numEdges is the number of edges to be selected\n - theNodes is a handle to a list of IDs of nodes that are to be selected\n - theEdges is a handle to a list of IDs edges that are to be selected\n - returns: nothing\n\nRemoveFromSel(graphID, numNodes, numEdges, theNodes, theEdges)\n - theGraph is the ID of the graph whose selection is to be affected\n - numNodes is the number of nodes to be unselected\n - numEdges is the number of edges to be unselected\n - theNodes is a handle to a list of IDs of nodes that are to be unselected\n - theEdges is a handle to a list of IDs edges that are to be unselected\n - returns: nothing\n\nGetSelection(graph)\n - graph is the graph object whose selection set is requested\n - returns: a set containing the node and edge objects of graph that are selected\nReferences\n\n\n"}}},{"rowIdx":162,"cells":{"id":{"kind":"string","value":"d11b827aaed16cb3c66bd08843b0f14fdf0a96e8"},"text":{"kind":"string","value":"Oracle Berkeley DB Java Edition\n\nGetting Started with Berkeley DB Java Edition\n\nRelease 3.2\nLegal Notice\n\nThis documentation is distributed under an open source license. You may review the terms of this license at: http://www.oracle.com/technology/software/products/berkeley-db/htdocs/jeoslicense.html\n\nOracle, Berkeley DB, Berkeley DB Java Edition and Sleepycat are trademarks or registered trademarks of Oracle. All rights to these marks are reserved. No third-party use is permitted without the express prior written consent of Oracle.\n\nJava™ and all Java-based marks are a trademark or registered trademark of Sun Microsystems, Inc., in the United States and other countries.\n\nTo obtain a copy of this document’s original source code, please submit a request to the Oracle Technology Network forum at: http://forums.oracle.com/forums/forum.jspa?forumID=273\n\nPublished 11/9/2007\nTable of Contents\n\nPreface .................................................................................................................. v\nConventions Used in this Book ........................................................................ v\nFor More Information ......................................................................................... vi\n\n1. Introduction to Berkeley DB Java Edition ................................................... 1\nFeatures .............................................................................................................. 1\nThe JE Application ........................................................................................... 3\nDatabases and Database Environments .......................................................... 3\nDatabase Records ............................................................................................. 4\nPutting and Getting Database Records ......................................................... 4\nDuplicate Data ................................................................................................. 4\nReplacing and Deleting Entries ....................................................................... 5\nSecondary Databases ....................................................................................... 5\nTransactions ...................................................................................................... 5\nJE Resources ..................................................................................................... 6\nApplication Considerations ............................................................................... 7\nJE Backup and Restore ....................................................................................... 7\nJCA Support ....................................................................................................... 8\nJMX Support ..................................................................................................... 8\nGetting and Using JE ......................................................................................... 9\nJE Exceptions ..................................................................................................... 9\nSix Things Everyone Should Know about JE Log Files ...................................... 10\n\n2. Database Environments .............................................................................. 11\nOpening Database Environments ..................................................................... 11\nClosing Database Environments ....................................................................... 12\nEnvironment Properties .................................................................................... 13\nThe EnvironmentConfig Class ......................................................................... 13\nEnvironmentMutableConfig ............................................................................ 14\nEnvironment Statistics ..................................................................................... 16\nDatabase Environment Management Example ............................................... 16\n\n3. Databases ..................................................................................................... 19\nOpening Databases ........................................................................................... 19\nDeferred Write Databases ............................................................................... 20\nClosing Databases ............................................................................................. 22\nDatabase Properties .......................................................................................... 23\nAdministrative Methods .................................................................................... 25\nDatabase Example ............................................................................................. 26\n\n4. Database Records ........................................................................................ 30\nUsing Database Records .................................................................................. 30\nReading and Writing Database Records ........................................................... 32\nWriting Records to the Database ...................................................................... 32\nGetting Records from the Database ................................................................... 33\nDeleting Records ............................................................................................... 35\nData Persistence ................................................................................................. 35\nUsing the BIND APIs ........................................................................................ 36\nNumerical and String Objects ......................................................................... 36\nSerializable Complex Objects .......................................................................... 38\n## Usage Caveats ................................................................. 39\n## Serializing Objects ............................................................. 40\n## Deserializing Objects .......................................................... 42\n## Custom Tuple Bindings ....................................................... 43\n## Using Comparators .......................................................................... 47\n## Writing Comparators ............................................................... 47\n## Setting Comparators ............................................................... 48\n## Database Record Example ...................................................... 49\n### 5. Using Cursors ................................................................................... 61\n#### Opening and Closing Cursors .................................................... 61\n#### Getting Records Using the Cursor .............................................. 62\n##### Searching for Records .............................................................. 64\n##### Working with Duplicate Records ............................................. 67\n#### Putting Records Using Cursors ............................................... 69\n#### Deleting Records Using Cursors .............................................. 71\n#### Replacing Records Using Cursors .......................................... 72\n#### Cursor Example ............................................................................. 73\n### 6. Secondary Databases .......................................................................... 78\n#### Opening and Closing Secondary Databases ................................ 79\n#### Implementing Key Creators ......................................................... 81\n#### Secondary Database Properties ................................................. 84\n#### Reading Secondary Databases .................................................. 84\n#### Deleting Secondary Database Records ..................................... 85\n#### Using Secondary Cursors ......................................................... 86\n#### Database Joins .............................................................................. 87\n##### Using Join Cursors .................................................................... 88\n##### JoinCursor Properties .............................................................. 91\n#### Secondary Database Example .................................................. 91\n#### Opening Secondary Databases with MyDbEnv .......................... 93\n#### Using Secondary Databases with ExamplelntventoryRead .......... 96\n### 7. Backing up and Restoring Berkeley DB Java Edition Applications .............................................................................. 99\n#### Databases and Log Files ......................................................... 99\n##### Log File Overview ................................................................. 99\n##### Cleaning the Log Files .......................................................... 100\n##### The BTree ............................................................................ 100\n##### Database Modifications and Syncs ............................................ 100\n##### Normal Recovery ............................................................... 101\n#### Performing Backups .................................................................. 101\n##### Performing a Hot Backup ....................................................... 101\n##### Performing an Offline Backup ............................................... 102\n##### Using the DbBackup Helper Class ........................................... 102\n#### Performing Catastrophic Recovery .......................................... 104\n#### Hot Standby ................................................................................ 104\n### 8. Administering Berkeley DB Java Edition Applications ................. 106\n#### The JE Properties File ............................................................ 106\n#### Managing the Background Threads ............................................ 106\n##### The Cleaner Thread ............................................................... 107\n##### The Checkpointer Thread ....................................................... 108\n#### Sizing the Cache ......................................................................... 108\nThe Command Line Tools ................................................................. 109\nDbDump ......................................................................................... 109\nDbLoad ........................................................................................ 111\nDbVerify ....................................................................................... 112\nPreface\n\nWelcome to Berkeley DB Java Edition (JE). This document introduces JE, version 3.2. It is intended to provide a rapid introduction to the JE API set and related concepts. The goal of this document is to provide you with an efficient mechanism with which you can evaluate JE against your project's technical requirements. As such, this document is intended for Java developers and senior software architects who are looking for an in-process data management solution. No prior experience with Berkeley DB Java Edition is expected or required.\n\nConventions Used in this Book\n\nThe following typographical conventions are used within this manual:\n\nClass names are represented in monospaced font, as are method names. For example: \"The Environment.openDatabase() method returns a Database class object.\"\n\nVariable or non-literal text is presented in italics. For example: \"Go to your JE_HOME directory.\"\n\nProgram examples are displayed in a monospaced font on a shaded background. For example:\n\n```java\nimport com.sleepycat.je.Environment;\n...\n// Open the environment. Allow it to be created if it does not already exist.\nEnvironment myDbEnv;\n```\n\nIn some situations, programming examples are updated from one chapter to the next. When this occurs, the new code is presented in monospaced bold font. For example:\n\n```java\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.EnvironmentConfig;\nimport java.io.File;\n...\n// Open the environment. Allow it to be created if it does not already exist.\nEnvironment myDbEnv;\nEnvironmentConfig envConfig = new EnvironmentConfig();\nenvConfig.setAllowCreate(true);\nmyDbEnv = new Environment(new File(\"/export/dbEnv\"), envConfig);\n```\n\nFinally, notes of interest are represented using a note block such as this.\nFor More Information\n\nBeyond this manual, you may also find the following sources of information useful when building a JE application:\n\nChapter 1. Introduction to Berkeley DB Java Edition\n\nWelcome to Berkeley DB Java Edition (JE). JE is a general-purpose, transaction-protected, embedded database written in 100% Java (JE makes no JNI calls). As such, it offers the Java developer safe and efficient in-process storage and management of arbitrary data.\n\nJE requires Java J2SE 1.4.2 or later.\n\nIn addition to the APIs described in this book, JE also offers the Direct Persistence Layer (DPL). The DPL is implemented as a layer on top of JE. Using it, you can cause any Java type to be persistent without implementing special interfaces.\n\nWe recommend that you use the DPL if all you want is to make classes with relatively static schemas to be persistent.\n\nThe only caveat to this recommendation is that the DPL requires Java 1.5, while JE does not. If you want to use Java 1.4, you must use the JE APIs.\n\nYou can find a brief introduction to the DPL in the Berkeley DB Java Edition Getting Started with the Direct Persistence Layer guide.\n\nFeatures\n\nJE provides an enterprise-class Java-based data management solution. You use JE through a series of Java APIs. All you need to get started is to add a single jar file to your application's classpath. See Getting and Using JE (page 9) for more information.\n\nJE offers the following major features:\n\n• Large database support. JE databases efficiently scale from one to millions of records. The size of your JE databases are likely to be limited more by hardware resources than by any limits imposed upon you by JE.\n\nDatabases are described in Databases (page 19).\n\n• Multiple thread and process support. JE is designed for multiple threads of control. Both read and write operations can be performed by multiple threads. JE uses record-level locking for high concurrency in threaded applications. Further, JE uses timeouts for deadlock detection to help you ensure that two threads of control do not deadlock indefinitely.\n\nMoreover, JE allows multiple processes to access the same databases. However, in this configuration JE requires that there be no more than one process allowed to write to the database. Read-only processes are guaranteed a consistent, although potentially out of date, view of the stored data as of the time that the environment is opened.\n\n• Database records. All database records are organized as simple key/data pairs. Both keys and data can be anything from primitive Java types to the most complex of Java objects.\nDatabase records are described in Database Records (page 30).\n\n- Transactions. Transactions allow you to treat one or more operations on one or more databases as a single unit of work. JE transactions offer the application developer recoverability, atomicity, and isolation for your database operations.\n\n Note that transaction protection is optional. Transactions are described in the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n\n- Indexes. JE allows you to easily create and maintain secondary indices for your primary data through the use of secondary databases. In this way, you can obtain rapid access to your data through the use of an alternative, or secondary, key.\n\n Indexes are described in Secondary Databases (page 78).\n\n- In-memory cache. The cache allows for high speed database access for both read and write operations by avoiding unnecessary disk I/O. The cache will grow on demand up to a pre-configured maximum size. To improve your application's performance immediately after startup time, you can preload your cache in order to avoid disk I/O for production requests of your data.\n\n Cache management is described in Sizing the Cache (page 108).\n\n- Log files. JE databases are stored in one or more sequential numerically-named log files in the environment directory. The log files are write-once and are portable across platforms with different endian-ness.\n\n Note that unlike other database implementations, there is no distinction between database files (that is, the \"material database\") and log files. Instead JE employs a log-based storage system to protect database modifications. Before any change is made to a database, JE writes information about the change to the log file.\n\n Note that JE's log files are not binary compatible with Berkeley DB's database files. However, both products provide dump and load utilities, and the files that these operate on are compatible across product lines.\n\n JE's log files are described in more detail in Backing up and Restoring Berkeley DB Java Edition Applications (page 99). For information on using JE's dump and load utilities, see The Command Line Tools (page 109). Finally, for a short list of things to know about log files while you are learning JE, see Six Things Everyone Should Know about JE Log Files (page 10).\n\n- Background threads. JE provides several threads that manage internal resources for you. The checkpoint is responsible for flushing database data to disk that was written to cache as the result of a transaction commit (this is done in order to shorten recovery time). The compressor thread removes subtrees from the database that are empty because of deletion activity. Finally, the cleaner thread is responsible for cleaning and removing unneeded log files, thereby helping you to save on disk space.\n\n Background thread management is described in Managing the Background Threads (page 106).\n• Database environments. Database environments provide a unit of encapsulation and management for one or more databases. In addition, an environment is the unit of management for internal resources such as the in-memory cache and the background threads. Environments are also used to manage concurrency and transactions. Note that all applications using JE are required to use database environments.\n\nDatabase environments are described in Database Environments (page 11).\n\n• Backup and restore. JE's backup procedure consists of simply copying JE's log files to a safe location for storage. To recover from a catastrophic failure, you copy your archived log files back to your production location on disk and reopen the JE environment.\n\nNote that JE always performs normal recovery when it opens a database environment. Normal recovery brings the database to a consistent state based on change information found in the database log files.\n\nJE's backup and recovery mechanisms are described in Backing up and Restoring Berkeley DB Java Edition Applications (page 99).\n\n• JCA. JE provides support for the Java Connector Architecture. See JCA Support (page 8) for more information.\n\n• JMX. JE provides support for Java Management Extensions. See JMX Support (page 8) for more information.\n\nThe JE Application\n\nThis section provides a brief overview to the major concepts and operations that comprise a JE application. This section is concluded with a summary of the decisions that you need to make when building a JE application.\n\nNote that the core JE classes are all contained in the com.sleepycat.je package. In addition, this book describes some classes that are found in com.sleepycat.je.bind. The bind APIs are used for converting Java objects in and out of byte arrays.\n\nDatabases and Database Environments\n\nTo use a JE database, you must first create or open a JE database environment. Database environments require you to identify the directory on disk where the environment lives. This location must exist before you create the environment.\n\nYou open a database environment by instantiating an Environment object. Your Environment instance is called an environment handle.\n\nOnce you have opened an environment, you can use it to open any number of databases within that environment. Each such database is encapsulated by a Database object. You are required to provide a string that uniquely identifies the database when you open it. Like environments, the Database instance is sometimes referred to as a database handle.\nYou use the environment handle to manage database environments and database opens through methods available on the Environment class. You use the database handle to manage individual databases through methods available on the Database class. Further, you use environment handles to close environments, and you use database handles to close databases.\n\nNote that for both databases and environments, you can optionally allow JE to create them if they do not exist at open time.\n\nEnvironments are described in greater detail in Database Environments (page 11). Databases are described in greater detail in Databases (page 19).\n\n**Database Records**\n\nDatabase records are represented as simple key/data pairs. Both record keys and record data must be byte arrays and are passed to and returned from JE using DatabaseEntry instances. DatabaseEntry only supports storage of Java byte arrays. Complex objects must be marshalled using either Java serialization, or more efficiently with the bind APIs provided with JE.\n\nDatabase records and byte array conversion are described in Database Records (page 30).\n\n**Putting and Getting Database Records**\n\nYou store records in a Database by calling one of the put methods on a Database handle. JE automatically determines the record's proper placement in the database's internal B-Tree using whatever key and data comparison functions that are available to it.\n\nYou can also retrieve, or get, records using the Database handle. Gets are performed by providing the key (and sometimes also the data) of the record that you want to retrieve.\n\nYou can also use cursors for database puts and gets. Cursors are essentially a mechanism by which you can iterate over the records in the database. Like databases and database environments, cursors must be opened and closed. Cursors are managed using the Cursor class.\n\nDatabases are described in Databases (page 19). Cursors are described in Using Cursors (page 61).\n\n**Duplicate Data**\n\nAt creation time, databases can be configured to allow duplicate data. Remember that JE database records consist of a key/data pair. Duplicate data, then, occurs when two or more records have identical keys, but different data. By default, a Database does not allow duplicate data.\n\nIf your Database contains duplicate data, then a simple database get based only on a key returns just the first record that uses that key. To access all duplicate records for that key, you must use a cursor.\nReplacing and Deleting Entries\n\nHow you replace database records depends on whether duplicate data is allowed in the database.\n\nIf duplicate data is not allowed in the database, then simply calling `Database.put()` with the appropriate key will cause any existing record to be updated with the new data. Similarly, you can delete a record by providing the appropriate key to the `Database.delete()` method.\n\nIf duplicate data is allowed in the database, then you must position a cursor to the record that you want to update, and then perform the put operation using the cursor.\n\nTo delete records, you can use either `Database.delete()` or `Cursor.delete()`. If duplicate data is not allowed in your database, then these two method behave identically. However, if duplicates are allowed in the database, then `Database.delete()` deletes every record that uses the provided key, while `Cursor.delete()` deletes just the record at which the cursor is currently positioned.\n\nSecondary Databases\n\nSecondary Databases provide a mechanism by which you can automatically create and maintain secondary keys or indices. That is, you can access a database record using a key other than the one used to store the record in the first place.\n\nWhen you are using secondary databases, the database that holds the data you are indexing is called the primary database.\n\nYou create a secondary database by opening it and associating it with an existing primary database. You must also provide a class that generates the secondary's keys (that is, the index) from primary records. Whenever a record in the primary database is added or changed, JE uses this class to determine what the secondary key should be.\n\nWhen a primary record is created, modified, or deleted, JE automatically updates the secondary database(s) for you as is appropriate for the operation performed on the primary.\n\nYou manage secondary databases using the `SecondaryDatabase` class. You identify how to create keys for your secondary databases by supplying an instance of a class that implements the `SecondaryKeyCreator` interface.\n\nSecondary databases are described in Secondary Databases (page 78).\n\nTransactions\n\nTransactions provide a high level of safety for your database operations by allowing you to manage one or more database operations as if they were a single unit of work. Transactions provide your database operations with recoverability, atomicity, and isolation.\nTransactions provide recoverability by allowing JE to undo any transactional-protected operations that may have been in progress at the time of an application or system failure.\n\nTransactions provide atomicity by allowing you to group many database operations into a single unit of work. Either all operations succeed or none of them do. This means that if one write operation fails for any reason, then all other writes contained within that transaction also fail. This ensures that the database is never partially updated as the result of an only partially successful chain of read/write operations.\n\nTransactions provide isolation by ensuring that the transaction will never write to a record that is currently in use (for either read or write) by another transaction. Similarly, any record to which the transaction has written can not be read outside of the transaction until the transaction ends. Note that this is only the default behavior; you can configure your Database, Cursor, or Transaction handle to relax its isolation guarantees.\n\nEssentially, transactional isolation provides a transaction with the same unmodified view of the database that it would have received had the operations been performed in a single-threaded application.\n\nTransactions may be long or short lived, they can encompass as many database operations as you want, and they can span databases so long as all participating databases reside in the same environment.\n\nTransaction usage results in a performance penalty for the application because they generally require more disk I/O than do non-transactional operations. Therefore, while most applications will use transactions for database writes, their usage is optional. In particular, processes that are performing read-only access to JE databases might not use transactions. Also, applications that use JE for an easily recreated cache might also choose to avoid transactions.\n\nUsing transactions with your JE applications is described in detail in the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n\nJE Resources\n\nJE has some internal resources that you may want to manage. Most important of these is the in-memory cache. You should carefully consider how large the JE cache needs to be. If you set this number too low, JE will perform potentially unnecessary disk I/O which will result in a performance hit. If you set it too high, then you are potentially wasting RAM that could be put to better purposes.\n\nNote that the size that you configure for the in-memory cache is a maximum size. At application startup, the cache starts out fairly small (only about 7% of the maximum allowed size for the cache). It then grows as is required by your application's database operations. Also, the cache is not pinned in memory - it can be paged out by your operating system's virtual memory system.\n\nBeyond the cache, JE uses several background threads to clean the JE log files, to compress the database by removing unneeded subtrees, and to flush database changes seen in the cache to the backing data files. For the majority of JE applications, the default behavior\nfor the background threads should be acceptable and you will not need to manage their behavior. Note that background threads are started no more than once per process upon environment open.\n\nFor more information on sizing the cache and on the background threads, see Administering Berkeley DB Java Edition Applications (page 106).\n\n**Application Considerations**\n\nWhen building your JE application, be sure to think about the following things:\n\n- What data do you want to store? What is best used for the primary key? What is the best representation for primary record data? Think about the most efficient way to move your keys and data in and out of byte arrays. See Database Records (page 30) for more information.\n\n- Does the nature of your data require duplicate record support? Remember that duplicate support can be configured only at database creation time. See Opening Databases (page 19) for more information.\n\n If you are supporting duplicate records, you may also need to think about duplicate comparators (not just key comparators). See Using Comparators (page 47) for more information.\n\n- What secondary indexes do you need? How can you compute your secondary indexes based on the data and keys stored in your primary database? Indexes are described in Secondary Databases (page 78).\n\n- What cache size do you need? See Sizing the Cache (page 108) for information on how to size your cache.\n\n- Does your application require transactions (most will). Transactions are described in the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n\n**JE Backup and Restore**\n\nTo backup your database, copy the .jdb files starting from the lowest numbered log file to the highest numbered log file to your backup media. Be sure to copy the bytes of the individual database files in order from the lowest to the highest. You do not have to close your database or otherwise cease database operations when you do this.\n\nRestoring a JE database from a backup consists of closing your JE environment, copying archived log files back into your environment directory and then opening your JE environment again.\n\nNote that whenever a JE environment is opened, JE runs normal recovery. This involves bringing your database into a consistent state given the changed data found in the database. If you are using transactions during normal operations, then JE automatically runs checkpoints for you so as to limit the time required to run this recovery. In any case,\nrunning normal recovery is a routine operation, while performing database restores is not.\n\nFor more information on JE backup and restores, and on checkpoints, see Backing up and Restoring Berkeley DB Java Edition Applications (page 99).\n\nJCA Support\n\nJCA is the Java Connector Architecture. This architecture provides a standard for connecting the J2EE platform to legacy enterprise information systems (EIS), such as ERP systems, database systems, and legacy applications not written in Java. JE supports this architecture.\n\nUsers who want to run JE within a J2EE Application Server can use the JCA Resource Adapter to connect to JE through a standard API. The JE Resource Adapter supports all three J2EE application server transaction types:\n\n- No transaction.\n- Local transactions.\n- XA transactions.\n\nJCA also includes the Java Transaction API (JTA), which means that JE supports 2 phase commit (XA). Therefore, JEs can participate in distributed transactions managed by either a J2EE server or the applications direct use of the JTA API.\n\nThe JE distribution includes an example showing JCA usage in a simple EJB. The Resource Adaptor has been tested using JBoss 3.2.6, and the Sun Java System Application Server, version 8.1. Instructions for how to build the Resource Adapter and run a simple “smoke test” example for each of the application servers can be found here:\n\n`JE_HOME/examples/jca/HOWTO-jboss.txt`\n\nand\n\n`JE_HOME/examples/jca/HOWTO-sjsas.txt`\n\nJMX Support\n\nJMX is the Java Management Extensions. This extension provides tools for managing and monitoring devices, applications, and service-driven networks. JE supports this extension.\n\nThe JE distribution supplies an MBean that can be deployed for monitoring a JE environment in any JMX server (such as an J2EE application server). Alternatively, applications can use JE helper classes to add JE monitoring to their own JMX MBean implementations.\n\nFor information on how to deploy the standalone JE JMX MBean, or on how to use JE helper classes to build an application-specific MBean, see:\n\n`JE_HOME/examples/jmx/README.txt`\nGetting and Using JE\n\nYou can obtain JE by visiting the JE download page:\n\nTo install JE, simple untar or unzip the distribution to the directory of your choice. If you use unzip, make sure to specify the \\-U option in order to preserve case.\n\nFor more information on installing JE, see JE_HOME/docs/relnotes.html, where JE_HOME is the directory where you unpacked JE.\n\nYou can use JE with your application by adding JE_HOME/lib/je-<version>.jar to your application's classpath.\n\nBeyond this manual, you can find documentation for JE at JE_HOME/docs/index.html directory. In particular, complete Javadoc for the JE API set is available at JE_HOME/docs/java/index.html.\n\nJE Exceptions\n\nBefore describing the Java API usage, it is first useful to examine the exceptions thrown by those APIs. So, briefly, this section describes the exceptions that you can expect to encounter when writing JE applications.\n\nAll of the JE APIs throw DatabaseException. DatabaseException extends java.lang.Exception. Also, the following classes are subclasses of DatabaseException:\n\n- DatabaseNotFoundException\n\n Thrown whenever an operation requires a database, and that database cannot be found.\n\n- DeadlockException\n\n Thrown whenever a transaction is selected to resolve a deadlock. Upon receiving this exception, any open cursors must be closed and the enclosing transaction aborted. Transactions are described in the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n\n- RunRecoveryException\n\n Thrown whenever JE experiences a catastrophic error such that recovery needs to be run on the database. If you receive this exception, you must reopen your environment so as to allow normal recovery to run. See Databases and Log Files (page 99) for more information on how normal recovery works.\n\nNote that when reopening your environment, you should stop all database read and write activities, close all your cursors, close all your databases, and then close and reopen your environment.\nNote that DatabaseException and its subclasses belong to the com.sleepycat.je package.\n\nSix Things Everyone Should Know about JE Log Files\n\nJE log files are not like the log files of other database systems. Nor are they like the log files or database files created by Berkeley DB C Edition. In this guide you will learn more about log files as you go along, but it is good to keep the following points in mind as you begin using JE.\n\n1. JE log files are \"append only\". Record insertions, deletions, and updates are always added at the end of the current file. The first file is named 00000000.jdb. When that file grows to a certain size (10 MB by default) a new file named 00000001.jdb becomes the current file, and so on.\n\n2. There are no separate database files. Unlike Berkeley DB C Edition, databases are not stored in files that are separate from the transaction log. The transaction log and the database records are stored together in a single sequential log consisting of multiple log files.\n\n3. The JE cleaner is responsible for reclaiming unused disk space. When the records in a log file are superseded by deletions or updates recorded in a later log file, the older log file is no longer fully utilized. The cleaner, which operates by default as a separate thread, determines the least utilized log files, copies any still utilized records in those files to the end of the current log file, and finally deletes the now completely un-utilized log file.\n\nSee The Cleaner Thread (page 107) for more information on the cleaner.\n\n4. Cleaning does not start immediately and never produces 100% utilization. Until you have written enough data to create several log files, and some of that data is obsoleted through deletions and updates, you will not notice any log files being deleted by the cleaner. By default cleaning occurs in the background and maintains the log files at 50% utilization. You can configure a higher utilization value, but configuring too high a utilization value will reduce overall performance.\n\n5. Cleaning is not automatically performed when closing the environment. If you wish to reduce unused disk space to a minimum at a particular point in time, you must explicitly call a method to perform log cleaning. See the Closing Database Environments (page 12) for more information.\n\n6. Log file deletion only occurs after a checkpoint. The cleaner prepares log files to be deleted, but file deletion must be performed after a checkpoint to ensure that the files are no longer referenced. Checkpoints occur on their own schedule, which is every 20 MB of log written, by default. This is part of the reason that you will not see log files being deleted until after several files have been created.\nChapter 2. Database Environments\n\nBerkeley DB Java Edition requires that all databases be placed in a database environment. Database environments encapsulate one or more databases. This encapsulation provides your threads with efficient access to your databases by allowing a single in-memory cache to be used for each of the databases contained in the environment. This encapsulation also allows you to group operations performed against multiple databases inside a single transactions (see the Berkeley DB Java Edition Getting Started with Transaction Processing guide for more information).\n\nMost commonly you use database environments to create and open databases (you close individual databases using the individual database handles). You can also use environments to delete and rename databases. For transactional applications, you use the environment to start transactions. For non-transactional applications, you use the environment to sync your in-memory cache to disk.\n\nFinally, you also use the database environment for administrative and configuration activities related to your database log files and the in-memory cache. See Administering Berkeley DB Java Edition Applications (page 106) for more information.\n\nFor information on managing databases using database environments, see Databases (page 19). To find out how to use environments with a transaction-protected application, see the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n\nOpening Database Environments\n\nYou open a database environment by instantiating an Environment object. You must provide to the constructor the name of the on-disk directory where the environment is to reside. This directory location must exist or the open will fail.\n\nBy default, the environment is not created for you if it does not exist. Set the creation property to true if you want the environment to be created. For example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.EnvironmentConfig;\nimport java.io.File;\n\n...\n\n// Open the environment. Allow it to be created if it does not already exist.\nEnvironment myDbEnvironment = null;\n\ntry {\n EnvironmentConfig envConfig = new EnvironmentConfig();\n```\nYour application can open and use as many environments as you have disk and memory to manage, although most applications will use just one environment. Also, you can instantiate multiple Environment objects for the same physical environment.\n\nOpening an environment usually causes some background threads to be started. JE uses these threads for log file cleaning and some administrative tasks. However, these threads will only be opened once per process, so if you open the same environment more than once from within the same process, there is no performance impact on your application. Also, if you open the environment as read-only, then the background threads (with the exception of the evictor thread) are not started.\n\nNote that opening your environment causes normal recovery to be run. This causes your databases to be brought into a consistent state relative to the changed data found in your log files. See Databases and Log Files (page 99) for more information.\n\n**Closing Database Environments**\n\nYou close your environment by calling the Environment.close() method. This method performs a checkpoint, so it is not necessary to perform a sync or a checkpoint explicitly before calling it. For information on checkpoints, see the Berkeley DB Java Edition Getting Started with Transaction Processing guide. For information on syncs, see Database Modifications and Syncs (page 100).\n\n```java\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\n...\ntry {\n if (myDbEnvironment != null) {\n myDbEnvironment.close();\n }\n} catch (DatabaseException dbe) {\n // Exception handling goes here\n}\n```\n\nYou should close your environment(s) only after all other database activities have completed and you have closed any databases currently opened in the environment.\n\nIt is possible for the environment to close before JE's cleaner thread has finished its work. This happens if you perform a large number of deletes immediately before shutting down your environment. The result is that your log files may be quit a lot larger than you expect them to be because the cleaner thread has not had a chance to finish its work.\nSee The Cleaner Thread (page 107) for details on the cleaner threads.\n\nSee the Getting Started with Berkeley DB Java Edition guide for information on the cleaner threads.\n\nIf you want to make sure that the cleaner has finished running before the environment is closed, call `Environment.cleanLog()` before calling `Environment.close()`:\n\n```java\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\n...\ntry {\n if (myDbEnvironment != null) {\n myDbEnvironment.cleanLog(); // Clean the log before closing\n myDbEnvironment.close();\n }\n} catch (DatabaseException dbe) {\n // Exception handling goes here\n}\n```\n\nClosing the last environment handle in your application causes all internal data structures to be released and the background threads to be stopped. If there are any opened databases, then JE will complain before closing them as well. At this time, any open cursors are also closed, and any on-going transactions are aborted. At this time, any on-going transactions are aborted.\n\n## Environment Properties\n\nYou set properties for the `Environment` using the `EnvironmentConfig` class. You can also set properties for a specific `Environment` instance using `EnvironmentMutableConfig`.\n\n### The EnvironmentConfig Class\n\nThe `EnvironmentConfig` class makes a large number of fields and methods available to you. Describing all of these tuning parameters is beyond the scope of this manual. However, there are a few properties that you are likely to want to set. They are described here.\n\nNote that for each of the properties that you can commonly set, there is a corresponding getter method. Also, you can always retrieve the `EnvironmentConfig` object used by your environment using the `Environment.getConfig()` method.\n\nYou set environment configuration parameters using the following methods on the `EnvironmentConfig` class:\n\n- `EnvironmentConfig.setAllowCreate()`\nIf true, the database environment is created when it is opened. If false, environment open fails if the environment does not exist. This property has no meaning if the database environment already exists. Default is false.\n\n- EnvironmentConfig.setReadOnly()\n\n If true, then all databases opened in this environment must be opened as read-only. If you are writing a multi-process application, then all but one of your processes must set this value to true. Default is false.\n\n You can also set this property using the je.env.isReadOnly parameter in your env_home/jem.properties file.\n\n- EnvironmentConfig.setTransactional()\n\n If true, configures the database environment to support transactions. Default is false.\n\n You can also set this property using the je.env.isTransactional parameter in your env_home/jem.properties file.\n\nFor example:\n\n```java\npackage je.gettingStarted;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.EnvironmentConfig;\nimport java.io.File;\n...\nEnvironment myDatabaseEnvironment = null;\ntry {\n EnvironmentConfig envConfig = new EnvironmentConfig();\n envConfig.setAllowCreate(true);\n envConfig.setTransactional(true);\n myDatabaseEnvironment =\n new Environment(new File(\"/export/dbEnv\"), envConfig);\n} catch (DatabaseException dbe) {\n System.err.println(dbe.toString());\n System.exit(1);\n}\n```\n\n**EnvironmentMutableConfig**\n\nEnvironmentMutableConfig manages properties that can be reset after the Environment object has been constructed. In addition, EnvironmentConfig extends EnvironmentMutableConfig, so you can set these mutable properties at Environment construction time if necessary.\nThe `EnvironmentMutableConfig` class allows you to set the following properties:\n\n- `setCachePercent()`\n \n Determines the percentage of JVM memory available to the JE cache. See Sizing the Cache (page 108) for more information.\n\n- `setCacheSize()`\n \n Determines the total amount of memory available to the database cache. See Sizing the Cache (page 108) for more information.\n\n- `setTxnNoSync()`\n \n Determines whether change records created due to a transaction commit are written to the backing log files on disk. A value of `true` causes the data to not be flushed to disk. See the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n\n- `setTxnWriteNoSync()`\n \n Determines whether logs are flushed on transaction commit (the logs are still written, however). By setting this value to `true`, you potentially gain better performance than if you flush the logs on commit, but you do so by losing some of your transaction durability guarantees.\n\nThere is also a corresponding getter method (`getTxnNoSync()`). Moreover, you can always retrieve your environment's `EnvironmentMutableConfig` object by using the `Environment.getMutableConfig()` method.\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.EnvironmentMutableConfig;\nimport java.io.File;\n\n...\n\ntry {\n Environment myEnv = new Environment(new File(\"/export/dbEnv\"), null);\n EnvironmentMutableConfig envMutableConfig =\n new EnvironmentMutableConfig();\n envMutableConfig.setTxnNoSync(true);\n myEnv.setMutableConfig(envMutableConfig);\n} catch (DatabaseException dbe) {\n```\nEnvironment Statistics\n\nJE offers a wealth of information that you can examine regarding your environment's operations. The majority of this information involves numbers relevant only to the JE developer and as such a description of those statistics is beyond the scope of this manual.\n\nHowever, one statistic that is very important (especially for long-running applications) is `EnvironmentStats.getNCacheMiss()`. This statistic returns the total number of requests for database objects that were not serviceable from the cache. This number is important to the application administrator who is attempting to determine the proper size for the in-memory cache. See Sizing the Cache (page 108) for details.\n\nTo obtain this statistic from your environment, call `Environment.getStats()` to return an `EnvironmentStats` object. You can then call the `EnvironmentStats.getNCacheMiss()` method. For example:\n\n```java\nimport com.sleepycat.je.Environment;\n...\nlong cacheMisses = myEnv.getStats(null).getNCacheMiss();\n...\n```\n\nNote that `Environment.getStats()` can only obtain statistics from with your application's process. In order for the application administrator to obtain this statistic, you must either use JMX to retrieve the statistic (see JMX Support (page 8) ) or you must print it for examination (for example, log the value once a minute).\n\nRemember that what is really important for cache sizing is the change in this value over time, and not the actual value itself. So you might consider offering a delta from one examination of this statistic to the next (a delta of 0 is desired while large deltas are an indication that the cache is too small).\n\nDatabase Environment Management Example\n\nThis example provides a complete class that can open and close an environment. It is both extended and used in subsequent examples in this book to open and close both environments and databases. We do this so as to make the example code shorter and easier to manage. You can find this class in:\n\n```bash\nJE_HOME/examples/je/gettingStarted/MyDbEnv.java\n```\n\nwhere `JE_HOME` is the location where you placed your JE distribution.\nExample 2.1. Database Environment Management Class\n\nFirst we write the normal class declarations. We also set up some private data members that are used to manage environment creation. We use the class constructor to instantiate the EnvironmentConfig object that is used to configure our environment when we open it.\n\n```java\n// File MyDbEnv.java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.EnvironmentConfig;\nimport java.io.File;\n\npublic class MyDbEnv {\n private Environment myEnv;\n\n public MyDbEnv() {} // Constructor\n\n public void setup(File envHome, boolean readOnly) throws DatabaseException {\n // Instantiate an environment configuration object\n EnvironmentConfig myEnvConfig = new EnvironmentConfig();\n // Configure the environment for the read-only state as identified by\n // the readOnly parameter on this method call.\n myEnvConfig.setReadOnly(readOnly);\n // If the environment is opened for write, then we want to be able to\n // create the environment if it does not exist.\n myEnvConfig.setAllowCreate(!readOnly);\n\n // Instantiate the Environment. This opens it and also possibly\n // creates it.\n myEnv = new Environment(envHome, myEnvConfig);\n }\n\n public Environment getEnv() {\n return myEnv;\n }\n}\n```\n\nNext we need a method to open the environment. This is responsible for instantiating our Environment object. Remember that instantiation is what opens the environment (or creates it if the creation property is set to true and the environment does not currently exist).\n\n```java\npublic void setup(File envHome, boolean readOnly) throws DatabaseException {\n // Instantiate an environment configuration object\n EnvironmentConfig myEnvConfig = new EnvironmentConfig();\n // Configure the environment for the read-only state as identified by\n // the readOnly parameter on this method call.\n myEnvConfig.setReadOnly(readOnly);\n // If the environment is opened for write, then we want to be able to\n // create the environment if it does not exist.\n myEnvConfig.setAllowCreate(!readOnly);\n\n // Instantiate the Environment. This opens it and also possibly\n // creates it.\n myEnv = new Environment(envHome, myEnvConfig);\n}\n```\n\nNext we provide a getter method that allows us to retrieve the Environment directly. This is needed for later examples in this guide.\n\n```java\n// Getter methods\npublic Environment getEnv() {\n return myEnv;\n}\n```\nFinally, we need a method to close our Environment. We wrap this operation in a try block so that it can be used gracefully in a finally statement.\n\n```java\n// Close the environment\npublic void close() {\n if (myEnv != null) {\n try {\n myEnv.close();\n } catch (DatabaseException dbe) {\n System.err.println(\"Error closing environment\" +\n dbe.toString());\n }\n }\n}\n```\n\nThis completes the MyDbEnv class. While not particularly useful as it currently exists, we will build upon it throughout this book so that it will eventually open and close all of the databases required by our applications.\n\nWe can now use MyDbEnv to open and close a database environment from the appropriate place in our application. For example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport java.io.File;\n\n...\n\nMyDbEnv exampleDbEnv = new MyDbEnv();\n\ntry {\n try {\n exampleDbEnv.setup(new File(\"/directory/currently/exists\"), true);\n ...\n } catch (DatabaseException dbe) {\n // Error code goes here\n }\n} finally {\n exampleDbEnv.close();\n}\n```\nChapter 3. Databases\n\nIn Berkeley DB Java Edition, a database is a collection of records. Records, in turn, consist of key/data pairings.\n\nConceptually, you can think of a Database as containing a two-column table where column 1 contains a key and column 2 contains data. Both the key and the data are managed using DatabaseEntry class instances (see Database Records (page 30) for details on this class). So, fundamentally, using a JE Database involves putting, getting, and deleting database records, which in turns involves efficiently managing information encapsulated by DatabaseEntry objects. The next several chapters of this book are dedicated to those activities.\n\nNote that on disk, databases are stored in sequentially numerically named log files in the directory where the opening environment is located. JE log files are described Databases and Log Files (page 99).\n\nOpening Databases\n\nYou open a database by using the Environment.openDatabase() method (environments are described in Database Environments (page 11)). This method creates and returns a Database object handle. You must provide Environment.openDatabase() with a database name.\n\nYou can optionally provide Environment.openDatabase() with a DatabaseConfig() object. DatabaseConfig() allows you to set properties for the database, such as whether it can be created if it does not currently exist, whether you are opening it read-only, and whether the database is to support transactions.\n\nNote that by default, JE does not create databases if they do not already exist. To override this behavior, set the creation property to true.\n\nFinally, if you configured your environment and database to support transactions, you can optionally provide a transaction object to the Environment.openDatabase(). Transactions are described in the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n\nThe following code fragment illustrates a database open:\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseConfig;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.EnvironmentConfig;\nimport java.io.File;\n...\nEnvironment myDbEnvironment = null;\nDatabase myDatabase = null;\n...\n\ntry {\n // Open the environment. Create it if it does not already exist.\n EnvironmentConfig envConfig = new EnvironmentConfig();\n envConfig.setAllowCreate(true);\n myDbEnvironment = new Environment(new File(\"/export/dbEnv\"), envConfig);\n\n // Open the database. Create it if it does not already exist.\n DatabaseConfig dbConfig = new DatabaseConfig();\n dbConfig.setAllowCreate(true);\n myDatabase = myDbEnvironment.openDatabase(null,\n \"sampleDatabase\",\n dbConfig);\n} catch (DatabaseException dbe) {\n // Exception handling goes here\n}\n\nDeferred Write Databases\n\nBy default, JE's databases are all persistent. That is, the data they contain is stored on disk so that it can be accessed across program runs. However, it is possible to configure JE's databases so that they are by default not persistent. JE calls databases configured in this way to be deferred write databases.\n\nDeferred write databases are essentially in-memory only databases. Therefore, they are particularly useful for applications that want databases which are truly temporary.\n\nNote that deferred write databases do not always avoid disk I/O. It is particularly important to realize that deferred write databases can page to disk if the cache is not large enough to hold the database's entire contents. Therefore, deferred write database performance is best if your in-memory cache is large enough to hold the database's entire data-set.\nBeyond that, you can deliberately cause data modifications made to a deferred write database to be made persistent. If `Database.sync()` is called before the application is shutdown, the contents of the deferred write database is saved to disk.\n\nIn short, upon reopening an environment and a deferred write database, the database is guaranteed to be in at least the same state it was in at the time of the last database sync. (It is possible that due to a full in-memory cache, the database will page to disk and so the database might actually be in a state sometime after the last sync.) This means that if the deferred write database is never sync’d, it is entirely possible for it to open as an empty database.\n\nBecause modifications made to a deferred write databases can be made persistent at a time that is easily controlled by the programmer, these types of databases are also useful for applications that perform a great deal of database modifications, record additions, deletions, and so forth. By delaying the data write, you delay the disk I/O. Depending on your workload, this can improve your data throughput by quite a lot.\n\nBe aware that you lose modifications to a deferred write database only if you (1) do not call sync, (2) close the deferred write database and (3) also close the environment. If you only close the database but leave the environment opened, then all operations performed on that database since the time of the last environment open may be retained.\n\nAll other rules of behavior pertain to deferred write databases as they do to normal databases. Deferred write databases must be named and created just as you would a normal database. If you want to delete the deferred write database, you must remove it just as you would a normal database. This is true even if the deferred write database is empty because its name persists in the environment’s namespace until such a time as the database is removed.\n\nNote that determining whether a database is deferred write is a configuration option. It is therefore possible to switch a database between “normal” mode and deferred write database. You might want to do this if, for example, you want to load a lot of data to the database. In this case, loading data to the database while it is in deferred write state is faster than in “normal” state, because you can avoid a lot of the normal disk I/O overhead during the load process. Once the load is complete, sync the database, close it, and then reopen it as a normal database. You can then continue operations as if the database had been created as a “normal” database.\n\nTo configure a database as deferred write, set `DatabaseConfig.setDeferredWrite()` to true and then open the database with that `DatabaseConfig` option.\n\nFor example, the following code fragment opens and closes a deferred write database:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseConfig;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.EnvironmentConfig;\n```\nOpening Databases\n\nOnce you are done using the database, you must close it. You use the `Database.close()` method to do this.\n\nClosing a database causes it to become unusable until it is opened again. If any cursors are opened for the database, JE warns you about the open cursors, and then closes them for you. Active cursors during a database close can cause unexpected results, especially if any of those cursors are writing to the database in another thread. You should always make sure that all your database accesses have completed before closing your database.\nRemember that for the same reason, you should always close all your databases before closing the environment to which they belong.\n\nCursors are described in Using Cursors (page 61) later in this manual.\n\nThe following illustrates database and environment close:\n\n```java\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.Environment;\n...\ntry {\n if (myDatabase != null) {\n myDatabase.close();\n }\n\n if (myDbEnvironment != null) {\n myDbEnvironment.close();\n }\n} catch (DatabaseException dbe) {\n // Exception handling goes here\n}\n```\n\n## Database Properties\n\nYou can set database properties using the `DatabaseConfig` class. For each of the properties that you can set, there is a corresponding getter method. Also, you can always retrieve the `DatabaseConfig` object used by your database using the `Database.getConfig()` method.\n\nThe database properties that you can set are:\n\n- `DatabaseConfig.setAllowCreate()`\n\n If `true`, the database is created when it is opened. If false, the database open fails if the database does not exist. This property has no meaning if the database currently exists. Default is `false`.\n\n- `DatabaseConfig.setBtreeComparator()`\n\n Sets the class that is used to compare the keys found on two database records. This class is used to determine the sort order for two records in the database. By default, byte for byte comparison is used. For more information, see Using Comparators (page 47).\n\n- `DatabaseConfig.setDuplicateComparator()`\n\n Sets the class that is used to compare two duplicate records in the database. For more information, see Using Comparators (page 47).\n- DatabaseConfig.setSortedDuplicates()\n\nIf true, duplicate records are allowed in the database. If this value is false, then putting a duplicate record into the database results in an error return from the put call. Note that this property can be set only at database creation time. Default is false.\n\nNote that your database must not support duplicates if it is to be associated with one or more secondary indices. Secondaries are described in Secondary Databases (page 78).\n\n- DatabaseConfig.setExclusiveCreate()\n\nIf true, the database open fails if the database currently exists. That is, the open must result in the creation of a new database. Default is false.\n\n- DatabaseConfig.setReadOnly()\n\nIf true, the database is opened for read activities only. Default is false.\n\n- DatabaseConfig.setTransactional()\n\nIf true, the database supports transactions. Default is false. Note that a database cannot support transactions if the environment is non-transactional.\n\nFor example:\n\n```java\npackage je.gettingStarted;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseConfig;\n...\n// Environment open omitted for brevity\n...\nDatabase myDatabase = null;\ntry {\n DatabaseConfig dbConfig = new DatabaseConfig();\n dbConfig.setAllowCreate(true);\n dbConfig.setSortedDuplicates(true);\n myDatabase =\n myDbEnv.openDatabase(null,\n \"sampleDatabase\",\n dbConfig);\n} catch (DatabaseException dbe) {\n // Exception handling goes here.\n}\n```\nAdministrative Methods\n\nBoth the `Environment` and `Database` classes provide methods that are useful for manipulating databases. These methods are:\n\n- **Database.getDatabaseName()**\n \n Returns the database's name.\n ```java\n String dbName = myDatabase.getDatabaseName();\n ```\n\n- **Database.getEnvironment()**\n \n Returns the `Environment` that contains this database.\n ```java\n Environment theEnv = myDatabase.getEnvironment();\n ```\n\n- **Database.preload()**\n \n Preloads the database into the in-memory cache. Optionally takes a `long` that identifies the maximum number of bytes to load into the cache. If this parameter is not supplied, the maximum memory usage allowed by the evictor thread is used.\n ```java\n myDatabase.preload(1048576l); // 1024*1024\n ```\n\n- **Environment.getDatabaseNames()**\n \n Returns a list of Strings of all the databases contained by the environment.\n ```java\n import java.util.List;\n ...\n List myDbNames = myDbEnv.getDatabaseNames();\n for(int i=0; i < myDbNames.size(); i++) {\n System.out.println(\"Database Name: \" + (String)myDbNames.get(i));\n }\n ```\n\n- **Environment.removeDatabase()**\n \n Deletes the database. The database must be closed when you perform this action on it.\n ```java\n String dbName = myDatabase.getDatabaseName();\n myDatabase.close();\n myDbEnv.removeDatabase(null, dbName);\n ```\n\n- **Environment.renameDatabase()**\n \n Renames the database. The database must be closed when you perform this action on it.\nString oldName = myDatabase.getDatabaseName();\nString newName = new String(oldName + \".new\", \"UTF-8\");\nmyDatabase.close();\nmyDbEnv.renameDatabase(null, oldName, newName);\n\n- Environment.truncateDatabase()\n\nDeletes every record in the database and optionally returns the number of records that were deleted. Note that it is much less expensive to truncate a database without counting the number of records deleted than it is to truncate and count.\n\n```java\nint numDiscarded =\n myEnv.truncate(null, // txn handle\n myDatabase.getDatabaseName(), // database name\n true); // If true, then the\n // number of records\n // deleted are counted.\nSystem.out.println(\"Discarded \" + numDiscarded + \n \" records from database \" + \n myDatabase.getDatabaseName());\n```\n\n### Database Example\n\nIn Database Environment Management Example (page 16) we created a class that manages an Environment. We now extend that class to allow it to open and manage multiple databases. Again, remember that you can find this class in:\n\n```shell\nJE_HOME/je/gettingStarted/MyDbEnv.java\n```\n\nwhere JE_HOME is the location where you placed your JE distribution.\n\n#### Example 3.1. Database Management with MyDbEnv\n\nFirst, we need to import a few additional classes, and setup some global variables to support databases. The databases that we are configuring and creating here are used by applications developed in examples later in this guide.\n\n```java\n// File MyDbEnv.java\n\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.DatabaseConfig;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.EnvironmentConfig;\nimport java.io.File;\n```\npublic class MyDbEnv {\n \n private Environment myEnv;\n private Database vendorDb;\n private Database inventoryDb;\n\n public MyDbEnv() {} \n\n Next we need to update the MyDbEnv.setup() method to instantiate a DatabaseConfig object. We also need to set some properties on that object. These property values are determined by the value of the readOnly parameter. We want our databases to be read-only if the environment is also read-only. We also want to allow our databases to be created if the databases are not read-only.\n\n public void setup(File envHome, boolean readOnly) throws DatabaseException {\n // Instantiate an environment and database configuration object\n EnvironmentConfig myEnvConfig = new EnvironmentConfig();\n DatabaseConfig myDbConfig = new DatabaseConfig();\n // Configure the environment and databases for the read-only state as identified by the readOnly parameter on this method call.\n myEnvConfig.setReadOnly(readOnly);\n myDbConfig.setReadOnly(readOnly);\n // If the environment is opened for write, then we want to be able to create the environment and databases if they do not exist.\n myEnvConfig.setAllowCreate(!readOnly);\n myDbConfig.setAllowCreate(!readOnly);\n\n // Instantiate the Environment. This opens it and also possibly creates it.\n myEnv = new Environment(envHome, myEnvConfig);\n\n // Now create and open our databases.\n vendorDb = myEnv.openDatabase(null,\n \"VendorDB\",\n myDbConfig);\n\n inventoryDb = myEnv.openDatabase(null,\n \"InventoryDB\",\n myDbConfig);\n }\n\n Next we need some additional getter methods used to return our database handles.\n\n // Getter methods\n public Environment getEnvironment() {\n return myEnv;\n }\n}\npublic Database getVendorDB() {\n return vendorDb;\n}\n\npublic Database getInventoryDB() {\n return inventoryDb;\n}\n\nFinally, we need to update the MyDbEnv.close() method to close our databases.\n\n// Close the environment\npublic void close() {\n if (myEnv != null) {\n try {\n vendorDb.close();\n inventoryDb.close();\n myEnv.close();\n } catch(DatabaseException dbe) {\n System.err.println(\"Error closing MyDbEnv: \" +\n dbe.toString());\n System.exit(-1);\n }\n }\n}\n\nWe can now use MyDbEnv to open and close both database environments and databases from the appropriate place in our application. For example:\n\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Database;\nimport java.io.File;\n...\n\nMyDbEnv exampleDbEnv = new MyDbEnv();\n\ntry {\n exampleDbEnv.setup(new File(\"/directory/currently/exists\"), true);\n Database vendorDb = exampleDbEnv.getVendorDB();\n Database inventoryDB = exampleDbEnv.getInventoryDB();\n ...\n} catch(DatabaseException dbe) {\n\n// Error code goes here\n} finally {\n exampleDbEnv.close();\n}\nChapter 4. Database Records\n\nJE records contain two parts — a key and some data. Both the key and its corresponding data are encapsulated in `DatabaseEntry` class objects. Therefore, to access a JE record, you need two such objects, one for the key and one for the data.\n\n`DatabaseEntry` can hold any kind of data from simple Java primitive types to complex Java objects so long as that data can be represented as a Java `byte` array. Note that due to performance considerations, you should not use Java serialization to convert a Java object to a `byte` array. Instead, use the Bind APIs to perform this conversion (see Using the BIND APIs (page 36) for more information).\n\nThis chapter describes how you can convert both Java primitives and Java class objects into and out of `byte` arrays. It also introduces storing and retrieving key/value pairs from a database. In addition, this chapter describes how you can use comparators to influence how JE sorts its database records.\n\nUsing Database Records\n\nEach database record is comprised of two `DatabaseEntry` objects — one for the key and another for the data. The key and data information are passed to- and returned from JE using `DatabaseEntry` objects as `byte` arrays. Using `DatabaseEntry`s allows JE to change the underlying byte array as well as return multiple values (that is, key and data). Therefore, using `DatabaseEntry` instances is mostly an exercise in efficiently moving your keys and your data in and out of `byte` arrays.\n\nFor example, to store a database record where both the key and the data are Java `String` objects, you instantiate a pair of `DatabaseEntry` objects:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseEntry;\n...\nString aKey = \"key\";\nString aData = \"data\";\n\ntry {\n DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes(\"UTF-8\"));\n DatabaseEntry theData = new DatabaseEntry(aData.getBytes(\"UTF-8\"));\n} catch (Exception e) {\n // Exception handling goes here\n}\n```\n\nNotice that we specify `UTF-8` when we retrieve the `byte` array from our `String` object. Without parameters, `String.getBytes()` uses the Java system's default encoding. You should\nnever use a system's default encoding when storing data in a database because the encoding can change.\n\nWhen the record is retrieved from the database, the method that you use to perform this operation populates two `DatabaseEntry` instances for you, one for the key and another for the data. Assuming Java `String` objects, you retrieve your data from the `DatabaseEntry` as follows:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseEntry;\n\n...\n\n// theKey and theData are DatabaseEntry objects. Database retrieval is described later in this chapter. For now, we assume some database get method has populated these objects for us.\n\n// Use DatabaseEntry.getData() to retrieve the encapsulated Java byte array.\n\nbyte[] myKey = theKey.getData();\nbyte[] myData = theData.getData();\n\nString key = new String(myKey, \"UTF-8\");\nString data = new String(myData, \"UTF-8\");\n```\n\nThere are a large number of mechanisms that you can use to move data in and out of `byte` arrays. To help you with this activity, JE provides the bind APIs. These APIs allow you to efficiently store both primitive data types and complex objects in `byte` arrays.\n\nThe next section describes basic database put and get operations. A basic understanding of database access is useful when describing database storage of more complex data such as is supported by the bind APIs. Basic bind API usage is then described in Using the BIND APIs (page 36).\nReading and Writing Database Records\n\nWhen reading and writing database records, be aware that there are some slight differences in behavior depending on whether your database supports duplicate records. Two or more database records are considered to be duplicates of one another if they share the same key. The collection of records sharing the same key are called a duplicates set.\n\nBy default, JE databases do not support duplicate records. Where duplicate records are supported, cursors (see below) are used to access all of the records in the duplicates set.\n\nJE provides two basic mechanisms for the storage and retrieval of database key/data pairs:\n\n- The `Database.put()` and `Database.get()` methods provide the easiest access for all non-duplicate records in the database. These methods are described in this section.\n\n- Cursors provide several methods for putting and getting database records. Cursors and their database access methods are described in Using Cursors (page 61).\n\nWriting Records to the Database\n\nDatabase records are stored in the internal BTree based on whatever sorting routine is available to the database. Records are sorted first by their key. If the database supports duplicate records, then the records for a specific key are sorted by their data.\n\nBy default, JE sorts both keys and the data portion of duplicate records using unsigned byte-by-byte lexicographic comparisons. This default comparison works well for the majority of cases. However, in some case performance benefits can be realized by overriding the default comparison routine. See Using Comparators (page 47) for more information.\n\nYou can use the following methods to put database records:\n\n- `Database.put()`\n\n Puts a database record into the database. If your database does not support duplicate records, and if the provided key already exists in the database, then the currently existing record is replaced with the new data.\n\n- `Database.putNoOverwrite()`\n\n Disallows overwriting (replacing) an existing record in the database. If the provided key already exists in the database, then this method returns `OperationStatus.KEYEXIST` even if the database supports duplicates.\n• Database.putNoDupData()\n\n Puts a database record into the database. If the provided key and data already exists in the database (that is, if you are attempting to put a record that compares equally to an existing record), then this returns OperationStatus.KEYEXIST.\n\nWhen you put database records, you provide both the key and the data as DatabaseEntry objects. This means you must convert your key and data into a Java byte array. For example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\n\n...\n\n// Environment and database opens omitted for clarity.\n// Environment and database must NOT be opened read-only.\n\nString aKey = \"myFirstKey\";\nString aData = \"myFirstData\";\n\ntry {\n DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes(\"UTF-8\"));\n DatabaseEntry theData = new DatabaseEntry(aData.getBytes(\"UTF-8\"));\n myDatabase.put(null, theKey, theData);\n} catch (Exception e) {\n // Exception handling goes here\n}\n```\n\nGetting Records from the Database\n\nThe Database class provides several methods that you can use to retrieve database records. Note that if your database supports duplicate records, then these methods will only ever return the first record in a duplicate set. For this reason, if your database supports duplicates, you should use a cursor to retrieve records from it. Cursors are described in Using Cursors (page 61).\n\nYou can use either of the following methods to retrieve records from the database:\n\n• Database.get()\n\n Retrieves the record whose key matches the key provided to the method. If no records exists that uses the provided key, then OperationStatus.NOTFOUND is returned.\n• Database.getSearchBoth()\n\nRetrieve the record whose key matches both the key and the data provided to the method. If no record exists that uses the provided key and data, then OperationStatus.NOTFOUND is returned.\n\nBoth the key and data for a database record are returned as byte arrays in DatabaseEntry objects. These objects are passed as parameter values to the Database.get() method.\n\nIn order to retrieve your data once Database.get() has completed, you must retrieve the byte array stored in the DatabaseEntry and then convert that byte array back to the appropriate datatype. For example:\n\n```java\npackage je.gettingStarted;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\n...\n// Environment and database opens omitted for clarity. // Environment and database may be opened read-only.\nString aKey = \"myFirstKey\";\ntry {\n // Create a pair of DatabaseEntry objects. theKey // is used to perform the search. theData is used // to store the data returned by the get() operation.\n DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes(\"UTF-8\"));\n DatabaseEntry theData = new DatabaseEntry();\n\n // Perform the get.\n if (myDatabase.get(null, theKey, theData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {\n byte[] retData = theData.getData();\n String foundData = new String(retData, \"UTF-8\");\n System.out.println(\"For key: '\" + aKey + \"' found data: '\" + foundData + \".\");\n } else {\n System.out.println(\"No record found for key '\" + aKey + \".\".\"\");\n }\n} catch (Exception e) {\n // Exception handling goes here\n}\nDeleting Records\n\nYou can use the `Database.delete()` method to delete a record from the database. If your database supports duplicate records, then all records associated with the provided key are deleted. To delete just one record from a list of duplicates, use a cursor. Cursors are described in Using Cursors (page 61).\n\nYou can also delete every record in the database by using `Environment.truncateDatabase()`.\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\n...\n\n// Environment and database opens omitted for clarity.\n// Environment and database can NOT be opened read-only.\n\ntry {\n String aKey = \"myFirstKey\";\n DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes(\"UTF-8\"));\n\n // Perform the deletion. All records that use this key are // deleted.\n myDatabase.delete(null, theKey);\n} catch (Exception e) {\n // Exception handling goes here\n}\n```\n\nData Persistence\n\nWhen you perform a database modification, your modification is made in the in-memory cache. This means that your data modifications are not necessarily flushed to disk, and so your data may not appear in the database after an application restart.\n\nTherefore, if you care if your data is durable across system failures, and to guard against the rare possibility of database corruption, you should use transactions to protect your database modifications. Every time you commit a transaction, JE ensures that the data will not be lost due to application or system failure. Transaction usage is described in the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n\nIf you do not want to use transactions, then the assumption is that your data is of a nature that it need not exist the next time your application starts. You may want this if, for example, you are using JE to cache data relevant only to the current application runtime.\nIf, however, you are not using transactions for some reason and you still want some guarantee that your database modifications are persistent, then you should periodically run environment syncs. Syncs cause any dirty entries in the in-memory cache and the operating system’s file cache to be written to disk. As such, they are quite expensive and you should use them sparingly.\n\nNote that by default, a sync is run every time you close an environment. You can also run a sync by calling the `Environment.sync()` method.\n\nFor a brief description of how JE manages its data in the cache and in the log files, and how sync works, see Databases and Log Files (page 99).\n\n**Using the BIND APIs**\n\nExcept for Java String and boolean types, efficiently moving data in and out of Java byte arrays for storage in a database can be a nontrivial operation. To help you with this problem, JE provides the Bind APIs. While these APIs are described in detail in the *Berkeley DB Java Edition Collections Tutorial*, this section provides a brief introduction to using the Bind APIs with:\n\n- Single field numerical and string objects\n \n Use this if you want to store a single numerical or string object, such as `Long`, `Double`, or `String`.\n\n- Complex objects that implement Java serialization.\n \n Use this if you are storing objects that implement `Serializable` and if you do not need to sort them.\n\n- Non-serialized complex objects.\n \n If you are storing objects that do not implement serialization, you can create your own custom tuple bindings. Note that you should use custom tuple bindings even if your objects are serializable if you want to sort on that data.\n\n**Numerical and String Objects**\n\nYou can use the Bind APIs to store primitive data in a `DatabaseEntry` object. That is, you can store a single field containing one of the following types:\n\n- `String`\n- `Character`\n- `Boolean`\n- `Byte`\n- `Short`\nTo store primitive data using the Bind APIs:\n\n1. **Create an** `EntryBinding` **object.**\n\n When you do this, you use `TupleBinding.getPrimitiveBinding()` to return an appropriate binding for the conversion.\n\n2. **Use the** `EntryBinding` **object to place the numerical object on the DatabaseEntry.**\n\nOnce the data is stored in the DatabaseEntry, you can put it to the database in whatever manner you wish. For example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.EntryBinding;\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.je.DatabaseEntry;\n\n// Need a key for the put.\ntry {\n String aKey = \"myLong\";\n DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes(\"UTF-8\"));\n\n // Now build the DatabaseEntry using a TupleBinding\n Long myLong = new Long(123456789l);\n DatabaseEntry theData = new DatabaseEntry();\n EntryBinding myBinding = TupleBinding.getPrimitiveBinding(Long.class);\n myBinding.objectToEntry(myLong, theData);\n\n // Now store it\n myDatabase.put(null, theKey, theData);\n} catch (Exception e) {\n // Exception handling goes here\n}\n```\n\n**Retrieval from the** `DatabaseEntry` **object is performed in much the same way:**\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.EntryBinding;\nimport com.sleepycat.bind.tuple.TupleBinding;\n```\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\n...\n\nDatabase myDatabase = null;\n// Database open omitted for clarity\n\ntry {\n // Need a key for the get\n String aKey = \"myLong\";\n DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes(\"UTF-8\"));\n\n // Need a DatabaseEntry to hold the associated data.\n DatabaseEntry theData = new DatabaseEntry();\n\n // Bindings need only be created once for a given scope\n EntryBinding myBinding = TupleBinding.getPrimitiveBinding(Long.class);\n\n // Get it\n OperationStatus retVal = myDatabase.get(null, theKey, theData,\n LockMode.DEFAULT);\n\n String retKey = null;\n if (retVal == OperationStatus.SUCCESS) {\n // Recreate the data.\n // Use the binding to convert the byte array contained in theData\n // to a Long type.\n Long theLong = (Long) myBinding.entryToObject(theData);\n retKey = new String(theKey.getData(), \"UTF-8\");\n System.out.println(\"For key: \\\"\" + retKey + \\\"\\\" found Long: \\\"\" +\n theLong + \\\"\\\".\\\"\\\");\n } else {\n System.out.println(\"No record found for key \\\"\" + retKey + \\\"\\\".\\\"\\\";\n }\n} catch (Exception e) {\n // Exception handling goes here\n}\n\n**Serializable Complex Objects**\n\nFrequently your application requires you to store and manage objects for your record data and/or keys. You may need to do this if you are caching objects created by another process. You may also want to do this if you want to store multiple data values on a record. When used with just primitive data, or with objects containing a single data member, JE database records effectively represent a single row in a two-column table. By storing a complex object in the record, you can turn each record into a single row in\nan $n$-column table, where $n$ is the number of data members contained by the stored object(s).\n\nIn order to store objects in a JE database, you must convert them to and from a byte array. The first instinct for many Java programmers is to do this using Java serialization. While this is functionally a correct solution, the result is poor space-performance because this causes the class information to be stored on every such database record. This information can be quite large and it is redundant — the class information does not vary for serialized objects of the same type.\n\nIn other words, directly using serialization to place your objects into byte arrays means that you will be storing a great deal of unnecessary information in your database, which ultimately leads to larger databases and more expensive disk I/O.\n\nThe easiest way for you to solve this problem is to use the Bind APIs to perform the serialization for you. Doing so causes the extra object information to be saved off to a unique Database dedicated for that purpose. This means that you do not have to duplicate that information on each record in the Database that your application is using to store its information.\n\nNote that when you use the Bind APIs to perform serialization, you still receive all the benefits of serialization. You can still use arbitrarily complex object graphs, and you still receive built-in class evolution through the serialVersionUID (SUID) scheme. All of the Java serialization rules apply without modification. For example, you can implement Externalizable instead of Serializable.\n\n**Usage Caveats**\n\nBefore using the Bind APIs to perform serialization, you may want to consider writing your own custom tuple bindings. Specifically, avoid serialization if:\n\n- If you need to sort based on the objects you are storing. The sort order is meaningless for the byte arrays that you obtain through serialization. Consequently, you should not use serialization for keys if you care about their sort order. You should also not use serialization for record data if your Database supports duplicate records and you care about sort order.\n\n- You want to minimize the size of your byte arrays. Even when using the Bind APIs to perform the serialization the resulting byte array may be larger than necessary. You can achieve more compact results by building your own custom tuple binding.\n\n- You want to optimize for speed. In general, custom tuple bindings are faster than serialization at moving data in and out of byte arrays.\n\n- You are using custom comparators. In JE, comparators are instantiated and called internally whenever databases are not accessible. Because serial bindings depend on the class catalog, a serial binding binding cannot be used during these times. As a result, attempting to use a serial binding with a custom comparator will result in a NullPointerException during environment open or close.\nFor information on building your own custom tuple binding, see Custom Tuple Bindings (page 43).\n\n**Serializing Objects**\n\nTo store a serializable complex object using the Bind APIs:\n\n1. Implement `java.io.Serializable` in the class whose instances that you want to store.\n\n2. Open (create) your databases. You need two. The first is the database that you use to store your data. The second is used to store the class information.\n\n3. Instantiate a class catalog. You do this with `com.sleepycat.bind.serial.StoredClassCatalog`, and at that time you must provide a handle to an open database that is used to store the class information.\n\n\n5. Instantiate an instance of the object that you want to store, and place it in a `DatabaseEntry` using the entry binding that you created in the previous step.\n\nFor example, suppose you want to store a long, double, and a String as a record's data. Then you might create a class that looks something like this:\n\n```java\npackage je.gettingStarted;\n\nimport java.io.Serializable;\n\npublic class MyData implements Serializable {\n private long longData;\n private double doubleData;\n private String description;\n\n MyData() {\n longData = 0;\n doubleData = 0.0;\n description = null;\n }\n\n public void setLong(long data) {\n longData = data;\n }\n\n public void setDouble(double data) {\n doubleData = data;\n }\n\n public void setDescription(String data) {\n description = data;\n }\n}\n```\npublic long getLong() {\n return longData;\n}\n\npublic double getDouble() {\n return doubleData;\n}\n\npublic String getDescription() {\n return description;\n}\n}\n\nYou can then store instances of this class as follows:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.EntryBinding;\nimport com.sleepycat.bind.serial.StoredClassCatalog;\nimport com.sleepycat.bind.serial.SerialBinding;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseConfig;\nimport com.sleepycat.je.DatabaseEntry;\n\n// The key data.\nString aKey = \"myData\";\n\n// The data data\nMyData data2Store = new MyData();\ndata2Store.setLong(123456789l);\ndata2Store.setDouble(1234.9876543);\ndata2Store.setDescription(\"A test instance of this class\");\n\ntry {\n // Environment open omitted for brevity\n\n // Open the database that you will use to store your data\n DatabaseConfig myDbConfig = new DatabaseConfig();\n myDbConfig.setAllowCreate(true);\n myDbConfig.setSortedDuplicates(true);\n Database myDatabase = myDbEnv.openDatabase(null, \"myDb\", myDbConfig);\n\n // Open the database that you use to store your class information.\n // The db used to store class information does not require duplicates\n // support.\nmyDbConfig.setSortedDuplicates(false);\nDatabase myClassDb = myDbEnv.openDatabase(null, \"classDb\", myDbConfig);\n\n// Instantiate the class catalog\nStoredClassCatalog classCatalog = new StoredClassCatalog(myClassDb);\n\n// Create the binding\nEntryBinding dataBinding = new SerialBinding(classCatalog, MyData.class);\n\n// Create the DatabaseEntry for the key\nDatabaseEntry theKey = new DatabaseEntry(aKey.getBytes(\"UTF-8\"));\n\n// Create the DatabaseEntry for the data. Use the EntryBinding object\n// that was just created to populate the DatabaseEntry\nDatabaseEntry theData = new DatabaseEntry();\ndataBinding.objectToEntry(data2Store, theData);\n\n// Put it as normal\nmyDatabase.put(null, theKey, theData);\n\n// Database and environment close omitted for brevity\n}\n\n// Exception handling goes here\n}\n\nDeserializing Objects\n\nOnce an object is stored in the database, you can retrieve the MyData objects from the retrieved DatabaseEntry using the Bind APIs in much the same way as is described above. For example:\n\n```java\ntry {\n String aKey = \"myData\";\n \n // The key data.\n try {\n \n```\nCustom Tuple Bindings\n\nIf you want to store complex objects in your database, then you can use tuple bindings to do this. While they are more work to write and maintain than if you were to use serialization, the byte array conversion is faster. In addition, custom tuple bindings should allow you to create byte arrays that are smaller than those created by serialization. Custom tuple bindings also allow you to optimize your BTree comparisons, whereas serialization does not.\n\nFor information on using serialization to store complex objects, see Serializable Complex Objects (page 38).\n\nTo store complex objects using a custom tuple binding:\n\n1. Implement the class whose instances that you want to store. Note that you do not have to implement the Serializable interface.\n2. Write a tuple binding using the `com.sleepycat.bind.tuple.TupleBinding` class.\n\n3. Open (create) your database. Unlike serialization, you only need one.\n\n4. Create an entry binding that uses the tuple binding that you implemented in step 2.\n\n5. Instantiate an instance of the object that you want to store, and place it in a `DatabaseEntry` using the entry binding that you created in the previous step.\n\nFor example, suppose you want to your keys to be instances of the following class:\n\n```java\npackage je.gettingStarted;\n\npublic class MyData2 {\n private long longData;\n private Double doubleData;\n private String description;\n\n public MyData2() {\n longData = 0;\n doubleData = new Double(0.0);\n description = \"\";\n }\n\n public void setLong(long data) {\n longData = data;\n }\n\n public void setDouble(Double data) {\n doubleData = data;\n }\n\n public void setString(String data) {\n description = data;\n }\n\n public long getLong() {\n return longData;\n }\n\n public Double getDouble() {\n return doubleData;\n }\n\n public String getString() {\n return description;\n }\n}\n```\nIn this case, you need to write a tuple binding for the MyData2 class. When you do this, you must implement the `TupleBinding.objectToEntry()` and `TupleBinding.entryToObject()` abstract methods. Remember the following as you implement these methods:\n\n- You use `TupleBinding.objectToEntry()` to convert objects to byte arrays. You use `com.sleepycat.bind.tuple.TupleOutput` to write primitive data types to the byte array. Note that `TupleOutput` provides methods that allows you to work with numerical types (`long`, `double`, `int`, and so forth) and not the corresponding `java.lang` numerical classes.\n\n- The order that you write data to the byte array in `TupleBinding.objectToEntry()` is the order that it appears in the array. So given the MyData2 class as an example, if you write `description`, `doubleData`, and then `longData`, then the resulting byte array will contain these data elements in that order. This means that your records will sort based on the value of the `description` data member and then the `doubleData` member, and so forth. If you prefer to sort based on, say, the `longData` data member, write it to the byte array first.\n\n- You use `TupleBinding.entryToObject()` to convert the byte array back into an instance of your original class. You use `com.sleepycat.bind.tuple.TupleInput` to get data from the byte array.\n\n- The order that you read data from the byte array must be exactly the same as the order in which it was written.\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.bind.tuple.TupleInput;\nimport com.sleepycat.bind.tuple.TupleOutput;\n\npublic class MyTupleBinding extends TupleBinding {\n // Write a MyData2 object to a TupleOutput\n public void objectToEntry(Object object, TupleOutput to) {\n MyData2 myData = (MyData2)object;\n // Write the data to the TupleOutput (aDatabaseEntry).\n // Order is important. The first data written will be\n // the first bytes used by the default comparison routines.\n to.writeDouble(myData.getDouble().doubleValue());\n to.writeLong(myData.getLong());\n to.writeString(myData.getString());\n }\n\n // Convert a TupleInput to a MyData2 object\n public Object entryToObject(TupleInput ti) {\n```\nIn order to use the tuple binding, instantiate the binding and then use:\n\n- `MyTupleBinding.objectToEntry()` to convert a `MyData2` object to a `DatabaseEntry`.\n- `MyTupleBinding.entryToObject()` to convert a `DatabaseEntry` to a `MyData2` object.\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.je.DatabaseEntry;\n\n... // Code\n\nTupleBinding keyBinding = new MyTupleBinding();\n\nMyData2 theKeyData = new MyData2();\ntheKeyData.setLong(123456789L);\ntheKeyData.setDouble(new Double(12345.6789));\ntheKeyData.setString(\"My key data\");\n\nDatabaseEntry myKey = new DatabaseEntry();\n\ntry {\n // Store theKeyData in the DatabaseEntry\n keyBinding.objectToEntry(theKeyData, myKey);\n ...\n // Database put and get activity omitted for clarity\n ...\n // Retrieve the key data\n theKeyData = (MyData2) keyBinding.entryToObject(myKey);\n} catch (Exception e) {\n // Exception handling\n}\n```\nUsing Comparators\n\nInternally, JE databases are organized as BTrees. This means that most database operations (inserts, deletes, reads, and so forth) involve BTree node comparisons. This comparison most frequently occurs based on database keys, but if your database supports duplicate records then comparisons can also occur based on the database data.\n\nBy default, JE performs all such comparisons using a byte-by-byte lexicographic comparison. This mechanism works well for most data. However, in some cases you may need to specify your own comparison routine. One frequent reason for this is to perform a language sensitive lexical ordering of string keys.\n\nWriting Comparators\n\nYou override the default comparison function by providing a Java Comparator class to the database. The Java Comparator interface requires you to implement the Comparator.compare() method (see http://java.sun.com/j2se/1.4.2/docs/api/java/util/Comparator.html for details).\n\nJE passes your Comparator.compare() method the byte arrays that you stored in the database. If you know how your data is organized in the byte array, then you can write a comparison routine that directly examines the contents of the arrays. Otherwise, you have to reconstruct your original objects, and then perform the comparison.\n\nFor example, suppose you want to perform unicode lexical comparisons instead of UTF-8 byte-by-byte comparisons. Then you could provide a comparator that uses String.compareTo(), which performs a Unicode comparison of two strings (note that for single-byte roman characters, Unicode comparison and UTF-8 byte-by-byte comparisons are identical - this is something you would only want to do if you were using multibyte unicode characters with JE). In this case, your comparator would look like the following:\n\n```java\npackage je.gettingStarted;\n\nimport java.util.Comparator;\n\npublic class MyDataComparator implements Comparator {\n public MyDataComparator() {}\n\n public int compare(Object d1, Object d2) {\n byte[] b1 = (byte[])d1;\n byte[] b2 = (byte[])d2;\n\n String s1 = new String(b1, \"UTF-8\");\n String s2 = new String(b2, \"UTF-8\");\n\n return s1.compareTo(s2);\n }\n}\n```\nSetting Comparators\n\nYou specify a Comparator using the following methods. Note that by default these methods can only be used at database creation time, and they are ignored for normal database opens. Also, note that JE uses the no-argument constructor for these comparators. Further, it is not allowable for there to be a mutable state in these comparators or else unpredictable results will occur.\n\n- **DatabaseConfig.setBtreeComparator()**\n\n Sets the Java Comparator class used to compare two keys in the database.\n\n- **DatabaseConfig.setDuplicateComparator()**\n\n Sets the Java Comparator class used to compare the data on two duplicate records in the database. This comparator is used only if the database supports duplicate records.\n\nYou can use the above methods to set a database's comparator after database creation time if you explicitly indicate that the comparator is to be overridden. You do this by using the following methods:\n\n- **DatabaseConfig.setOverrideBtreeComparator()**\n\n If set to true, causes the database's Btree comparator to be overridden with the Comparator specified on DatabaseConfig.setBtreeComparator(). This method can be used to change the comparator post-environment creation.\n\n- **DatabaseConfig.setOverrideDuplicateComparator()**\n\n If set to true, causes the database's duplicates comparator to be overridden with the Comparator specified on DatabaseConfig.setDuplicateComparator().\n\nFor example, to use the Comparator described in the previous section:\n\n```java\npackage je.gettingStarted;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseConfig;\nimport com.sleepycat.je.DatabaseException;\n```\nimport java.util.Comparator;\n...\n\n// Environment open omitted for brevity\ntry {\n // Get the database configuration object\n DatabaseConfig myDbConfig = new DatabaseConfig();\n myDbConfig.setAllowCreate(true);\n\n // Set the duplicate comparator class\n myDbConfig.setDuplicateComparator(MyDataComparator.class);\n\n // Open the database that you will use to store your data\n myDbConfig.setSortedDuplicates(true);\n Database myDatabase = myDbEnv.openDatabase(null, \"myDb\", myDbConfig);\n} catch (DatabaseException dbe) {\n // Exception handling goes here\n // Environment close omitted for brevity\n}\n\nDatabase Record Example\n\nIn Database Example (page 26), we created MyDbEnv, a class that manages DatabaseEnvironment and Database opens and closes. We will now write an application that takes advantage of this class to open databases, put a series of records in them, and then close the databases and environment.\n\nRemember that all of the classes and programs presented here can be found in the following directory:\n\nJE_HOME/examples/je/gettingStarted\n\nwhere JE_HOME is the location where you placed your JE distribution.\n\nNote that in this example, we are going to save two types of information. First there are a series of inventory records that identify information about some food items (fruits, vegetables, and desserts). These records identify particulars about each item such as the vendor that the item can be obtained from, how much the vendor has in stock, the price per unit, and so forth.\n\nWe also want to manage vendor contact information, such as the vendor’s address and phone number, the sales representative’s name and his phone number, and so forth.\n\nExample 4.1. Inventory.java\n\nAll Inventory data is encapsulated in an instance of the following class. Note that because this class is not serializable, we need a custom tuple binding in order to place it on a DatabaseEntry object. Because the TupleInput and TupleOutput classes used by custom\ntuple bindings support Java numerical types and not Java numerical classes, we use \\texttt{int}\nand \\texttt{float} here instead of the corresponding \\texttt{Integer} and \\texttt{Float} classes.\n\n```java\n// File Inventory.java\npackage je.gettingStarted;\n\npublic class Inventory {\n private String sku;\n private String itemName;\n private String category;\n private String vendor;\n private int vendorInventory;\n private float vendorPrice;\n\n public void setSku(String data) {\n sku = data;\n }\n\n public void setItemName(String data) {\n itemName = data;\n }\n\n public void setCategory(String data) {\n category = data;\n }\n\n public void setVendorInventory(int data) {\n vendorInventory = data;\n }\n\n public void setVendor(String data) {\n vendor = data;\n }\n\n public void setVendorPrice(float data) {\n vendorPrice = data;\n }\n\n public String getSku() { return sku; }\n public String getItemName() { return itemName; }\n public String getCategory() { return category; }\n public int getVendorInventory() { return vendorInventory; }\n public String getVendor() { return vendor; }\n public float getVendorPrice() { return vendorPrice; }\n}\n```\nExample 4.2. Vendor.java\n\nThe data for vendor records are stored in instances of the following class. Notice that we are using serialization with this class simply to demonstrate serializing a class instance.\n\n```java\n// File Vendor.java\npackage je.gettingStarted;\n\nimport java.io.Serializable;\n\npublic class Vendor implements Serializable {\n private String repName;\n private String address;\n private String city;\n private String state;\n private String zipcode;\n private String bizPhoneNumber;\n private String repPhoneNumber;\n private String vendor;\n\n public void setRepName(String data) {\n repName = data;\n }\n\n public void setAddress(String data) {\n address = data;\n }\n\n public void setCity(String data) {\n city = data;\n }\n\n public void setState(String data) {\n state = data;\n }\n\n public void setZipcode(String data) {\n zipcode = data;\n }\n\n public void setBusinessPhoneNumber(String data) {\n bizPhoneNumber = data;\n }\n\n public void setRepPhoneNumber(String data) {\n repPhoneNumber = data;\n }\n}\n```\nBecause we will not be using serialization to convert our `Inventory` objects to a `DatabaseEntry` object, we need a custom tuple binding:\n\n**Example 4.3. InventoryBinding.java**\n\n```java\n// File InventoryBinding.java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.bind.tuple.TupleInput;\nimport com.sleepycat.bind.tuple.TupleOutput;\n\npublic class InventoryBinding extends TupleBinding {\n // Implement this abstract method. Used to convert\n // a DatabaseEntry to an Inventory object.\n public Object entryToObject(TupleInput ti) {\n String sku = ti.readString();\n String itemName = ti.readString();\n String category = ti.readString();\n String vendor = ti.readString();\n int vendorInventory = ti.readInt();\n float vendorPrice = ti.readFloat();\n\n Inventory inventory = new Inventory();\n inventory.setSku(sku);\n inventory.setItemName(itemName);\n inventory.setCategory(category);\n inventory.setVendor(vendor);\n inventory.setVendorInventory(vendorInventory);\n inventory.setVendorPrice(vendorPrice);\n\n return inventory;\n }\n\n // Implement this abstract method. Used to convert a\n // Inventory object to a DatabaseEntry object.\n```\npublic void objectToEntry(Object object, TupleOutput to) {\n Inventory inventory = (Inventory)object;\n to.writeString(inventory.getSku());\n to.writeString(inventory.getItemName());\n to.writeString(inventory.getCategory());\n to.writeString(inventory.getVendor());\n to.writeInt(inventory.getVendorInventory());\n to.writeFloat(inventory.getVendorPrice());\n}\n\nIn order to store the data identified above, we write the ExampleDatabasePut application. This application loads the inventory and vendor databases for you.\n\nInventory information is stored in a Database dedicated for that purpose. The key for each such record is a product SKU. The inventory data stored in this database are objects of the Inventory class (see Inventory.java (page 49) for more information). ExampleDatabasePut loads the inventory database as follows:\n\n1. Reads the inventory data from a flat text file prepared in advance for this purpose.\n2. Uses java.lang.String to create a key based on the item’s SKU.\n3. Uses an Inventory class instance for the record data. This object is stored on a DatabaseEntry object using InventoryBinding, a custom tuple binding that we implemented above.\n4. Saves each record to the inventory database.\n\nVendor information is also stored in a Database dedicated for that purpose. The vendor data stored in this database are objects of the Vendor class (see Vendor.java (page 51) for more information). To load this Database, ExampleDatabasePut does the following:\n\n1. Reads the vendor data from a flat text file prepared in advance for this purpose.\n2. Uses the vendor’s name as the record’s key.\n3. Uses a Vendor class instance for the record data. This object is stored on a DatabaseEntry object using com.sleepycat.bind.serial.SerialBinding.\n\nExample 4.4. Stored Class Catalog Management with MyDbEnv\n\nBefore we can write ExampleDatabasePut, we need to update MyDbEnv.java to support the class catalogs that we need for this application.\n\nTo do this, we start by importing an additional class to support stored class catalogs:\n\n```java\n// File MyDbEnv.java\npackage je.gettingStarted;\n```\nWe also need to add two additional private data members to this class. One supports the database used for the class catalog, and the other is used as a handle for the class catalog itself.\n\n```java\npublic class MyDbEnv {\n private Environment myEnv;\n private Database vendorDb;\n private Database inventoryDb;\n private Database classCatalogDb;\n private StoredClassCatalog classCatalog;\n\n public MyDbEnv() {}\n}\n```\n\nNext we need to update the `MyDbEnv.setup()` method to open the class catalog database and create the class catalog.\n\n```java\npublic void setup(File envHome, boolean readOnly) throws DatabaseException {\n ...\n myEnv = new Environment(envHome, myEnvConfig);\n ...\n myEnv.openDatabase(null, \"VendorDB\", myDbConfig);\n myEnv.openDatabase(null, \"InventoryDB\", myDbConfig);\n myEnv.openDatabase(null, \"ClassCatalog\", myDbConfig);\n}\n```\nNext we need a getter method to return the class catalog. Note that we do not provide a getter for the catalog database itself - our application has no need for that.\n\n```java\n// Getter methods\npublic Environment getEnvironment() {\n return myEnv;\n}\n\npublic Database getVendorDB() {\n return vendorDb;\n}\n\npublic Database getInventoryDB() {\n return inventoryDb;\n}\n\npublic StoredClassCatalog getClassCatalog() {\n return classCatalog;\n}\n```\n\nFinally, we need to update the `MyDbEnv.close()` method to close the class catalog database.\n\n```java\n// Close the environment\npublic void close() {\n if (myEnv != null) {\n try {\n vendorDb.close();\n inventoryDb.close();\n classCatalogDb.close();\n myEnv.close();\n } catch(DatabaseException dbe) {\n System.err.println(\"Error closing MyDbEnv: \"+\n dbe.toString());\n System.exit(-1);\n }\n }\n}\n```\n\nSo far we have identified the data that we want to store in our databases and how we will convert that data in and out of `DatabaseEntry` objects for database storage. We have also updated `MyDbEnv` to manage our databases for us. Now we write `ExampleDatabasePut`\nto actually put the inventory and vendor data into their respective databases. Because of the work that we have done so far, this application is actually fairly simple to write.\n\n**Example 4.5. ExampleDatabasePut.java**\n\nFirst we need the usual series of import statements:\n\n```java\n//File ExampleDatabasePut.java\npackage je.gettingStarted;\n\n// Bind classes used to move class objects in an out of byte arrays.\nimport com.sleepycat.bind.EntryBinding;\nimport com.sleepycat.bind.serial.SerialBinding;\nimport com.sleepycat.bind.tuple.TupleBinding;\n\n// Standard JE database imports\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\n\n// Most of this is used for loading data from a text file for storage\n// in the databases.\nimport java.io.File;\nimport java.io.FileInputStream;\nimport java.io.BufferedReader;\nimport java.io.InputStreamReader;\nimport java.io.FileNotFoundException;\nimport java.io.IOException;\nimport java.util.ArrayList;\nimport java.util.List;\n```\n\nNext comes the class declaration and the private data members that we need for this class. Most of these are setting up default values for the program.\n\nNote that two `DatabaseEntry` objects are instantiated here. We will reuse these for every database operation that this program performs. Also a `MyDbEnv` object is instantiated here. We can do this because its constructor never throws an exception. See Stored Class Catalog Management with `MyDbEnv` (page 53) for its implementation details.\n\nFinally, the `inventory.txt` and `vendors.txt` file can be found in the GettingStarted examples directory along with the classes described in this extended example.\n\n```java\npublic class ExampleDatabasePut {\n private static File myDbEnvPath = new File(\"/tmp/JEDB\");\n private static File inventoryFile = new File(\"./inventory.txt\");\n private static File vendorsFile = new File(\"./vendors.txt\");\n\n // DatabaseEntries used for loading records\n private static DatabaseEntry theKey = new DatabaseEntry();\n private static DatabaseEntry theData = new DatabaseEntry();\n```\nNext comes the usage() and main() methods. Notice the exception handling in the main() method. This is the only place in the application where we catch exceptions. For this reason, we must catch DatabaseException which is thrown by the com.sleepycat.je.* classes.\n\nAlso notice the call to MyDbEnv.close() in the finally block. This is the only place in the application where MyDbEnv.close() is called. MyDbEnv.close() is responsible for closing the Environment and all open Database handles for you.\n\nNext we write the ExampleDatabasePut.run() method. This method is responsible for initializing all objects. Because our environment and databases are all opened using the MyDbEnv.setup() method, ExampleDatabasePut.run() method is only responsible for calling MyDbEnv.setup() and then calling the ExampleDatabasePut methods that actually load the databases.\nThis next method loads the vendor database. This method uses serialization to convert the Vendor object to a DatabaseEntry object.\n\n```java\nprivate void loadVendorsDb()\n throws DatabaseException {\n // loadFile opens a flat-text file that contains our data\n // and loads it into a list for us to work with. The integer\n // parameter represents the number of fields expected in the\n // file.\n List vendors = loadFile(vendorsFile, 8);\n\n // Now load the data into the database. The vendor's name is the\n // key, and the data is a Vendor class object.\n\n // Need a serial binding for the data\n EntryBinding dataBinding =\n new SerialBinding(myDbEnv.getClassCatalog(), Vendor.class);\n\n for (int i = 0; i < vendors.size(); i++) {\n String[] sArray = (String[]) vendors.get(i);\n Vendor theVendor = new Vendor();\n theVendor.setVendorName(sArray[0]);\n theVendor.setAddress(sArray[1]);\n theVendor.setCity(sArray[2]);\n theVendor.setState(sArray[3]);\n theVendor.setZipcode(sArray[4]);\n theVendor.setBusinessPhoneNumber(sArray[5]);\n theVendor.setRepName(sArray[6]);\n theVendor.setRepPhoneNumber(sArray[7]);\n\n // The key is the vendor's name.\n // ASSUMES THE VENDOR'S NAME IS UNIQUE!\n String vendorName = theVendor.getVendorName();\n try {\n theKey = new DatabaseEntry(vendorName.getBytes(\"UTF-8\"));\n } catch (IOException willNeverOccur) {} \n\n // Convert the Vendor object to a DatabaseEntry object\n // using our SerialBinding\n dataBinding.objectToEntry(theVendor, theData);\n\n // Put it in the database. These puts are transactionally\n // protected (we're using autocommit).\n myDbEnv.getVendorDB().put(null, theKey, theData);\n }\n\nSystem.out.println(\"loading inventory db.\");\nloadInventoryDb();\n}\n```\nNow load the inventory database. This method uses our custom tuple binding (see `InventoryBinding.java (page 52)`) to convert the `Inventory` object to a `DatabaseEntry` object.\n\n```java\nprivate void loadInventoryDb()\n throws DatabaseException {\n\n // loadFile opens a flat-text file that contains our data\n // and loads it into a list for us to work with. The integer\n // parameter represents the number of fields expected in the\n // file.\n List inventoryArray = loadFile(inventoryFile, 6);\n\n // Now load the data into the database. The item's sku is the\n // key, and the data is an Inventory class object.\n // Need a tuple binding for the Inventory class.\n TupleBinding inventoryBinding = new InventoryBinding();\n\n for (int i = 0; i < inventoryArray.size(); i++) {\n String[] sArray = (String[])inventoryArray.get(i);\n String sku = sArray[1];\n try {\n theKey = new DatabaseEntry(sku.getBytes(\"UTF-8\"));\n } catch (IOException willNeverOccur) {} \n Inventory theInventory = new Inventory();\n theInventory.setItemName(sArray[0]);\n theInventory.setSku(sArray[1]);\n try {\n theInventory.setVendorPrice((new Float(sArray[2])).floatValue());\n } catch (NumberFormatException exception) {\n exception.printStackTrace();\n }\n theInventory.setVendorInventory((new Integer(sArray[3])).intValue());\n theInventory.setCategory(sArray[4]);\n theInventory.setVendor(sArray[5]);\n\n // Place the Vendor object on the DatabaseEntry object using our\n // the tuple binding we implemented in InventoryBinding.java\n inventoryBinding.objectToEntry(theInventory, theData);\n\n // Put it in the database.\n myDbEnv.getInventoryDB().put(null, theKey, theData);\n }\n}\n```\n\nThe remainder of this application provides utility methods to read a flat text file into an array of strings and parse the command line options. From the perspective of this\ndocument, these things are relatively uninteresting. You can see how they are implemented by looking at:\n\n```\nJE_HOME/examples/je/gettingStarted/ExampleDataPut.java\n```\n\nwhere `JE_HOME` is the location where you placed your JE distribution.\n\n```java\nprivate static void parseArgs(String args[]) {\n // Implementation omitted for brevity.\n}\n\nprivate List loadFile(File theFile, int numFields) {\n List records = new ArrayList();\n // Implementation omitted for brevity.\n return records;\n}\n\nprotected ExampleDatabasePut() {}\n```\nChapter 5. Using Cursors\n\nCursors provide a mechanism by which you can iterate over the records in a database. Using cursors, you can get, put, and delete database records. If a database allows duplicate records, then cursors are the only mechanism by which you can access anything other than the first duplicate for a given key.\n\nThis chapter introduces cursors. It explains how to open and close them, how to use them to modify databases, and how to use them with duplicate records.\n\nOpening and Closing Cursors\n\nTo use a cursor, you must open it using the `Database.openCursor()` method. When you open a cursor, you can optionally pass it a `CursorConfig` object to set cursor properties. Currently, the only available property tells the cursor to perform uncommitted reads. (For a description of uncommitted reads, see the Berkeley DB Java Edition Getting Started with Transaction Processing guide.)\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Cursor;\nimport com.sleepycat.je.CursorConfig;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport java.io.File;\n...\nEnvironment myDbEnvironment = null;\nDatabase myDatabase = null;\nCursor myCursor = null;\n\ntry {\n myDbEnvironment = new Environment(new File(\"/export/dbEnv\"), null);\n myDatabase = myDbEnvironment.openDatabase(null, \"myDB\", null);\n\n myCursor = myDatabase.openCursor(null, null);\n} catch (DatabaseException dbe) {\n // Exception handling goes here ...\n}\n```\n\nTo close the cursor, call the `Cursor.close()` method. Note that if you close a database that has cursors open in it, then it will throw an exception and close any open cursors for you. For best results, close your cursors from within a `finally` block.\nGetting Records Using the Cursor\n\nTo iterate over database records, from the first record to the last, simply open the cursor and then use the `Cursor.getNext()` method. For example:\n\n```java\npackage je.gettingStarted;\nimport com.sleepycat.je.Cursor;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\n...\nCursor cursor = null;\ntry {\n ...\n // Database and environment open omitted for brevity\n ...\n}\n```\nGetting Records Using the Cursor\n\n```java\n// Open the cursor.\ncursor = myDatabase.openCursor(null, null);\n\n// Cursors need a pair of DatabaseEntry objects to operate. These hold\n// the key and data found at any given position in the database.\nDatabaseEntry foundKey = new DatabaseEntry();\nDatabaseEntry foundData = new DatabaseEntry();\n\n// To iterate, just call getNext() until the last database record has been\n// read. All cursor operations return an OperationStatus, so just read\n// until we no longer see OperationStatus.SUCCESS\nwhile (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) ==\n OperationStatus.SUCCESS) {\n // getData() on the DatabaseEntry objects returns the byte array\n // held by that object. We use this to get a String value. If the\n // DatabaseEntry held a byte array representation of some other data\n // type (such as a complex object) then this operation would look\n // considerably different.\n String keyString = new String(foundKey.getData(), \"UTF-8\");\n String dataString = new String(foundData.getData(), \"UTF-8\");\n System.out.println(\"Key | Data : \" + keyString + \" | \" +\n dataString + \";\");\n}\n\nTo iterate over the database from the last record to the first, instantiate the cursor, and\nthen use Cursor.getPrev() until you read the first record in the database. For example:\n```\n```\nSearching for Records\n\nYou can use cursors to search for database records. You can search based on just a key, or you can search based on both the key and the data. You can also perform partial matches if your database supports sorted duplicate sets. In all cases, the key and data parameters of these methods are filled with the key and data values of the database record to which the cursor is positioned as a result of the search.\n\nAlso, if the search fails, then cursor’s state is left unchanged and OperationStatus.NOTFOUND is returned.\n\nThe following Cursor methods allow you to perform database searches:\n\n- `Cursor.getSearchKey()`\n\n Moves the cursor to the first record in the database with the specified key.\n\n- `Cursor.getSearchKeyRange()`\n\n Moves the cursor to the first record in the database whose key is greater than or equal to the specified key. This comparison is determined by the comparator that you provide for the database. If no comparator is provided, then the default unsigned byte-by-byte lexicographical sorting is used.\n\n For example, suppose you have database records that use the following Strings as keys:\nThen providing a search key of **Alaska** moves the cursor to the second key noted above. Providing a key of **Al** moves the cursor to the first key (**Alabama**), providing a search key of **Alas** moves the cursor to the second key (**Alaska**), and providing a key of **Ar** moves the cursor to the last key (**Arizona**).\n\n- **Cursor.getSearchBoth()**\n\n *Moves the cursor to the first record in the database that uses the specified key and data.*\n\n- **Cursor.getSearchBothRange()**\n\n *Moves the cursor to the first record in the database whose key matches the specified key and whose data is greater than or equal to the specified data. If the database supports duplicate records, then on matching the key, the cursor is moved to the duplicate record with the smallest data that is greater than or equal to the specified data.*\n\nFor example, suppose you have database records that use the following key/data pairs:\n\n<table>\n<thead>\n<tr>\n<th>Alabama/Athens</th>\n<th>Alabama/Florence</th>\n<th>Alaska/Anchorage</th>\n<th>Alaska/Fairbanks</th>\n<th>Arizona/Avondale</th>\n<th>Arizona/Florence</th>\n</tr>\n</thead>\n</table>\n\nthen providing:\n\n<table>\n<thead>\n<tr>\n<th>a search key of ...</th>\n<th>and a search data of ...</th>\n<th>moves the cursor to ...</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Alaska</td>\n<td>Fa</td>\n<td>Alaska/Fairbanks</td>\n</tr>\n<tr>\n<td>Arizona</td>\n<td>Fl</td>\n<td>Arizona/Florence</td>\n</tr>\n<tr>\n<td>Alaska</td>\n<td>An</td>\n<td>Alaska/Anchorage</td>\n</tr>\n</tbody>\n</table>\n\nFor example, assuming a database containing sorted duplicate records of U.S. States/U.S Cities key/data pairs (both as Strings), then the following code fragment can be used to position the cursor to any record in the database and print its key/data values:\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Cursor;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\n\n...\n\n// For this example, hard code the search key and data\nString searchKey = \"Alaska\";\nString searchData = \"Fa\";\n\nCursor cursor = null;\ntry {\n ...\n // Database and environment open omitted for brevity\n ...\n\n // Open the cursor.\n cursor = myDatabase.openCursor(null, null);\n\n DatabaseEntry theKey =\n new DatabaseEntry(searchKey.getBytes(\"UTF-8\"));\n DatabaseEntry theData =\n new DatabaseEntry(searchData.getBytes(\"UTF-8\"));\n\n // Open a cursor using a database handle\n cursor = myDatabase.openCursor(null, null);\n\n // Perform the search\n OperationStatus retVal = cursor.getSearchBothRange(theKey, theData, LockMode.DEFAULT);\n // NOTFOUND is returned if a record cannot be found whose key\n // matches the search key AND whose data begins with the search data.\n if (retVal == OperationStatus.NOTFOUND) {\n System.out.println(searchKey + \"/\" + searchData + \n \" not matched in database \" + myDatabase.getDatabaseName());\n } else {\n // Upon completing a search, the key and data DatabaseEntry\n // parameters for getSearchBothRange() are populated with the\n // key/data values of the found record.\n String foundKey = new String(theKey.getData(), \"UTF-8\");\n String foundData = new String(theData.getData(), \"UTF-8\");\n System.out.println(\"Found record \" + foundKey + \"/\" + foundData + \n \" for search key/data: \" + searchKey + \n searchData);\n**Working with Duplicate Records**\n\nIf your database supports duplicate records, then it can potentially contain multiple records that share the same key. Using normal database get operations, you can only ever obtain the first such record in a set of duplicate records. To access subsequent duplicates, use a cursor. The following `Cursor` methods are interesting when working with databases that support duplicate records:\n\n- `Cursor.getNext()`, `Cursor.getPrev()`\n \n Shows the next/previous record in the database, regardless of whether it is a duplicate of the current record. For an example of using these methods, see Getting Records Using the Cursor (page 62).\n\n- `Cursor.getSearchBothRange()`\n \n Useful for seeking the cursor to a specific record, regardless of whether it is a duplicate record. See Searching for Records (page 64) for more information.\n\n- `Cursor.getNextNoDup()`, `Cursor.getPrevNoDup()`\n \n Gets the next/previous non-duplicate record in the database. This allows you to skip over all the duplicates in a set of duplicate records. If you call `Cursor.getPrevNoDup()`, then the cursor is positioned to the last record for the previous key in the database. For example, if you have the following records in your database:\n\n<table>\n<thead>\n<tr>\n<th>Alabama/Athens</th>\n<th>Alabama/Florence</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Alaska/Anchorage</td>\n<td>Alaska/Fairbanks</td>\n</tr>\n<tr>\n<td>Arizona/Avondale</td>\n<td>Arizona/Florence</td>\n</tr>\n</tbody>\n</table>\n\nand your cursor is positioned to Alaska/Fairbanks, and you then call `Cursor.getPrevNoDup()`, then the cursor is positioned to Alabama/Florence. Similarly, if you call `Cursor.getNextNoDup()`, then the cursor is positioned to the first record corresponding to the next key in the database.\n\nIf there is no next/previous key in the database, then `OperationStatus.NOTFOUND` is returned, and the cursor is left unchanged.\n• **Cursor.getNextDup()**, **Cursor.getPrevDup()**\n\n Gets the next/previous record that shares the current key. If the cursor is positioned at the last record in the duplicate set and you call `Cursor.getNextDup()`, then `OperationStatus.NOTFOUND` is returned and the cursor is left unchanged. Likewise, if you call `getPrevDup()` and the cursor is positioned at the first record in the duplicate set, then `OperationStatus.NOTFOUND` is returned and the cursor is left unchanged.\n\n• **Cursor.count()**\n\n Returns the total number of records that share the current key.\n\nFor example, the following code fragment positions a cursor to a key and, if the key contains duplicate records, displays all the duplicates. Note that the following code fragment assumes that the database contains only String objects for the keys and data.\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Cursor;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\n...\n\nCursor cursor = null;\ntry {\n ...\n // Database and environment open omitted for brevity\n ...\n\n // Create DatabaseEntry objects\n // searchKey is some String.\n DatabaseEntry theKey = new DatabaseEntry(searchKey.getBytes(\"UTF-8\"));\n DatabaseEntry theData = new DatabaseEntry();\n\n // Open a cursor using a database handle\n cursor = myDatabase.openCursor(null, null);\n\n // Position the cursor\n // Ignoring the return value for clarity\n OperationStatus retVal = cursor.getSearchKey(theKey, theData,\n LockMode.DEFAULT);\n\n // Count the number of duplicates. If the count is greater than 1,\n // print the duplicates.\n if (cursor.count() > 1) {\n while (retVal == OperationStatus.SUCCESS) {\n```\n\n```java\n ```\nPutting Records Using Cursors\n\nYou can use cursors to put records into the database. JE's behavior when putting records into the database differs depending on whether the database supports duplicate records. If duplicates are allowed, its behavior also differs depending on whether a comparator is provided for the database. (Comparators are described in Using Comparators (page 47)).\n\nNote that when putting records to the database using a cursor, the cursor is positioned at the record you inserted.\n\nYou can use the following methods to put records to the database:\n\n- **Cursor.put()**\n \n If the provided key does not exist in the database, then the order that the record is put into the database is determined by the BTree (key) comparator in use by the database.\n\n If the provided key already exists in the database, and the database does not support sorted duplicates, then the existing record data is replaced with the data provided on this method.\n\n If the provided key already exists in the database, and the database does support sorted duplicates, then the order that the record is inserted into the database is determined by the duplicate comparator in use by the database.\n\n- **Cursor.putNoDupData()**\n \n If the provided key and data already exists in the database, then this method returns OperationStatus.KEYEXIST.\n\n If the key does not exist, then the order that the record is put into the database is determined by the BTree (key) comparator in use by the database.\n• `Cursor.putNoOverwrite()`\n\nIf the provided key already exists in the database, then this method returns `OperationStatus.KEYEXIST`.\n\nIf the key does not exist, then the order that the record is put into the database is determined by the BTree (key) comparator in use by the database.\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Cursor;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.OperationStatus;\n\n...\n\n// Create the data to put into the database\nString key1str = \"My first string\";\nString data1str = \"My first data\";\nString key2str = \"My second string\";\nString data2str = \"My second data\";\nString data3str = \"My third data\";\n\nCursor cursor = null;\ntry {\n ...\n // Database and environment open omitted for brevity\n ...\n\n DatabaseEntry key1 = new DatabaseEntry(key1str.getBytes(\"UTF-8\"));\n DatabaseEntry data1 = new DatabaseEntry(data1str.getBytes(\"UTF-8\"));\n DatabaseEntry key2 = new DatabaseEntry(key2str.getBytes(\"UTF-8\"));\n DatabaseEntry data2 = new DatabaseEntry(data2str.getBytes(\"UTF-8\"));\n DatabaseEntry data3 = new DatabaseEntry(data3str.getBytes(\"UTF-8\"));\n\n // Open a cursor using a database handle\n cursor = myDatabase.openCursor(null, null);\n\n // Assuming an empty database.\n OperationStatus retVal = cursor.put(key1, data1); // SUCCESS\n retVal = cursor.put(key2, data2); // SUCCESS\n retVal = cursor.put(key2, data3); // SUCCESS if dups allowed,\n // KEYEXIST if not.\n}\n```\nDeleting Records Using Cursors\n\nTo delete a record using a cursor, simply position the cursor to the record that you want to delete and then call `Cursor.delete()`. Note that after deleting a record, the value of `Cursor.getCurrent()` is unchanged until such a time as the cursor is moved again. Also, if you call `Cursor.delete()` two or more times in a row without repositioning the cursor, then all subsequent deletes result in a return value of `OperationStatus.KEYEMPTY`.\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Cursor;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\n...\n\nCursor cursor = null;\ntry {\n ...\n // Database and environment open omitted for brevity\n ...\n // Create DatabaseEntry objects\n // searchKey is some String.\n DatabaseEntry theKey = new DatabaseEntry(searchKey.getBytes(\"UTF-8\"));\n DatabaseEntry theData = new DatabaseEntry();\n\n // Open a cursor using a database handle\n cursor = myDatabase.openCursor(null, null);\n\n // Position the cursor. Ignoring the return value for clarity\n OperationStatus retVal = cursor.getSearchKey(theKey, theData,\n LockMode.DEFAULT);\n\n // Count the number of records using the given key. If there is only\n // one, delete that record.\n if (cursor.count() == 1) {\n System.out.println(\"Deleting \" +\n new String(theKey.getData(), \"UTF-8\") +\n \"|\" +\n```\nReplacing Records Using Cursors\n\nYou replace the data for a database record by using `Cursor.putCurrent()`. This method takes just one argument — the data that you want to write to the current location in the database.\n\n```java\nimport com.sleepycat.je.Cursor;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\n...\nCursor cursor = null;\ntry {\n // Database and environment open omitted for brevity\n ...\n // Create DatabaseEntry objects\n // searchKey is some String.\n DatabaseEntry theKey = new DatabaseEntry(searchKey.getBytes(\"UTF-8\"));\n DatabaseEntry theData = new DatabaseEntry();\n\n // Open a cursor using a database handle\n cursor = myDatabase.openCursor(null, null);\n\n // Position the cursor. Ignoring the return value for clarity\n OperationStatus retVal = cursor.getSearchKey(theKey, theData, LockMode.DEFAULT);\n\n // Replacement data\n String replaceStr = \"My replacement string\";\n DatabaseEntry replacementData =\n new DatabaseEntry(replaceStr.getBytes(\"UTF-8\"));\n cursor.putCurrent(replacementData);\n} catch (Exception e) { // Exception handling goes here\n finally { // Make sure to close the cursor\n cursor.close();\n }\n}\n```\nNote that this method cannot be used if the record that you are trying to replace is a member of a duplicate set. This is because records must be sorted by their data and replacement would violate that sort order.\n\nIf you want to replace the data contained by a duplicate record, delete the record and create a new record with the desired key and data.\n\nCursor Example\n\nIn Database Example (page 26) we wrote an application that loaded two Database objects with vendor and inventory information. In this example, we will use those databases to display all of the items in the inventory database. As a part of showing any given inventory item, we will look up the vendor who can provide the item and show the vendor’s contact information.\n\nTo do this, we create the ExampleInventoryRead application. This application reads and displays all inventory records by:\n\n1. Opening the environment and then the inventory, vendor, and class catalog Database objects. We do this using the MyDbEnv class. See Stored Class Catalog Management with MyDbEnv (page 53) for a description of this class.\n\n2. Obtaining a cursor from the inventory Database.\n\n3. Steps through the Database, displaying each record as it goes.\n\n4. To display the Inventory record, the custom tuple binding that we created in InventoryBinding.java (page 52) is used.\n\n5. Database.get() is used to obtain the vendor that corresponds to the inventory item.\n\n6. A serial binding is used to convert the DatabaseEntry returned by the get() to a Vendor object.\n\n7. The contents of the Vendor object are displayed.\n\nWe implemented the Vendor class in Vendor.java (page 51). We implemented the Inventory class in Inventory.java (page 49).\n\nThe full implementation of ExampleInventoryRead can be found in:\n\nJE_HOME/examples/je/gettingStarted/ExampleInventoryRead.java\n\nwhere JE_HOME is the location where you placed your JE distribution.\nExample 5.1. ExampleInventoryRead.java\n\nTo begin, we import the necessary classes:\n\n```java\n// file ExampleInventoryRead.java\npackage je.gettingStarted;\nimport com.sleepycat.bind.EntryBinding;\nimport com.sleepycat.bind.serial.SerialBinding;\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.je.Cursor;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\nimport java.io.File;\nimport java.io.IOException;\n```\n\nNext we declare our class and set up some global variables. Note a MyDbEnv object is instantiated here. We can do this because its constructor never throws an exception. See Database Example (page 26) for its implementation details.\n\n```java\npublic class ExampleInventoryRead {\n private static File myDbEnvPath =\n new File(\"/tmp/JEDB\");\n // Encapsulates the database environment and databases.\n private static MyDbEnv myDbEnv = new MyDbEnv();\n private static TupleBinding inventoryBinding;\n private static EntryBinding vendorBinding;\n\n private static void usage() {\n System.out.println(\"ExampleInventoryRead [-h <env directory>] \");\n System.exit(0);\n }\n\n public static void main(String args[]) {\n ExampleInventoryRead eir = new ExampleInventoryRead();\n try {\n eir.run(args);\n } catch (DatabaseException dbe) {\n```\nIn ExampleInventoryRead.run(), we call MyDbEnv.setup() to open our environment and databases. Then we create the bindings that we need for using our data objects with DatabaseEntry objects.\n\n```java\nprivate void run(String args[]) throws DatabaseException {\n // Parse the arguments list\n parseArgs(args);\n\n myDbEnv.setup(myDbEnvPath, // path to the environment home\n true); // is this environment read-only?\n\n // Setup our bindings.\n inventoryBinding = new InventoryBinding();\n vendorBinding =\n new SerialBinding(myDbEnv.getClassCatalog(),\n Vendor.class);\n\n showAllInventory();\n}\n```\n\nNow we write the loop that displays the Inventory records. We do this by opening a cursor on the inventory database and iterating over all its contents, displaying each as we go.\n\n```java\nprivate void showAllInventory() throws DatabaseException {\n // Get a cursor\n Cursor cursor = myDbEnv.getInventoryDB().openCursor(null, null);\n\n // DatabaseEntry objects used for reading records\n DatabaseEntry foundKey = new DatabaseEntry();\n DatabaseEntry foundData = new DatabaseEntry();\n\n try { // always want to make sure the cursor gets closed.\n while (cursor.getNext(foundKey, foundData,\n LockMode.DEFAULT) == OperationStatus.SUCCESS) {\n Inventory theInventory =\n (Inventory)inventoryBinding.entryToObject(foundData);\n displayInventoryRecord(foundKey, theInventory);\n }\n } catch (Exception e) {\n System.err.println(\"Error on inventory cursor:\");\n System.err.println(e.toString());\n e.printStackTrace();\n }\n}```\nWe use `ExampleInventoryRead.displayInventoryRecord()` to actually show the record. This method first displays all the relevant information from the retrieved Inventory object. It then uses the vendor database to retrieve and display the vendor. Because the vendor database is keyed by vendor name, and because each inventory object contains this key, it is trivial to retrieve the appropriate vendor record.\n\n```java\nprivate void displayInventoryRecord(DatabaseEntry theKey,\n Inventory theInventory)\n throws DatabaseException {\n\n DatabaseEntry searchKey = null;\n try {\n String theSKU = new String(theKey.getData(), \"UTF-8\");\n System.out.println(theSKU + \":\");\n System.out.println(\"\\t \" + theInventory.getItemName());\n System.out.println(\"\\t \" + theInventory.getCategory());\n System.out.println(\"\\t \" + theInventory.getVendor());\n System.out.println(\"\\t\\tNumber in stock: \" +\n theInventory.getVendorInventory());\n System.out.println(\"\\t\\tPrice per unit: \" +\n theInventory.getVendorPrice());\n System.out.println(\"\\t\\tContact: \");\n\n searchKey =\n new DatabaseEntry(theInventory.getVendor().getBytes(\"UTF-8\"));\n } catch (IOException willNeverOccur) {} \n DatabaseEntry foundVendor = new DatabaseEntry();\n\n if (myDbEnv.getVendorDB().get(null, searchKey, foundVendor,\n LockMode.DEFAULT) != OperationStatus.SUCCESS) {\n System.out.println(\"Could not find vendor: \" +\n theInventory.getVendor() + \".\");\n System.exit(-1);\n } else {\n Vendor theVendor =\n (Vendor)vendorBinding.entryToObject(foundVendor);\n System.out.println(\"\\t\\t \" + theVendor.getAddress());\n System.out.println(\"\\t\\t \" + theVendor.getCity() + \", \" +\n theVendor.getState() + \", \" + theVendor.getZipcode());\n System.out.println(\"\\t\\t Business Phone: \" +\n theVendor.getBusinessPhoneNumber());\n System.out.println(\"\\t\\t Sales Rep: \" +\n theVendor.getRepName());\n }\n}\n```\nThe remainder of this application provides a utility method used to parse the command line options. From the perspective of this document, this is relatively uninteresting. You can see how this is implemented by looking at:\n\nJE_HOME/examples/je/gettingStarted/ExampleInventoryRead.java\n\nwhere JE_HOME is the location where you placed your JE distribution.\nChapter 6. Secondary Databases\n\nUsually you find database records by means of the record's key. However, the key that you use for your record will not always contain the information required to provide you with rapid access to the data that you want to retrieve. For example, suppose your Database contains records related to users. The key might be a string that is some unique identifier for the person, such as a user ID. Each record's data, however, would likely contain a complex object containing details about people such as names, addresses, phone numbers, and so forth. While your application may frequently want to query a person by user ID (that is, by the information stored in the key), it may also on occasion want to locate people by, say, their name.\n\nRather than iterate through all of the records in your database, examining each in turn for a given person's name, you create indexes based on names and then just search that index for the name that you want. You can do this using secondary databases. In JE, the Database that contains your data is called a primary database. A database that provides an alternative set of keys to access that data is called a secondary database, and these are managed using SecondaryDatabase class objects. In a secondary database, the keys are your alternative (or secondary) index, and the data corresponds to a primary record's key.\n\nYou create a secondary database by using a SecondaryConfig class object to identify an implementation of a SecondaryKeyCreator class object that is used to create keys based on data found in the primary database. You then pass this SecondaryConfig object to the SecondaryDatabase constructor.\n\nOnce opened, JE manages secondary databases for you. Adding or deleting records in your primary database causes JE to update the secondary as necessary. Further, changing a record's data in the primary database may cause JE to modify a record in the secondary, depending on whether the change forces a modification of a key in the secondary database.\n\nNote that you can not write directly to a secondary database. While methods exist on SecondaryDatabase and SecondaryCursor that appear to allow this, they in fact always throw UnsupportedOperationException. To change the data referenced by a SecondaryDatabase record, modify the primary database instead. The exception to this rule is that delete operations are allowed on the SecondaryDatabase object. See Deleting Secondary Database Records (page 85) for more information.\n\nSecondary database records are updated/created by JE only if the SecondaryKeyCreator.createSecondaryKey() method returns true. If false is returned, then JE will not add the key to the secondary database, and in the event of a record update it will remove any existing key.\n\nSee Implementing Key Creators (page 81) for more information on this interface and method.\n\nWhen you read a record from a secondary database, JE automatically returns the key and data from the corresponding record in the primary database.\nOpening and Closing Secondary Databases\n\nYou manage secondary database opens and closes using the `Environment.openSecondaryDatabase()` method. Just as is the case with primary databases, you must provide `Environment.openSecondaryDatabase()` with the database's name and, optionally, other properties such as whether duplicate records are allowed, or whether the secondary database can be created on open. In addition, you must also provide:\n\n- A handle to the primary database that this secondary database is indexing. Note that this means that secondary databases are maintained only for the specified `Database` handle. If you open the same `Database` multiple times for write (such as might occur when opening a database for read-only and read-write in the same application), then you should open the `SecondaryDatabase` for each such `Database` handle.\n\n- A `SecondaryConfig` object that provides properties specific to a secondary database. The most important of these is used to identify the key creator for the database. The key creator is responsible for generating keys for the secondary database. See Secondary Database Properties (page 84) for details.\n\nPrimary databases must not support duplicate records. Secondary records point to primary records using the primary key, so that key must be unique.\n\nSo to open (create) a secondary database, you:\n\n1. Open your primary database.\n2. Instantiate your key creator.\n3. Instantiate your `SecondaryConfig` object.\n4. Set your key creator object on your `SecondaryConfig` object.\n5. Open your secondary database, specifying your primary database and your `SecondaryConfig` at that time.\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseConfig;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.SecondaryDatabase;\nimport com.sleepycat.je.SecondaryConfig;\nimport java.io.File;\n```\n... \n\nDatabaseConfig myDbConfig = new DatabaseConfig();\nSecondaryConfig mySecConfig = new SecondaryConfig();\nmyDbConfig.setAllowCreate(true);\nmySecConfig.setAllowCreate(true);\n// Duplicates are frequently required for secondary databases.\nmySecConfig.setSortedDuplicates(true);\n\n// Open the primary\nEnvironment myEnv = null;\nDatabase myDb = null;\nSecondaryDatabase mySecDb = null;\ntry {\n String dbName = \"myPrimaryDatabase\";\n myEnv = new Environment(new File(\"/tmp/JEENV\"), null);\n myDb = myEnv.openDatabase(null, dbName, myDbConfig);\n\n // A fake tuple binding that is not actually implemented anywhere\n // in this manual. The tuple binding is dependent on the data in use.\n // Tuple bindings are described earlier in this manual.\n TupleBinding myTupleBinding = new MyTupleBinding();\n\n // Open the secondary.\n // Key creators are described in the next section.\n FullNameKeyCreator keyCreator = new FullNameKeyCreator(myTupleBinding);\n\n // Get a secondary object and set the key creator on it.\n mySecConfig.setKeyCreator(keyCreator);\n\n // Perform the actual open\n String secDbName = \"mySecondaryDatabase\";\n mySecDb = myEnv.openSecondaryDatabase(null, secDbName, myDb, mySecConfig);\n} catch (DatabaseException de) {\n // Exception handling goes here ...\n}\n\nTo close a secondary database, call its close() method. Note that for best results, you should close all the secondary databases associated with a primary database before closing the primary.\n\nFor example:\n\ntry {\n if (mySecDb != null) {\n mySecDb.close();\n }\n}\nif (myDb != null) {\n myDb.close();\n}\n\nif (myEnv != null) {\n myEnv.close();\n}\n}\n\n} catch (DatabaseException dbe) {\n // Exception handling goes here\n}\n\n### Implementing Key Creators\n\nYou must provide every secondary database with a class that creates keys from primary records. You identify this class using the `SecondaryConfig.setKeyCreator()` method.\n\nYou can create keys using whatever data you want. Typically you will base your key on some information found in a record's data, but you can also use information found in the primary record's key. How you build your keys is entirely dependent upon the nature of the index that you want to maintain.\n\nYou implement a key creator by writing a class that implements the `SecondaryKeyCreator` interface. This interface requires you to implement the `SecondaryKeyCreator.createSecondaryKey()` method.\n\nOne thing to remember when implementing this method is that you will need a way to extract the necessary information from the data's `DatabaseEntry` and/or the key's `DatabaseEntry` that are provided on calls to this method. If you are using complex objects, then you are probably using the Bind APIs to perform this conversion. The easiest thing to do is to instantiate the `EntryBinding` or `TupleBinding` that you need to perform the conversion, and then provide this to your key creator's constructor. The Bind APIs are introduced in Using the BIND APIs (page 36).\n\n`SecondaryKeyCreator.createSecondaryKey()` returns a boolean. A return value of false indicates that no secondary key exists, and therefore no record should be added to the secondary database for that primary record. If a record already exists in the secondary database, it is deleted.\n\nFor example, suppose your primary database uses the following class for its record data:\n\n```java\npackage je.gettingStarted;\n\npublic class PersonData {\n private String userID;\n private String surname;\n private String familiarName;\n\n public PersonData(String userID, String surname, String familiarName) {\n this.userID = userID;\n this.surname = surname;\n }\n```\nthis.familiarName = familiarName;\n}\n\npublic String getUserID() {\n return userID;\n}\n\npublic String getSurname() {\n return surname;\n}\n\npublic String getFamiliarName() {\n return familiarName;\n}\n\nAlso, suppose that you have created a custom tuple binding, PersonDataBinding, that you use to convert PersonData objects to and from DatabaseEntry objects. (Custom tuple bindings are described in Custom Tuple Bindings (page 43).)\n\nFinally, suppose you want a secondary database that is keyed based on the person’s full name.\n\nThen in this case you might create a key creator as follows:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.je.SecondaryKeyCreator;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.SecondaryDatabase;\nimport java.io.IOException;\n\npublic class FullNameKeyCreator implements SecondaryKeyCreator {\n private TupleBinding theBinding;\n\n public FullNameKeyCreator(TupleBinding theBinding1) {\n theBinding = theBinding1;\n }\n\n public boolean createSecondaryKey(SecondaryDatabase secDb,\n DatabaseEntry keyEntry,\n DatabaseEntry dataEntry,\n DatabaseEntry resultEntry) {\n try {\n```\nFinally, you use this key creator as follows:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.SecondaryDatabase;\nimport com.sleepycat.je.SecondaryConfig;\n\nEnvironment myEnv = null;\nDatabase myDb = null;\nSecondaryDatabase mySecDb = null;\ntry {\n // Environment and primary database open omitted for brevity\n...\n TupleBinding myDataBinding = new MyTupleBinding();\n FullNameKeyCreator fnkc = new FullNameKeyCreator(myDataBinding);\n SecondaryConfig mySecConfig = new SecondaryConfig();\n mySecConfig.setKeyCreator(fnkc);\n // Perform the actual open\n String secDbName = \"mySecondaryDatabase\";\n mySecDb = myEnv.openSecondaryDatabase(null, secDbName, myDb,\n mySecConfig);\n} catch (DatabaseException de) {\n // Exception handling goes here\n} finally {\n try {\n if (mySecDb != null) {\n mySecDb.close();\n }\n }\n if (myDb != null) {\n```\nmyDb.close();\n}\nif (myEnv != null) {\nmyEnv.close();\n}\n} catch (DatabaseException dbe) {\n // Exception handling goes here\n}\n\nSecondary Database Properties\n\nSecondary databases accept SecondaryConfig objects. SecondaryConfig is a subclass of\nDatabaseConfig, so it can manage all of the same properties as does DatabaseConfig. See\nDatabase Properties (page 23) for more information.\n\nIn addition to the DatabaseConfig properties, SecondaryConfig also allows you to manage\nthe following properties:\n\n- SecondaryConfig.setAllowPopulate()\n\nIf true, the secondary database can be auto-populated. This means that on open, if\nthe secondary database is empty then the primary database is read in its entirety and\nadditions/modifications to the secondary's records occur automatically.\n\n- SecondaryConfig.setKeyCreator()\n\nIdentifies the key creator object to be used for secondary key creation. See\nImplementing Key Creators (page 81) for more information.\n\nReading Secondary Databases\n\nLike a primary database, you can read records from your secondary database either by\nusing the SecondaryDatabase.get() method, or by using a SecondaryCursor. The main\ndifference between reading secondary and primary databases is that when you read a\nsecondary database record, the secondary record's data is not returned to you. Instead,\nthe primary key and data corresponding to the secondary key are returned to you.\n\nFor example, assuming your secondary database contains keys related to a person's full\nname:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\nimport com.sleepycat.je.SecondaryDatabase;\n...\n```\ntry {\n // Omitting all database and environment opens\n ...\n\n String searchName = \"John Doe\";\n DatabaseEntry searchKey =\n new DatabaseEntry(searchName.getBytes(\"UTF-8\"));\n DatabaseEntry primaryKey = new DatabaseEntry();\n DatabaseEntry primaryData = new DatabaseEntry();\n\n // Get the primary key and data for the user 'John Doe'.\n OperationStatus retVal = mySecondaryDatabase.get(null, searchKey,\n primaryKey,\n primaryData,\n LockMode.DEFAULT);\n}\n\ntry { catch (Exception e) { // Exception handling goes here } }\n\nNote that, just like Database.get(), if your secondary database supports duplicate records then SecondaryDatabase.get() only return the first record found in a matching duplicates set. If you want to see all the records related to a specific secondary key, then use a SecondaryCursor (described in Using Secondary Cursors (page 86)).\n\nDeleting Secondary Database Records\n\nIn general, you can not modify a secondary database directly. In order to modify a secondary database, you should modify the primary database and simply allow JE to manage the secondary modifications for you.\n\nHowever, as a convenience, you can delete SecondaryDatabase records directly. Doing so causes the associated primary key/data pair to be deleted. This in turn causes JE to delete all SecondaryDatabase records that reference the primary record.\n\nYou can use the SecondaryDatabase.delete() method to delete a secondary database record. Note that if your database supports duplicate records, then only the first record in the matching duplicates set is deleted by this method. To delete all the duplicate records that use a given key, use a SecondaryCursor.\n\nSecondaryDatabase.delete() causes the previously described delete operations to occur only if the primary database is opened for write access.\n\nFor example:\n\n```java\npackage je.gettingStarted;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.OperationStatus;\nimport com.sleepycat.je.SecondaryDatabase;\n```\ntry {\n // Omitting all database and environment opens\n ...\n\n String searchName = \"John Doe\";\n DatabaseEntry searchKey =\n new DatabaseEntry(searchName.getBytes(\"UTF-8\"));\n\n // Delete the first secondary record that uses \"John Doe\" as\n // a key. This causes the primary record referenced by this secondary\n // record to be deleted.\n OperationStatus retVal = mySecondaryDatabase.delete(null, searchKey);\n} catch (Exception e) {\n // Exception handling goes here\n}\n\nUsing Secondary Cursors\n\nJust like cursors on a primary database, you can use secondary cursors to iterate over the\nrecords in a secondary database. Like normal cursors, you can also use secondary cursors\nto search for specific records in a database, to seek to the first or last record in the\ndatabase, to get the next duplicate record, to get the next non-duplicate record, and so\nforth. For a complete description on cursors and their capabilities, see Using\nCursors (page 61).\n\nHowever, when you use secondary cursors:\n\n- Any data returned is the data contained on the primary database record referenced\n by the secondary record.\n\n- SecondaryCursor.getSearchBoth() and related methods do not search based on a\n key/data pair. Instead, you search based on a secondary key and a primary key. The\n data returned is the primary data that most closely matches the two keys provided\n for the search.\n\nFor example, suppose you are using the databases, classes, and key creators described\nin Implementing Key Creators (page 81). Then the following searches for a person's name\nin the secondary database, and deletes all secondary and primary records that use that\nname.\n\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\nimport com.sleepycat.je.SecondaryDatabase;\nimport com.sleepycat.je.SecondaryCursor;\n... try {\n // Database and environment opens omitted for brevity\n...\n\n String secondaryName = \"John Doe\";\n DatabaseEntry secondaryKey =\n new DatabaseEntry(secondaryName.getBytes(\"UTF-8\"));\n\n DatabaseEntry foundData = new DatabaseEntry();\n\n SecondaryCursor mySecCursor =\n mySecondaryDatabase.openSecondaryCursor(null, null);\n\n OperationStatus retVal = mySecCursor.getSearchKey(secondaryKey,\n foundData,\n LockMode.DEFAULT);\n\n while (retVal == OperationStatus.SUCCESS) {\n mySecCursor.delete();\n retVal = mySecCursor.getNextDup(secondaryKey,\n foundData,\n LockMode.DEFAULT);\n }\n} catch (Exception e) {\n // Exception handling goes here\n}\n\nDatabase Joins\n\nIf you have two or more secondary databases associated with a primary database, then\nyou can retrieve primary records based on the intersection of multiple secondary entries.\nYou do this using a JoinCursor.\n\nThroughout this document we have presented a class that stores inventory information\non grocery items. That class is fairly simple with a limited number of data members, few\nof which would be interesting from a query perspective. But suppose, instead, that we\nwere storing information on something with many more characteristics that can be queried,\nsuch as an automobile. In that case, you may be storing information such as color, number\nof doors, fuel mileage, automobile type, number of passengers, make, model, and year,\nto name just a few.\n\nIn this case, you would still likely be using some unique value to key your primary entries\n(in the United States, the automobile’s VIN would be ideal for this purpose). You would\nthen create a class that identifies all the characteristics of the automobiles in your\ninventory. You would also have to create some mechanism by which you would move\ninstances of this class in and out of Java byte arrays. We described the concepts and\nmechanisms by which you can perform these activities in Database Records (page 30).\nTo query this data, you might then create multiple secondary databases, one for each of the characteristics that you want to query. For example, you might create a secondary for color, another for number of doors, another for number of passengers, and so forth. Of course, you will need a unique key creator for each such secondary database. You do all of this using the concepts and techniques described throughout this chapter.\n\nOnce you have created this primary database and all interesting secondaries, what you have is the ability to retrieve automobile records based on a single characteristic. You can, for example, find all the automobiles that are red. Or you can find all the automobiles that have four doors. Or all the automobiles that are minivans.\n\nThe next most natural step, then, is to form compound queries, or joins. For example, you might want to find all the automobiles that are red, and that were built by Toyota, and that are minivans. You can do this using a JoinCursor class instance.\n\n### Using Join Cursors\n\nTo use a join cursor:\n\n- Open two or more secondary cursors. These cursors must be obtained from secondary databases that are associated with the same primary database.\n\n- Position each such cursor to the secondary key value in which you are interested. For example, to build on the previous description, the cursor for the color database is positioned to the *red* records while the cursor for the model database is positioned to the *minivan* records, and the cursor for the make database is positioned to *Toyota*.\n\n- Create an array of secondary cursors, and place in it each of the cursors that are participating in your join query.\n\n- Obtain a join cursor. You do this using the Database.join() method. You must pass this method the array of secondary cursors that you opened and positioned in the previous steps.\n\n- Iterate over the set of matching records using JoinCursor.getNext() until OperationStatus is not SUCCESS.\n\n- Close your join cursor.\n\n- If you are done with them, close all your secondary cursors.\n\nFor example:\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.JoinCursor;\nimport com.sleepycat.je.LockMode;\nimport com.sleepycat.je.OperationStatus;\n```\nimport com.sleepycat.je.SecondaryCursor;\nimport com.sleepycat.je.SecondaryDatabase;\n\n...\n\n// Database and secondary database opens omitted for brevity.\n// Assume a primary database handle:\n// automotiveDB\n// Assume 3 secondary database handles:\n// automotiveColorDB -- index based on automobile color\n// automotiveTypeDB -- index based on automobile type\n// automotiveMakeDB -- index based on the manufacturer\n\n// Query strings:\nString theColor = \"red\";\nString theType = \"minivan\";\nString theMake = \"Toyota\";\n\n// Secondary cursors used for the query:\nSecondaryCursor colorSecCursor = null;\nSecondaryCursor typeSecCursor = null;\nSecondaryCursor makeSecCursor = null;\n\n// The join cursor\nJoinCursor joinCursor = null;\n\n// These are needed for our queries\nDatabaseEntry foundKey = new DatabaseEntry();\nDatabaseEntry foundData = new DatabaseEntry();\n\n// All cursor operations are enclosed in a try block to ensure that they\n// get closed in the event of an exception.\ntry {\n\n // Database entries used for the query:\n DatabaseEntry color = new DatabaseEntry(theColor.getBytes(\"UTF-8\"));\n DatabaseEntry type = new DatabaseEntry(theType.getBytes(\"UTF-8\"));\n DatabaseEntry make = new DatabaseEntry(theMake.getBytes(\"UTF-8\"));\n\n colorSecCursor = automotiveColorDB.openSecondaryCursor(null, null);\n typeSecCursor = automotiveTypeDB.openSecondaryCursor(null, null);\n makeSecCursor = automotiveMakeDB.openSecondaryCursor(null, null);\n\n // Position all our secondary cursors to our query values.\n OperationStatus colorRet =\n colorSecCursor.getSearchKey(color, foundData, LockMode.DEFAULT);\n OperationStatus typeRet =\n typeSecCursor.getSearchKey(type, foundData, LockMode.DEFAULT);\n OperationStatus makeRet =\n makeSecCursor.getSearchKey(make, foundData, LockMode.DEFAULT);\n\n}\nmakeSecCursor.getSearchKey(make, foundData, LockMode.DEFAULT);\n\n// If all our searches returned successfully, we can proceed\nif (colorRet == OperationStatus.SUCCESS &&\ntypeRet == OperationStatus.SUCCESS &&\nmakeRet == OperationStatus.SUCCESS) {\n\n// Get a secondary cursor array and populate it with our\n// positioned cursors\nSecondaryCursor[] cursorArray = {colorSecCursor,\n typeSecCursor,\n makeSecCursor};\n\n// Create the join cursor\njoinCursor = automotiveDB.join(cursorArray, null);\n\n// Now iterate over the results, handling each in turn\nwhile (joinCursor.getNext(foundKey, foundData, LockMode.DEFAULT) ==\n OperationStatus.SUCCESS) {\n\n // Do something with the key and data retrieved in\n // foundKey and foundData\n\n} catch (DatabaseException dbe) {\n // Error reporting goes here\n} catch (Exception e) {\n // Error reporting goes here\n} finally {\n try {\n // Make sure to close out all our cursors\n if (colorSecCursor != null) {\n colorSecCursor.close();\n } if (typeSecCursor != null) {\n typeSecCursor.close();\n } if (makeSecCursor != null) {\n makeSecCursor.close();\n } if (joinCursor != null) {\n joinCursor.close();\n }\n } catch (DatabaseException dbe) {\n // Error reporting goes here\n }\n}\nJoinCursor Properties\n\nYou can set JoinCursor properties using the JoinConfig class. Currently there is just one property that you can set:\n\n- JoinConfig.setNoSort()\n\n Specifies whether automatic sorting of input cursors is disabled. The cursors are sorted from the one that refers to the least number of data items to the one that refers to the most.\n\nIf the data is structured so that cursors with many data items also share many common elements, higher performance will result from listing those cursors before cursors with fewer data items. Turning off sorting permits applications to specify cursors in the proper order given this scenario.\n\nThe default value is false (automatic cursor sorting is performed).\n\nFor example:\n\n```java\n// All database and environments omitted\nJoinConfig config = new JoinConfig();\nconfig.setNoSort(true);\nJoinCursor joinCursor = myDb.join(cursorArray, config);\n```\n\nSecondary Database Example\n\nIn previous chapters in this book, we built applications that load and display several JE databases. In this example, we will extend those examples to use secondary databases. Specifically:\n\n- In Stored Class Catalog Management with MyDbEnv (page 53) we built a class that we can use to open and manage a JE Environment and one or more Database objects. In Opening Secondary Databases with MyDbEnv (page 93) we will extend that class to also open and manage a SecondaryDatabase.\n\n- In Cursor Example (page 73) we built an application to display our inventory database (and related vendor information). In Using Secondary Databases with ExampleInventoryRead (page 96) we will extend that application to show inventory records based on the index we cause to be loaded using ExampleDatabasePut.\n\nBefore we can use a secondary database, we must implement a class to extract secondary keys for us. We use ItemNameKeyCreator for this purpose.\n\nExample 6.1. ItemNameKeyCreator.java\n\nThis class assumes the primary database uses Inventory objects for the record data. The Inventory class is described in Inventory.java (page 49).\nIn our key creator class, we make use of a custom tuple binding called InventoryBinding. This class is described in InventoryBinding.java (page 52).\n\nYou can find the following class in:\n\n```\nJE_HOME/examples/je/gettingStarted/ItemNameKeyCreator.java\n```\n\nwhere JE_HOME is the location where you placed your JE distribution.\n\n```java\npackage je.gettingStarted;\n\nimport com.sleepycat.je.DatabaseEntry;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.SecondaryDatabase;\nimport com.sleepycat.je.SecondaryKeyCreator;\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport java.io.IOException;\n\npublic class ItemNameKeyCreator implements SecondaryKeyCreator {\n\n private TupleBinding theBinding;\n\n // Use the constructor to set the tuple binding\n ItemNameKeyCreator(TupleBinding binding) {\n theBinding = binding;\n }\n\n // Abstract method that we must implement\n public boolean createSecondaryKey(SecondaryDatabase secDb,\n DatabaseEntry keyEntry, // From the primary\n DatabaseEntry dataEntry, // From the primary\n DatabaseEntry resultEntry) // set the key data on this.\n throws DatabaseException {\n\n try {\n // Convert dataEntry to an Inventory object\n Inventory inventoryItem =\n (Inventory) theBinding.entryToObject(dataEntry);\n // Get the item name and use that as the key\n String theItem = inventoryItem.getItemName();\n resultEntry.setData(theItem.getBytes(\"UTF-8\"));\n } catch (IOException willNeverOccur) {} \n return true;\n }\n}\n```\nNow that we have a key creator, we can use it to generate keys for a secondary database. We will now extend `MyDbEnv` to manage a secondary database, and to use `ItemNameKeyCreator` to generate keys for that secondary database.\n\n### Opening Secondary Databases with MyDbEnv\n\nIn [Stored Class Catalog Management with MyDbEnv](page 53) we built `MyDbEnv` as an example of a class that encapsulates `Environment` and `Database` opens and closes. We will now extend that class to manage a `SecondaryDatabase`.\n\n### Example 6.2. SecondaryDatabase Management with MyDbEnv\n\nWe start by importing two additional classes needed to support secondary databases. We also add a global variable to use as a handle for our secondary database.\n\n```java\n// File MyDbEnv.java\npackage je.gettingStarted;\n\nimport com.sleepycat.bind.tuple.TupleBinding;\nimport com.sleepycat.bind.serial.StoredClassCatalog;\n\nimport com.sleepycat.je.Database;\nimport com.sleepycat.je.DatabaseConfig;\nimport com.sleepycat.je.DatabaseException;\nimport com.sleepycat.je.Environment;\nimport com.sleepycat.je.EnvironmentConfig;\nimport com.sleepycat.je.SecondaryConfig;\nimport com.sleepycat.je.SecondaryDatabase;\n\nimport java.io.File;\n\npublic class MyDbEnv {\n private Environment myEnv;\n\n // The databases that our application uses\n private Database vendorDb;\n private Database inventoryDb;\n private Database classCatalogDb;\n private SecondaryDatabase itemNameIndexDb;\n\n // Needed for object serialization\n private StoredClassCatalog classCatalog;\n\n // Our constructor does nothing\n public MyDbEnv() {}\n}\n```\nNext we update the `MyDbEnv.setup()` method to open the secondary database. As a part of this, we have to pass an `ItemNameKeyCreator` object on the call to open the secondary database. Also, in order to instantiate `ItemNameKeyCreator`, we need an `InventoryBinding` object (we described this class in `InventoryBinding.java (page 52)`). We do all this work together inside of `MyDbEnv.setup()`.\n\n```java\npublic void setup(File envHome, boolean readOnly) throws DatabaseException {\n EnvironmentConfig myEnvConfig = new EnvironmentConfig();\n DatabaseConfig myDbConfig = new DatabaseConfig();\n SecondaryConfig mySecConfig = new SecondaryConfig();\n\n // If the environment is read-only, then\n // make the databases read-only too.\n myEnvConfig.setReadOnly(readOnly);\n myDbConfig.setReadOnly(readOnly);\n mySecConfig.setReadOnly(readOnly);\n\n // If the environment is opened for write, then we want to be\n // able to create the environment and databases if\n // they do not exist.\n myEnvConfig.setAllowCreate(!readOnly);\n myDbConfig.setAllowCreate(!readOnly);\n mySecConfig.setAllowCreate(!readOnly);\n\n ...\n // Environment and database opens omitted for brevity\n ...\n\n // Open the secondary database. We use this to create a\n // secondary index for the inventory database\n\n // We want to maintain an index for the inventory entries based\n // on the item name. So, instantiate the appropriate key creator\n // and open a secondary database.\n ItemNameKeyCreator keyCreator =\n new ItemNameKeyCreator(new InventoryBinding());\n\n // Set up the secondary properties\n mySecConfig.setAllowPopulate(true); // Allow autopopulate\n mySecConfig.setKeyCreator(keyCreator);\n // Need to allow duplicates for our secondary database\n mySecConfig.setSortedDuplicates(true);\n\n // Now open it\n itemNameIndexDb =\n myEnv.openSecondaryDatabase(\n null,\n ...);\nNext we need an additional getter method for returning the secondary database.\n\n```java\npublic SecondaryDatabase getNameIndexDB() {\n return itemNameIndexDb;\n}\n```\n\nFinally, we need to update the `MyDbEnv.close()` method to close the new secondary database. We want to make sure that the secondary is closed before the primaries. While this is not necessary for this example because our closes are single-threaded, it is still a good habit to adopt.\n\n```java\npublic void close() {\n if (myEnv != null) {\n try {\n //Close the secondary before closing the primaries\n itemNameIndexDb.close();\n vendorDb.close();\n inventoryDb.close();\n classCatalogDb.close();\n\n // Finally, close the environment.\n myEnv.close();\n } catch(DatabaseException dbe) {\n System.err.println(\"Error closing MyDbEnv: \"+ dbe.toString());\n System.exit(-1);\n }\n }\n}\n```\n\nThat completes our update to `MyDbEnv`. You can find the complete class implementation in:\n\n```java\nJE_HOME/examples/je/gettingStarted/MyDbEnv.java\n```\n\nwhere `JE_HOME` is the location where you placed your JE distribution.\n\nBecause we performed all our secondary database configuration management in `MyDbEnv`, we do not need to modify `ExampleDatabasePut` at all in order to create our secondary indices. When `ExampleDatabasePut` calls `MyDbEnv.setup()`, all of the necessary work is performed for us.\n\nHowever, we still need to take advantage of the new secondary indices. We do this by updating `ExampleInventoryRead` to allow us to query for an inventory record based on its\nname. Remember that the primary key for an inventory record is the item’s SKU. The item’s name is contained in the Inventory object that is stored as each record’s data in the inventory database. But our new secondary index now allows us to easily query based on the item’s name.\n\n**Using Secondary Databases with ExampleInventoryRead**\n\nIn the previous section we changed MyDbEnv to cause a secondary database to be built using inventory item names as the secondary keys. In this section, we will update ExampleInventoryRead to allow us to query our inventory records based on the item name. To do this, we will modify ExampleInventoryRead to accept a new command line switch, `-s`, whose argument is the name of an inventory item. If the switch is present on the command line call to ExampleInventoryRead, then the application will use the secondary database to look up and display all the inventory records with that item name. Note that we use a SecondaryCursor to seek to the item name key and then display all matching records.\n\nRemember that you can find the following class in:\n\n```java\nJE_HOME/examples/je/gettingStarted/ExampleInventoryRead.java\n```\n\nwhere `JE_HOME` is the location where you placed your JE distribution.\n\n**Example 6.3. SecondaryDatabase usage with ExampleInventoryRead**\n\nFirst we need to import a few additional classes in order to use secondary databases and cursors, and then we add a single global variable:\n\n```java\nclass ExampleInventoryRead {\n private static File myDbEnvPath =\n new File(\"/tmp/JEDB\");\n}\n```\n// Encapsulates the database environment and databases.\nprivate static MyDbEnv myDbEnv = new MyDbEnv();\n\nprivate static TupleBinding inventoryBinding;\nprivate static EntryBinding vendorBinding;\n\n// The item to locate if the -s switch is used\nprivate static String locateItem;\n\nNext we update ExampleInventoryRead.run() to check to see if the locateItem global variable a value. If it does, then we show just those records related to the item name passed on the -s switch.\n\nprivate void run(String args[]) throws DatabaseException {\n // Parse the arguments list\n parseArgs(args);\n myDbEnv.setup(myDbEnvPath, // path to the environment home\n true); // is this environment read-only?\n\n // Setup our bindings.\n inventoryBinding = new InventoryBinding();\n vendorBinding =\n new SerialBinding(myDbEnv.getClassCatalog(),\n Vendor.class);\n\n if (locateItem != null) {\n showItem();\n } else {\n showAllInventory();\n }\n}\n\nFinally, we need to implement ExampleInventoryRead.showItem(). This is a fairly simple method that opens a secondary cursor, and then displays every primary record that is related to the secondary key identified by the locateItem global variable.\n\nprivate void showItem() throws DatabaseException {\n SecondaryCursor secCursor = null;\n try {\n // searchKey is the key that we want to find in the\n // secondary db.\n DatabaseEntry searchKey =\n new DatabaseEntry(locateItem.getBytes(\"UTF-8\"));\n\n // foundKey and foundData are populated from the primary\n // entry that is associated with the secondary db key.\n DatabaseEntry foundKey = new DatabaseEntry();\n DatabaseEntry foundData = new DatabaseEntry();\n }\n// open a secondary cursor\nsecCursor = \n myDbEnv.getNameIndexDB().openSecondaryCursor(null, null);\n\n// Search for the secondary database entry.\nOperationStatus retVal =\n secCursor.getSearchKey(searchKey, foundKey,\n foundData, LockMode.DEFAULT);\n\n// Display the entry, if one is found. Repeat until no more\n// secondary duplicate entries are found\nwhile(retVal == OperationStatus.SUCCESS) {\n Inventory theInventory =\n (Inventory)inventoryBinding.entryToObject(foundData);\n displayInventoryRecord(foundKey, theInventory);\n retVal = secCursor.getNextDup(searchKey, foundKey,\n foundData, LockMode.DEFAULT);\n}\n\n} catch (Exception e) {\n System.err.println(\"Error on inventory secondary cursor:\");\n System.err.println(e.toString());\n e.printStackTrace();\n} finally {\n if (secCursor != null) {\n secCursor.close();\n }\n}\n\nThe only other thing left to do is to update ExampleInventoryRead.parseArgs() to support\nthe -s command line switch. To see how this is done, see:\n\nJE_HOME/examples/je/gettingStarted/ExampleInventoryRead.java\n\nwhere JE_HOME is the location where you placed your JE distribution.\nChapter 7. Backing up and Restoring Berkeley DB Java Edition Applications\n\nFundamentally, you backup your databases by copying JE log files off to a safe storage location. To restore your database from a backup, you copy those files to an appropriate directory on disk and reopen your JE application.\n\nBeyond these simple activities, there are some differing backup strategies that you may want to consider. These topics are described in this chapter.\n\nDatabases and Log Files\n\nBefore describing JE backup and restore, it is necessary to describe some of JE's internal workings. In particular, a high-level understanding of JE log files and the in-memory cache is required. You also need to understand a little about how JE is using its internal data structures in order to understand why checkpoints and/or syncs are required.\n\nYou can skip this section so long as you understand that:\n\n- JE databases are stored in log files contained in your environment directory.\n- Every time a JE environment is opened, normal recovery is run.\n- For transactional applications, checkpoints should be run in order to bound normal recovery time. Checkpoints are normally run by the checkpointer thread. Transactional applications and the checkpointer thread are described in the Berkeley DB Java Edition Getting Started with Transaction Processing guide.\n- For non-transactional applications, environment syncs must be performed if you want to guarantee the persistence of your database modifications. Environment syncs are manually performed by the application developer. See Data Persistence (page 35) for details.\n\nLog File Overview\n\nYour JE database is stored on-disk in a series of log files. JE uses no-overwrite log files, which is to say that JE only ever appends data to the end of a log file. It will never delete or modify an existing log file record.\n\nJE log files are named \\texttt{NNNNNNNN.jdb} where \\texttt{NNNNNNNN} is an 8-digit hexadecimal number that increases by 1 (starting from \\texttt{00000000}) for each log file written to disk.\n\nJE creates a new log file whenever the current log file has reached a pre-configured size (10000000 bytes by default). This size is controlled by the \\texttt{je.log.fileMax} properties parameter. See The JE Properties File (page 106) for information on setting JE properties.\nCleaning the Log Files\n\nBecause JE uses no-overwrite log files, the logs must be compacted or cleaned so as to conserve disk space.\n\nJE uses the cleaner background thread to perform this task. When it runs, the cleaner thread picks the log file with the smallest number of active records and scans each log record in it. If the record is no longer active in the database tree, the cleaner does nothing. If the record is still active in the tree, then the cleaner copies the record forward to a newer log file.\n\nOnce a log file is no longer needed (that is, it no longer contains active records), then the cleaner thread deletes the log file for you. Or, optionally, the cleaner thread can simply rename the discarded log file with a del suffix.\n\nJE uses a minimum log utilization property to determine how much cleaning to perform. The log files contain both obsolete and utilized records. Obsolete records are records that are no longer in use, either because they have been modified or because they have been deleted. Utilized records are those records that are currently in use. The je.cleaner.minUtilization property identifies the minimum percentage of log space that must be used by utilized records. If this minimum percentage is not met, then log files are cleaned until the minimum percentage is met.\n\nFor information on managing the cleaner thread, see The Cleaner Thread (page 107).\n\nThe BTree\n\nJE databases are internally organized as a BTree. In order to operate, JE requires the complete BTree be available to it.\n\nWhen database records are created, modified, or deleted, the modifications are represented in the BTree's leaf nodes. Beyond leaf node changes, database record modifications can also cause changes to other BTree nodes and structures.\n\nDatabase Modifications and Syncs\n\nWhen a write operation is performed in JE, the modified data is written to a leaf node contained in the in-memory cache. If your JE writes are performed without transactions, then the in-memory cache is the only location guaranteed to receive a database modification without further intervention on the part of the application developer.\n\nFor some class of applications, this lack of a guaranteed write to disk is ideal. By not writing these modifications to the on-disk logs, the application can avoid most of the overhead caused by disk I/O.\n\nHowever, if the application requires its data to persist persist at a specific point in time, then the developer must manually sync database modifications to the on-disk log files (again, this is only necessary for non-transactional applications). This is done using Environment.sync().\nNote that syncing the cache causes JE to write all modified objects in the cache to disk. This is probably the most expensive operation that you can perform in JE.\n\n**Normal Recovery**\n\nEvery time a JE environment is opened, normal recovery is run. Because of the way that JE organizes and manages its B-Trees, all it needs is leaf nodes in order to recreate the rest of the BTree. Essentially, this is what normal recovery is doing - recreating any missing parts of the internal BTree from leaf node information stored in the log files.\n\nUnlike a traditional database system, JE performs recovery for both transactional and non-transactional operations. The integrity of the Btree is guaranteed by JE in the face of both application and OS crashes.\n\n**Performing Backups**\n\nThis section describes how to backup your JE database(s) such that catastrophic recovery is possible for non-transactional applications. Note that this same material is repeated in the *Berkeley DB Java Edition Getting Started with Transaction Processing* guide, but for transactional applications. If you are writing transactional applications, you may want to skip the rest of this chapter and go straight to that book.\n\nTo backup your database, you can either take a hot backup or an offline backup. A hot backup is performed while database write operations are in progress.\n\nDo not confuse hot and offline backups with the concept of a full and incremental backup. Both a hot and an offline backup are full backups - you back up the entire database. The only difference between them is how much of the contents of the in-memory cache are contained in them. On the other hand, an incremental backup is a backup of just those log files modified or created since the time of the last backup. Most backup software is capable of performing both full and incremental backups for you.\n\n**Performing a Hot Backup**\n\nTo perform a hot backup of your JE databases, copy all log files (*.jdb files) from your environment directory to your archival location or backup media. The files must be copied in alphabetical order (numerical in effect). You do not have to stop any database operations in order to do this.\n\nTo make this process a bit easier, you may want to make use of the DbBackup helper class. See Using the DbBackup Helper Class (page 102) for details.\n\nNote that any modifications made to the database since the time of the last environment sync are not guaranteed to be contained in these log files. In this case, you may want to consider running an offline backup in order to guarantee the availability of all modifications made to your database.\nPerforming an Offline Backup\n\nAn offline backup guarantees that you have captured the database in its entirety, including all contents of your in-memory cache, at the moment that the backup was taken. To do this, you must make sure that no write operations are in progress and all database modifications have been written to your log files on disk. To obtain an offline backup:\n\n1. Stop writing your databases.\n2. Run `Environment.sync()` so as to ensure that all database modifications are written to disk. Note that cleanly closing your environment will also ensure that all database modifications are written to disk.\n3. Copy all log files (*.jdb) from your environment directory to your archival location or backup media. To make this process a bit easier, you may want to make use of the `DbBackup` helper class. See the next section for details.\n\nYou can now resume normal database operations.\n\nUsing the DbBackup Helper Class\n\nIn order to simplify backup operations, JE provides the `DbBackup` helper class. This class stops and restarts JE background activity in an open environment. It also lets the application create a backup which can support restoring the environment to a specific point in time.\n\nBecause you do not have to stop JE write activity in order to take a backup, it is usually necessary to examine your log files twice before you decide that your backup is complete. This is because JE may create a new log file while you are running your backup. A second pass over your log files allows you to ensure that no new files have been created and so you can declare your backup complete.\n\nFor example:\n\n<table>\n<thead>\n<tr>\n<th>time</th>\n<th>files in environment</th>\n<th>activity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>000000001.jdb</td>\n<td>Backup starts copying file 1</td>\n</tr>\n<tr>\n<td></td>\n<td>000000003.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>000000004.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td>t0</td>\n<td>000000001.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>000000003.jdb</td>\n<td>JE log cleaner migrates portion of file 3 to newly created file 5 and deletes file 3. Backup finishes file 1, starts copying file 4. Backup MUST include file 5 for a consistent backup!</td>\n</tr>\n<tr>\n<td></td>\n<td>000000004.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>000000005.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td>t1</td>\n<td>000000001.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>000000003.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>000000004.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>000000005.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td>t2</td>\n<td>000000001.jdb</td>\n<td>Backup finishes copying file 4, starts and finishes file 5, has caught up. Backup ends.</td>\n</tr>\n<tr>\n<td></td>\n<td>000000003.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>000000004.jdb</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>000000005.jdb</td>\n<td></td>\n</tr>\n</tbody>\n</table>\nDbBackup works around this problem by defining the set of files that must be copied for each backup operation, and freezes all changes to those files. The application can copy that defined set of files and finish operation without checking for the ongoing creation of new files. Also, there will be no need to check for a newer version of the last file on the next backup.\n\nIn the example above, if DbBackup was used at t0, the application would only have to copy files 1, 3 and 4 to back up. On a subsequent backup, the application could start its copying at file 5. There would be no need to check for a newer version of file 4.\n\nThe following code fragment illustrates this class’ usage:\n\n```java\npackage je.gettingStarted;\n...\nimport com.sleepycat.je.util.DbBackup;\n...\n\nEnvironment env = new Environment(...);\nDbBackup backupHelper = new DbBackup(env);\n\n// Find the file number of the last file in the previous backup\n// persistently, by either checking the backup archive, or saving\n// state in a persistent file.\nlong lastFileCopiedInPrevBackup = ...\n\n// Start backup, find out what needs to be copied.\nbackupHelper.startBackup();\ntry {\n String[] filesForBackup =\n backupHelper.getLogFilesInBackupSet(lastFileCopiedInPrevBackup);\n\n // Copy the files to archival storage.\n myApplicationCopyMethod(filesForBackup)\n // Update our knowlege of the last file saved in the backup set,\n // so we can copy less on the next backup\n lastFileCopiedInPrevBackup = backupHelper.getLastFileInBackupSet();\n myApplicationSaveLastFile(lastFileCopiedInBackupSet);\n}\nfinally {\n // Remember to exit backup mode, or all log files won't be cleaned\n // and disk usage will bloat.\n backupHelper.endBackup();\n}\n```\nPerforming Catastrophic Recovery\n\nCatastrophic recovery is necessary whenever your environment and/or database have been lost or corrupted due to a media failure (disk failure, for example). Catastrophic recovery is also required if normal recovery fails for any reason.\n\nIn order to perform catastrophic recovery, you must have a full back up of your databases. You will use this backup to restore your database. See Performing Backups (page 101) for information on running back ups.\n\nTo perform catastrophic recovery:\n\n1. Shut down your application.\n2. Delete the contents of your environment home directory (the one that experienced a catastrophic failure), if there is anything there.\n3. Copy your most recent full backup into your environment home directory.\n4. If you are using a backup utility that runs incremental backups of your environment directory, copy any log files generated since the time of your last full backup. Be sure to restore all log files in the order that they were written. The order is important because it is possible the same log file appears in multiple archives, and you want to run recovery using the most recent version of each log file.\n5. Open the environment as normal. JE's normal recovery will run, which will bring your database to a consistent state relative to the changed data found in your log files.\n\nYou are now done restoring your database.\n\nHot Standby\n\nAs a final backup/recovery strategy, you can create a hot standby. Note that using hot standbys requires your application to be able to specify its environment home directory at application startup time. Most application developers allow the environment home directory to be identified using a command line option or a configuration or properties file. If your application has its environment home hard-coded into it, you cannot use hot standbys.\n\nYou create a hot standby by periodically backing up your database to an alternative location on disk. Usually this alternative location is on a separate physical drive from where you normally keep your database, but if multiple drives are not available then you should at least put the hot standby on a separate disk partition.\n\nYou failover to your hot standby by causing your application to reopen its environment using the hot standby location.\n\nNote that a hot standby should not be used as a substitute for backing up and archiving your data to a safe location away from your operating environment. Even if your data is spread across multiple physical disks, a truly serious catastrophe (fires, malevolent\nsoftware viruses, faulty disk controllers, and so forth) can still cause you to lose your data.\n\nTo create and maintain a hot standby:\n\n1. Copy all log files (*.jdb) from your environment directory to the location where you want to keep your standby. Either a hot or an offline backup can be used for this purpose, but typically a hot standby is initially created by taking an offline backup of your database. This ensures that you have captured the contents of your in-memory cache.\n\n2. Periodically copy to your standby directory any log files that were changed or created since the time of your last copy. Most backup software is capable of performing this kind of an incremental backup for you.\n\n Note that the frequency of your incremental copies determines the amount of data that is at risk due to catastrophic failures. For example, if you perform the incremental copy once an hour then at most your hot standby is an hour behind your production database, and so you are risking at most an hours worth of database changes.\n\n3. Remove any *.jdb files from the hot standby directory that have been removed or renamed to .del files in the primary directory. This is not necessary for consistency, but will help to reduce disk space consumed by the hot standby.\nChapter 8. Administering Berkeley DB Java Edition Applications\n\nThere are a series of tools and parameters of interest to the administrator of a Berkeley DB Java Edition database. These tools and parameters are useful for tuning your JE database's behavior once it is in a production setting, and they are described here. This chapter, however, does not describe backing up and restoring your JE databases. See Backing up and Restoring Berkeley DB Java Edition Applications (page 99) for information on how to perform those procedures.\n\nThe JE Properties File\n\nJE applications can be controlled through a Java properties file. This file must be placed in your environment home directory and it must be named je.properties.\n\nThe parameters set in this file take precedence over the configuration behavior coded into the JE application by your application developers.\n\nUsually you will use this file to control the behavior of JE's background threads, and to control the size of your in-memory cache. These topics, and the properties parameters related to them, are described in this chapter. Beyond the properties described here, there are other properties identified throughout this manual that may be of interest to you. However, the definitive identification of all the property parameters available to you is in the sample example.properties located in the directory where your JE distribution was unpacked.\n\nManaging the Background Threads\n\nJE uses some background threads to keep your database resources within pre-configured limits. If they are going to run, the background threads are started once per application per process. That is, if your application opens the same environment multiple times, the background threads will be started just once for that process. See the following list for the default conditions that gate whether an individual thread is run. Note that you can prevent a background thread from running by using the appropriate je.properties parameter, but this is not recommended for production use and those parameters are not described here.\n\nThe background threads are:\n\n- Cleaner thread.\n \n Responsible for cleaning and deleting unused log files. See The Cleaner Thread (page 107) for more information.\n\n This thread is run only if the environment is opened for write access.\n• Compressor thread.\n\n Responsible for cleaning up the internal BTree as database records are deleted. The compressor thread ensures that the BTree does not contain unused nodes. There is no need for you to manage the compressor and so it is not described further in this manual.\n\n This thread is run only if the environment is opened for write access.\n\n• Checkpointer thread.\n\n Responsible for running checkpoints on your environment. See The Checkpointer Thread (page 108) for more information.\n\n This thread always runs.\n\nThe Cleaner Thread\n\nThe cleaner thread is responsible for cleaning, or compacting, your log files for you. Log file cleaning is described in Cleaning the Log Files (page 100).\n\nThe following two properties may be of interest to you when managing the cleaner thread:\n\n• **je.cleaner.minUtilization**\n\n Identifies the percentage of the log file space that must be used for utilized records. If the percentage of log file space used by utilized records is too low, then the cleaner removes obsolete records until this threshold is reached. Default is 50%.\n\n• **je.cleaner.expunge**\n\n Identifies the cleaner’s behavior in the event that it is able to remove a log file. If true, the log files that have been cleaned are deleted from the file system. If false, the log files that have been cleaned are renamed from \\texttt{NNNNNNNN.jdb} to \\texttt{NNNNNNNN.del}. You are then responsible for deleting the renamed files.\n\nNote that the cleaner thread runs only if the environment is opened for write access. Also, be aware that the cleaner is not guaranteed to finish running before the environment is closed, which can result in unexpectedly large log files. See Closing Database Environments (page 12) for more information.\n**The Checkpointer Thread**\n\nAutomatically runs checkpoints. Checkpoints and the administration of this thread are described in the *Berkeley DB Java Edition Getting Started with Transaction Processing* guide.\n\n**Sizing the Cache**\n\nBy default, your cache is limited to a percentage of the JVM maximum memory as specified by the `-Xmx` parameter. You can change this percentage by using the `je.maxMemoryPercent` property or through `EnvironmentMutableConfig.setCachePercent()`. That is, the maximum amount of memory available to your cache is normally calculated as:\n\n\\[\n\\text{je.maxMemoryPercent} \\times \\text{JVM\\_maximum\\_memory}\n\\]\n\nYou can find out what the value for this property is by using `EnvironmentConfig.getCachePercent()`.\n\nNote that you can cause JE to use a fixed maximum cache size by using `je.maxMemory` or by using `EnvironmentConfig.setCacheSize()`.\n\nAlso, not every JVM is capable of identifying the amount of memory requested via the `-Xmx` parameter. For those JVMs you must use `je.maxMemory` to change your maximum cache size. The default maximum memory available to your cache in this case is 38M.\n\nOf the amount of memory allowed for your cache, 93% is used for the internal BTree and the other 7% is used for internal buffers. When your application first starts up, the 7% for buffers is immediately allocated. The remainder of the cache grows lazily as your application reads and writes data.\n\nIn order for your application to start up successfully, the Java virtual machine must have enough memory available to it (as identified by the `-Xmx` command line switch) for both your application and 7% of your maximum cache value. In order for your application to run continuously (all the while loading data into the cache), you must make sure your JVM has enough memory for your application plus the maximum cache size.\n\nThe best way to determine how large your cache needs to be is to put your application into a production environment and watch to see how much disk I/O is occurring. If the application is going to disk quite a lot to retrieve database records, then you should increase the size of your cache (provided that you have enough memory to do so).\n\nIn order to determine how frequently your application is going to disk for database records not found in the cache, you can examine the value returned by `EnvironmentStats.getNCacheMiss()`.\n\n`EnvironmentStats.getNCacheMiss()` identifies the total number of requests for database objects that were not serviceable from the cache. This value is cumulative since the application started. The faster this number grows, the more your application is going to disk to service database operations. Upon application startup you can expect this value to grow quite rapidly. However, as time passes and your cache is seeded with your most\nfrequently accessed database records, what you want is for this number’s growth to be zero or at least very small.\n\nNote that this statistic can only be collected from within the application itself or using the JMX extension (see JMX Support (page 8)).\n\nFor more information on collecting this statistic, see Environment Statistics (page 16).\n\nThe Command Line Tools\n\nJE ships with several command line tools that you can use to help you manage your databases. They are:\n\n- **DbDump**\n Dumps a database to a user-readable format.\n\n- **DbLoad**\n Loads a database from the output produced by DbDump.\n\n- **DbVerify**\n Verifies the structure of a database.\n\n**DbDump**\n\nDumps a database to a flat-text representation. Options are:\n\n- `-f`\n Identifies the file to which the output from this command is written. The console (standard out) is used by default.\n\n- `-h`\n Identifies the environment’s directory. This parameter is required.\n\n- `-l`\n Lists the databases contained in the environment. If the `-s` is not provided, then this argument is required.\n\n- `-p`\n Prints database records in human-readable format.\n\n- `-r`\n Salvage data from a possibly corrupt file. When used on an uncorrupted database, this option should return data equivalent to a normal dump, but most likely in a different order.\n\n This option causes the ensuing output to go to a file named `dbname.dump` where `dbname` is the name of the database you are dumping. The file is placed in the current working directory.\n-R\nAggressively salvage data from a possibly corrupt file. This option differs from\nthe -r option in that it will return all possible data from the file at the risk of also\nreturning already deleted or otherwise nonsensical items. Data dumped in this\nfashion will almost certainly have to be edited by hand or other means before\nthe data is ready for reload into another database.\n\nThis option causes the ensuing output to go to a file named dbname.dump where\ndbname is the name of the database you are dumping. The file is placed in the\ncurrent working directory.\n\n-s\nIdentifies the database to be dumped. If this option is not specified, then the -l\nis required.\n\n-v\nPrints progress information to the console for -r or -R mode.\n\n-v\nPrints the database version number and then quits. All other command line options\nare ignored.\n\nFor example:\n\n```\n > java com.sleepycat.je.util.DbDump -h . -p -s VendorDB\n VERSION=3\n format=print\ntype=btree\ndatabase=VendorDB\ndupsort=false\nHEADER=END\n Mom's Kitchen\n sr\\01\\01xpt\\00\\0d53 Yerman Ct\\00\\0c763 554 9200t\\00\\0bMiddle Town\\00\n\\0eMaggie Kultgent\\00\\10763 554 9200 x12t\\00\\02MNt\\00\\0dMom's Kitchent\\00\n\\0555432\n Off the Vine\n sr\\01\\01xpt\\00\\10133 American Ct\\00\\0c563 121 3800t\\00\\0aCentennial\\00\\0\n\\08Bob Kingt\\00\\10563 121 3800 x54t\\00\\021At\\00\\0cOff the Vinet\\00\\0552002\n Simply Fresh\n sr\\01\\01xpt\\00\\1115612 Bogart Lanet\\00\\0c420 333 3912t\\00\\08Harrigant\\00\\0\n\\0fCheryl Swedbergt\\00\\0c420 333 3952t\\00\\02WIt\\00\\0cSimply Fresht\\00\\0\n 553704\n The Baking Pan\n sr\\01\\01xpt\\00\\0e1415 53rd Ave.t\\00\\0c320 442 2277t\\00\\07Dutchint\\00\\09\nMike Roant\\00\\0c320 442 6879t\\00\\02MNt\\00\\0eThe Baking Pant\\00\\0556304\n The Pantry\n sr\\01\\01xpt\\00\\0f11206 N. Creek Wayt\\00\\0c763 555 3391t\\00\\0bMiddle Town\n t\\00\\0fSully Beckstromt\\00\\0c763 555 3391t\\00\\02MNt\\00\\0aThe Pantryt\\00\n\\0555432\n TriCounty Produce\n```\nDbLoad\n\nLoads a database from the output produced by DbDump. Options are:\n\n-\\c\n\nSpecifies configuration options. The options supplied here override the corresponding options that appear in the data that is being loaded. This option takes values of the form name=value, where name is the configuration option that you are overriding and value is the new value for the option.\n\nThe following options can be specified:\n\n- database\n\nThe name of the database to be loaded. This option duplicates the functionality of this command's \\-s command line option.\n\n- dupsort\n\nIndicates whether duplicates are allowed in the database. A value of true allows duplicates in the database.\n\n-\\f\n\nIdentifies the file from which the database is to be loaded.\n\n-\\n\nDo not overwrite existing keys in the database when loading into an already existing database. If a key/data pair cannot be loaded into the database for this reason, a warning message is displayed on the standard error output, and the key/data pair are skipped.\n\n-\\h\n\nIdentifies the environment’s directory. This parameter is required.\n\n-\\l\n\nAllows loading databases that were dumped with the Berkeley DB C product, when the dump file contains parameters not known to JE.\n\n-\\s\n\nOverrides the database name, causing the data to be loaded into a database that uses the name supplied to this parameter.\n\n-\\T\n\nCauses a flat text file to be loaded into the database.\nThe input must be paired lines of text, where the first line of the pair is the key item, and the second line of the pair is its corresponding data item.\n\nA simple escape mechanism, where newline and backslash (\\) characters are special, is applied to the text input. Newline characters are interpreted as record separators. Backslash characters in the text will be interpreted in one of two ways: If the backslash character precedes another backslash character, the pair will be interpreted as a literal backslash. If the backslash character precedes any other character, the two characters following the backslash will be interpreted as a hexadecimal specification of a single character; for example, \\0a is a newline character in the ASCII character set.\n\nFor this reason, any backslash or newline characters that naturally occur in the text input must be escaped to avoid misinterpretation by db_load.\n\n-v\nReport periodic load status to the console.\n\n-V\nPrints the database version number and then quits. All other command line options are ignored.\n\nFor example:\n\n> java com.sleepycat.je.util.DbDump -h . -s VendorDB -f vendordb.txt\n> java com.sleepycat.je.util.DbLoad -h . -f vendordb.txt\n>\n\nDbVerify\n\nExamines the identified database for errors. Options are:\n\n-h\nIdentifies the environment’s directory. This parameter is required.\n\n-q\nSuppress the printing of any error descriptions. Instead, simply exit success or failure.\n\n-s\nIdentifies the database to be verified. This parameter is required.\n\n-v\nPrints the database version number and then quits. All other command line options are ignored.\n\n-V\nReport intermediate statistics every N leaf nodes, where N is the value that you provide this parameter.\n\nFor example:\n> java com.sleepycat.je.util.DbVerify -h . -s VendorDB\n\n<BtreeStats>\n <BottomInternalNodesByLevel total=\"1\">\n <Item level=\"1\" count=\"1\"/>\n </BottomInternalNodesByLevel>\n <InternalNodesByLevel total=\"1\">\n <Item level=\"2\" count=\"1\"/>\n </InternalNodesByLevel>\n <LeafNodes count=\"6\"/>\n <DeletedLeafNodes count=\"0\"/>\n <DuplicateCountLeafNodes count=\"0\"/>\n <MainTreeMaxDepth depth=\"2\"/>\n <DuplicateTreeMaxDepth depth=\"0\"/>\n</BtreeStats>"}}},{"rowIdx":163,"cells":{"id":{"kind":"string","value":"d4e70d137aba07b642df3c3c3424bcbfa6f89edb"},"text":{"kind":"string","value":"GXP2130/2135/2140/2160/2170 Firmware Release Notes\n\nTable of Content\n\nTable of Content .................................................................................................................. 1\n\nFIRMWARE VERSION 1.0.11.16 .......................................................................................... 7\nPRODUCT NAME .............................................................................................................. 7\nDATE .................................................................................................................................. 7\nFIRMWARE FILE INFORMATION ...................................................................................... 7\nIMPORTANT UPGRADING NOTE ...................................................................................... 7\nENHANCEMENT ................................................................................................................ 7\nBUG FIX ............................................................................................................................ 8\nNEW FEATURES OVERVIEW ............................................................................................ 8\n TLS VERSION SELECTION ............................................................................................... 8\n ENABLE/DISABLE WEAK CIPHERS ................................................................................. 9\n SSH PORT ....................................................................................................................... 9\n FACTORY RESET SECURITY LEVEL .............................................................................. 10\n AUTO ANSWER NUMBERS FEATURE ......................................................................... 10\n RELEASE DHCP ON REBOOT ...................................................................................... 11\n\nFIRMWARE VERSION 1.0.11.10 ......................................................................................... 12\nPRODUCT NAME .............................................................................................................. 12\nDATE .................................................................................................................................. 12\nFIRMWARE FILE INFORMATION ...................................................................................... 12\nIMPORTANT UPGRADING NOTE ...................................................................................... 12\nBUG FIX ............................................................................................................................ 12\n\nFIRMWARE VERSION 1.0.11.6 ......................................................................................... 13\nPRODUCT NAME .............................................................................................................. 13\nDATE .................................................................................................................................. 13\nFIRMWARE FILE INFORMATION ...................................................................................... 13\nIMPORTANT UPGRADING NOTE ...................................................................................... 13\nBUG FIX ............................................................................................................................ 13\n\nFIRMWARE VERSION 1.0.11.3 ......................................................................................... 14\nPRODUCT NAME .............................................................................................................. 14\nDATE .................................................................................................................................. 14\n## FIRMWARE VERSION 1.0.11.2 ......................................................... 15\n\n| PRODUCT NAME | ................................................................. | 15 |\n| DATE | ................................................................. | 15 |\n| FIRMWARE FILE INFORMATION | ................................................................. | 15 |\n| IMPORTANT UPGRADING NOTE | ................................................................. | 15 |\n| ENHANCEMENT | ................................................................. | 15 |\n| BUG FIX | ................................................................. | 16 |\n\n### NEW FEATURES OVERVIEW.\n\n- **LOAD CA CERTIFICATES** ......................................................... 17\n- **XML APP AUTO LAUNCH** ......................................................... 17\n- **ACCEPT INCOMING SIP FROM PROXY ONLY** .................................. 18\n- **LOCK SPEAKER VOLUME** ......................................................... 18\n- **ACCEPT PVALUE IN STRING FORMAT** ........................................ 19\n- **SIP USER ID FIELD IMPROVEMENT** ........................................ 20\n\n## FIRMWARE VERSION 1.0.9.135 ..................................................... 21\n\n| PRODUCT NAME | ................................................................. | 21 |\n| DATE | ................................................................. | 21 |\n| FIRMWARE FILE INFORMATION | ................................................................. | 21 |\n| IMPORTANT UPGRADING NOTE | ................................................................. | 21 |\n| ENHANCEMENT | ................................................................. | 21 |\n\n## FIRMWARE VERSION 1.0.9.132 ..................................................... 22\n\n| PRODUCT NAME | ................................................................. | 22 |\n| DATE | ................................................................. | 22 |\n| FIRMWARE FILE INFORMATION | ................................................................. | 22 |\n| IMPORTANT UPGRADING NOTE | ................................................................. | 22 |\n| ENHANCEMENT | ................................................................. | 22 |\n| BUG FIX | ................................................................. | 23 |\n\n### NEW FEATURES OVERVIEW.\n\n- **DISABLE HOOK SWITCH** ......................................................... 23\n- **TOTAL NUMBER OF CUSTOM RINGTONE UPDATE** ............................. 24\n\n## FIRMWARE VERSION 1.0.9.127 ..................................................... 25\n\n| PRODUCT NAME | ................................................................. | 25 |\n| DATE | ................................................................. | 25 |\n| FIRMWARE FILE INFORMATION | ................................................................. | 25 |\nFIRMWARE VERSION 1.0.9.121 ................................................................. 27\nPRODUCT NAME ............................................................................. 27\nDATE .................................................................................................. 27\nFIRMWARE FILE INFORMATION ..................................................... 27\nIMPORTANT UPGRADING NOTE .................................................. 27\nENHANCEMENT ............................................................................. 27\nBUG FIX .......................................................................................... 27\nNEW FEATURES OVERVIEW .......................................................... 28\n BLF CALL PICKUP ......................................................................... 28\n ALWAYS RING SPEAKER .............................................................. 29\n SHOW ON HOLD DURATION .......................................................... 29\n ONLY SAME ACCOUNT IN CONFERENCE ..................................... 30\n FIRMWARE UPGRADE SILENTLY .................................................. 31\n DISABLE MISSED CALL BACKLIGHT ......................................... 31\n CALL PARK ENHANCEMENT ....................................................... 32\n INCOMING CALL POPUP .............................................................. 32\n EXACT MATCH SEARCH .............................................................. 33\n DIVERSION INFO DISPLAY ........................................................ 33\n SORT PHONEBOOK ..................................................................... 34\n SUBSCRIPTION ENHANCEMENT .............................................. 34\n CUSTOM SOFTKEY VALUES ....................................................... 35\n MANUAL VLAN CONFIGURATION ............................................. 35\n\nFIRMWARE VERSION 1.0.9.108 ............................................................. 37\nPRODUCT NAME ............................................................................. 37\nDATE .................................................................................................. 37\nFIRMWARE FILE INFORMATION ..................................................... 37\nIMPORTANT UPGRADING NOTE .................................................. 37\nBUG FIX .......................................................................................... 37\n\nFIRMWARE VERSION 1.0.9.102 ............................................................. 39\nPRODUCT NAME ............................................................................. 39\nDATE .................................................................................................. 39\nFIRMWARE FILE INFORMATION ........................................................................................................39\nIMPORTANT UPGRADING NOTE ..................................................................................................39\nENHANCEMENT .............................................................................................................................39\nBUG FIX ..........................................................................................................................................41\nNEW FEATURES OVERVIEW .........................................................................................................44\n DOWNLOAD CERTIFICATE FILES DURING PROVISION ...........................................................44\n CID AND IMAGE FROM SIP NOTIFY .........................................................................................44\n ENHANCED ACOUSTIC ECHO CANCELLER ..............................................................................44\n RANDOMIZED TR069 STARTUP .................................................................................................44\n 802.1X AUTHENTICATION WITH SPECIAL LETTERS ..............................................................45\n MORE MATCHING RULES SUPPORTED ......................................................................................45\n ACTION URL IMPROVEMENT ......................................................................................................48\n GROUP LISTENING .......................................................................................................................49\n CUSTOM CERTIFICATE .................................................................................................................50\n FTP (FTPS) SUPPORT ....................................................................................................................50\n ENABLE IM POPUP ..........................................................................................................................51\n CUSTOMIZE SOFTKEY LAYOUT ...................................................................................................51\n INVERSE CFG FILES UPLOADING SEQUENCE ...........................................................................52\n MAX DOWNLOAD/SEARCH LIMITATION FOR BROADSOFT XSI .............................................52\n BROADSOFT XSI DIRECTORY DOWNLOAD IMPROVEMENT ....................................................53\n GENERATE CORE DUMP ................................................................................................................53\n NO NEED TO DISABLE LOCAL CALL FEATURES WITH BROADSOFT ........................................53\n BLF TO PICKUP PARKED CALL ....................................................................................................54\n BUSY PARKING LOT .......................................................................................................................54\n ONHOLD DURATION .......................................................................................................................54\n SHOW VPK SHARED LINE DISPLAY DESCRIPTION ..................................................................54\n DIAL PLAN FLAG T SUPPORT ......................................................................................................55\n\nFIRMWARE VERSION 1.0.9.69 ..........................................................................................................56\n PRODUCT NAME .............................................................................................................................56\n DATE .............................................................................................................................................56\n FIRMWARE FILE INFORMATION ................................................................................................56\n IMPORTANT UPGRADING NOTE ................................................................................................56\n ENHANCEMENT .............................................................................................................................56\n BUG FIX ..........................................................................................................................................57\n NEW FEATURES OVERVIEW .........................................................................................................57\n SYSLOG ENHANCEMENT ............................................................................................................57\n IMPORT GROUP METHOD ............................................................................................................57\n PVVALUES THAT TRIGGER AUTO PROVISION .......................................................................58\n ATTEMPT TO DOWNLOAD CONFIG FILE AGAIN .....................................................................58\n\nFIRMWARE VERSION 1.0.9.63 ..........................................................................................................60\nPRODUCT NAME ................................................................. 60\nDATE ................................................................................. 60\nIMPORTANT UPGRADING NOTE ........................................... 60\nENHANCEMENT .................................................................. 60\nBUG FIX ............................................................................. 61\nNEW FEATURES OVERVIEW ................................................. 64\n RADOMIZED AUTOMATIC UPGRADE .................................. 64\n ACCOUNT DISPLAY ................................................................ 65\n CONFIRMATION FOR FACTORY RESET ............................... 65\n uaCSTA SUPPORT FOR 3CX ............................................. 66\n SNMP SUPPORT .................................................................. 66\n AUTOMATICALLY LOG IN FROM 3CX SERVER INTERFACE ... 68\n WEB SESSION TIMEOUT ..................................................... 68\n WEB ACCESS ATTEMPT LIMIT ......................................... 68\n FORCE TO DOWNLOAD ALL CONFIG FILES ....................... 69\n TEST PASSWORD STRENGTH ........................................... 69\n USER WEB ACCESS .......................................................... 70\n CHANGE PRIORITY OF EXISTING DIAL PLAN PATTERN ....... 70\n ACTIVE VPK PAGE .......................................................... 71\n SUPPORT TO ALLOW LCD BACKLIGHT ALWAYS ON .......... 71\n PUBLIC MODE USERNAME PREFIX/SUFFIX .......................... 72\n WARNING MESSAGE FOR DELETING CONTACTS ............... 73\n SERVER VALIDATION ........................................................ 73\n SUPPORT TO GET OPENVPN FILE FROM SERVER ............... 73\n LOGOUT SOFTKEY IN PUBLIC MODE ................................. 74\n DISABLE DND FEATURE .................................................... 74\n SSH PUBLIC KEY ............................................................. 74\n PREDICTIVE DIALING SOURCE ......................................... 75\n ENABLE INCOMING CALL POPUP ....................................... 75\n USE MAC HEADER ........................................................... 76\n VPK SHARED LINE DISCRIPTION ..................................... 76\n USE SBC WITH 3CX ......................................................... 77\n DONOTDISTURBEVENT SUPPORT FOR 3CX ....................... 78\n USER PROTECTION .......................................................... 78\n\nFIRMWARE VERSION 1.0.9.26 ..................................................... 80\n PRODUCT NAME ............................................................ 80\n DATE ............................................................................. 80\n IMPORTANT UPGRADING NOTE ....................................... 80\n BUG FIX ....................................................................... 80\n\nFIRMWARE VERSION 1.0.9.25 ..................................................... 81\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PRODUCT NAME</td>\n<td>81</td>\n</tr>\n<tr>\n<td>DATE</td>\n<td>81</td>\n</tr>\n<tr>\n<td>IMPORTANT UPGRADING NOTE</td>\n<td>81</td>\n</tr>\n<tr>\n<td>ENHANCEMENT</td>\n<td>81</td>\n</tr>\n<tr>\n<td>BUG FIX</td>\n<td>82</td>\n</tr>\n<tr>\n<td>NEW FEATURES OVERVIEW</td>\n<td>85</td>\n</tr>\n<tr>\n<td><strong>OFF-HOOK AUTO DIAL DELAY</strong></td>\n<td>85</td>\n</tr>\n<tr>\n<td><strong>FACTORY RESET VIA KEYPAD</strong></td>\n<td>85</td>\n</tr>\n<tr>\n<td><strong>CALL COMPLETION SERVICE</strong></td>\n<td>86</td>\n</tr>\n<tr>\n<td><strong>KEYPAD LOCK VIA MPK/VPK/SOFTKEY</strong></td>\n<td>87</td>\n</tr>\n<tr>\n<td><strong>ACCOUNT SWAPPING</strong></td>\n<td>88</td>\n</tr>\n<tr>\n<td><strong>DIALPLAN INTERFACE</strong></td>\n<td>88</td>\n</tr>\n<tr>\n<td><strong>MULTICAST LISTENING ADDRESS LIST</strong></td>\n<td>90</td>\n</tr>\n<tr>\n<td><strong>SEARCH BAR SUPPORT</strong></td>\n<td>91</td>\n</tr>\n<tr>\n<td><strong>WEATHER CONFIGURATION FROM LCD MENU</strong></td>\n<td>91</td>\n</tr>\n<tr>\n<td><strong>NEW MPK MODE FOR FORWARD, DND, REDIAL, SMS AND PAGING</strong></td>\n<td>92</td>\n</tr>\n<tr>\n<td><strong>SHORTCUT (HOLD+UP) TO FACTORY FUNCTIONS SETTING</strong></td>\n<td>92</td>\n</tr>\n<tr>\n<td><strong>ACTION URI SUPPORT</strong></td>\n<td>93</td>\n</tr>\n<tr>\n<td><strong>TRANSFER MODE VIA VPK</strong></td>\n<td>94</td>\n</tr>\n<tr>\n<td><strong>CUSTOM RINGTONE FOR INDIVIDUAL CONTACT</strong></td>\n<td>94</td>\n</tr>\n<tr>\n<td><strong>UCM CALL CENTER FEATURE</strong></td>\n<td>95</td>\n</tr>\n<tr>\n<td><strong>USER SPACE STATUS</strong></td>\n<td>96</td>\n</tr>\n<tr>\n<td><strong>SUPPORT FOR CISCO DISCOVERY PROTOCOL (CDP)</strong></td>\n<td>97</td>\n</tr>\n<tr>\n<td><strong>SUPPORT TO DOWNLOAD USER CONFIGURATION</strong></td>\n<td>97</td>\n</tr>\n<tr>\n<td><strong>ERROR MESSAGE SUPPORT ON LCD SCREEN</strong></td>\n<td>98</td>\n</tr>\n<tr>\n<td><strong>VIRTUAL VOICE MAIL</strong></td>\n<td>98</td>\n</tr>\n<tr>\n<td><strong>DATE AND TIME DISPLAY ON SCREENSAVER</strong></td>\n<td>98</td>\n</tr>\n<tr>\n<td><strong>DEFAULT RINGTONE</strong></td>\n<td>99</td>\n</tr>\n</tbody>\n</table>\nFIRMWARE VERSION 1.0.11.16\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n09/28/2020\n\nFIRMWARE FILE INFORMATION\n• GXP2130 firmware file name: gxp2130fw.bin\n MD5: 3c25e402a62e9ca3c9b9aa04bfa6e134\n• GXP2135 firmware file name: gxp2135fw.bin\n MD5: 990069a8de99e7503f66c418d9a189bd\n• GXP2140 firmware file name: gxp2140fw.bin\n MD5: 08cb0ee1fe697ee2dc54e18901c127d\n• GXP2160 firmware file name: gxp2160fw.bin\n MD5: 3e0f98bb913da32282097d38f5405540\n• GXP2170 firmware file name: gxp2170fw.bin\n MD5: 22063ed04f9650c00527756e599ed940\n\nIMPORTANT UPGRADING NOTE\n• If the phone's web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n• Added support of Beirut Time zone\n• Added Support of Central Africa Time zone “CAT”\n• Added Ability to choose TLS Version for HTTPS provisioning [TLS VERSION SELECTION]\n• Added Ability to enable/disable weak ciphers [ENABLE/DISABLE WEAK CIPHERS]\n• Improved Support of Integrated Feature Synchronization with NetSapiens Platform\n• Improved Device not to query DNS if Internet connectivity popup is disabled\n• Added Ability to customize SSH port [SSH PORT]\n• Added Support of Factory Reset Security Level [FACTORY RESET SECURITY LEVEL]\n• Added Ability to auto answer pre-defined numbers [AUTO ANSWER NUMBERS FEATURE]\n• Added support to not send the DHCP release upon reboot [RELEASE DHCP ON REBOOT]\n\n**BUG FIX**\n\n• Fixed BLF call pickup barge-in code option does not work correctly\n• Updated the light_httpd version due to Vulnerabilities CVE-2015-3200\n• Fixed Device cuts off Russian names when importing a phonebook XML file\n• Fixed Vulnerability CVE2016-218/QIDS 38657\n• Fixed Device 256-BIT SRTP Key Length does not work with Asterisk 16.5\n• Fixed Device freezes when pressing on \"Dial\" softkey to dial an LDAP contact\n• Fixed Device works abnormally when managing high call traffic\n• Fixed Manually added VPKs disappear after upgrading\n• Fixed Incorrect translation in Russian\n• Fixed Phone_status command in SSH does not work\n• Fixed Multicast Paging channel does not work correctly\n• Fixed Device does not contact NTP server from DHCP option 42\n• Fixed Device can't hang up the call from the 3CX Web client\n• Fixed Two Call-Info headers in INVITE causes device not to Auto-Answer Intercom\n• Fixed Device does not send Setup Completed Action URL in Static IP boot up\n• Fixed HTTPs provisioning via DHCP option 66 is not working\n• Fixed Multicast paging audio is not stable if device is not rebooted\n• Fixed Device does not start displaying the current frame stream received from GDS directly\n• Fixed RCE vulnerability\n• Fixed SUBSCRIBE does not contain the contact header\n\n**NEW FEATURES OVERVIEW**\n\n**TLS VERSION SELECTION**\n\n• **Web Configuration**\n This option can be found under device web UI ➔ Maintenance ➔ Security Settings ➔ Security.\n\n \n\n - **Minimum TLS Version**: TLS 1.1\n - **Maximum TLS Version**: Unlimited\n\n• **Functionality**\n The function allows users to choose minimum/maximum TLS version for HTTPS provisioning and SIP transport. After change the TLS Version, the phone needs rebooting for taking effect on HTTPS web access.\nProvisioning and sip transport don't need reboot.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P22293</td>\n<td>Minimum TLS Version</td>\n<td>Value = 10; TLS 1.0</td>\n<td>TLS 1.1</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 11; TLS 1.1</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 12; TLS 1.2</td>\n<td></td>\n</tr>\n<tr>\n<td>P22294</td>\n<td>Maximum TLS Version</td>\n<td>Value = 99; Unlimited</td>\n<td>Unlimited</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 10; TLS 1.0</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 11; TLS 1.1</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 12; TLS 1.2</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**ENABLE/DISABLE WEAK CIPHERS**\n\n- **Web Configuration**\nThis option can be found under device web UI → Maintenance → Security Settings → Security.\n\n- **Functionality**\nThis feature could force the TLS version/Cipher suites for HTTPS provisioning and the TLS version for sip transport (TLS/TCP) and HTTPS web access.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8536</td>\n<td>Enable/Disable Weak Ciphers</td>\n<td>Value = 0; Enable Weak TLS Ciphers Suites Value = 1; Disable Symmetric Encryption RC4/DES/3DES Value = 2; Disable Symmetric Encryption SEED Value = 3; Disable All Weak Symmetric Encryption Value = 4; Disable Symmetric Authentication MD5 Value = 5; Disable All Weak TLS Cipher Suites</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\n**SSH PORT**\n\n- **Web Configuration**\nThis option can be found under device web UI → Maintenance → Security Settings → Security.\n• **Functionality**\n\nThis feature allows users to customize the SSH access port to connect to the phone.\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P27006</td>\n<td>SSH Port</td>\n<td>22 - 65535</td>\n<td>22</td>\n</tr>\n</tbody>\n</table>\n\n**FACTORY RESET SECURITY LEVEL**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Security Settings → Security.\n\n- **Functionality**\n\nThis feature allows users to decide whether or not to disable password request when performing factory reset with hard keys.\n\nThere are three options:\n1. Default: Password is needed when “configuration via keypad menu” is not “Unrestricted”.\n2. Always Require password: Password is needed no matter what “configuration via keypad menu” mode is.\n3. No password: No password is needed no matter what “configuration via keypad menu mode” is.\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n</table>\n| P22373 | Factory Reset Security Level| Value = 0, Default\nValue = 1, Always Require Password\nValue = 2, No Password Required | 0 |\n\n**AUTO ANSWER NUMBERS FEATURE**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Account x → Call Settings.\n\n- **Functionality**\nThe function allows users to have the phone configured with a pre-defined list of numbers that will perform auto answer.\n\nThere are different situations for auto answer setup:\n1) Auto Answer disable → no auto answer;\n2) Auto Answer enable, no auto answer number specified → all numbers are auto answered;\n3) Auto Answer enable, auto answer number specified → only numbers specified will be auto answered.\n\nFor “Auto Answer Numbers”, it accepts:\n- Digits : 1,2,3,4,5,6,7,8,9;\n- x – any digit from 0-9;\n- xx – any two digits from 0-9;\n- [1-5] – any digit from 1 to 5;\n- +: it matches the previous character as many time as needed like regular expression.\n\nPlease note Auto Answer Numbers can be split with “;”, for example: 1x;2xxx;3x+\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P29064</td>\n<td>Auto Answer Numbers</td>\n<td>String: Max length is 512.</td>\n<td>NULL</td>\n</tr>\n<tr>\n<td>P29164</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P29264</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P29364</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P29464</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P29564</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**RELEASE DHCP ON REBOOT**\n\n- **Web Configuration**\nThis option can be found under device web UI → Network → Advanced Settings.\n\n- **Functionality**\nThis function allows users to determine whether to release DHCP upon reboot.\nPlease note this option change requires a reboot before taking effect.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P22380</td>\n<td>Release DHCP On Reboot</td>\n<td>Value = 0, Disabled. Value = 1, Enabled.</td>\n<td>Enabled</td>\n</tr>\n</tbody>\n</table>\nFIRMWARE VERSION 1.0.11.10\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n5/14/2020\n\nFIRMWARE FILE INFORMATION\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 9ccb6b34838030d4a4bd643e37f07b87\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: dffaa73fc099fbf6330b4af5ba514990\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: 767daed9e934c7efa9f6cc74a125eb19\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 6f0085fd02ece0930b4af5ba514990\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: 50ac278554010fe67ed490a3b644951e\n\nIMPORTANT UPGRADING NOTE\n- If the phone’s web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nBUG FIX\n- Fixed Device freezes after disconnecting switch uplink\n- Fixed Devices randomly freezes\n- Fixed Device only displays the first number when a LDAP Contact is set with multiple numbers\n**FIRMWARE VERSION 1.0.11.6**\n\n**PRODUCT NAME**\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\n**DATE**\n2/21/2020\n\n**FIRMWARE FILE INFORMATION**\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 3e33a659cb6a24f21dccbde27e4e8a66\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: e0dd0ab348e39589bb034fafb25c446b\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: 66573bafb5f45b9fcc28db46c3ab0949\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 4b55cc64a6001c60d738e6fd917c73c\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: 88ab89f4c268d4560cca1e8cd03c4122\n\n**IMPORTANT UPGRADING NOTE**\n- If the phone's web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\n**BUG FIX**\n- Fixed XML file provision with other config version number doesn't work\n- Fixed Device can't provision account 5's ringtone issue\nFIRMWARE VERSION 1.0.11.3\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n11/15/2019\n\nFIRMWARE FILE INFORMATION\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 93bb8186bb7a2369e671417670f09f6e\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: b0283860a30c7c845d1d0c24b56d5066\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: 6e6e1037460d22fc5251b525bfc71cea\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 7f3d1c3558d87b887084093be9ef44ca\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: c44ffbaa70c3e7362955e3a70773b93f\n\nIMPORTANT UPGRADING NOTE\n- If the phone's web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nBUG FIX\n- Fixed Device terminates BLF subscription when registering with 2 SIP servers\nFIRMWARE VERSION 1.0.11.2\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n10/15/2019\n\nFIRMWARE FILE INFORMATION\n• GXP2130 firmware file name: gxp2130fw.bin\n MD5: 2f8a284ba187176e4fe7dee20cecefe84\n• GXP2135 firmware file name: gxp2135fw.bin\n MD5: d2cb77a7cc59742f3a8a70a517998f89\n• GXP2140 firmware file name: gxp2140fw.bin\n MD5: 28cdf64493cc187ef2fac332b3794fc\n• GXP2160 firmware file name: gxp2160fw.bin\n MD5: 32fea5c1424cb57d014390c9f89b229\n• GXP2170 firmware file name: gxp2170fw.bin\n MD5: ed40514eeb473cb9770b73b66d846d0\n\nIMPORTANT UPGRADING NOTE\n• If the phone’s web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n• Added Support for GDMS (Grandstream Device Management System)\n• Added Support for Ukrainian language\n• Added Support to use uploaded CA Certificates only [LOAD CA CERTIFICATES]\n• Added the ability to launch XML App automatically upon receiving calls [XML APP AUTO LAUNCH]\n• Added Support to bypass security settings when External Service is configured [ACCEPT INCOMING SIP FROM PROXY ONLY]\n• Added Support to lock the audio volume of the speaker phone [LOCK SPEAKER VOLUME]\n• Added Support to accept pvalue in string format for MPKs, Extension board and softkey mode configuration [ACCEPT PVALUE IN STRING FORMAT]\n• Added Support for inputting \"@\" for SIP User ID field [SIP USER ID FIELD IMPROVEMENT]\n• Added Support for Chile time zone\n\nBUG FIX\n• Fixed Device does not respond 200 OK for inbound call with 3CX\n• Fixed Account picture disappears in remote party after DUT holds the call\n• Fixed Deleting account picture from general setting page works abnormally\n• Fixed Device freezes after it’s provisioned with a phonebook that has 32 characters or more in two fields of a contact\n• Fixed Device plays keypad tone when putting in password in provision authentication window\n• Fixed Provide_lock feature issue\n• Fixed “MPK LCD Settings” on web UI\n• Updated translations for Hungarian language\n• Updated translations for Korean language\n• Updated the label display in Spanish record on and record off\n• Fixed Transferring issue when using predictive dialing feature\n• Fixed Device does not escape special characters when loading XML provisioning file\n• Fixed Phonebook does not accept Greek characters with a space in the middle\n• Fixed Character “+” is not supported for phonebook contacts when it’s added manually in the Web GUI.\n• Fixed Substitution dial string breaks attended transfer\n• Fixed Device SRTCP related error message with Asterisk platform\n• Fixed Device randomly terminates BLF subscription with Expires: 0 header\n• Fixed Device lose call park subscription with Skyswitch platform\n• Fixed Device BLF Call-Pickup issue when set to mode \"Auto\"\n• Fixed Config file downloaded from Web UI empty issue for some of the devices\n• Fixed Device freezes and lags after intensive call usage for a few days\n• Fixed OpenVPN connection not successful with Watchguard OpenVPN Server\n• Fixed Lock sign is only displayed when both TLS/SRTP are enabled\n• Fixed Device can’t disconnect a call when using TLS\n• Fixed Device doesn’t send its Default certificate for TLS Authentication\n• Fixed Device does not take weather degree unit from UCM Zero config\n• Fixed Device web UI misspelling issue\n• Fixed Wrong time zone display for Israel\n• Fixed BLF keys remains grey after network connection is recovered\n• Fixed “Upload Wallpaper” option’s tooltip\nNEW FEATURES OVERVIEW\nThis section lists major new features and describes how to use it from the user's point of view.\n\nLOAD CA CERTIFICATES\n• Web Configuration\nThis option can be found under device web UI → Maintenance → Security Settings → Trusted CA Certificates.\n\n[Image: Load CA Certificates]\n\n• Functionality\nWith this new option, now users are able to choose which certificate they are going to use.\n→ Default Certificates: Built-in Certificates;\n→ Custom Certificates: Uploaded Certificates;\n→ All Certificates: Both built-in and uploaded Certificates.\n\n• Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8502</td>\n<td><New Pvalue> Load CA Certificates</td>\n<td>Value = 0; Default Certificates Value = 1; Custom Certificates Value = 2; All Certificates</td>\n<td>All Certificates</td>\n</tr>\n</tbody>\n</table>\n\nXML APP AUTO LAUNCH\n• Web Configuration\nThis option can be found under device Web UI → Settings → XML Application.\n\n[Image: Enable XML Application Auto Launch]\n\n• Functionality\nWhen this feature is enabled, when receiving a call, the XML application set will be launched automatically if the setup works.\n\n• Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\nEnable XML Application Auto Launch\n\nValue = 0; No\nValue = 1; Yes\n\nNo\n\nACCEPT INCOMING SIP FROM PROXY ONLY\n\n- **Web Configuration**\n\nThis option can be found under device web UI→ Accounts → Account # → SIP settings → Security Settings.\n\n- **Functionality**\n\nWhen \"External Service\" (Eg: GDS System Number) is configured on DUT, DUT should bypass automatically to accept requests from specified GDS.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P2347</td>\n<td><New Pvalue> Accept Incoming SIP from Proxy Only</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\n\nLOCK SPEAKER VOLUME\n\n- **Web Configuration**\n\nThis option can be found under device web UI→ Settings → Preference → Ringtone → Lock Volume.\n\n- **Functionality**\n\nIf set to “Ring”, volume of the speaker will be locked in ringing state and idle.\nIf set to “Talk”, volume of the speaker will be locked in calling state.\nIf set to “Both”, volume of the speaker will be locked.\nIf set to “No”, volume of the speaker will not be locked.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8392</td>\n<td><New Pvalue></td>\n<td>Value = 0; No</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\nLock Speaker Volume | Value = 1; Ring \n| Value = 2; Talk \n| Value = 3; Both\n\nACCEPT PVALUE IN STRING FORMAT\n\n**Functionality**\n\nWe had added support to accept pvalue in string format for VPK mode configuration. This was implemented for GXP VPK before. Now we added this support for MPK, extension board and softkey as well.\n\nHere is the list of supported pvalue string for key mode:\n\n\"none\" \n\"line\" \n\"sharedline\" \n\"speeddial\" \n\"blf\" \n\"presencewatcher\" \n\"eventlistblf\" \n\"speeddialaa\" \n\"dialdtmf\" \n\"voicemail\" \n\"callreturn\" \n\"transfer\" \n\"callpark\" \n\"intercom\" \n\"ldapsearch\" \n\"conference\" \n\"multicastpaging\" \n\"record\" \n\"calllog\" \n\"moniteredcp\" \n\"menu\" \n\"xmlapp\" \n\"information\" \n\"message\" \n\"forward\" \n\"dnd\" \n\"redial\" \n\"instantmessage\" \n\"multicastlistenaddress\" \n\"keypadlock\"\nSIP USER ID FIELD IMPROVEMENT\n\n• Functionality\n\nNow users are able to register an account with a SIP user ID that carries \"@\". For example, you can put \"111@test.com\" in your SIP User ID field. When registering, the phone will register your account as \"111@test.com\" instead of 111.\n\nNote: The server domain will not be included in the SIP from header.\nFIRMWARE VERSION 1.0.9.135\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n06/05/2019\n\nFIRMWARE FILE INFORMATION\n\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 2e0c0188d764d76af6c69ab57959480\n\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: 55c5f9af6fafa46273f8aa011d23e21b\n\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: 6d3b2b161c6b3173b1039c24ed0fd8\n\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 9527b0e447f1d789766568c4290f04f5\n\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: ac9f63d2f2da9a6d5939dbc4c325db24\n\nIMPORTANT UPGRADING NOTE\n\n- If the phone's web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n\n- Added new OUI (C0:74:AD) support\nFIRMWARE VERSION 1.0.9.132\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n04/12/2019\n\nFIRMWARE FILE INFORMATION\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 669f029f678dc159a5d3b6e067030018\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: d65c23e7e11af480129d52f4ea34162c\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: e1670199f3e07dd4d42250cc6dcd8616\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 3bc15480de8ed0fc6afedf35d7361ab1\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: d959fd742003bf0a5ece5fc13e414bf3\n\nIMPORTANT UPGRADING NOTE\n- If the phone's web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n- Added Web UI option “Disable Hook Switch” [DISABLE HOOK SWITCH]\n- Added Web UI option “Total Number of Custom Ringtone Update” [TOTAL NUMBER OF CUSTOM RINGTONE UPDATE]\nBUG FIX\n\n- Fixed No audio issue with call pickup answering\n- Fixed One-way audio issue after picking up monitored BLF call if caller is using certain audio codecs\n- Fixed No audio issue after RE-INVITE\n- Fixed Device does not send PRACK in ALLOW header when sending 180 Ringing\n- Fixed Phone replies with 200OK “sendrecv” upon receiving INVITE “sendonly” for SIP/UDP and SIP/TLS with Broadsoft\n- Fixed Phone displays N/A on screen if weather service is unavailable\n- Fixed Broadsoft UC-One: Not reusing authorization header for XSI\n- Fixed Broadsoft UC-One: Dialing conference with ID and PIN have DTMF issue for IM&P\n- Fixed Security vulnerability issues\n\nNEW FEATURES OVERVIEW\n\nThis section lists major new features and describes how to use it from the user’s point of view.\n\nDISABLE HOOK SWITCH\n\n- **Web Configuration**\n\n This option can be found under device web UI → Settings → Call Features.\n\n \n\n- **Functionality**\n\n Now the users can choose the behavior for hook switch for the phone’s handset.\n - If set to “No”, the phone will answer the call when the handset is off-hook. This is the default behavior.\n - If set to “Yes”, the hook switch will not work to trigger onhook/offhook at all. The handset audio channel will not work during phone call either.\n - If set to “For Answering Call”, the phone’s hook switch will not work to answer incoming call. Users will need press softkey or speaker/headset/line hard key to answer the call. The hook switch will still work to switch audio channel to handset. For example, if the incoming call is answered by pressing ANSWER softkey, users can lift handset (off-hook) to switch audio channel to handset.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P6763</td>\n<td>Disable Hook Switch</td>\n<td>Value = 0; No</td>\n<td>Value = 0; No</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1; Yes</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 2; For Answering call</td>\n<td></td>\n</tr>\n</tbody>\n</table>\nTOTAL NUMBER OF CUSTOM RINGTONE UPDATE\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Preference → Ringtone.\n\n\n\n- **Functionality**\n\nBy configuring the total number of custom ringtone update option, the users can control how many custom ringtones the phone will download in provisioning process. If set to 0, no ringtone will be downloaded. Up to 3 ringtones can be downloaded.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8509</td>\n<td>Total Number of Custom Ringtone Update</td>\n<td>0, 1, 2, 3. If set to 0, no ringtone will be downloaded.</td>\n<td>3</td>\n</tr>\n</tbody>\n</table>\nFIRMWARE VERSION 1.0.9.127\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n01/25/2019\n\nFIRMWARE FILE INFORMATION\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 35aa2a4fd8261190db579286d2e1d40d\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: 022d212bc15ba25329c406f535318002\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: f988a1f5f5636f91755099d706d70bb\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 60e068c28bc1cb44650a2fd3a7b0531\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: dff4adde2f6486c6a0cf421832cd2b19\n\nIMPORTANT UPGRADING NOTE\n- If the phone’s web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n- Added Clear option for trace captured [CLEAR PACKET CAPTURED]\n- Added Ability to press BLF key as forward destination [BLF AS CALL FORWARD DESTINATION]\n- Added Ability to sync phonebook directly through SIP notify [SYNC PHONEBOOK THROUGH SIP NOTIFY]\nBUG FIX\n\n- Fixed Dial softkey disappears if switch groups upon logging in for Broadsoft UC-One IM&P\n- Fixed There is no dial softkey when selection is on a number in contact details for Broadsoft UC-One IM&P\n- Fixed Usability issues with search bar for Broadsoft UC-One IM&P\n- Fixed Azores Timezone does not include DST definition\n- Fixed Device does not show proper Date display format\n- Fixed Weather feature does not work when using zip code\n- Fixed Wallpaper cannot be downloaded via HTTPS Proxy\n- Fixed Forwarded calls are logged as missed calls\n\nNEW FEATURES OVERVIEW\n\nThis section lists major new features and describes how to use it from the user’s point of view.\n\nCLEAR PACKET CAPTURED\n\n- **Web Configuration**\n\n This option can be found under device web UI → Maintenance → Packet Capture.\n\n ![Packet Capture Interface]\n\n - **Functionality**\n\n Now users are able to clear the traces that they previously captured so they don’t have the repetitive files downloaded.\n\nBLF AS CALL FORWARD DESTINATION\n\n- **Functionality**\n\n Now users can forward the call using BLF keys, set on VPK or MPK. They only need to Subscribe to a valid BLF and press Forward Key then the BLF key to perform the call forward.\n\nSYNC PHONEBOOK THROUGH SIP NOTIFY\n\n- **Functionality**\n\n Now when phone receives a SIP Notify that contains “Event: sync-contacts” header then the device will recognize it and start the process to download phonebook.\nFIRMWARE VERSION 1.0.9.121\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n11/13/2018\n\nFIRMWARE FILE INFORMATION\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 9687fd763962fc6ada93f6f5bbfc17d1\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: fa4697a8bf014639e8bf00d07544a701\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: b5d0f69bf00d3941784c06fd3c3fb0f\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 67b23c96bb553279cf93b79960533f\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: 561a09cfc173e12206fb22c0e8395bb9\n\nIMPORTANT UPGRADING NOTE\n- If the phone’s web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n- Added Support to disable the BLF call pickup process for both methods \"Replaces header\" and \"Prefix\" [BLF CALL PICKUP]\n- Added Support to disable/enable ringtone on headset [ALWAYS RING SPEAKER]\n- Added Support to show both call session timer and hold duration timer on LCD during call hold [SHOW ON HOLD DURATION]\n• Added Support to set only the same account in conference [ONLY SAME ACCOUNT IN CONFERENCE]\n• Added Support to automatically firmware upgrade [FIRMWARE UPGRADE SILENTLY]\n• Added Support to turn off LCD even if there is a missed call notification and flash MWI Led [DISABLE MISSED CALL BACKLIGHT]\n• Added Support to park call real number [CALL PARK ENHANCEMENT]\n• Added Support to allow configuration backup not to include CA/Custom certificate\n• Added Option to disable incoming call popup [INCOMING CALL POPUP]\n• Added Support of exact match lookup method for LDAP search [EXACT MATCH SEARCH]\n• Added Support to display or hide Diversion info [DIVERSION INFO DISPLAY]\n• Added Support to sort the favorite contacts by First Name or Last Name [SORT PHONEBOOK]\n• Added VPKs to TR069 Data Model\n• Removed subscription then changing subscribe information [SUBSCRIPTION ENHANCEMENT]\n• Added Support to allow custom softkey values in all phone states [CUSTOM SOFTKEY VALUES]\n• Added Support for more of 30 groups in local phonebook\n• Added Support of manual VLAN configuration [MANUAL VLAN CONFIGURATION]\n• Updated Spanish, French, Portuguese, German, Italian, Russian LCD and Web language display\n• Changed weather system to be based on IBM weather company data\n\nBUG FIX\n• Fixed Device SCA LED shows wrong indicator with UCM when resuming public-held call\n• Fixed Device cannot login and shows remote host closed connection for Broadsoft UC-One\n• Fixed Timezone values are not correct for some locations\n• Fixed Device duplicating extensions monitored by EventList BLF\n• Fixed Device BLF worked abnormally when configured with Eventlist BLF\n• Fixed Device contacts with same extension number got duplicated when downloading the phonebook automatically in public mode\n• Fixed Multicast Paging channel issue\n• Fixed Multicast paging listening address issue\n• Fixed access to a root shell (CVE-2018-17565)\n• Fixed Line key LED display wrongly when there’s an inbound call handling with multiple accounts\n• Fixed “Reconf” softkey in conference holding page displayed abnormally\n• Fixed Device EXT 2/3/4 MPK are not included in the device TR-069 data mode\n• Fixed NTP Update interval missing on TR-069 data mode\n• Fixed Device didn’t contact ACS server URL provided through DHCP Option 43\n• Fixed device failed to provision some MPK modes failed through TR069\n• Fixed TR069 device applied SetParameterValues even there is an invalid parameter\n• Fixed Device didn’ send the complete codecs list in DataModel\n• Fixed The port of Broadsoft IM&P was abnormal\n• Fixed API bypass dial plan doesn't work\n• Fixed device cut off Cyrillic names after importing a Phonebook XML file\n• Fixed Parameter values for line keys does not take effect through TR069\n• Fixed Device didn’t send BYE message after completing the blind transfer and putting the handset onhook\n• Fixed 100rel related call completion issue\n• Fixed Device added 802.1Q tag when VLAN ID is 0 and priority value is not 0\n• Fixed Keypad Lock feature does not work\n• Fixed Device used inactive in SDP to put call on hold\n• Fixed some matching rules didn’t swap along with account\n• Fixed Alternate device Shared line indicator was off when the incoming call is picked up by primary device\n• Fixed Device didn’t use BLF server address if BLF server address contained a port\n• Fixed Device met network down intermittently after connecting to the POE switch\n• Fixed Device failed to retrieve parked call when “force BLF call-pickup by prefix is set to yes\n• Fixed Device showed wrong BLF status when receiving NOTIFY too quickly\n• Fixed Device didn’t return BUSY when disabling call waiting for the second received call (when first call hasn’t been answered\n• Fixed Device SCA Line-Seize failed with Broadsoft\n• Fixed Device secondary device works incorrect when trying to pick up a private-held call by primary device with Broadsoft\n• Fixed Multicast paging listener didn’t get paged\n• Fixed Device 2nd incoming call changed 1st call’s caller number with shared line mode\n• Fixed Device sent wrong request to get DHCPv6 address with Broadsoft\n• Fixed Device kept playing busy tone after we hang up the first call and still talking in the second call\n• Fixed BLF key does not change status after receiving Notify with status update\n• Fixed Ringtones in uploaded contacts didn't keep identical\n• Fixed Device shared line’s VPK LED displayed abnormally\n• Fixed Device crashed after changing Eventlist BLF URI and Auto Provision Eventlist BLF multiple times\n\nNEW FEATURES OVERVIEW\nThis section lists major new features and describes how to use it from the user’s point of view.\n\nBLF CALL PICKUP\n\n• Web Configuration\n\nThis option can be found under device web UI → Accounts → Account # → SIP settings → Advanced Features.\n\nBLF Call-pickup\n\n☐ Auto ☐ Force BLF Call-pickup by prefix ☐ Disabled\n\n• Functionality\n\nNow the users can choose the function of the monitored BLF to do as such:\nIf select Auto:\nIf the Server include the Call-ID, from-tag, to-tag, and Notify, device will use the replace header. If not, device will use the BLF pickup prefix.\n\nIf select Force BLF Call-pickup by prefix:\nDevice will only use Prefix as BLF pickup method.\n\nIf select Disable:\nDevice will ignore both BLF pickup method, now the monitored VPK will only dial the extension if pressed.\n\n- Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P6752 (Acc. 1)</td>\n<td><New Pvalue> BLF Call-Pickup</td>\n<td>Value = 0; Auto Value = 1; Force BLF Call-Pickup by prefix Value = 2; Disabled</td>\n<td>Auto</td>\n</tr>\n<tr>\n<td>P6753 (Acc. 2)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P6754 (Acc. 3)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P6755 (Acc. 4)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P6756 (Acc. 5)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P6757 (Acc. 6)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**ALWAYS RING SPEAKER**\n\n- Web Configuration\n\nThis option can be found under device web UI ➔ Settings ➔ Preferences ➔ Audio Control.\n\n- Functionality\n\nNow the users can choose to either ring from their headset, ring from both headset and device, or only ring from device.\n\n- Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P1439</td>\n<td><New Pvalue> Always Ring Speaker</td>\n<td>Value = 0; No Value = 1; Yes, both Value = 2; Yes, speaker only</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\nSHOW ON HOLD DURATION\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Call Features → Show on Hold Duration.\n\n- **Functionality**\n\nNow users can see how long their call has been hold with this option set to YES.\n\n\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8503</td>\n<td><New Pvalue> Show On Hold Duration</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\n\nONLY SAME ACCOUNT IN CONFERENCE\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Call Features → Only Same Account in conference.\n\n\n\n- **Functionality**\nNow users can limit the ability for device to cross conferencing different accounts.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8506</td>\n<td><New Pvalue> Only Same Account in Conference</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\n\n**FIRMWARE UPGRADE SILENTLY**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Upgrade and Provisioning\n\n- **Functionality**\n\nNow users can skip the upgrade confirmation. If enabled, the phone will check the provisioning server, if new firmware exists, the phone will automatically upgrade.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8375</td>\n<td><New Pvalue> Firmware Upgrade Confirmation</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\n**DISABLE MISSED CALL BACKLIGHT**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Preferences → LCD Display.\n\n- **Functionality**\n\nNow phone can also turn off LCD backlight while having a missed call. If users want to have missed call notification, select yes, bug flash MWI LED so when missed call exist, MWI will not be deemed.\n\n- **Pvalue**\nCALL PARK ENHANCEMENT\n\n- Functionality\n\nNow if a call is parked via VPK call park, the display on the VPK will change between CID of the active call and the parking number.\n\nINCOMING CALL POPUP\n\n- Web Configuration\n\nThis option can be found under device web UI → Settings → Call Features → Enable Incoming Call Popup.\n\n- Functionality\n\nNow when there’s an ongoing call, users can disable call pop up. This way users will not get disrupted by unexpected popup call but still get notify by the flashing line LED.\n\n- Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8401</td>\n<td><New Pvalue> Enable Incoming Call Popup</td>\n<td>Value = 0; No Value = 1; Yes Value = 2; Yes, but flash MWI LED</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\nEXACT MATCH SEARCH\n\n- Web Configuration\n\nThis option can be found under device web UI → Phonebook → LDAP → Exact Match Search.\n\n- Functionality\n\nWith LDAP Lookup Incoming call, Outgoing call selected, device will perform LDAP search during incoming and outgoing call. If exact match search enabled, during the LDAP search, device will only get the result...\nthat matches the search input exactly. i.e. if 100 is the incoming/outgoing number only 100 will get searched, *100* will not.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8505</td>\n<td><New Pvalue> Exact Match Search</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\n\n**DIVERSION INFO DISPLAY**\n\n- **Web Configuration**\n\nThis option can be found under device web UI ➔ Settings ➔ Call Features ➔ Enable diversion information display.\n\n\n\n- **Functionality**\n\nWhen forwarding a call, the recipient will display a “diverted from” message. If user selects No, when phone receives a forwarded call, phone will not display the “diverted from” message.\n\n“Diverted From” message:\n\n\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P22237</td>\n<td><New Pvalue> Enable Diversion Information display</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\nSORT PHONEBOOK\n\n- Web Configuration\n\nThis option can be found under device web UI→ Phonebook → Phonebook Management→Sort Phonebook by.\n\n- Functionality\n\nNow users can select the sorting style when performing search on LCD.\n\n- Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P2914</td>\n<td><New Pvalue></td>\n<td>Value = 0; Last Name</td>\n<td>Last Name</td>\n</tr>\n<tr>\n<td></td>\n<td>Sort Phonebook by</td>\n<td>Value = 1; First Name</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nSUBSCRIPTION ENHANCEMENT\n\n- Functionality\n\nNow when changing the VPK information that requires subscription, device will perform unsubscribe first, then perform a new subscription. This way server will know that previous subscription has been void.\n\nCUSTOM SOFTKEY VALUES\n\n- Web Configuration\n\nThis option can be found under device web UI→ Settings→ Programmable Keys→ Call Screen Softkeys.\n\nCall Screen Softkeys\n\n<table>\n<thead>\n<tr>\n<th>Order</th>\n<th>Mode</th>\n<th>Description</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Default</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2</td>\n<td>Default</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>3</td>\n<td>Default</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n- Functionality\n\nNow users can configure whatever the mode and value they want to use in call screen on Call Screen Softkeys. (Similar to MPK, but with limited set.)\nMANUAL VLAN CONFIGURATION\n\n- **Web Configuration**\n\n This option can be found under device web UI → Network → Advanced Settings → Enable Manual VLAN Configuration.\n\n- **Functionality**\n\n Now users can choose to bypass VLAN configuration and only use the DHCP VLAN as their config for VLAN tag and priority when this option is set to Disabled.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P22174</td>\n<td><New Pvalue> Enable Manual VLAN Configuration</td>\n<td>Value = 0; Enabled Value = 1; Disabled</td>\n<td>Enabled</td>\n</tr>\n</tbody>\n</table>\nFIRMWARE VERSION 1.0.9.108\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n08/17/2018\n\nFIRMWARE FILE INFORMATION\n\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 7f8366aafd5e005271fbfa3acd115542\n\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: 42c8c63f1d92bba4d090074c90603d7d\n\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: 721ed3df7c6f8021bdacc242b09f3688\n\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 51cadce62f8b7276c6e1495c7df2356\n\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: 3eafeb98a8eaf15163f07f0442c8be02\n\nIMPORTANT UPGRADING NOTE\n\n- If the phone's web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nBUG FIX\n\n- Fixed Phone responds 488 to INVITE incorrectly\n- Fixed Device LCD displayed black screen in upgrade process until entering boot up status\n- Fixed DHCP Vlan worked abnormally\n- Fixed BLF cannot be provisioned successfully for 3CX\n- Fixed Device crashed if unregistered account switched \"Authentic Incoming INVITE\" then received incoming call\n• Fixed Multicast paging priority disable option didn’t work\n• Fixed Hide Vocoder didn't work\n• Fixed Device intermittently does not allow terminal to be answered\n• Fixed Handset audio changes to speakerphone in some SCA Scenario\n• Fixed Option \"Prefer, fallback when failed\" in \"Allow DHCP Option 43 and Option 66 to Override Server\" worked abnormally\n• Fixed Broadsoft SRTP negotiation worked abnormally when SRTP is enabled and call is held\n• Fixed Establishing a call worked abnormally when caller set SRTP to no and callee set SRTP to enable but not forced\nFIRMWARE VERSION 1.0.9.102\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n06/21/2018\n\nFIRMWARE FILE INFORMATION\n\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: 9418e5307e1d2e8544eb890cb19f8904\n\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: 4a2b5879044f32504699dccb0a6a7694\n\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: 6e00d6487363580b138db4710954b7b\n\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 37e1c830b2e2d86e89dff0ccc747e81\n\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: 445eb22db7825d8230be0b6d146394cb\n\nIMPORTANT UPGRADING NOTE\n\n- If the phone's web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n\n- Added Support to download certificate files during provisioning [DOWNLOAD CERTIFICATE FILES DURING PROVISION]\n- Added Support for CID and Image from SIP NOTIFY [CID AND IMAGE FROM SIP NOTIFY]\n- Updated Korean LCD and web UI display translations\n- Added Option to enable or disable Acoustic Echo Cancellation [ENHANCED ACOUSTIC ECHO CANCELLER]\n- Added Ability to randomize the sending of TR069 INFORM message for iPageOn platform [RANDOMIZED TR069 STARTUP]\n- Added Support for 802.1x authentication with special letter like \"@\",\"-\" [802.1X AUTHENTICATION WITH SPECIAL LETTERS]\n- Improved Device to send SIP SUBSCRIBE messages when switching between OBPs\n- Added More fields for Distinctive Ring Tone (Matching Rule) [MORE MATCHING RULES SUPPORTED]\n- Added more character for password input from LCD\n- Added support for more Action URL notification [ACTION URL IMPROVEMENT]\n- Added support for SNMPv3\n- Added support for Group Listening softkey [GROUP LISTENING]\n- Added support to configure device with custom certificate signed by custom CA certificate [CUSTOM CERTIFICATE]\n- Added FTP support for provisioning and firmware upgrade [FTP (FTPS) SUPPORT]\n- Added support for Catalan Language support\n- Added option to enable/disable instant messages on LCD screen [ENABLE IM POPUP]\n- Added support to allow custom softkey values configurable in all phone states [CUSTOMIZE SOFTKEY LAYOUT]\n- Allow provision to fallback to origin server path if it fails from the server from DHCP option 66\n- Added support to inverse the sequence of uploading cfg files when the phone is forced to load all config files [INVERSE CFG FILES UPLOADING SEQUENCE]\n- Added max download/search result number support for Broadsoft XSI directory [MAX DOWNLOAD/SEARCH LIMITATION FOR BROADSOFT XSI]\n- Removed downloading all XSI directory on reboot for Broadsoft [BROADSOFT XSI DIRECTORY DOWNLOAD IMPROVEMENT]\n- Added login window to access Broadsoft xsi directory if set as login credential when credential is empty or login failed\n- Added kick option for network conference for Broadsoft\n- Added ability to generate core dump files manually according to Phone or GUI [GENERATE CORE DUMP]\n- Allowed feature key sync for call forward with local call features disabled for Broadsoft [NO NEED TO DISABLE LOCAL CALL FEATURES WITH BROADSOFT]\n- Allow BLF key to pick up a call parked on a monitored extension for Broadsoft [BLF TO PICKUP PARKED CALL]\n- Added monitored call park on busy lot should be denied [BUSY PARKING LOT]\n- Added Web UI Entry for Users to Append OpenVPN Config Options\n- Added support to see how long a call has been on hold from the phone LCD display [ONHOLD DURATION]\n• Added ability to show/hide VPK shared line description value by provisioning [SHOW VPK SHARED LINE DISPLAY DESCRIPTION]\n• Added Dial plan flag T support [DIAL PLAN FLAG T SUPPORT]\n• Removed Device's unused P-Values from the configuration backup file downloaded from Web UI\n• Supported Mute function during dialing outgoing call phase\n• Updated Broadsoft XSI Contact Download Interval tooltip\n• Improved Broadsoft SCA feature for handling multiple call arrangement under Account Mode\n• Updated Broadsoft XSI download interval default value to 72 hours\n\nBUG FIX\n• Fixed some comments display error\n• Fixed BLF call pick-up dial plan does not work correctly\n• Fixed Uploaded ring tone plays abnormally if “Always Ring Speaker” is enabled\n• Fixed LCD displays encryption icon in multicast paging call\n• Fixed Call forwarding via LCD menu does not work correctly\n• Fixed Device does not send SIP SUBSCRIBE messages when switching between OBPs\n• Fixed Device does not send \"Idle to Busy\" action URL after entering onhook dialing page.\n• Fixed Invite cannot be printed out in syslog\n• Fixed Device audio loss issue when there is jump in RTP timestamp.\n• Fixed Device LCD screen quits dialing screen while editing the call forward destination number\n• Fixed Device freezing with possible memory leak\n• Fixed The tooltip of \"Proxy server Switch Delay\" display error\n• Fixed Exporting backup package works abnormally\n• Improved the softkey for conference should not appear until getting ringback tone from the PSTN line and then establishing a successful conference\n• Fixed Device’s echo sound on speaker issue\n• Fixed Device responds with 488 when incoming INVITE contains 2 m lines on RTP and SRTP causing calls to fail with BroadSoft SBC\n• Fixed Locked keypad gets unlocked after setting \"Keypad Lock Timer\" to 0\n• Fixed No sound in speaker mode after pressing SpkOn during headset call if \"Ring for Call Waiting\" is enabled\n• Fixed Device One-way audio issue after semi-attended transfer using SRTP\n• Fixed Device only sends missed call URL after rejecting call if both Missed Call URL and Rejected Call URL are configured\n• Fixed Device only CONTACT header is using SIPS when setting SIP URI Scheme when using TLS to SIPS\n• Fixed Device still sends all other syslog packets when setting the syslog level to ERROR\n• Fixed Device still sends TCP Keep-Alive With all Keep-Alive settings off\n• Fixed \"Download and Process ALL Available Config Files\" function works abnormally\n• Fixed Device’s Conference URI works abnormally with shared line for Broadsoft\n• Fixed Device’s establishment of conference is abnormal with shared line for Broadsoft\n- Fixed Picking up a call works abnormally when registering on Broadsoft and set VPK to Shared Line mode\n- Fixed No call forwarding indicator when local call features are turned off for Broadsoft\n- Updated Call hold is not allowed if receiving a 488\n- Updated Support of BLF state following pval value for iPageOn platform\n- Fixed Device doesn't display \"Ignoree ATE\" in bootup process when MAC address is 0\n- Fixed Daylight Saving Time does not work correctly for some time zones\n- Fixed Picking up a call is abnormal when device is registered on BroadSoft and set VPK mode with Shared in Line mode\n- Fixed device does not send DND status back to PBX after 200OK with 3CX server\n- Fixed HTTP provision will return 505 error if config path contains space\n- Fixed device can't download the config file by using HTTPS from BroadWorks server\n- Fixed device adds the content of the Number attribute field to the Filter\n- Fixed device does not re-establish PPPoE connection after Termination request from server\n- Fixed audio stutter during re-invite in dialog\n- Fixed Outbound Notification SMTP stopped working\n- Fixed “Randomized Automatic Upgrade” spelling mistakes\n- Fixed “Favorite” contacts can’t be displayed immediately at handset off-hook\n- Fixed “Automatic Upgrade” works abnormally\n- Fixed device LCD updates network status slowly after factory reset\n- Fixed device works abnormally if unavailable shared line key is pressed\n- Fixed LCD display abnormally when pressing shared line key under account mode\n- Fixed EXT backlight can’t be woken up if there’s an incoming call in DND status\n- Fixed provision shortcut keys do not work in Menu locked mode\n- Fixed Account Ringtone settings not accessible on LCD menu under \"Basic Settings Only\" Mode\n- Fixed firmware upgrade via method automatically changing after factory reset then provision\n- Fixed pressing # or \"Send\" key cannot dial out if waiting for 5s after putting numbers in conference or transfer process\n- Fixed device takes wrong IP in contact header of subscribe packets after IP change\n- Fixed some modes (speed dial/intercom) of Idle screen softkeys can be saved without value\n- Fixed LCD displays abnormally if the call is transferred to unavailable contact\n- Fixed numbers do not match dial rules but still can be recorded to call history\n- Fixed group name length limit in LCD is different from that on web\n- Fixed device calls wrong numbers if pressing Speed dial mode MPK/VPK/EXT in dialing page\n- Fixed predictive dial works abnormally if set Preferred Default Account with Hand free mode\n- Fixed automatic redial destination is wrong\n- Fixed lock volume doesn't work after enabling Toggle headset/speaker mode\n- Fixed Eventlist BLFs LED still lighten up after logging out public mode\n- Fixed offhook/onhook and cancelling dial would trigger Terminated Call Event action URL\n- Fixed device shows “saved successfully” if setting Weather update interval with value length larger 20\n- Fixed device makes failover last around 15 minutes when SIP/TCP is set on the phone\n• Fixed device refreshes register after modifying any options on web pages\n• Fixed Broadsoft Key Synchronize cannot perform correctly if local call feature is disabled\n• Fixed shared line indicator should change in private hold for Broadsoft\n• Fixed LCD Softkey “ForwardAll” and “CancelFwd” not work under \"Shared Line\" Mode for Broadsoft\n• Fixed device cannot make calls using the BLF buttons\n• Fixed alternate device and Broadworks won't get synchronized after Primary device set call forward all for Broadsoft Shared line mode\n• Fixed contacts are cleared after uploading wrong format phonebook.xml\n• Fixed no call forwarding indicator when local call feature is turned off\n• Fixed Broadsoft contact download interval may not update correctly in some scenarios\n• Fixed device shared line GUI crash issue\n• Fixed device handles wrong after dialing some number that does not match dial plan when setting bypass dial plan feature to No\n• Fixed LCD warning is wrong after IP call being rejected\n• Fixed ring for call waiting works abnormal when ringtone is set to custom ringtone\n• Fixed call history duration of unavailable number displays abnormally\n• Fixed some action URL commands do not work\n• Fixed option 120 didn’t work\n• Fixed conference URI works abnormally with shared line issue with Broadsoft\n• Fixed pressing line key couldn't answer call in Account mode paging call mode\n• Fixed BLF red Light stays on\n• Fixed device doesn't play reorder tone in “Onhook Dial Barging” disabling status\n• Fixed account name displays incompletely in dialing page\n• Fixed long pressing EXT cannot skip missed call notification popup window\n• Fixed BLF status does not update when registration is lost with SIP primary server\n• Fixed entity body in request is missing after receiving 302 message for Broadsoft XSI\n• Fixed keypad lock timer worked abnormally after being modified several times\n• Fixed device works abnormally if there’s incoming call after failing to unlock keypad\n• Fixed device auto dials non-emergency number in Functional Keypad Lock mode\n• Fixed device uses IPv6 even though network is set to IPv4 only with Broadsoft XSI\n• Fixed device needs a prompt for warning customer it cannot play video voicemail with Braodsoft XSI\n• Fixed device displays misses call after receiving two reasons in SIP CANCEL\n• Fixed group displays abnormally after deleting group and uploading phonebook.xml file\n• Fixed device works abnormally if running API commands in screensaver status\n• Fixed device doesn’t take user=phone in contact header if setting \"SIP Listening Mode\" with Dual\n• Fixed device works abnormally if disabling Headset mode in onhook dialing page\n• Fixed softkey disappears after pressing Save softkey directly in Call Features page\n• Fixed account displays wrong if swapping account then sending IM\n• Fixed device works abnormally with some characters when sending IM\n• Fixed device does not keep voice vlan when LLDP is set to voice vlan and voice-signaling vlan\nNEW FEATURES OVERVIEW\nThis section lists major new features and describes how to use it from the user’s point of view.\n\nDOWNLOAD CERTIFICATE FILES DURING PROVISION\n\n- **Functionality**\n\nNow if phones are provisioned from xml file through http/https/tftp/ftp/ftps, users can put URL in the Pvalue field instead of the actual certificate content in text. The phone will then process the URL and search for the appropriate certificate and download then apply into the phone.\n\nCID AND IMAGE FROM SIP NOTIFY\n\n- **Functionality**\n\nWe have already supported the CID and Image previously. Now if phone receives NOTIFY message with type header: \"application/cid-info+xml\" and event header: \"cid-info-update\", phone will also take the message.\n\nENHANCED ACOUSTIC ECHO CANCELLER\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Call Features → Enable Enhanced Acoustic Echo Canceller.\n\n- **Functionality**\n\nNow users are able to choose to enable or disable the echo canceller on their phone in speaker mode.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P22175</td>\n<td><New Pvalue> Enable Enhanced Acoustic Echo Canceller</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\nRANDOMIZED TR069 STARTUP\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → TR-069 → Randomized TR069 Startup.\nRandomized TR069 Startup\n\n- **Functionality**\n\nNow users are able to randomize the sending of TR069 INFORM packets.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8487</td>\n<td><New Pvalue></td>\n<td>Value = 0; Disabled</td>\n<td>Disabled</td>\n</tr>\n<tr>\n<td></td>\n<td>Randomized TR069 Startup</td>\n<td>Value = 1; Enabled</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**802.1X AUTHENTICATION WITH SPECIAL LETTERS**\n\n- **Functionality**\n\nWhen phone needs to be authenticated by 802.1x and the switch gives special symbols such as \"-\" and \"@\" to the username or password, now phone supports those special symbols and won't indicate them as invalid input.\n\n**MORE MATCHING RULES SUPPORTED**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Accounts → Account # → Call Settings.\nNow instead of supporting three matching rules ringtone settings, users can have up to ten matching incoming caller ID\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Account 1-6: P6716 P6722 P6728 P6734 P6740 P6746</td>\n<td><New Pvalue> Match Incoming Caller ID 4</td>\n<td>String</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Account 1-6: P6718 P6724 P6730 P6736 P6742 P6748</td>\n<td><New Pvalue> Match Incoming Caller ID 5</td>\n<td>String</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Account 1-6: P6720 P6726 P6732 P6738 P6744 P6750</td>\n<td><New Pvalue> Match Incoming Caller ID 6</td>\n<td>String</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Account 1-6: P26064 P26164 P26264 P26364 P26464 P26564</td>\n<td><New Pvalue> Match Incoming Caller ID 7</td>\n<td>String</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Account 1-6: P26066 P26166 P26266</td>\n<td><New Pvalue> Match Incoming Caller ID 8</td>\n<td>String</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>Pvalue</td>\n<td>Description</td>\n<td>Value Range</td>\n<td>Default</td>\n</tr>\n<tr>\n<td>------------</td>\n<td>--------------------------------------------------</td>\n<td>-----------------------------------------------------------------------------</td>\n<td>--------------------------</td>\n</tr>\n<tr>\n<td>Account 1-6: P6717 P6723 P6729 P6735 P6741 P6747</td>\n<td><New Pvalue> Match Rule 4 Ringtone</td>\n<td>Value= -1 No Ringtone; Value= 0 system ring tone; Value= 1 custom ring tone 1; Value= 2 custom ring tone 2; Value= 3 custom ring tone 3; Value= 4 silent; Value= 5 Default Ringtone.</td>\n<td>Default Ringtone</td>\n</tr>\n<tr>\n<td>Account 1-6: P6719 P6725 P6731 P6737 P6743 P6749</td>\n<td><New Pvalue> Match Rule 5 Ringtone</td>\n<td>Value= -1 No Ringtone; Value= 0 system ring tone; Value= 1 custom ring tone 1; Value= 2 custom ring tone 2; Value= 3 custom ring tone 3; Value= 4 silent; Value= 5 Default Ringtone.</td>\n<td>Default Ringtone</td>\n</tr>\n<tr>\n<td>Account 1-6: P6721 P6727</td>\n<td><New Pvalue> Match Rule 6 Ringtone</td>\n<td>Value= -1 No Ringtone; Value= 0 system ring tone; Value= 1 custom ring tone 1;</td>\n<td>Default Ringtone</td>\n</tr>\n<tr>\n<td>Account 1-6: P26065 P26165 P26265 P26365 P26465 P26565</td>\n<td><New Pvalue> Match Rule 7 Ringtone</td>\n<td>Value= -1 No Ringtone; Value= 0 system ring tone; Value= 1 custom ring tone 1; Value= 2 custom ring tone 2; Value= 3 custom ring tone 3; Value= 4 silent; Value= 5 Default Ringtone.</td>\n<td>Default Ringtone</td>\n</tr>\n<tr>\n<td>Account 1-6: P26067 P26167 P26267 P26367 P26467 P26567</td>\n<td><New Pvalue> Match Rule 8 Ringtone</td>\n<td>Value= -1 No Ringtone; Value= 0 system ring tone; Value= 1 custom ring tone 1; Value= 2 custom ring tone 2; Value= 3 custom ring tone 3; Value= 4 silent; Value= 5 Default Ringtone.</td>\n<td>Default Ringtone</td>\n</tr>\n<tr>\n<td>Account 1-6: P26069 P26169 P26269 P26369 P26469 P26569</td>\n<td><New Pvalue> Match Rule 9 Ringtone</td>\n<td>Value= -1 No Ringtone; Value= 0 system ring tone; Value= 1 custom ring tone 1; Value= 2 custom ring tone 2; Value= 3 custom ring tone 3; Value= 4 silent; Value= 5 Default Ringtone.</td>\n<td>Default Ringtone</td>\n</tr>\n<tr>\n<td>Account 1-6: P26097 P26197 P26297 P26397 P26497 P26597</td>\n<td><New Pvalue> Match Rule 10 Ringtone</td>\n<td>Value= -1 No Ringtone; Value= 0 system ring tone; Value= 1 custom ring tone 1; Value= 2 custom ring tone 2; Value= 3 custom ring tone 3; Value= 4 silent; Value= 5 Default Ringtone.</td>\n<td>Default Ringtone</td>\n</tr>\n</tbody>\n</table>\n\n**ACTION URL IMPROVEMENT**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Outbound Notification → Action URL.\n**Functionality**\n\nNow phone supports more action URL including: Unconditional Forward, No Answer Forward, Transfer, Mute, etc.\n\n**GROUP LISTENING**\n\n**Web Configuration**\n\nThis option can be found under device web UI → Settings → Preferences → Audio Control.\n\n- Enable Group Listening\n- Group Listen with Speaker\n\n**Functionality**\n\nEnabling Group Listening will enable speaker sound while the handset/headset still functioning as they should.\n• **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P22100</td>\n<td><New Pvalue> Enable Group Listening</td>\n<td>Value = 0; No</td>\n<td>No</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1; Yes</td>\n<td></td>\n</tr>\n<tr>\n<td>P22163</td>\n<td><New Pvalue> Group Listen with Speaker</td>\n<td>Value = 0; No</td>\n<td>No</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1; Yes</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**CUSTOM CERTIFICATE**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Security Settings → Security.\n\n- **Custom Certificate**\n - **Upload**\n - **Delete**\n\n• **Functionality**\n\nNow if the users want to upload their own certificate, they can upload from the custom certificate that allows the server to verify with the phone.\n\n• **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8472</td>\n<td><New Pvalue> Custom Certificate</td>\n<td>String (by upload)</td>\n<td>N/A</td>\n</tr>\n</tbody>\n</table>\n\n**FTP (FTPS) SUPPORT**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Upgrade and Provisioning → Config\nUpgrade via.\n\n<table>\n<thead>\n<tr>\n<th>Config Upgrade via</th>\n<th>TFTP</th>\n<th>HTTP</th>\n<th>HTTPS</th>\n<th>FTP</th>\n<th>FTPS</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Firmware Upgrade via</td>\n<td>TFTP</td>\n<td>HTTP</td>\n<td>HTTPS</td>\n<td>FTP</td>\n<td>FTPS</td>\n</tr>\n</tbody>\n</table>\n\n- **Functionality**\n\nNow other than TFTP/HTTP/HTTPS, we also support FTP and FTPS for provisioning and firmware upgrade.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P212/</td>\n<td>Config Upgrade via</td>\n<td>Value = 0; TFTP</td>\n<td>2</td>\n</tr>\n<tr>\n<td>P6767</td>\n<td></td>\n<td>Value = 1; HTTP</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 2; HTTPS</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 3; FTP</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 4; FTPS</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**ENABLE IM POPUP**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Call Features → Enable IM Popup.\n\n- **Functionality**\n\nNow users can choose to get popup window on their LCD or not when receiving an instant message.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8474</td>\n<td><New Pvalue> Enable IM Popup</td>\n<td>Value = 0; No</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1; Yes</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**CUSTOMIZE SOFTKEY LAYOUT**\n\n- **Web Configuration**\n\nThis setting can be found under device web UI → Settings → Programmable Keys → Idle Screen Softkeys / Call Screen Softkeys.\nIdle Screen Softkeys\n\n<table>\n<thead>\n<tr>\n<th>Order</th>\n<th>Mode</th>\n<th>Account</th>\n<th>Description</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Default</td>\n<td>Account 1</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2</td>\n<td>Default</td>\n<td>Account 1</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>3</td>\n<td>Default</td>\n<td>Account 1</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nCall Screen Softkeys\n\n<table>\n<thead>\n<tr>\n<th>Order</th>\n<th>Mode</th>\n<th>Description</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Default</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2</td>\n<td>Default</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>3</td>\n<td>Default</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n- **Functionality**\n\nNow users can setup their own customized softkeys and arrange their layout in idle screen or call screen.\n\n**INVERSE CFG FILES UPLOADING SEQUENCE**\n\n- **Functionality**\n\nNow if enabled “Download and Process All Available Config Files”, the phone will inverse the downloading process to cfg.xml > cfgxp21xx.xml > cfgMAC.bin > cfgMAC.xml. The following files will override the files that has already been load and processed.\n\n**MAX DOWNLOAD/SEARCH LIMITATION FOR BROADSOFT XSI**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Broadsoft → Broadsoft XSI.\n\n\n\n\n\n- **Functionality**\n\nNow users are able to set a maximum Broadsoft XSI contacts download/search number. If users reach this maximum number, phone will pop up message to remind users.\n### Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8464</td>\n<td><New Pvalue> Broadsoft Contacts Download Limitation</td>\n<td>0-2000</td>\n<td>100</td>\n</tr>\n<tr>\n<td>P8465</td>\n<td><New Pvalue> Broadsoft Contacts Search Limitation</td>\n<td>0-2000</td>\n<td>100</td>\n</tr>\n</tbody>\n</table>\n\n### BROADSOFT XSI DIRECTORY DOWNLOAD IMPROVEMENT\n\n#### Functionality\n\nNow instead of downloading all XSI directory on reboot, phone will download at following scenario:\n\n- First time when users access Broadsoft Phonebook;\n- When users change setting related with XSI directory;\n- When download interval triggers downloading (This Interval will start to count after 1st time downloading successfully);\n- When users press download softkey (In this case, phone will only download related directory type).\n\n### GENERATE CORE DUMP\n\n#### Web Configuration\n\nThis option can be found under device web UI → Status → System Info.\n\n**Core Dump**\n\nGenerate core dump\n\n- GUI\n- PHONE\n\n**Core Dump**\n\n- NORMAL\n\n#### Functionality\n\nNow when the phone freezes up or crashes, instead of waiting for the phone to generate a core dump file, users can generate core dump files manually according to the frozen part: PHONE or GUI.\n\n### NO NEED TO DISABLE LOCAL CALL FEATURES WITH BROADSOFT\n\n#### Functionality\n\nNow if device is registered with Broadsoft account, no matter local call features are enabled or disabled,\nonce the Broadsoft account is set special feature to Broadsoft and Feature Key Synchronization is enabled, the call feature will be handled by Broadsoft server, not by the phone.\n\n**BLF TO PICKUP PARKED CALL**\n\n- **Functionality**\n\nIn Broadsoft environment, now if user A parked a call, and user B has a BLF VPK that monitors user A, user B can simply press the VPK to retrieve the parked call.\n\n**BUSY PARKING LOT**\n\n- **Functionality**\n\nNow if user tries to park a call to an occupied parking lot, the parking process will fail and the conversation will resume.\n\n**ONHOLD DURATION**\n\n- **Functionality**\n\nNow if a call was on hold, the holder can see each call's held time if there are more than 3 calls at the same time.\n\n\n\n**SHOW VPK SHARED LINE DISPLAY DESCRIPTION**\n\n- **Functionality**\n\nVPK shared line display description is a new option that will allow admins to decide to show or hide the description value for VPK shared line.\n\nNote: This only can be done with provisioning.\n\n- **Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8484</td>\n<td><New Pvalue> Show VPK shared line</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\nDIAL PLAN FLAG T SUPPORT\n\n- **Functionality**\n\nWhen editing/adding Dial plans, adding a “T” at the end of the plan will make the phone wait for 3 seconds before dialing out. This allows users to have more flexibility on their dial plan setup. For example, with dial plan 1XXT, user will be able to dial more than just 3 digits, while originally the phone will dial out immediately after dialing the third digit.\nFIRMWARE VERSION 1.0.9.69\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n03/08/2018\n\nFIRMWARE FILE INFORMATION\n- GXP2130 firmware file name: gxp2130fw.bin\n MD5: a6cf8f039cf1529dd45df85f77c1db8e\n- GXP2135 firmware file name: gxp2135fw.bin\n MD5: 0389c4df0623c976a10a1c1752549493\n- GXP2140 firmware file name: gxp2140fw.bin\n MD5: 89752d10df1d70aea0e8f424aa20da67\n- GXP2160 firmware file name: gxp2160fw.bin\n MD5: 3b75cfcf3132fe9946c4e770eabb65f4\n- GXP2170 firmware file name: gxp2170fw.bin\n MD5: bf9dde6727b53d41f41d4263afca890a\n\nIMPORTANT UPGRADING NOTE\n- If the phone's web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n- Added Confirm window for killing program to generate core dump on web UI\n- Enhanced syslog to run on other ports instead of default port [SYSLOG ENHANCEMENT]\n- Added Option to choose either to override or accumulate groups when uploading a new XML phonebook [IMPORT GROUP METHOD]\n• Added Auto provision starts when certain p-values are changed [PVALUES THAT TRIGGER AUTO PROVISION]\n• Added Attempt to download config files [ATTEMPT TO DOWNLOAD CONFIG FILE AGAIN]\n\nBUG FIX\n• Fixed Contacts are cleared after uploading wrong format phonebook.xml\n• Fixed First P Value merges with the second comment in config.txt file\n• Remove MAC address in the \"User-Agent\" header of the SIP Register messages for 3CX\n• Fixed Phone does not send DND status back to PBX after 200OK for 3CX\n• Fixed Firmware upgrade via method automatically changes after factory reset and provision\n• Fixed BLF issue with Porta One platform\n• Fixed Phone cannot make calls using the BLF buttons with handset on 3CX\n• Fixed Phone leaves the stuck call in call park scenario with 3CX\n• Fixed Phone randomly changes its IP address\n\nNEW FEATURES OVERVIEW\nThis section lists major new features and describes how to use it from the user’s point of view.\n\nSYSLOG ENHANCEMENT\n• Web Configuration\n\nThis option can be found under device web UI→ Maintenance → Syslog → Syslog Server.\n\nSyslog Server\n\nBy adding port number to the syslog server field, the phone will send syslog to the corresponding port of that IP.\n• Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P207</td>\n<td>Syslog Server</td>\n<td>String</td>\n<td>N/A</td>\n</tr>\n</tbody>\n</table>\n\nIMPORT GROUP METHOD\n• Web Configuration\n\nThis option can be found under device web UI→ Phonebook → Phonebook management → Import Group Method.\n• **Functionality**\n\nNow when user import a new phonebook, they can choose either to replace the old phonebook groups, or to accumulate the old phonebook and the new phonebook together.\n\n• **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8462</td>\n<td><New Pvalue> Import Group Method</td>\n<td>Value = 0; Replace Value = 1; Append</td>\n<td>Replace</td>\n</tr>\n</tbody>\n</table>\n\n**PVALUES THAT TRIGGER AUTO PROVISION**\n\n• **Functionality**\n\nIf the p-values listed below are changed while managing configuration on web UI or LCD, the provision process will be triggered:\n* 192 -- Firmware upgrade server\n* 232 -- Firmware prefix\n* 233 -- Firmware postfix\n* 6767 -- Firmware Upgrade Via\n* 6768 -- Firmware HTTP/HTTPS Username\n* 6769 -- Firmware HTTP/HTTPS Password\n* 237 -- Config upgrade Server\n* 212 -- Config upgrade via\n* 234 -- Config prefix\n* 235 -- Config postfix\n* 1360 -- Config HTTP/HTTPS username\n* 1361 -- Config HTTP/HTTPS password\n\n**ATTEMPT TO DOWNLOAD CONFIG FILE AGAIN**\n\n• **Functionality**\n\nWhen doing provision on the phone, if your first config file contains p-values listed below, phone will try to download the potential second cfg.xml file and apply the second file without rebooting. Maximum 3 extra attempts. Those P-values are:\n* 212 -- Config upgrade via\n* 234 -- Config prefix\n* 235 -- Config postfix\n*237 -- Config upgrade Server\n*240 – Authenticate Config File\n*1359 – XML Config File Password\n*8463 – Validate Server Certificate\n*8467 – Download and process ALL Available Config Files\n*20713 – Always authenticate before challenge\n*22011 – Bypass Proxy For\n*22030 – Enable SSL host verification for provision\nFIRMWARE VERSION 1.0.9.63\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n02/16/2018\n\nIMPORTANT UPGRADING NOTE\n• If the phone’s web UI cannot be accessed after upgrading, please clear web browser cache and it should be accessible again. This is due to front end is cached with previous script, and this issue will be fixed in future release.\n\nENHANCEMENT\n• Added random firmware/config download time feature [RANDOMIZED AUTOMATIC UPGRADE]\n• Added \"Account display\" under account general settings [ACCOUNT DISPLAY]\n• Added confirmation for factory reset from the Keypad while booting [CONFIRMATION FOR FACTORY RESET]\n• Added SNMP support [SNMP SUPPORT]\n• Added uaCSTA support for 3CX [uaCSTA SUPPORT FOR 3CX]\n• Added support to automatically log in web UI from server interface for 3CX [AUTOMATICALLY LOG IN FROM 3CX SERVER INTERFACE]\n• Added support to automatically log in web UI from server interface for 3CX\n• Added support HTTP/HTTPS at the same time for 3CX\n• Added \"Let's Encrypt\" Validation for 3CX\n• Added Use SBC configuration for 3CX [USE SBC WITH 3CX]\n• Added DoNotDisturbEvent support for 3CX [DONOTDISTURBEVENT SUPPORT FOR 3CX]\n• Added support to customize idle time to log out web access [WEB SESSION TIMEOUT]\n• Added support to customize number of failed attempt to access web GUI [WEB ACCESS ATTEMPT LIMIT]\n• Added option to disable user web access [USER WEB ACCESS]\n• Added ability to force the phone to download all configuration files [FORCE TO DOWNLOAD ALL CONFIG FILES]\n• Enabled strong password for admin/user password [TEST PASSWORD STRENGTH]\n• Added support to display Active VPK page [ACTIVE VPK PAGE]\n• Added ability to increase/decrease the priority of each existing pattern under phone’s dial plan [CHANGE PRIORITY OF EXISTING DIAL PLAN PATTERN]\n• Allowed LCD backlight to be always on or always off [SUPPORT TO ALLOW LCD BACKLIGHT ALWAYS ON]\n• Added Login Prefix/Suffix for public mode [PUBLIC MODE USERNAME PREFIX/SUFFIX]\n• Added option on Web UI to warm deleting all contacts [WARNING MESSAGE FOR DELETING CONTACTS]\n• Added Server Validation [SERVER VALIDATION]\n• Added support to get OpenVPN files from HTTP/TFTP server [SUPPORT TO GET OPENVPN FILE FROM SERVER]\n• Added softkey “Logout” when Public mode is enabled [LOGOUT SOFTKEY IN PUBLIC MODE]\n• Added option to disable DND function [DISABLE DND FEATURE]\n• Added support for SSH access with authentication keys [SSH PUBLIC KEY]\n• Added ability to choose the predictive dialing source [PREDICTIVE DIALING SOURCE]\n• Added option to enable/disable incoming call popup [ENABLE INCOMING CALL POPUP]\n• Allowed BLF and speed dial to perform blind transfer during active call\n• Added host name of the phone on the DHCP INFORM using DHCP Option 12\n• Added support for HTTPS server based on TLSv1.2\n• Added support for more of 30 groups on local phonebook\n• Added option to include MAC address in the SIP User-Agent [USE MAC HEADER]\n• Added support for VPK share line to display description value [VPK SHARED LINE DISCRPTION]\n• Added record user config privilege checking\n\nBUG FIX\n\n• Fixed Network gateway displayed wrong after removing network cable\n• Fixed Device didn’t send SUBSCRIBE to primary IP in SRV record\n• Fixed All LEDs didn’t light up after offhook then entering Diagnostic mode\n• Fixed BLF light remained red after monitored extension performs transfer\n• Fixed Broadsoft N-WAY conference worked abnormally with SCA\n• Fixed Device cannot playback any voicemail for Broadsoft XSI voicemail\n• Fixed Device \"dial\" softkey did not work correctly after performing remote search for Broadsoft Group Directory Search\n• Fixed Device contact list lost status of all contacts when Broadsoft UC-One client logs in\n• Fixed Device didn’t display total charge during a call for Broadsoft advice-of-charge users\n• Fixed Broadsoft XSI voicemail - Cannot playback any voicemail\n• Fixed Device works abnormal after downloading Broadsoft call history\n• Fixed Device enabled SCA only in one line key when hosting conference\n• Fixed Device unable to dial star code during conference\n• Fixed Swapped account’s call history worked abnormally\n• Fixed Device generated core dump file after lots osnf characters input in Description/Values of EXT/MPK\n• Fixed 802.1x Client Certificate cannot be deleted\n• Fixed Device was unable to save edited ringtones from phone’s LCD screen\n• Fixed Device worked abnormally if configured with wrong BLF server and multiple BLF keys\n• Fixed Phone gets locked when using customer’s LDAP setting\n• Fixed Device couldn’t handle the next 180 or 183 after encountering 183 session in progress\n• Fixed Device didn’t follow the SRTP Key length that was set after receiving no SDP in the INVITE\n• Fixed Device uploading new phonebook cannot erase previous uploaded phonebook\n• Fixed Device special characters are not displayed correctly in certain menus\n• Fixed Max hits and Search Timeout of LDAP didn’t work\n• Fixed Device couldn't dial IP call logs if no account is registered successfully\n• Fixed Device replied with 486 when the called extension is registered on the same phone\n• Fixed Device ignored the number on TRANSFER screen after pressing Speed Dial MPK\n• Fixed Device LCD displayed extra BlindTrnf softkey in GXE platform call park page\n• Fixed There still displayed previous missed call icon in public mode\n• Fixed The Ext board displayed abnormally when many members in Eventlist BLF URI\n• Fixed Instant Message display abnormally\n• Fixed Line LED displayed abnormally if disabled \"Onhook Dial Barging\" then came call in Account mode\n• Fixed Device couldn’t adjust the volume after the remote party ended the Bluetooth call\n• Fixed NewCall softkey is invalid in HF call of Account Mode\n• Fixed LCD could skip to dialing page after Offhook in NO LAN CABLE status\n• Fixed Contact list will lose status of all contacts when UC one client logs in for IM&P\n• Fixed Call center status icon didn't update in time\n• Fixed LCD tip is wrong if using * to send emergency call in Functional keypad lock mode\n• Fixed Device worked abnormally after pressing up/down key in Account Mode’s multiple calls\n• Fixed device didn't keep identical in serials automatic redial of Functional keypad locked mode\n• Fixed Device didn't pop up Automatic redial window after being rejected twice\n• Fixed device still upgraded even user has checked NO in functional keypad locked mode\n• Fixed VPK mode and display couldn't be changed by provisioning by DM Server\n• Fixed Advice of charge not displaying XML during call\n• Fixed change SIP static library to shared library\n• Fixed There was one-way audio after hold/unhold call when there is incoming call in outgoing call status\n• Fixed Device sends SIP requests to OBP port 5060 when configured as a different port\n• Fixed Call history displayed abnormal in semi-attended transfer\n• Fixed Device still could establish more than 5-way conference in Account mode\n• Fixed Web page didn't close Select ringtone window after uploading wrong format file when adding contact or group\n• Fixed the automatic redial countdown timer stopped after putting down handset\n• Fixed GUI crashed after disabling ‘Onhook Dial Barging’ then answering call\n• Fixed Device worked abnormally if participant ended call when host is in CONF page\n• Fixed No Swap softkey when there is incoming call in Account mode call after disabling Incoming call popup\n• Fixed After performing remote search, the \"dial\" softkey cannot dial a number that has both extension and phone number\n• Fixed Special characters are not displaying correctly in certain menu entries\n• Fixed There was no Split softkey in attended transfer call of pre-conference process\n• Fixed There displayed ConfCall softkey in attended transfer process\n• There was no ring tone after parking call then picking up\n• Fixed The EXT board did not update the modified content after linked with EXT board for some time\n• Fixed Account status page does not display actual SIP server registered when secondary SIP server is in use\n• Fixed Web page doesn’t close Select ringtone window after uploading wrong format file for contact or group\n• Fixed Factory reset message not clearly displayed\n• Fixed Softkeys disappeared if entering phonebook then back from conference holding page\n• Fixed Phone freeze when hanging calls when updated to 1.0.9.26\n• Fixed “User” could modify the value which was only allowed to be changed by \"Admin\" by sending specific html\n• Fixed LDAP port could be saved as 0 in LCD\n• Fixed 3CX CTI to dial * asterisk is not working\n• Fixed 3CX provision failed for some phone properties\n• Fixed phone did not send unregister when factory reset for 3CX\n• Fixed Empty Cache and Hard reload will cause empty web page\n• Fixed 3CX CTI to dial * asterisk is not working\n• Fixed Inaccurate weather description with open weather API\n• Fixed 3CX re-provision failed for some phone properties\n• Fixed Device freezed after configuring Eventlist BLF URI on 3CX platform then staying in Idle\n• Fixed Device couldn't use Target to establish conference or transfer in VPK page\n• Fixed NewCall softkey is invalid in HF call of Account Mode\n• Fixed Device repeatedly registered after reboot\n• Fixed Seize busy shared line will trigger a speed dial to call shared line number\n• Fixed Off-hook seizing of busy shared line will send SUBSCRIBE with call info containing wrong appearance\n• Fixed User Protection setting is not blocking provisioning\n• Fixed Device lock ringer volume also locks the volume of the headset in a call\n• Fixed Shared line will send wrong line appearance in SUBSCRIBE when unseizing the line\n• Fixed No sound in call\n• Fixed Line LED displayed abnormally if disabled \"Onhook Dial Barging\" then there is incoming call in Account mode\n• Fixed Call Completion service worked abnormally in Functional keypad locked mode\n• Fixed Keypad unlock popup displayed abnormally if pressed other keys when adjusting volume\n• Fixed Transferred call log didn't display manually added contact's names\n• Fixed Phone cannot provision certain idle screen softkey\n• Fixed There was no Next softkey in Active VPK page if only exists one VPK page\n• Fixed Shared line is not following line seize expiration timer\n• Fixed GXP2130 Factory reset message not clearly displayed\n• Fixed Device still restored Config even without checking Config when Restore Backup Package\n• Fixed phone does not update the group of contacts when adding a new contact\n• Fixed Shared line related VPK's LED displayed abnormally\n• Fixed phone is frozen after multiple automatic answers\n• Fixed device worked abnormally if answered paging call in SIP Error page\n• Fixed new feature “Enable strong password” didn't work normally\n• Fixed Device didn't popup Authentication window when downloading encrypted config files\n• Fixed Device crashed after answering the queue call\n• Fixed USB storage driver couldn't be detected if it boots up along with phone\n• Fixed Device auto dials in onhook dialing page after checking predictive dial entry even live dialpad is disabled\n• Fixed Device GUI crashed when using the last line\n• Fixed LCD didn't pop up \"Allow remote control?\" if executing API commands in keypad unlock status\n• Fixed No sound after establishing long time call then hold/unhold call\n• Fixed There was no Close or Cancel button on web option Restore From Backup package\n• Updated GXP Certificates\n• Removed Currency page on LCD\n• Fixed Device refreshed register after modifying any options on web pages except options on Account page\n• Fixed Device was undiscoverable under GS Affinity\n• Fixed Syslog custom port had no range limit\n• Set Config upgrade via HTTPS & Firmware upgrade via HTTP as Default value\n\nNEW FEATURES OVERVIEW\nThis section lists major new features and describes how to use it from the user’s point of view.\n\nRADOMIZED AUTOMATIC UPGRADE\n\n• Web Configuration\n\nThis option can be found under device web UI → Maintenance → Upgrade and Provisioning → Randomized Automatic Upgrade.\n\nRadomized Automatic Upgrade: No | Yes\n\nHour of the Day (0-23): Start 1 | End 0\n\nDay of the Week (0-6): 1\n\n• Functionality\n\nNow users can setup randomized upgrade with day of the week and hour of the day.\n\n• New Pvalue\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8458</td>\n<td><New Pvalue> Randomized Automatic Upgrade</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>P285</td>\n<td><New Pvalue> Hour of the Day Start</td>\n<td>0-23</td>\n<td>1</td>\n</tr>\n<tr>\n<td>P8459</td>\n<td><New Pvalue> Hour of the Day End</td>\n<td>-1; 0-23</td>\n<td>0</td>\n</tr>\n<tr>\n<td>P286</td>\n<td><New Pvalue> Day of the Week</td>\n<td>0-6</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\n**ACCOUNT DISPLAY**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Accounts → Account # → General Settings → Account Display.\n\n\n\n- **Functionality**\n\nNow the users can decide whether they want to display User Name or User ID on their LCD.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P2380</td>\n<td><New Pvalue> Account Display</td>\n<td>Value = 0; User Name Value = 1; User ID</td>\n<td>User Name</td>\n</tr>\n</tbody>\n</table>\n\n**CONFIRMATION FOR FACTORY RESET**\n\n- **Functionality**\n\nWhen users try to factory reset from keypad while booting, the phone will prompt confirmation information to make sure the action. This will avoid people from accidentally reset your phone.\nuaCSTA SUPPORT FOR 3CX\n\n- **Web Configuration**\n\n This option can be found under device web UI → Network → Remote Control → CSTA Control.\n\n- **Functionality**\n\n Now the users can use 3CX server with the CSTA enabled and have the following functions supported:\n - Support for CSTA session establish through SIP INVITE\n - Support for CSTA MonitorStart request through SIP INFO\n - Support for CSTA MakeCall request through SIP INFO\n - Support for CSTA AnswerCall request through SIP INFO\n - Support to send CSTA DeliveredEvent request through SIP INFO\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P32053</td>\n<td><code><New Pvalue></code> CSTA Control</td>\n<td>Value = 0; Disabled</td>\n<td>Disable</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1; Enabled</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**SNMP SUPPORT**\n\n- **Web Configuration**\n\n This option can be found under device web UI → Network → SNMP Settings.\n### SNMP Settings\n\n- **Enable SNMP**\n - Yes\n - No\n\n- **SNMP Trap Community**\n\n- **SNMP Trap IP**\n\n- **SNMP Trap Port**\n - 162\n\n- **SNMP Trap Version**\n - Version 1\n - Version 2\n\n- **SNMP Trap Interval**\n - 5\n\n---\n\n**Functionality**\n\nNow the device support SNMP (Simple Network Management Protocol) and users can modify the trap information by themselves.\n\n**New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n</table>\n| P21896 | Enable SNMP | Value = 0; No\n | | Value = 1; Yes | No |\n| P21900 | SNMP Trap Community | String | N/A |\n| P21897 | SNMP Trap IP | String | N/A |\n| P21898 | SNMP Trap Port | 1025-65535, 162 | 162 |\n| P21899 | SNMP Trap Version | Value = 0; Version 1\n | | Value = 1; Version 2 | Version 2 |\n| P21901 | SNMP Trap Interval | 1-1440 | 5 |\nAUTOMATICALLY LOG IN FROM 3CX SERVER INTERFACE\n\n- **Functionality**\n\nNow users can log on to the phone’s web UI from 3CX server by pressing the Phone UI with the correct provision and correct template.\n\nWEB SESSION TIMEOUT\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Security Settings → Security → Web Session Timeout.\n\n| Web Session Timeout | 10 |\n\n- **Functionality**\n\nNow users can set the session timeout time. This will give users more flexibility on how long they want to stay on their web UI without trying to log in again.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P28116</td>\n<td><New Pvalue> Web Session Timeout</td>\n<td>2-60</td>\n<td>10</td>\n</tr>\n</tbody>\n</table>\n\nWEB ACCESS ATTEMPT LIMIT\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Security Settings → Security → Web Access Attempt Limit.\n\n| Web Access Attempt Limit | 5 |\n\n- **Functionality**\n\nNow users can set the session timeout time. This will give users more flexibility on how long they want to stay on their web UI without trying to log in again.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n</table>\n\n| | | | |\nFORCE TO DOWNLOAD ALL CONFIG FILES\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Upgrade and Provisioning → Download and Process ALL Available Config Files\n\n- **Functionality**\n\nNow users are able to download all the config files if there exist multiple config files on the server. The phone will download in the order of cfg[MAC].bin file > cfg[MAC].xml file > cfg[MODEL](gxp21XX).xml file > cfg.xml file, which the file that downloads after will override the previous one.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8467</td>\n<td>Download and Process ALL Available Config Files</td>\n<td>Value = 0; No</td>\n<td>No</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1; Yes</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTEST PASSWORD STRENGTH\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → General Settings → Test Password Strength.\n\n- **Functionality**\n\nWhen choose Yes, users are able to set their password contains at least 3 out of these four categories:\n\n1. Numerics (0-9)\n2. Capital Letters (A-Z)\n3. Lower Case Letters (a-z)\n4. Special symbols: Eg: !, @, #, $, %, ^, &, *, (, ), etc.\n\nAlso that the minimum characters should not be lesser than 9. This allows more security for the user/admin.\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8468</td>\n<td><New Pvalue> Test Password Strength</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\n\n**USER WEB ACCESS**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Security Settings → Security → Enable User Web Access.\n\n- **Functionality**\n\nWhen this option is disabled, the user account will no longer be able to log on to web GUI. This allow admin to be fully control for the phone.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8469</td>\n<td><New Pvalue> Enable User Web Access</td>\n<td>Value = 0; Disabled Value = 1; Enabled</td>\n<td>Enabled</td>\n</tr>\n</tbody>\n</table>\n\n**CHANGE PRIORITY OF EXISTING DIAL PLAN PATTERN**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Accounts → Account # → Dialplan.\n\n**Dialplan**\n- **Functionality**\n \n From the figure above, blue square indicates to increase/decrease of the priority. Changing priority from Accounts → Account # → Call Settings → Dial Plan will also works the same.\n\n**ACTIVE VPK PAGE**\n\n- **Web Configuration**\n \n This option can be found under device web UI → Settings → Call Features → Enable Active VPK Page.\n\n \n\n- **Functionality**\n \n If active VPK page is enabled, when monitored BLF number is called, the screen will generate the VPK Page that shows which VPK key(s) is(are) active as below, where you can see the page number is a handset icon, which indicate that this page is an active VPK page. The original VPK pages are still navigable by pressing Next softkey.\n\n\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P22134</td>\n<td><New Pvalue></td>\n<td>Value = 0; No</td>\n<td>No</td>\n</tr>\n<tr>\n<td></td>\n<td>Enable Active VPK Page</td>\n<td>Value = 1; Yes</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**SUPPORT TO ALLOW LCD BACKLIGHT ALWAYS ON**\n\n- **Web Configuration**\n \n This option can be found under device web UI → Settings → Preferences → LCD Display → Active Back Light Timeout\n• **Functionality**\n\nWhen Active Backlight Timeout is set to 0, the backlight will be constantly on.\n\n• **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8356</td>\n<td>Active Backlight Timeout</td>\n<td>0 (Always on), 1-90 (mins)</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\n**PUBLIC MODE USERNAME PREFIX/SUFFIX**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Settings → General Settings → Public Mode Username Prefix/Suffix\n\n**Public Mode Username Prefix**\n\n**Public Mode Username Suffix**\n\n• **Functionality**\n\nNow users can add prefix and suffix to their login information for public mode.\n\nAs the figure showed, “Grandstream-” is the prefix, “-Test” is the suffix and “1034” is the account number.\n\n• **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8470</td>\n<td><New Pvalue> Public Mode Username Prefix</td>\n<td>String</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>P8471</td>\n<td><New Pvalue> Public Mode Username Suffix</td>\n<td>String</td>\n<td>N/A</td>\n</tr>\n</tbody>\n</table>\nWARNING MESSAGE FOR DELETING CONTACTS\n\n- **Functionality**\n\nNow when user hits on deleting contacts, the web will prompt a warning message to confirm action.\n\nSERVER VALIDATION\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Security Settings → Security → Validate Server Certificate\n\n- **Functionality**\n\nAfter enabling this feature, phone will validate the server’s certificate. If the server that our phone tries to register on is not on our list, it will not allow server to access the phone.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8463</td>\n<td><New Pvalue> Validate Server Certificates</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\n\nSUPPORT TO GET OPENVPN FILE FROM SERVER\n\n- **Functionality**\n\nWith this feature, instead of uploading the whole texts onto cfg.xml file, users can simply put the HTTP/TFTP link of the file in the P value to upload their Certificates information into the phone.\nLOGOUT SOFTKEY IN PUBLIC MODE\n\n- Functionality\n\nNow users can log out of the public mode account by simply pressing the logout softkey.\n\nDISABLE DND FEATURE\n\n- Web Configuration\n\nThis option can be found under device web UI → Settings → Call Features → Enable DND Feature.\n\n- Functionality\n\nNow uses can enable/disable DND function. When disabled, DND functions can no longer be activated from the phone.\n\n- New Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8446</td>\n<td><New Pvalue> Enable DND Feature</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\nSSH PUBLIC KEY\n\n- Web Configuration\n\nThis option can be found under device web UI → Maintenance → Security Settings → Security → SSH Public Key.\n• **Functionality**\n\nNow users can upload their own public key onto the phone and use the corresponding private key to access SSH without typing in password.\n\n**PREDICTIVE DIALING SOURCE**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Settings → Call Features → Predictive Dialing Source.\n\n• **Functionality**\n\nNow users can choose where they want their predictive dial to get its source from. Simply press “Modify” and choose the source you need. Default is set to all areas.\n\n**ENABLE INCOMING CALL POPUP**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Settings → Call Features → Enable Incoming Call Popup.\n\n• **Functionality**\n\nOriginally, when there is an incoming call during an ongoing call, there will be a popup window:\n\nNow when this feature is disabled, the popup window will no longer show up.\n• New Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8401</td>\n<td><New Pvalue> Enable Incoming Call Popup</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\nUSE MAC HEADER\n\n• Web Configuration\n\nThis option can be found under device web UI → Accounts → Account # → SIP Settings → Custom SIP Headers.\n\nUse MAC Header ☐ No ☐ Yes\n\n• Functionality\n\nNow instead of showing in regular MAC field, we have included the MAC address into the User-Agent Field.\n\nEg:\n\n```\nX-Grandstream-PBX: true\nMax-Forwards: 70\nUser-Agent: Grandstream GXP2130 1.0.9.60 000b826a56f7\nPrivacy: none\nP-Preferred-Identity: \"1016\" <sip:1016@172.18.25.146>\nP-Access-Network-Info: IEEE-EUI-48;eui-48-addr=00-00-0C-07-AC-02\nP-Emergency-Info: IEEE-EUI-48;eui-48-addr=00-0B-82-6A-56-F7\n```\n\n• New Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P26061</td>\n<td>Use MAC Header</td>\n<td>Value = 0; User Name Value = 1; User ID</td>\n<td>User Name</td>\n</tr>\n</tbody>\n</table>\n\nVPK SHARED LINE DISCRIPTION\n\n• Functionality\n\nIf the VPK Description is set, it will show the description on the LCD screen. If the Description is left empty, Default value will be Account name.\n\nFor example:\n\nVPK1 is left empty:\nVPK2 is set to “share 1”:\n\nAfter Save and Apply, the LCD screen will show as below:\n\nUSE SBC WITH 3CX\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Accounts → Account # → Network Settings → Use SBC.\n\n- **Functionality**\n\nNow if users want to work under SBC associated with 3CX, they should enable this feature to have better communication with the server.\n• **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P26090</td>\n<td>Use SBC</td>\n<td>Value = 0; No</td>\n<td>No</td>\n</tr>\n<tr>\n<td>P26190</td>\n<td></td>\n<td>Value = 1; Yes</td>\n<td></td>\n</tr>\n<tr>\n<td>P26290</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P26390</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P26490</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>P26590</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**DONOTDISTURBEVENT SUPPORT FOR 3CX**\n\n• **Functionality**\n\nNow DND function can be support by 3CX server. It will display on CTI and web client page. When device uses DND mode, it will send SIP NOTIFY contains message as the figure shown below. That will sync with the server and show on CTI and Web Client.\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<DoNotDisturbEvent xmlns=\"http://www.ecma-international.org/standards/ecma-323/csta/ed5\">\n <monitorCrossRefID>0</monitorCrossRefID>\n <device>\n <deviceIdentifier>sip:630@172.18.30.26:5060</deviceIdentifier>\n <doNotDisturbOn>true</doNotDisturbOn>\n </device>\n</DoNotDisturbEvent>\n```\n\n**USER PROTECTION**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Maintenance → Upgrade and Provisioning → User Protection.\n• **Functionality**\n\nNow users can set protection on their Pvalues.\n\n➢ If \"User protection\" is OFF, everyone (Provider, user or admin) has access to most of the Pvalues.\n\n➢ If \"User protection\" is ON, only those (normally user or admin) who have privilege can modify the configuration.\n\nNote: If the P values are included with Provider lock, then the User Protection function will not protect those values.\n\n• **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P9996</td>\n<td><New Pvalue></td>\n<td>Value = 0: Disabled</td>\n<td>0</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1: Enable</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>User Protection</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\nFIRMWARE VERSION 1.0.9.26\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n09/26/2017\n\nIMPORTANT UPGRADING NOTE\n\nBUG FIX\n- Fixed Phone cannot dial characters if using Affinity\n- Patched Blueborne vulnerability\nFIRMWARE VERSION 1.0.9.25\n\nPRODUCT NAME\nGXP2130, GXP2135, GXP2140, GXP2160 and GXP2170\n\nDATE\n08/30/2017\n\nIMPORTANT UPGRADING NOTE\n\n- This release restored the Weather service. Part of the change requires users who are using “Self-Defined City Code” to change their setting. The upstream content provider has changed the API to yield a free-style search based on this argument instead of mapping to a specific code being used before. Hence the city being displayed would have been incorrect. These users should change this option to the name of the city, for instance; “Dallas”; “Dallas, NC”; “Dallas, Scotland”; “Liverpool”; “Liverpool, NY”; “Liverpool, England”. Note: If you enter only the name of the city it’s going to go the best match. In the case of Dallas it would be Dallas, TX; and in the case of the Liverpool it would be Liverpool, England.\n- Firmware 1.0.9.25 and higher versions support new hardware revision on GXP2130. For GXP2130 with new hardware version 2.5A and 2.6A, it cannot downgrade to firmware version lower than 1.0.7.25.\n\nENHANCEMENT\n\n- Added support for “Off-Hook Auto Dial Delay” [OFF-HOOK AUTO DIAL DELAY]\n- Added keypad support for factory reset [FACTORY RESET VIA KEYPAD]\n- Added “Call Completion” feature [CALL COMPLETION SERVICE]\n- Added support to enable keypad lock with MPK/VPK/Softkey by one press [KEYPAD LOCK]\n- Added account swapping feature [ACCOUNT SWAPPING]\n- Added dialplan new web UI interface [DIALPLAN INTERFACE]\n- Added MPK mode for multicast listening list [MULTICAST LISTENING ADDRESS LIST]\n- Added new MPK mode: forward, DND, redial, SMS, paging [NEW MPK MODE FOR FORWARD, DND, REDIAL, SMS AND PAGING ]\n- Added shortcut HOLD+UP to factory functions page [SHORTCUT (HOLD+UP) TO FACTORY FUNCTIONS SETTING]\n- Added “Transfer Mode via VPK” feature [TRANSFER MODE VIA VPK]\n- Added action URI feature [ACTION URI SUPPORT]\n- Added support for Cisco Discovery Protocol (CDP) [SUPPORT FOR CISCO DISCOVERY PROTOCOL (CDP)]\n• Added support of wav playback feature and custom ringtone for individual Contact [CUSTOM RINGTONE FOR INDIVIDUAL CONTACT]\n• Added LCD menu for weather configuration [WEATHER CONFIGURATION FROM LCD MENU]\n• Added support to export/import user configuration [SUPPORT TO DOWNLOAD USER CONFIGURATION]\n• Added search bar feature to search with alphabet characters, lookup first/last name and UserID fields [SEARCH BAR SUPPORT]\n• Added “Virtual Voice mail” feature [VIRTUAL VOICE MAIL]\n• Added UCM Call Center Feature [UCM CALL CENTER FEATURE]\n• Added support to show status of user space [USER SPACE STATUS]\n• Added support for error message popup [ERROR MESSAGE SUPPORT ON LCD SCREEN]\n• Added support for date and time display on screensaver [DATE AND TIME DISPLAY ON SCREENSAVER]\n• Added support for default ringtone [DEFAULT RINGTONE]\n• Added ability to display original caller’s ID for BLF call pick up calls. If user performs a BLF pickup, the phone will display the original caller’s call ID instead of the extension’s call ID.\n• Added “NewCall” softkey when on hold in Account Mode so that users do not need go back to the call to access NewCall softkey.\n\nBUG FIX\n• Fixed \"Disable DHCP Option 43 and Option 66 to Override Server\" doesn’t work\n• Fixed There is no sound in the call after changing iLBC payload type\n• Fixed VPK cannot be provisioned successfully if configuration file has P values requiring reboot\n• Fixed Conference participants hear noise after conference host hangs up when SRTP is used\n• Fixed Eventlist BLF is not auto provisioned on LCD after disconnecting EXT board\n• Fixed BLF stops working after a period of time\n• Fixed Broadsoft XSI directories do not send request with authentication after receiving 401 message\n• Fixed ReConf Softkey disappears when pressing Up/Down key on call interface under account mode\n• Fixed ‘Hide Dialing Password’ doesn't work after holding/resuming call\n• Fixed Device works abnormally if connecting with Bluetooth headset during ringing status\n• Fixed Device doesn’t respond when pressing shared line key under account mode\n• Fixed Audio mode is incorrect when enabling Live DialPad and connecting Bluetooth\n• Fixed Password length of Hide Dialing Password has no value limitation\n• Fixed Bluetooth “Toggle” softkey is displayed wrong in on-hook dialing page\n• Fixed Syslog messages do not have MAC address and firmware version included\n• Fixed Device works abnormally after dialing favorite contacts in Quick IP Call page\n• Fixed USB screensaver source works abnormally\n• Fixed Device sends duplicate outbound notification and Action URL message\n• Fixed LCD displays extra Broadsoft center icon after reboot\n• Fixed Device acts abnormally when using Favorite contact to predictive call\n• Fixed Device doesn’t display far end picture if it’s added to local phonebook\n• Fixed Call history duration on web displayed abnormally\n• Fixed Device line LED works abnormally in account mode\n• Fixed Device couldn’t access network\n• Fixed Firmware upgrade method could be changed when Provider Lock is enabled\n• Fixed “Backspace” Softkey in Broadsoft conference “add” page doesn't work\n• Fixed Device works abnormally if holding/resuming call after dismissing incoming call\n• Fixed Broadsoft UC-One related issues for IM&P, XSI and Broadsoft Anywere\n• Fixed The input box displays abnormally after configuring multiple characters in LDAP Directory\n• Fixed Device works abnormally if modifying Menu mode with \"Locked\" in audio loopback page\n• Fixed Device LCD displays abnormally in “More” menu key after entering number in Attended Transfer\n• Fixed LCD stays in Cancel ForwardAll page after pressing CancelFwd Softkey\n• Fixed Device fails to download language file when options “config via” and “firmware upgrade via” are set to use different protocols\n• Fixed Device plays dial tip tone in idle state after CancelFwd\n• Fixed The extension board backlight is off after switching Sync Backlight with LCD option\n• Fixed Device works abnormally if there is an incoming call in audio loopback mode after setting ForwardAll\n• Fixed Accounts’ contacts are cleared after selecting “Delete All contacts” in Affinity App\n• Fixed LCD warning box displays incompletely when performing record via USB but not connecting to a USB storage device\n• Fixed History Softkey and missed call records display abnormally in DND status when disabling the call log\n• Fixed Allow Remote Control Popup Window doesn’t pop up again after timeout or hiding it\n• Fixed Device couldn't obtain network if 802.1p is configured in DHCP VLAN mode\n• Fixed On-Hook Dialing window disappears when there is an incoming call\n• Fixed Unread missed call log is not synchronized with Affinity app\n• Removed default image on the overview call screen\n• Split call recording file into 2 channel files\n• Fixed Device works abnormally after provisioning a config file in a call\n• Fixed Device is switched to speaker and generates noise when using Bluetooth headset and dialing\n• Fixed Device with Line Key Sync enabled still handles CallFWD No Answer if there is incoming call from BS Hunt Group\n• Fixed No audio upon answering multiple calls issue\n• Fixed Device plays back tone instead of call waiting tone (CWT)\n• Fixed DHCP Option 60 Vendor class identifier is sent incorrectly after factory reset\n• Fixed Eventlist BLF only auto provisions first VPK page upon reboot\n• Fixed DeleteAll softkey doesn't take effect on BS phonebook list interface\n• Fixed Device couldn't get DHCP VLAN network segment IP after bootup\n• Fixed \"Broadsoft Only\" is displayed incompletely on LCD\n• Fixed Keypad Lock status on web page is not synchronized with Keypad Lock VPK\n• Fixed MPK/VPK configuration and display issue\n• Fixed Broadsoft call log details have time information displayed in strange format\n• Fixed There is no sound in G.722 call using handset after enabling Ring For Call Waiting\n• Fixed Device fails to download phonebook after setting server path to a domain name address\n• Fixed GXP2130v1 doesn't answer multicast\n• Fixed `<PhotoUrl>` tag is not working in the XML phonebook file\n• Fixed Pressing Bluetooth headset key couldn't end current call when there is an incoming call\n• Fixed Audio works abnormally after pressing BTOFF/BTON Softkey when there is an incoming call\n• Fixed No audio for incoming multicast paging with codecs other than PCMU\n• Fixed Multicast paging call displays PCMU codec even if using a different codec\n• Fixed Device works abnormally after logging in with the Public Mode\n• Fixed DHCP inform doesn't include vendor class identifier\n• Fixed Call history info is displayed wrong after call is being transferred\n• Fixed Device works abnormally after answering call before performing re-register\n• Fixed Discrepancies issue with Multicast Codec Defined at the Sender Side\n• Fixed Device fails to send call after two minutes of idle time when device is connected to a Bluetooth Headset\n• Fixed Device doesn't parse and process presence status in UCM presence NOTIFY\n• Fixed Password is displayed abnormally on External Service page\n• Fixed Broadsoft Phonebook only shows 50 contacts\n• Fixed No key Entry Timeout doesn't keep default value after factory reset\n• Fixed Device freeze issue in certain scenarios\n• Fixed Softkeys doesn't work after rejecting one of multiple incoming calls\n• Fixed Domain name with underscore couldn't be saved\n• Fixed Predictive dialing is not working when local phonebook contains German characters such as \"Ä \" or \"Ä\" or \"Ô\n• Fixed One-way audio issue when resuming a call on hold\n• Fixed User is logged out after entering into Bluetooth settings in public mode\n• Fixed Device does not support some API operation\n• Fixed Device LCD displays missed call window after forwarding call manually\n• Fixed One-way audio issue when resuming a call on hold\n• Fixed Garbled text issue on Phonebook\n• Fixed 3CX SRTP audio issue when resuming from hold\n• Fixed Phone module crashes after receiving message\n• Fixed Hold/resume key issue\n• Fixed \"Cancel\" Softkey is removed from LCD when establishing an attended call transfer\n• Fixed PAI doesn't update the number or name if contact is set\n• Fixed Contact names are lost after uploading phonebook.xml on web\n• Fixed Phone cannot properly upgrade through HTTP\n• Fixed Phone automatically dialed out even when Live DialPad is disabled\n• Fixed Existing dynamic parameters' names are not case-insensitive for Outbound notification and ActionURL configuration\n• Fixed ‘Enable DHCP VLAN’ feature tip info displayed XXXX\n• Fixed Ringing through Speaker to Signal Call Waiting issue\n• Fixed SIP performance issue in response to re-invite during call setup\n• Fixed Device still can add contacts from web page when it already has 500 entries\n• Fixed Device upgrading fails in 802.1x environment\n• Fixed Device took wrong subscribe expire after calling UCM conference room constantly\n• Fixed Device uses the first offered codec even there is no such codec is configured\n• Fixed Incorrect caller ID on redial with multiple accounts in Account Mode\n• Fixed Device line LED displayed abnormally if disabling \"Onhook Dial Barging\" and then a call comes in to Account mode.\n• Fixed Some languages are translated abnormally\n• Fixed Device line LED displayed abnormally if disabling \"Onhook Dial Barging\" and then a call comes in to Account mode.\n• Fixed CTI APP display doesn't change according to status if connected with phone using static IP\n\nNEW FEATURES OVERVIEW\nThis section lists major new features and describes how to use it from the user’s point of view.\n\nOFF-HOOK AUTO DIAL DELAY\n\n• Web Configuration\n\nThis option can be found under device web UI→Settings→Call Features→Off-hook Auto Dial Delay.\n\n<table>\n<thead>\n<tr>\n<th>P8388</th>\n<th><New Pvalue></th>\n<th>Off-hook Auto Dial Delay</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Pvalue</td>\n<td>Description</td>\n<td>Value Range</td>\n</tr>\n<tr>\n<td>0-10</td>\n<td>0</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nFACTORY RESET VIA KEYPAD\n\n• Web Configuration\n\nThis option can be found under device web UI→Maintenance→Security→Configuration via Keypad Menu.\n• **Functionality**\n\nIf we want to allow factory reset from keypad work without restriction, set this option to \"Unrestricted\". If you want to do Factory reset via keypad, please follow the steps:\n\n1. Power cycle the phone;\n2. Wait till you see “booting”;\n3. When phone is “booting”, press KEY 1 + Key 9 immediately and hold it until LCD displays factory reset message;\n4. Factory reset is complete.\n\nIf other modes are set, password will be requested. If the password input is correct, phone will perform factory reset; if not, the phone will reboot without factory reset. Here are the steps:\n\n1. Power cycle the phone;\n2. Wait till you see “booting”;\n3. When phone is “booting”, press KEY 1 + Key 9 immediately and hold it until LCD displays “Password”;\n4. Enter the correct Password to factory reset (Password for Keypad Lock);\n5. Factory reset is complete.\n\n• **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n</table>\n| P1357 | Configuration via Keypad Menu | Value = 0; Unrestricted \nValue = 1; Basic settings only \nValue = 2; Constraint Mode \nValue = 3; Locked Mode | Unrestricted |\n\n**CALL COMPLETION SERVICE**\n\n• **Web Configuration**\n\nThis option can be found under device web UI→Settings →Call Features→Enable Call Completion Service.\n• **Functionality**\n\nIf user enables automatic redial and call completion service, and makes a call to callee, when the callee is busy at the moment, phone will monitor callee’s status. Once the callee is available, phone will ask if user wants to redial again.\n\n• **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8391</td>\n<td><New Pvalue> Enable Call Completion Service</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\n\n**KEYPAD LOCK VIA MPK/VPK/SOFTKEY**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Settings → Programmable Keys → Virtual Multi-Purpose Keys → Edit VPK → Mode → Keypad Lock; or under web UI → Settings → Programmable Keys → Physical Multi-Purpose Keys → Mode → Keypad Lock.\n• **Functionality**\n\nNow users are able to perform keypad lock by using MPK/VPK/Softkey other than STAR key.\n\n**ACCOUNT SWAPPING**\n\n• **Web Configuration**\n\nThis option can be found under device web UI→Accounts→Account Swap→Swap Account Settings.\n\n**Account Swap**\n\n\n\n• **Functionality**\n\nThis option allows users to swap the two accounts that they have configured. This will increase the flexibility of account management.\n\n**DIALPLAN INTERFACE**\n\n• **Web Configuration**\n\nThis option can be found under device web UI→Accounts→Account #→Dialplan.\nDialplan\n\nThe new Dial plan web user interface is a simplified way for users to modify/configure their dial plan. Users can still choose to use the old Dial Plan in the call settings, or they can configure their dial plan in this page.\n\nThe current interface features:\n1. Name: Users can name their dial plans for identification.\n2. Rule: The rules can be typed out separately or in combination with “Type”\n3. Type: We now support the following types.\n i. Pattern: The general rule and it will not change the dial plan you configured.\n ii. Block: The rules you set in combination with this type will be blocked.\n iii. Dial Now: The rules you set in combination with this type will be dialed out once the DTMF matches the Dial Plan.\n iv. Prefix: The rules you set in combination with this type will include configured prefix automatically. If Replaced is set, your used prefix will replace the “Replaced” value.\n\n For example: If Dialed 3456, the DTMF will send 123456. See configuration below.\n\n v. Second tone: The rules you set in combination with this type will play second tone if matching the Trigger.\n4. Automatically update the configured data to the Dial Plan in Call Settings.\n5. Dial Plan Verification.\n\nNote:\n1. This feature is not supported in any format of config files.\n2. This feature does not have order verification for the dial plan; it will not tell you if your dial plan is being blocked by other dial plans.\n3. When you input dial plan from Call Settings, it will not automatically choose a type for you. The default type is Pattern.\n4. Entering Dial Plan from Call Settings → Dial Plan will cause bypassing the verification.\n\nMULTICAST LISTENING ADDRESS LIST\n\n• Web Configuration\n\nThis option can be found under device web UI → Settings → Programmable Keys → Physical Multi-Purpose Keys → Mode → Multicast Listen Address.\n\n• Functionality\nAllow users to access and configure multicast listening address list from LCD.\n\n**SEARCH BAR SUPPORT**\n\n- **Functionality**\n\nNow the users can search their contacts using alphabets in the exact mode which allows them to find their contacts even if they forget the numbers. Also, phone supports quick search which uses T9 (Text on 9 keys) implementations. (Eg: “5” key on the keypad stands for J,K,L).\n\nQuick search example:\n\n\n\nExact Search example:\n\n\n\n**WEATHER CONFIGURATION FROM LCD MENU**\n\n- **Functionality**\n\nThis feature allows users to configure their weather.\nNEW MPK MODE FOR FORWARD, DND, REDIAL, SMS AND PAGING\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Settings → Programmable Keys → Physical Multi-Purpose Keys Settings → Mode.\n\n• **Functionality**\n\nAllow users to use DND, Redial, Forward with one press on MPK.\n\n**SHORTCUT (HOLD+UP) TO FACTORY FUNCTIONS SETTING**\n\n• **Functionality**\n\nThis improvement allow users to access factory functions setting by simply pressing HOLD and UP keys at the same time. This setting can be also found under LCD Menu → System → Factory Functions.\nACTION URI SUPPORT\n\n- Web Configuration\n\nThis option can be found under device web UI → Network → Remote Control.\n\nRemote Control\n\n- Functionality\n\nThis feature allows users to remotely control their device for simple actions such as make call, hold, end call and etc. This is done through either URI command or SIP NOTIFY. (I.E. http://[IPaddress]/cgi-bin/api-phone_operation?passcode=[PASSWORD]&cmd=acceptcall. This command is for accepting the incoming call)\n\n- New Pvalue\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P32050</td>\n<td><New Pvalue> Action URI Support</td>\n<td>Value = 0; Disabled</td>\n<td>Enabled</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1; Enabled</td>\n<td></td>\n</tr>\n<tr>\n<td>P32051</td>\n<td><New Pvalue> Remote Control Pop</td>\n<td>Value = 0; Disabled</td>\n<td>Enabled</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Value = 1; Enabled</td>\n<td></td>\n</tr>\n</tbody>\n</table>\nTRANSFER MODE VIA VPK\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Call Features → Transfer Mode via VPK.\n\n<table>\n<thead>\n<tr>\n<th>Transfer Mode via VPK</th>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>0</td>\n<td>Blind Transfer</td>\n</tr>\n<tr>\n<td></td>\n<td>1</td>\n<td>Attended Transfer</td>\n</tr>\n<tr>\n<td></td>\n<td>2</td>\n<td>New Call</td>\n</tr>\n</tbody>\n</table>\n\n- **Functionality**\n\nThis option allows users to configure “Transfer” VPK to do either Blind or Attended Transfer. They can also set their Transfer key to make a new call with the configured number.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8390</td>\n<td><New Pvalue> Transfer Mode via VPK</td>\n<td>Value = 0; Blind Transfer Value = 1; Attended Transfer Value = 2; New Call</td>\n<td>Blind Transfer</td>\n</tr>\n</tbody>\n</table>\n\nCUSTOM RINGTONE FOR INDIVIDUAL CONTACT\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Phonebook → Contacts → Edit Contact → Ring Tone.\n• **Functionality**\n\nThis option allows users to set their contacts with individual Ringtone. If not set, phone will use default ringtone.\n\nNote: Currently only .wav file is supported. Users can upload their customized .wav files as custom ringtones. (File size and format are restricted to 500KB or less.)\n\n**UCM CALL CENTER FEATURE**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Accounts → Account # → Special Feature--UCM Call Center.\n• **Functionality**\n\nThis feature allows phone to log in/log out UCM call queue from phone side.\nNote: This feature requires UCM firmware support which is not publicly released yet. Please check UCM release notes for upcoming release that adds support for this feature.\n\n• **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P424</td>\n<td>Special Feature</td>\n<td><New Value> Value = 120; UCM Call Center</td>\n<td>Standard</td>\n</tr>\n</tbody>\n</table>\n\n**USER SPACE STATUS**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Status → System Info.\n\n**User Space**\n\n```\nUser Space Used 2%\nDatabase Status NORMAL\n```\n\n• **Functionality**\n\nThis feature shows how many percentage space has been used.\nIf the database is in healthy status, a green bar with “NORMAL” will be on the screen.\nIf the database is broken, there will be a red bar with “ABNORMAL” warning. Besides, a “recover” key will show below the status bar. Once user clicks the “recover” key, phone will reset database to a new one and reboot.\n\nSUPPORT FOR CISCO DISCOVERY PROTOCOL (CDP)\n\n- **Web Configuration**\n \n This option can be found under device web UI → Network → Advanced Settings → Enabled CDP.\n\n- **Functionality**\n \n Allow user to enable/disable CDP feature which will allow the phone to receive CDP packets from the uplink. When CDP feature is enabled, make sure VLAN is also configured accordingly. It will need reboot to take effect for both enabling and disabling this feature.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P22119</td>\n<td><New Pvalue> Enable CDP</td>\n<td>Value = 0; Enabled Value = 1; Disabled</td>\n<td>Enabled</td>\n</tr>\n</tbody>\n</table>\n\nSUPPORT TO DOWNLOAD USER CONFIGURATION\n\n- **Web Configuration**\n \n This option can be found under device web UI → Maintenance → Upgrade and Provisioning → Download User Configuration.\n• **Functionality**\n\nThis feature “Download User Configuration” allows users to download part of the configuration that does not include any personal settings like Username and Passwords. Also, it will include all the changes manually made by user from web UI, or config file uploaded from “Upload Device Configuration”, but not include the changes from the server provision via TFTP/HTTP/HTTPS.\n\n**ERROR MESSAGE SUPPORT ON LCD SCREEN**\n\n• **Functionality**\n\nWhen user changes configuration settings on LCD and the configuration cannot be applied for any reason, LCD screen will pop up a window displaying an error message with information explaining why the configuration cannot be saved.\n\nNote: Possible error types could be Security, Privilege, PValue Validation, etc.\n\n**VIRTUAL VOICE MAIL**\n\n• **Functionality**\n\nWith this feature, phone downloads the voicemail into a .wav file and stores it on the phone for the user. Users do not have to dial feature codes and go to the Broadsoft server to listen to their voicemails. Also, users can pause/resume their voicemail message at any time they want.\n\nNote: Currently this feature works with Broadsoft server.\n\n**DATE AND TIME DISPLAY ON SCREENSAVER**\n\n• **Web Configuration**\n\nThis option can be found under device web UI → Settings → Preferences → LCD Display → Show Date and Time.\n\n• **Functionality**\nThis option allows users to see time, dates, and weather on phone’s screensaver mode.\n\n- **New Pvalue**\n\n<table>\n<thead>\n<tr>\n<th>Pvalue</th>\n<th>Description</th>\n<th>Value Range</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P8441</td>\n<td><New Pvalue> Show Date and Time</td>\n<td>Value = 0; No Value = 1; Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\n**DEFAULT RINGTONE**\n\n- **Web Configuration**\n\nThis option can be found under device web UI → Settings → Preferences → Ring Tone → Default Ring Tone.\n\n- **Functionality**\n\nThis option allows users to set Default Ring tone as their Global ring tone. Please note the ring tone set in individual accounts have higher priority to this setting. If users want the default ring tone to be used globally, they need to set the ring tone of each account to Default Ring Tone; otherwise, it will be whichever the ring tone you set. The Priority goes as: Contact Ring Tone > Account Ring Tone > Default Ring Tone."}}},{"rowIdx":164,"cells":{"id":{"kind":"string","value":"a0399b2ddcda6e5562c1a6c62895fc9d999b9388"},"text":{"kind":"string","value":"University of Southern Queensland\nFaculty of Engineering and Surveying\n\nCentreline Tools Upgrade\n\nA dissertation submitted by\n\nRobert William Thompson\n\nin fulfilment of the requirements for\n\nCourses ENG4111 and 4112 Research Project\n\ntowards the degree of\n\nGraduate Diploma of Geomatic Studies (Geographic Information Systems)\n\nSubmitted: October, 2008\nAbstract\n\nThe state-controlled road network is Queensland's single largest built community asset and the Department of Main Roads is responsible for its operation and the delivery of projects for its enhancement and maintenance. The majority of road related asset data is stored in linear referenced format, which cannot be represented spatially in a MapInfo GIS environment without translation.\n\nCentreline Tools is a MapBasic utility developed by Main Roads to translate between linear and spatial forms of data. Centreline Tools performs dynamic segmentation operations not supported by native MapInfo, and enables linear referenced road asset data to be viewed and analysed in MapInfo with coordinated-based vector data.\n\nThis dissertation describes the development of an upgraded version of the Centreline Tools utility. A mixture of existing and new ideas was incorporated into the development process while the original look and feel were retained for operational consistency. Several long standing issues with its operation were resolved and reporting has been improved. Modifications to the organisation and structure of the upgraded version have resulted in a more maintainable product. Early evidence suggests that the majority of the benefits expected from the project have been realised.\n\nAn iterative implementation of the System Development Life Cycle methodology was adopted for the project and proved to be very effective. This strategy facilitated extended testing of the logic and procedures at the core of the upgrade and allowed feedback to be evaluated and integrated into subsequent development releases.\nThe Centreline Tools upgrade delivered by this project has now been released into production.\nLimitations of Use\n\nThe Council of the University of Southern Queensland, its Faculty of Engineering and Surveying, and the staff of the University of Southern Queensland, do not accept any responsibility for the truth, accuracy or completeness of material contained within or associated with this dissertation.\n\nPersons using all or any part of this material do so at their own risk, and not at the risk of the Council of the University of Southern Queensland, its Faculty of Engineering and Surveying or the staff of the University of Southern Queensland.\n\nThis dissertation reports an educational exercise and has no purpose or validity beyond this exercise. The sole purpose of the course pair entitled “Research Project” is to contribute to the overall education within the student’s chosen degree program. This document, the associated hardware, software, drawings, and other material set out in the associated appendices should not be used for any other purpose: if they are so used, it is entirely at the risk of the user.\n\nProf Frank Bullen\nDean\nFaculty of Engineering and Surveying\nCertification\n\nI certify that the ideas, designs and experimental work, results, analyses and conclusions set out in this dissertation are entirely my own effort, except where otherwise indicated and acknowledged.\n\nI further certify that the work is original and has not been previously submitted for assessment in any other course or institution, except where specifically stated.\n\nRobert William Thompson\nStudent Number: 0031210039\n\nSignature: \n\nDate: October 2008\nAcknowledgments\n\nI would like to take this opportunity to thank my project supervisor, Mrs Xiaoye Liu, University of Southern Queensland, for her advice and support throughout this project.\n\nI would also like to thank the following people for the valuable feedback they provided and acknowledge their contribution to the project:\n\n- Alex Appleman, Department of Main Roads, Townsville.\n- Debra Barney, Department of Main Roads, Bundaberg.\n- Maxine Maguire, Department of Main Roads, Townsville.\n- Stephen Clague, Department of Main Roads, Mackay.\n- Tony Martin, Department of Main Roads, Cairns.\n\nFinally, I would like to thank the staff of Geospatial Technologies Branch, Department of Main Roads for their continued support during the project, in particular:\n\n- Tony Bitz, Director (Geospatial Technologies), and\n- Richard Jeffries, Senior Advisor (GIS).\n# Table of Contents\n\nAbstract ........................................................................................................................................... i \nCertification ..................................................................................................................................... iv \nAcknowledgments ............................................................................................................................ v \nList of Figures ..................................................................................................................................... x \nList of Tables ..................................................................................................................................... xii \nGlossary ............................................................................................................................................ xiii \n\n## CHAPTER 1 INTRODUCTION ................................................................................................. 1 \n1.1 Background ............................................................................................................................... 1 \n1.2 Aims and Objectives .................................................................................................................. 2 \n1.3 Expected Benefits ..................................................................................................................... 3 \n1.4 Dissertation Overview .............................................................................................................. 4 \n\n## CHAPTER 2 LITERATURE REVIEW ....................................................................................... 5 \n2.1 Introduction ................................................................................................................................. 5 \n2.2 Spatial Referencing .................................................................................................................... 5 \n2.3 Linear Referencing ..................................................................................................................... 6 \n2.4 Dynamic Segmentation ............................................................................................................ 7 \n2.5 Dynamic Segmentation in Centreline Tools ............................................................................ 8 \n2.6 Terminology ............................................................................................................................... 13 \n\n## CHAPTER 3 METHODOLOGY ................................................................................................. 15 \n3.1 Overview ................................................................................................................................... 15 \n3.2 Preliminary Investigation .......................................................................................................... 17 \n3.3 System Analysis ......................................................................................................................... 18 \n3.3.1 Functional Requirements ...................................................................................................... 18 \n3.3.2 Additional Requirements ....................................................................................................... 19\n4.6.2 Textual Input................................................................. 53\n4.6.3 Spatial Input................................................................. 55\n4.7 System Testing................................................................. 55\n 4.7.1 Introduction.............................................................. 55\n 4.7.2 Development Testing............................................... 56\n 4.7.3 Operational Testing................................................ 60\n4.8 Conclusions................................................................. 62\n\nCHAPTER 5 RESULTS............................................................. 63\n 5.1 Introduction................................................................. 63\n 5.2 Linear Reference at a Point.......................................... 63\n 5.3 Find a Linear Reference............................................. 65\n 5.4 Process Table of Linear References............................. 68\n 5.5 Process Table of Points............................................... 71\n 5.6 Section Between Points.............................................. 73\n 5.7 Section Between Linear References......................... 76\n 5.8 Save Labels................................................................. 79\n 5.9 Clear/Remove Labels................................................ 80\n 5.10 About Centreline Tools........................................... 80\n 5.11 Exit.............................................................................. 81\n\nCHAPTER 6 CONCLUSIONS.................................................. 82\n 6.1 Introduction................................................................. 82\n 6.2 Benefits........................................................................ 83\n 6.3 Future Work................................................................. 84\n 6.4 Conclusions................................................................. 85\n\nREFERENCES........................................................................ 86\nAppendix A – Project Specification........................................ 89\nAppendix B – Centreline Tools Definition File.................... 91\nAppendix C – Procedure Structure Charts.......................... 96\nAppendix D – Function FindReferenceSegments()............... 104\nAppendix E – Example Test Data........................................ 107\nAppendix F – Linear References at Specified Points.......... 110\nAppendix G – Linear References Located.......................... 112\nAppendix H – Dynamic Segmentation............................... 114\nAppendix I – Linear Referencing....................................... 117\nAppendix J – Section Defined by Spatial Coordinates.......... 120\nList of Figures\n\nFigure 2.1 – Spatial Objects of sc_roads................................................................. 9\nFigure 2.2 – Attributes of sc_roads..................................................................... 9\nFigure 2.3 – Road Structure and Direction........................................................... 12\nFigure 2.4 – Example sc_roads Polylines............................................................ 14\nFigure 3.1 – System Development Life Cycle.................................................... 16\nFigure 3.2 – Original Centre Line Tools Toolbar............................................... 19\nFigure 3.3 – Main Roads MapInfo Menu............................................................. 27\nFigure 3.4 – Main Roads Menu Customisation Dialog......................................... 28\nFigure 3.5 – Menu Selection of Centreline Tools............................................... 28\nFigure 4.1 – Code Modules Used in Centreline Tools......................................... 31\nFigure 4.2 – Definition Statement for the SegmentType Data Type.................. 34\nFigure 4.3 – Search Area Intersections with Road Segments............................ 35\nFigure 4.4 – Reference Point on a Single Carriageway....................................... 36\nFigure 4.5 – Reference Point at an Intersection............................................... 37\nFigure 4.6 – Reference Point on Multiple Roads.............................................. 37\nFigure 4.7 – End of Road Segment................................................................. 38\nFigure 4.8 – Constant Definitions Representing Direction.............................. 40\nFigure 4.9 – Circle Intersection with a Link Object......................................... 42\nFigure 4.10 – Segment Object End Node Assignment...................................... 43\nFigure 4.11 – Search Area Intersection with a Segment Object......................... 44\nFigure 4.12 – Overlap Object from Intersection.............................................. 44\nFigure 4.13 – Intersecting Circle Objects.......................................................... 44\nFigure 4.14 – Polyline Joining Circle Intersect Points........................................ 45\nFigure 4.15 – Intersect Point in the Segment Object.......................................... 45\nFigure 4.16 – Spatial Debugging Environment................................................ 57\nFigure 4.17 – Node Number Variable Debugging Output\nFigure 4.18 – Expanding Search Area Debugging Output\nFigure 4.19 – Link Intersection Debugging Output\nFigure 5.1 – Centreline Tools V5.0 Toolbar\nFigure 5.2 – Entry Dialog for Linear References\nFigure 5.3 – Verification of Road Extents\nFigure 5.4 – Linear Reference Entry Error Messages\nFigure 5.5 – Selection Dialog for Carriageway Options\nFigure 5.6 – Selection Dialog for an Input Table of Linear References\nFigure 5.7 – Selection Dialog for an Output Linear Reference Table\nFigure 5.8 – Dynamic Segmentation Configuration Dialog\nFigure 5.9 – Selection Dialog for an Input Table of Point Objects\nFigure 5.10 – Selection Dialog for an Output Points Table\nFigure 5.11 – Defining a Section Between Coordinates\nFigure 5.12 – Error Messages for a Section Defined by Coordinates\nFigure 5.13 – Processing Options for a Section on a Single Carriageway\nFigure 5.14 – Entry Dialog for a Section Defined by Linear References\nFigure 5.15 – Error Messages for a Section Defined by Linear References\nFigure 5.16 – Processing Options for a Section on Multiple Carriageways\nFigure 5.17 – Selection Dialog to Save the Centreline Tools Table CT_Data\nFigure 5.18 – The ‘About Centreline Tools’ Dialog\nList of Tables\n\nTable 2.1 – Attributes of sc_roads used in Dynamic Segmentation ....................... 10\nTable 4.1 – Versions of Centreline Tools Released .............................................. 60\nTable 5.1 – CT_Data Attributes for Specified Spatial Locations ......................... 65\nTable 5.2 – CT_Data Attributes for Specified Linear References .......................... 67\nTable 5.3 – CT_Data Attributes for a Section Defined by Coordinates .................. 76\nTable 5.4 – CT_Data Attributes for a Section Defined by Linear References .......... 78\n# Glossary\n\n<table>\n<thead>\n<tr>\n<th>Abbreviation</th>\n<th>Definition</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ARMIS</td>\n<td>A Road Management Information System</td>\n</tr>\n<tr>\n<td>Chainage</td>\n<td>Driven distance along a road from its start point</td>\n</tr>\n<tr>\n<td>GIS</td>\n<td>Geographic Information System</td>\n</tr>\n<tr>\n<td>GIS&T</td>\n<td>Geographic Information Science & Technology</td>\n</tr>\n<tr>\n<td>GPS</td>\n<td>Global Positioning System</td>\n</tr>\n<tr>\n<td>Line</td>\n<td>A MapInfo vector object with two nodes, one at each end</td>\n</tr>\n<tr>\n<td>Link</td>\n<td>Component of a MapInfo vector polyline between two nodes</td>\n</tr>\n<tr>\n<td>LRS</td>\n<td>Linear Referencing System</td>\n</tr>\n<tr>\n<td>MapBasic</td>\n<td>MapBasic Version 8.0</td>\n</tr>\n<tr>\n<td>MapInfo</td>\n<td>MapInfo Professional Version 8.0/9.01</td>\n</tr>\n<tr>\n<td>MR</td>\n<td>Queensland Department of Main Roads</td>\n</tr>\n<tr>\n<td>Node</td>\n<td>The end point of a link or line</td>\n</tr>\n<tr>\n<td>Point</td>\n<td>Spatial object represented by a x, y coordinate pair</td>\n</tr>\n<tr>\n<td>Polyline</td>\n<td>A connected sequence of links that is not closed</td>\n</tr>\n<tr>\n<td>Portion</td>\n<td>Part of a segment object occurring within a road section</td>\n</tr>\n<tr>\n<td>Reference Point</td>\n<td>Point of known location on the road network</td>\n</tr>\n<tr>\n<td>REFLEN</td>\n<td>Attribute for driven length of a road segment</td>\n</tr>\n<tr>\n<td>REFOFFSET</td>\n<td>Attribute for chainage at the start of a road segment</td>\n</tr>\n<tr>\n<td>RII</td>\n<td>Road Information Integrator</td>\n</tr>\n<tr>\n<td>RIP</td>\n<td>Roads Implementation Program</td>\n</tr>\n<tr>\n<td>RP</td>\n<td>Reference Point</td>\n</tr>\n<tr>\n<td>RRS</td>\n<td>Road Reference System</td>\n</tr>\n<tr>\n<td>SAS</td>\n<td>Spatial Application Suite</td>\n</tr>\n<tr>\n<td>SCALEFACTOR</td>\n<td>Attribute for conversion between object length and chainage</td>\n</tr>\n<tr>\n<td>SDLC</td>\n<td>System Development Life Cycle</td>\n</tr>\n<tr>\n<td>Term</td>\n<td>Definition</td>\n</tr>\n<tr>\n<td>--------</td>\n<td>-------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>Section</td>\n<td>Part of a particular road between two liner references or points</td>\n</tr>\n<tr>\n<td>Segment</td>\n<td>Part of a particular road between two RPs</td>\n</tr>\n<tr>\n<td>SQL</td>\n<td>Structured Query Language</td>\n</tr>\n</tbody>\n</table>\nCHAPTER 1\nINTRODUCTION\n\n1.1 Background\n\nThe state-controlled road network consists of approximately 33,500 kilometres of public roads and 2,838 bridges, and is Queensland’s single largest built community asset (Department of Main Roads 2007). Responsibility for the operation of the road network and the delivery of projects for its enhancement and maintenance lies with the Department of Main Roads. In order to meet this obligation, Main Roads requires the capacity to store and manipulate large volumes of road network related data.\n\nHistorically, Main Roads has stored road asset data in departmental databases in linear referenced format, in which the location of an entity or event is described as a measurement along a specified road. However, linear references are textual descriptions and cannot generally be represented spatially in a Geographic Information System (GIS) without some form of translation. Such translations require a conversion between linear reference descriptions and geospatial coordinates and involve a process known as dynamic segmentation.\n\nGeographic Information Science and Technology (GIS&T) is widely used in Main Roads, most commonly in a MapInfo Professional desktop environment. In addition to out-of-the-box MapInfo, the department utilises a suite of custom-built tools and utilities developed in-house in MapBasic, MapInfo’s development language. This suite of tools, referred to internally as the Spatial Application Suite (SAS), enhances and extends the spatial capability of MapInfo in the department and supports a number of\nbusiness operations and processes. One important member of this suite performs a number of operations based on dynamic segmentation, which are not available in native MapInfo Professional. This utility is known as Centreline Tools.\n\nThe dynamic segmentation capabilities of Centreline Tools enable linear referenced road asset data to be viewed and manipulated in a GIS environment with regular spatial data such as the road centreline, cadastre, aerial photography and satellite imagery.\n\nActivity logging implemented to monitor usage of the SAS indicates that there are approximately one thousand (1000) users of MapInfo Professional within Main Roads. Activity logs also indicate that many of these users load Centreline Tools on a regular basis, suggesting that it performs an important role in supporting Main Roads business operations.\n\nCentreline Tools was originally released for use in Main Roads circa 1998. Since that time it has received very little maintenance, contributing to an apparent gradual degradation of operational reliability and performance in recent years. In order to ensure the continued availability of Centreline Tools, the issues impacting on its declining reliability needed to be addressed.\n\n1.2 Aims and Objectives\n\nThe aim of this project was to upgrade the Centreline Tools utility.\n\nSpecifically, the objectives of the project were to upgrade the most regularly used utility operations, which involved:\n\n- determining the linear reference of a specified coordinate based location,\n- finding the coordinate based location of a specified linear reference,\n- creating coordinate based spatial objects representing the linear references contained in a specified MapInfo input table, and\n- determining the linear references representing the point objects contained in a specified MapInfo input table.\nSupporting functionality enabling the display and manipulation of data generated by these operations was also to be upgraded.\n\nAdditional objectives, while desirable, were not initially considered to be possible within the time and resource constraints of this project, but would be considered if time permitted. These involved:\n\n- upgrading the remaining operations that generate spatial objects representing sections of the road network defined by specified start and end points or linear references, and\n- improving the reporting capabilities of the utility in relation to the outcome of processes performed on MapInfo tables.\n\n1.3 Expected Benefits\n\nIt was expected that an upgrade of Centreline Tools would deliver a number of operational and organisational benefits to the department.\n\nIn an operational context, benefits might include:\n\n- the correction of some long standing issues with the utility’s operation,\n- improved reliability, consistency and dependability,\n- simpler to use, less ambiguous user interface dialogs,\n- improved reporting capabilities, and\n- increased flexibility in linear referenced data format selection.\n\nIt was hoped that the delivery of these benefits would enhance useability and improve user confidence in the utility. As well as benefiting regular users, flow-on effects might include an increase in the number of district officers prepared to utilise dynamic segmentation as a means to display and manipulate linear referenced data in a GIS environment.\n\nFrom an organisational perspective, it was expected that an upgraded Centreline Tools would be easier to maintain, saving time and resources for the department. It would also make the development of enhancements and extensions a more feasible proposition.\n1.4 Dissertation Overview\n\nChapter 1, this chapter, provides some background information and introduces the aims and objectives of the project, together with a summary of the expected benefits.\n\nChapter 2 reviews the concepts and technologies that underpin dynamic segmentation. The relationship between Centreline Tools and the vector-based representation of the state-controlled road network known as 'sc_roads' is described.\n\nChapter 3 outlines the methodology adopted for the project and describes the design strategies employed for the implementation of dynamic segmentation.\n\nChapter 4 covers the development phase of the project and includes a description of the strategies used for testing and significant coding issues encountered.\n\nChapter 5 presents a detailed description of the operation and behaviour of the upgraded version of Centreline Tools.\n\nChapter 6 offers some concluding remarks together with an assessment of the benefits derived from the project and the potential for further work.\nCHAPTER 2\nLITERATURE REVIEW\n\n2.1 Introduction\n\nThis chapter reviews the concepts and technologies that underpin the project.\n\nSpatial and linear referencing systems are introduced, together with the origin of, and continuing requirement for dynamic segmentation.\n\nThe chapter goes on to describe the structure of the state-controlled road network and how it is represented as a road centreline using the vector data model in MapInfo. The specific characteristics of the road centreline that support the implementation of dynamic segmentation in Centreline Tools are discussed.\n\nFinally, the terminology used throughout this dissertation to describe particular components of vector structures is explained to avoid any confusion with common usage.\n\n2.2 Spatial Referencing\n\nGeographic Information Systems (GIS) commonly use the vector data model to represent geographic features. In the vector data model, two-dimensional x, y coordinates are used to store the shape of spatial entities (Korte 2001). That is, a point feature such as a road sign or light pole is represented by a single x and y coordinate\npair. A linear feature such as a road or river is represented by a continuous string of x and y pairs (Davis 1996). The vector data model works well for features with static boundaries (ESRI 2002).\n\nUsing coordinate systems to locate features on the surface of the earth in this way is known as spatial referencing (Kothuri, Godfrind & Beinat 2004).\n\n2.3 Linear Referencing\n\nSpatial coordinates are not the only way to locate objects. Data related to linear features such as roads are often collected and referred to on the basis of a relative position on the road. That is, a location on a linear feature can be described by a measure value such as distance, with respect to some known point on the feature such as its start point. This type of location referencing using a measure is called a Linear Referencing System (Kothuri, Godfrind & Beinat 2004) (LRS). For example, the description ‘55 kilometres along road 12A’ uniquely describes a location in space without the use of geographic coordinates. This is a very efficient way of storing information related to linear structures such as road networks. An interesting aspect of linear referencing is that a two-dimensional linear network is reduced to a one-dimensional linear list (Longley et al. 2005). Linear referencing therefore underpins an important model for the collection and storage of information by agencies responsible for the management of linear networks.\n\nThe Queensland Department of Main Roads employs a specific implementation of linear referencing known as the Road Reference System (RRS) as a basis for the storage and management of road asset information (Department of Main Roads, unpub.). In the Road Reference System, a system of points of known location called Reference Points (RPs) enable any part of the road network to be described in terms of a road, carriageway and distance measurement. The majority of road asset data is stored in this format in a departmental database known as ARMIS (A Road Management Information System).\n\nThe use of linear referencing for the collection and storage of information related to the road network and road corridor is entirely appropriate for linear assets. However,\nanalysing, visualising, displaying and mapping these data in association with other contextual spatially referenced data can be problematic.\n\n2.4 Dynamic Segmentation\n\nDynamic segmentation was developed out of a need to geographically represent features whose locations are recorded as a relative distance along a linear feature (ESRI 2002). ESRI (2002) goes on to describe dynamic segmentation as the process of displaying linearly referenced data in a geographic environment. Kothuri, Godfrind & Beinat (2004) describe dynamic segmentation as the ability to generate points or line segments dynamically from measure information.\n\nLinear referencing in association with dynamic segmentation has some advantages over spatial referencing. Small portions along a road can have attributes attached dynamically without impacting on the base feature. That is, portions and attributes can be derived as needed at run-time (Wood 2000). In addition, this method enables multiple sets of attributes to be associated with any portion of an existing linear feature, independent of its beginning and end. These attributes can be displayed, queried, edited and analysed without affecting the underlying linear feature’s geometry (ESRI 2002).\n\nSome GIS software packages and environments offer dynamic segmentation capabilities as a standard feature. For example, GeoMedia (Intergraph Corporation 2001), ArcGIS (ESRI 2001, 2002), and Oracle Spatial (Kothuri, Godfrind & Beinat 2004) each provides an implementation of dynamic segmentation using their own proprietary data structures and function sets. However, the MapInfo Professional software used in Main Roads has no such capability in its native form. An implementation of dynamic segmentation is therefore required to spatially represent linear referenced road asset information in the MapInfo environment.\n2.5 Dynamic Segmentation in Centreline Tools\n\nIn recognition of the importance of spatially representing linear referenced data, Main Roads has developed a number of implementations of dynamic segmentation in recent years.\n\nCentreline Tools was one such application, designed to operate within the MapInfo Professional environment. Centreline Tools, was developed in MapInfo’s development language, MapBasic and was released for use within Main Roads circa 1998.\n\nThe original version of Centreline Tools performed a number of operations based on dynamic segmentation (Department of Main Roads 1999). Centreline Tools enabled direct translation between spatial coordinates and linear references in a simple to use interactive environment. Centreline Tools also supported dynamic segmentation processing of input tables containing linear references, as well as determining the linear references for input tables of point objects. Appendix K contains the user guide for the operation of the original version of Centre Line Tools.\n\nThe implementation of dynamic segmentation in Centreline Tools was built around the properties of a specifically structured MapInfo table called sc_roads, which is a vector-based representation of the state-controlled road network.\n\nThe road network is divided into segments based on physical and structural elements such as intersections, carriageways, overpasses, underpasses and bridges. The sc_roads table contains a vector-based graphic object representing each segment of the road network. The graphic objects of sc_roads therefore collectively represent the entire state-controlled road network in its correct geospatial location. Figure 2.1 illustrates the sc_roads representation of the state-controlled road network in a MapInfo environment.\n\nEach segment of the road network is also described by the Road Reference System (RRS). In the RRS, a road segment is a section of road occurring between two Reference Points (RPs) (Department of Main Roads, unpub.). The RRS therefore provides the linear reference at the start and end point of each road segment in the road network in the form of road identifier, carriageway type and distance from the start of the road. By including these linear reference elements in the attribute set of the\nThe `sc_roads` table, a direct relationship is created between each vector object, and the RRS. The attribute set from the `sc_roads` table is displayed in Figure 2.2.\n\n\n\n\nIt is this relationship that underpins the implementation of dynamic segmentation in Centreline Tools.\n\nA number of the attributes of the `sc_roads` table contain information necessary for the dynamic segmentation process. These attributes are listed in Table 2.1 and their specific characteristics are described below.\n\n<table>\n<thead>\n<tr>\n<th>Attribute Name</th>\n<th>Attribute Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>STREET</td>\n<td>Road Identifier for the segment</td>\n</tr>\n<tr>\n<td>CARRWAY</td>\n<td>Carriageway Code (infers segment direction)</td>\n</tr>\n<tr>\n<td>REOFFSET</td>\n<td>Chainage at the start of the segment in metres</td>\n</tr>\n<tr>\n<td>REFLEN</td>\n<td>Driven length of the segment in metres</td>\n</tr>\n<tr>\n<td>CLINELEN</td>\n<td>Vector object length in metres</td>\n</tr>\n<tr>\n<td>SCALEFACTOR</td>\n<td>Measurement correction factor for the segment</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.1 – Attributes of `sc_roads` used in Dynamic Segmentation\n\n**STREET**\n\nIn the RRS, an alphanumeric code is assigned to each individual road in the road network. This code value is contained in the STREET attribute of `sc_roads` and identifies the specific road to which the segment object belongs.\n\n**CARRWAY**\n\nEvery road has an assigned direction, which is specified when the road is legally gazetted. The gazetted direction of a road is the direction in which the RRS linear reference measurement value, known as ‘chainage’ or ‘through distance’ increases. Gazetted direction is consistent over an entire road.\n\nBecause of the complex structure of the road network, some carriageway types have a direction that is opposite to, or against gazetted direction. In these carriageway types, the direction of the segment object matches the direction of the carriageway. Therefore, the RRS chainage increases in a direction opposite to the direction of the segment object. A diagrammatic representation of carriageway types and their relationship with gazetted\ndirection is presented in Figure 2.3. The *sc_roads* table represents the road network to the carriageway level only and does not include lanes.\n\nThe *sc_roads* attribute CARRWAY contains the code value representing the carriageway type of the specific road segment. This attribute therefore also represents the direction of the road segment in relation to the gazettal direction of the road to which the segment belongs.\n\n**REFOFFSET**\nThe REFOFFSET attribute of *sc_roads* contains the RRS linear measure or chainage value at the starting point of the road segment. Since chainage increases with gazettal, the start chainage of the segment will occur at the start or end point of the segment object, in object direction, depending on the carriageway type of the segment.\n\n**REFLEN**\nThe REFLEN attribute contains the actual three-dimensional length of the road segment according to the RRS. This value is known as the driven length of the segment.\n\n**CLINELEN**\nThe two-dimensional length of the vector object representing the road segment is contained in the CLINELEN attribute.\n\n**SCALEFACTOR**\nAn obvious disparity exists between the three-dimensional driven length of a road segment relative to the RRS (REFLEN), and the two-dimensional length of the MapInfo vector object representing it (CLINELEN). The SCALEFACTOR attribute contains a correction factor for this disparity. A mathematical relationship therefore exists between these three attribute values such that:\n\n\\[\n\\text{SCALEFACTOR} = \\frac{\\text{CLINELEN}}{\\text{REFLEN}}, \\quad \\text{and} \\quad \\text{REFLEN} = \\frac{\\text{CLINELEN}}{\\text{SCALEFACTOR}}.\n\\]\nFigure 2.3 – Road Structure and Direction\n\nSource: Roads Information Branch, Department of Main Roads, 2005.\n2.6 Terminology\n\nDynamic segmentation necessarily involves the processing and manipulation of the fundamental graphic objects that comprise the road centreline. As is typical of GIS software developers, MapInfo utilises a specific implementation of vector structures with its own terminology to describe graphic objects and their component elements. MapInfo Corporation (2005b) provides the following definitions of vector structure elements:\n\n- A line is an object with two nodes, one at each end.\n- A polyline is a connected sequence of lines that are not closed.\n- A node is an end-point of a line object or an end-point of a line segment that is part of a polyline.\n- A line segment is a portion of a polyline between two nodes.\n\nIt should be noted that MapInfo does not use the term ‘vertex’, commonly used in other texts such as Davis (1996), to describe the non-end points of a polyline.\n\nMapInfo uses the term ‘line segment’ to describe the straight component of a polyline between two nodes. However, the RRS refers to a ‘segment’ as that portion of the road network that lies between two Reference Points. In order to avoid confusion, therefore, for the purposes of this project the term ‘segment’ is used to describe the spatial object representing one record in the road centreline MapInfo table `sc_roads`. The term ‘link’ is substituted for ‘line segment’ and refers to the straight component of a polyline between two nodes.\n\nFigure 2.4 illustrates the structure of the polyline vector objects used in the MapInfo table `sc_roads`. In this example, `sc_roads` has been thematically mapped by carriageway type to enhance the illustration. Nodes and object direction are displayed and carriageways are labelled.\nFigure 2.4 – Example sc_roads Polylines\nCHAPTER 3\nMETHODOLOGY\n\n3.1 Overview\n\nThe methodology followed for this project is known as the System Development Life Cycle (SDLC). The SDLC is a well-established methodology developed for the analysis and design of information systems (Senn 1989; Scott et al. 1996) and involves a set of distinct phases (Scott et al. 1996). Figure 3.1 shows the various phases of the System Development Life Cycle as described by Scott et al. (1996).\n\nAn iterative implementation of the SDLC, as described by Apan (2002, p. 2.5), was chosen as the most appropriate methodology for the upgrade of Centreline Tools.\n\nInitially, the interactive operations involving single location translations between spatial coordinates and linear references were analysed, designed, developed and distributed to selected officers for testing. While this development version was being tested and evaluated, the remaining operations, which build on these fundamental processes, were analysed, designed and developed.\n\nThis agile development approach was made possible by the familiarity of the testing officers with the existing utility and its functionality, and offered the following advantages:\n\n- The logic and procedures at the core of Centreline Tools were under test for an extended period.\n- Comprehensive testing in a true operational environment was enable.\n- Experienced users with extensive local knowledge of the road network were likely to recognise erroneous calculations.\n- Users had access to the basic operations in the new version soon after they were developed.\n- Feedback from regular users of the utility would be available for consideration at a much earlier stage in the development life cycle.\n- The completed upgrade would be available more quickly overall.\n\n![System Development Life Cycle Diagram]\n\n**Figure 3.1 – System Development Life Cycle**\n\nThe main disadvantage of this approach was that some procedures might not be as well planned and functionally independent as possible in the initial iteration of the\ndevelopment cycle. This would result in some rework to maximise their useability and flexibility in subsequent iterations of the SDLC.\n\nThe following sections describe the steps taken in each phase of the SDLC.\n\n3.2 Preliminary Investigation\n\nAs an active operational system, Centreline Tools has been the subject of periodic reviews to assess its functional suitability and operational effectiveness. As a result of these reviews, a number of issues with the existing version have been known to exist for some time. The need for maintenance of the utility was therefore recognised and well overdue, and led the proposal of this project.\n\nThe most obvious problem occurred in determining the linear reference at a specified spatial location, which is the most regularly used utility operation. An incorrect chainage was usually generated on the first occasion the operation was performed. It appears that the utility calculated a chainage based on the commencement of a road segment, rather than from the start of the road. While regular users of the utility were aware of this error and worked around it, the continuation of this behaviour was clearly unacceptable.\n\nAn operational issue was identified in relation to the input of a linear reference to be translated to spatial coordinates (Martin, AM 2008, pers. comm.). A list of all available road identifiers was generated every time the operation was performed. This process demanded additional interactive selections and slowed the operation unnecessarily for regular users familiar with the road network.\n\nSeveral issues of concern related to the utility’s geocoding process. Firstly, the dialog from which input table column names representing linear reference elements were specified was ambiguous and confusing. The layout of the dialog appeared to have been modified to provide for different processing options since the original user guide was written. However, the user guide was not updated and the outcomes from several selection options were unclear. Several of the options offered did not perform as expected and several tool buttons performed no function. In addition, the options\noffered in relation to the format of linear reference elements were limited (Barney, DK, Clague, SJ & Henry, BA 2008, pers. comm.).\n\nThe utility did not provide any form of permanent feedback or status report on the success or otherwise of processes performed on input tables. This made it very difficult to locate and correct invalid data contained in input tables.\n\nOther anecdotal operational problems with Centreline Tools included inexplicable crashes, the display of copious error messages and occasional lapses into endless loops after completing a processing operation. In general terms, the performance and reliability of the utility could be described as inconsistent at best.\n\n3.3 System Analysis\n\n3.3.1 Functional Requirements\n\nThe analysis phase of the project involved specifying the functional requirements of the Centreline Tools upgrade. Since this project involved an upgrade to an existing system, the requirements of the upgrade were largely those of the existing version. In fact, retention of the existing functionality and look and feel of the utility were fundamental requirements of the project. To determine the requirements of the new version, an examination of the operations performed by the existing utility was performed.\n\nThe existing version of Centreline Tools performs a number of spatial operations designed to provide information related to the state-controlled road network in Queensland. These operations involve translation between linear referenced data in a format based on the Road Reference System (RRS) used in Main Roads, and traditional spatial data based on an earth coordinate reference system. The operations performed by the original version of Centreline Tools are detailed in a user guide (Department of Main Roads 1999).\n\nSystem operations are selected from a toolbar created when the utility is launched. The toolbar from the original version is shown in Figure 3.2.\nThe operation performed by each tool button is described in detail the original utility user guide included in Appendix L. These operations are summarised as follows:\n\n- determining the linear reference description at the location specified by a mouse click on or near the road centreline,\n- finding the spatial location on the road network represented by an input linear reference,\n- creating spatial objects representing sections of the road network occurring between two points specified by clicking the mouse in the map window,\n- creating spatial objects representing sections of the road network occurring between two specified linear references,\n- creating point and polyline spatial objects representing the linear references contained in a specified input table,\n- generating the linear references represented by point objects contained in a specified input table, and\n- displaying and optionally saving spatial objects and information generated during processing.\n\n3.3.2 Additional Requirements\n\nOne aspect of the existing system identified for improvement was the information produced during file processing operations. The status of the processing success or otherwise of a particular record is displayed in the message window during processing, but is not permanently saved. Watching for processing anomalies in large files is virtually impossible as is checking each record afterwards. It was therefore proposed to add some form of reporting capability on the status of table processing.\n\nTwo options were considered to achieve this outcome:\n\n(a) generating an additional log file, and\n\n(b) adding reporting information to the output file.\nA log file is a permanent record but still requires matching records between the log file and the processed output file to derive useful information.\n\nThe preferred option was to add a brief comment to the processed output file. The comment would then permanently reside with each processed record and would be instantly available.\n\n### 3.3.3 Constraints\n\nCentreline Tools is an operational departmental utility. As such, constraints did exist in relation to the functional and operational requirements of the upgrade.\n\nMapInfo Professional is the desktop GIS environment currently in use in Main Roads. As a result, the department has made a significant investment over time in software licence fees, building staff capability and developing customised utilities, of which Centreline Tools is one example. To change would involve re-training staff and redeveloping tools and utilities on another platform, incurring significant costs in time and resources.\n\nCentreline Tools was originally developed in MapBasic to run in the MapInfo environment. It is a widely used utility and performs an important function in the context of Main Roads business.\n\nA number of constraints therefore applied to the Centreline Tools upgrade project, including the following:\n\n- Development in the MapBasic language was mandatory.\n- Continued operation with the MapInfo road centreline product *sc_road* was mandatory.\n- The existing general look and feel of interface dialogs and tool buttons was to be maintained for reasons of operational consistency.\n- All existing functionality was to be retained.\n- Access via the customised Main Roads Menu was to be retained.\n- The existing method of distribution as an executable .mbx file was to remain the same.\n• Existing library procedures developed for other SAS components could be used.\n• For strategic and budgeting purposes, the project was classified within the department as system maintenance.\n\n3.4 System Design\n\n3.4.1 Introduction\n\nIn the initial phase of system design, the source code of the existing version of Centreline Tools was examined. The purpose of this was twofold. Firstly, it was necessary to assess the feasibility of redeveloping the utility based on the existing design. Secondly, if this was not the case, to determine if any existing design elements could be used in the new version.\n\nThis examination revealed that the logic of the program was convoluted and difficult to follow. The code appeared overly complex and contained very little useful explanatory documentation. A decision was therefore made early in the process that it would be more time-effective to redesign and redevelop the utility than to attempt to re-code the existing design. A redesigned utility would also produce a more reliable and maintainable product into the future.\n\nIn spite of the decision to redesign the utility, several significant elements of the existing design were retained in the new version. These design elements are identified in the following sections.\n\n3.4.2 Design Specifications\n\nThe design of the Centreline Tools upgrade surrounds the structure and properties of the MapInfo road centreline table ‘sc_roads’. As discussed in Chapter 2, a relationship exists between sc_roads and the linear Road Reference System such that values linking the vector objects to the RRS are contained in, or can be derived from, the attributes of the sc_roads table.\nIn order to satisfy the functional requirements of the Centreline Tools upgrade, it was necessary to consider several fundamental processes in the system design. These are:\n\n- to determine the spatial location of the point on the road network at which a given linear reference occurs,\n- to determine the linear reference at the point on the road network represented by a given spatial location, and\n- to expand these single location based processes for use on sections of the road network.\n\nThe remaining functional requirements involving interactive program input and administrative tasks related to generated data had to be developed for the upgrade, but did not require any significant redesign.\n\n### 3.4.3 Determining the Spatial Location of a Given Linear Reference\n\nThe initial phase of the design was concerned with identifying the specific road centreline segment in the *sc_roads* table in which a given linear reference occurs.\n\nIn order to describe a unique location on the road network, a linear reference must contain, at a minimum, the identity of the road and a measurement along the road from some point of reference, usually the starting point of the road. This measurement is known as ‘chainage’ or ‘through distance’. Where the form of the road is more complex, a carriageway code is also necessary to describe a unique location.\n\nThe attribute values in the *sc_roads* table therefore provide the key to the identification of the required segment, as follows:\n\n- The identity of the road is contained in the STREET attribute.\n- The carriageway code is contained in the CARRWAY attribute.\n- The chainage at the start of the segment is contained in REFOFFSET.\n- The chainage at the end of the segment is equal to the start chainage plus the driven length of the segment (*REFOFFSET + REFLEN*).\n\nIn combination, these attribute values provide the identity of the specific centreline segment within which the given linear reference occurs.\nOnce the required segment has been identified, the next step in the design strategy involves identifying the ‘link’ in the segment object within which the chainage component of the given linear reference occurs. A link is the straight section of the vector object between two adjacent nodes (see Chapter 2 for a description of MapInfo vector structures).\n\nThe methodology involves traversing the segment object programmatically, one link at a time from its starting point. Since the chainage at the segment start point is known, an accumulating chainage can be calculated by converting the length of each link to chainage using the SCALEFACTOR attribute (see Chapter 2 for a description of the disparity between driven length and object length). When the accumulating chainage value exceeds the given chainage, the given chainage occurs somewhere in the current link. The given chainage therefore occurs in the segment at a distance along the link equal to the difference between the given chainage and the accumulated chainage at the start of the current link. This value is the remaining chainage.\n\nThe location of the given linear reference can be represented by a circular vector object centred at the start node of the current link, with a radius equal to the remaining chainage. The given linear reference will occur at the intersection point between the circular object and the segment object.\n\nThe intersection point is then be used to create a spatial point object to represent the location of a linear reference.\n\nOne significant issue complicates the design strategy described above. As described in Chapter 2, chainage increases in the direction in which roads are gazetted. However, some carriageway types, and hence the vector objects representing them, have a direction that is opposite to, or against road gazetted direction. In these cases, vector object nodes increase in number against gazetted. Therefore, to traverse these segment objects in the direction of gazetted requires commencing at the last node, and addressing the nodes in descending order towards node number one. Object direction and node numbering were therefore important considerations in the development process.\n3.4.4 Determining the Linear Reference of a Given Spatial Location\n\nIn Centreline Tools, a given spatial location is represented by a point object. However, the point object may or may not be coincident with a road centreline segment, making identification of the required segment problematic.\n\nThe design solution used to identify the segment object proximal to the given point was retained from the existing version. An expanding circular area object, centred at the spatial coordinates of the given point object was utilised. As the area object expands, it will intersect with a road segment object, if the given point at its centre is in the proximity of the road network.\n\nOnce the required segment object has been identified, the location in the segment that is closest to the given point must be found. At this stage the design strategy for the upgrade diverged significantly from the original version. The new design involves the construction of two circular geometric objects of equal radii, centred at the intersection points of the expanding area object and the centreline segment object. A line object is then created between the intersection points of the two circular objects. This line must intersect the segment object.\n\nIt then remains to sequentially traverse the segment object links to identify the link that is intersected by the constructed line object. Once this link is identified a new node can be placed in the segment object at the intersection point. The length of the segment object up to the new node is then measured and converted to chainage using the SCALEFACTOR correction value.\n\nThe centreline segment attribute values of road identifier (STREET) and carriageway type (CARRWAY) and then combined with the calculated chainage to provide the linear reference at the given point.\n\nA point object can then be created with the coordinates of the new node to represent the precise spatial location of the determined linear reference.\nAs in the previous section, segment object direction in relation to road gazettedal direction, and consequential sequencing of nodes significantly complicated the development of this design concept.\n\n3.4.5 Constructing Road Sections\n\nThe design strategies described above are suitable for translating between individual spatial locations and linear references. However, the specifications of Centreline Tools require the implementation of true dynamic segmentation. This involves creating spatial objects to represent sections of road as well as single locations.\n\nConstructing road sections commences with the identification of all the centreline segment objects that occur between the defined linear extents of the section. The required segments can be identified by the attribute values contained in the sc_roads table, as in the previous section.\n\nTo support the construction of spatial objects representing sections of road, the concept of a ‘portion’ was introduced. For the purposes of this project, a portion is defined as that part of an individual centreline segment object that occurs within a defined road section. A portion may therefore consist of an entire segment object, or the remains of one truncated at the chainage defining the start and or end of the road section.\n\nThe design strategies used to construct portion objects based on linear references representing the extents of a road section are similar to those described previously and involve the programmatic traversal of segment objects.\n\nAn object representing a road section is constructed by combining all the segment object portions that occur between the start and end of the defined section.\n3.5 System Development\n\nThe system development phase of the Centreline Tools upgrade project is presented in detail in Chapter 4, and describes the coding methods used to implement the design strategies introduced in the previous section.\n\n3.6 System Implementation\n\n3.6.1 Installation\n\nIn the implementation phase of the project, a completed development version of the Centreline Tools upgrade was distributed for installation and operational testing. The program executable file CT_Main.MBX was attached to an e-mail, which contained release notes and installation instructions.\n\nInstallation involved adding a new item for the Centreline Tools upgrade to the MainRoads MapInfo Menu using the Menu Customisation Dialog. This dialog is accessed from the MainRoads menu as shown in Figure 3.3. The name of the application, the directory path to the executable file and help string to appear in the MapInfo Status Bar were entered into the customisation dialog. The entry for Centreline Tools in the customisation dialog is shown in Figure 3.4. This procedure was necessary for the initial release only.\nThe installation process is completed by placing the executable file CT_Main.MBX in the network directory reserved for SAS utilities. This operation had to be repeated for each subsequent release.\n\nThe new release of Centreline Tools could then be launched by a single mouse click from the MainRoads Menu. Figure 3.5 shows how Centreline Tools appears in the MainRoads Menu, ready for selection.\nFigure 3.4 – Main Roads Menu Customisation Dialog\n\nFigure 3.5 – Menu Selection of Centreline Tools\n3.6.2 Training\n\nBecause the Centreline Tools upgrade was necessarily very similar in function and operation to the old version, very little training was required.\n\nHowever, some changes in the operation and behaviour of the upgrade did require explanation. Users were made aware of these changes in release notes that were sent with the executable .mbx file, initially to the test group, and finally to the regional GIS coordinators when the production release was distributed.\n\nAdditional information sessions are proposed in the future. A new version of the Centreline Tools user guide is also proposed.\n\n3.7 System Maintenance\n\nAs well as testing during the development phase of the project, individuals within the department were specifically requested to test development versions of the Centreline Tools upgrade in an operational environment in regional offices.\n\nThe test group was contacted regularly to assess progress, provide support and gather feedback on the operation and reliability of the development versions of the upgrade. Feedback was evaluated and subsequently incorporated into the development phase of the project.\n\nThis process resulted in the identification and correction of several programming errors and modifications to the requirements of the utility.\nCHAPTER 4\nSYSTEM DEVELOPMENT\n\n4.1 Introduction\n\nIn the system development phase of the project, several identifiable although not necessarily discrete activities were undertaken. These activities consisted of:\n\n- assessing the source code of the existing version to identify elements suitable for reuse in the upgraded version,\n- writing new MapBasic functions and sub-procedures to implement the design concepts introduced in Chapter 3, and\n- combining the new material with modified existing code to produce an upgraded version of Centreline Tools.\n\nIn reality, these activities merged into one process. The development phase of the Centreline Tools upgrade project is presented in the following sections.\n\n4.2 Program Structure\n\n4.2.1 Overview\n\nCentreline Tools is a structured collection of sub-procedures and functions written in the MapBasic language, which are loosely grouped into modules on the basis of the operation they perform. The source code modules are ‘Included’ into the main module, which is compiled directly to an executable file called CT_Main.MBX. All the modules\nused are specific to Centreline Tools, with the exception of two that contain library files used to support other SAS utilities.\n\nFigure 4.1 is an extract from the module CT_Main.MB and shows all of the program modules used in the Centreline Tools upgrade.\n\n'-------------------------------------------------------------------------------\n| Modules used in the Centreline Tools utility. |\n| See utility definition file for definitions and declarations. |\n'-------------------------------------------------------------------------------\nINCLUDE \"MapBasic.def\" '- standard MapBasic definitions\nINCLUDE \"Icons.def\" '- standard MapBasic definitions\nINCLUDE \"Menu.def\" '- standard MapBasic definitions\nINCLUDE \"CT_Def.DEF\" '- centreline utility definition file\nINCLUDE \"..\\..\\Common\\Lib ini.MB\" '- SAS ini procedure library\nINCLUDE \"..\\..\\Common\\Lib_funct2.MB\" '- SAS procedure library\nINCLUDE \"CT_CoordsToRef.MB\" '- translates input points to chainages\nINCLUDE \"CT_Debug.MB\" '- utility debugging routines\nINCLUDE \"CT_Dialogs.MB\" '- dialogs for table/process selection\nINCLUDE \"CT_DynSeg.MB\" '- manages dynamic segmentation\nINCLUDE \"CT_FindNodes.MB\" '- node finding and adding procedures\nINCLUDE \"CT_RefToCoords.MB\" '- translates input chainages to points\nINCLUDE \"CT_SectionByCoords.MB\" '- extracts a section by coordinates\nINCLUDE \"CT_SectionByRefs.MB\" '- extracts a section by linear references\nINCLUDE \"CT_Select.MB\" '- contains queries from sc_roads\n'-------------------------------------------------------------------------------\n\nFigure 4.1 – Code Modules Used in Centreline Tools\n\n4.2.2 The Definition File\n\nA new program structure was introduced for the Centreline Tools upgrade. In the existing program, procedures were generally declared in the module in which they were coded. This arrangement contributed to difficulties in following the program’s logic and caused potential compilation problems because of the order in which procedures were declared, and modules included in the main module. In addition, the MapBasic definition files MapBasic.def, Icons.def and Menu.def were included in each module.\n\nIn the upgrade, all procedures were declared in the program definition file, CT_Def.DEF with the global variable declarations and constant definitions. This strategy centralised information for easier reference during development and maintenance. It also avoided the refer-before-declare issues caused by procedure declarations in individual modules. As the modules relate only to this utility, a requirement for each module to compile independently was considered unnecessary.\nNew program constants were introduced for version identifier, release date, and road centreline table name. The use of constant values simplifies maintenance since a change to any of these values requires one change only in the definition file.\n\nThe complete Centreline Tools definition file, CT_Def.DEF is included in Appendix B.\n\n4.2.3 The Main Module\n\nWhen Centreline Tools is launched, program execution commences with the sub-procedure called Main.\n\nCalls to sub-procedures ReadInitSetup and WriteLogEntry are used in the majority of SAS utilities, and were included in the Centreline Tools upgrade. They respectively read MainRoads Menu System directories from an initialisation file into global variables for reference purposes, and write an entry to an activity log file.\n\nBecause Centreline Tools is dependent on a specific road centreline table, the function OpenClTab(), renamed and slightly modified from the existing version, was used to verify that the table sc_roads is open, or request it to be opened if it is not. The sub-procedure DisplayClTab displays sc_roads in a new MapInfo map window, if one is not open.\n\nThe most significant task to be performed by the Main sub-procedure was to construct the Centreline Tools Toolbar, from which all utility operations are launched or selected. MapBasic statements Create ButtonPad, ToolButton and PushButton were used to construct the toolbar.\n\nStructure charts for procedures developed for the Centreline Tools upgrade, including the Main sub-procedure, are included in Appendix C.\n4.3 Selecting and Filtering Road Centreline Segments\n\n4.3.1 Selecting Segments for a Linear Reference\n\nAs described in Chapter 3, identifying specific road centreline segment objects contained in the `sc_roads` table was fundamental to performing spatial to linear and linear to spatial translations.\n\nRoad centreline segments were selected using ‘Select’ statements, which are essentially a MapBasic implementation of SQL queries. Select statements produce a temporary MapInfo table containing the records that match the expression in the ‘Where’ clause of the statement. Where possible, select statements on `sc_roads` were grouped into the module CT_Select.MB.\n\nThe function FindReferenceSegments() was developed to select the road segments in which a single specified linear reference occurs. That is, segments with the specified road identifier, and having a start chainage less than or equal to the specified chainage, and an end chainage greater than or equal to the specified chainage. The use of a greater than operator (>) could not be used here because end segments (ie segments with no adjoining segments) would not be selected. The following extract from the function FindReferenceSegments() shows the MapBasic select statement:\n\n```mapbasic\nSelect * From CT_SC_ROADS\nWhere STREET = sRoadId AND\n CARRWAY = sCarriageway AND\n REFOFFSET <= fChainage AND\n REFOFFSET + REFLEN >= fChainage\nInto tblReferenceSegs Noselect\nOrder By CARRWAY, REFOFFSET\n```\n\nThis statement creates the temporary MapInfo table tblReferenceSegs which contains all the road segment records in which the chainage value in the variable fChainage occurs, including segments for multiple carriageways, if they exist.\n\nVariations on the value of the carriageway code variable sCarriageway in the function enabled the selection of segments for various combinations of carriageway types.\nSelected segments were ordered by carriageway type (CARRWAY) and segment start chainage (REFOFFSET) to facilitate processing elsewhere in the program.\n\nThe function then assigns the selected segments to a SegmentType array variable (see below). Unwanted segments are filtered out during this process. Segment filtering is discussed in Section 4.3.3.\n\nThe data type ‘SegmentType’ was introduced in the upgrade to contain a road centreline segment object and the set of attributes used in format translations. The use of a defined date type had several benefits. Firstly, it made procedures involving road segment manipulations more independent. Selected segments can be stored and passed between procedures as array variables of type SegmentType. This method avoids continual reference to selections made in other procedures, which was the method employed in the existing version. Continual reference to selection tables disrupts program continuity and is similar to the overuse of global variables. Neither strategy was favoured in the development of the upgrade.\n\nSecondly, the defined data type can potentially be used for segment selections from any road centreline table containing Road Reference System based attributes. In the event of the introduction of another road centreline product, only the select statement would need to be modified, significantly reducing future maintenance requirements. Figure 4.2 shows the type definition statement used for the SegmentType data type.\n\n```\nTYPE SegmentType\n SegObj As Object ' segment object\n SegRoad As String ' segment road identifier\n SegCway As String ' segment carriageway code\n SegStart As Float ' segment start chainage (in m)\n SegLength As Float ' segment driven length (in m)\n SegScale As Float ' segment scalefactor\nEND TYPE\n```\n\n**Figure 4.2 – Definition Statement for the SegmentType Data Type**\n\nAppendix D contains the entire function FindReferenceSegments() and illustrates the use of select statements. The function also demonstrates the use of a variable to control the selection of segments representing various combinations of carriageway types.\n4.3.2 Selecting Segments for a Spatial Location\n\nThe function FindPointSegments() was developed to select road segment objects in proximity to a specified spatial location. An expanding circular area object, centred at the coordinates of the specified location, was used to locate proximal segment objects. The area object is expanded in preset increments until it intersects a segment object, or a maximum search radius value represented by a system constant is reached. A select statement with a spatial condition in the Where clause was used as the following extract from the function FindPointSegments() shows:\n\n```\nSelect * From CT_SC_ROADS\nWhere oSearchArea Contains Part Obj\nInto tblPointSegs Noselect\nOrder By STREET, CARRWAY, REFOFFSET\n```\n\nThe select statement was placed in a loop based on the incrementing value of the search area radius. If a segment is selected, the loop is terminated. After segments are selected, the search area is expanded by one additional increment value to ensure that the intersection is not a tangential (single point) intersection. Examples of search area intersections with road segments are illustrated in Figure 4.3.\n\nIn this selection process, the road identifier is not known as it is in the selection for a linear reference, so the result table tblPointSegs might contain segments from multiple roads. The segments selected are therefore ordered by road identifier (STREET), carriageway type (CARRWAY), and segment start chainage (REFOFFSET) to assist filtering and processing for multiple roads if necessary.\nThe selected segments are then filtered and assigned to a SegmentType array variable as in the previous section.\n\n4.3.3 Filtering Selected Segments\n\nA linear reference consisting of a road identifier, carriageway code and chainage value represents a unique location on the road network (excluding lane structures). However, in some circumstances, more that one road segment satisfies the condition clauses used in the statements described in previous sections. It was therefore necessary to filter out (remove) redundant segments prior to processing.\n\nThis problem arises when a specified chainage occurs at a Reference Point (RP). When an RP occurs on a given carriageway, the end point of one segment, and at the start point of the adjoining segment are coincidental with the RP, and consequently have the same chainage value. The statement therefore selects the segment with a start chainage (REFOFFSET) equal to the specified chainage as well as the segment with an end chainage (REFOFFSET + REFLEN) equal to the specified chainage. A RP on a single carriageway road is shown in Figure 4.4. In these cases the select statement will select the segment on each side of the RP.\n\n\n\nRedundant segments are not selected at every RP. Figures 4.5 and 4.6 demonstrate how RPs can occur in different circumstances in relation to the road network. In Figure 4.5, filtering is required for Road 426. In Figure 4.6 however, no filtering would be required.\nThe use of a less than operator (<) in selections may have avoided the need for filtering. However, the less than or equal to operator (\\(\\leq\\)) was necessary to ensure that objects representing the end segments of roads were included in the selection (i.e., in situations where there is no contiguous segment, as shown in Figure 4.7).\n\nSegment filtering was implemented by assigning the first segment record in the result table to the SegmentType array variable, then testing each subsequent record against the last for road/carriageway equality, prior to assignment. Duplicates are ignored. Appendix D illustrates how segment filtering is implemented in the function FindReferenceSegments().\n\nApplying this filtering strategy ensures that the SegmentType array variable only ever contains segments with unique road and carriageway combinations.\n4.3.4 Selecting Segments for Road Sections\n\nSelections for road sections are more complex because sections may comprise multiple road segments. The selection of road segment objects that make up a specified section of road was coded into the function FindSectionSegments(), as shown in the following extract:\n\n```sql\nSelect * From CT_SC_ROADS\nWhere STREET = sRoadId AND\n CARRWAY = sCarriageway AND\n REFOFFSET + REFLEN > fSectionStart AND\n REFOFFSET < fSectionEnd '- <= includes the next segment\nInto tblSectionSegs Noselect\nOrder By CARRWAY, REFOFFSET\n```\n\nIn this statement, the less than or equal to operator (<=) is not used because it includes the next contiguous segment in the result table. The next contiguous segment is not wanted in this case.\n\nThis statement is similar to the selection for a single linear reference. However, it contains two chainage variables, fSectionStart representing the beginning of the section, and fSectionEnd representing the end of the section. All the segments occurring between the linear references defining the section are therefore selected.\n\nThe selected segments are ordered by carriageway (CARRWAY) and increasing start chainage (REFOFFSET).\nSegments representing various combinations of carriageway types were selected by varying the value of the carriageway code variable sCarriageway in the function.\n\nThe selected segments are assigned to a SegmentType array variable but filtering was not necessary because adjacent segments may be required to construct a road section.\n\n**4.3.5 Other Selections**\n\nSelect statements were also used to validate input data and extract additional information from the road centreline table `sc_roads`.\n\nThe function RoadExists() was used to verify that a named road identifier is valid, as the following extract shows:\n\n```sql\nSelect STREET From CT_SC_ROADS\nWhere STREET = sRoadId\nInto tblRoadExists Noselect\n```\n\nIf the result table tblRoadExists is empty following the selection, the road represented by the String variable sRoadId is not valid.\n\nA selection statement was used in the function RoadExtents() to acquire the minimum and maximum chainages of a named road identifier, as shown in the following extract:\n\n```sql\nSelect Min(REOFFSET) \"RoadStart\",\n Max(REOFFSET + REFLEN) \"RoadEnd\"\nFrom CT_SC_ROADS\nWhere STREET = sRoadId\nInto tblRoadExtents Noselect\n```\n\nThe aggregate functions Min() and Max() were used to find the minimum and maximum start and end chainages respectively of the entire road represented by the String variable sRoadId. The aggregate function return values are placed into the columns RoadStart and RoadEnd of the result table tblRoadExtents.\n4.4 Processing Segment Objects\n\n4.4.1 Segment Direction\n\nThe direction of road segment objects was a critical consideration in the development of the Centreline Tools upgrade. Segment direction is a function of gazettal direction and carriageway code. To facilitate the use of object direction in the code, program constants representing the direction of specific carriageway types, and the direction of segment objects in relation to gazettal direction, were retained from the existing version. Figure 4.8 is an extract from the definition file CT_Def.DEF showing the constant definitions for carriageway types and relevant object direction.\n\n```\nDEFINE CT_CWAY_BOTH \"1\" '- cway code in both directions\nDEFINE CT_CWAY_WITH_GAZ \"24ABCDEKLMXZ\" '- cway codes in gazettal direction\nDEFINE CT_CWAY_AGAINST_GAZ \"35NOPQRSTUY\" '- cway codes against gazettal\nDEFINE CT_DIR_WITH_GAZ 1 '- line direction with gazettal\nDEFINE CT_DIR_AGAINST_GAZ 2 '- line direction against gazettal\nDEFINE CT_DIR_UNKNOWN 3 '- line direction unspecified\n```\n\nFigure 4.8 – Constant Definitions Representing Direction\n\nThe function SegmentDirection() was retained from the existing version. This function, compares a given carriageway code with the String constants shown above, and returns a small integer value representing the direction of the segment object based on its carriageway type.\n\n4.4.2 Finding the Spatial Location of a Chainage\n\nThe function FindNodeAtChainage() finds the number of the node in a selected segment object at which a given chainage occurs. The required node may be a new node created by the function, or an existing node if one occurs at the chainage.\n\nThe given chainage can occur at the start point or end point of the segment, or some point in between. If the given chainage is equal to the attribute value representing the chainage at the start of the segment (REFOFFSET), the chainage occurs at the first node of the object (node number one), if the object direction is with gazettal. If the direction of the object is against gazettal, the chainage occurs at the last node (maximum node\nnumber) of the object. The number of nodes in the object is retrieved using the MapBasic function ObjectInfo(SegmentObject, OBJ_INFO_NPNTS), where SegmentObject represents the segment object and OBJ_INFO_NPNTS is a MapBasic constant.\n\nSimilarly, if the given chainage is equal to the chainage value at the end of the segment (REFOFFSET + REFLEN), the chainage occurs at the last or first object node depending on object direction.\n\nIf the given chainage occurs elsewhere within the segment, the function loops sequentially through the segment object link by link (node-node; node-node), searching for the link in which the chainage occurs. If the segment object direction is with gazettal, the loop begins at node number one and progresses in ascending node order. Otherwise it begins at the maximum node and descends towards node number one. The MapBasic function ExtractNodes() was used in the function to create an object to represent a link from two adjacent node numbers. Node number pairs are incremented or decremented in the loop to produce a sequential series of link objects.\n\nAt the beginning of each loop, the length of the current link is extracted by the MapBasic function ObjectLen(), and subtotalled to represent the length of the segment object traversed up to the current iteration of the loop. The object length traversed is converted to chainage traversed, by dividing the subtotal by the SCALEFACTOR attribute value. When the chainage traversed exceeds the given chainage, the given chainage must occur at some point within the current link of the segment object. This point occurs beyond the start of the current link, at a chainage equal to the difference between the chainage at the start of the link, and the given chainage.\n\nTo determine this point in the link object, the chainage excess beyond the segment start point is converted back to distance, this time by multiplying the excess chainage by the SCALEFACTOR attribute value. The MapBasic function CreateCircle() was used to create a circular object, centred at the first node of the current link object, with a radius equal to the excess distance. This circle object must intersect with the link object because the given chainage falls within the link. An example circle/link intersection is demonstrated in Figure 4.9.\nThe MapBasic function OverlayNodes() was then used to create another object similar to the link object, but with an additional node at the intersect point with the circle object. A new node is then be added to the segment object variable using the coordinates of the node at the intersect point. This new node in the segment object variable is the point at which the given chainage occurs. The number of the new node is the one after, or the one before the segment node used for the start of the current link object, depending on the direction of the segment object.\n\nThe loop is terminated when the required link is found and the function FindNodeAtChainage() returns the number of the new node. The spatial coordinates at the specified linear reference are therefore those of the new node in the segment.\n\n4.4.3 Finding the Chainage at a Spatial Location\n\nThe function FindNodeAtPoint() returns the node number of the node within the selected segment object that is as close as possible to the spatial location represented by a given point object.\n\nThe segment object closest to the point object is selected using the expanding area spatial selection process described in Section 4.3.2. Following the selection of an intersecting segment, the circular object known to intersect the segment is used to locate the spatial location in the segment closest to the given point object.\nThe algorithm used to implement this process was based on simple geometric construction, as would be done manually using intersecting arcs to bisect a line, and is described in the following five steps.\n\nStep 1.\nThe location of the search area is tested in relation to the segment object. Point objects are created at the coordinates of the start and end nodes of the segment object. A spatial select statement determines if one of these points falls within the search area. If so, the number of the node concerned is assigned to the function for return. In this way the given point object is effectively ‘snapped’ to an end point of the segment, as shown in Figure 4.10. Segment object direction is not a concern for this step.\n\n\n\nStep 2.\nIf neither end of the segment object falls within the search area, an object representing the portion of the segment object that is intersected, is created using the MapBasic function Overlap(). The area/segment object intersection and resulting ‘overlap’ object are illustrated in Figures 4.11 and 4.12.\n\nStep 3.\nTwo circular objects, centred at the coordinates of the end points of the ‘overlap’ object, and with radii equal to its length, are created. These circular objects, shown in Figure 4.13, must intersect because their radii are equal.\nStep 4.\nThe MapBasic function IntersectNodes() was used to create a polyline object joining the intersection points of the two circles created in the previous step. This polyline object, shown in Figure 4.14, must intersect the segment object, and does so at the point on the\nsegment that is closest to the centre of the search area, which in turn represents the\ngiven spatial location.\n\nFigure 4.14 – Polyline Joining Circle Intersect Points\n\nStep 5.\nThe intersection point between the polyline object and the segment object is located by\nlooping sequentially through the links of the segment object, starting at node number\none, searching for the link object that is intersected by the polyline object (segment\ndirection is not relevant here). The intersection point in the segment object is shown in\nFigure 4.15. The method used to loop through segment link objects was described in the\nprevious section.\n\nFigure 4.15 – Intersect Point in the Segment Object\n\nThe MapBasic function OverlayNodes() was then used to construct another polyline\nobject with a node at the intersection point between the original polyline object and the\nlink object. The spatial coordinates of this new node are stored and compared with that\nof each end of the link object. If a match occurs, the node number of the segment object\nnode providing the link is assigned to the function. Otherwise, the intersection point occurs elsewhere in the link and a new node is added to the segment object using the stored coordinates, and the new node number is assigned to the function.\n\nThe node number returned by FindNodeAtPoint() therefore represents the location within the segment object that is as close as possible to the actual location of the original point object.\n\nThe Function ChainageAtNode() determines the chainage at a given node number in a segment object. The given node can be the first node of the segment object, the last node, or any node in between. If the given node is node number one, the required chainage will be the start chainage of the segment (REFOFFSET), provided the segment object direction is with gazettal. If the direction of the object is against gazettal, the chainage at node number one will be the chainage at the end of the segment (REFOFFSET + REFLEN). This scenario is reversed if the given node is the last node of the segment.\n\nWhere the given node occurs elsewhere in the segment, the MapBasic function ExtractNodes() was used to extract the portion of the segment for which the chainage calculation is relevant. If the segment object is in gazettal direction, the portion extracted is between node number one and the given node. Otherwise, the portion is between the given node and the last node.\n\nThe length of the object extracted from the segment is measured by the MapBasic function ObjectLen(), and then converted to chainage using the SCALEFACTOR attribute, as described previously.\n\nThe chainage value at the given node is then assigned to the function and returned to the calling procedure.\n4.4.4 Constructing Sections\n\nDynamic segmentation involves the construction of spatial vector objects representing defined sections of a road.\n\nAn individual road segment object can relate to a defined section of road in a number of ways. That is, a segment object can:\n\n- begin before the start of the section and finish after the end of the section.\n- begin before the start of the section and finish at or before the end of the section.\n- begin at or after the start of the section and finish after the end of the section.\n- begin at or after the start of the section and finish at or before the end of the section.\n\nThe construction of a defined road section therefore involves identifying the part of each individual road segment object that occurs within the confines of the section. For the purposes of this project, this part of a segment object is called a ‘portion’, as discussed in Chapter 3. The function ConstructPortion() was written to construct a portion vector object from a given segment object.\n\nThe function ConstructPortion() tests for each possibility of the location of the segment in relation to the section. It determines the node numbers at the chainages defining the road section using the function FindNodeAtChainage(), described in Section 4.4.2, and the SegmentDirection() function, also described previously. Adding nodes in this function is more complicated than previously described. If a segment object is cut at both ends, a second node must be added to the segment object, necessitating a double shift in node numbers. Node numbering is further complicated by segment object direction.\n\nThe portion object is created using the MapBasic function ExtractNodes() with the node numbers representing the section start and end points. The constructed portion is then assigned to the function ConstructPortion().\n\nA road section is constructed by applying the function ConstructPortion() to each of the segment objects selected for the defined road section, and combining the resulting\nportions into a single object. Segment object selections for road sections were discussed in Section 4.3.4.\n\nThe function ConstructPortion() is used by the dynamic segmentation sub-procedure ProcessReferenceTable and by the sub-procedure ExtractSection which constructs defined sections.\n\n### 4.5 Processing Tables\n\n#### 4.5.1 Introduction\n\nThe system requirements of the Centreline Tools upgrade included the capability to perform segmentation operations on entire MapInfo tables. Two types of tables were involved.\n\n1. **Tables containing linear references**\n \n Tables of this type normally contain road asset data extracted from ARMIS, or data collected along the road corridor using a vehicle speedometer to obtain chainage values. Processing these tables involves creating vector objects to represent the linear references.\n\n2. **Tables containing point objects**\n\n Such tables usually contain data collected along the road using a GPS device. In these tables, the linear references representing the coordinate-based locations are determined.\n\nThe following sections describe the development of table processing in the Centreline Tools upgrade.\n\n#### 4.5.2 Tables Containing Linear References\n\nThe sub-procedure ProcessReferenceTable was developed to manage the processing of tables containing linear references.\nDialogs were used as the means to select an input table and specify a name and path for the processed output table. A MapBasic ‘SaveAs’ dialog was used to copy the input table to a named output table. The copied table is then processed leaving the original input table unmodified.\n\nThe table to be processed must be mappable in order to store the objects created. The following MapBasic statement extracted from the ProcessReferenceTable procedure was used to make the table mappable and sets the table projection to longitude/latitude, GDA94:\n\n```\nCreate Map For sOutputTable CoordSys Earth Projection 1, 116\n```\n\nIf the table is already mappable, this statement destroys any objects it contains.\n\nAn additional column is added to the table for a processing status report. The following MapBasic statement was used to add a character field of 50 characters to the table:\n\n```\nAlter Table sOutputTable (Add Status Char(50))\n```\n\nOnce the output table has been prepared, information about the table must be gathered for processing. Firstly, the format of the linear reference in the table must be specified. Three linear reference formats were defined as:\n\n- a specific location defined by a road identifier and a single chainage value,\n- a section of road defined by a road identifier, and section start and end chainages, and\n- a section of road defined by a road identifier, a section start chainage and the length of the section.\n\nSecondly, the column of the table containing each of these linear reference elements must be identified.\n\nA dialog was designed for the interactive entry of the relevant table information. A mutually exclusive RadioGroup Control was used for the selection of the linear reference format.\nA separate section of the dialog was set aside for each linear reference format, to be activated when the format is selected. Each section of the dialog has ListBox Controls for the table columns containing the values needed for the specific format. The ListBox Controls are populated with the names of the table columns for selection. Column names are filtered so that only columns containing the required data type are displayed.\n\nRadioGroup Controls were included for the specification of units of measurement for distance values.\n\nThe Do While NOT EOT() construct was used to loop through the records in the table. The function EOT() (End of Table) returns TRUE when the end of the table is encountered and the loop terminates.\n\nThe table is processed on the basis of the linear reference format and measurement units specified in the entry dialog. The road identifier and chainage values are assigned to local variables from the specified columns. Chainage values are converted from kilometres to metres if necessary.\n\nThe road identifier and chainages are tested for validity. A brief message describing any anomalies is assigned to the String variable sReport.\n\nIf a chainage is beyond the extent of a road, the value is reset to the maximum chainage of the road and a report is assigned to the sReport variable.\n\nLikewise, section start and end chainages are tested to verify that they are in gazettal direction for processing. The values are swapped if necessary, and a message assigned to the sReport variable.\n\nThe procedure also tests for the selection of a carriageway code column. If no carriageway column is specified, segmentation is performed on through carriageways only (ie carriageways 1, 2 and 3). If a carriageway column is specified, the value contained in the selected column is used.\n\nIrrespective of the data format selected, the program algorithm uses a start and end value in each case to construct a section object. If the data format is a single chainage,\nthe section has a length of zero. Similarly, a section with the same start and end chainages also has a length of zero.\n\nIf the section has a length of zero, a point object is created. Otherwise, a section is created using the ConstructPortion() function described previously. In either case the object created is assigned to the object variable oSectionObj.\n\nIf no anomalies are encountered during processing, the message ‘OK’ is assigned to the sReport variable.\n\nThe following MapBasic statements, extracted from ProcessReferenceTable, were used to update the row of the table currently being processed with the content of the variables oSectionObj and sReport:\n\n```\nUpdate tblReferences Set Obj = oSectionObj\nWhere RowID = tblReferences.RowID\n\nUpdate tblReferences Set Status = sReport\nWhere RowID = tblReferences.RowID\n```\n\nThe procedure then commits the table and continues the loop until the entire table is processed.\n\n4.5.3 Tables Containing Point Objects\n\nThe sub-procedure ProcessPointTable was developed to manage the processing of tables containing point objects.\n\nThe dialog described in the previous section was for selecting an input table of point objects. A variable in the calling procedure identifies which process has been requested and titles the dialog accordingly.\n\nThe MapBasic SaveAs dialog was also used to copy the input table to a named output table as before, to protect the input table.\nPrior to processing, columns for the attributes road identifier, carriageway, chainage and status report are added to the output table. The following MapBasic Statement, extracted from ProcessPointTable, was used to add the additional columns to the table:\n\n```mapbasic\nAlter Table sOutputTable (Add RoadID Char(6),\nCway Char(1),\nChainage Float,\nStatus Char(50))\n```\n\nThe procedure ProcessPointTable first verifies that the table contains mappable objects. If not, the process is terminated.\n\nThe Do While NOT EOT() construct described in the previous section was used to process the output table.\n\nThe method used to derive the linear referenced location of a point object in a table is similar to the interactive process described previously. However, since there is only one point object per record in a table, only one linear reference can be assigned. Therefore the procedure uses the segment object and hence carriageway type, closest to the point object.\n\nIf a point object is not within a tolerated distance of a road segment, a linear reference is not produced and an error message is assigned to the String variable sReport. Otherwise an ‘OK’ message is assigned.\n\nAfter a record is processed, the linear reference elements and report string are added to the table. The following MapBasic statement was used to update the table for the current record:\n\n```mapbasic\nUpdate tblPoints Set RoadId = sRoadOut,\nCway = sCwayOut,\nChainage = Format$(fChainage/1000, \"0.###\"),\nStatus = sReport\nWhere RowID = tblPoints.RowID\n```\n\nThe table is then committed and the procedure continues the loop until the entire table is processed.\n4.6 Program Input\n\n4.6.1 Introduction\n\nIt was necessary for the Centreline Tools upgrade to accept interactive input in both textual and spatial formats to satisfy translation requirements.\n\nData such as road identifiers, chainages and MapInfo table names are presented to Centreline Tools in textual format, while spatial coordinates identify locations to be translated to linear references.\n\nThe following sections discuss the implementation of interactive data input into the Centreline Tools program.\n\n4.6.2 Textual Input\n\nTextual input in the Centreline Tools upgrade was enabled through the use of dialog boxes.\n\nIn general terms, code used in dialog boxes in the existing version was suitable for reuse in the upgrade, albeit with varying degrees of modification.\n\nDialogs boxes were constructed using MapBasic ‘Dialog’ statements into which various combinations of ‘Control’ statements were placed. A number of Controls were used for a range of purposes, including:\n\n- RadioGroup, to display a set of mutually exclusive radio buttons for selection,\n- EditText, to accept input text,\n- StaticText, to display textual information,\n- OKButton, to accept the input and dismiss the dialog,\n- CancelButton, to cancel the operation, and\n- Button, for other operations activated by buttons.\n\nVariables were used in ‘Control’ statements to enable the contents of dialog boxes to vary at run-time.\nIn the ‘Select a Carriageway’ dialog, a RadioGroup control was used to present a mutually exclusive list of carriageway options for selection. In this dialog the String array variable aCwayList was used in the 'Title' statement to populate the RadioGroup, enabling the option list to vary at run-time, based on the carriageway types involved. The following extract from the function SelectReferenceCway(), shows how the variable was used in the control:\n\n```\nControl RadioGroup\n Title From Variable aCwayList\n Position 20,47\n Value 1\n Into iListOption\n```\n\nSimilarly, a dialog was used to display the options available for processing a defined section of road. The String variable sCwayString was used in the control 'Title' statement to enable a list of carriageways to be varied at run-time. The following extract from the function SelectSectionProcess() shows how the variable was used to represent a varying list of carriageway types:\n\n```\nControl StaticText\n Title sCwayString\n Position 20,20\n Width 170 Height 20\n```\n\nHandler sub-procedures were written to enable and disable dialog buttons based on the values entered into other dialog controls. Generally, one handler was written to establish the default status of the buttons in a dialog. Another handler, which is called every time a control value changes, was used to reset the button status based on input received.\n\nDialogs were also used to provide information and direction during interactive operations.\n\nThe MapBasic function CommandInfo(CMD_INFO_DLG_OK) was used in procedures involving dialogs to conditionally process input data. When the ‘OK’ button is pressed, the current values in the input controls are accepted, the function returns TRUE and the dialog is dismissed.\n\nThe appearance and behaviour of the dialogs used in the Centreline Tools upgrade are illustrated in Chapter 5, which describes the operation of the utility in some detail.\n4.6.3 Spatial Input\n\nInteractive spatial input into Centreline Tools involves the specification of coordinate-based point locations by mouse click events. The MapBasic functions CommandInfo(CMD_INFO_X) and CommandInfo(CMD_INFO_Y) were used in the function CaptureClickPoint() to capture the x and y coordinates of the location of a mouse click event in the map window.\n\nThe MapBasic function CreatePoint(X, Y) was used to create a point object at the captured coordinates, which could then be assigned to an object type variable for use elsewhere in the program. The following extract from the function CaptureClickPoint() demonstrates the use of the MapBasic functions to create a point object:\n\n```mapbasic\nfClickX = CommandInfo(CMD_INFO_X)\nfClickY = CommandInfo(CMD_INFO_Y)\n\n'--- create a point object at the captured coordinates\noMouseClickPoint = CreatePoint(fClickX, fClickY)\n```\n\nThe function CaptureClickPoint() was used to capture the spatial locations for which linear references were required, and the definition of road sections by beginning and end spatial locations.\n\n4.7 System Testing\n\n4.7.1 Introduction\n\nTesting was an important facet of the development of the Centreline Tools upgrade and several strategies were employed. Development testing was carried out during the design and coding phases of the project. Operational testing involved the limited release of completed development versions to be tested under operational conditions by regular users of the system.\n4.7.2 Development Testing\n\nThe sub-procedure MakeDebugTable was written to create a MapInfo table in which to store debugging information. The structure and behaviour of spatial objects constructed by the program could then be examined and manipulated in a MapInfo environment. Figure 4.16 shows an example of the debugging environment containing the spatial objects used to determine the linear reference at a given spatial location.\n\nAdditional statements were written into the source code to display debugging information such as variable values during program execution. These sections of code were enclosed by condition statements controlled by the value of the Logical (boolean) data type program constant CT_DEBUG_ON, which was defined in the definition file. The display of debugging information could then be turned off for development version releases simply by setting the value of CT_DEBUG_ON to FALSE in the definition file prior to compilation. This strategy also enabled sections of debugging code to be left in place for possible use in the future. The following extract from the definition file shows the definition statements for the debugging constants:\n\n```\nDEFINE CT_DEBUG_ON FALSE 'TRUE ' - set T for development\nDEFINE CT_DEBUG_TAB \"Debug\" ' - debugging table name\n```\n\nFigure 4.17 demonstrates the use of debugging code to display the incrementing value of a node number variable, and chainage calculation values during a program loop structure.\nFigure 4.16 – Spatial Debugging Environment\n\nFigure 4.17 – Node Number Variable Debugging Output\nAnother example of the use of debugging code is shown in Figure 4.18, which shows the increasing value of the radius variable used to incrementally expand a search area in search of a road segment.\nFigure 4.19 illustrates another example of debugging code which displays variable values during a traverse through the links of a segment object in search of an intersection condition.\n\nProgram outputs from interactive processes were assessed in relation to expected outcomes and examined manually using other MapInfo tools. Outputs were also compared against the results of similar operations performed by the existing version.\n\nIn order to accommodate comparative testing between development versions of the upgrade and the existing version, some changes were made to system file names. The name of the MapBasic executable file for the upgrade was changed to CT_Main.MBX from CL_Main.MBX, and the name of the temporary system data table was also changed to CT_Data.TAB from CL_Data.TAB. These changes allowed the upgrade versions to run in the same instance of MapInfo as the existing version without conflicts.\n\nSpecifically designed input data was also used for development testing and served several purposes. Firstly, prepared data was used to ensure that the majority of logical branches in the program were executed.\n\nSecondly, data was designed to test the program’s operation with the entire spectrum of road network complexity.\n\nFinally, prepared input data enabled testing of the program’s response to potentially problematic scenarios, including:\n\n- incorrect road identifiers,\n- chainages known to exceed the extents of a road,\n- road/carriageway combinations known not to exist,\n- linear references known to occur at RPs,\n- section start and end points occurring on different roads,\n- section start and end chainages occurring at RPs,\n- section start and end chainages both exceeding extents, and\n- sections defined against gazettal direction.\nAppendix E illustrates the use of specifically prepared input data for system testing. The attributes of the input table contain comments describing known anomalies in the test data. The 'Status' column shows the report generated for each record during processing. The Centreline Tools environment shows some of the spatial objects produced from the input data during segmentation.\n\n### 4.7.3 Operational Testing\n\nSeveral versions of the Centreline Tools upgrade were released to the test group for operational testing during the project. Details of the releases are listed in Table 4.1.\n\n<table>\n<thead>\n<tr>\n<th>Centreline Tools Version</th>\n<th>Release Date</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Development Version 5.0.Alpha</td>\n<td>6th June 2008</td>\n</tr>\n<tr>\n<td>Development Version 5.0.Beta</td>\n<td>18th July 2008</td>\n</tr>\n<tr>\n<td>Development Version 5.0.Beta.2</td>\n<td>19th August 2008</td>\n</tr>\n<tr>\n<td>Production Version 5.0</td>\n<td>23rd September 2008</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.1 – Versions of Centreline Tools Released\n\nThe Alpha version mandated the inclusion of a carriageway code element in the dialog used to set the parameters for dynamic segmentation. However, feedback suggested that mandating the selection of a carriageway code element complicated the process unnecessarily. It was rightly pointed out that the majority of the state does not have roads made up of multiple carriageways, so in many cases a carriageway code is not required (Appleman, A 2008, pers. comm., 20 June).\n\nAs a result of the feedback provided, the dynamic segmentation process in relation to carriageway code was modified. The mandated requirement for a carriageway code column was removed and is now used only if selected. Otherwise, each linear reference is mapped to a through carriageway, or the actual carriageways on which it occurs (through carriageways are 1, 2 and 3). Removing the necessity for the inclusion of a carriageway code also simplified the preparation of an input file to be segmented.\nThe Version 5.0.Beta release of Centreline Tools included support for extracting (copying) sections of roads defined by start and end points and linear references. The modifications required for the entry of carriageway codes were also incorporated into this release.\n\nThe additional section definition toolbar used in the existing version was absorbed into the Centreline Tools toolbar because of an issue with the focus of windows changing away from MapInfo on closing the section toolbar. This behaviour was considered to be unacceptable from a user perspective, and as the cause was not immediately apparent in the Main Roads environment, a decision was made to avoid the problem by combining the section definition buttons into the Centreline Tools toolbar.\n\nSoon after the release of the 5.0.Beta version, it was reported that the 'Process' button was not activating correctly in the dialog used to set dynamic segmentation parameters (Martin, AL 2008, pers. comm., 12 Aug). This problem was traced to the logic of the procedure VerifySelectColumns, which failed to activate the ‘Process’ button if the road identifier and carriageway columns were both selected. It appears that this procedure was incorrectly modified while removing the mandatory requirement for a carriageway code in the previous release. The sub-procedure VerifySelectColumns was rewritten to ensure the ‘Process’ button activated correctly.\n\nFollowing these modifications, Centreline Tools was re-released on 19th August as Version 5.0.Beta.2.\n\nAfter an additional period of operational testing, during which no problems were reported, a final version was released into production on 23rd September as Centreline Tools Version 5.0.\n4.8 Conclusions\n\nDuring the system development process, several methodologies were pursued unsuccessful for a variety of reasons, principally the unreliability of several MapBasic functions in relation to intersecting objects.\n\nInitially, the MapBasic function ConnectObjects(object1, object2, min) was used to create a node at the location on a segment object that is closest to a given point. This function returns a two-point polyline object representing the shortest distance between the two objects, with one end on object1 (the given point) and the other on object2, (the centreline segment). The method involved creating and finding a node in the segment (object2) at the intersection point with the shortest distance polyline returned by the ConnectObjects() function. However, when searching for the intersection point between the two objects, run-time errors were often encountered because the polyline and the segment did not, according to MapInfo, intersect. Although the use of ConnectObjects() was the preferred approach, it was abandoned because it was not considered to be sufficiently reliable for use in the Centreline Tools upgrade.\n\nOther errors were occasionally encountered with object intersections, possible because the single-precision nature of MapInfo is not sufficiently accurate to place nodes precisely into objects.\n\nA similar issue arose in the function FindPointSegments(), which is used to select the road centreline segments that intersect with an expanding circular search area. This procedure contains a select statement with a spatial intersection condition clause, which when assessed as TRUE, causes the search loop to terminate. However, during further processing, a run-time error occasionally occurred claiming that the objects did not intersect. Introducing an additional test to verify that an intersection condition did exist solved this problem.\n\nUnexpected ‘Line’ object types in sc_roads caused run-time errors during system development. Some MapBasic procedures involving polylines fail if applied to a line object, including those used to add nodes and return node numbers. Therefore, the subprocedure VerifyPolyline was included to test object types prior to the use of these functions, and convert lines to polylines if they were encountered.\nCHAPTER 5\nRESULTS\n\n5.1 Introduction\n\nWhen the Centreline Tools program is launched, a toolbar is created and placed into the MapInfo environment. This toolbar provides the interface through which the operations performed by the utility are accessed. The toolbar from the Centreline Tools upgrade is shown in Figure 5.1, together with a brief description of each button.\n\nThe remainder of this chapter describes the operation performed by each tool button available in the production version of the upgrade, Centreline Tools Version 5.0.\n\n5.2 Linear Reference at a Point\n\nSelecting the ‘Linear reference at point’ tool button (see Figure 5.1) enables the determination and display of linear references at selected spatial locations on the road network.\n\nThis button is a push-button and once selected, it remains active until another tool button is selected. When the push-button is depressed, the cursor changes to a crosshair when moved into the map window. The spatial location at which a linear reference is required, is specified by positioning the cursor at the location, and clicking the mouse button.\nWhen a location is selected, a point object representing the position on the road closest to the selected location, and a set of attributes are written to the Centreline Tools data table called `CT_Data`. A label expression is constructed from the road identifier, carriageway and chainage attributes and is also written to the table `CT_Data`. The point object is displayed in the map window labelled with the constructed expression.\n\nAppendix F illustrates the Centreline Tools environment following the use of the ‘Linear reference at point’ tool button to obtain a number of linear references. The attributes of `CT_Data` generated during this activity are displayed in Table 5.1. The 'Item' attribute identifies the operation performed.\nTable 5.1 – *CT_Data* Attributes for Specified Spatial Locations\n\n### 5.3 Find a Linear Reference\n\nThis operation determines the spatial coordinates of the location at which a specified linear reference occurs, and centres the map window at the coordinates.\n\nAfter selecting the “Find a linear reference” button (see Figure 5.1), the dialog displayed in Figure 5.2 is presented for the entry of the desired linear reference. The entered chainage can be in metres or kilometres, but the appropriate ‘units’ must be specified.\n\n\n\nFigure 5.2 – Entry Dialog for Linear References\nThe ‘Verify Road’ button in the entry dialog provides the option to display the minimum and maximum chainage of the entered road identifier. Clicking the ‘Verify Road’ button displays the road extents, as shown in Figure 5.3.\n\n\n\nSeveral validations are carried out on an entered linear reference. If the road identifier does not represent a valid road, or the chainage is beyond the extents of the road, the user is advised and the dialog remains in place. Error messages generated for invalid entries are displayed in Figure 5.4.\n\n\n\nAfter a valid linear reference has been entered, clicking the OK button dismisses the dialog and Centreline Tools finds the coordinates of the requested location and creates a point object. As in the previous operation the point object and relevant attributes are added to the table `CT_Data`. The map window is then centred at the coordinates of the linear reference and the point object and a label similar to that in the previous section are displayed.\nIf the requested linear reference occurs on multiple carriageways, a dialog is presented from which to select a carriageway option for processing. Figure 5.5 is the dialog produced by the linear reference requested on road 12A shown in Figure 5.3. This dialog is not presented if the requested linear reference occurs on one carriageway only.\n\n\n\n**Figure 5.5 – Selection Dialog for Carriageway Options**\n\nIf the ‘All carriageways’ option is selected, a record for each carriageway is added to *CT_Data* and multiple points and labels are displayed.\n\nTable 5.2 contains the attributes generated after the ‘All carriageways’ option selection shown in Figure 5.5. Comparison with the attributes in Table 5.1 shows that the ‘Item’ column identifies the operation performed as ‘Specified linear reference’.\n\n\n\n**Table 5.2 – CT_Data Attributes for Specified Linear References**\n\nAppendix G illustrates the Centreline Tools environment after using the ‘Find a linear reference’ tool button to locate the linear reference shown in Figure 5.3, with the ‘All carriageways’ option as shown in Figure 5.5.\n5.4 Process Table of Linear References\n\nSelecting the ‘Process table of references’ tool button (see Figure 5.1) triggers the dynamic segmentation process, which is also referred to within MR as ‘geocoding’.\n\nWhen the ‘Process table of references’ tool button is selected, a dialog is presented for the selection of an input table containing linear references to be dynamically segmented. An open table can be selected, or a table can be located and selected in a browser. Figure 5.6 shows the input dialog with the table 'Access16A' selected. This table contains the locations of accesses to a state-controlled road in linear reference format.\n\nFigure 5.6 – Selection Dialog for an Input Table of Linear References\n\nAfter the input table is selected, a MapInfo SaveAs Dialog is presented to save a copy of the input table as an output table. The spatial objects created during processing are added to the output table, leaving the input table unmodified. In the Figure 5.7 example, the input table ‘Access16A’ is saved as the output table ‘Access16A_Mapped’. When the output table is created an additional column is added for a brief status report on the result of the segmentation process for each record.\nOnce the output table has been created, the dynamic segmentation parameters must be specified in the dialog shown in Figure 5.8. Firstly, the format of the linear references is selected. Centreline Tools can segment data in the three formats described at the top of Figure 5.8. In the Figure 5.8 example, the ‘single chainage value’ format is selected, which results in the creation of point objects. Polyline objects can also be created for linear sections in the formats of start and end chainages, and start chainage and section length.\n\nNext, the table columns containing the values representing the selected linear reference elements must be specified. The column known to contain the road identifier is selected from the list under ‘Road identifier column’. The column containing the carriageway code can also be specified if required.\n\nFollowing the specification of the single chainage format, the ‘Select column for a single chainage value’ section of the dialog is activated for entry, as shown in Figure 5.8. The name of the column known to contain the single chainage value is selected from the drop-down list in this section. Finally, the chainage units are specified.\nThe ‘Process’ button on the dialog is activated only after the columns required for the specified linear reference format have been selected. Table processing commences when the ‘Process’ button is clicked.\n\nDuring processing, tests are conducted to validate each linear reference. Road identifier, road extents and the order of linear references are verified. Chainages that are beyond the road extents are reset to the end of the road and noted in the status report. Records containing invalid road identifiers cannot be processed. The status value is also displayed in the Message window during processing.\n\nAppendix H.A illustrates the Centreline Tools environment following dynamic segmentation. To better demonstrate the outcome of the process, the point objects of the\ntable ‘Access16A_Mapped’ created during segmentation, have been thematically mapped by the attribute ‘Access_Type’, and labelled with the chainage attribute ‘TDist’.\n\nAppendix H.B compares the attributes of the input table ‘Access16A’ with that of the output table ‘Access16A_Mapped’, after processing. It can be seen from the ‘Status’ column that all the records in the table were correctly geocoded.\n\n5.5 Process Table of Points\n\nSelection of the ‘Process table of points’ tool button (see Figure 5.1) enables the processing of a MapInfo input table containing point objects. In this process, a linear reference is generated for each point object in the input table. This process is often referred to in MR as ‘reverse geocoding’.\n\nAfter the tool button is selected, the dialog shown in Figure 5.9 is presented for selection of a MapInfo input table. An open table can be selected, or a table can be located and selected in a browser. The example shown in Figure 5.9 shows the open table 'FloraSites' selected as the input table. This table contains point objects representing site data collected in the road corridor using a GPS device.\n\n\n\n71\nAn output table is created in the same way as the previous operation to protect the input table. In the Figure 5.10 example, the input table is copied to an output table called ‘FloraSites_Referenced’. During the creation of the output table, additional columns are added for the linear reference elements and a brief status report on the referencing process.\n\nCentreline Tools then processes the output table, generating a linear reference for each point object. The linear reference consists of a road identifier, carriageway code and chainage. The status column is populated on the basis of the outcome of the referencing process.\n\nAppendix I.A displays the attributes of the input table ‘FloraSites’ and the output table ‘FloraSites_Referenced’ after processing, and illustrates the additional columns populated with the linear reference elements.\n\nIt can also be seen in Appendix I.A that a linear reference was not resolved for two point records, which have a ‘Status’ value of ‘Point is not near a road segment’. In these\ncases the point objects were not within a tolerated distance of a road segment object, which is currently preset to 50 metres.\n\nAppendix I.B illustrates the Centreline Tools environment after using the ‘Process table of points’ button to 'reverse geocode' a table of point objects. As in the previous section, the display has been enhanced to better demonstrate the operation. The processed data has been thematically mapped by ‘Status’ and labelled with the linear reference generated. The unsuccessfully referenced points are labelled in red.\n\n5.6 Section Between Points\n\nThe purpose of the operation enabled by the ‘Section between points’ tool button (see Figure 5.1) is to create spatial objects representing sections of road that occur between two specified geographic locations.\n\nDefining a road section between coordinates involves specifying start and end points in a similar way to requesting a linear reference at a point, described above in Section 5.2.\n\nSelecting the ‘Section between points’ tool button activates the ‘Set start point’ tool button (see Figure 5.1). When this button is activated, the cursor becomes a crosshair in the map window, enabling a section start point to be created. The start point is displayed and labelled with the identifier of the road in which the start point occurs.\n\nSuccessfully specifying the start point enables the ‘Set end point’ tool button (see Figure 5.1). The section end point is specified in the same way as the start point, and is similarly displayed. Figure 5.11 shows a map window extract containing a section definition between start and end coordinates.\n\nCentreline Tools validates point selections. Firstly, the end point must be on the same road as the start point. Secondly, the section must be defined in gazettal direction (in the direction of increasing chainage). If either of these conditions is not met, an error message is displayed and the section ends must be respecified before continuing. Messages displayed by Centreline Tools for invalid section end point definitions are displayed in Figure 5.12.\nOnly when the section has been correctly defined, is the ‘Process section’ tool button enabled (see Figure 5.1). After activating the ‘Process section’ tool button, the defined section elements are displayed in the map window and a dialog such as the example shown in Figure 5.13 presents the available options for preparation of the section elements. The section elements referred to in the dialog are the segment objects or parts\nthereof (portions) that collectively make up the defined section, and can be presented in a number of ways.\n\nFigure 5.13 – Processing Options for a Section on a Single Carriageway\n\nThe section elements can be displayed as individual elements, combined into a single object for each carriageway, or combined into a single object representing the entire section. An option to create a buffer object around the entire section, with a specified radius, is also available. The options are not mutually exclusive and any combination of the options can be selected.\n\nOnce the desired options have been selected, the section objects are created and written to the table $CT_{Data}$, together with the relative attributes. The constructed section objects and their labels are then displayed in the map window.\n\nAppendix J shows the Centreline Tools environment following the definition of the section on Road 14A by end point coordinates. The section objects representing the individual elements, combined carriageway and entire section options selected in Figure 5.13 are displayed.\n\nTable 5.3 shows the attributes written to the table $CT_{Data}$ for the section display options selected in Figure 5.13.\n5.7 Section Between Linear References\n\nThe operation performed by the ‘Section between references’ tool button (see Figure 5.1) is similar to that of the ‘Section between points’ button described in the previous section. However, the road section is defined by the entry of section start and end linear references.\n\nSelecting the ‘Section between references’ tool button immediately opens a dialog in which to define a section of road. This dialog, shown in Figure 5.14, is similar to that used for finding a linear reference described in Section 5.3, but two chainage values must be entered to specify the start and end of the road section.\n\nThe ‘Verify Road’ button optionally returns the extents of the entered road identifier as previously described. The entered road identifier is validated as previously described in Section 5.3. Entered start and end chainage values are verified also. Invalid entries are rejected, and error messages shown in Figure 5.15 are displayed.\n\nThe road section must be defined in gazetted direction. Should the entered section end chainage be less than the section start, the message also shown in Figure 5.15 is displayed, and the section must be redefined.\nFigure 5.14 – Entry Dialog for Defining a Section by Linear References\n\nFigure 5.15 – Error Messages for a Section Defined by Linear References\nOnce a valid road section has been defined, the process follows that described in the previous section. The example processing option selection dialog shown in Figure 5.16 represents a section defined by linear references on Road 12A, which contains multiple carriageways. In this case, elements combined for each carriageway and a section buffer set to a radius of 100m have been selected. The objects representing the selected options are then created and written to the table $CT_Data$, together with the relative attributes. The constructed section objects and their labels are then displayed in the map window.\n\n\n\nFigure 5.16 – Processing Options for a Section on Multiple Carriageways\n\nAppendix K shows the Centreline Tools environment following the definition of the section between two linear references on Road 12A. The options selected in Figure 5.16 are displayed.\n\nThe attributes written to the table $CT_Data$ for the Road 12A section options are shown in Table 5.4.\n\n<table>\n<thead>\n<tr>\n<th>Centreline Item</th>\n<th>RoadID</th>\n<th>Carriageway</th>\n<th>StartDist</th>\n<th>EndDist</th>\n<th>Length</th>\n<th>LabelText</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ac_roads</td>\n<td>12A</td>\n<td>2</td>\n<td>54</td>\n<td>56</td>\n<td>2</td>\n<td>Sect Owy 2 - Rd 12A 54.09m to 56.60m</td>\n</tr>\n<tr>\n<td>ac_roads</td>\n<td>12A</td>\n<td>3</td>\n<td>54</td>\n<td>56</td>\n<td>2</td>\n<td>Sect Owy 2 - Rd 12A 54.09m to 56.60m</td>\n</tr>\n<tr>\n<td>ac_roads</td>\n<td>12A</td>\n<td>A</td>\n<td>54.8</td>\n<td>55.915</td>\n<td>1.115</td>\n<td>Sect Owy A - Rd 12A 54.80m to 55.915m</td>\n</tr>\n<tr>\n<td>ac_roads</td>\n<td>12A</td>\n<td>Q</td>\n<td>54.78</td>\n<td>55.87</td>\n<td>1.11</td>\n<td>Sect Owy Q - Rd 12A 54.78m to 55.87m</td>\n</tr>\n<tr>\n<td>ac_roads</td>\n<td>12A</td>\n<td>X</td>\n<td>55.09</td>\n<td>55.31</td>\n<td>0.22</td>\n<td>Sect Owy X - Rd 12A 55.09m to 55.31m</td>\n</tr>\n<tr>\n<td>ac_roads</td>\n<td>12A</td>\n<td>Section buffer</td>\n<td>54</td>\n<td>56</td>\n<td>2</td>\n<td>Sect Buffer - Rd 12A 54.00m to 56.60m</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.4 – $CT_Data$ Attributes for a Section Defined by Linear References\n5.8 Save Labels\n\nThe table *CT_Data* is a temporary table and is not saved when Centreline Tools is closed. The ‘Save labels’ tool button (see Figure 5.1) provides the option to save the current contents of *CT_Data* to a permanent table. When the operation is performed, the dialog shown in Figure 5.17 is presented in which to enter a name for the saved table. The name 'CT_labels' appears initially as a default option. After being copied to the new table, *CT_Data* is closed, removing the objects and labels currently displayed in the map window. The table *CT_Data* is recreated next time Centreline Tools performs an operation.\n\n\n\nFigure 5.17 – Selection Dialog to Save the Centreline Tools Table *CT_Data*\n5.9 Clear/Remove Labels\n\nThe operation performed by the ‘Clear/remove labels’ tool button (see Figure 5.1) is twofold. Firstly, the table $CT_{Data}$ is closed, automatically removing any related objects and labels currently displayed in the map window.\n\nSecondly, the tool buttons are reset to their default states, removing any persisting section specification point definitions.\n\n5.10 About Centreline Tools\n\nInformation about the program is obtained by selecting the 'About Centreline Tools’ tool button (see Figure 5.1). The information provided includes the version number and release date, which are particularly important when providing client support. Figure 5.18 shows the ‘About Centreline Tools’ dialog box produced by the production release of the Centreline Tools upgrade developed for this project.\n\nFigure 5.18 – The ‘About Centreline Tools’ Dialog\n5.11 Exit\n\nThe ‘Exit’ tool button (see Figure 5.1) closes the system data table \\textit{CT\\_Data} and terminates the program, removing the Centreline Tools toolbar from the MapInfo environment.\nCHAPTER 6\nCONCLUSIONS\n\n6.1 Introduction\n\nThis project delivered an upgraded version of Centreline Tools, a utility used by Main Roads to translate between linear and spatial forms of data.\n\nA system upgrade, particularly one in which the existing look and feel were to be retained, necessarily involved some degree of code reuse. In this project much of the existing code used to manage the toolbar and interface dialogs was reused with varying degrees of modification.\n\nThe design of the upgrade was an amalgamation of new and existing ideas. Some of the design elements of the existing version, including the representation of segment direction and the use of an expanding search area were retained but implemented in a different way. However, the methods used to implement dynamic segmentation processes were developed from original ideas.\n\nThe organisation and structure of the upgrade represented a significant departure from the existing version and contributed to an expected simplification in program maintenance. Initially, the expanded definition file centralised program information and simplified referencing. Additional advantages ensued.\n\nThe module restructure in combination with the introduction of the SegmentType data type and segment filtering, ensured that only required segments were processed. The\ndefined type also enabled selected segments to be passed between procedures, significantly reducing the need for the regular selections from the *sc_roads* table seen throughout the existing version.\n\nExpanding the use of procedure parameters in the upgrade also helped to minimise what was considered to be an unnecessary dependence on the use of global variables in the existing version.\n\nThese changes dramatically improved the logic and flow of the program making it much easier to follow and hence, maintain.\n\nAnecdotal accounts suggest that the upgrade is a definite improvement over the existing version and that it is more intuitive to use. Positive evidentiary reports have also been received.\n\nThe test group in Cairns advised that the new version was used to geocode their annual RIP (Roads Implementation Program) in preparation for mapping. A substantial number of tables were processed with no problems (Angus, B 2008, pers. comm., 29 Aug).\n\nA report from Townsville indicated that the Centreline Tools upgrade is working very well (Appleman, A 2008, pers. comm., 10 Sept).\n\nMackay also indicated that the upgrade is performing well (Clague, S 2008, pers. comm., 17 Sept).\n\n### 6.2 Benefits\n\nIt is a little too early in the life cycle of the upgrade to claim that all the expected benefits have been realised. However, to date feedback has been very positive. In addition, there have been no reports of unexplained program behaviours or crashes.\n\nWhile an exhaustive assessment is not yet possible, the following benefits can tentatively be claimed:\n\n- The issue of producing an incorrect chainage at first usage has been resolved.\n• The status reports provided by the table processing operations are useful.\n• Selection of linear reference data formats is more flexible.\n• The upgraded version will definitely be easier to maintain.\n• Early evidence suggests that the upgrade is consistent, stable and reliable.\n\nA more informed assessment of the benefits provided by the Centreline Tools upgrade project will be possible only after the new version has been in production for a reasonable period of time.\n\n6.3 Future Work\n\nA number of improvements could be made to Centreline Tools in the future to provide a more functional and complete product. Some of these might include:\n\n• enabling offsetting of points to the left and right of the road centreline by a specified distance,\n• dynamically displaying labels while geocoding,\n• accommodating the use of another road centreline product,\n• interactive setting of parameters such as the proximity tolerance for point objects in relation to the road centreline,\n• providing a ‘Help’ facility to assist less experienced users, and\n• updating the user guide.\n\nIn addition, some form of advice is necessary, to point out that results produced by the program are entirely dependent on the accuracy of the road centreline representation of ARMIS and the Road Reference System.\n\nFuture development of Centreline Tools will also inevitably be impacted by other work carried out in Main Roads. For example, future projects or processes that modify the structure, content or availability of sc_roads would no doubt impact on Centreline Tools.\n\nIn addition, a Road Information Integrator (RII) is currently being developed to perform translations between linear references and spatial coordinates at the system level between ARMIS sub-systems (Mayocchi, W 2008, pers. comm., 4 Feb). While support\nfor MapInfo is currently not in scope for this project, a service providing spatial/linear translations into the desktop MapInfo environment is indeed likely in the longer term. How this service might be utilised is currently not know, but it could impact significantly on Centreline Tools in the future. Some form of interface would still be necessary, however, through which to request and apply the RII service in a MapInfo environment.\n\nAny proposal for further work on Centreline Tools will also be subject to the usual departmental assessment of need and priority to secure funding.\n\n6.4 Conclusions\n\nAll of the specific objectives outlined for this project were achieved, including the additional functionality that was identified as likely to be completed only if time permitted.\n\nSome unexpected problems were encountered during the development phase of the project. Several MapBasic functions did not perform as claimed in certain circumstances and were not sufficiently reliable to be used. This was disappointing and resulted in some compromises in system development.\n\nThe use of the iterative approach to the SDLC methodology proved to be very effective in the context of this project. This approach enabled significant periods of operational testing of the logic and procedures at the core of the upgrade. It also allowed useful feedback to be evaluated and integrated into subsequent development releases.\n\nWhile it is still very early in the life cycle of the upgrade, the majority of the expected benefits from the project have already been realised, and the life of the utility has been extended.\n\nThe Centreline Tools Upgrade delivered by this project was released into production on 23rd September 2008.\nREFERENCES\n\n\nDepartment of Main Roads 1999, *MapInfo GIS user guide version 4.0*, Department of Main Roads.\n\nDepartment of Main Roads 2004, *MapView training workbook*, Department of Main Roads.\n\nDepartment of Main Roads 2006, *ARMIS road reference system on-line help*, Department of Main Roads.\n\nDepartment of Main Roads 2007, *Main Roads annual report 2006-07*, Department of Main Roads.\n\n\nMapInfo Corporation 2005a, *MapBasic development environment version 8.0 user guide*, MapInfo Corporation, Troy, New York, USA.\n\nMapInfo Corporation 2005b, *MapInfo Professional version 8.0 user guide*, MapInfo Corporation, Troy, New York, USA.\n\n\nAppendix A – Project Specification\nUniversity of Southern Queensland\n\nFACULTY OF ENGINEERING AND SURVEYING\n\nENG4111/4112 Research Project\nPROJECT SPECIFICATION\n\nFOR: Robert William THOMPSON\n\nTOPIC: Centreline Tools Upgrade\n\nSUPERVISOR: Mrs Xiaoye Liu\n\nSPONSORSHIP: Queensland Department of Main Roads\n\nPROJECT AIM: To upgrade the MapBasic linear segmentation utility known within Main Roads as Centreline Tools.\n\nPROGRAMME: (Issue A, 20th March 2008)\n1. Examine the current centreline tools utility to determine the range of operations it performs and develop priorities and a feasible scope definition for the upgrade.\n2. Research the implementation of the linear referencing system used by Main Roads to describe the physical structure of the state controlled road network.\n3. Research the relationship between Main Roads’ linear referencing system and the structure of the digital road centreline which is used as a spine for the linear segmentation process.\n4. Evaluate the source code of the current system to identify procedures suitable for modification and reuse in the upgrade.\n5. Design and implement new algorithms in MapBasic to translate between locations described by linear references and mappable spatial locations based on coordinates.\n6. Develop an upgraded centreline tools utility using an amalgamation of new algorithms and modified existing system procedures.\n7. Test and distribute the upgraded utility.\n8. Prepare and submit an academic dissertation on the system upgrade process.\n\nAs time permits:\n9. Develop additional functionality for the upgraded utility that was originally out of scope.\n10. Include a function to report on processing anomalies.\n\nAGREED\n\n(student)\nDate: 27/03/2008\n\n(supervisor)\nDate: 03/04/2008\n\nCo-examiner: \n\nAppendix A – Project Specification\nAppendix B – Centreline Tools Definition File\nData type definition representing a road centreline segment object and the attributes necessary to translate between coordinates and linear references. This is used to make procedures involving centreline manipulations more independent. Selections on the centreline tables for a particular operation are then necessary in one procedure only. Selected segments are then carried as arrays of the segment type.\n\nThis type can therefore potentially be used to pass segment selections from any road centreline table containing Road Reference System attributes.\n\n---\n\nTYPE SegmentType\n\nSegObj As Object\nSegRoad As String\nSegCway As String\nSegStart As Float\nSegLength As Float\nSegScale As Float\n\nEND TYPE\n\n---\n\nConstant definitions\n\nDEFINE CT_VERSION \"5.0\" 'version identifier\nDEFINE CT_RELEASE_DATE \"23 Sept 2008\" 'version release date\nDEFINE CT_DEBUG_ON FALSE 'TRUE 'set T in development mode for info\nDEFINE CT_DEBUG_TAB \"Debug\" 'debugging table name\nDEFINE CT_PRECISION 50.0 'point to road fail distance in m\nDEFINE CT_SC_ROADS \"sc_roads\" '- road centreline table name\nDEFINE CT_DATA_TAB \"CT_Data\" '- temp table for objects/labels\nDEFINE CT_SECT_DEF \"Section\" '- temp table for section definition\nDEFINE CT_SECT_ELEMENTS \"Elements\" '- temp table for section elements\nDEFINE CT_DIR_WITH_GAZ 1 '- line direction with gazettal\nDEFINE CT_DIR_AGAINST_GAZ 2 '- line direction against gazettal\nDEFINE CT_DIR_UNKNOWN 3 '- line direction unspecified\nDEFINE CT_CWAY_BOTH \"1\" '- cway code in both directions\nDEFINE CT_CWAY_WITH_GAZ \"24ABCDEKLMXZ\" '- cway codes in gazettal direction\nDEFINE CT_CWAY_AGAINST_GAZ \"35NOPQRSTUY\" '- cway codes against gazettal\nDEFINE CT_UNITS_M 1 '- represents unit of measure of metres\nDEFINE CT_UNITS_KM 2 '- represents unit of measure of km\n\n'-------------------------------------------------------------------------------\n' Global variable declarations\n'-------------------------------------------------------------------------------\nGLOBAL gSysApplicationDir$ As String '- SAS system directories\nGLOBAL gSysWorkspaceDir$ As String '- \nGLOBAL gSysDataDir$ As String '- \nGLOBAL gSysReadWrite$ As String '- \n'===============================================================================\n' CT_Main.MB procedure declarations\n'===============================================================================\nDECLARE SUB AboutCT\nDECLARE SUB DisplayClTab(ByVal sInTable As String)\nDECLARE SUB DisplayLabel(ByVal oInputObj As Object,\nByVal sClTable As String,\nByVal sInputTable As String,\nByVal sRoadId As String,\nByVal sCarrWay As String,\nByVal sStartChainage As String,\nByVal sEndChainage As String,\nByVal sLength As String,\nByVal sLabelExpr As String)\nDECLARE SUB ExitCT\nDECLARE SUB LoadCTButtonPad\nDECLARE SUB Main\nDECLARE FUNCTION OpenClTab(ByVal sInTable As String) As Logical\nDECLARE SUB RemoveCTLabels\nDECLARE SUB SaveCTLabels\nDECLARE SUB SetSectionButtons\nDECLARE SUB ResetToolButtons\n'===============================================================================\n' CT_CoordsToRef.MB procedure declarations\n'===============================================================================\nDECLARE FUNCTION CaptureClickPoint(oMouseClickPoint As Object) As Logical\nDECLARE FUNCTION ChainageAtNode(ByVal iNodeNumber As Integer,\nByVal oSegment As Object,\nByVal sCarrway As String,\nByVal fStartChainage,\nByVal fDrivenLength,\nByVal fScalefactor As Float) As Float\nDECLARE SUB PointToReference\n'===============================================================================\n' CT_Debug.MB procedure declarations\n'===============================================================================\nDECLARE SUB MakeDebugTable\n\n'-------------------------------------------------------------------------------\n' CT_CoordsToRef.MB procedure declarations\n'-------------------------------------------------------------------------------\nDECLARE SUB ExitCT\nDECLARE SUB LoadCTButtonPad\nDECLARE SUB Main\nDECLARE FUNCTION OpenClTab(ByVal sInTable As String) As Logical\nDECLARE SUB RemoveCTLabels\nDECLARE SUB SaveCTLabels\nDECLARE SUB SetSectionButtons\nDECLARE SUB ResetToolButtons\n'===============================================================================\n' CT_Debug.MB procedure declarations\n'===============================================================================\nDECLARE SUB MakeDebugTable\n\n93\n**CT_Dialogs.MB procedure declarations**\n\nDECLARE SUB BrowseSelectInTable\n\nDECLARE FUNCTION CopyInputTable(ByVal sInputTable As String, sNewTable As String) As Logical\n\nDECLARE SUB ResetSelectColumns\n\nDECLARE SUB ResetSelectInTable\n\nDECLARE FUNCTION SelectColumns(ByVal sLinearFile As String, iLinearFormat As SmallInt, asColumnNames(0) As String, iSectionUnits, iLengthUnits As SmallInt) As Logical\n\nDECLARE FUNCTION SelectInputTable(ByVal iDialogType As SmallInt, sInputFile As String) As Logical\n\nDECLARE SUB SetSelectColumns\n\nDECLARE SUB SetSelectInTable\n\nDECLARE SUB VerifySelectColumns\n\n**CT_DynSeg.MB procedure declarations**\n\nDECLARE SUB ProcessPointTable\n\nDECLARE SUB ProcessReferenceTable\n\n**CT_FindNodes.MB procedure declarations**\n\nDECLARE FUNCTION ConstructPortion(ByVal fSectionStart, fSectionEnd As Float, aSectionSeg As SegmentType, fSegPortionStart, fSegPortionEnd As Float) As Object\n\nDECLARE FUNCTION FindNodeAtChainage(ByVal fChainage As Float, oLinearObj As Object, ByVal sSegCway As String, ByVal fSegRefoffset As Float, ByVal fSegReflen As Float, ByVal fScalefactor As Float) As Integer\n\nDECLARE FUNCTION FindNodeAtPoint(ByVal oPointArea As Object, oLinearObj As Object) As Integer\n\nDECLARE FUNCTION SegmentDirection(ByVal sCarrwayCode As String) As SmallInt\n\nDECLARE SUB VerifyPolyline(oObject As Object)\n\n**CT_RefToCoords.MB procedure declarations**\n\nDECLARE FUNCTION EnterLinearReference(sRoadIn As String, fChainageIn As Float) As Logical\n\nDECLARE SUB ReferenceToPoint\n\nDECLARE FUNCTION SelectReferenceCway(aSegmentsFound() As SegmentType, sSelectOption As String) As Logical\n\nDECLARE SUB VerifyLinearReference\n\nDECLARE SUB VerifyRoad\n\n**CT_SectionByCoords.MB procedure declarations**\n\nDECLARE SUB CaptureSectionCoord\n\nDECLARE SUB SaveSectionCoords\n\nDECLARE SUB SectionByCoords\n\nDECLARE FUNCTION VerifyCoordSection() As Logical\nAppendix B – Centreline Tools Definition File\nAppendix C – Procedure Structure Charts\n\nC.A – Sub-procedure Main Structure Chart\nC.B – Sub-procedure PointToReference Structure Chart\nC.C – Sub-procedure ReferenceToPoint Structure Chart\nC.D – Sub-procedure ProcessReferenceTable Structure Chart\nC.E – Sub-procedure ProcessPointTable Structure Chart\nC.F – Sub-procedure CaptureSectionCoord Structure Chart\nC.G – Sub-procedure SectionByReferences Structure Chart\nAppendix C.A – Sub-procedure Main Structure Chart\nAppendix C.B – Sub-procedure PointToReference Structure Chart\nAppendix C.C – Sub-procedure ReferenceToPoint Structure Chart\nAppendix C.D – Sub-procedure ProcessReferenceTable Structure Chart\nAppendix C.E – Sub-procedure ProcessPointTable Structure Chart\nAppendix C.F – Sub-procedure CaptureSectionCoord Structure Chart\nAppendix D – Function FindReferenceSegments()\nFinds the road centreline segments in which the named linear reference description occurs.\n\nSelects the road centreline segments for the specified road identifier which occur at the specified carriageway (may be one carriageway code or \"All\" or \"Through\" 1, 2 or 3), have a start chainage <= the specified chainage, and an end chainage => the specified chainage (> does not select end segments).\n\nLoads the selected segments into a segment type array. Loads only one segment for the given road identifier per carriageway. Returns T if segments are selected, F otherwise.\n\nFUNCTION FindReferenceSegments(ByVal sRoadId As String, ByVal sCarriageway As String, ByVal fChainage As Float, aReferenceSegs() As SegmentType) As Logical\n\nDIM i, iSegs As Integer\n\nOnError GoTo ErrorHandle\n\n'--- initialise\nFindReferenceSegments = FALSE\n\n'--- select the centreline segments in which the named linear reference occurs\n'--- ie the segments of the specified road & carriageway for which the\n'--- specified chainage <= the chainage at the start of the segment, and the\n'--- specified chainage >= the chainage at the end of the segment\n'--- (<= is necessary to include end-of-road segments in the selection)\n'--- order the selected segments by carriageway and start chainage (refoffset)\nIf sCarriageway = \"All\" Then\n Select * From CT_SC_ROADS\n Where STREET = sRoadId AND\n REFOFFSET <= fChainage AND\n REFOFFSET + REFLEN >= fChainage\n Into tblReferenceSegs Noselect\n Order By CARRWAY, REFOFFSET\nElseIf sCarriageway = \"Through\" Then\n Select * From CT_SC_ROADS\n Where STREET = sRoadId AND\n (CARRWAY = \"1\" OR\n CARRWAY = \"2\" OR\n CARRWAY = \"3\") AND\n REFOFFSET <= fChainage AND\n REFOFFSET + REFLEN => fChainage\n Into tblReferenceSegs Noselect\n Order By CARRWAY, REFOFFSET\nElse\n Select * From CT_SC_ROADS\n Where STREET = sRoadId AND\n CARRWAY = sCarriageway AND\n REFOFFSET <= fChainage AND\n REFOFFSET + REFLEN => fChainage\n Into tblReferenceSegs Noselect\n Order By CARRWAY, REFOFFSET\nEnd If\n\n'--- if the specified chainage occurs at a reference point\n'--- ie the common point between two segments\n'--- two segments on the one carriageway will be selected\n'--- so exclude the second segment on the same carriageway\n'--- to avoid creating duplicate points with labels\n'--- load the selected segments into an array\ni = 1\niSegs = TableInfo(tblReferenceSegs, TAB_INFO_NROWS)\nIf iSegs > 0 Then\n '--- centreline segments were selected\n '--- load the first segment into the array\n Fetch First From tblReferenceSegs\nReDim aReferenceSegs(i)\naReferenceSegs(i).SegObj = tblReferenceSegs.Obj\naReferenceSegs(i).SegRoad = tblReferenceSegs.STREET\naReferenceSegs(i).SegCway = tblReferenceSegs.CARRWAY\naReferenceSegs(i).SegStart = tblReferenceSegs.REFOFFSET\naReferenceSegs(i).SegLength = tblReferenceSegs.REFLEN\naReferenceSegs(i).SegScale = tblReferenceSegs.SCALEFACTOR\n\n'--- avoid divide by zero errors\nIf aReferenceSegs(i).SegScale = 0 Then\n aReferenceSegs(i).SegScale = 1\nEnd If\n\n'--- loop through the remaining segments and\n'--- load only unique carriageways\nFetch Next From tblReferenceSegs\nDo While NOT EOT(tblReferenceSegs)\n If tblReferenceSegs.CARRWAY <> aReferenceSegs(i).SegCway Then\n '--- this carriageway is not the same as the previous one\n '--- store this one\n i = i + 1\n ReDim aReferenceSegs(i)\n aReferenceSegs(i).SegObj = tblReferenceSegs.Obj\n aReferenceSegs(i).SegRoad = tblReferenceSegs.STREET\n aReferenceSegs(i).SegCway = tblReferenceSegs.CARRWAY\n aReferenceSegs(i).SegStart = tblReferenceSegs.REFOFFSET\n aReferenceSegs(i).SegLength = tblReferenceSegs.REFLEN\n aReferenceSegs(i).SegScale = tblReferenceSegs.SCALEFACTOR\n End If\nEnd If\nFetch Next From tblReferenceSegs\nLoop\n'--- set return value\nFindReferenceSegments = TRUE\nEnd If\n\nClose Table tblReferenceSegs\nGoTo TheEnd\n\nErrorHandle:\n Print Error$(())\n Resume Next\nTheEnd:\n\nEND FUNCTION\n\nAppendix D – Function FindReferenceSegments()\nAppendix E – Example Test Data\n\nE.A – Test Data Before and After Processing\nE.B – Dynamically Segmented Test Data\n### Appendix E.A – Test Data Before and After Processing\n\n#### Test Data Browser\n\n<table>\n<thead>\n<tr>\n<th>Road_ID</th>\n<th>C-way</th>\n<th>Start</th>\n<th>End</th>\n<th>Comment</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>46D</td>\n<td>1</td>\n<td>51,234</td>\n<td>72,345</td>\n<td>End exceeds max</td>\n</tr>\n<tr>\n<td>4603</td>\n<td></td>\n<td>5,678</td>\n<td>14,587</td>\n<td>Null c-way</td>\n</tr>\n<tr>\n<td>46C</td>\n<td>1</td>\n<td>123,456</td>\n<td>178,901</td>\n<td>End exceeds max - RP in section</td>\n</tr>\n<tr>\n<td>12A</td>\n<td>2</td>\n<td>54,000</td>\n<td>57,000</td>\n<td>C-way 2 - RP in section</td>\n</tr>\n<tr>\n<td>12A</td>\n<td>3</td>\n<td>53,920</td>\n<td>56,000</td>\n<td>C-way 3 - RP at start</td>\n</tr>\n<tr>\n<td>12A</td>\n<td>Q</td>\n<td>55,000</td>\n<td>55,500</td>\n<td>C-way Q</td>\n</tr>\n<tr>\n<td>12A</td>\n<td>A</td>\n<td>54,080</td>\n<td>56,000</td>\n<td>C-way A - RP at start</td>\n</tr>\n<tr>\n<td>4406</td>\n<td>1</td>\n<td>18,550</td>\n<td>7,500</td>\n<td>Start exceeds end</td>\n</tr>\n<tr>\n<td>85A</td>\n<td>2</td>\n<td>45,000</td>\n<td>50,000</td>\n<td>No c-way 2 on 85A</td>\n</tr>\n<tr>\n<td>27A</td>\n<td>1</td>\n<td>17,890</td>\n<td>17,869</td>\n<td>Zero length</td>\n</tr>\n<tr>\n<td>46E</td>\n<td>1</td>\n<td>12,345</td>\n<td>45,678</td>\n<td>No road 46E</td>\n</tr>\n<tr>\n<td>46C</td>\n<td>1</td>\n<td>78,901</td>\n<td>112,345</td>\n<td>Multiple segments</td>\n</tr>\n<tr>\n<td>469</td>\n<td>1</td>\n<td>123,456</td>\n<td>78,901</td>\n<td>Start exceeds end and max</td>\n</tr>\n<tr>\n<td>469</td>\n<td>1</td>\n<td>59,100</td>\n<td>67,800</td>\n<td>RP at start</td>\n</tr>\n<tr>\n<td>24E</td>\n<td>1</td>\n<td>145,800</td>\n<td>153,400</td>\n<td>RP at start and end</td>\n</tr>\n<tr>\n<td>460</td>\n<td>1</td>\n<td>34,770</td>\n<td>34,770</td>\n<td>RP at end</td>\n</tr>\n<tr>\n<td>85B</td>\n<td>1</td>\n<td>46,290</td>\n<td>46,290</td>\n<td>Zero length at RP</td>\n</tr>\n<tr>\n<td>4607</td>\n<td>1</td>\n<td>23,456</td>\n<td>34,567</td>\n<td>Start and end exceed max</td>\n</tr>\n</tbody>\n</table>\n\n#### Test Data out Browser\n\n<table>\n<thead>\n<tr>\n<th>Road_ID</th>\n<th>C-way</th>\n<th>Start</th>\n<th>End</th>\n<th>Comment</th>\n<th>Status</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>46D</td>\n<td>1</td>\n<td>51,234</td>\n<td>72,345</td>\n<td>End exceeds max</td>\n<td>Chainage 72345 reset to end of road</td>\n</tr>\n<tr>\n<td>4603</td>\n<td></td>\n<td>5,678</td>\n<td>14,587</td>\n<td>Null c-way</td>\n<td>Invalid linear reference</td>\n</tr>\n<tr>\n<td>46C</td>\n<td>1</td>\n<td>123,456</td>\n<td>178,901</td>\n<td>End exceeds max - RP in section</td>\n<td>Chainage 178901 reset to end of road</td>\n</tr>\n<tr>\n<td>12A</td>\n<td>2</td>\n<td>54,000</td>\n<td>57,000</td>\n<td>C-way 2 - RP in section</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>12A</td>\n<td>3</td>\n<td>53,920</td>\n<td>56,000</td>\n<td>C-way 3 - RP at start</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>12A</td>\n<td>Q</td>\n<td>55,000</td>\n<td>55,500</td>\n<td>C-way Q</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>12A</td>\n<td>A</td>\n<td>54,080</td>\n<td>56,000</td>\n<td>C-way A - RP at start</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>4406</td>\n<td>1</td>\n<td>15,500</td>\n<td>7,500</td>\n<td>Start exceeds end</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>85A</td>\n<td>2</td>\n<td>45,000</td>\n<td>50,000</td>\n<td>No c-way 2 on 85A</td>\n<td>Invalid linear reference</td>\n</tr>\n<tr>\n<td>27A</td>\n<td>1</td>\n<td>17,890</td>\n<td>17,869</td>\n<td>Zero length</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>46E</td>\n<td>1</td>\n<td>12,345</td>\n<td>45,678</td>\n<td>No road 46E</td>\n<td>Road 46E not found</td>\n</tr>\n<tr>\n<td>46C</td>\n<td>1</td>\n<td>78,901</td>\n<td>112,345</td>\n<td>Multiple segments</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>469</td>\n<td>1</td>\n<td>123,456</td>\n<td>78,901</td>\n<td>Start exceeds end and max</td>\n<td>Chainage 123456 read to end of road</td>\n</tr>\n<tr>\n<td>469</td>\n<td>1</td>\n<td>59,100</td>\n<td>67,800</td>\n<td>RP at start</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>24E</td>\n<td>1</td>\n<td>145,800</td>\n<td>153,400</td>\n<td>RP at start and end</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>46D</td>\n<td>1</td>\n<td>18,149</td>\n<td>34,770</td>\n<td>RP at end</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>85B</td>\n<td>1</td>\n<td>46,290</td>\n<td>46,290</td>\n<td>Zero length at RP</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>4607</td>\n<td>1</td>\n<td>23,456</td>\n<td>34,567</td>\n<td>Start and end exceed max</td>\n<td>Chainage 34567 reset to end of road</td>\n</tr>\n</tbody>\n</table>\nAppendix E.B – Dynamically Segmented Test Data\nAppendix F – Linear References at Specified Points\nAppendix F – Linear References at Specified Points\nAppendix G – Linear References Located\nAppendix G – Linear References Located\nAppendix H – Dynamic Segmentation\n\nH.A – Dynamically Segmented Linear References\nH.B – Attributes Before and After Segmentation\nAppendix H.A – Dynamically Segmented Linear References\n## Appendix H.B – Attributes Before and After Segmentation\n\n<table>\n<thead>\n<tr>\n<th>Road_ID</th>\n<th>Title</th>\n<th>Side</th>\n<th>Access_Type</th>\n<th>Comments</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>16A</td>\n<td>71.59</td>\n<td>R</td>\n<td>Paddock</td>\n<td>Rural Address 7116</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>75.237</td>\n<td>L</td>\n<td>Paddock</td>\n<td>Macintosh Road</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>75.6</td>\n<td>R</td>\n<td>Paddock</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>76.631</td>\n<td>R</td>\n<td>Property</td>\n<td>Rural Address 7674</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>77.38</td>\n<td>L</td>\n<td>Paddock</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>78.239</td>\n<td>R</td>\n<td>Road</td>\n<td>Beelarra-Edungaba Road</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>78.894</td>\n<td>L</td>\n<td>Paddock</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>79.598</td>\n<td>R</td>\n<td>Stopping Bay</td>\n<td>Truck/Car Stopping Bay</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>79.645</td>\n<td>L</td>\n<td>Stopping Bay</td>\n<td>Truck/Car Stopping Bay</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>80.504</td>\n<td>R</td>\n<td>Paddock</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>82.278</td>\n<td>R</td>\n<td>Track</td>\n<td>Dirt Track</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>82.436</td>\n<td>L</td>\n<td>Road</td>\n<td>Anchor Road</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>85.15</td>\n<td>L</td>\n<td>Stopping Bay</td>\n<td>Track pull-off area</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>87.009</td>\n<td>L</td>\n<td>Road</td>\n<td>Proudi Road</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>87.028</td>\n<td>R</td>\n<td>Property</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>89.198</td>\n<td>R</td>\n<td>Paddock</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>92.62</td>\n<td>L</td>\n<td>Road</td>\n<td>Bilcole - Duaringa Road</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>92.62</td>\n<td>R</td>\n<td>Road</td>\n<td>Bilcole-Duaringa Road</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>94.051</td>\n<td>R</td>\n<td>Road</td>\n<td>Cabarita Road</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>94.091</td>\n<td>L</td>\n<td>Property</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>94.251</td>\n<td>L</td>\n<td>Track</td>\n<td>Gravel Track</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>94.408</td>\n<td>R</td>\n<td>Stopping Bay</td>\n<td>Track pull-off area</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>96.339</td>\n<td>L</td>\n<td>Road</td>\n<td>Road to Baralaba</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>97.349</td>\n<td>R</td>\n<td>Property</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>98.529</td>\n<td>R</td>\n<td>Paddock</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>98.29</td>\n<td>L</td>\n<td>Track</td>\n<td>Dirt Track</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>99.298</td>\n<td>L</td>\n<td>Track</td>\n<td>Dirt/Gravel Track</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>102.651</td>\n<td>L</td>\n<td>Road</td>\n<td>Laguna Road "Laguna"</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>103.855</td>\n<td>R</td>\n<td>Paddock</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>104.036</td>\n<td>R</td>\n<td>Paddock</td>\n<td>Rural Address 10404</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>104.521</td>\n<td>L</td>\n<td>Paddock</td>\n<td></td>\n</tr>\n<tr>\n<td>16A</td>\n<td>105.201</td>\n<td>R</td>\n<td>Property</td>\n<td>Montemare Road, "Duaringa Selling Complex"</td>\n</tr>\n<tr>\n<td>16A</td>\n<td>105.335</td>\n<td>L</td>\n<td>Other</td>\n<td>Parthenium Wood Washdown Facility</td>\n</tr>\n</tbody>\n</table>\nAppendix I – Linear Referencing\n I.A – Attributes Before and After Linear Referencing\n I.B – Linear Referenced Point Objects\n### Appendix I.A – Attributes Before and After Linear Referencing\n\n<table>\n<thead>\n<tr>\n<th>Capture Date</th>\n<th>Capture Device ID</th>\n<th>Side of Carriageway</th>\n<th>Density</th>\n<th>Boards</th>\n<th>Cwys</th>\n<th>Changes</th>\n<th>Status</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>moderate</td>\n<td>305</td>\n<td>1</td>\n<td>112</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>moderate</td>\n<td>305</td>\n<td>1</td>\n<td>103</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>right</td>\n<td>scattered</td>\n<td>305</td>\n<td>1</td>\n<td>102</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>scattered</td>\n<td>305</td>\n<td>1</td>\n<td>112</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>both</td>\n<td>high</td>\n<td>305</td>\n<td>1</td>\n<td>1.977</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>scattered</td>\n<td>305</td>\n<td>1</td>\n<td>3.057</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>scattered</td>\n<td>305</td>\n<td>1</td>\n<td>2.676</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>right</td>\n<td>moderate</td>\n<td>305</td>\n<td>1</td>\n<td>0</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>right</td>\n<td>scattered</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>scattered</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>low</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>right</td>\n<td>low</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>both</td>\n<td>low</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>scattered</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>low</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>low</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>low</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>scattered</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>low</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n<tr>\n<td>26/05/2000</td>\n<td>D07_E16_DG05</td>\n<td>left</td>\n<td>low</td>\n<td>305</td>\n<td>1</td>\n<td>203</td>\n<td>OK</td>\n</tr>\n</tbody>\n</table>\nAppendix 1.B – Linear Referenced Point Objects\nAppendix J – Section Defined by Spatial Coordinates\nAppendix J – Section Defined by Spatial Coordinates\nAppendix K – Section Defined by Linear References\nAppendix K – Section Defined by Linear References\nAppendix L – Original Centre Line Tools User Guide\n5 CENTRE LINE TOOLS\n\nThe Road Centre Line Tools is a suite of functions that allow users to perform several GIS operations on the state controlled network road centre line data. For example, it is possible for a user to view the map at a desired location described by the road number and the through distance. Also, by using the centre line tools it is easy to create new map objects of features using description information such as the road number, carriageway id, starting through distance, length of feature and width.\n\nNote: Centre Line Tools is available to districts with a specially prepared digital road table. This table format is specific and further processing is required to produce a suitable input table for Centre Line Tools to function.\n\n5.1 The Centre Line Tools Button Pad\n5.1.1 Tdist at Mouse Click\n\nThis feature will return the road number, carriageway and through distance at the location where you click the mouse on a state controlled centre line, as in the example below.\n\n5.1.2 Find Road and Tdist\n\nThis function enables you to find a location described by the road number and through distance. On selecting this feature the dialog below appears, requiring you to select the road from a list that is presented. After selecting the road enter the through distance. The map view will change to show the location you described and a label will appear at that point along the road, similar to the example above.\n5.1.3 Extract Road Segment Between Points\n\nThis feature allows the user to interactively extract a road segment identified by the start and end points along a road segment. Upon selecting this tool the \"Point to Point\" tool pad appears, as displayed below.\n\nThe \"Point to Point\" button pad allows you to select the start and end points, choose the road and process the query.\n\nSelect the start of the segment of interest, and\n\nSelect the end.\n\nSelect the road to process.\n\nProcess the road segment.\n\nCancel the point to point selection process.\n\nWhen the selected road segment is processed you will be presented with a preview of the new road segment and a pick list of the carriageways within the selected road segment.\nYou can select all or any of the carriageways from the pick list to determine the desired output. As you alter the selection of carriageways the view of the road segment is updated to display the selected carriageway types.\n\nAfter selecting the carriageway type you can select from any of the processing options. These enable you to represent the selected carriageway elements as individual polyline segments, as polylines grouped by carriageway, as a single combined object, or as a buffered region object.\n\nBelow is an example of a 10 metre buffered object for the road carriageways selected on the previous page.\n5.1.4 Extract Road Segment Between Tdist\n\nThis tool is similar to the previous feature, except in this case you identify the required segment by entering the road number, carriageway and start and end through distances.\n\nThe extraction is processed exactly the same as the \"Extract Road Segment Between Points\" described beforehand. A selection list of carriageways will be presented followed by a list of processing options. Below is an example of a typical segment extraction.\n5.1.5 Geocode Wizard\n\nThe Geocode Wizard is a batch processing geocoder specifically for the State controlled road centre line. The system can geocode data (i.e. create map objects) using the ARMIS road reference description. The system can also determine the ARMIS road reference attributes for a geographic object along the state controlled road centre line.\n\n5.1.5.1 Geocoding using road and tdist\n\nThe application can process any MapInfo table containing road number and tdist descriptions. For example, a file containing the Road Implementation Program (RIP) data can have map objects created for it by using the textual location attributes such as the Road Number, Carriageway Identity and Through Distance. The resulting map and data can be viewed thematically and interrogated geographically.\n\nExample of some data suitable for geocoding using road reference description.\n\nBelow is a map and legend of the Road Implementation Program (RIP) for the South-Coast Hinterland District created using the Geocode Wizard.\n5.1.6 Procedure For Batch Geocode using Road ID and Tdist\n\nStep 1. From the Centre Line tools button pad, select the Geocode Wizard.\n\nStep 2. Select the state controlled roads centre line street table, e.g. \"sc_roads\".\nStep 3. Click on the \"Next\" button.\n\nStep 4. Select the Input data table, (the table with Tdist descriptions) either from the list, or choose browse to open the desired file.\nStep 5. Click on the \"Next\" button.\n\nStep 6. Select the radio button option \"has a road and thru distance description\"\nStep 7. Click on the \"Next\" button.\nStep 8. From the \"Select the ROAD field\" group click on the field name that contains the RoadID data.\n\nStep 9. From the \"Select the CARRIAGEWAY field\" group click on the field name that contains the CARRIAGEWAY code data.\n\nStep 10. From the \"Select the THROUGH DISTANCE field\" group click on the field name that contains the THROUGH DISTANCE code data, and select the distance units.\n\nStep 11. From the \"Select the LENGTH field\" group click on the field name that contains the LENGTH code data, and select the distance units.\n\nStep 12. From the \"Select the WIDTH field\" group click on the field name that contains the WIDTH data, and select the distance units.\n\nStep 13. Click on the \"Next\" button.\n\nThe system will now process your file and create new map objects for each data record in your table. To view the results open the output file into a map window.\n\n5.1.6.1 Determining road reference data for map objects\n\nA table of map objects, such as points along a road, can have their road reference description determined using the Geocode Wizard. For example, a global positioning system could be used to create points locating road side assets in the field, the Geocode Wizard can be use to determine the road referencing information that Main Roads uses to describe those locations (Road number, Carriageway, and through distance).\n5.1.7 Procedure for determining road reference data for objects that are mapped\n\nStep 1. From Centre Line tools button pad, select the Geocode Wizard.\n\nStep 2. Select the centre line street table, e.g. \"sc_roads\".\nStep 3. Click on the \"Next\" button.\n\nStep 4. Select the Input data table, either from the list or browse to open the file.\nStep 5. Click on the \"Next\" button.\nStep 6. Select the radio button option \"is geocoded with points\".\nStep 7. Click on the \"Next\" button.\nStep 8. Type, or browse for, an output file name.\n\nThe system will now process your table and produce an output table. Overleaf is an example of a typical input table and the resulting output table.\n5.1.8 Discard Labels\nRemoves all map labels generated by the centre line tools system and clears the CL_DATA table.\n\n5.1.9 Exit Centre Line Tools\nCloses Centre Line Tools and all files."}}},{"rowIdx":165,"cells":{"id":{"kind":"string","value":"6a0bae0cb878dd67526ab8950d57f6e228492ca0"},"text":{"kind":"string","value":"Legal Notice\n\nTHIS DOCUMENT AND THE SOFTWARE DESCRIBED IN THIS DOCUMENT ARE FURNISHED UNDER AND ARE SUBJECT TO THE TERMS OF A LICENSE AGREEMENT OR A NON-DISCLOSURE AGREEMENT, EXCEPT AS EXPRESSLY SET FORTH IN SUCH LICENSE AGREEMENT OR NON-DISCLOSURE AGREEMENT. NETIQ CORPORATION PROVIDES THIS DOCUMENT AND THE SOFTWARE DESCRIBED IN THIS DOCUMENT \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SOME STATES DO NOT ALLOW DISCLAIMERS OF EXPRESS OR IMPLIED WARRANTIES IN CERTAIN TRANSACTIONS; THEREFORE, THIS STATEMENT MAY NOT APPLY TO YOU.\n\nFor purposes of clarity, any module, adapter or other similar material (\"Module\") is licensed under the terms and conditions of the End User License Agreement for the applicable version of the NetIQ product or software to which it relates or interoperates with, and by accessing, copying or using a Module you agree to be bound by such terms. If you do not agree to the terms of the End User License Agreement you are not authorized to use, access or copy a Module and you must destroy all copies of the Module and contact NetIQ for further instructions.\n\nThis document and the software described in this document may not be lent, sold, or given away without the prior written permission of NetIQ Corporation and Omnibond Systems, LLC., except as otherwise permitted by law. Except as expressly set forth in such license agreement or non-disclosure agreement, no part of this document or the software described in this document may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, electronic, mechanical, or otherwise, without the prior written consent of NetIQ Corporation and Omnibond Systems, LLC.. Some companies, names, and data in this document are used for illustration purposes and may not represent real companies, individuals, or data.\n\nThis document could include technical inaccuracies or typographical errors. Changes are periodically made to the information herein. These changes may be incorporated in new editions of this document. NetIQ Corporation and Omnibond Systems, LLC. may make improvements in or changes to the software described in this document at any time.\n\nU.S. Government Restricted Rights: If the software and documentation are being acquired by or on behalf of the U.S. Government or by a U.S. Government prime contractor or subcontractor (at any tier), in accordance with 48 C.F.R. 227.7202-4 (for Department of Defense (DOD) acquisitions) and 48 C.F.R. 2.101 and 12.212 (for non-DOD acquisitions), the government’s rights in the software and documentation, including its rights to use, modify, reproduce, release, perform, display or disclose the software or documentation, will be subject in all respects to the commercial license rights and restrictions provided in the license agreement.\n\n\nFor information about NetIQ trademarks, see https://www.netiq.com/company/legal/.\n\nNetIQ Trademarks\n\nFor NetIQ trademarks, see the NetIQ Trademark and Service Mark list (http://www.novell.com/company/legal/trademarks/tmlist.html).\n\nThird-Party Materials\n\nAll third-party trademarks are the property of their respective owners.\n## Contents\n\n### About this Book and the Library\n- About NetIQ Corporation \n - About NetIQ Corporation 9\n\n### 1 Overview\n- 1.1 Driver Architecture 11\n - 1.1.1 Component Summary 12\n - 1.1.2 Component Discussion 14\n- 1.2 Configuration Overview 17\n - 1.2.1 ACF2 Base 17\n - 1.2.2 ACF2 Default Configuration 18\n - 1.2.3 ACF2 Entitlements 19\n - 1.2.4 ACF2 Password Synchronization 19\n - 1.2.5 ACF2 Account Tracking 20\n - 1.2.6 ACF2 Managed System Information 21\n\n### 2 Planning for the ACF2 Driver\n- 2.1 Deployment Planning 23\n- 2.2 Migration Planning 24\n- 2.3 Customization Planning 24\n- 2.4 Establishing a Security-Equivalent User 25\n\n### 3 Installing the ACF2 Driver\n- 3.1 Before You Begin 27\n- 3.2 Required Knowledge and Skills 27\n- 3.3 Prerequisites 28\n - 3.3.1 Connected System Requirements 28\n - 3.3.2 Identity Vault Requirements 28\n- 3.4 Getting the Installation Files 28\n- 3.5 Creating the Driver in Designer 28\n - 3.5.1 Importing the Current Driver Packages 29\n - 3.5.2 Installing the Driver Packages 30\n - 3.5.3 Configuring the Driver 33\n - 3.5.4 Deploying the Driver 33\n - 3.5.5 Starting the Driver 34\n - 3.5.6 Creating the Driver in iManager 34\n- 3.6 Installing the Driver Shim on the Connected System 34\n - 3.6.1 Setting Up the Libraries on Your z/OS System 35\n - 3.6.2 Securing the Driver Shim with SSL 36\n - 3.6.3 Configuring the Remote Loader and Driver Object Passwords 36\n - 3.6.4 Allocating and Initializing the Change Log Data Set 37\n - 3.6.5 Setting Up the Started Tasks 37\n - 3.6.6 Authorizing the Driver TSO Commands 39\n - 3.6.7 Testing Before Installing the Security System Exit 39\n - 3.6.8 Installing the Driver Security System Exits 40\n - 3.6.9 Testing the Completed Connected System Installation 41\n- 3.7 Post-Installation Tasks 42\n- 3.8 Uninstalling the Driver 42\n - 3.8.1 Uninstalling the Security System Exits 43\n## Upgrading from the Fan-Out Driver\n\n### 4.1 Preparing for Migration\n\n### 4.2 Migrating Fan-Out Driver Platform Services to the ACF2 Driver\n\n### 4.3 Configuring the Driver\n\n### 4.4 Post-Migration Tasks\n\n## Configuring the ACF2 Driver\n\n### 5.1 The Driver Shim Configuration File\n\n### 5.2 Setting the Remote Loader and Driver Object Passwords\n\n### 5.3 Migrating Identities\n\n### 5.4 International Considerations\n\n### 5.5 Migrating Identities from the Identity Vault to the Connected System\n\n### 5.6 Migrating Identities from the Connected System to the Identity Vault\n\n### 5.7 Synchronizing the Driver\n\n### 5.8 International Considerations\n\n## Customizing the ACF2 Driver\n\n### 6.1 The Scriptable Framework\n\n### 6.1.1 Modifying a REXX Exec\n\n### 6.2 The Connected System Schema File\n\n### 6.2.1 Schema File Syntax\n\n### 6.2.2 Example Schema File\n\n### 6.3 The Connected System Include/Exclude File\n\n### 6.3.1 Include/Exclude Processing\n\n### 6.3.2 Include/Exclude File Syntax\n\n### 6.3.3 Example Include/Exclude Files\n\n### 6.4 Managing Additional Attributes\n\n### 6.4.1 Modifying the Filter\n\n## Using the ACF2 Driver\n\n### 7.1 Starting and Stopping the Driver\n\n### 7.2 Starting and Stopping the Change Log Started Task\n\n### 7.3 Starting and Stopping the Driver Shim Started Task\n\n### 7.4 Displaying Driver Shim Status\n\n### 7.5 Changing the Driver Shim Trace Level\n\n### 7.6 Monitoring Driver Messages\n\n## Securing the ACF2 Driver\n\n### 8.1 Using SSL\n\n### 8.2 Auditing\n\n### 8.3 Driver Security Certificates\n\n### 8.4 Driver REXX Execs\n\n### 8.5 The Change Log\n\n### 8.6 Driver Passwords\n\n### 8.7 Driver Code\n\n### 8.8 Administrative Users\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>3.8.2 Uninstalling the Driver Shim</td>\n<td>43</td>\n</tr>\n<tr>\n<td>3.8.3 Uninstalling the Driver Object from the Identity Vault</td>\n<td>44</td>\n</tr>\n<tr>\n<td>4 Upgrading from the Fan-Out Driver</td>\n<td>45</td>\n</tr>\n<tr>\n<td>4.1 Preparing for Migration</td>\n<td>45</td>\n</tr>\n<tr>\n<td>4.2 Migrating Fan-Out Driver Platform Services to the ACF2 Driver</td>\n<td>46</td>\n</tr>\n<tr>\n<td>4.3 Configuring the Driver</td>\n<td>46</td>\n</tr>\n<tr>\n<td>4.4 Post-Migration Tasks</td>\n<td>46</td>\n</tr>\n<tr>\n<td>5 Configuring the ACF2 Driver</td>\n<td>49</td>\n</tr>\n<tr>\n<td>5.1 The Driver Shim Configuration File</td>\n<td>49</td>\n</tr>\n<tr>\n<td>5.2 Setting the Remote Loader and Driver Object Passwords</td>\n<td>50</td>\n</tr>\n<tr>\n<td>5.2.1 Connected System</td>\n<td>50</td>\n</tr>\n<tr>\n<td>5.2.2 Identity Vault</td>\n<td>50</td>\n</tr>\n<tr>\n<td>5.3 Migrating Identities</td>\n<td>51</td>\n</tr>\n<tr>\n<td>5.3.1 Migrating Identities from the Identity Vault to the Connected System</td>\n<td>51</td>\n</tr>\n<tr>\n<td>5.3.2 Migrating Identities from the Connected System to the Identity Vault</td>\n<td>51</td>\n</tr>\n<tr>\n<td>5.3.3 Synchronizing the Driver</td>\n<td>52</td>\n</tr>\n<tr>\n<td>5.4 International Considerations</td>\n<td>52</td>\n</tr>\n<tr>\n<td>6 Customizing the ACF2 Driver</td>\n<td>55</td>\n</tr>\n<tr>\n<td>6.1 The Scriptable Framework</td>\n<td>55</td>\n</tr>\n<tr>\n<td>6.1.1 Modifying a REXX Exec</td>\n<td>56</td>\n</tr>\n<tr>\n<td>6.2 The Connected System Schema File</td>\n<td>61</td>\n</tr>\n<tr>\n<td>6.2.1 Schema File Syntax</td>\n<td>61</td>\n</tr>\n<tr>\n<td>6.2.2 Example Schema File</td>\n<td>62</td>\n</tr>\n<tr>\n<td>6.3 The Connected System Include/Exclude File</td>\n<td>63</td>\n</tr>\n<tr>\n<td>6.3.1 Include/Exclude Processing</td>\n<td>63</td>\n</tr>\n<tr>\n<td>6.3.2 Include/Exclude File Syntax</td>\n<td>63</td>\n</tr>\n<tr>\n<td>6.3.3 Example Include/Exclude Files</td>\n<td>66</td>\n</tr>\n<tr>\n<td>6.4 Managing Additional Attributes</td>\n<td>67</td>\n</tr>\n<tr>\n<td>6.4.1 Modifying the Filter</td>\n<td>67</td>\n</tr>\n<tr>\n<td>7 Using the ACF2 Driver</td>\n<td>69</td>\n</tr>\n<tr>\n<td>7.1 Starting and Stopping the Driver</td>\n<td>69</td>\n</tr>\n<tr>\n<td>7.2 Starting and Stopping the Change Log Started Task</td>\n<td>69</td>\n</tr>\n<tr>\n<td>7.3 Starting and Stopping the Driver Shim Started Task</td>\n<td>70</td>\n</tr>\n<tr>\n<td>7.4 Displaying Driver Shim Status</td>\n<td>70</td>\n</tr>\n<tr>\n<td>7.5 Changing the Driver Shim Trace Level</td>\n<td>70</td>\n</tr>\n<tr>\n<td>7.6 Monitoring Driver Messages</td>\n<td>70</td>\n</tr>\n<tr>\n<td>8 Securing the ACF2 Driver</td>\n<td>71</td>\n</tr>\n<tr>\n<td>8.1 Using SSL</td>\n<td>71</td>\n</tr>\n<tr>\n<td>8.2 Auditing</td>\n<td>71</td>\n</tr>\n<tr>\n<td>8.3 Driver Security Certificates</td>\n<td>71</td>\n</tr>\n<tr>\n<td>8.4 Driver REXX Execs</td>\n<td>72</td>\n</tr>\n<tr>\n<td>8.5 The Change Log</td>\n<td>72</td>\n</tr>\n<tr>\n<td>8.6 Driver Passwords</td>\n<td>72</td>\n</tr>\n<tr>\n<td>8.7 Driver Code</td>\n<td>72</td>\n</tr>\n<tr>\n<td>8.8 Administrative Users</td>\n<td>73</td>\n</tr>\n</tbody>\n</table>\nAbout this Book and the Library\n\nThis guide explains implementation of the NetIQ® Identity Manager 4.7 driver for ACF2 on mainframes (z/OS operating system).\n\nThe driver synchronizes data from a connected mainframe system using ACF2, the IBM* security system, with NetIQ Identity Manager 4.7, the comprehensive identity management suite that allows organizations to manage the full user life cycle, from initial hire, through ongoing changes, to ultimate retirement of the user relationship.\n\nIntended Audience\n\nThis driver for ACF2 for Identity Manager was created for the following audiences:\n\n- Enterprise IT developers\n- Consultants\n- Sales engineers\n- Architects or system designers\n- System administrators\n\nThis driver is aimed at information technology professionals who:\n\n- Plan, install, configure, and use the Identity Manager bidirectional driver for ACF2\n- Are familiar with Identity Manager, NetIQ eDirectory™, and the administration of systems and platforms you connect to Identity Manager\n\nYou don’t need to be a developer or programmer to use Designer. Designer contains fourteen builders to help you build working policies and drivers, seven editors to assist you in editing projects, and wizards to help you build drivers. Designer also contains over thirty views to help you design and implement Identity Manager solutions. Experienced users can bypass the wizards and interact directly at any level of detail.\n\nOther Information in the Library\n\nThe library provides the following information resources:\n\nIdentity Manager Setup Guide\n Provides overview of Identity Manager and its components. This book also provides detailed planning and installation information for Identity Manager.\n\nDesigner Administration Guide\n Provides information about designing, testing, documenting, and deploying Identity Manager solutions in a highly productive environment.\n\nUser Application: Administration Guide\n Describes how to administer the Identity Manager User Application.\nUser Application: User Guide\nDescribes the user interface of the Identity Manager User Application and how you can use the features it offers, including identity self-service, the Work Dashboard, role and resource management, and compliance management.\n\nUser Application: Design Guide\nDescribes how to use the Designer to create User Application components, including how to work with the Provisioning view, the directory abstraction layer editor, the provisioning request definition editor, the provisioning team editor, and the role catalog.\n\nIdentity Reporting Module Guide\nDescribes the Identity Reporting Module for Identity Manager and how you can use the features it offers, including the Reporting Module user interface and custom report definitions, as well as providing installation instructions.\n\nAnalyzer Administration Guide\nDescribes how to administer Analyzer for Identity Manager.\n\nIdentity Manager Common Driver Administration Guide\nProvides information about administration tasks that are common to all Identity Manager drivers.\n\nIdentity Manager Driver Guides\nProvides implementation information about Identity Manager drivers.\nAbout NetIQ Corporation\n\nWe are a global, enterprise software company, with a focus on the three persistent challenges in your environment: Change, complexity and risk—and how we can help you control them.\n\nOur Viewpoint\n\nAdapting to change and managing complexity and risk are nothing new\n\nIn fact, of all the challenges you face, these are perhaps the most prominent variables that deny you the control you need to securely measure, monitor, and manage your physical, virtual, and cloud computing environments.\n\nEnabling critical business services, better and faster\n\nWe believe that providing as much control as possible to IT organizations is the only way to enable timelier and cost effective delivery of services. Persistent pressures like change and complexity will only continue to increase as organizations continue to change and the technologies needed to manage them become inherently more complex.\n\nOur Philosophy\n\nSelling intelligent solutions, not just software\n\nIn order to provide reliable control, we first make sure we understand the real-world scenarios in which IT organizations like yours operate — day in and day out. That's the only way we can develop practical, intelligent IT solutions that successfully yield proven, measurable results. And that's so much more rewarding than simply selling software.\n\nDriving your success is our passion\n\nWe place your success at the heart of how we do business. From product inception to deployment, we understand that you need IT solutions that work well and integrate seamlessly with your existing investments; you need ongoing support and training post-deployment; and you need someone that is truly easy to work with — for a change. Ultimately, when you succeed, we all succeed.\n\nOur Solutions\n\n- Identity & Access Governance\n- Access Management\n- Security Management\n- Systems & Application Management\n- Workload Management\n- Service Management\nContacting Sales Support\n\nFor questions about products, pricing, and capabilities, contact your local partner. If you cannot contact your partner, contact our Sales Support team.\n\nWorldwide: www.netiq.com/about_netiq/officelocations.asp\nUnited States and Canada: 1-888-323-6768\nEmail: info@netiq.com\nWeb Site: www.netiq.com\n\nContacting Technical Support\n\nFor specific product issues, contact our Technical Support team.\n\nWorldwide: www.netiq.com/support/contactinfo.asp\nNorth and South America: 1-713-418-5555\nEurope, Middle East, and Africa: +353 (0) 91-782 677\nEmail: support@netiq.com\nWeb Site: www.netiq.com/support\n\nContacting Documentation Support\n\nOur goal is to provide documentation that meets your needs. If you have suggestions for improvements, click Add Comment at the bottom of any page in the HTML versions of the documentation posted at www.netiq.com/documentation. You can also email Documentation-Feedback@netiq.com. We value your input and look forward to hearing from you.\n\nContacting the Online User Community\n\nQmunity, the NetIQ online community, is a collaborative network connecting you to your peers and NetIQ experts. By providing more immediate information, useful links to helpful resources, and access to NetIQ experts, Qmunity helps ensure you are mastering the knowledge you need to realize the full potential of IT investments upon which you rely. For more information, visit http://community.netiq.com.\n1 Overview\n\nThe NetIQ® Identity Manager 4.7 driver for ACF2 synchronizes data between Identity Manager and an ACF2 installation on a connected mainframe. Identity Manager, installed on any Identity Manager supported platform, communicates with the driver on the target z/OS system over a secure network link.\n\nThe driver gives you access to ACF2 Logonid fields in accordance with the z/OS ACF2 schema. The driver also allows you to issue arbitrary TSO commands on the z/OS system. Identity Manager gives you access to eDirectory™ objects and their attributes via its Identity Vault.\n\nThe driver uses embedded Remote Loader technology to communicate with Identity Manager, bidirectionally synchronizing changes between the Identity Vault and ACF2. It implements this technology using its own embedded Remote Loader component as part of the main driver shim, which runs as a started task on the connected z/OS system.\n\nThe driver shim’s Subscriber function commits changes to ACF2 using customizable REXX execs that issue native TSO commands through the z/OS service routine IKJEFTSR. This flexible interface provides the option for implementing additional business logic through REXX programming.\n\nThe driver shim’s Publisher function uses standard security system exit routines to capture events of interest and submits them to the Identity Manager Metadirectory engine.\n\nThe Identity Manager 4.7 driver for ACF2 combines the flexibility of the Fan-Out driver and the bidirectional support and Identity Manager policy options available from traditional Identity Manager drivers. Key features of the driver include:\n\n- Bidirectional synchronization of data\n- Customizable schema to integrate all aspects of account administration\n- Customizable REXX execs to handle all data to be synchronized\n- Driver shim implemented as a traditional z/OS started task\n- Operator command control for starting and stopping the driver shim, configuring Remote Loader options, and displaying status information\n- Support for ACF2 passwords and password phrases\n\nThe following sections present a basic overview of the driver:\n\n- Section 1.1, “Driver Architecture,” on page 11\n- Section 1.2, “Configuration Overview,” on page 17\n\n1.1 Driver Architecture\n\nThe driver synchronizes information between the Identity Vault on the Identity Manager platform and ACF2 on the connected z/OS system.\n\nWhen Identity Manager detects relevant changes to identities in its Identity Vault, it uses the Subscriber channel to process and communicate the updates to all connected systems. Events are received by the Subscriber component of the ACF2 driver, which runs as a started task on the z/OS host system. This Subscriber component securely passes the information to customizable REXX execs that carry out the updates to ACF2.\nWhen changes to passwords and other items relevant to Identity Manager are made at the local ACF2 installation, two security system exit routines are used to capture the changes and place them in a cross memory queue. The change log, another z/OS started task, moves events from the memory queue to the change log data set, where they are stored for processing. At configurable intervals, the Publisher component of the driver polls the change log for events and submits them to Identity Manager, where they are processed for posting to the Identity Vault.\n\nFigure 1-1 illustrates the driver’s architecture.\n\n**Figure 1-1 ACF2 Driver Architecture**\n\nThe following topics describe the driver architecture in more detail:\n\n- Section 1.1.1, “Component Summary,” on page 12\n- Section 1.1.2, “Component Discussion,” on page 14\n\n### 1.1.1 Component Summary\n\nMost components of the bidirectional ACF2 driver can be associated with one of the two channels of communication—Subscriber and Publisher—used by the driver and Identity Manager in general.\n\n**Subscriber Channel** Represents data flowing from Identity Manager to the driver on the connected z/OS system, then on to its final destination in ACF2. In this way, ACF2 functions as a *subscriber* to Identity Manager events, receiving any updates from the central Identity Vault via the Subscriber channel.\n\n**Publisher Channel** Represents data flowing from ACF2, through the driver on the host z/OS system, and on to Identity Manager. In this way, ACF2 functions as a *publisher* of events to Identity Manager, sending any updates from its individual ACF2 installation to the central Identity Vault via the Publisher channel.\nNOTE: The term “channel,” within the context of Identity Manager data flow, should not be confused with the same term used in mainframe nomenclature to describe a physical cable or connection.\n\nGiven this general organization, Table 1-1 provides a summary description for each of the driver’s main components, including the data channel it relates to.\n\nTable 1-1 Summary of Driver Components\n\n<table>\n<thead>\n<tr>\n<th>Data Channel</th>\n<th>Component</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Subscriber</td>\n<td>Schema Map</td>\n<td>Provides a reference to the hierarchy of objects and attributes available in ACF2. The driver reads the schema map, usually at startup. It’s also used by Identity Manager’s Policy Editor to map the schema of the Identity Vault to the schema for ACF2.</td>\n</tr>\n<tr>\n<td></td>\n<td>Include/Exclude File</td>\n<td>Optional configuration file for listing local ACF2 identities that you wish to be included or excluded from the central Identity Vault. Allows local system policy to enforce which objects receive provisioning through the Subscriber channel.</td>\n</tr>\n<tr>\n<td></td>\n<td>REXX Execs</td>\n<td>Mainframe scripts that apply the schema map and standard TSO commands to issue changes to ACF2 accounts—including adds, modifies, deletes, and renames—for User objects, and to handle password synchronization. Can be extended to support other object types and events.</td>\n</tr>\n<tr>\n<td>Publisher</td>\n<td>LDXPOST</td>\n<td>Exit routine that detects changes to the ACF2 Logonid database. These changes are written to the cross memory queue; the change log started task is notified each time an event is placed in the memory queue.</td>\n</tr>\n<tr>\n<td></td>\n<td>LDXNPXIT</td>\n<td>Exit routine that detects password changes to ACF2. These changes are written to the cross memory queue; the change log started task is notified each time an event is placed in the memory queue.</td>\n</tr>\n<tr>\n<td></td>\n<td>LDXNPHXT</td>\n<td>Exit routine that detects password phrase changes to ACF2. These changes are written to the cross memory queue; the change log started task is notified each time an event is placed in the memory queue.</td>\n</tr>\n<tr>\n<td></td>\n<td>LDXLOGR</td>\n<td>z/OS started task that responds to events stored in the cross memory queue by writing them to the change log data set. The exit routines LDXPOST and LDXNPXIT notify LDXLOGR of each event added to the memory queue.</td>\n</tr>\n<tr>\n<td></td>\n<td>Change Log</td>\n<td>z/OS data-set representing the final location where updates are placed in the driver’s portion of the Publisher channel before sending to Identity Manager. The driver’s Publisher component removes events from the change log at configurable intervals and submits them to Identity Manager.</td>\n</tr>\n</tbody>\n</table>\n1.1.2 Component Discussion\n\nThis section discusses each of the driver components in more detail.\n\n<table>\n<thead>\n<tr>\n<th>Data Channel</th>\n<th>Component</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Both</td>\n<td>ACF2DRV (Driver Shim)</td>\n<td>z/OS started task that encapsulates the Remote Loader, Subscriber and Publisher channels. It maintains the network connectivity between the ACF2 system and the Identity Vault; it delivers event data to the REXX scriptable framework, where it is used to modify the ACF2 database; it retrieves event data from the ACF2 change log to be published to the Identity Vault.</td>\n</tr>\n<tr>\n<td>Remote Loader</td>\n<td>Enables communication between Identity Manager and ACF2 as if they were running in a common environment. Identity Manager has no specific knowledge of the Remote Loader. For improved efficiency, the ACF2 driver has its own embedded remote loader, which is used in place of the standard version bundled with Identity Manager.</td>\n<td></td>\n</tr>\n<tr>\n<td>Subscriber Component</td>\n<td>Translates XDS event data from the Identity Vault into REXX variables, which are processed by the REXX execs. This component also replies to the Metadirectory engine with XDS status documents.</td>\n<td></td>\n</tr>\n<tr>\n<td>Publisher Component</td>\n<td>Polls the change log for new event data and sends it to the Metadirectory engine for processing. It also clears each event entry from the change log after it has been processed.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n| LDXSERV | Custom, APF-authorized, TSO command providing two key services for the driver: \n\n- When updates are passed to ACF2 in the Subscriber channel, `LDXSERV` is called (with the `NOLOG` parameter) to flag those items with a token in the Publisher event address space. The token’s presence causes the exit routines to ignore the updates. This prevents redundant loopback to Identity Manager for any changes made through the Subscriber channel. \n- `LDXSERV` can also be executed manually (with the `STATUS` parameter) to display information in the change log data set. \n\nACFQUERY | Tool used by both channels to query the ACF2 Logonid database for records and fields. |\n\nNone (z/OS Components) | ACF2 (Access Control Facility) CA product option for z/OS security system requirement. |\n\nToken Address Space | z/OS system memory space used to process changes detected by ACF2 exit routines. Can be flagged with tokens by `LDXSERV` for changes initiated through Subscriber channel to prevent loopback to Identity Manager. |\n\nCross Memory Queue | The memory queue is an encrypted, in-storage buffer used to record events sequentially. Events are added to the memory queue by the ACF2 exit routines, and are removed from the queue by the `LDXLOGR` started task. The memory queue is located in Subpool 231 (fetch-protected ECSA). |\nDriver Shim Started Task\n\nThe driver shim, ACF2DRV, runs as a started task. Only one system that shares the security system database runs the driver shim started task. The driver shim started task must be started as part of your normal z/OS system initialization procedure and stopped during normal system shutdown.\n\nSubscriber Channel Components\n\nThe Subscriber channel of the driver shim started task receives XDS command documents from the Metadirectory engine, stores them using z/OS name/token callable services, then calls the appropriate REXX execs to handle the command.\n\nThe Subscriber shim calls the LDXSERV command on startup to identify itself to the security system exit routines for loopback detection. This prevents the exit routines from generating events for commands issued by the Subscriber shim.\n\nREXX Execs\n\nREXX Execs are essentially scripts that are designed to run on a mainframe. The provided REXX execs support adds, modifies, deletes, and renames for User objects, and handle password synchronization. The REXX execs use standard TSO commands to apply the changes. You can extend the REXX execs to support other object types and events. The REXX execs have secure access to the original XDS command data using the IDMGETV command. IDMGETV accesses z/OS name/token callable services and places the data in REXX variables.\n\nScriptable Framework\n\nThe interface between the security system and the driver shim uses customizable REXX execs. You can extend the execs that are provided with the driver to support other applications and databases.\n\nSeveral utility execs and helper commands are provided with the driver to enable communication with the driver shim and the change log. An extensible connected system schema file allows you to add your own objects and attributes to those already supported by the driver.\n\nFor more information about the REXX execs and the scriptable framework, see Section 6.1, “The Scriptable Framework,” on page 55.\n\nSchema File\n\nThe configuration of class and attribute definitions for the connected system is specified using the schema file. You can modify and extend this file to include new objects and attributes. For details about configuring the schema file, see Section 6.2, “The Connected System Schema File,” on page 61.\n\nThe driver uses the keywords of the ACF2 administrative commands to define the schema. The schema includes one classe: Logonid. This corresponds to ACF2 Logonid records.\n\nSome items in the schema refer to keywords used to create and modify ACF2 Logonids, but cannot be queried or synchronized. These attributes can be used only by Identity Manager policies to make event-time decisions that affect the behavior of the ACF2 administrative command. The auxiliary schema used to extend eDirectory does not include these attributes.\n**Include/Exclude File**\n\nThe include/exclude file allows local system policies to enforce which objects are included or excluded from provisioning by the Subscriber channel. This allows for administrative rules to be set and enforced locally rather than having processing decisions made by the Metadirectory engine. For details about using the include/exclude file, see Section 6.3, “The Connected System Include/Exclude File,” on page 63.\n\nTo control which objects are processed by the Publisher channel, use policies. For details about customizing policies, see the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\n**Publisher Channel Components**\n\nThe Publisher shim periodically examines the change log for events. When the Publisher shim finds events in the change log, it decrypts, processes, and sends them to the Metadirectory engine over a Secure Sockets Layer (SSL) network link. The Metadirectory engine applies policies, takes appropriate actions, and posts the events to the Identity Vault.\n\n**Security System Exit Routines**\n\nACF2 provides two exit interfaces. The driver uses these exits to detect activities of interest and to place events in the memory queue. When the driver exit routines place an event in the memory queue, they notify the change log started task. The change log started task then moves the event information to the change log data set. Each system that shares the security system database must run these exit routines provided by the driver in modules **LDXPOST**, **LDXNPXIT** and **LDXNPHXT**.\n\nThe driver exit routines perform the following tasks:\n\n- Monitor password changes from the local security system and record user and password information in the memory queue.\n- Monitor security system administrative commands entered by users, either directly from the TSO command line, or as generated by the administrative panels. The exit routines record these commands and related information, such as the issuer and time stamp, in the memory queue.\n\n**Memory Queue**\n\nThe memory queue is an encrypted, in-storage buffer that holds events. Events are added to the memory queue by the security system exit routines, and are removed from the queue by the change log started task. The memory queue is located in Subpool 231 (fetch-protected ECSA).\n\n**Change Log Started Task**\n\nThe change log started task is notified of events added to the memory queue by the driver exit routines and moves them to the change log data set.\n\nEach system that shares a security system database must run the change log started task. The change log started task must be started as part of your normal z/OS system initialization procedure and stopped during normal system shutdown.\nChange Log Data Set\n\nThe change log started task removes encrypted events from the memory queue and stores them in the change log data set for processing by the Publisher shim. The Publisher shim removes events from the change log at configurable intervals and submits them to the Metadirectory engine. If communication with the Metadirectory engine is temporarily lost, events remain in the change log until communication becomes available again.\n\nThe change log data set is a standard z/OS direct access (DSORG=DA) data set. There is one change log data set for the set of systems that share the security system database. The change log data set must reside on a shared device unless the security system database is not shared.\n\nLDXSERV Command\n\nLDXSERV is an APF-authorized, TSO command used in both the Publisher and Subscriber channels.\n\nWhen updates are passed to ACF2 in the Subscriber channel, LDXSERV is called (with the NOLOG parameter) to flag those items with a token in the Publisher event address space. The token’s presence causes the exit routines to ignore the updates. This prevents redundant loopback to Identity Manager for any changes made through the Subscriber channel.\n\nLDXSERV can also be executed manually (with the STATUS parameter) to display information in the change log data set. To use the command, you must include the driver load library in the logon procedure STEPLIB concatenation.\n\n1.2 Configuration Overview\n\nThis section discusses driver configuration details specific to the Identity Manager driver for ACF2. For basic configuration information, see the Identity Manager 4.7 Administration Guide on the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/). For detailed information about configuring the driver, see Chapter 5, “Configuring the ACF2 Driver,” on page 49.\n\nThe following topics include each Designer ACF2 Package available for configuration:\n\n- Section 1.2.1, “ACF2 Base,” on page 17\n- Section 1.2.2, “ACF2 Default Configuration,” on page 18\n- Section 1.2.3, “ACF2 Entitlements,” on page 19\n- Section 1.2.4, “ACF2 Password Synchronization,” on page 19\n- Section 1.2.5, “ACF2 Account Tracking,” on page 20\n- Section 1.2.6, “ACF2 Managed System Information,” on page 21\n\n1.2.1 ACF2 Base\n\nThe ACF2 Base provides the policies and settings necessary to provide a basic functioning ACF2 Driver.\n\nThe ACF2 Base Package includes the following Global Configuration Variables:\n\n- **Remote Loader**: A boolean true/false value indicating whether or not to use the Remote Loader service. For this driver, this value should always be set to true.\n- **Host Name**: The physical DNS hostname or IP address for the ACF2 system to connect to.\n- **Port**: The TCP/IP port of the remote loader running on the ACF2 system (default 8090).\n- **KMO**: The SSL KMO object to use for secure communication.\n- **Remote Password**: The remote loader password.\n- **Driver Password**: The driver object password.\n\nThe ACF2 Base Package provides the following Identity Manager policies:\n\n- **NOVLACF2BASE-ot-AppendACF2CMD**: This output transform converts XDS documents from the Subscriber channel into ACF2 commands that will be executed by the ACF2 driver shim.\n- **NOVLACF2BASE-it-ChangeLog**: This input transform converts ACF2 ChangeLog events into XDS that can be interpreted by the rest of the Publisher channel.\n\n### 1.2.2 ACF2 Default Configuration\n\nThe ACF2 Default Configuration provides a set of configuration settings to begin synchronizing ACF2 Logonid records with Identity Vault users.\n\nThe ACF2 Default Configuration Package includes the following Global Configuration Variables (GCVs):\n\n- **User Base Container**: A DN value that represents a container in the Identity Vault from which Subscriber events are restricted from and new and matched User objects are created under on the Publisher channel.\n- **Subscriber Passphrase Synchronization**: A boolean true/false value indicating whether to synchronize Vault passwords with ACF2 passphrases.\n- **Publisher Passphrase Synchronization**: A boolean true/false value indicating whether to synchronize ACF2 passphrases with Vault passwords.\n\nThe ACF2 Default Configuration Package provides the following Identity Manager policies:\n\n- **NOVLACF2DCFG-pub-cp**: This Publisher Create Policy provides a default Surname using either the Full Name field or Association value from the add event.\n- **NOVLACF2DCFG-pub-mp**: This Publisher Matching Policy attempts to match Users by the CN attribute within the User Base Container GCV.\n- **NOVLACF2DCFG-pub-pp**: This Publisher Placement Policy sets the target DN for new users to be the concatenation of the User Base Container GCV and the lowercase value of the CN attribute.\n- **NOVLACF2DCFG-sub-cp**: This Subscriber Create Policy requires the CN and Password and reformats the CN value to be uppercase.\n- **NOVLACF2DCFG-sub-et**: This Subscriber Event Transform vetoes events not in the User Base Container and also renames and moves.\n- **NOVLACF2DCFG-sub-mp**: This Subscriber Matching Policy queries ACF2 for Users that match the CN attribute.\n\nThe ACF2 Default Configuration Package provides the **NOVLACF2DCFG-smp** schema mapping policy and the **NOVLACF2DCFG-filter** filter policy. See Section C.5, “Default ACF2 Schema,” on page 113 for details.\nIn addition, the remaining ACF2 fields are automatically mapped to corresponding attributes in the ACF2 Auxiliary Schema. For a complete list, see Table C-5 on page 111. Each additional auxiliary attribute in the filter is intentionally set to ignore on both channels by default, so they can be conveniently configured otherwise if necessary.\n\n### 1.2.3 ACF2 Entitlements\n\nThe ACF2 Entitlements Package provides a basic entitlement for an ACF2 Logonid record. This package leverages the DirXML-EntitlementsRef attribute, set by the Role Based Entitlements Driver. When entitlements are granted or revoked, you can take the appropriate action in ACF2 by creating, suspending or deleting the Logonid record.\n\nThe ACF2 Entitlements Package provides the following Identity Manager policies:\n\n- **NOVLACF2ENT-pub-et-DisallowDeletes**: When this Publisher Event Transformation detects a user is deleted from ACF2, it removes the user’s Vault association and vetoes the event.\n- **NOVLACF2ENT-sub-cp-EntitlementsImpl**: This Subscriber Create Policy blocks account creation when an Entitlement is not granted.\n- **NOVLACF2ENT-sub-ct-EntitlementsImpl**: When this Subscriber Command Transformation detects a removed entitlement, it results in a delete or suspension. It is based upon the on-account-remove GCV.\n- **NOVLACF2ENT-sub-mp-EntitlementsImpl**: When this Subscriber Matching Policy detects an ACF2 User account managed by entitlements, it vetoes the matching existing account.\n\nThe ACF2 Entitlements Package also provides a filter that includes the User attribute DirXML-EntitlementsRef. This attribute, configured for notification on the Subscriber channel, is set outside the driver whenever a process grants or removes an entitlement for a User.\n\n### 1.2.4 ACF2 Password Synchronization\n\nThe ACF2 Password Synchronization Package leverages the Common Password Synchronization policies to provide email notifications for failed password synchronization and configuration options for Universal Passwords.\n\nThe ACF2 Password Synchronization Package provides the following Identity Manager policies:\n\n- **NOVLPWDSYNC-pub-ctp-AddPwdPayload**: Publish password payloads.\n- **NOVLPWDSYNC-pub-ctp-CheckPwdGCV**: Publish password changes.\n- **NOVLPWDSYNC-pub-ctp-DefaultPwd**: On User add, provide default password if none exists.\n\n### Table 1-2 Default Schema Mapping and Filter\n\n<table>\n<thead>\n<tr>\n<th>eDirectory Class</th>\n<th>eDirectory Attribute</th>\n<th>ACF2 Record</th>\n<th>ACF2 Field</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>User</td>\n<td>CN</td>\n<td>Logonid</td>\n<td>LID</td>\n</tr>\n<tr>\n<td>User</td>\n<td>Login Disabled</td>\n<td>Logonid</td>\n<td>SUSPEND</td>\n</tr>\n<tr>\n<td>User</td>\n<td>nspmDistributionPassword</td>\n<td>Logonid</td>\n<td>PASSWORD</td>\n</tr>\n<tr>\n<td>User</td>\n<td>Full Name</td>\n<td>Logonid</td>\n<td>NAME</td>\n</tr>\n<tr>\n<td>User</td>\n<td>Telephone Number</td>\n<td>Logonid</td>\n<td>PHONE</td>\n</tr>\n</tbody>\n</table>\n\nIn addition, the following attributes are automatically mapped to corresponding attributes in the ACF2 Auxiliary Schema:\n\n- **User CN** => **Logonid LID**\n- **User Login Disabled** => **Logonid SUSPEND**\n- **User nspmDistributionPassword** => **Logonid PASSWORD**\n- **User Full Name** => **Logonid NAME**\n- **User Telephone Number** => **Logonid PHONE**\n• NOVLPWDSYNC-pub-ctp-PublishDistPwd: Publish passwords to NMAS distribution password.\n• NOVLPWDSYNC-pub-ctp-PublishNDSPwd: Publish passwords to NDS password.\n• NOVLPWDSYNC-sub-ctp-AddPwdPayload: Payloads for subscribe to password changes.\n• NOVLPWDSYNC-sub-ctp-CheckPwdGCV: Subscribe to password changes.\n• NOVLPWDSYNC-sub-ctp-DefaultPwd: On User add, provide default password of Surname if no password exists.\n• NOVLPWDSYNC-sub-ctp-TransformDistPwd: Transform NMAS attribute to password elements.\n• NOVLPWDSYNC-itp-EmailOnFailedPwdSub: Email notifications for failed password subscriptions.\n• NOVLPWDSYNC-otp-EmailOnFailedPwdPub: Email notifications for failed password publications.\n\nThe ACF2 Password Synchronization Package includes the following Global Configuration Variables (GCVs):\n\n• Connected System or Driver Name: The name of the connected system, application or Identity Manager driver. This value is used by the e-mail notification templates.\n• Application accepts passwords from Identity Manager: Option to allow passwords to flow from the Identity Manager vault to the connected system.\n• Identity Manager accepts passwords from application: Option to allow passwords to flow from the connected system to the Identity Manager data store.\n• Publish passwords to NDS password: Use the password from the connected system to set the non-reversible NDS password in eDirectory.\n• Publish passwords to Distribution Password: Use the password from the connected system to set the NMAS Distribution Password used for Identity Manager password synchronization.\n• Require password policy validation before publishing passwords: Option to apply the NMAS password policies during password operations on the Publisher channel. The password is not written to the data store if it does not comply.\n• Reset user’s external system password to the Identity Manager password on failure: Attempt to reset the password in the connected system by using the Distribution Password from the Identity Vault when a publish Distribution Password failure occurs.\n• Notify the user of password synchronization failure via e-mail: Notify the user of a password synchronization failure via email.\n\n### 1.2.5 ACF2 Account Tracking\n\nThe ACF2 Account Tracking Package allows the driver to track the accounts and identities of each user in your system.\n\nThe ACF2 Account Tracking Package (with the prerequisite Data Collection Common and Account Tracking Common packages) provides the following Identity Manager policies:\n\n• NOVLATRKBASE-itp-Publish\n• NOVLATRKBASE-itp-WriteAccounts\n• NOVLATRKBASE-otp-Subscribe\n• NOVLDATACOLL-itp-DataCollectionQuerySupport: Convert selected attributes to a form most commonly used in the Identity Vault.\n• NOVLDACCOLL-smp-SkipSchemaMapping\n\nThe ACF2 Account Tracking Package (with the prerequisite Data Collection Common and Account Tracking Common packages) includes the following Global Configuration Variables (GCVs):\n\n• Enable account tracking: If true, account tracking policies are enabled. If false, account tracking policies are not executed.\n• Realm: Name of realm. The realm must be set to the ACF2 DNS name (Example: acf2.yourcompany.org).\n• Object class: Add the object class to track. Class names must be in the application namespace.\n• Identifiers: Add the account identifier attributes. Attribute names must be in the application namespace.\n• Status attribute: Name of the attribute in the application namespace to represent the account status.\n• Status active value: Value of the status attribute that represents an active state.\n• Status inactive value: Value of the status attribute that represents an inactive state.\n• Subscription default status: Default status the policies will assume when an object is subscribed to the application and the status attribute is not set in the identity vault.\n• Publication default status: Default status the policies will assume when an object is published to the identity vault and the status attribute is not set in the application.\n\n1.2.6 ACF2 Managed System Information\n\nThe ACF2 Managed System Information Package provides settings that help the Identity Reporting Module generate reports.\n\nThe ACF2 Managed System Information Package includes the following Global Configuration Variables (GCVs):\n\n• General Information\n • Name: Descriptive name for the ACF2 connected system. This name is displayed in the reports.\n • Description: Brief description of this connected ACF2 system. This description is displayed in the reports.\n • Location: The physical location of this connected ACF2 system. This location is displayed in the reports.\n • Vendor: The vendor of this connected ACF2 system (Computer Associates). This information is displayed in the reports.\n • Version: The version of this connected ACF2 system. This version information is displayed in the reports.\n\n• System Ownership\n • Business Owner\n • Application Owner\n\n• System Classification\n • Classification\n • Environment\n• **Connection and miscellaneous Information:** This options is always set to hide so that you don’t make changes to these options. These options are system options that are necessary for reporting to work. If you make any changes, reporting stops working.\nPlanning for the ACF2 Driver\n\nThis section helps you plan for deployment of the NetIQ® Identity Manager 4.7 driver for ACF2. Topics include\n\n- Section 2.1, “Deployment Planning,” on page 23\n- Section 2.2, “Migration Planning,” on page 24\n- Section 2.3, “Customization Planning,” on page 24\n- Section 2.4, “Establishing a Security-Equivalent User,” on page 25\n\nFor more information about planning, see the Identity Manager 4.7 Installation Guide on the Identity Manager Documentation Web site (https://www.netiq.com/documentation/idm45/).\n\n2.1 Deployment Planning\n\n- Review Chapter 3, “Installing the ACF2 Driver,” on page 27 and Chapter 5, “Configuring the ACF2 Driver,” on page 49.\n- Is this a new installation or an upgrade?\n - If you are installing the ACF2 driver on a system for the first time, use Chapter 3, “Installing the ACF2 Driver,” on page 27, as your main procedural reference.\n - If you are upgrading a system that already uses an ACF2 driver, begin with Chapter 4, “Upgrading from the Fan-Out Driver,” on page 45, which includes instructions for upgrading from both the Fan-Out ACF2 driver.\n- Consider where and how you will install each component.\n The driver shim libraries (SAMPLIB, IDMLOAD, ACF2EXEC) must be installed on a volume that is shared by each system that shares the security system database.\n- If you will use the Publisher channel to track changes made in ACF2, you will need to:\n - Run the driver shim started task on only one system that shares the ACF2 security system database.\n - Create the change log data set on a volume that is shared by all systems that share the security system database.\n - Install the Exit routines on each system that shares the security system database.\n - Schedule an IPL for the Exit installations.\n- How will you stage, test and roll out your deployment of the ACF2 driver?\n- What are the host names or IP addresses of your Metadirectory server and the ACF2 system that will run the driver shim started task?\n- Will you use the default TCP port numbers (see Table 2-1) and are they accessible through your network infrastructure?\n2.2 Migration Planning\n\nSince identities will be synchronized between the Vault and ACF2, you will need to consider the following:\n\n- Where will these identities be located and managed in the Vault?\n- Can you use the default Matching policy to associate Logonid LID fields with the Vault CN attribute, or will you need to base matching on other properties?\n- How will you handle existing Vault IDs that do not meet the requirements for ACF2?\n\nYou will also need to decide whether to use the migration tool provided with Identity Manager or a more manual process for importing your data.\n\n2.3 Customization Planning\n\n- Do you plan to customize the REXX execs provided with the driver?\n \n For details about the provided execs, see Table 6-1, “Identity Vault Command Processing Execs,” on page 56; Table 6-2, “Other Execs,” on page 56; and the execs themselves.\n\n- Do you plan to add attributes or classes to the connected system schema file?\n \n\n- What options do you plan to use in your driver shim configuration file?\n \n For details about the driver shim configuration file, see Section 5.1, “The Driver Shim Configuration File,” on page 49.\n\n- Do you plan to customize the include/exclude file?\n \n For details about the include/exclude file, see Section 6.3, “The Connected System Include/Exclude File,” on page 63.\n\n- Do you plan to customize policies?\n \n For details about customizing policies, see the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\n- Are the resources needed to perform the customization available within your organization?\n\n---\n\nTable 2-1 Default TCP Port Numbers\n\n<table>\n<thead>\n<tr>\n<th>Purpose</th>\n<th>TCP Port Number</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Driver shim connection to the Metadirectory engine</td>\n<td>8090</td>\n</tr>\n<tr>\n<td>Driver shim HTTP services for log viewing</td>\n<td>8091</td>\n</tr>\n<tr>\n<td>Secure LDAP port</td>\n<td>636</td>\n</tr>\n<tr>\n<td>Non-secure LDAP port</td>\n<td>389</td>\n</tr>\n</tbody>\n</table>\n2.4 Establishing a Security-Equivalent User\n\nThe driver object must run with security equivalence to a user with sufficient rights. You can set the driver equivalent to Admin or a similar user. For stronger security, you can define a user with only the minimal rights necessary for the operations you want the driver to perform.\n\nThe driver user must be a trustee of the containers where synchronized users reside, with the rights shown in Table 2-2. Inheritance must be set for [Entry Rights] and [All Attribute Rights].\n\nTable 2-2 Base Container Rights Required by the Driver Security-Equivalent User\n\n<table>\n<thead>\n<tr>\n<th>Operation</th>\n<th>[Entry Rights]</th>\n<th>[All Attribute Rights]</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Subscriber notification of account changes (recommended minimum)</td>\n<td>Browse</td>\n<td>Compare and Read</td>\n</tr>\n<tr>\n<td>Creating objects in the Identity Vault without group synchronization</td>\n<td>Browse and Create</td>\n<td>Compare and Read</td>\n</tr>\n<tr>\n<td>Creating objects in the Identity Vault with group synchronization</td>\n<td>Browse and Create</td>\n<td>Compare, Read, and Write</td>\n</tr>\n<tr>\n<td>Modifying objects in the Identity Vault</td>\n<td>Browse</td>\n<td>Compare, Read, and Write</td>\n</tr>\n<tr>\n<td>Renaming objects in the Identity Vault</td>\n<td>Browse and Rename</td>\n<td>Compare and Read</td>\n</tr>\n<tr>\n<td>Deleting objects from the Identity Vault</td>\n<td>Browse and Erase</td>\n<td>Compare, Read, and Write</td>\n</tr>\n<tr>\n<td>Retrieving passwords from the Identity Vault</td>\n<td>Browse and Supervisor</td>\n<td>Compare and Read</td>\n</tr>\n<tr>\n<td>Updating passwords in the Identity Vault</td>\n<td>Browse and Supervisor</td>\n<td>Compare, Read, and Write</td>\n</tr>\n</tbody>\n</table>\n\nIf you do not set Supervisor for [Entry Rights], the driver cannot set passwords. If you do not want to set passwords, set the Subscribe setting for the User class nspmDistributionPassword attribute to *Ignore* in the filter to avoid superfluous error messages. For details about accessing and editing the filter, see the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\nFor complete information about rights, see the *NetIQ eDirectory™ Administration Guide*.\n3 Installing the ACF2 Driver\n\nThis section provides the information you need for first-time installation of the NetIQ® Identity Manager 4.7 driver for ACF2.\n\nNOTE: If you are upgrading a system that already uses an Identity Manager ACF2 driver, begin with Chapter 4, “Upgrading from the Fan-Out Driver,” on page 45, which includes instructions for upgrading from the Fan-Out ACF2 driver.\n\nTopics include\n- Section 3.1, “Before You Begin,” on page 27\n- Section 3.2, “Required Knowledge and Skills,” on page 27\n- Section 3.3, “Prerequisites,” on page 28\n- Section 3.4, “Getting the Installation Files,” on page 28\n- Section 3.5, “Creating the Driver in Designer,” on page 29\n- Section 3.6, “Installing the Driver Shim on the Connected System,” on page 34\n- Section 3.7, “Post-Installation Tasks,” on page 42\n- Section 3.8, “Uninstalling the Driver,” on page 43\n\n3.1 Before You Begin\n\n- Review Chapter 2, “Planning for the ACF2 Driver,” on page 23.\n- Ensure that you have the most recent distribution, support pack, and patches for the driver.\n- Review the most recent support information for the driver on the NetIQ Support Web site (http://support.netiq.com).\n\n3.2 Required Knowledge and Skills\n\nTo successfully install, configure, and use the driver, you must have system administration skills and rights for Identity Manager, z/OS, and ACF2. You must be proficient with using iManager to configure Identity Manager drivers. You must be familiar with the facilities of the driver, and you must have developed a deployment plan.\n\nFor an overview of driver facilities, see Chapter 1, “Overview,” on page 11.\n\nFor information about planning for the driver, see Chapter 2, “Planning for the ACF2 Driver,” on page 23.\n\nFor information about administering your target systems, see your IBM and ACF2 documentation.\n3.3 **Prerequisites**\n\n- Section 3.3.1, \"Connected System Requirements,\" on page 28\n- Section 3.3.2, \"Identity Vault Requirements,\" on page 28\n\n3.3.1 **Connected System Requirements**\n\n- z/OS\n- ACF2 Security for z/OS\n\nFor information about supported platforms and operating environments, see the Identity Manager 4.7 Drivers Documentation Web site (https://www.netiq.com/documentation/identity-manager-47-drivers). From this index page, you can select a readme file associated with the platform(s) for which you need support.\n\n3.3.2 **Identity Vault Requirements**\n\n- NetIQ Identity Manager (Metadirectory engine) 4.0.4.0 or later with the latest Support Pack\n\n3.4 **Getting the Installation Files**\n\n1. Obtain the most recent distribution of the Identity Manager 4.7 Driver for ACF2 from the NetIQ Downloads Web site (https://dl.netiq.com/index.jsp).\n\n At the time of this Implementation Guide’s initial release, the -driver was included in the following ISO package:\n\n NIdM_Integration_Module_4.7_Mainframes_Midrange.iso\n\n2. Based on the version of the Identity Manager Metadirectory engine you are using, determine which files you will need to copy from the software distribution.\n\n 2a. Regardless of the Metadirectory engine version you are running, the following files are required for all installations:\n\n SAMPLIB.XMT\n IDMLOAD.XMT\n ACF2EXEC.XMT\n\n These files are located under ACF2.\n\n3. Copy the files the files you will need (see Step 2) onto the workstation you will use for the installation. You will use this workstation to set up the driver on the Metadirectory server and to FTP files to the target z/OS system.\n3.5 Creating the Driver in Designer\n\nThe ACF2 Driver supports Designer 4 Package features, which allows you to create a driver by selecting which packages to install. After you create and configure the driver, you need to deploy it to the Identity Vault and start it.\n\nTopics include\n\n- Section 3.5.1, “Importing the Current Driver Packages,” on page 29\n- Section 3.5.2, “Installing the Driver Packages,” on page 30\n- Section 3.5.3, “Configuring the Driver,” on page 33\n- Section 3.5.4, “Deploying the Driver,” on page 33\n- Section 3.5.5, “Starting the Driver,” on page 34\n- Section 3.5.6, “Creating the Driver in iManager,” on page 34\n\n3.5.1 Importing the Current Driver Packages\n\nDriver packages can be updated at any time and are stored in the Package Catalog. Packages are initially imported into the Package Catalog when you create a project, import a project, or convert a project. It is important to verify you have the latest packages imported into the Package Catalog before you install the driver.\n\nTo verify you have the latest packages imported into the Package Catalog:\n\n1. Open Designer.\n2. In the toolbar, click Help > Check for Package Updates.\n3. Click OK if there are no package updates.\n or\n Click OK to import the package updates.\n4. In the Outline view, right-click the Package Catalog.\n5. Click Import Package.\n6. Select the ACF2 packages.\n or\n Click Select All to import all of the packages displayed, then click OK.\nNOTE: By default, only the base packages are displayed. Deselect Show Base Packages Only to display all packages.\n\n7 Click OK to import the selected packages, then click OK in the successfully imported packages message.\n\n8 After the current packages are imported, continue to the next section, Section 3.5.2, “Installing the Driver Packages,” on page 30.\n\n3.5.2 Installing the Driver Packages\n\nAfter you have imported the current driver packages into the Package Catalog, you can install the driver packages to create a new driver.\n\n1 In Designer, open your project.\n\n2 In the Modeler, right-click the driver set where you want to create the driver, then select New > Driver.\n\n3 Select ACF2 Base from the list of base packages, then click Next.\n\n4 Select the optional features to install for the ACF2 driver. The options are:\n\nNOTE: Publications referenced in the following option descriptions can be accessed at the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\nDefault Configuration: This package contains the default configuration information for the ACF2 driver. Always leave this option selected.\n\nEntitlements: This package contains configuration information for synchronizing ACF2 accounts and policies that enable account creation and auditing for the ACF2 driver. To enable account creation and auditing, verify that this option is selected. For more information, see the Identity Manager 4.7 Entitlements Guide.\n\nPassword Synchronization: This package contains the policies that enable the ACF2 driver to synchronize passwords. To synchronize passwords, verify that this option is selected. For more information, see the Identity Manager 4.7 Password Management Guide.\n\nData Collection: This package contains the policies that enable the driver to collect data for reports. If you are using the Identity Reporting Module, verify that this option is selected. For more information, see the Identity Reporting Module Guide.\n\nAccount Tracking: This package contains the policies that enable you to track accounts for reports. If you are using the Identity Reporting Module, verify that this option is selected. For more information, see the Identity Reporting Module Guide.\n\n5 After selecting the optional packages, click Next.\n\n6 (Conditional) If the packages you selected to install have package dependencies, you must install them to install the selected package. Click OK to install the package dependencies listed.\n\n7 (Conditional) If more than one type of package dependency must be installed, you are presented with these packages separately. Continue to click OK to install any additional package dependencies.\n\n8 (Conditional) The Common Settings page is only displayed if the Common Settings package is installed as a dependency. On the Install Common Settings page, fill in the following fields:\n\nUser Container: Select the Identity Vault container where ACF2 users will be added if they don’t already exist in the vault. This value becomes the default for all drivers in the driver set.\nIf you want a unique location for this driver, set the value for all drivers on this page. After the driver is created, change the value on the driver’s Global Configuration Values page.\n\n**Group Container:** Since the ACF2 driver does not synchronize Group objects, this setting can be ignored.\n\n9 (Conditional) If not already configured, fill in the following fields on the Common Settings Advanced Edition page, then click Next:\n\n**User Application Provisioning Services URL:** specify the User Application Identity Manager Provisioning URL.\n\n**User Application Provisioning Services Administrator:** Specify the DN of the User Application Administrator user. This user should have the rights for creating and assigning resources. For more information, see “Setting Up Administrative Accounts” in the NetIQ Identity Manager 4.7 Common Driver Administration Guide.\n\n10 On the Install ACF2 page, fill in the following field:\n\n**Driver Name:** Specify a name for the driver that is unique within the driver set.\n\n11 (Conditional) On the Driver Parameters page, review the default Subscriber and Publisher Options. Edit, if necessary, and click Next.\n\n12 On the Install ACF2 Base page, fill in the following fields to connect to the Remote Loader and click Next:\n\n**Connect to Remote Loader:** By default, the driver is configured to connect using the RemoteLoader. You must select Yes for this option.\n\n**Host Name:** Specify the port number where the Remote Loader is installed and is running for this driver. The default port number is 8090.\n\n**Port:** Specify the Remote Loader’s password as defined on the Remote Loader. The Metadirectory server (or Remote Loader shim) requires this password to authenticate to the Remote Loader.\n\n**Remote Password:** Specify the Remote Loader’s password as defined on the Remote Loader. The Metadirectory server (or Remote Loader shim) requires this password to authenticate to the Remote Loader.\n\n**Driver Password:** Specify the driver object password that is defined in the Remote Loader service. The Remote Loader requires this password to authenticate to the Metadirectory server.\n\n13 (Conditional) On the Account Tracking page, review the default values. Edit, if necessary, and click Next.\n\n14 (Conditional) On the Entitlements Name to CSV File Mappings page, click the **Add Name to File Mapping** icon to populate the page with the entitlement configuration options. Identity Manager uses the CSV file to map ACF2 entitlements into corresponding resources in the Identity Manager catalog.\n\n**NOTE:** This page is displayed only if you installed the Entitlements package.\n\nThe information that you specify in this page is used for creating the permission catalog. Fill in the following fields, then click Next:\n\n**Entitlement Name:** Specify a descriptive name for the entitlement to map it to the CSV file that contains the ACF2 entitlement details.\n\n*Entitlement Name* is the name of the entitlement. This parameter corresponds to the Entitlement Assignment Attribute in ACF2. For example, you could define an entitlement called `ParkingPass`.\n\n**Entitlement Assignment Attribute:** Specify a descriptive name for the assignment attribute for an entitlement.\nEntitlement Assignment Attribute holds the entitlement values in ACF2. For example, you could have an attribute called Parking.\n\nYou must add this parameter to Field Names in the Driver Parameters page or modify it in driver settings after creating the driver.\n\n**CSV File:** Specify the location of the CSV file. This file must be located on the same server as the driver. This file contains the values for the application entitlements.\n\n**Multi-valued?:** Set the value of this parameter to True if you want to assign resources and entitlements multiple times with different values to the same user. Otherwise, set it to False.\n\n15 (Conditional) On the Entitlements page, review the default values. Edit, if necessary, and click Next.\n\n16 (Conditional) On the General Information page, fill in the following fields to define your ACF2 system, then click Next:\n\n- **Name:** Specify a descriptive name for this ACF2 system. The name is displayed in reports.\n- **Description:** Specify a brief description for this ACF2 system. The description is displayed in reports.\n- **Location:** Specify the physical location for this ACF2 system. The location is displayed in reports.\n- **Vendor:** Leave CA as the vendor of ACF2. This information is displayed in reports.\n- **Version:** Specify the version of this ACF2 system. The version is displayed in reports.\n\n**NOTE:** This page is only displayed if you installed the Managed System package.\n\n17 (Conditional) This page is displayed only if you selected to install the Managed System Information packages. On the Install ACF2 Managed System Information page, fill in the following fields, then click Next.\n\n- **Classification:** Select the classification of the ACF2 system. This information is displayed in the reports. Options include:\n - Mission-Critical\n - Vital\n - Not-Critical\n - Other\n\nIf you select Other, you must specify a custom classification for the ACF2 system.\n\n- **Environment:** Select the type of environment the ACF2 system provides. Options include:\n - Development\n - Test\n - Staging\n - Production\n - Other\n\nIf you select Other, you must specify a custom classification for the ACF2 system.\n\n18 (Conditional) On the System Ownership page, fill in the following fields to define the ownership of the ACF2 system, then click Next:\n\n- **Business Owner:** Select a user object in the Identity Vault that is the business owner of the ACF2 system. This can only be a user object, not a role, group, or container.\nApplication Owner: Select a user object in the Identity Vault that is the application owner of the ACF2 system. This can only be a user object, not a role, group, or container.\n\n19 Review the summary of tasks that will be completed to create the driver, then click Finish.\n\nThe driver is created. You can modify the configuration settings by continuing with the next section, Section 3.5.3, “Configuring the Driver,” on page 33. If you don’t need to configure the driver, skip ahead to Section 3.5.4, “Deploying the Driver,” on page 33.\n\n3.5.3 Configuring the Driver\n\nThere are many settings that can help you customize and optimize the driver. The settings are divided into categories such as Driver Configuration, Engine Control Values, and Global Configuration Values (GCVs). Although it is important for you to understand all of the settings, your first priority should be to review the Driver Parameters located on the Driver Configuration page and the Global Configuration Values. These settings must be configured properly for the driver to start and function correctly.\n\nTo access the Driver Properties page:\n\n1 Open your project.\n2 In the Modeler, right-click the driver icon or the driver line, then select Properties.\n3 Modify the driver settings as necessary.\n\nIMPORTANT: In addition to the driver settings, you should review the set of default policies and rules provided by the basic driver configuration. Although these policies and rules are suitable for synchronizing with ACF2*, your synchronization requirements for the driver might differ from the default policies. If this is the case, you need to change them to carry out the policies you want. The default policies and rules are discussed in Section 1.2, “Configuration Overview,” on page 17.\n\n4 Continue with the next section, Section 3.5.4, “Deploying the Driver,” on page 33.\n\n3.5.4 Deploying the Driver\n\nAfter a driver is created in Designer, it must be deployed into the Identity Vault:\n\n1 In Designer, open your project.\n2 In the Modeler, right-click the driver icon or the driver line, then select Live > Deploy.\n3 If you are authenticated to the Identity Vault, skip to Step 5; otherwise, specify the following information:\n \n Host: Specify the IP address or DNS name of the server hosting the Identity Vault.\n Username: Specify the DN of the user object used to authenticate to the Identity Vault.\n Password: Specify the user’s password.\n4 Click OK.\n5 Read through the deployment summary, then click Deploy.\n6 Read the successful message, then click OK.\n7 Click Define Security Equivalence to assign rights to the driver.\nThe driver requires rights to objects within the Identity Vault. The Admin user object is most often used to supply these rights. However, you might want to create a DriversUser (for example) and assign security equivalence to that user. Whatever rights that the driver needs to have on the server, the DriversUser object must have the same security rights:\n\n7a Click Add, then browse to and select the object with the correct rights.\n\n7b Click OK twice.\n\n8 Click Exclude Administrative Roles to exclude users that should not be synchronized.\n\nYou should exclude any administrative User objects (for example, Admin and DriversUser) from synchronization:\n\n8a Click Add, then browse to and select the user object you want to exclude.\n\n8b Click OK.\n\n8c Repeat Step 8a and Step 8b for each object you want to exclude.\n\n8d Click OK.\n\n9 Click OK.\n\n3.5.5 Starting the Driver\n\nWhen a driver is created, it is stopped by default. To make the driver work, you must start the driver and cause events to occur. Identity Manager is an event-driven system, so after the driver is started, it won’t do anything until an event occurs.\n\nTo start the driver:\n\n1 In Designer, open your project.\n\n2 In the Modeler, right-click the driver icon or the driver line, then select Live > Start Driver.\n\n3.5.6 Creating the Driver in iManager\n\nDrivers are created with packages, and iManager does not support packages. In order to create or modify drivers, you must use Designer. See Section 3.5, “Creating the Driver in Designer,” on page 29.\n\n3.6 Installing the Driver Shim on the Connected System\n\nThe driver shim and its files are installed into data sets that you specify, and into files created by the installation process in the HFS.\n\nThe driver uses an embedded Remote Loader. It is not necessary to install Java on the connected system.\n\nFor all procedures in this section that are performed using the target ACF2 system, you must use a privileged user with both TSO and OMVS segments.\n\nTopics in this section include\n\n- Section 3.6.1, “Setting Up the Libraries on Your z/OS System,” on page 35\n- Section 3.6.2, “Securing the Driver Shim with SSL,” on page 36\n- Section 3.6.3, “Configuring the Remote Loader and Driver Object Passwords,” on page 37\n3.6.1 Setting Up the Libraries on Your z/OS System\n\nThe driver shim is packaged as z/OS partitioned data sets (PDS) unloaded with the `TRANSMIT` command.\n\n- **Driver Samples Library**: `SAMPLIB.XMT` contains sample cataloged procedures, other JCL, and sample configuration-related files.\n- **Driver Load Library**: `IDMLOAD.XMT` contains executable programs for the driver shim.\n- **Driver REXX Exec Library**: `ACF2EXEC.XMT` contains the REXX execs for the scriptable framework and to perform configuration tasks.\n\nTo upload these files to the target system and extract them:\n\n1. Use FTP to upload the files to the target system from the workstation where you placed them in Step 2 on page 28.\n\n ```\nc:\\> ftp Your-z/OS-Host\nUser: Your-User-ID\nPassword:\nftp> quote site lrecl=80 recfm=fb\nftp> binary\nftp> put samplib.xmt\nftp> put acf2exec.xmt\nftp> quote site pri=30 sec=5 cyl\nftp> put idmload.xmt\nftp> quit\n ```\n\n2. Log on to z/OS using the same user ID that you used for the FTP session.\n\n3. Use the TSO `RECEIVE` command to extract the data sets. When `RECEIVE` prompts you for parameters, specify the appropriate data set names and volumes according to your standards.\n\n Place these data sets on a disk volume that is shared by the systems that share the security system database.\n4 Add the driver load library to the APF list.\n\nUse the `PARMLIB IEAAPFx` or `PROGxx` member as appropriate. If you use the dynamic APF facility, you can use the `SET PROG` command to activate your changes. Otherwise, you must IPL for the change to take effect.\n\n5 Restrict access to the driver load library.\n\n**WARNING:** Do not put the driver load library in the linklist unless you use program protection to secure its contents against unauthorized use. Failure to protect the driver load library introduces security exposures.\n\n6 Customize and run the JOB card samples library member `SAMPLIB(HFSINST)`.\n\nThis creates the HFS file system structure for the driver.\n\n7 Verify the Unix file structure was created:\n\n```\n/opt/novell/acf2drv/\n/opt/novell/acf2drv/keys\n/opt/novell/acf2drv/logs\n```\n\n### 3.6.2 Securing the Driver Shim with SSL\n\n1 Customize the REXX exec member `EXEC(SETCERT)` to specify the LOAD library and `DRVCONF` locations for your installation.\n\n2 Run the REXX member `EXEC(SETCERT)`.\n\n3 When prompted, enter the Metadirectory server host name or IP address and secure LDAP port number (default is 636).\n\n4 When prompted, enter `Y` to accept the certificate authority presented.\nYou are about to connect to the eDirectory LDAP server to retrieve the eDirectory Tree Trusted Root public certificate.\n\nEnter the LDAP Server Host Address [localhost]: sr.digitalairlines.com\nEnter the LDAP Server Port [636]:\n\nCertificate Authority:\n Subject: ou=Organizational CA,o=TREENAME\n Not Before: 20060821144845Z\n Not After: 20160821144845Z\n\nDo you accept the Certificate Authority? (Y/N) y\n\n5 Verify the following file was created:\n\n /opt/novell/acf2drv/keys/ca/pem\n\nNOTE: If you are unable to contact the LDAP server using these steps, see Section A.2.2, \"Driver Certificate Setup Failure,\" on page 77.\n\n3.6.3 Configuring the Remote Loader and Driver Object Passwords\n\n1 Customize the REXX EXEC(SETPWDS) member to specify the LOAD library and DRVCONF location for your installation.\n2 Run the REXX member EXEC(SETPWDS) and respond to the prompts.\n3 Verify the following files were created:\n\n /opt/novell/acf2drv/keys/lpwd1f40\n /opt/novell/acf2drv/keys/dpwdlf40\n\n3.6.4 Allocating and Initializing the Change Log Data Set\n\nThe change log data set is a standard z/OS direct access data set. The change log data set must reside on a shared device unless it is used by only a single system.\n\nCreate one change log data set. It is shared by each z/OS system that shares the security system database. Use the log file utility LDXUTIL to initialize the change log data set. The change log data set must be initialized before you start the driver shim started task for the first time.\n\nTo allocate and initialize the change log data set:\n\n1 Customize the samples library member LOGINIT.\n\n Update the JCL to conform to your local installation requirements, and specify the following:\n • The name of your driver load library.\n • A name for your change log data set.\n • The shared disk volume where the change log is to be allocated. Specify a different unit name if appropriate.\n\n2 Run the LOGINIT job.\n\n An IEC0311 D37 message is normal and should be ignored.\n\n3 Ensure that your change log data set is protected appropriately for the sensitive nature of its contents.\n\nWARNING: If you initialize a change log data set that contains data, the data is lost.\nSetting Up the Started Tasks\n\n- “Setting Up the Change Log Started Task” on page 38\n- “Setting Up the Driver Shim Started Task” on page 38\n\nSetting Up the Change Log Started Task\n\nYou must install and run the change log started task on each system that shares the security system database.\n\nTo install the change log started task:\n\n1. Copy member LDLOGR from the samples library to your started task procedure library (SYS1.PROCLIB or its equivalent). You can give the change log started task a different name if necessary.\n2. Update the JCL to specify the following:\n - The name of your driver load library\n - The name of your change log data set\n3. Add the change log started task to your system startup and shutdown procedures.\n For more information, see Section 7.2, “Starting and Stopping the Change Log Started Task,” on page 69.\n\n The change log started task should be started during your system startup procedure before user processing begins. Any events of interest that occur are stored in the memory queue until the change log started task has initialized.\n\n The change log started task should be stopped during your system shutdown procedure after all user processing has ended. Any events of interest that occur after the change log started task shuts down remain in the memory queue and are lost when the system is shut down.\n4. Review your Workload Manager definitions to ensure that the change log started task is assigned to a Service Class appropriate for its role.\n\nSetting Up the Driver Shim Started Task\n\nInstall and run the driver shim started task on only one system that shares the security system database.\n\nTo install the driver shim started task:\n\n1. Copy member ACFSHIM from the samples library to your started task procedure library (SYS1.PROCLIB or its equivalent). You can give the driver shim started task a different name if necessary.\n2. Update the JCL to specify the following:\n - The name of your driver load library\n - The name of your driver shim configuration file\n You can use your driver samples library member DRVCONF as a model. For details, see Section 5.1, “The Driver Shim Configuration File,” on page 49.\n - The name of your connected system schema file\n You can use your driver samples library member SCHEMDEF as a model. For details, see Section 6.2, “The Connected System Schema File,” on page 61.\n - The name of your include/exclude file\nYou can use your driver samples library member INCEXC as a model. For details, see Section 6.3, “The Connected System Include/Exclude File,” on page 63.\n\n- The name of your change log data set\n- The name of your driver REXX exec library\n\n3 Add the driver shim started task to your system startup and shutdown procedures.\n\n For information about starting and stopping the driver shim started task, see Section 7.3, “Starting and Stopping the Driver Shim Started Task,” on page 70.\n\n The driver shim started task should be started during your system startup procedure before user processing begins. The driver shim started task should be stopped during your system shutdown procedure after all user processing has ended.\n\n4 Review your Workload Manager definitions to ensure that the driver shim started task is assigned to a Service Class appropriate for its role.\n\n5 Assign a restricted user ID to the ACF2DRV started task, which has been authorized for OMVS and TSO.\n\n acf\n set lid\n insert acf2drv account audit job security stc tso group(omvsgrp)\n set profile(user) div(cmvs)\n insert acf2drv uid(0) home(/) omvspgm(/bin/sh)\n\n This user ID must have read/write permissions to the /opt/novell/acf2drv/ directory and subdirectories to run properly. In the example above, these permissions are given to ACF2DRV by uid(0) and group(omvsgrp).\n\n3.6.6 Authorizing the Driver TSO Commands\n\n The ACF2 driver uses two TSO commands, LDXSERV and ACFQUERY, to interact with the ACF2 system. These two commands need to be APF-authorized and configured as TSO commands on the ACF2 system:\n\n 1 Add LDXSERV and ACFQUERY to the AUTHCMD NAMES(...) statement in member IKJTSOxx of SYS1.PARMLIB or its equivalent.\n\n Example:\n\n AUTHCMD NAMES(+\n ... other commands ... +\n LDXSERV ACFQUERY)\n\n 2 Use the PARMLIB TSO command to activate your changes.\n\n Example:\n\n PARMLIB CHECK(00)\n PARMLIB UPDATE(00)\n\n3.6.7 Testing Before Installing the Security System Exit\n\n You can use the LDXSERV command to test your installation before you install the exit.\n\n 1 If it is not already running, start the change log started task.\n\n For details about starting the change log started task, see Section 7.2, “Starting and Stopping the Change Log Started Task,” on page 69.\n\n 2 Issue the following command from a TSO session that has the driver load library included in its STEPLIB concatenation:\nLDXSERV STATUS\n\n3 Examine the output of the command. As in the following example, you should see information about the memory queue and the change log started task, as well as a valid, empty change log data set:\n\nREADY\nldxserv status\n\n<ldx>\n <source>\n <product build=\"20171217\" instance=\"ldxserv\" version=\"4.70\">\n NetIQ IDM ACF2 Driver Version 4.0.4.0\n </product>\n <contact>NetIQ Corporation</contact>\n </source>\n <output>\n <status level=\"success\">\n <queue version=\"4.70\" state=\"active\" created-by=\"\" entries=\"0\"/>\n <logger version=\"4.70\" state=\"active\" taskid=\"LDXLOGR\"\n logfilename=\"SYSTEMS.LDXACF.V4540821.LOGFILE\"/>\n <logfile name=\"SYSTEMS.LDXACF.V4540821.LOGFILE\" state=\"empty\"/>\n </status>\n </output>\n</ldx>\n\n4 Also in this output, check for the following information:\n\n- The <logfile> element describes the change log data set created earlier (see Section 3.6.4, “Allocating and Initializing the Change Log Data Set,” on page 37). The name attribute describes the data set location and the state attribute describes how full the change log is, expressed either as a percentage or with the keyword empty.\n- The <logger> element displays the status of the change log started task, including attributes for its version, assigned taskid and logfilename if the change log data set is configured for writing.\n- The <queue> element displays the properties of the cross-memory queue, including attributes for version, number of entries currently queued, and created-by (which module created the queue). Before the Exits are installed, the entries attribute will be 0 and the created-by attribute should be empty.\n\n3.6.8 Installing the Driver Security System Exits\n\nThe ACF2 driver uses three ACF2 exits for capturing changes in ACF2 and publishing them to the Identity Vault.\n\n- **LDXPOST** is the ACF2 Logonid exit, invoked by the **LIDPOST** exit point, which captures and queues changes to the Logonid record database.\n- **LDXNPXIT** is the ACF2 exit, invoked by the **NEWPXIT** exit point, which captures and queues password changes from terminal logon.\n\n**NOTE:** The **LDXNPXIT** exit does not capture administrative password changes from the ACF2 menus or the interactive **ACF** command.\n\n- **LDXNPHXT** is the ACF2 exit, invoked by the **NWPXEXIT** exit point, which captures and queues password phrase changes from terminal logon.\nAll three exits are optional for capturing changes to ACF2. If you do not intend to capture changes to the Logonid records, then you do not need to install LDXPOST. If you do not intend to capture user password changes at logon time, then you do not need to install LDXNPXIT. If you do not intend to capture password phrases at logon time, then you do not need to install LDXNPHXT.\n\nTo install LDXPOST, the Logonid database exit:\n\n1. Copy the LOAD library member LDXPOST into a library specified by SYS1.PARMLIB member LPALSTxx. If you add an additional load library to LPA, you will also need to IPL your system to apply these changes.\n\n2. Update the ACF2 GSO option to add the exits. From TSO Ready:\n \n ```\n ACF\n SET CONTROL(GSO) SYSID(NAME)\n INSERT SYSID(NAME) EXITS LIDPOST(LDXPOST)\n QUIT\n ```\n\n3. Refresh the GSO record.\n\n ```\n MODIFY ACF2,REFRESH(EXITS)\n ```\n\n4. IPL the system if LPA has been modified.\n\nTo install LDXNPXIT, the password change exit:\n\n1. Copy the LOAD library member LDXNPXIT into a library specified by SYS1.PARMLIB member LPALSTxx. If you add an additional load library to LPA, you will also need to IPL your system to apply these changes.\n\n2. Update the ACF2 GSO option to add the exit. From TSO Ready:\n\n ```\n ACF\n SET CONTROL(GSO) SYSID(NAME)\n INSERT SYSID(NAME) EXITS NEWPXIT(LDXNPXIT)\n QUIT\n ```\n\n3. Refresh the GSO record.\n\n ```\n MODIFY ACF2,REFRESH(EXITS)\n ```\n\n4. IPL the system if LPA has been modified.\n\nTo install LDXNPHXT, the password phrase change exit:\n\n1. Copy the LOAD library member LDXNPHXT into a library specified by SYS1.PARMLIB member LPALSTxx. If you add an additional load library to LPA, you will also need to IPL your system to apply these changes.\n\n2. Update the ACF2 GSO option to add the exit. From TSO Ready:\n\n ```\n ACF\n SET CONTROL(GSO) SYSID(NAME)\n INSERT SYSID(NAME) EXITS NPWPEXIT(LDXNPHXT)\n QUIT\n ```\n\n3. Refresh the GSO record.\n\n ```\n MODIFY ACF2,REFRESH(EXITS)\n ```\n\n4. IPL the system if LPA has been modified.\n3.6.9 Testing the Completed Connected System Installation\n\nYou can, again, use the **LDXSERV** command to test your installation after installing the ACF2 security exit(s). Issue the following command from a TSO session that has the driver load library included in its **STEPLIB** concatenation:\n\n```\nLDXSERV STATUS\n```\n\nExamine the output of the command. As in the following example, you should see information about the exits, **LDXNPXIT** and **LDXPOST**:\n\n```\nREADY\nldxserv status\n<ldx>\n<source>\n <product build=\"20171217\" instance=\"ldxserv\" version=\"4.70\">\n Novell IDM ACF2 Driver Version 4.0.4.0\n </product>\n <contact>NetIQ Corporation</contact>\n</source>\n<output>\n <status level=\"success\">\n <exit name=\"LDXNPXIT\" state=\"enabled\" version=\"4.70\" build-date=\"20171217\" times-called=\"0\" events-queued=\"1\" info=\"OK\"/>\n <exit name=\"LDXPOST\" state=\"enabled\" version=\"4.70\" build-date=\"20171217\" times-called=\"0\" events-queued=\"1\" info=\"ok\"/>\n </status>\n</output>\n<ldx>\n```\n\nThe output will show two **<exit>** elements that describe the state of each ACF2 exit. Each exit will include:\n\n- A **version** attribute to describe the version level\n- A **build-date** attribute to describe the exact date of assembly\n- A **times-called** attribute describing how many times the exit has been invoked\n- An **events-queued** attribute to show how many events this particular exit has queued an event into memory\n\n3.7 Post-Installation Tasks\n\n1. If desired, set **Startup Option** on the Driver Configuration page to **Auto start**. This causes the driver to start when the Metadirectory engine starts.\n\n2. Activate the driver.\n\nIdentity Manager and Identity Manager drivers must be activated within 90 days of installation or they shut down. At any time during the 90 days, or afterward, you can activate Identity Manager products.\n\nFor details about activating NetIQ Identity Manager Products, see the *Identity Manager 4.7 Installation Guide* on the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n3.8 Uninstalling the Driver\n\n- Section 3.8.1, “Uninstalling the Security System Exits,” on page 43\n- Section 3.8.2, “Uninstalling the Driver Shim,” on page 43\n- Section 3.8.3, “Uninstalling the Driver Object from the Identity Vault,” on page 44\n\n3.8.1 Uninstalling the Security System Exits\n\nThe procedure you use for uninstalling the security exits depends on how you set them up.\n\nIf you linked the LDXNPXIT exit with exits of your own:\n\n1. Reinstall your original exits, then IPL with CLPA to load the relinked exits in the active LPA.\n2. If you change the exit names as you relinked them, be sure to also update the GSO EXITS record with the changed exit names.\n3. Delete the exit modules from the LPA library containing them. Then IPL with CLPA at a convenient time.\n\nIf you are using LDXNPXIT, LDXNPXHT or LDXPOST alone:\n\n1. Update the GSO EXITS record to remove the exit names.\n 1a. Enter the following TSO commands:\n ```\n READY\n acf\n ACF\n set control(gso) sysid(system)\n CONTROL\n insert sysid(system) exits lidpost() newpxit() npwpexit()\n ```\n 1b. Install the new values. From an z/OS console, enter:\n ```\n MODIFY ACF2,REFRESH\n ```\n2. Delete the exit modules from the LPA library containing them. Then IPL with CLPA at a convenient time.\n\n3.8.2 Uninstalling the Driver Shim\n\n1. Remove the change log started task (LDXLOGR) and driver shim (ACF2DRV) started task from your system startup and shutdown procedures.\n2. Stop both started tasks (LDXLOGR and ACF2DRV).\n For details, see Section 7.2, “Starting and Stopping the Change Log Started Task,” on page 69 and Section 7.3, “Starting and Stopping the Driver Shim Started Task,” on page 70.\n3. Remove members LDXLOGR and ACF2DRV from your started task procedure library.\n4. Remove the driver load library from your APF list by modifying PARMLIB IEAAPFxx or PROGxx member as appropriate.\n\n**NOTE:** If you use the dynamic APF facility, you can use the SET PROG command to activate your changes. Otherwise, you must IPL for the change to take affect.\n\n5. Remove the LDXSERV and ACFQUERY TSO commands from IKJTSOxx.\n6. Remove the driver files from the HFS:\noshell rm -rf /opt/novell\n\n7 Delete the SAMPLIB, LOAD and EXEC driver data sets.\n\n8 Delete the change log data set that you created in Section 3.6.4, “Allocating and Initializing the Change Log Data Set,” on page 37.\n\n3.8.3 Uninstalling the Driver Object from the Identity Vault\n\n1 In iManager, select Identity Manager Administration from the top menu icons.\n2 Under Administration tasks, select Identity Manager Overview.\n3 Click Driver Sets and navigate to your driver set by clicking on its name.\n4 Click Drivers, then click Delete Driver on the Driver Set Overview page.\n5 Select the driver object to be deleted, then click OK.\n4 Upgrading from the Fan-Out Driver\n\nThis section provides information about upgrading the latest Identity Manager driver for ACF2 from the Identity Manager Fan-Out Driver for ACF2.\n\nNOTE: At the time of this document’s initial release, the Fan-Out Driver was commonly leveraged to provide an identity solution for ACF2.\n\nTopics include\n\n- Section 4.1, “Preparing for Migration,” on page 45\n- Section 4.2, “Migrating Fan-Out Driver Platform Services to the ACF2 Driver,” on page 46\n- Section 4.3, “Configuring the Driver,” on page 46\n- Section 4.4, “Post-Migration Tasks,” on page 46\n\nThe Fan-Out driver provides one-way synchronization to a heterogeneous mix of systems including Linux and UNIX systems, and IBM i5/OS* (OS/400* operating system) and z/OS systems. The Fan-Out driver also provides authentication redirection from those systems.\n\nMoving to the Identity Manager 4.7 driver for ACF2 provides a few advantages:\n\n- **Bidirectional Synchronization:** The new driver architecture allows you to synchronize every field from the Logonid record of the connected ACF2 system.\n- **Identity Manager Policies and Packages:** The Fan-Out driver makes minimal use of the Identity Manager policies.\n- **Password Phrases:** The new driver supports ACF2 password phrases.\n\nConsider the following before migrating from the Fan-Out driver:\n\n- **Heterogeneity:** The Fan-Out driver supports operating system environments besides ACF2. You can continue to use the Fan-Out driver for those systems while using the Identity Manager 4.7 driver for ACF2 on your ACF2 systems.\n- **Authentication Redirection:** The Fan-Out driver provides authentication redirection using the password exit. The Identity Manager 4.7 driver for ACF2 provides bidirectional password synchronization.\n\n4.1 Preparing for Migration\n\nNetIQ® recommends that you perform the upgrade in a test environment similar to your production environment before upgrading production systems.\n\nBefore beginning the upgrade process, review Chapter 3, “Installing the ACF2 Driver,” on page 27.\n\nTo prepare for installing the upgrade:\n\n1. Verify that you have the required knowledge and skills.\n For details, see Section 3.2, “Required Knowledge and Skills,” on page 27.\n2. Ensure that the prerequisites are met.\n3 Prepare the distribution files for installation.\n For details, see Section 3.4, “Getting the Installation Files,” on page 28.\n\n4.2 Migrating Fan-Out Driver Platform Services to the ACF2 Driver\n\nTo migrate, follow these tasks on your target platform system:\n\n1 Stop the following started tasks:\n - PLATRCVR\n - ASCLIENT\n\n2 Remove ASCLIENT and PLATRCVR from your system startup and shutdown procedures.\n\n3 Remove the Fan-Out driver’s ACF2 exits.\n For details on uninstalling ACF2 exits, see the Identity Manager 4.7 Fan-Out Driver for Mainframes Administration Guide, which is available at the Identity Manager 4.7 Drivers Documentation Web site (https://www.netiq.com/documentation/identity-manager-47-drivers).\n\n4 Install the driver shim on the connected system.\n For details, see Section 3.6, “Installing the Driver Shim on the Connected System,” on page 34.\n\n4.3 Configuring the Driver\n\nTo configure the driver:\n\n1 Install and set up the Identity Manager driver for ACF2 on the Metadirectory server.\n For details, see Section 3.5, “Creating the Driver in Designer,” on page 29.\n\n2 Make any required policy modifications.\n For more information about policy customization, see the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\n3 Start the driver.\n Click the upper right corner of the driver icon, then click Start driver.\n\n4 Migrate the users to make new associations.\n For details, see Section 5.3.1, “Migrating Identities from the Identity Vault to the Connected System,” on page 51 and Section 5.3.2, “Migrating Identities from the Connected System to the Identity Vault,” on page 51.\n\n4.4 Post-Migration Tasks\n\nPerform the tasks listed in Section 3.7, “Post-Installation Tasks,” on page 42.\n\nAfter the new driver is operating properly, you can remove the Fan-Out driver components:\n\n1 Delete the Platform object from the Fan-Out driver configuration.\n\n2 On the connected system, uninstall Platform Services.\nIf this is the last platform being served by the Fan-Out driver, you can uninstall the Fan-Out core driver.\n\n3a Remove the ASAM directory from the file system, by running the `fandrv-uninstall` script.\n3b Remove the ASAM System container object and all of its subordinates from the tree.\n3c Uninstall the Fan-Out driver iManager plug-in.\n5 Configuring the ACF2 Driver\n\nAfter you have installed the Identity Manager 4.7 driver for ACF2, use the information in this section for configuration. Topics include\n\n- Section 5.1, “The Driver Shim Configuration File,” on page 49\n- Section 5.2, “Setting the Remote Loader and Driver Object Passwords,” on page 50\n- Section 5.3, “Migrating Identities,” on page 51\n- Section 5.4, “International Considerations,” on page 52\n\n5.1 The Driver Shim Configuration File\n\nThe driver shim configuration file controls operation of the driver shim. You can specify the configuration options listed in Table 5-1, one per line. You can also specify these options on the command line. For details about driver shim command line values, see Section C.1, “Driver Shim Command Line Options,” on page 105.\n\nThe driver shim configuration file must be a sequential file or a member of a partitioned data set. The DRVCONF DD statement in the driver shim started task JCL identifies the driver shim configuration file. An example driver shim configuration file is provided in the driver samples library member DRVCONF.\n\nTable 5-1 Driver Shim Configuration File Statements\n\n<table>\n<thead>\n<tr>\n<th>Option (Short and Long Forms)</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-conn <connString></td>\n<td>A string with connection options. Enclose the string in double quotes (" ). If you specify more than one option, separate the options with spaces.</td>\n</tr>\n<tr>\n<td>-connection <connString></td>\n<td>port=<driverShimPort></td>\n</tr>\n<tr>\n<td>-hp <httpPort></td>\n<td>ca=<Certificate Authority Key File></td>\n</tr>\n<tr>\n<td>-httpport <httpPort></td>\n<td>Specifies the HTTP services port number. The default HTTP services port number is 8091. You can connect to this port to view log files. For details, see Section A.1.2, “The Trace File,” on page 75 and Section A.1.5, “The Status Log,” on page 76.</td>\n</tr>\n<tr>\n<td>-path <driverPath></td>\n<td>Specifies the path for driver files. The default path is /opt/novell/acf2drv.</td>\n</tr>\n<tr>\n<td>-sp <RLpassword>,<DOpassword>,</td>\n<td>Sets the Remote Loader and Driver object passwords.</td>\n</tr>\n<tr>\n<td>-setpassword <RLpassword>,<DOpassword>,</td>\n<td></td>\n</tr>\n<tr>\n<td>-t <traceLevel></td>\n<td>Sets the level of debug tracing. 0 is no tracing, and 10 is all tracing. For details, see Section A.1.2, “The Trace File,” on page 75.</td>\n</tr>\n<tr>\n<td>-trace <traceLevel></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n5.2 Setting the Remote Loader and Driver Object Passwords\n\nThe Remote Loader password is used by the Metadirectory engine to authenticate itself to the driver shim (embedded Remote Loader). The Driver object password is used by the driver shim to authenticate itself to the Metadirectory engine.\n\nThese passwords are set during installation. You can set them at any time later using the procedures in the following sections. The corresponding passwords you set on the connected system and in the Identity vault must be identical.\n\n- Section 5.2.1, “Connected System,” on page 50\n- Section 5.2.2, “Identity Vault,” on page 50\n\n5.2.1 Connected System\n\nThe Remote Loader and Driver object passwords are stored on the connected system under /opt/novell/acf2drv/keys in encrypted files dpwdlf40 (Driver object password) and lpwdlf40 (Remote Loader password).\n\nTo set the passwords on the connected system:\n\n1. Run the REXX exec in the REXX exec library member SETPWDS and respond to the prompts.\n2. Restart the driver shim started task.\n\n5.2.2 Identity Vault\n\nThe Remote Loader and Driver object passwords are set for the driver through iManager and are stored in the Identity Vault. Each password on the connected system must exactly match its counterpart in the Identity vault.\n\nTo change the passwords in the Identity Vault after driver installation:\n\n1. In iManager, navigate to the Driver Overview for the driver.\n2 Click the driver icon.\n3 Specify the Driver object password.\n4 Specify the Remote Loader password.\n The Remote Loader password follows the Authentication heading.\n5 Click Apply.\n6 Restart the driver.\n\n5.3 Migrating Identities\n\nWhen you first run the driver, you might have identities in the Identity Vault that you want to provision to the connected system, or vice versa. Identity Manager provides a built-in migration feature to help you accomplish this.\n\n- Section 5.3.1, “Migrating Identities from the Identity Vault to the Connected System,” on page 51\n- Section 5.3.2, “Migrating Identities from the Connected System to the Identity Vault,” on page 51\n- Section 5.3.3, “Synchronizing the Driver,” on page 52\n\n5.3.1 Migrating Identities from the Identity Vault to the Connected System\n\n1 In iManager, open the Identity Manager Driver Overview for the driver.\n2 Click Migrate from Identity Vault. An empty list of objects to migrate is displayed.\n3 Click Add. A browse and search dialog box that allows you to select objects is displayed.\n4 Select the objects you want to migrate, then click OK.\n\nTo view the results of the migration, click View the Driver Status Log. For details about the log, see Section A.1.5, “The Status Log,” on page 76.\n\nIf a user has a Distribution Password, the Distribution Password is migrated to the connected system as the user’s password. Otherwise, no password is migrated. For information about Universal Passwords and Distribution Passwords, see the appropriate version of the Password Management Administration Guide at the NetIQ Documentation Web site (https://www.netiq.com/documentation).\n\n5.3.2 Migrating Identities from the Connected System to the Identity Vault\n\n1 In iManager, open the Identity Manager Driver Overview for the driver.\n2 Click Migrate into Identity Vault to display the Migrate Data into the Identity Vault window.\n3 Specify your search criteria:\n 3a To view the list of eDirectory™ classes and attributes, click Edit List.\n 3b Select class User.\n 3c Select the attributes to be used as search criteria for objects of the selected class, then click OK.\nThe eDirectory attributes map to ACF2 attributes as specified by the driver schema: CN maps to DirXML-ACF2-LID, etc. For the default mappings, see Table 1-2, “Default Schema Mapping and Filter,” on page 18.\n\n3d Specify values for the selected attributes, then click OK.\n\n4 Click OK.\n\nTo view the results of the migration, click View the Driver Status Log. For details about the log, see Section A.1.5, “The Status Log,” on page 76.\n\nBecause local passwords cannot be retrieved from ACF2, they cannot be submitted to the Metadirectory engine until they are changed. The password change exit routine captures password changes.\n\n5.3.3 Synchronizing the Driver\n\nTo generate events for associated objects that have changed since the driver’s last processing, open the Identity Manager Driver Overview page for the driver in iManager, then click Synchronize.\n\n5.4 International Considerations\n\nThe Identity Manager driver for ACF2 assumes the ACF2 system is using the EBCDIC Latin 1 (Open Systems) codepage for translating data to and from the Identity Manager Metadirectory engine. This codepage, IBM-1047, is configured in the SAMPLIB member ACF2DRV, the JCL for starting the ACF2 driver shim. If your system uses a codepage other than IBM-1047, you will need to change the JCL for starting the ACF2 driver to ensure correct character translation.\n\nThe following line, specified in the SAMPLIB(CEEOPT) member, illustrates how the environment is configured for the default codepage IBM-1047:\n\n```\nENVAR(\"LC_CTYPE=IBM-1047\")\n```\n\nYou may change this text to reflect the codepage of your ACF2 system. The format is IBM-CCSID, where CCSID is a coded character set identifier, represented in decimal.\n\nFor a list of valid codepage identifiers, see the IBM CCSID reference table (http://www-01.ibm.com/software/globalization/ccsid/ccsid_registered.jsp). The following table lists a subset of sample values:\n\n<table>\n<thead>\n<tr>\n<th>Codepage</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>IBM-858</td>\n<td>IBM-PC</td>\n</tr>\n<tr>\n<td>IBM-1047</td>\n<td>Latin 1 (Open Systems)</td>\n</tr>\n<tr>\n<td>IBM-1140</td>\n<td>US/Canada</td>\n</tr>\n<tr>\n<td>IBM-1141</td>\n<td>Austria/Germany</td>\n</tr>\n<tr>\n<td>IBM-1142</td>\n<td>Denmark/Norway</td>\n</tr>\n<tr>\n<td>IBM-1143</td>\n<td>Finland/Sweden</td>\n</tr>\n<tr>\n<td>IBM-1144</td>\n<td>Italy</td>\n</tr>\n<tr>\n<td>IBM-1145</td>\n<td>Spain/Spanish Latin America</td>\n</tr>\n<tr>\n<td>IBM-1146</td>\n<td>UK</td>\n</tr>\n<tr>\n<td>IBM-1147</td>\n<td>France</td>\n</tr>\n<tr>\n<td>Codepage</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>----------</td>\n<td>-------------</td>\n</tr>\n<tr>\n<td>IBM-1148</td>\n<td>International</td>\n</tr>\n<tr>\n<td>IBM-1149</td>\n<td>Iceland</td>\n</tr>\n</tbody>\n</table>\nCustomizing the ACF2 Driver\n\nThis section provides information about available resources for customizing the Identity Manager 4.7 driver for ACF2.\n\nTopics include\n\n- Section 6.1, “The Scriptable Framework,” on page 55\n- Section 6.3, “The Connected System Include/Exclude File,” on page 63\n- Section 6.4, “Managing Additional Attributes,” on page 67\n\nFor details about the filters and policies provided with the driver, see Section 1.2.2, “ACF2 Default Configuration,” on page 18 and Section 1.2.4, “ACF2 Password Synchronization,” on page 19.\n\n6.1 The Scriptable Framework\n\nThe driver provides a comprehensive scriptable framework that you can use to add to the built-in support for the security system, and to add support for other applications and security system fields that have been customized for a particular installation.\n\nThe driver’s scriptable framework includes components that simplify the job of extending the driver to support new applications and fields.\n\n- Embedded Remote Loader\n - Full SSL support, and an installer to easily configure the certificates\n - Web access to debugging information from the embedded Remote Loader\n- Encrypted change log that stores changes from the application to the Identity Vault if there is a communication problem\n- Loopback detection system to prevent subscribed events from being published back to the Identity Vault\n- z/OS name/token callable services helper programs that provide for securely passing large variables to and from the REXX execs\n- Easily extendable connected system schema file to support any application\n- Include/exclude file for simplified testing and deployment by the platform administrator\n- Event support, both for applications that have exits or callouts, and for applications that must be polled for changes\n\nThe names of objects and attributes in the REXX execs are the names specified in the connected system schema file.\n\nThe following tables describe the major REXX execs.\n### Table 6-1 Identity Vault Command Processing Execs\n\n<table>\n<thead>\n<tr>\n<th>REXX Exec</th>\n<th>Identity Vault Event</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>IDMADDG</td>\n<td>Add Group</td>\n</tr>\n<tr>\n<td>IDMADDO</td>\n<td>Add User</td>\n</tr>\n<tr>\n<td>IDMDELG</td>\n<td>Delete Group</td>\n</tr>\n<tr>\n<td>IDMDELU</td>\n<td>Delete User</td>\n</tr>\n<tr>\n<td>IDMMDLG</td>\n<td>Modify Group</td>\n</tr>\n<tr>\n<td>IDMMODU</td>\n<td>Modify User</td>\n</tr>\n<tr>\n<td>IDMDPDPW</td>\n<td>Password Change</td>\n</tr>\n<tr>\n<td>IDMQUERY</td>\n<td>Query</td>\n</tr>\n<tr>\n<td>IDMHOPW</td>\n<td>Check Password</td>\n</tr>\n</tbody>\n</table>\n\n### Table 6-2 Other Execs\n\n<table>\n<thead>\n<tr>\n<th>REXX Exec</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>IDMSUB</td>\n<td>Calls the appropriate command processing exec based on the type of event and object. This is executed for every Subscriber event.</td>\n</tr>\n<tr>\n<td>IDMPOLL</td>\n<td>Not used for ACF2. You can use this exec as needed to support your own applications if they do not generate events when changes are made.</td>\n</tr>\n<tr>\n<td>IDMHRTBT</td>\n<td>Heartbeat exec.</td>\n</tr>\n<tr>\n<td>IDMGLBLS</td>\n<td>Holds configurable options that all REXX execs can use during event processing.</td>\n</tr>\n<tr>\n<td>IDMSTATS</td>\n<td>Sends a status document to report the health of the application.</td>\n</tr>\n<tr>\n<td>IDMTSOEX</td>\n<td>Executes a TSO command and returns the command return code and command output.</td>\n</tr>\n<tr>\n<td>SETPWDS</td>\n<td>Sets the Remote Loader and Driver object passwords, which are used to authenticate and authorize the connection between the driver shim started task and the Metadirectory system.</td>\n</tr>\n<tr>\n<td>SETCERT</td>\n<td>Retrieves the certificate authority for the Metadirectory engine that uses SSL to communicate with the driver shim started task.</td>\n</tr>\n</tbody>\n</table>\n\n### 6.1.1 Modifying a REXX Exec\n\nEach of the REXX execs that come with the driver is designed with a common format, which makes it easy to read, edit, and maintain. Following are functional descriptions of the standard sections included in each exec:\n\n- Retrieve subscriber shim variables, using IDMGETV sub.\n- Retrieve event data variables, using IDMGETV event.\n- Trace a useful message to be logged to the TSO print file.\n- Provide comments instructing where to insert custom code before the TSO command is executed.\n- Execute the TSO command stored in variable `ACF2CMD`, which performs the basic action.\n- Provide comments instructing where to insert custom code after the TSO command has been executed.\n- Return of status document, using the `IDMSTATS` function.\n\n**Retrieving and Returning Information with `IDMGETV` and `IDMSETV`**\n\nThe REXX execs use `IDMGETV` to obtain information about the event and about the properties configured on the ACF2 driver. The REXX execs use `IDMSETV` to return information to the driver shim or Metadirectory engine for processing. Both `IDMGETV` and `IDMSETV` are utilities, found in the distribution `LOAD` library, which transport information between REXX variables and memory storage. When information is retrieved using `IDMGETV`, the REXX variables will be created and populated and a special variable, `VariableList`, will also be created to contain a list of the available REXX variables from the shim.\n\nTo check for the existence of a REXX variable, set by `IDMGETV`, use:\n\n```plaintext\nif wordpos(\"VariableName\", VariableList) > 0; then do;\n /* REXX variable, VariableName exists and was created by IDMGETV */\nend;\n```\n\nWhere `VariableName` is the name of the variable of interest. Event variables will contain the prefix `ADD_` or `REMOVE_` to indicate that this attribute has been added or removed from the object in question. For example, to check if the `REVOKE` field has been removed:\n\n```plaintext\nif wordpos(\"REMOVE_REVOKED\", VariableList) > 0; then do;\n /* User had REVOKED value removed */\nend;\n```\n\nFor example, if the following XDS document is sent to the ACF2 driver shim:\n\n```xml\n<modify class-name=\"User\" event-id=\"12345\">\n <association>IBMUSER</association>\n <modify-attr attr-name=\"NAME\">\n <remove-value>\n <value>IBMUSER</value>\n </remove-value>\n <add-value>\n <value>THE IBMUSER</value>\n </add-value>\n </modify-attr>\n</modify>\n```\n\nThe resulting REXX variables would look like:\n\n```plaintext\nCOMMAND=modify\nCLASS_NAME=User\nEVENT_ID=12345\nASSOCIATION=IBMUSER\nREMOVE_NAME=IBMUSER\nADD_NAME=THE IBMUSER\n```\n\nWhen attributes are mapped to REXX variables, all invalid REXX variable characters are converted into underscore (\"_\") characters. These include \"-\", \"@\" and \"..\".\n**Multivalued (Stem) Variables**\n\nWhen attributes are multivalued, IDMGETV assigns a suffix to the variable name to index its values. The count of the number of values is represented by suffix .0 and the values are represented from .1 to .n, where n is the total count. For example, if the variable CLASSES was multivalued with values: CLS1, CLS2, CLS3, the following variables would be created:\n\n```\nCLASSES.0=3\nCLASSES.1=CLS1\nCLASSES.2=CLS2\nCLASSES.3=CLS3\n```\n\nTo iterate over each value, use a REXX do loop:\n\n```\ndo i = 1 to CLASSES.0\n class = CLASSES.i\nend;\n```\n\n**Returning Status Documents Using IDMSTATS**\n\nIdentity Manager uses status documents, returned by the driver, to investigate whether an event was processed by the driver shim. Therefore, it's important for the REXX execs to return a status document indicating whether the event was successful or resulted in an error. Use the supplied REXX exec, IDMSTATS, to return a status document:\n\n```\nx = IDMSTATS(\"success\", \"Event was processed successfully\", EVENT_ID);\n```\n\nThe IDMSTATS script takes three parameters: level, message and event id. The level must be one of: success, error, warning, retry or fatal.\n\n```\n<status level=\"success\" event-id=\"12345\">\n Event was processed successfully\n</status>\n```\n\n**Understanding the ACF2CMD Variable**\n\nBefore an XDS command is sent to the driver shim, the Output Transformation policy converts the XDS document into a ACF2 TSO administrative command and stores the result in the attribute, ACF2CMD. This process avoids adding parsing logic inside the REXX execs to build the command, making the REXX execs cleaner, shorter, and easier to read. Therefore the default action of each REXX exec is to look for the ACF2CMD variable, which may be multivalued, and execute the command by default.\n\n**Using IDMTRACE To Print Messages**\n\nIDMTRACE is another REXX exec, supplied by the driver distribution, that allows you to simply trace a message to the TSO print file (SYSTSPRT), allocated by the ACF2DRV JCL. It will only trace messages if ENABLE_TRACE is set to true in IDMGLBLS. It will also print the date and time before the message for convenience.\n\n```\nx = IDMTRACE(\"IDMADDU is running for user <\"ADD_LID\">.\");\n```\nGlobal Settings in member IDMGLBLS\n\nThe REXX exec **IDMGLBLS** is a simple script containing global settings that all scripts may use. It provides a common repository of variables you may change to alter the behavior of the other REXX execs. There are four variables of interest:\n\n- **SUBCOMMAND_SEPARATOR**: Defines the character to be recognized as a delimiter between lines of output received from TSO when executing commands that produce output. The default is the EBDIC newline character.\n- **MESSAGE_PREFIX**: Defines a string that precedes lines in the TSO print file (**SYSTSPRT**) in which a TSO command is about to be executed. The default is -->TSO:\n- **DISPLAY_TSO_OUTPUT**: A boolean variable that controls whether TSO output received from a command should be displayed in the TSO print file (**SYSTSPRT**). The default is true.\n- **ENABLE_TRACE**: A boolean variable that controls whether **IDMTRACE** messages should be displayed. The default is true.\n\n**NOTE**: Enabling trace can be useful for troubleshooting and log collecting; however, disabling trace can reduce the amount of output that is saved in the **SYSTSPRT** file.\n\nUsing IDMTSOEX To Execute A TSO Command\n\nIn REXX, a TSO command can be evaluated simply by entering the command on its own line:\n\n```rexx\ncmd = \"ALU IBMUSER NAME(IBMUSER)IDMTRACE\");\n\\$\n```\n\nThe **IDMTSOEX** exec, also supplied by the distribution, will provide a few other options:\n\n- Log the command (password sanitized) using **IDMTRACE**\n- Trap the output and return code from the command\n- Return the code and output of the command to the caller\n\nIt's convenient to use this output to display a message back to the engine through a status document:\n\n```rexx\nresponse = IDMTSOEX(\"ALU IBMUSER NAME(IBMUSER) \");\n// first word is the return code */\nif word(cmd_response) > 0 then do;\n x = IDMSTATS(\"error\", response, EVENT_ID);\nend;\nelse do;\n x = IDMSTATS(\"success\", response, EVENT_ID);\nend;\n```\n\nPutting It All Together\n\nThe following code sample illustrates how the IMMADDU exec can be modified to additionally create an OMVS home directory:\n/* retrieve subscriber variables */\n\"IDMGETV sub\";\n\n/* retrieve event variables */\n\"IDMGETV event\";\n\n/* trace a message to SYSTSPRT */\nxx = idmtrace(\"IDMADDU running for user <\"ADD_LID\">.\");\n\n/* INSERT CUSTOM CODE HERE */\n\nAdd any custom code here that needs to be executed before creating the user in the ACF2 database.\n\n/* Add the user to the ACF2 database using a TSO command */\nif wordpos(\"ADD_ACF2CMD.0\", variablelist) <= 0; then do;\n /* we did not get a ACF2CMD from the event document */\n success = IDMSTATS(\"error\", \"No ACF2 command found\", EVENT_ID);\n exit 0;\nend;\n\n do i = 1 to ADD_ACF2CMD.0\n tscodm = ADD_ACF2CMD.i\n /* For an event, multiple TSO commands may be generated */\n cmd_response = IDMTSOEX(tscodm);\n /* Check the return code from our command */\n if word(cmd_response, 1) > 0 then do;\n /* an error occurred, report an error and exit from script */\n success = IDMSTATS(\"error\", cmd_response, EVENT_ID);\n exit 0;\n end;\n else do;\n success = IDMSTATS(\"success\", cmd_response, EVENT_ID);\n end;\nend;\n\n/* INSERT CUSTOM CODE HERE */\nAdd any custom code here that needs to be executed after creating the user in the ACF2 database.\n\n/* check for the home directory attribute and create it */\nif wordpos(\"ADD_OMVSHOME\", Variablelist) > 0; then do\n makeDir = \"cshell mkdir '\"ADD_OMVS_HOME'\";\n response = IDMTSOEX(makeDir);\n if word(response, 1) > 0 then do;\n x = IDMSTATS(\"warning\", response, EVENT_ID);\n end;\nend;\n\n/* All is successful, so we need to return an association for this user. */\nparse upper var ADD_LID ASSOCIATION;\n\"IDMSETV MODIFY NAME(COMMAND) VALUE(ADD_ASSOCIATION)\";\n\"IDMSETV MODIFY NAME(ASSOCIATION) VALUE(\"ASSOCIATION\")\";\n\"IDMSETV MODIFY NAME(EVENT_ID) VALUE(\"EVENT_ID\")\";\n\nif SRC_DN <> \"SRC_DN\"; then\n \"IDMSETV MODIFY NAME(DEST_DN) VALUE(\"SRC_DN\")\";\nend;\n\nif SRC_ENTRY_ID <> \"SRC_ENTRY_ID\"; then\n \"IDMSETV MODIFY NAME(DEST_ENTRY_ID) VALUE(\"SRC_ENTRY_ID\")\";\nend;\n\n/* Exit the script with return code 0 (no error) */\nexit 0;\n\n6.2 The Connected System Schema File\n\nThe schema file on the connected system is used to specify the classes and attributes that are available on the system.\n\nThe schema file is read by the driver shim when the Metadirectory engine requests it. This typically happens at driver startup. The schema file is also used by the Policy Editor to map the schema of the Identity Vault to the schema of the external application.\n\nIf you change the schema file, you must restart the driver shim and the driver.\n\nThe REXX execs that are provided with the driver depend on the classes and attributes in the schema file that is provided with the driver.\n\nThe connected system schema file must be a sequential file or a member of a partitioned data set. The `SCHEMDEF` DD statement in the driver shim started task JCL identifies the schema file. An example schema file with the required classes and attributes is provided in the driver samples library member `SCHEMDEF`.\n\n- Section 6.2.1, \"Schema File Syntax,\" on page 61\n- Section 6.2.2, \"Example Schema File,\" on page 62\n\n6.2.1 Schema File Syntax\n\nEach line in the schema file represents an element and must begin with the element name: `SCHEMA`, `CLASS`, or `ATTRIBUTE`.\n\nThe first element of the schema file is the schema definition. The schema definition is followed by class definitions. Each class definition can contain attribute definitions.\n\nExcept for the values of class and attribute names, the contents of the schema file are case insensitive.\n\nComments\n\nLines that begin with an octothorpe (#) are comments.\n\n # This is a comment.\n\nSchema Definition\n\nThe first line in the schema file that is not a comment must be the schema definition.\nSCHEMA [HIERARCHICAL]\n\nHIERARCHICAL specifies that the target application is not a flat set of users and groups, but is organized by hierarchical components, such as a directory-based container object.\n\nClass Definition\n\nCLASS className [CONTAINER]\n\nYou must specify a class name. Enclose the class name in double quotes (\"”) if it contains spaces. Add the CONTAINER keyword if objects of this class can contain other objects. End the class definition by another class definition or by the end of the file.\n\nAttribute Definition\n\nAny number of attribute definitions can follow a class definition. Attribute definitions define attributes for the class whose definition they follow.\n\nATTRIBUTE attributeName [TypeAndProperties]\n\nAn attribute name is required. Enclose the attribute name in double quotes (\"”) if it contains spaces. If no attribute type is specified, the default is STRING. Allowable types are:\n\n- STRING\n- INTEGER\n- STATE\n- DN\n\nAllowable attribute properties are:\n\n- REQUIRED\n- NAMING\n- MULTIVALUED\n- CASESENSITIVE\n- READONLY\n\n6.2.2 Example Schema File\n\nFor a complete example connected system schema file, see the driver samples library member SCHEMDEF. An excerpt from that file follows.\n\n SCHEMA\n CLASS Logonid\n ATTRIBUTE LID NAMING REQUIRED\n ATTRIBUTE MAXDAYS INTEGER\n ATTRIBUTE ACCOUNT STATE\n6.3 The Connected System Include/Exclude File\n\nYou can use an optional include/exclude file on the connected system to control which identities are or are not synchronized from the Identity Vault to the connected system.\n\nTo control which objects are synchronized from the connected system to the Identity Vault, use policies. For details about customizing policies, see the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\nThe connected system include/exclude file must be a sequential file or a member of a partitioned data set. The INCEXC DD statement in the driver shim started task JCL identifies the include/exclude file. An example include/exclude file that excludes many common z/OS users, such as JES, OMVS, and INIT, is provided in the driver samples library member INCEXC.\n\nThe file is read when the driver shim starts. If you make changes to it, you must restart the driver shim.\n\nThe include/exclude file can contain rules for both including and excluding accounts. To ensure optimal performance, each include/exclude file should contain no more than 50 entries total.\n\nYou can use the include/exclude file to phase in your deployment of the driver, excluding most users at first, and then adding more as you gain confidence and experience.\n\n- Section 6.3.1, “Include/Exclude Processing,” on page 63\n- Section 6.3.2, \"Include/Exclude File Syntax,\" on page 63\n- Section 6.3.3, “Example Include/Exclude Files,” on page 66\n\n6.3.1 Include/Exclude Processing\n\nIdentity Vault events for identities that match an exclude rule are discarded by the Subscriber shim.\n\nIncluded identities are treated normally by the Subscriber shim.\n\nIdentities that do not match an include rule or an exclude rule in the file are included.\n\nIdentities are matched in the following priority:\n\n1. Exclude rules\n2. Include rules\n\nWithin each level of this matching priority, identities are matched against rules in the order that the rules appear in the file. The first rule that matches determines whether the identity is included or excluded.\n\n6.3.2 Include/Exclude File Syntax\n\nExcept for class names, attribute names, and the values to match, the contents of the include/exclude file are case insensitive.\n\nThe Subscriber Creation policy converts object names to uppercase. Use uppercase names in the include/exclude file to match identities.\n\nThe include/exclude file can contain any number of include sections, exclude sections, and single-line rules.\nInclude sections and exclude sections can contain class matching rules, and class matching rules can contain attribute matching rules. Include sections and exclude sections can also contain association matching rules.\n\nClass and attribute names used in the include/exclude file must correspond to the names specified in the schema file. For details about the schema file, see Section 6.2, “The Connected System Schema File,” on page 61.\n\nComments\n\nLines that begin with an octothorpe (#) are comments.\n\n # This is a comment.\n\nInclude and Exclude Sections\n\nInclude and exclude sections provide rules to specify which objects are to be included or excluded from synchronization.\n\nAn include section begins with an INCLUDE line and ends with an ENDFILE line.\n\n INCLUDE\n .\n ENDFILE\n\nAn exclude section begins with an EXCLUDE line and ends with an ENDEXCLUDE line.\n\n EXCLUDE\n .\n ENDEXCLUDE\n\nYou can use class matching rules and association matching rules within an include section and an exclude section.\n\nClass Matching Rules\n\nUse a class matching rule within an include section or an exclude section to specify the name of a class of objects to include or exclude.\n\nA class matching rule is defined by a class line that specifies the name of the class and ends with an ENDC class line.\n\n CLASS className\n .\n ENDCCLASS\n\nYou can use attribute matching rules within a class matching rule.\nAttribute Matching Rules\n\nYou can use attribute matching rules within a class matching rule to limit the objects that are included or excluded. If no attribute matching rules are specified for a class, all objects of the specified class are included or excluded.\n\nAn attribute matching rule comprises an attribute name, an equals sign (=), and an expression. The expression can be an exact value, or it can use limited regular expressions. For details about limited regular expressions, see “Limited Regular Expressions” on page 66.\n\n```plaintext\nattributeName=expression\n```\n\nMultiple attribute matching rules can be specified for a given class.\n\nAttribute matching rules within a class matching rule are logically ANDed together. To logically OR attribute matching rules for a class, specify multiple class matching rules. For example, the following include/exclude file excludes both user01 and user02:\n\n```plaintext\n# Exclude the User object if its ACF2 LID is USER01 or USER02.\nEXCLUDE\nCLASS Logonid\n LID=USER01\nENDCLASS\nCLASS Logonid\n LID=USER02\nENDCLASS\nENDEXCLUDE\n```\n\nAssociation Matching Rules\n\nYou can specify association matching rules in an include or exclude section. Association matching rule expressions can specify an exact association or a limited regular expression. For details about limited regular expressions, see “Limited Regular Expressions” on page 66.\n\nBy default, an association is the ACF2 user ID. Association formation can be customized in the Subscriber REXX execs.\n\nFor example, to exclude the root user, specify\n\n```plaintext\nEXCLUDE\n ACFUSER\nENDEXCLUDE\n```\n\nSpecial Considerations\n\nUsing the Include/Exclude rules can be a convenient way to control processing decisions from the ACF2 administration point. They can quickly filter events before they reach the Identity Manager Metadirectory engine, thus saving time and resources. However, it is not recommended that you use the Include/Exclude rules for processing if you plan to create more than 50 rules. Each rule adds additional complexity that the driver shim must process for every event.\n\nSingle-Line Rules\n\n```plaintext\nINCLUDE|EXCLUDE [className] objectSelection\n```\n\nWhere `objectSelection` can be\n\n```plaintext\nassociationMatch | attributeName=expression\n```\n\nYou must specify whether the rule is to include or exclude the objects it matches.\n\nYou can specify a class name to limit matches to only objects of that class.\nYou must specify either an association or an attribute matching expression. The syntax of the association and attribute matching expression is the same as that of association matching rules and attribute matching rules previously described. For details, see “Association Matching Rules” on page 65 and “Attribute Matching Rules” on page 65.\n\nFor example, to ignore events from the Admin user in the Identity Vault:\n\n```bash\n# Do not subscribe to events for the Admin user.\nEXCLUDE ADMIN\n```\n\n**Limited Regular Expressions**\n\nA limited regular expression is a pattern used to match a string of characters.\n\nCharacter matching is case sensitive.\n\nAny literal character matches that character.\n\nA period (.) matches any single character.\n\nA bracket expression is a set of characters enclosed by left ( [ ) and right ( ] ) brackets that matches any listed character. Within a bracket expression, a range expression is a pair of characters separated by a hyphen, and is equivalent to listing all of the characters that sort between the given characters. For example, \\[0-9\\] matches any single digit.\n\nAn asterisk (*) indicates that the preceding item is matched zero or more times.\n\nA plus sign (+) indicates that the preceding item is matched one or more times.\n\nA question mark (?) indicates that the preceding item is matched zero or one times.\n\nYou can use parentheses to group multiple expressions into a single item. For example, \\(abc\\) matches `abc`, `abcabc`, `abcabcabc`, etc. Nesting of parentheses is not supported.\n\n### 6.3.3 Example Include/Exclude Files\n\n**Example 1**\n\n```bash\n# Exclude users whose names start with TEMP\nEXCLUDE\n CLASS Logonid\n LID=TEMP.*\n ENDCLASS\nENDEXCLUDE\n```\n\n**Example 2**\n\n```bash\n# Exclude USERA and USERB\n# Because attribute rules are ANDed, these must be in separate\n# CLASS sections.\nEXCLUDE\n CLASS Logonid\n LID=USERA\n ENDCLASS\n CLASS Logonid\n LID=USERB\n ENDCLASS\nENDEXCLUDE\n```\n6.4 Managing Additional Attributes\n\nYou can add additional attributes to the driver for both the Publisher and Subscriber channels. These attributes can be accessed by the REXX execs for all event types.\n\nTo publish or subscribe to additional attributes, you must add them to the filter and add support for them into the REXX execs.\n\n- Section 6.4.1, “Modifying the Filter,” on page 67\n\n6.4.1 Modifying the Filter\n\n1. On the iManager Driver Overview page for the driver, click the Filter icon on either the Publisher or Subscriber channel. It is the same object.\n2. In the Filter Edit dialog box, click the class containing the attribute to be added.\n3. Click Add Attribute, then select the attribute from the list.\n4. Select the flow of this attribute for the Publisher and Subscriber channels.\n - **Synchronize:** Changes to this object are reported and automatically synchronized.\n - **Ignore:** Changes to this object are not reported and not automatically synchronized.\n - **Notify:** Changes to this object are reported, but not automatically synchronized.\n - **Reset:** Resets the object value to the value specified by the opposite channel. (You can set this value on either the Publisher or Subscriber channel, but not both.)\n5. Click Apply.\n\nIf you want to map this attribute to an existing attribute in the connected system schema file, modify the Schema Mapping policy for the driver.\n\nFor complete details about managing filters and Schema Mapping policies, see the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\nThis section provides information about operational tasks commonly used with the Identity Manager 4.7 driver for ACF2.\n\nTopics include\n\n- Section 7.1, “Starting and Stopping the Driver,” on page 69\n- Section 7.2, “Starting and Stopping the Change Log Started Task,” on page 69\n- Section 7.3, “Starting and Stopping the Driver Shim Started Task,” on page 70\n- Section 7.4, “Displaying Driver Shim Status,” on page 70\n- Section 7.5, “Changing the Driver Shim Trace Level,” on page 70\n- Section 7.6, “Monitoring Driver Messages,” on page 70\n\n### 7.1 Starting and Stopping the Driver\n\nTo start the driver:\n\n1. In iManager, navigate to the Driver Overview for the driver.\n2. Click the upper right corner of the driver icon.\n3. Click Start driver.\n\nTo stop the driver:\n\n1. In iManager, navigate to the Driver Overview for the driver.\n2. Click the upper right corner of the driver icon.\n3. Click Stop driver.\n\n### 7.2 Starting and Stopping the Change Log Started Task\n\nThe change log started task must be run on each system that shares the security system database.\n\nTo start the change log started task, issue the following operator command:\n\n```\nSTART LDXLOGR\n```\n\nTo stop the change log started task, issue the following operator command:\n\n```\nSTOP LDXLOGR\n```\n7.3 Starting and Stopping the Driver Shim Started Task\n\nThe driver shim started task must be run on only one system that shares the security system database.\n\nTo start the driver shim started task, issue the following operator command:\n\n```\nSTART ACF2DRV\n```\n\nTo stop the driver shim started task, issue the following operator command:\n\n```\nSTOP ACF2DRV\n```\n\n7.4 Displaying Driver Shim Status\n\nTo see status, version and statistic information for the driver shim, issue the following operator command:\n\n```\nMODIFY ACF2DRV,APPL=STATUS\n```\n\nYou can use the `LDXSERV` TSO command to display information about the Publisher channel event subsystem. Enter the following TSO command:\n\n```\nLDXSERV STATUS\n```\n\nTo use the `LDXSERV` command, you must include the driver load library in your STEPLIB concatenation.\n\n7.5 Changing the Driver Shim Trace Level\n\nTo change the trace level setting for the driver shim, issue the following operator command with the desired trace level:\n\n```\nMODIFY ACF2DRV,APPL='CTL(desired_trace_level)'\n```\n\nFor example\n\n```\nMODIFY ACF2DRV,APPL='CTL(9)'\n```\n\nFor details about the trace file and trace levels, see Section A.1.2, “The Trace File,” on page 75.\n\n7.6 Monitoring Driver Messages\n\nThe driver shim started task writes messages to the system operator console and the driver operational log. The driver operational log data set is defined by the `DRVLOG DD` statement in the `ACF2DRV` started task JCL.\n\nMonitor driver activity there in the same way you monitor other key system functions. For details about the messages written by the driver, see Appendix B, “System and Error Messages,” on page 83.\nSecuring the ACF2 Driver\n\nThis section describes best practices for securing the Identity Manager 4.7 driver for ACF2. Topics include:\n\n- Section 8.1, “Using SSL,” on page 71\n- Section 8.2, “Auditing,” on page 71\n- Section 8.3, “Driver Security Certificates,” on page 71\n- Section 8.4, “Driver REXX Execs,” on page 72\n- Section 8.5, “The Change Log,” on page 72\n- Section 8.6, “Driver Passwords,” on page 72\n- Section 8.7, “Driver Code,” on page 72\n- Section 8.8, “Administrative Users,” on page 73\n- Section 8.9, “Connected Systems,” on page 73\n\nFor additional information about Identity Manager security, see the NetIQ® Identity Manager 4.7 Administration Guide on the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\n8.1 Using SSL\n\nEnable SSL for communication between the Metadirectory engine and the driver shim on the connected system. This option is enabled by default.\n\nIf you don’t enable SSL, you are sending information, including passwords, in the clear.\n\n8.2 Auditing\n\nTrack changes to sensitive information. Examine audit logs periodically.\n\nFor details about using NetIQ Audit to monitor driver operation, see the NetIQ Audit Documentation Web site (http://www.novell.com/documentation/novellaudit20/index.html).\n\nFor details about auditing ACF2, see your ACF2 Auditor Guide.\n\n8.3 Driver Security Certificates\n\nSSL uses security certificates to control, encrypt, and authenticate communications.\n\nEnsure that the security certificate directory /opt/novell/acf2drv/keys is appropriately protected. The installation program sets secure file permissions for this directory.\n\nThe Driver Shim and the Identity Manager engine communicate through SSL using a certificate created in the Identity Vault and retrieved by the driver shim during the installation process. For more information on this certificate and how to renew or install third-party certificates, refer to the Identity Manager Administration Guide.\nThe Embedded Remote Loader web interface uses a dynamically generated, self-signed certificate for SSL communication. The details of this certificate are as follows:\n\n<table>\n<thead>\n<tr>\n<th>Property Name</th>\n<th>Values / Parameters</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Subject</td>\n<td>SSL Server</td>\n</tr>\n<tr>\n<td>Issuer</td>\n<td>SSL Server</td>\n</tr>\n<tr>\n<td>Validity</td>\n<td>1 year</td>\n</tr>\n<tr>\n<td>Serial Number</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Key</td>\n<td>1024-bit RSA</td>\n</tr>\n</tbody>\n</table>\n\nRenewal of this certificate automatically occurs when the Driver Shim is restarted on the connected platform.\n\n### 8.4 Driver REXX Excs\n\nThe driver uses REXX execs to perform updates on the connected system and to collect changes made there.\n\nEnsure that the driver REXX exec library is appropriately protected.\n\n### 8.5 The Change Log\n\nThe change log data set contains information about events on the connected system, including passwords. It is encrypted, but it should be protected against access by unauthorized users.\n\nEnsure that the change log data set is appropriately protected.\n\n### 8.6 Driver Passwords\n\nUse strong passwords for the Driver object and Remote Loader passwords, and restrict knowledge of them to authorized personnel. These passwords are stored in encrypted form in the security certificate directory `/opt/novell/acf2drv/keys`. The installation program sets secure file permissions for this directory. These passwords should be changed periodically.\n\n### 8.7 Driver Code\n\nEnsure that the driver load library is appropriately protected.\n\nDo not put the driver load library in the linklist unless you use program protection to secure its contents against unauthorized use.\n8.8 Administrative Users\n\nEnsure that accounts with elevated rights on the Metadirectory system, Identity Vault systems, and the connected systems are appropriately secure. Protect administrative user IDs with strong passwords.\n\n8.9 Connected Systems\n\nEnsure that connected systems can be trusted with account information, including passwords, for the portion of the tree that is configured as their base containers.\nA Troubleshooting\n\nThis section provides information about troubleshooting the Identity Manager 4.7 driver for ACF2. Topics include\n\n- Section A.1, “Driver Status and Diagnostic Files,” on page 75\n- Section A.2, “Troubleshooting Common Problems,” on page 77\n\nA.1 Driver Status and Diagnostic Files\n\nThere are several log files that you can view to examine driver operation.\n\n- Section A.1.1, “The System Log,” on page 75\n- Section A.1.2, “The Trace File,” on page 75\n- Section A.1.3, “The REXX Exec Output File,” on page 76\n- Section A.1.4, “DSTRACE,” on page 76\n- Section A.1.5, “The Status Log,” on page 76\n- Section A.1.6, “The Operational Log,” on page 77\n- Section A.1.7, “Change Log Started Task Message Log,” on page 77\n\nA.1.1 The System Log\n\nSYSLOG is used by the driver shim to record urgent, informational, and debug messages. Examining these should be foremost in your troubleshooting efforts. For detailed message documentation, see Appendix B, “System and Error Messages,” on page 83.\n\nA.1.2 The Trace File\n\nThe default trace file exists on the connected system at /opt/novell/acf2drv/logs/trace.log. A large amount of debug information can be written to this file. Use the trace level setting in the driver shim configuration file to control what is written to the file. For details about the driver shim configuration file, see Section 5.1, “The Driver Shim Configuration File,” on page 49.\n\nTable A-1 Driver Shim Trace Levels\n\n<table>\n<thead>\n<tr>\n<th>Trace Level</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>No debugging.</td>\n</tr>\n<tr>\n<td>1–3</td>\n<td>Identity Manager messages. Higher trace levels provide more detail.</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Previous level plus Remote Loader, driver, driver shim, and driver connection messages.</td>\n</tr>\n<tr>\n<td>5–7</td>\n<td>Previous level plus change log and loopback messages. Higher trace levels provide more detail.</td>\n</tr>\n</tbody>\n</table>\nThe following is an example of the driver shim configuration file line to set the trace level:\n\n```bash\n-trace 9\n```\n\nTo view the trace file:\n\n1. Use a Web browser to access the driver shim at `https://driver-address:8091`. Substitute the DNS name or IP address of your driver for `driver-address`.\n2. Authenticate by using any user name and the password that you specified as the Remote Loader password.\n3. Click `Trace`.\n\n### A.1.3 The REXX Exec Output File\n\nOutput from the REXX execs is written to ddname `SYSTSPRT` of the driver shim started task. This file captures the standard error output from all execs executed by the driver shim.\n\n### A.1.4 DSTRACE\n\nYou can view Identity Manager information using the DSTRACE facility on the Metadirectory server. Use iManager to set the tracing level. For example, trace level 2 shows Identity Vault events in XML documents, and trace level 5 shows the results of policy execution. Because a high volume of trace output is produced, it is recommended that you capture the trace output to a file. For details about using DSTRACE, see the *NetIQ® Identity Manager 4.7 Administration Guide* on the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\n### A.1.5 The Status Log\n\nThe status log is a condensed summary of the events that have been recorded on the Subscriber and Publisher channels. This file exists on the connected system at `/opt/novell/acf2drv/logs/dirxml.log`. You can also view the status log in iManager on the Driver Overview page. You can change the log level to specify what types of events to log. For details about using the status log, see the *NetIQ Identity Manager 4.7 Administration Guide* on the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\nTo view the status log:\n\n1. Use a Web browser to access the driver shim at `https://driver-address:8091`. Substitute the DNS name or IP address of your driver for `driver-address`.\n2. Authenticate by using any user name and the password that you specified as the Remote Loader password.\n3. Click `Status`.\n\n<table>\n<thead>\n<tr>\n<th>Trace Level</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8</td>\n<td>Previous level plus driver status log, driver parameters, driver security, driver Web server, driver schema, driver encryption, and driver include/exclude file messages.</td>\n</tr>\n<tr>\n<td>9</td>\n<td>Previous level plus low-level networking and operating system messages.</td>\n</tr>\n<tr>\n<td>10</td>\n<td>Previous level plus maximum low-level program details (all options).</td>\n</tr>\n</tbody>\n</table>\nA.1.6 The Operational Log\n\nThe operational log contains both important and informational messages that indicate the operational status of the driver shim. These messages indicate items that are not urgent enough to warrant operator response, but useful for tracking the progress of the driver. The location of the operational log is specified by the `DRVLOG DD` statement in the driver shim started task JCL.\n\nA.1.7 Change Log Started Task Message Log\n\nThe change log started task writes important and informational messages to ddname `SYSPRINT`.\n\nA.2 Troubleshooting Common Problems\n\n- Section A.2.1, “Driver Shim Installation Failure,” on page 77\n- Section A.2.2, “Driver Certificate Setup Failure,” on page 77\n- Section A.2.3, “Driver Start Failure,” on page 78\n- Section A.2.4, “Driver Shim Startup or Communication Failure,” on page 78\n- Section A.2.5, “Users Are Not Provisioned to the Connected System,” on page 79\n- Section A.2.6, “Users Are Not Provisioned to the Identity Vault,” on page 79\n- Section A.2.7, “Identity Vault User Passwords Are Not Provisioned to the Connected System,” on page 79\n- Section A.2.8, “Connected System User Passwords Are Not Provisioned to the Identity Vault,” on page 80\n- Section A.2.9, “Users Are Not Modified, Deleted, Renamed, or Moved,” on page 80\n- Section A.2.10, “Change Log Errors,” on page 80\n\nA.2.1 Driver Shim Installation Failure\n\nEnsure that you use binary mode to FTP the driver samples library, load library, and REXX exec library XMT files to the target system.\n\nA.2.2 Driver Certificate Setup Failure\n\nTo set up certificates, the driver shim communicates with the Metadirectory server using the LDAP secure port (636).\n\n- Ensure that eDirectory™ is running LDAP with SSL enabled. For details about configuring eDirectory, see the NetIQ eDirectory Administration Guide.\n- Ensure that the connected system has network connectivity to the Metadirectory server.\n\nYou can use the driver REXX exec library member `SETCERT` to configure the certificate at any time. If you cannot configure SSL using LDAP, you can install the certificate manually.\n\n1. In iManager, browse the Security container to locate your tree’s certificate authority (typically named `treeName CA`).\n2. Click the certificate authority object.\n3. Click Modify Object.\n4 Select the Certificates tab.\n5 Click Public Key Certificate.\n6 Click Export.\n7 Select No to export the certificate without the private key, then click Next.\n8 Select Base64 format, then click Next.\n9 Click Save the exported certificate to a file, then specify a location to save the file.\n10 Use FTP or another method to store the file on the connected system as /opt/novell/acf2drv/keys/ca.pem.\n\nA.2.3 Driver Start Failure\n\n- Examine the status log and DSTRACE output.\n- The driver must be specified as a Remote Loader driver. You can set this option in the iManager Driver Edit Properties window.\n- You must activate both Identity Manager and the driver within 90 days. The Driver Set Overview page in iManager shows when Identity Manager requires activation. The Driver Overview page shows when the driver requires activation.\n \n For details about activating NetIQ Identity Manager Products, see the Identity Manager 4.7 Installation Guide on the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n- Ensure that the driver load library is APF-authorized.\n \n You can use the DISPLAY PROG,APF operator command to display your APF-authorized libraries.\n- Ensure that the LDXSERV and SAFQUERY commands are listed as authorized TSO commands in your active IKJTSOxx member.\n \n You can use the DISPLAY IKJTSO,AUTHCMD operator command to display authorized TSO commands.\n\n For more information about troubleshooting Identity Manager engine errors, see the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\nA.2.4 Driver Shim Startup or Communication Failure\n\n- Examine the trace file.\n- Ensure that the connected system’s operating system and security system versions are supported. For a list of supported operating systems, see “Connected System Requirements” on page 28.\n- Apply all maintenance for your operating system and security system.\n- Ensure that the Remote Loader and Driver object passwords that you specified while setting up the driver on the Metadirectory server match the passwords stored with the driver shim.\n \n To update these passwords on the connected system, use the SETPWDS REXX exec. The passwords are stored under /opt/novell/acf2drv/keys in encrypted files dpwdlf40 (Driver object password) and lpwdlf40 (Remote Loader password).\n \n To update these passwords on the Metadirectory server, use iManager to update the driver configuration.\n- Ensure that the correct host name and port number of the connected system are specified in the Driver Configuration Remote Loader connection parameters. You can change the port number (default 8090) in the driver shim configuration file.\n• Ensure that the driver shim started task has been set up properly. For details, see “Setting Up the Started Tasks” on page 38.\n• Ensure that only one system in a complex that shares the security system database is running the driver shim started task.\n\nA.2.5 Users Are Not Provisioned to the Connected System\n• Examine the status log, DSTRACE output, trace file, and REXX exec output file.\n• To be provisioned, users must be in the appropriate base container. You can view and change the base containers in iManager on the Global Configuration Values page of the Driver Edit Properties window.\n• To provision identities from the Identity Vault to the connected system, the driver Data Flow property must be set to Bidirectional or Identity Vault to Application. To change this value, re-import the driver rules file over your existing driver.\n• The user that the driver is security equivalent to must have rights to read information from the base container. For details about the rights required, see Table 2-2, “Base Container Rights Required by the Driver Security-Equivalent User,” on page 25.\n\nA.2.6 Users Are Not Provisioned to the Identity Vault\n• Examine the status log, DSTRACE output, and trace file.\n• Examine the User Base Container GCV values.\n• To provision identities from the connected system to the Identity Vault, the driver Data Flow property must be set to Bidirectional or Application to Identity Vault. To change this value, re-import the driver rules file over your existing driver.\n• The user that the driver is security equivalent to must have rights to update the base container. For details about the rights required, see Table 2-2, “Base Container Rights Required by the Driver Security-Equivalent User,” on page 25.\n• Ensure that the security system exit has been installed, that LLA has been refreshed, and that the exit has been activated. For details, see Section 3.6.8, “Installing the Driver Security System Exits,” on page 40.\n\nA.2.7 Identity Vault User Passwords Are Not Provisioned to the Connected System\n• Examine the status log, DSTRACE output, and REXX exec output file.\n• Several password management properties are available in iManager on the Global Configuration Values page of the Driver Edit Properties window. Ensure that the connected system accepts passwords from the Identity Vault. To determine the right settings for your environment, view the help for the options, or see the NetIQ Identity Manager 4.7 Administration Guide on the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n• Ensure that the user’s container has an assigned Universal Password policy and that the Synchronize Distribution Password When Setting Universal Password option is set for this policy.\nA.2.8 Connected System User Passwords Are Not Provisioned to the Identity Vault\n\n- Examine the status log, DSTRACE output, and the trace file.\n- Several password management properties are available in iManager on the Global Configuration Values page of the Driver Edit Properties window. Ensure that at least one of the following options is set:\n - The Identity Vault Accepts Passwords from the ACF2 Connected System\n - The Identity Vault Accepts Administrative Password Resets from the ACF2 Connected System\n\nTo determine the right settings for your environment, view the help for the options, or see the NetIQ Identity Manager 4.7 Administration Guide on the Identity Manager 4.7 Documentation Web site (https://www.netiq.com/documentation/identity-manager-47/).\n\n- If the Require Password Policy Validation before Publishing Passwords GCV is set, the user’s password must satisfy the password rules in the password policy assigned to the user container.\n- Ensure that the change log started task is running on all systems that share the security system database.\n- Ensure that the security system exit has been installed, that LLA has been refreshed, and that the exit has been activated. For details, see Section 3.6.8, “Installing the Driver Security System Exits,” on page 40.\n\nA.2.9 Users Are Not Modified, Deleted, Renamed, or Moved\n\n- Examine the status log, DSTRACE output, trace file, and REXX exec output file.\n- Examine the driver Data Flow setting to verify the authoritative source for identities.\n- Identity Vault and connected system identities must be associated before events are synchronized. To view an identity’s associations, use Modify User/Group in iManager and click the Identity Manager tab. You can migrate identities to establish associations. For details, see Section 5.3, “Migrating Identities,” on page 51.\n- Identity Vault move events can remove the identity from the base container monitored by the driver to a container that is not monitored by the driver. This makes the move appear to be a delete.\n- Moving a user is not supported by ACF2.\n\nA.2.10 Change Log Errors\n\n- Examine the change log started task messages.\n- Ensure that the change log started task is running on all systems that share the security system database.\n- Ensure that the change log started task has been set up properly. For details, see “Setting Up the Started Tasks” on page 38.\n- Ensure that you initialized the change log data set during installation. For details about initializing the change log data set, see Section 3.6.4, “Allocating and Initializing the Change Log Data Set,” on page 37.\n- You can use the LDXSERV TSO command to display information about the change log data set. Enter the following TSO command:\nLDXSERV STATUS\n\nTo use the LDXSERV command, you must include the driver load library in your STEPLIB concatenation.\nComponents of the Identity Manager 4.7 driver for ACF2 write messages to report operational status and problems. For detailed troubleshooting information, see Appendix A, “Troubleshooting,” on page 75.\n\nEach message begins with a code of 3-6 characters associated with the driver component that generated the message. Use this code to find message information quickly as follows:\n\n- Section B.1, “CFG Messages,” on page 83\n- Section B.2, “DOM Messages,” on page 84\n- Section B.3, “DRVCOM Messages,” on page 84\n- Section B.4, “HES Messages,” on page 85\n- Section B.5, “LDX0 Messages,” on page 85\n- Section B.6, “LDXL Messages,” on page 87\n- Section B.7, “LDXS Messages,” on page 90\n- Section B.8, “LDXU Messages,” on page 90\n- Section B.9, “LDXV Messages,” on page 93\n- Section B.10, “LWS Messages,” on page 95\n- Section B.11, “NET Messages,” on page 102\n- Section B.12, “RDXML Messages,” on page 102\n\n### B.1 CFG Messages\n\nMessages beginning with CFG are issued by configuration file processing.\n\n**CFG001E Could not open configuration file *filename*.**\n\nExplanation: Could not open the configuration file.\n\nPossible cause: The file does not exist.\n\nPossible cause: You don’t have permission to read the file.\n\nAction: Ensure that the configuration file exists at the correct location and that you have file system rights to read it.\n\n**CFG002E Error parsing configuration file line: `<configline>`.**\n\nExplanation: The line is not formatted as a valid configuration statement and cannot be parsed.\n\nAction: Correct the line in the configuration file.\nCFG003W Configuration file line was ignored. No matching statement name found: <configline>.\n\nExplanation: This line is formatted as a valid configuration file statement, but the statement is not recognized. The line is ignored.\n\nPossible cause: The statement is incorrectly typed or the statement name is used only in a newer version of the software.\n\nAction: Correct the statement.\n\nCFG004E Error parsing configuration file line. No statement name was found: <configLine>.\n\nExplanation: Could not find a statement name on the configuration line.\n\nAction: Correct the line in the configuration file to supply the required statement.\n\nCFG005E A required statement statement_id is missing from the configuration file.\n\nExplanation: The statement_id statement was not specified in the configuration file, but is required for the application to start.\n\nAction: Add the required statement to the configuration file.\n\nB.2 DOM Messages\n\nMessages beginning with DOM are issued by driver components as they communicate among themselves.\n\nDOM0001W XML parser error encountered: errorString.\n\nExplanation: An error was detected while parsing an XML document.\n\nPossible cause: The XML document was incomplete, or it was not a properly constructed XML document.\n\nAction: See the error string for additional details about the error. Some errors, such as no element found, can occur during normal operation and indicate that an empty XML document was received.\n\nB.3 DRVCOM Messages\n\nMessages beginning with DRVCOM are issued by the include/exclude system.\n\nDRVCOM0001 nameversion Copyright 2005 Omnibond Systems, LLC. ID=code_id_string.\n\nExplanation: This message identifies the system component version.\n\nAction: No action is required.\nDRVCOM001W Invalid include/exclude CLASS statement.\n Explanation: The include/exclude configuration file contains an invalid CLASS statement.\n Action: Correct the include/exclude configuration file with proper syntax.\n\nDRVCOM002D An include/exclude Rule was added for class: class.\n Explanation: The include/exclude configuration supplied a rule for the specified class.\n Action: None.\n\nDRVCOM003D An include/exclude Association Rule was added for association association.\n Explanation: The include/exclude configuration supplied an association rule for the specified association.\n Action: None.\n\nB.4 HES Messages\nMessages beginning with HES are issued by driver components as they use HTTP to communicate.\n\nHES001E Unable to initialize the HTTP client.\n Explanation: Communications in the client could not be initialized.\n Possible cause: Memory is exhausted.\n Action: Increase the amount of memory available to the process.\n\nHES002I Connecting to host host_name on port port_number.\n Explanation: The client is connecting to the specified server.\n Action: None.\n\nHES003W SSL communications have an incorrect certificate. rc = rc.\n Explanation: The security certificate for SSL services could not be verified.\n Possible cause: The certificate files might be missing or invalid.\n Action: Obtain a new certificate.\n\nB.5 LDX0 Messages\nMessages beginning with LDX0 are issued by the driver security system exit modules LIDPOST and LDXNPXT, the LDXSERV command and the ACP2DRV started task.\nLDX0001E There are old events on the LDX queue. Ensure that LDXLOGR is started.\n\n Explanation: The memory queue access routine in the security system exit found events in the memory queue that have been unprocessed for at least fifteen minutes. During normal operation, the change log started task processes events from the queue immediately.\n\n Possible cause: The change log started task is not running.\n\n Action: Ensure that the change log started task is running.\n\nLDX0002I Unexpected RC xxxxxxxx during token processing routine.\n\n Explanation: An unexpected return code was received from z/OS name/token callable services by a driver component.\n\n Possible cause: Internal system error.\n\n Action: Collect diagnostic information and contact NetIQ® Technical Support.\n\nLDX0103E Unable to parse command line.\n\n Explanation: The LDXSERV command contained invalid operands and was unable to prompt for correct information.\n\n Action: Correct the syntax of the LDXSERV command and reissue it. If the command was issued by the driver shim, collect diagnostic information and contact NetIQ Technical Support.\n\nLDX0105E Internal error: description.\n\n Explanation: An unexpected error occurred in the LDXSERV command. The message contains a description of the problem.\n\n Possible cause: Internal error.\n\n Action: Collect diagnostic information and contact NetIQ Technical Support.\n\nLDX0106E Unable to open the log file.\n\n Explanation: LDXSERV was unable to open the change log data set.\n\n Possible cause: The user ID running the LDXSERV command does not have access to the change log data set.\n\n Action: Check the session log and message files for additional messages concerning the failure. If you are unable to determine and correct the cause of the error, collect diagnostic information and contact NetIQ Technical Support.\n\nLDX0107E No preallocated log file and no valid environment.\n\n Explanation: The LDXSERV command was unable to find the change log data set because there was no LOGFILE DD statement and there was no valid LDX environment. The LDX environment is created when the security system exit is invoked for the first time after an IPL or when the change log started task first starts.\nAction: Ensure that you are logged on to a system where the driver is installed and that the security system exit has been properly installed and is active. If you are unable to determine and correct the cause of the error, collect diagnostic information and contact NetIQ Technical Support.\n\nLDX0108E No preallocated log file and logger is not active.\n\nExplanation: The LDXSERV command was unable to find the change log data set because there was no LOGFILE DD statement and the change log started task was not active.\n\nAction: If you are unable to determine and correct the cause of the error, collect diagnostic information and contact NetIQ Technical Support.\n\nLDX0109E Dynamic allocation failed for log file dsname, s99rc=rc, s99error=err.\n\nExplanation: The LDXSERV command was unable to dynamically allocate the change log data set. The dynamic allocation return code and reason codes are given in the message by rc and err respectively.\n\nDynamic allocation return codes and reason codes are documented in the IBM publication z/OS Programming: Authorized Assembler Services Guide.\n\nAction: If you are unable to determine and correct the cause of the error, collect diagnostic information and contact NetIQ Technical Support.\n\nB.6 LDXL Messages\n\nMessages beginning with LDXL are issued by the change log started task.\n\nLDXL000 LOGGING STARTED AT hh:mm:ss ON mm/dd/yyyy.\n\nExplanation: The change log started task has initialized.\n\nAction: Informational only. No action is required.\n\nLDXL001 MESSAGE LOG DISABLED, SYSPRINT DD MISSING.\n\nExplanation: During initialization, the change log started task was unable to open the SYSPRINT DD statement.\n\nThe change log started task continues processing, but no messages are written to SYSPRINT.\n\nPossible cause: The SYSPRINT DD statement is missing from the JCL for the change log started task.\n\nAction: Ensure that a SYSPRINT DD statement is present in the JCL and that it defines a file that the change log started task can write to.\n\nLDXL002 EXECUTE STATEMENT PARAMETERS: parm-values.\n\nExplanation: During initialization, the change log started task found the listed parameters present on the EXEC statement PARM parameter.\nLDXL003 START COMMAND PARAMETERS: parameters.\n\nExplanation: During initialization, the change log started task found the listed parameters present on the command line.\n\nAction: Informational only. No action is required.\n\nLDXL004 STOP COMMAND RECEIVED.\n\nExplanation: An operator entered a STOP command for the change log started task. The change log started task ends.\n\nAction: Informational only. No action is required.\n\nLDXL005 MODIFY COMMAND PARAMETERS: parameters.\n\nExplanation: An operator entered a MODIFY command for the change log started task with the listed parameters.\n\nAction: Informational only. No action is required.\n\nLDXL006 UNRECOGNIZED CIBVERB TYPE: X'hh', COMMAND IGNORED.\n\nExplanation: During processing, the change log started task received a command input buffer (CIB) with a verb other than STOP or MODIFY. Processing continues.\n\nPossible cause: Internal system error.\n\nAction: Collect diagnostic information and contact NetIQ Technical Support.\n\nLDXL007 OPERATOR CANCEL DETECTED, ATTEMPTING NORMAL SHUTDOWN.\n\nExplanation: An operator has issued a CANCEL command without the DUMP parameter for the change log started task. The change log started task attempts a clean shutdown.\n\nAction: Wait for the change log started task to end. If the change log started task does not end within a reasonable amount of time, issue another CANCEL command specifying the DUMP parameter. If you are unable to determine and correct the cause of the error, collect diagnostic information and contact NetIQ Technical Support.\n\nLDXL008 EVENT TRACING ENABLED.\n\nExplanation: An operator has issued a MODIFY command for TRACE ON to the change log started task.\n\nEvent tracing is turned on.\n\nAction: Informational only. No action is required.\nLDXL009 EVENT TRACING DISABLED.\n\nExplanation: An operator has issued a MODIFY command for TRACE OFF to the change log started task.\n\nEvent tracing is turned off.\n\nAction: Informational only. No action is required.\n\nLDXL010 MODIFY COMMAND IGNORED, INVALID OR MISSING PARAMETERS.\n\nExplanation: An operator has issued a MODIFY command to the change log started task, but the command parameters are not recognized.\n\nThe MODIFY command is ignored.\n\nAction: Reissue the MODIFY command with the intended parameters.\n\nLDXL011 EVENT RC(rc) DATA: event_data.\n\nExplanation: Event tracing is turned on and an event has been processed.\n\nThe return code from ProcessEvent is rc. The content of the event record is event_data.\n\nProcessing continues.\n\nAction: Informational only. No action is required.\n\nLDXL012 TERMINATING BECAUSE LOGGING ALREADY ACTIVE.\n\nExplanation: On startup, the change log started task has detected that another change log started task is already running.\n\nThis instance of the change log started task terminates.\n\nTo detect this condition, the change log started task enqueues exclusively on qname ldxlogr, rname #LDXENVIRONTOKEN when it initializes. If the ENQ macro fails, this message is issued. The change log started task dequeues this resource on shutdown.\n\nPossible cause: A START command for the change log started task has been issued more than once.\n\nAction: Do not start more than one instance of the change log started task at a time.\n\nLDXL013 LOGGING TO DATASET: dsname.\n\nExplanation: The name of the change log data set in use is dsname.\n\nAction: Informational only. No action is required.\n\nLDXL999 LOGGING ENDED AT hh:mm:ss ON mm/dd/yyyy.\n\nExplanation: The change log started task is ending.\n\nPossible cause: An operator entered a STOP command for the change log started task.\nB.7 LDXS Messages\n\nMessages beginning with LDXS are issued by the driver shim change log API.\n\n**LDXS000I nameversion Copyright 2006 Omnibond Systems, LLC. ID=code_id_string.**\n\nExplanation: This message identifies the system component version.\n\nAction: No action is required.\n\n**LDXS001A Error executing script scriptName. The return code is returnCode, the reason code is reasonCode, the abend code is abendCode.**\n\nExplanation: The driver shim could not execute scriptName.\n\nPossible cause: The script or command does not exist or is not valid.\n\nAction: Ensure that the driver shim is correctly configured to execute the command or script and that the command or script exists and is valid.\n\n**LDXS002A The change log service startup failed, rc = rc.**\n\nExplanation: The change log API failed to initialize.\n\nPossible cause: The change log data set has not been initialized.\n\nPossible cause: The driver load library is not properly configured.\n\nPossible cause: The driver does not have the required rights to access the change log data set.\n\nAction: Ensure that all of the steps of the installation procedure have been performed correctly and have not subsequently been reversed.\n\n**LDXS003A Unable to create token, return code from IEANTCR is rc.**\n\nExplanation: z/OS name/token callable services failed to create a token. The return code from IEANTCR is rc.\n\nPossible cause: Internal error.\n\nAction: Collect diagnostic information and contact NetIQ Technical Support.\n\nB.8 LDXU Messages\n\nMessages beginning with LDXU are issued by the log file utility LDXUTIL.\n\n**LDXU000I Log File Utility started on mm/dd/yyyy at hh:mm:ss.**\n\nExplanation: The log file utility has initialized.\n**LDXU001W Message log disabled, SYS PRINT DD missing.**\n\n**Explanation:** During initialization, the log file utility was unable to open the SYS PRINT DD statement. The log file utility continues processing, but no messages are written to SYS PRINT.\n\n**Possible cause:** The SYS PRINT DD statement is missing from the JCL for the log file utility.\n\n**Action:** Ensure that a SYS PRINT DD statement is present in the JCL and that it defines a file that the log file utility can write to.\n\n**LDXU002I Execute statement parameters: parm-values.**\n\n**Explanation:** During initialization, the log file utility found the listed parameters present on the EXEC statement PARM parameter.\n\n**Action:** Informational only. No action is required.\n\n**LDXU003E Open failed for log file.**\n\n**Explanation:** The log file utility could not open the change log data set.\n\n**Possible cause:** The LOGFILE DD statement is missing from the JCL for the log file utility.\n\n**Action:** Ensure that a LOGFILE DD statement is present in the JCL and that it defines a data set that the log file utility can write to.\n\n**LDXU004I Log file blocksize: blksize.**\n\n**Explanation:** The log file utility is initializing the change log data set with a blocksize of blksize.\n\n**Action:** Informational only. No action is required.\n\n**LDXU005I Log file blocks written: block-count.**\n\n**Explanation:** While initializing the change log data set, the log file utility has written block-count blocks of empty records.\n\n**Action:** Informational only. No action is required.\n\n**LDXU006E Open failed for LOADIN file.**\n\n**Explanation:** The log file utility load function could not open the LOADIN ddname.\n\n**Possible cause:** The LOADIN DD statement is missing from the JCL for the log file utility.\n\n**Action:** Ensure that a LOADIN DD statement is present in the JCL and that it defines a file that the log file utility can read.\n\n**LDXU007E Unrecognized or missing execute statement parameter.**\n\n**Explanation:** The log file utility found an unknown parameter in the EXEC statement PARM parameter.\n\n**Action:** Ensure that the log file utility load function is aware of the missing parameter.\n\n**Processing ends.**\nPossible cause: The EXEC statement PARM value is missing or does not contain one of the following functions:\n\n- INITIALIZE\n- DUMP\n- LOAD\n\nAction: Correct the PARM value and resubmit the job.\n\nLDXU008I Log file events loaded: event-count.\n\nExplanation: The log file utility load function has successfully loaded event-count events into the change log data set from the input file.\n\nAction: Informational only. No action is required.\n\nLDXU009E Add event failed, error code code.\n\nExplanation: The log file utility load function was unable to add an event record to the change log data set. The LDXLADD LDXIOERR code was code.\n\nPossible cause: Internal system error.\n\nAction: Collect diagnostic information and contact NetIQ Technical Support.\n\nLDXU010E Read header failed, error code code.\n\nExplanation: The log file utility dump function was unable to read the header record of the change log data set. The LDXGETE LDXIOERR code was code.\n\nPossible cause: Internal system error.\n\nAction: Collect diagnostic information and contact NetIQ Technical Support.\n\nLDXU011E Read event failed, error code code.\n\nExplanation: The log file utility dump function was unable to read an event record from the change log data set. The LDXGETE LDXIOERR code was code.\n\nPossible cause: Internal system error.\n\nAction: Collect diagnostic information and contact NetIQ Technical Support.\n\nLDXU990I Open BDAM log succeeded.\n\nExplanation: The log file utility has initialized the change log data set with empty records and has successfully opened it to complete the initialization by updating the header information.\n\nAction: Informational only. No action is required.\n\nLDXU991E Open BDAM log failed.\n\nExplanation: The log file utility has initialized the change log data set with empty records, but could not reopen it to complete the initialization by updating the header information.\n\nPossible cause: Internal system error.\nAction: Collect diagnostic information and contact NetIQ Technical Support.\n\nLDXU999I Log File Utility ended on mm/dd/yyyy at hh:mm:ss.\nExplanation: The log file utility has completed processing.\nAction: Informational only. No action is required.\n\nB.9 LDXV Messages\n\nMessages beginning with LDXV are issued by the IDMGETV and IDMSETV commands.\n\nLDXV001E IDM token not present.\nSource: IDMGETV command, IDMSETV command\nExplanation: The data areas that the driver shim sets up for the IDMGETV or IDMSETV command before calling a script are not present.\nPossible Cause: The command was not called by the driver shim.\nAction: Ensure that the commands are invoked by the driver shim. They are not intended to be used outside of this environment.\n\nLDXV002E Unable to parse command.\nSource: IDMGETV command, IDMSETV command\nExplanation: The TSO parsing routine detected an error in the command and was unable to prompt for a correction.\nPossible Cause: The command had a syntax error. It was not called from an interactive session and could not prompt for a correction.\nAction: Examine the associated messages from the TSO parsing routine that describe the error. Correct the operands of the command.\n\nLDXV003E Error from TSO service routine IKJCT441, RC <rc>.\nSource: IDMGETV command\nExplanation: TSO routine IKJCT441 detected a problem and ended with return code rc (decimal).\nPossible Cause: Internal error.\nAction: Collect diagnostic information and contact NetIQ Technical Support.\n\nLDXV004W <variablename> contains invalid characters to be a REXX variable.\nSource: IDMGETV command, IDMSETV command\nExplanation: The command was directed to create the variable named in the message, but the variable name contained characters that are not acceptable in a REXX variable name. The acceptable characters are as follows:\nPossible Cause: The variable named in the message was defined in eDirectory™ using one or more characters not in the list of acceptable characters. For example, some attribute names might contain spaces.\nAction: Use the driver mapping rules to rename the variable to a name that meets the REXX naming requirements.\n\n**LDXV005E IDMGETV was not called from a CLIST or REXX exec.**\n\nSource: IDMGETV command\nExplanation: The IDMGETV command must be called from a REXX exec, because it creates and manipulates REXX variables.\nPossible Cause: The command was not called from within the REXX environment.\nAction: Call the command from within the REXX environment.\n\n**LDXV006E GROUP or USER list required.**\n\nSource: IDMSETV command\nExplanation: The IDMSETV command requires either the GROUP(grouplist) or USER(userlist) operand.\nPossible Cause: Use one of the required operands.\nAction: Correct the operands of the command.\n\n**LDXV007E GROUP and USER operands are mutually exclusive.**\n\nSource: IDMSETV command\nExplanation: The command found both the USER and GROUP operands on the command line. These are mutually exclusive.\nPossible Cause: Both GROUP and USER were specified on the IDMSETV command.\nAction: Correct the command.\n\n**LDXV008E Error returned from <service>: RC <rc>.**\n\nSource: IDMGETV command, IDMSETV command\nExplanation: The IBM service routine service returned the return code rc (decimal).\nPossible Cause: Internal error.\nAction: Collect diagnostic information and contact NetIQ Technical Support.\n\nB.10 LWS Messages\n\nMessages beginning with LWS are issued by the integrated HTTP server.\n\nLWS0001I Server has been initialized.\nExplanation: The server has successfully completed its initialization phase.\nAction: None. Informational only.\n\nLWS0002I All services are now active.\nExplanation: All of the services offered by the server are now active and ready for work.\nAction: None. Informational only.\n\nLWS0003I Server shut down successfully.\nExplanation: The server processing completed normally. The server ends with a return code of 0.\nAction: No action is required.\n\nLWS0004W Server shut down with warnings.\nExplanation: The server processing completed normally with at least one warning. The server ends with a return code of 4.\nAction: See the log for additional messages that describe the warning conditions.\n\nLWS0005E Server shut down with errors.\nExplanation: The server processing ended with one or more errors. The server ends with a return code of 8.\nAction: See the log for additional messages that describe the error conditions.\n\nLWS0006I Starting service.\nExplanation: The server is starting the specified service.\nAction: None. Informational only.\n\nLWS0007E Failed to start service.\nExplanation: The server attempted to start the specified service, but the service could not start. The server terminates processing.\nAction: See the log for additional messages that describe the error condition.\nLWS0008I Stopping all services.\n Explanation: The server was requested to stop. All services are notified and will subsequently end processing.\n Action: None. Informational only.\n\nLWS0009I Local host is host_name (IP_address).\n Explanation: This message shows the host name and IP address of the machine that the server is running on.\n Action: None. Informational only.\n\nLWS0010I Local host is IP_address.\n Explanation: This message shows the IP address of the machine that the server is running on.\n Action: None. Informational only.\n\nLWS0011I Server is now processing client requests.\n Explanation: The server has successfully started all configured services, and it is ready for clients to begin requests.\n Action: None. Informational only.\n\nLWS0012I service is now active on port number.\n Explanation: The server service is running on the specified TCP port number. Clients can begin making requests to the specified service.\n Action: None. Informational only.\n\nLWS0013I service is now inactive on port number.\n Explanation: The server service is not active on the specified TCP port number. Processing continues, but no client requests can be made to the service until it becomes active again.\n Action: None. Informational only.\n\nLWS0014E An error was encountered while parsing execution parameters.\n Explanation: An error occurred while parsing the execution parameters. The server terminates with a minimum return code of 8.\n Action: Collect diagnostic information and contact NetIQ Technical Support.\n\nLWS0015E service failed to start with error number.\n Explanation: The specified service failed to start. The server terminates with a minimum return code of 8.\n Action: Collect diagnostic information and contact NetIQ Technical Support.\nLWS0020I Server version level: level.\n\nExplanation: This message contains information detailing the current service level for the server program being executed. The value of version indicates the current release of the server. The value of level is a unique sequence of characters that can be used by NetIQ Technical Support to determine the maintenance level of the server being executed.\n\nAction: Normally, no action is required. However, if you report a problem with the server to NetIQ Technical Support, you might be asked to provide the information in the message.\n\nLWS0023I Listen port number is already in use.\n\nExplanation: The displayed listen port is already in use by another task running on the local host. The server retries establishing the listen port.\n\nAction: Determine what task is using the required port number and restart the server when the task is finished, or specify a different port in the configuration file. If the port number is changed for the server, the client must also specify the new port number.\n\nLWS0024W Too many retries to obtain port number.\n\nExplanation: The server tried multiple attempts to establish a listen socket on the specified port number, but the port was in use. The server terminates with a return code of 4.\n\nAction: Determine what task is using the required port number, and restart the server when the task is finished, or specify a different port in the configuration file. If the port number is changed for the server, the client must also specify the new port number.\n\nLWS0025I Local TCP/IP stack is down.\n\nExplanation: The server detected that the local host TCP/IP service is not active or is unavailable. The server retries every two minutes to reestablish communication with the TCP/IP service.\n\nAction: Ensure that the TCP/IP service is running.\n\nLWS0026E Unrecoverable TCP/IP error number returned from internal_function_name.\n\nExplanation: An unrecoverable TCP/IP error was detected in the specified internal server function name. The server ends with a minimum return code of 8. The error number reported corresponds to a TCP/IP errno value.\n\nAction: Correct the error based on TCP/IP documentation for the specified errno.\n\nLWS0027W Listen socket was dropped for port number.\n\nExplanation: The server connection to the displayed listen port was dropped. The server attempts to reconnect to the listen port so that it can receive new client connections.\nLWS0028E Unable to reestablish listen socket on port number.\n\nExplanation: The listen socket on the specified port number was dropped. The server tried multiple attempts to reestablish the listen socket, but all attempts failed. The server ends with a return code of 8.\n\nAction: Determine if the host’s TCP/IP service is running. If the host’s TCP/IP service is running, determine if another task on the local host is using the specified port.\n\nLWS0029I <id> Client request started from ip_address on port number.\n\nExplanation: A new client request identified by id has been started from the specified IP address on the displayed port number.\n\nAction: None. Informational only.\n\nLWS0030I <id> Client request started from host (ip_address) on port number.\n\nExplanation: A new client request identified by id has been started from the specified host and IP address on the displayed port number.\n\nAction: None. Informational only.\n\nLWS0031W Unable to stop task id: reason.\n\nExplanation: The server attempted to terminate a service task identified by id. The server could not stop the task for the specified reason. The server ends with a return code of 4.\n\nAction: See the reason text for more information about why the task could not terminate.\n\nLWS0032I <id> Client request has ended.\n\nExplanation: The client requested identified by id has ended.\n\nAction: None. Informational only.\n\nLWS0033I <id> Client request: resource.\n\nExplanation: The client connection identified by id issued a request for resource.\n\nAction: None. Informational only.\n\nLWS0034W <id> Write operation for client data has failed.\n\nExplanation: A write operation failed for the connection identified by id. This is normally because the client dropped the connection. The client connection is dropped by the server.\nAction: Ensure that the client does not prematurely drop the connection. Retry the client request if necessary.\n\nLWS0035W <id> Read operation for client data has timed out.\nExplanation: A read operation on the connection identified by id has timed out because of inactivity. The client connection is dropped by the server.\nAction: Ensure that the client does not prematurely drop the connection. Retry the client request if necessary.\n\nLWS0036W <id> Client request error: error_code - error_text.\nExplanation: The server encountered an error while processing the client request. The server terminates the request.\nAction: Determine why the request was in error by viewing the error code and error text that was generated.\n\nLWS0037W <id> Client request error: code.\nExplanation: The server encountered an error while processing the client request. The server terminates the request.\nAction: Determine why the request was in error by viewing the error code and error text that was generated.\n\nLWS0038I Received command: command_text.\nExplanation: The server has received the displayed command from the operator. The server processes the command.\nAction: None. Informational only.\n\nLWS0043E Task id ended abnormally with RC=retcode.\nExplanation: The server detected a task that ended with a non-zero return code. The server ends with a minimum return code of 8.\nAction: View the log for other messages that might have been generated regarding the error.\n\nLWS0045I Idle session time-out is number seconds.\nExplanation: The message shows the idle time limit for connections. The server automatically terminates sessions that are idle for longer than the specified number of seconds.\nAction: None. Informational only.\n\nLWS0046I Maximum concurrent sessions limited to number.\nExplanation: The message shows the maximum number of concurrent sessions allowed. The server allows only the specified number of concurrent sessions to be active at any given time. All connections that exceed this limit are forced to wait until the total number of connections drops below the specified value.\nLWS0047W Unable to delete log file filename.\n Explanation: The log file could not be deleted as specified.\n Possible cause: The user service or daemon does not have file system rights to delete old log files.\n Action: Verify that the user service or daemon has the appropriate rights.\n Action: Examine the current logs for related messages.\n\nLWS0048I Log file filename successfully deleted.\n Explanation: The log file has been deleted as specified.\n Action: None. Informational only.\n\nLWS0049E Error error authenticating to the directory as fdn.\n Explanation: The connection manager could not connect to the directory as user fdn. The error was error.\n Possible cause: The configuration parameters do not contain the correct user or password.\n Action: Correct the cause of the error as determined from error.\n Action: Verify that the User object has the appropriate rights.\n Action: Verify that the password given for the User object in the configuration parameters is correct.\n\nLWS0050E Server application initialization failure was detected.\n Explanation: During server initialization, an error was detected while initializing the server Application object.\n Possible Cause: This message is commonly logged when the driver is started and then immediately shut down. This can happen during installation, when the shim is started to generate keys or configure SSL. You can safely ignore this message in those cases.\n Action: See the error logs for additional messages that indicate the cause of the error.\n\nLWS0051E Server initialization failure was detected.\n Explanation: The server failed to initialize properly because of an initialization error specific to the operating system.\n Action: See the log for additional messages that indicate the cause of the error.\n\nLWS0052W This server is terminating because of another instance already running (details).\n Explanation: The server is shutting down because there is another active instance of this server running on the host.\nPossible cause: A previous instance of the server was not stopped before starting a new instance.\nAction: Stop or cancel the previous server instance before starting a new one.\n\nLWS0053I The parameter keyword is no longer supported.\nExplanation: The specified parameter is not supported in this release and might be removed in future releases.\nPossible cause: An execution parameter was specified that is no longer supported.\nAction: Do not specify the unsupported parameter.\n\nLWS0054I The execution parameter keyword is in effect.\nExplanation: The specified execution parameter is in effect for the server.\nAction: Informational only. Processing continues.\n\nLWS0055W Invalid execution parameter detected: keyword.\nExplanation: An invalid execution parameter was detected.\nAction: Do not specify the invalid or unknown execution parameter.\n\nLWS0056I Not accepting new connections because of the MAXCONN limit. There are number active connections now for service.\nExplanation: The specified service has a maximum connection limit that has been reached. The service no longer accepts new connections until at least one of the active connections ends.\nAction: If you receive this message frequently, increase the MAXCONN limit for this service or set the MAXCONN to unlimited connections.\n\nLWS0057I New connections are now being accepted for service.\nExplanation: The service was previously not accepting new connections because of the imposed MAXCONN limit. The service can now accept a new connection because at least one active connection has ended.\nAction: None. Informational only.\n\nLWS0058I Listen socket on port number has been re-established.\nExplanation: The previously dropped listen socket has been reestablished. Services using the specified port can now continue. The listen socket previously dropped because of an error or TCP/IP connectivity problems has been reestablished. Client connection processing continues.\nAction: None. Informational only.\nLWS0059W Server is terminating because the required service **serviceName** is ending.\n\n**Explanation:** The specified required service has ended. The server terminates because it cannot continue running without the required service.\n\n**Action:** See related log messages to determine why the required service ended. Correct the problem and restart the server.\n\n### B.11 NET Messages\n\nMessages beginning with NET are issued by driver components during verification of SSL certificates.\n\n**NET001W Certificate verification failed. Result is result.**\n\n**Explanation:** A valid security certificate could not be obtained from the connection client. Diagnostic information is given by result.\n\n**Possible cause:** A security certificate has not been obtained for the component.\n\n**Possible cause:** The security certificate has expired.\n\n**Possible cause:** The component certificate directory has been corrupted.\n\n**Action:** Respond as indicated by result. Obtain a new certificate if appropriate.\n\n### B.12 RDXML Messages\n\nMessages beginning with RDXML are issued by the embedded Remote Loader.\n\n**RDXML000I nameversion Copyright 2005 Omnibond Systems, LLC. ID=code_id_string.**\n\n**Explanation:** This message identifies the system component version.\n\n**Action:** No action is required.\n\n**RDXML001I Client connection established.**\n\n**Explanation:** A client has connected to the driver. This can be the Metadirectory engine connecting to process events to and from the driver, or a Web-based request to view information or publish changes through the SOAP mechanism.\n\n**Action:** No action required.\n\n**RDXML002I Request issued to start Driver Shim.**\n\n**Explanation:** The driver received a command to start the driver shim and begin processing events.\n\n**Action:** No action required.\nRDXML003E An unrecognized command was issued. The driver shim is shutting down.\n\n Explanation: The driver received an unrecognized command from the Metadirectory engine. The driver shim is shutting down to avoid further errors.\n\n Possible cause: Network error.\n Possible cause: Invalid data sent to the driver.\n Possible cause: The Metadirectory engine version might have been updated with new commands that are unrecognized by this version of the driver.\n Possible cause: This message is logged when the driver shim process is shut down from the connected system rather than from a Driver object request. The local system can queue an invalid command to the driver shim to simulate a shutdown request and terminate the running process.\n\n Action: Ensure that the network connection is secured and working properly.\n Action: Apply updates for the engine or driver if necessary.\n Action: If the driver shim process was shut down from the local system, no action is required.\n\nRDXML004I Client Disconnected.\n\n Explanation: A client has disconnected from the driver. This might be the Metadirectory engine disconnecting after a driver shutdown request or a Web-based request that has ended.\n\n Action: No action required.\n\nRDXML005W Unable to establish client connection.\n\n Explanation: A client attempted to connect to the driver, but was disconnected prematurely.\n\n Possible cause: The client is not running in SSL mode.\n Possible cause: Mismatched SSL versions or mismatched certificate authorities.\n Possible cause: Problems initializing SSL libraries because of improperly configured system entropy settings.\n\n Action: Ensure that both the Metadirectory engine and the driver are running in the same mode: either clear text mode or SSL mode.\n Action: If you are using SSL, ensure that the driver and Metadirectory engine have properly configured certificates, and that the driver system is configured properly for entropy.\n\nRDXML006E Error in Remote Loader Handshake.\n\n Explanation: The Metadirectory engine attempted to connect to the driver, but the authorization process failed. Authorization requires that both supply mutually acceptable passwords. Passwords are configured at installation.\n\n Possible cause: The Remote Loader or Driver object passwords do not match.\nAction: Set the Remote Loader and Driver object passwords to the same value for both the driver and the driver shim. Use iManager to modify the driver properties. Reconfigure the driver shim on the connected system.\n\nRDXML007I Driver Shim has successfully started and is ready to process events.\n\nExplanation: The Metadirectory engine has requested the driver to start the shim for event processing, and the driver shim has successfully started.\n\nAction: No action required.\n\nRDXML008W Unable to establish client connection from remoteName.\n\nExplanation: A client attempted to connect to the driver, but was disconnected prematurely.\n\nPossible cause: The client is not running in SSL mode.\n\nPossible cause: Mismatched SSL versions or mismatched certificate authorities.\n\nPossible cause: Problems initializing SSL libraries because of improperly configured system entropy settings.\n\nAction: Ensure that both the Metadirectory engine and the driver are running in the same mode: either clear text mode or SSL mode.\n\nAction: If you are using SSL, ensure that the driver and Metadirectory engine have properly configured certificates, and that the driver system is configured properly for entropy.\n\nRDXML009I Client connection established from remoteName.\n\nExplanation: A client has connected to the driver. This can be the Metadirectory engine connecting to process events to and from the driver, or a Web-based request to view information or publish changes through the SOAP mechanism.\n\nAction: No action required.\nC Technical Details\n\nTopics in this section include\n\n- Section C.1, “Driver Shim Command Line Options,” on page 105\n- Section C.2, “ACFQUERY Tool,” on page 106\n- Section C.3, “LDXSERV Tool,” on page 107\n- Section C.4, “Performance Information,” on page 108\n- Section C.5, “Default ACF2 Schema,” on page 113\n\nC.1 Driver Shim Command Line Options\n\nThe following options can be specified on the driver shim command line. You can also specify driver shim configuration file statements as command line options. For details about the driver shim configuration file, see Section 5.1, “The Driver Shim Configuration File,” on page 49.\n\nC.1.1 Options Used to Set Up Driver Shim SSL Certificates\n\nThe following command line options are used to set up the driver shim SSL certificates:\n\n<table>\n<thead>\n<tr>\n<th>Option (Short and Long Forms)</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-s (-secure)</td>\n<td>Secures the driver by creating SSL certificates, then exits.</td>\n</tr>\n<tr>\n<td>-p (-password)</td>\n<td>Specifies the Remote Loader password.</td>\n</tr>\n</tbody>\n</table>\n\nC.1.2 Other Options\n\n<table>\n<thead>\n<tr>\n<th>Option (Short and Long Forms)</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-c <configFile></td>\n<td>Instructs the driver shim to read options from the specified configuration file.</td>\n</tr>\n<tr>\n<td>-config <configFile></td>\n<td>Options are read from ddname DRVCONF by default.</td>\n</tr>\n</tbody>\n</table>\n## C.2 ACFQUERY Tool\n\nThe driver query processor uses the ACF2 API to retrieve information from the security system. Queries are used by the Metadirectory engine for matching and merging. The TSO command, `ACFQUERY`, is used to extract information from the ACF2 database. `ACFQUERY` has the following format for read operations:\n\n```\nACFQUERY SCOPE(entry) CLASS(class) ASSOCIATION(association)\n[READATTRS(attrs...)|ALLREADATTRS] [PRINT]\n```\n\nThe `SCOPE` operand tells `ACFQUERY` that information about a specific profile is being requested. The `CLASS` operand should always be set 'Logonid'. The `ASSOCIATION` operand specifies the association of the object to read. For Logonid profiles, simply use the LID field for association values. The `READATTRS` operand specifies a list of attributes to return; optionally, you may specify `ALLREADATTRS` instead to return everything. The `PRINT` operand instructs `ACFQUERY` to print the results to the display. The output is a series of lines, each with a name=value pair. These pairs are interpreted by the driver shim to create an appropriate XDS document that the engine can use for processing. For example:\n\n```\nACFQUERY SCOPE(entry) CLASS(Logonid) ASSOCIATION(IBMUSER)\nREADATTRS(ACCOUNT)PRINT\n```\n\nFor search operations, a search criteria is specified:\n\n```\nACFQUERY SCOPE(subtree) SEARCHCLASSES(classes..) SEARCHATTRS(attr=value' ...)\n[READATTRS(attrs...)|ALLREADATTRS] [PRINT]\n```\n\nThe `SCOPE` operand tells `ACFQUERY` that information about a specific profile is being requested. The `SEARCHCLASSES` operand lists the class(es) of interest. The `SEARCHATTRS` provides a list of values and attributes to search on. For example:\n\n```\nACFQUERY SCOPE(subtree) SEARCHCLASSES(Logonid)\nSEARCHATTRS('ACCOUNT=true') PRINT\n```\n\n<table>\n<thead>\n<tr>\n<th>Option (Short and Long Forms)</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-?</td>\n<td>Displays the command line options, then exits.</td>\n</tr>\n<tr>\n<td>-help</td>\n<td>Displays the command line options, then exits.</td>\n</tr>\n<tr>\n<td>-v</td>\n<td>Displays the driver shim version and build date, then exits.</td>\n</tr>\n<tr>\n<td>-version</td>\n<td>Displays the driver shim version and build date, then exits.</td>\n</tr>\n</tbody>\n</table>\n\n### Option (Short and Long Forms) Description\n\n<table>\n<thead>\n<tr>\n<th>Option (Short and Long Forms)</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-?</td>\n<td>Displays the command line options, then exits.</td>\n</tr>\n<tr>\n<td>-help</td>\n<td>Displays the command line options, then exits.</td>\n</tr>\n<tr>\n<td>-v</td>\n<td>Displays the driver shim version and build date, then exits.</td>\n</tr>\n<tr>\n<td>-version</td>\n<td>Displays the driver shim version and build date, then exits.</td>\n</tr>\n</tbody>\n</table>\n\n- **?** Displays the command line options, then exits.\n- **-help** Displays the driver shim version and build date, then exits.\n- **-v** Displays the driver shim version and build date, then exits.\n- **-version** Displays the driver shim version and build date, then exits.\nYou will notice that there are multiple results returned. Search operations may return zero or more responses.\n\n## C.3 LDXSERV Tool\n\nLDXSERV is a TSO command tool that serves several functions. For the driver shim, it allows the started task to set a loopback token in its address space memory in order to prevent the Exit routines from logging its activity to the change log. From the user's perspective, LDXSERV can be used as a verification tool to investigate whether the Exits are in place correctly. It can also be used to query information from the change log queue and even modify the queue, if necessary.\n\nThe syntax for LDXSERV is as follows:\n\n```\nLDXSERV < STATUS | GETNEXT | [MARKDONE <EVENT(event-id)>] >\n```\n\n### C.3.1 STATUS\n\nThe `STATUS` operand reports back to the user an XML document describing the installed Event Subsystem. It provides several pieces of information, including the build date and version of each component, the state of each Exit, the number of events queued through each Exit, and the size and location of the log file.\n\n```\nldxserv status\n<ldx>\n <source>\n <product build=\"20171217\" instance=\"ldxserv\" version=\"4.70\">\n Novell IDMA C2 Driver Version 4.0.4.0\n </product>\n <contact>NetIQ Corporation</contact>\n </source>\n <output>\n <status level=\"success\">\n <exit name=\"LDXNPXIT\" state=\"enabled\" version=\"4.70\" build-date=\"20171217\"\n times-called=\"584\" events-queued=\"2\" info=\"ok\"/>\n <exit name=\"LDXEVX01\" state=\"enabled\" version=\"4.70\" build-date=\"20171217\"\n times-called=\"20\" events-queued=\"7\" info=\"ok\"/>\n <queue version=\"4.70\" state=\"active\" created-by=\"LDXNPXIT\" entries=\"0\"/>\n <logger version=\"4.70\" state=\"active\" taskid=\"LDXLOGRP\"\n logfilename=\"LDX.LOGFILE\"/>\n <logfile name=\"LDX.LOGFILE\" state=\"0% used\"/>\n </status>\n </output>\n</ldx>\n```\n\n### C.3.2 GETNEXT\n\nThe `GETNEXT` operand reports back to the user an XML document describing the first event in the change log queue. Inside the XML document, you may view the type of event and details about the event, including the user that issued the event, the date and time of the event.\n\n```\nldxserv getnext\n```\nldxserv getnext\n<ldx>\n <source>\n <product build=\"20171217\" instance=\"ldxserv\" version=\"4.70\">\n Novell IDM ACF2 Driver Version 4.0.4.0\n </product>\n <contact>NetIQ Corporation</contact>\n </source>\n <output>\n <modify-password date=\"2012-10-01\" time=\"7:18\" event-id=\"7006\">\n <association>JAVIER</association>\n <password>********</password>\n </modify-password>\n <status level=\"success\">\n <description>ok</description>\n </status>\n </output>\n</ldx>\n\nC.3.3 MARKDONE\n\nThe MARKDONE operand instructs LDXSERV to remove the event in the queue, described by the EVENTID operand. The event-id must match the event-id found by the GETNEXT command. When complete, it reports back an XML document describing the success or error of the instruction.\n\nldxserv markdone event(7006)\n<ldx>\n <source>\n <product build=\"20171217\" instance=\"ldxserv\" version=\"4.70\">\n Novell IDM ACF2 Driver Version 4.0.4.0\n </product>\n <contact>NetIQ Corporation</contact>\n </source>\n <output>\n <status level=\"success\">\n <description>ok</description>\n </status>\n </output>\n</ldx>\n\nC.4 Performance Information\n\nThis section presents the results of a performance case study of the Identity Manager 4.7 driver for ACF2. The study is based on software and hardware configurations that may vary from your production deployment. Therefore, the results, which include real-time throughput and mainframe resource usage, are offered only as approximations for calculating similar measurements in your environment.\n\nC.4.1 Configuration Information\n\nThe system on which Identity Manager was installed was a VMWare virtual machine with the following configuration:\n\n- Single Intel® Xeon® CPU at 2.5 GHz\n- 8 GB RAM\n- SLES 10.2 x86_64\n- 64-bit eDirectory 8.8 SP5 (20601.18)\n- 64-bit Identity Manager 4.0.1 (4.0.1-0)\n• Single Driver Set with one driver (ACF2)\n• Engine trace level 10\n\nThe connected z/OS system running ACF2 consisted of:\n• IBM System z10 Business Class Mainframe 2098-E10 model D02\n• 8 MB memory\n• z/OS 1.13\n• ACF2 with 1000 users\n\nC.4.2 Performance Metrics\n\nAll tests in the case study used three or more of the following benchmarks:\n• Real-Time Speed\n• CPU-Time\n• EXCP-Cnt\n• Memory Usage\n\nReal-Time Speed\nThis measurement describes the amount of time for a particular transaction in real seconds or milliseconds. It is useful for ascertaining how long a large migration may take or how many events per day can be processed by a particular channel in real time. Real-time measurements are helpful in previewing what to expect in a production deployment; however, they are dependent on a variety of factors, including speed of the mainframe and vault systems, size of the ACF2 database, size and layout of Identity Vault, operating systems workload, network delays, disk I/O speeds, trace levels, and customized policies.\n\nCPU-Time\nOn the mainframe, CPU-Time is a measurement of the amount of CPU processing time consumed by a particular job. This figure can be used for capacity planning.\n\nEXCP-Cnt\nThe EXCP-Cnt is the total number of blocks transferred for I/O requests. I/O utilization may also be used for capacity planning.\n\nMemory Usage\nMemory usage is the number of frames allocated by a running task on z/OS. Each frame represents 4096 bytes of memory. In all tests for this study, the memory recorded was the highest observed peak that occurred during transactions.\n\nC.4.3 Idle Performance\n\nIdle performance measures how the Driver Shim started task performs while no event transactions are being processed.\nPhase Discussion\n\nDriver Shim idle performance is measured in four phases:\n\n- Shim Startup\n- Shim Idle (not connected)\n- Shim Connection\n- Shim Idle (connected)\n\nShim Startup\n\nWhen the ACF2 Driver Shim (ACF2DRV) is started, various internal tasks are created and executed to create a network listener.\n\nShim Idle (not connected)\n\nThis phase describes the time after the Driver Shim has been started and before the engine has established a network connection.\n\nShim Connection\n\nThe connection between Identity Manager and the Driver Shim uses SSL negotiations and a handshake, which involves the exchange of passwords for the remote loader and driver. Internally, two new tasks are created to read and parse data exchange and to poll the change log data set.\n\nShim Idle (connected)\n\nOnce a connection is established, the Driver Shim periodically polls the change log data set for any new events to publish. In addition, Identity Manager sends keep-alive packets to the Driver Shim to ensure the connection remains intact. For this case study, this phase was tested with a 5-minute publisher polling interval.\n\nResults\n\n<table>\n<thead>\n<tr>\n<th>Phase</th>\n<th>CPU-Time</th>\n<th>EXCP-Cnt</th>\n<th>Memory Usage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Startup</td>\n<td>0.90 seconds</td>\n<td>890</td>\n<td>1338 (5.5 MB)</td>\n</tr>\n<tr>\n<td>Idle (not connected)</td>\n<td>0.12 seconds/hour</td>\n<td>0/hour</td>\n<td>1338 (5.9 MB)</td>\n</tr>\n<tr>\n<td>Connection</td>\n<td>1.55 seconds</td>\n<td>40</td>\n<td>1935 (7.9 MB)</td>\n</tr>\n<tr>\n<td>Idle (connected)</td>\n<td>0.6 seconds/hour</td>\n<td>12/hour</td>\n<td>1935 (7.9 MB)</td>\n</tr>\n</tbody>\n</table>\n\nNOTE: The polling interval will affect the results for the Idle (connected) phase. For this study, the polling interval was set to 300 seconds (or 5 minutes) and the driver heartbeat was disabled.\nC.4.4 **Subscriber Performance**\n\nThe Subscriber channel processes events originating in Identity Manager that need to be replicated in the ACF2 database. In this study, all ACF2 rules and packages were applied with 1000 events were timed for each use case and the results were averaged across all 1000 events. Six event types were included:\n\n- **Add User** - A new user in Identity Manager is replicated on the connected system using the minimum required fields\n- **Modify User** - A change to a user in Identity Manager causes a change to that user’s REVOKE field in ACF2\n- **Delete User** - A user’s deletion in Identity Manager causes that user’s deletion in ACF2\n- **Change Password** - A user’s new password in Identity Manager is replicated in ACF2\n- **Entry Query User** - Identity Manager queries a user in ACF2 and reads its NAME field\n- **Search Query User** - Identity Manager queries ACF2 with a search on the NAME field\n\nEach test was run both with and without the REXX extensions. When the Driver Shim invokes the REXX scripts to execute commands, additional CPU, Time and I/O are consumed to accomplish the task. However, using REXX allows you to customize the provisioning process with native z/OS policy decisions.\n\n**Table C-5 ACF2DRV Performance Per Transaction**\n\n<table>\n<thead>\n<tr>\n<th>Event</th>\n<th>CPU-Time</th>\n<th>EXCP-Cnt</th>\n<th>Memory Usage</th>\n<th>Real Time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Add User</td>\n<td>1.16 seconds</td>\n<td>216</td>\n<td>2900 (11.9 MB)</td>\n<td>2.02 seconds</td>\n</tr>\n<tr>\n<td>Modify User</td>\n<td>0.48 seconds</td>\n<td>181</td>\n<td>2200 (9.0 MB)</td>\n<td>1.11 seconds</td>\n</tr>\n<tr>\n<td>Delete User</td>\n<td>0.79 seconds</td>\n<td>287</td>\n<td>2043 (8.4 MB)</td>\n<td>1.66 seconds</td>\n</tr>\n<tr>\n<td>Change Password</td>\n<td>0.74 seconds</td>\n<td>399</td>\n<td>2008 (8.2 MB)</td>\n<td>0.79 seconds</td>\n</tr>\n<tr>\n<td>Entry Query User</td>\n<td>0.27 seconds</td>\n<td>93</td>\n<td>2008 (8.2 MB)</td>\n<td>1.00 seconds</td>\n</tr>\n<tr>\n<td>Search Query User</td>\n<td>1.16 seconds</td>\n<td>3264</td>\n<td>2023 (8.3 MB)</td>\n<td>3.04 seconds</td>\n</tr>\n</tbody>\n</table>\n\nC.4.5 **Publisher Performance**\n\nThe Publisher channel processes events originating in the connected system’s ACF2 database that need to be replicated in the Identity Vault. In this study, 1000 events were timed for each use case and the results were averaged across all 1000 events. Five event types were included:\n\n- **Add User** - A new user created in ACF2 with minimum required fields is replicated in Identity Manager\n• Add Group - A new group created in ACF2 with minimum required fields is replicated in Identity Manager\n• Modify User - A change to a user’s REVOKE field in ACF2 causes a change to that user’s account in Identity Manager\n• Delete User - A user deleted in ACF2 causes that user’s deletion in Identity Manager\n• Change Password - A user’s new password in ACF2 is replicated in Identity Manager\n\nFor each test, a CLIST containing the commands for each event type, was executed against ACF2. To gain accurate samples, measurements were taken in steps:\n\n• First, LDXLOGR was started to move the events from cross memory to the change log.\n• Then the CLIST was executed to begin queueing commands and changes. This implies that the performance of the LDXLOGR during this phase was in contention with the actual ACF2 commands being executed by ACF2.\n• Finally, the Drive Shim (ACF2DRV) was started to fetch each event and publish to the Identity Vault. Default matching rules and placement policies were used.\n\nWhen LDXLOGRP (monitored on the mainframe as LDXLOGRP) is not bottlenecked by ACF2 and started after the cross memory queue is populated with events, the CPU-Time and Real Time performance is more efficient. This is demonstrated by the bulk processing results in Table C-7 on page 112.\n\n<table>\n<thead>\n<tr>\n<th>Event</th>\n<th>CPU-Time</th>\n<th>EXCP-Cnt</th>\n<th>Memory Usage</th>\n<th>Real Time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Add User</td>\n<td>0.002 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.18 seconds</td>\n</tr>\n<tr>\n<td>Add Group</td>\n<td>0.002 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.18 seconds</td>\n</tr>\n<tr>\n<td>Modify User</td>\n<td>0.002 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.18 seconds</td>\n</tr>\n<tr>\n<td>Delete User</td>\n<td>0.002 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.18 seconds</td>\n</tr>\n<tr>\n<td>Change Password</td>\n<td>0.002 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.18 seconds</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Event</th>\n<th>CPU-Time</th>\n<th>EXCP-Cnt</th>\n<th>Memory Usage</th>\n<th>Real Time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Add User</td>\n<td>0.001 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.003 seconds</td>\n</tr>\n<tr>\n<td>Add Group</td>\n<td>0.001 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.003 seconds</td>\n</tr>\n<tr>\n<td>Modify User</td>\n<td>0.001 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.003 seconds</td>\n</tr>\n<tr>\n<td>Delete User</td>\n<td>0.001 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.003 seconds</td>\n</tr>\n<tr>\n<td>Change Password</td>\n<td>0.001 seconds</td>\n<td>5</td>\n<td>285 (1.2 MB)</td>\n<td>0.003 seconds</td>\n</tr>\n</tbody>\n</table>\nTable C-8 ACF2DRV Performance Per Transaction\n\n<table>\n<thead>\n<tr>\n<th>Event</th>\n<th>CPU-Time</th>\n<th>EXCP-Cnt</th>\n<th>Memory Usage</th>\n<th>Real Time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Add User</td>\n<td>0.027 s</td>\n<td>7</td>\n<td>1977 (8.1 MB)</td>\n<td>0.14 s</td>\n</tr>\n<tr>\n<td>Add Group</td>\n<td>0.023 s</td>\n<td>7</td>\n<td>1976 (8.1 MB)</td>\n<td>0.12 s</td>\n</tr>\n<tr>\n<td>Modify User</td>\n<td>0.022 s</td>\n<td>7</td>\n<td>1977 (8.1 MB)</td>\n<td>0.10 s</td>\n</tr>\n<tr>\n<td>Delete User</td>\n<td>0.022 s</td>\n<td>7</td>\n<td>1977 (8.1 MB)</td>\n<td>0.10 s</td>\n</tr>\n<tr>\n<td>Change Password</td>\n<td>0.027 s</td>\n<td>7</td>\n<td>1975 (8.1 MB)</td>\n<td>0.14 s</td>\n</tr>\n</tbody>\n</table>\n\nC.5 Default ACF2 Schema\n\nThe default schema for the ACF2 Driver uses the installation default Logonid record supplied by CA. Table C-9 lists each field and its syntax.\n\nTable C-9 ACF2 Schema\n\n<table>\n<thead>\n<tr>\n<th>eDirectory Attribute</th>\n<th>ACF2 Field</th>\n<th>Syntax</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DirXML-ACF2-ACC-CNT</td>\n<td>ACC-CNT</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ACC-DATE</td>\n<td>ACC-DATE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ACC-SRCE</td>\n<td>ACC-SRCE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ACC-TIME</td>\n<td>ACC-TIME</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ACCOUNT</td>\n<td>ACCOUNT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ACCTPRIV</td>\n<td>ACCTPRIV</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ACF2CICS</td>\n<td>ACF2CICS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ACTIVE</td>\n<td>ACTIVE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ALLCMDS</td>\n<td>ALLCMDS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ATTR2</td>\n<td>ATTR2</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUDIT</td>\n<td>AUDIT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTHSUP1</td>\n<td>AUTHSUP1</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTHSUP2</td>\n<td>AUTHSUP2</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTHSUP3</td>\n<td>AUTHSUP3</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTHSUP4</td>\n<td>AUTHSUP4</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTHSUP5</td>\n<td>AUTHSUP5</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTHSUP6</td>\n<td>AUTHSUP6</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTHSUP7</td>\n<td>AUTHSUP7</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTHSUP8</td>\n<td>AUTHSUP8</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTOALL</td>\n<td>AUTOALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>eDirectory Attribute</td>\n<td>ACF2 Field</td>\n<td>Syntax</td>\n</tr>\n<tr>\n<td>------------------------------</td>\n<td>--------------</td>\n<td>--------</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTODUMP</td>\n<td>AUTODUMP</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTONOPW</td>\n<td>AUTONOPW</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-AUTOONLY</td>\n<td>AUTOONLY</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-BDT</td>\n<td>BDT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CANCEL</td>\n<td>CANCEL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CHAR</td>\n<td>CHAR</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CICS</td>\n<td>CICS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CICSCCL</td>\n<td>CICSCCL</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CICSID</td>\n<td>CICSID</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CICSOPT</td>\n<td>CICSOPT</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CICSPRI</td>\n<td>CICSPRI</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CICSRSL</td>\n<td>CICSRSL</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CMD-LONG</td>\n<td>CMD-LONG</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CMD-PROP</td>\n<td>CMD-PROP</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CONSOLE</td>\n<td>CONSOLE</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CONSULT</td>\n<td>CONSULT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CRE-TOD</td>\n<td>CRE-TOD</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CSDATE</td>\n<td>CSDATE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-CSWHO</td>\n<td>CSWHO</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DFT-DEST</td>\n<td>DFT-DEST</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DFT-PFX</td>\n<td>DFT-PFX</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DFT-SOUT</td>\n<td>DFT-SOUT</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DFT-SUBC</td>\n<td>DFT-SUBC</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DFT-SUBH</td>\n<td>DFT-SUBH</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DFT-SUBM</td>\n<td>DFT-SUBM</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DG84DIR</td>\n<td>DG84DIR</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DIALBYP</td>\n<td>DIALBYP</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DSNSCOPE</td>\n<td>DSNSCOPE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-DUMPAUTH</td>\n<td>DUMPAUTH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-EXPRIE</td>\n<td>EXPIRE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-GROUP</td>\n<td>GROUP</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-GRP-OPT</td>\n<td>GRP-OPT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-GRP-USER</td>\n<td>GRP-USER</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>eDirectory Attribute</td>\n<td>ACF2 Field</td>\n<td>Syntax</td>\n</tr>\n<tr>\n<td>------------------------------------</td>\n<td>------------</td>\n<td>--------</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-GRPLOGON</td>\n<td>GRPLOGON</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-HOMENODE</td>\n<td>HOMENODE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-IDLE</td>\n<td>IDLE</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-IMS</td>\n<td>IMS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-INTERCOM</td>\n<td>INTERCOM</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-JCL</td>\n<td>JCL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-JOB</td>\n<td>JOB</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-JOBFROM</td>\n<td>JOBFROM</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-KERB-VIO</td>\n<td>KERB-VIO</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-KERBCUR</td>\n<td>KERBCUR</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-KERBCURV</td>\n<td>KERBCURV</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-KERBPRE</td>\n<td>KERBPRE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-KERBPREV</td>\n<td>KERBPREV</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LDEV</td>\n<td>LDEV</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LDS</td>\n<td>LDS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LDSNODES</td>\n<td>LDSNODES</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LDSNODEDEV</td>\n<td>LDSNODEV</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LEADER</td>\n<td>LEADER</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-ACCT</td>\n<td>LGN-ACCT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-DEST</td>\n<td>LGN-DEST</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-MSG</td>\n<td>LGN-MSG</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-PERF</td>\n<td>LGN-PERF</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-PROC</td>\n<td>LGN-PROC</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-RCVR</td>\n<td>LGN-RCVR</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-SIZE</td>\n<td>LGN-SIZE</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-TIME</td>\n<td>LGN-TIME</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LGN-UNIT</td>\n<td>LGN-UNIT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LID</td>\n<td>LID</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LIDSCOPE</td>\n<td>LIDSCOPE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LIDTEMP</td>\n<td>LIDTEMP</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LIDZMAX</td>\n<td>LIDZMAX</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LIDZMIN</td>\n<td>LIDZMIN</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LINE</td>\n<td>LINE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>eDirectory Attribute</td>\n<td>ACF2 Field</td>\n<td>Syntax</td>\n</tr>\n<tr>\n<td>---------------------------</td>\n<td>--------------</td>\n<td>---------</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-LOGSHIFT</td>\n<td>LOGSHIFT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MAIL</td>\n<td>MAIL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MAINT</td>\n<td>MAINT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MAXDAYS</td>\n<td>MAXDAYS</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MINDAYS</td>\n<td>MINDAYS</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MODE</td>\n<td>MODE</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MON-LOG</td>\n<td>MON-LOG</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MONITOR</td>\n<td>MONITOR</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MOUNT</td>\n<td>MOUNT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MSGID</td>\n<td>MSGID</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MULTSIGN</td>\n<td>MULTSIGN</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MUSASS</td>\n<td>MUSASS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MUSDLID</td>\n<td>MUSDLID</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MUSID</td>\n<td>MUSID</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MUSIDINF</td>\n<td>MUSIDINF</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-MUSUPDT</td>\n<td>MUSUPDT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NAME</td>\n<td>NAME</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NO-INH</td>\n<td>NO-INH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NO-OMVS</td>\n<td>NO-OMVS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NO-SMC</td>\n<td>NO-SMC</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NO-STATS</td>\n<td>NO-STATS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NO-STORE</td>\n<td>NO-STORE</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NOMAXVIO</td>\n<td>NOMAXVIO</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NON-CNCL</td>\n<td>NON-CNCL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NOSPOOL</td>\n<td>NOSPOOL</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-NOTICES</td>\n<td>NOTICES</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-OPERATOR</td>\n<td>OPERATOR</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PASSWORD</td>\n<td>PASSWORD</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PAUSE</td>\n<td>PAUSE</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PGM</td>\n<td>PGM</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PHONE</td>\n<td>PHONE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PMT-ACCT</td>\n<td>PMT-ACCT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PMT-PROC</td>\n<td>PMT-PROC</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>eDirectory Attribute</td>\n<td>ACF2 Field</td>\n<td>Syntax</td>\n</tr>\n<tr>\n<td>------------------------------</td>\n<td>------------</td>\n<td>--------</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PP-TRC</td>\n<td>PP-TRC</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PP-TRCV</td>\n<td>PP-TRCV</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PPGM</td>\n<td>PPGM</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PREFIX</td>\n<td>PREFIX</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRIV-CTL</td>\n<td>PRIV-CTL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PROGRAM</td>\n<td>PROGRAM</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PROMPT</td>\n<td>PROMPT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRV-TOD1</td>\n<td>PRV-TOD1</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRV-TOD2</td>\n<td>PRV-TOD2</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRV-TOD3</td>\n<td>PRV-TOD3</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRV-TOD4</td>\n<td>PRV-TOD4</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRVPSWD1</td>\n<td>PRVPSWD1</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRVPSWD2</td>\n<td>PRVPSWD2</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRVPSWD3</td>\n<td>PRVPSWD3</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PRVPSWD4</td>\n<td>PRVPSWD4</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWA1TOD</td>\n<td>PSWA1TOD</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWA1VAL</td>\n<td>PSWA1VAL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-DAT</td>\n<td>PSWD-DAT</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-EXP</td>\n<td>PSWD-EXP</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-INV</td>\n<td>PSWD-INV</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-MIX</td>\n<td>PSWD-MIX</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-MX8</td>\n<td>PSWD-MX8</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-SRC</td>\n<td>PSWD-SRC</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-TIM</td>\n<td>PSWD-TIM</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-TOD</td>\n<td>PSWD-TOD</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-UPP</td>\n<td>PSWD-UPP</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-VIO</td>\n<td>PSWD-VIO</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-XTR</td>\n<td>PSWD-XTR</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWD-XTV</td>\n<td>PSWD-XTV</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWDAES1</td>\n<td>PSWDAES1</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PSWDCVIO</td>\n<td>PSWDCVIO</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PTICKET</td>\n<td>PTICKET</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PWP-DATE</td>\n<td>PWP-DATE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>eDirectory Attribute</td>\n<td>ACF2 Field</td>\n<td>Syntax</td>\n</tr>\n<tr>\n<td>------------------------------</td>\n<td>--------------</td>\n<td>----------</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PWP-VIO</td>\n<td>PWP-VIO</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-PWPAALLOW</td>\n<td>PWPAALLOW</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RECOVER</td>\n<td>RECOVER</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-RESTRICT</td>\n<td>RESTRICT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-READALL</td>\n<td>READALL</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-REFRESH</td>\n<td>REFRESH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>eDirectory Attribute</td>\n<td>ACF2 Field</td>\n<td>Syntax</td>\n</tr>\n<tr>\n<td>----------------------</td>\n<td>------------</td>\n<td>---------</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-TSORBA</td>\n<td>TSORBA</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-TSORGN</td>\n<td>TSORGN</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-TSOSIZE</td>\n<td>TSOSIZE</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-TSOTIME</td>\n<td>TSOTIME</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-TSOUNIT</td>\n<td>TSOUNIT</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-UID</td>\n<td>UID</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-UIDSCOPE</td>\n<td>UIDSCOPE</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-UNICNTR</td>\n<td>UNICNTR</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-UPD-TOD</td>\n<td>UPD-TOD</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-USER</td>\n<td>USER</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VAR-HIGH</td>\n<td>VAR-HIGH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VLD-ACCT</td>\n<td>VLD-ACCT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VLD-PROC</td>\n<td>VLD-PROC</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VLDRSTCT</td>\n<td>VLDRSTCT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VLDVMACT</td>\n<td>VLDVMACT</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VM</td>\n<td>VM</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMACCT</td>\n<td>VMACCT</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMD4AUTH</td>\n<td>VMD4AUTH</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMD4FSEC</td>\n<td>VMD4FSEC</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMD4RSET</td>\n<td>VMD4RSET</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMD4TARG</td>\n<td>VMD4TARG</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMESM</td>\n<td>VMESM</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMIDLEMN</td>\n<td>VMIDLEMN</td>\n<td>INTEGER</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMIDLEOP</td>\n<td>VMIDLEOP</td>\n<td>STRING</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMSAF</td>\n<td>VMSAF</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMSFS</td>\n<td>VMSFS</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VMXA</td>\n<td>VMXA</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-VSESRF</td>\n<td>VSESRF</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-WTP</td>\n<td>WTP</td>\n<td>STATE</td>\n</tr>\n<tr>\n<td>DirXML-ACF2-ZONE</td>\n<td>ZONE</td>\n<td>STRING</td>\n</tr>\n</tbody>\n</table>"}}},{"rowIdx":166,"cells":{"id":{"kind":"string","value":"ab83e31e67d5c38044b8cef4cb450d9faf879d3a"},"text":{"kind":"string","value":"Master’s Thesis\n\nGtext\n\nA Language Workbench based on GLL and Term Rewriting\n\nAli Afroozeh\n\nAugust 24, 2012\n\nSupervisor:\nProf. dr. Mark van den Brand\nI dedicate this work to my parents, for their encouragement and support at every step during my Master’s studies.\nAbstract\nOne of the main difficulties in developing domain-specific languages is the use of deterministic parsing technologies in language workbenches. These deterministic parsers do not naturally support modularity, and impose restrictions on defining the grammar of a language. For example, LL(k) parsers cannot deal with left recursion or ambiguities, which have to be removed by rewriting the grammar. These modifications usually lead to a grammar definition which is not readable and may cause maintenance problems. More importantly, the parse trees from a modified grammar may be significantly different from the ones of the original, ambiguous grammar. This may cause problems in processing parse trees, for example, for mapping to EMF models.\n\nIn this thesis, we present a new language workbench based on the GLL parsing algorithm. GLL is able to parse the full class of context-free grammars without any limitation and thus inherently supports modularity. Being a generalized parser, GLL produces a parse forest containing all the ambiguities. Our disambiguation method is based on pattern matching and rewriting within the resulting parse forest. One of the motivations for our disambiguation mechanism is solving hard parsing problems such as language embeddings and extensions. In addition, we present an error reporting mechanism for GLL-based parsers, an Eclipse plugin for developing new languages, and facilities for the mapping of ambiguous, complex concrete syntax to EMF models.\nAcknowledgements\n\nThis thesis would have not been possible without the assistance of many people, whom I would like to gratefully acknowledge. First and foremost, I would like to thank my supervisor, Professor Mark van den Brand, for his invaluable guidance and advice during the course of this project. I particularly enjoyed his vast knowledge in parsing and the freedom he gave me to explore different disambiguation mechanisms. I also would like to thank Maarten Manders, who has provided me with his GLL implementation and helped me through the course of this project. His feedback on a first draft of this thesis was very useful. Without his initial work, I could come this far.\n\nI would like to express my gratitude for Professor Elizabeth Scott, who has provided me with crucial feedback on this thesis. Her comments have greatly contributed to the accuracy of the claims made in the disambiguation chapter. Furthermore, I appreciate the help of Professor Adrian Johnstone and fruitful discussions we had on GLL implementation.\n\nImplementing the disambiguation mechanism, which is the core part of this thesis, would have not been possible without the assistance of members of the Tom project. I would like to specifically thank Professor Pierre-Etienne Moreau, for his assistance during the island parsing project and my thesis. His knowledge on term rewriting had a significant impact on the successful implementation of the disambiguation mechanism. I also would like to thank Jean-Christophe Bach who has kindly helped me in learning Tom and applying it in my thesis.\n\nPart of this project is the continuation of my seminar course. I would like to thank Dr. Alexander Serebrenik, who has kindly provided me with valuable feedback on this work, during and after the seminar course. Last but not least, I express my appreciation for Dr. Serguei Roubtsov, a member of the examination committee, who has read and evaluated my work.\n# Contents\n\n1 Introduction .......................................................... 1\n\n2 Preliminaries ......................................................... 4\n 2.1 Context-free Grammars ........................................... 4\n 2.2 Generalized LL Parsing ......................................... 5\n 2.3 Tom in a Nutshell ................................................. 7\n\n3 Modular EBNF (MEBNF) Syntax Formalism ......................... 10\n 3.1 An Abstract Syntax for EBNF .................................... 10\n 3.2 EBNF to BNF Conversion ......................................... 11\n 3.3 A Concrete Syntax for MEBNF ................................... 15\n 3.4 Lexical Syntax .................................................... 17\n 3.5 Layout ............................................................ 21\n 3.6 Modularity ....................................................... 21\n\n4 Error Reporting in Generalized LL Parsers ....................... 23\n\n5 Disambiguation by Rewriting within the Parse Forest ............. 26\n 5.1 Rewriting within the SPPF ....................................... 28\n 5.2 Concrete Syntax for Disambiguation Rules ..................... 34\n 5.3 Binary and Unary Operators ..................................... 36\n 5.3.1 Concrete Syntax for Operator Associativities and Priorities .................................................. 36\n 5.3.2 Translation to Disambiguation Rules ..................... 39\n 5.4 Implementation .................................................. 40\n 5.5 Disambiguation as a Term Rewriting System ................. 43\n\n6 Disambiguation by Example .......................................... 46\n 6.1 Complex Ambiguities in Programming Languages ............... 46\n 6.1.1 Postfix Expressions with Guarded Children ........... 46\n 6.1.2 Overloaded Commas ........................................ 47\n 6.1.3 The Dangling Else Ambiguity ............................ 48\nB Tom mapping for SPPF 92\nC An Introspector for SPPF mapping 94\nD An Ambiguous Pico Grammar in EBNF 95\nE Disambiguation rules for mCRL2 99\nF An MEBNF grammar for Tom 103\nList of Figures\n\n2.1 SPPF .................................................. 7\n3.1 The SPPF resulting from the parsing of \"aaacc\" with intermediary EBNF nodes. .............................. 14\n3.2 The SPPF resulting from the parsing of \"aaacc\" without intermediary EBNF nodes. .............................. 14\n5.1 A grammar for arithmetic addition .......................... 26\n5.2 The complete SPPF resulting from parsing \"1+2+3\". ........ 29\n5.3 The SPPF resulting from parsing \"1+2+3\" without unambiguous intermediate and packed nodes. ............. 30\n5.4 The SPPF resulting from parsing 1+2*3 .................. 31\n5.5 The parse tree resulting from parsing 1--2*3--4*5*3\" ........ 39\n5.6 Different SPPF representations ........................... 41\n5.7 An ambiguous SPPF ....................................... 45\n6.1 The SPPF resulting from parsing e+e(e+e) .................. 47\n6.2 The SPPF resulting from parsing f(e,e) .................. 48\n6.3 The dangling else ambiguity ............................. 49\n6.4 The ambiguity in the then part ........................... 50\n6.5 The SPPF corresponding to the parsing of \"return (x)\" .... 51\n6.6 The island-water ambiguity ............................. 54\n6.7 The island-island ambiguity ............................. 55\n6.8 The island-island ambiguity resulting from parsing \"const int x = 1\" ........................................ 56\n7.1 The parsing and disambiguation times for arithmetic expressions ...................................................... 58\n7.2 The parsing and disambiguation times for mCRL2 ........ 59\n7.3 The parsing and disambiguation times for Tom ........... 60\n8.1 The architecture of the JGLL parser generator ............ 63\n8.2 Parse tree for \"if if then then = if\" ..................... 64\n9.1 An overview of an IMP-based Eclipse plugin for MEBNF. ... 73\n9.2 Error messages appear in the editor as soon as a parse error occurs ........................................ 73\n10.1 The Arithmetics meta-model ........................................ 77\nD.1 A metamodel for Pico ........................................ 98\nList of Tables\n\n3.1 A step-by-step example of EBNF to BNF conversion . . . . . 13\n7.1 The average disambiguation results. Times are in milliseconds 58\nList of Listings\n\n2.1 An example of a Tom program .......................... 9\n3.1 The algebraic definition describing the abstract syntax of EBNF 11\n3.2 The starting rules of MEBNF’s concrete syntax ............. 15\n3.3 A concrete syntax for defining context-free rules in MEBNF . 16\n3.4 The abstract syntax of MEBNF’s lexical definition .......... 19\n3.5 MEBNF’s concrete syntax for lexical definitions .......... 19\n3.6 An example of a layout definition section .................. 21\n5.1 A simple grammar for arithmetic addition ................... 28\n5.2 An algebraic type definition for the SPPF ................. 30\n5.3 A rewrite rule in Tom for preferring the left-associative derivation. .................. 31\n5.4 A rewrite rule in Tom giving ** a higher priority over *+* . 32\n5.5 The rewrite rule for preferring the left-associativity by taking the layout definition into account .................. 33\n5.6 The MEBNF specification for disambiguation rewrite rules . 35\n5.7 Concrete syntax for the associativity and priority of operators 36\n5.8 A grammar for arithmetic expressions ...................... 37\n5.9 The associativity and priority of arithmetic operations .... 38\n5.10 Context-free priorities forRegularExpression ................ 38\n5.11 A rewrite rule in Tom for preferring the left-associative derivation .......................... 42\n6.1 A grammar for postfix expressions ...................... 46\n6.2 A grammar for expression languages with overloaded commas 47\n6.3 A grammar for conditional statements ...................... 49\n6.4 Resolving the dangling else ambiguity .................... 49\n6.5 Resolving the ambiguity of the then part .................. 50\n6.6 A grammar for showing the ambiguity in syntactic overloading 51\n6.7 preferring the keyword return to identifiers ................ 51\n6.8 The starting rules of an island grammar ................... 52\n6.9 Resolving the island-water ambiguity ..................... 54\n6.10 An island grammar for integer definitions and assignments . 56\n6.11 Resolving the island-water ambiguity in Figure 6.11 .... 56\n8.1 A Java function associated with ........................... 63\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>8.2</td>\n<td>A grammar for if statements without reserved keywords</td>\n<td>64</td>\n</tr>\n<tr>\n<td>8.3</td>\n<td>Needed steps for parsing and disambiguation</td>\n<td>66</td>\n</tr>\n<tr>\n<td>8.4</td>\n<td>The disambiguationRule interface</td>\n<td>66</td>\n</tr>\n<tr>\n<td>9.1</td>\n<td>A parser controller implementation for MEBNF</td>\n<td>69</td>\n</tr>\n<tr>\n<td>9.2</td>\n<td>Getting the token iterator using Tom</td>\n<td>70</td>\n</tr>\n<tr>\n<td>9.3</td>\n<td>Token coloring for MEBNF’s keywords</td>\n<td>70</td>\n</tr>\n<tr>\n<td>9.4</td>\n<td>Creating tree models from MEBNF’s AST</td>\n<td>71</td>\n</tr>\n<tr>\n<td>9.5</td>\n<td>Making MEBNF’s sections foldable</td>\n<td>72</td>\n</tr>\n<tr>\n<td>10.1</td>\n<td>Augmenting the MEBNF concrete syntax with annotation support</td>\n<td>75</td>\n</tr>\n<tr>\n<td>10.2</td>\n<td>Concrete syntax for defining annotations</td>\n<td>75</td>\n</tr>\n<tr>\n<td>10.3</td>\n<td>EMF mapping annotations for arithmetics expressions</td>\n<td>76</td>\n</tr>\n<tr>\n<td>A.1</td>\n<td>The MEBNF module</td>\n<td>88</td>\n</tr>\n<tr>\n<td>A.2</td>\n<td>The Annotations module</td>\n<td>89</td>\n</tr>\n<tr>\n<td>A.3</td>\n<td>The Disambiguation module</td>\n<td>90</td>\n</tr>\n<tr>\n<td>A.4</td>\n<td>The Priorities Module</td>\n<td>90</td>\n</tr>\n<tr>\n<td>A.5</td>\n<td>The Basics module</td>\n<td>91</td>\n</tr>\n</tbody>\n</table>\nChapter 1\n\nIntroduction\n\nLanguage workbenches [20] are tools that facilitate the development of domain-specific languages (DSLs). These tools provide an environment for editing the syntax of DSLs and can even generate a development environment for DSLs. In addition to syntax editing, many language workbenches also provide means for disambiguation, type checking, parse tree processing, and mapping to meta-modeling frameworks such as EMF [5].\n\nThe first step in language processing is parsing, and the choice of parsing technology significantly influences a language workbench’s capabilities and usage. One of main difficulties in developing domain-specific languages is the use of deterministic parsing technologies in language workbenches. These deterministic parsers do not naturally support modularity, and impose restrictions on defining the grammar of a language. For example, LL(k) parsers cannot deal with left recursion and ambiguities, which have to be removed by rewriting the grammar. These modifications usually lead to a grammar definition which is not readable and may lead to maintenance problems. More importantly, the parse trees from a modified grammar may not be as natural as the ones of the original ambiguous grammar. This hinders the processing of a parse tree, for example, for mapping to arbitrary EMF models.\n\nFurthermore, deterministic parsers cannot be used to solve hard parsing problems, such as language embeddings and extensions, at least not easily. First, the class of deterministic context-free languages is not closed under union [22], meaning that the union of two deterministic languages might not be deterministic. Therefore, even if one designs LL(k) or LR(k) syntax for two languages, there is no guarantee that the resulting language of combining them be deterministic. Second, different languages may share tokens, which may lead to ambiguities in language compositions. These ambiguities can not be easily resolved by deterministic parsers.\nCurrent language workbenches can be divided in two categories. In the first group there are Xtext [13] and EMFT ext [6], which are based on ANTLR [1], a deterministic LL(k) parsing technology. EMFT ext and Xtext have the mentioned problems for deterministic parsers, thus they are not suitable for creating an environment for language extensions, for example. However, they provide good support, within the limitations of LL(k) parsing, for binding concrete syntax to EMF. The second category is composed of ASF+SDF [34] successors. These tools are Rascal [11] and Spoofax [12] which are based on SGLR [38], a generalized parsing technique. As generalized parsers support the full class of context-free grammars, these tools are powerful enough for language experimentation and building parsers for embedded languages, but they provide no support for EMF mapping.\n\nDuring the last 30 years, more efficient implementations of generalized parsers have become available. Since the algorithm formulated by Tomita [32] there have been a number of generalized LR parsing (GLR) implementations, such as GLR [29], a scannerless variant (SGLR) [38] and Dparser [2]. Johnstone and Scott developed a generalized LL (GLL) parser [31] in which the function call stack in a traditional recursive descent parser is replaced by a structure similar to the stack data structure (Graph Structured Stack) used in GLR parsing. GLL parsers are particularly interesting because their implementations are straightforward and efficient.\n\nIn this thesis we present Gtext, a prototype of a language workbench based on GLL and Term Rewriting. Gtext uses a Java implementation of GLL as its underlying parsing technology, and provides mappings to EMF. The GLL parsing algorithm is relatively new, and there is currently no standard disambiguation mechanism for selecting the desired derivation from a set of derivations. A great part of this work is dedicated to developing a generic disambiguation mechanism for GLL parsers. The disambiguation mechanism is based on term rewriting within the parse forest produced from a GLL parser, without modifications in the parser. As we show in Chapter 6, the disambiguation mechanism can be used to deal with complex ambiguities, thus making Gtext a suitable tool for language experimentation and developing parsers for embedded languages.\n\nThe research questions we answer in this thesis are as follows:\n\n1. How can one select a derivation from a set of ambiguous derivations produced by a GLL parser? i.e., how to disambiguate a parse forest produced by GLL.\n2. How to report parse errors from GLL parsers?\n3. Can our disambiguation mechanism, together with GLL, be used to solve complex ambiguities arising in programming languages and language embeddings?\n4. How can GLL be integrated into the Eclipse platform [3] to build \nGLL-based Integrated Development Environments (IDEs)?\n\nThis rest of this thesis is organized as follows.\n\nChapter 2, Preliminaries, presents a set of preliminary topics, providing a \ntechnical basis for the rest of this thesis. The preliminary topics include \nan overview of context-free grammars, the GLL parsing algorithm, and the \nTom language.\n\nChapter 3, MEBNF Syntax Formalism, presents a modular EBNF formal- \nism, MEBNF, for describing the syntax of context-free grammars. MEBNF \nis the basis for our parser generator presented in Chapter 8.\n\nChapter 4, Error Reporting in Generalized LL Parsers, describes an error \nreporting mechanism for generated GLL parsers.\n\nChapter 5, Disambiguation by Rewriting within the Parse Forest, the core \npart of this thesis, presents our disambiguation mechanism, which is based \non term rewriting within GLL’s parse forest, in detail.\n\nChapter 6, Disambiguation by Example, presents a number of complex am- \nbiguities in programming languages and island grammars [26]. Island gram- \nmars are particularly suitable for implementing parsers for language embed- \ndings.\n\nChapter 7, Experiments, presents three case studies for the evaluation of \nour disambiguation mechanism.\n\nChapter 8, JGLL Parser Generator, describes the architecture and imple- \nmentation of our Java-based GLL parser generator, JGLL.\n\nChapter 9, The Eclipse Plugin, is dedicated to the integration of GLL to \nthe Eclipse platform.\n\nChapter 10, EMF Model Generation, incorporates the EMF mapping intro- \nduced in previous work [24] to \\( \\mathcal{G}_{\\text{text}} \\). In this chapter, we show how to map \nambiguous grammars written in EBNF to meta-models.\n\nChapter 11, Future Work, discusses the current issues in this work, and \npropose research paths for future work.\n\nChapter 12, Conclusions, provides a conclusion to this work.\nChapter 2\n\nPreliminaries\n\n2.1 Context-free Grammars\n\nA context-free grammar (CFG) consists of a set \\( N \\) of nonterminals, a set \\( T \\) of terminals, a set of grammar rules of the form \\( A ::= \\alpha \\) where \\( A \\in N \\) and \\( \\alpha \\) is a string in \\((T \\cup N)^*\\), and a specified start symbol, \\( S \\in N \\). The symbol \\( \\epsilon \\) denotes the empty string. Rules with the same left hand side can be written as a single rule using the alternation symbol, \\( A ::= \\alpha_1 | \\ldots | \\alpha_k \\). The strings \\( \\alpha_i \\) are the alternates of \\( A \\).\n\nA grammar \\( \\Gamma \\) defines a set of strings of terminals, its language, as follows. A derivation step, has the form \\( \\gamma A \\beta \\Rightarrow \\gamma \\alpha \\beta \\) where \\( \\gamma, \\beta \\in (T \\cup N)^* \\) and \\( A ::= \\alpha \\) is a grammar rule. A derivation of \\( \\tau \\) from \\( \\sigma \\) is a sequence \\( \\sigma \\Rightarrow \\beta_1 \\Rightarrow \\beta_2 \\Rightarrow \\ldots \\Rightarrow \\beta_{n-1} \\Rightarrow \\tau \\), also written \\( \\sigma \\Rightarrow^* \\tau \\). A derivation is left-most if at each step the left-most nonterminal is replaced. The language defined by \\( \\Gamma \\) is the set of \\( u \\in T^* \\) such that \\( S \\Rightarrow^* u \\). A grammar is ambiguous if there is a string \\( u \\) for which there is more than one left-most derivation \\( S \\Rightarrow^* u \\).\n\nThe role of a parser for \\( \\Gamma \\) is, given a string \\( u \\in T^* \\), to find (all) the derivations \\( S \\Rightarrow^* u \\). In our case the derivations will be recorded as trees. A derivation tree in \\( \\Gamma \\) is an ordered tree whose root node is labeled with the start symbol, whose interior nodes are labeled with nonterminals and whose leaf nodes are labeled with elements of \\( T \\cup \\{ \\epsilon \\} \\). The children of a node labeled \\( A \\) are ordered and labeled with the symbols, in order, from an alternate of \\( A \\). The yield of the tree is the string of leaf node labels in left to right order. A grammar \\( \\Gamma \\) is ambiguous if and only if there are two or more derivation trees in \\( \\Gamma \\) with the same yield.\n\nThe first set of the symbol \\( X \\) is the set of all tokens which can appear as the first token derivable from \\( X \\). The first set can be computed from the grammar as follows:\n• If $X$ is a terminal, then $\\text{first}(X) = \\{X\\}$.\n\n• Let $Y := X_1X_2...X_n$ be a production rule. Then, $\\text{first}(X_1) - \\{\\epsilon\\}$ is in $\\text{first}(Y)$, and if $X_1 \\Rightarrow \\epsilon$, $\\text{first}(X_2) - \\{\\epsilon\\}$ is also in $\\text{first}(Y)$ and so on. In the general case, if $Y := X_1X_2...X_{j-1}X_j...X_n$, then $\\text{first}(X_i)$, $1 \\leq i \\leq j - 1$, except for $\\epsilon$ are in $\\text{first}(Y)$. If $X_1X_2...X_{j-1} \\Rightarrow \\epsilon$, $\\text{first}(X_j) - \\{\\epsilon\\}$ is also in $\\text{first}(Y)$.\n\n• If $X \\Rightarrow \\epsilon$, then $\\epsilon$ is in the $\\text{first}(X)$.\n\nThe $\\text{FOLLOW}$ set of a nonterminal $X$ determines the set of terminals which can immediately appear after $X$ in sentential forms derivable from the start symbol. The $\\text{FOLLOW}$ set can be computed as:\n\n• Let $S$ be the start symbol of the grammar, then $\\$, denoting the end of input symbol, is in $\\text{FOLLOW}(S)$.\n\n• For the production rule $A ::= \\alpha{B}\\beta$, in which $\\alpha$ is a list of zero or more symbols and $\\beta$ is a list of one or more symbols, $\\text{first}(\\beta)$ except for the empty symbol, $\\epsilon$, is in $\\text{FOLLOW}(B)$. Moreover, if $\\text{first}(\\beta)$ contains $\\epsilon$, then $\\text{FOLLOW}(A)$ is in $\\text{FOLLOW}(B)$.\n\n• For the production rule $A ::= \\alpha B$, $\\text{FOLLOW}(A)$ is in the $\\text{FOLLOW}(B)$.\n\nThe $\\text{TEST}$ set of a nonterminal $X$ is the same as the $\\text{FIRST}(X)$, and if $\\epsilon \\in \\text{FIRST}(X)$, then $\\text{FOLLOW}(X)$ is also in $\\text{TEST}(X)$. The $\\text{TEST}$ set of a nonterminal is used by parsers to select an alternate of the nonterminal based on the current token from the input.\n\n2.2 Generalized LL Parsing\n\nTop down parsers whose execution closely follows the structure of the underlying grammar are attractive, particularly because they make grammar debugging easier. GLL is a top down parsing technique which is fully general, allowing even left recursive grammars, which has worst-case cubic runtime order and which is close to linear on most ‘real’ grammars. In this section we give a basic description of the technique, a full formal description can be found in [31].\n\nA GLL parser effectively traverses the grammar using the input string to guide the traversal. There may be several traversal threads, each of which has a pointer into the grammar and a pointer into the input string. For each nonterminal $A$ there is a block of code corresponding to each alternate of $A$. At each step of the traversal, (i) if the grammar pointer is immediately before a terminal we attempt to match it to the current input symbol; (ii) if it is immediately before a nonterminal $B$ then the pointer moves to the start of\nthe block of code associated with $B$; (iii) if it is at the end of an alternate of $A$ then it moves to the position immediately after the instance of $A$ from which it came. This control flow is essentially the same as for a classical recursive descent parser in which the blocks of code for a nonterminal $X$ are collected into a parse function for $X$ with traversal steps of type (ii) implemented as a function call to $X$ and traversal steps of type (iii) implemented as function return. In classical recursive descent, we use the runtime stack to manage actions (ii) and (iii) but in a general parser there may be multiple parallel traversals arising from nondeterminism; thus in the GLL algorithm the call stack is handled directly using a Tomita-style graph structured stack (GSS) which allows the potentially infinitely many stacks arising from multiple traversals to be merged and handled efficiently.\n\nMultiple traversal threads are handled using process descriptors, making the algorithm parallel rather than backtracking in nature. Each time a traversal bifurcates, the current grammar and input pointers, together with the top of the current stack and associated portion of the derivation tree, are recorded in a descriptor. The outer loop of a GLL algorithm removes a descriptor from the set of pending descriptors and continues the traversal thread from the point at which the descriptor was created. When the set of pending descriptors is empty all possible traversals will have been explored and all derivations (if there are any) will have been found.\n\nWe define a grammar slot to be a position immediately before or after any symbol in any alternate and the grammar pointer points to a grammar slot. We use the familiar LR(0)-style notation, $X ::= x_1 \\ldots x_i \\cdot x_{i+1} \\ldots x_q$ denotes the slot before the symbol $x_{i+1}$. During a traversal, in the case where $x_{i+1}$ is a nonterminal, the ‘return’ slot $X ::= x_1 \\ldots x_{i+1} \\cdot x_{i+2} \\ldots x_q$ is added to the GSS and the pointer is moved to some slot of the form $x_{i+1} ::= \\delta$.\n\nOf course, there may be more than one such slot. The selector set associated with $x_{i+1} ::= \\delta$ is the set of terminals $a$ such that there is some derivation $S \\rightarrow^* vx_{i+1} \\beta \\rightarrow^* v\\delta \\beta \\rightarrow^* vau$, where $v, u \\in T^*$. (If $\\beta, \\delta \\rightarrow \\epsilon$ then the end-of-string symbol is also included in the selector set.) A slot is chosen only if the current input symbol belongs to its selector set, but even so there may be more than one choice of slot. Thus, when the traversal reaches the start or the end of an alternate the possible traversal continuations are recorded in context descriptors. These are 4-tuples $(t, i, u, w)$ where $t$ is the current grammar position (slot), $i$ is the current input pointer position, $u$ is the node on top of the current return-slot stack of the GSS and $w$ is the root of the current derivation subtree. Details of the creation and processing of the descriptors by a GLL algorithm can be found in [31] and a more implementation oriented discussion can be found in [30].\n\nThe output of a GLL parser is a representation of all the possible derivations of the input in the form of a shared packed parse forest (SPPF), a union\nof all the derivation trees of the input in which nodes with the same tree below them are shared and nodes which correspond to different derivations of the same substring from the same nonterminal are combined by creating a packed node for each family of children. To make sure that descriptors contain only one tree node, the root of the current subtree, the SPPFs are binarized in the natural left associative manner, with the two left-most children being grouped under an intermediate node, which is in turn then grouped with the next child to the left, etc. It is this binarization that keeps both the size of the SPPF and the number of descriptors worst-case cubic.\n\nIn detail, a binarized SPPF has three types of SPPF nodes: symbol nodes, with labels of the form \\((x; j; i)\\) where \\(x\\) is a terminal, nonterminal or \\(\\epsilon\\) and \\(0 \\leq j \\leq i \\leq n\\); intermediate nodes, with labels of the form \\((t; j; i)\\); and packed nodes, with labels for the form \\((t; k)\\), where \\(0 \\leq k \\leq n\\) and \\(t\\) is a grammar slot. (A grammar slot is essentially an LR(0)-item, a formal definition can be found in [31].) Terminal symbol nodes have no children. Nonterminal symbol nodes, \\((A; j; i)\\), have packed node children of the form \\((A := \\gamma; k)\\) and intermediate nodes, \\((t; j; i)\\), have packed node children with labels of the form \\((t; k)\\), where \\(j \\leq k \\leq i\\). A packed node has one or two children, the right child is a symbol node \\((x; k; i)\\), and the left child, if it exists, is a symbol or intermediate node, \\((s; j; k)\\). For example, for the grammar \\(S := abc | aA, \\quad A := bc\\) we obtain the SPPF as shown in Figure 2.1. As is clear from this example, for ambiguous grammars there will be more than one derivation.\n\n2.3 Tom in a Nutshell\n\nTom [16, 27] is a language based on rewriting calculus and is designed to integrate term rewriting and pattern matching facilities into general-purpose programming languages (GPLs) such as Java, C, C++, Python or Caml.\nTom relies on the Formal Island framework [17], meaning that the underlying host-language does not need to be parsed in order to compile Tom constructs.\n\nThe basic functionality of Tom is pattern matching through the %match construct. This construct can be seen as a generalization of the switch-case construct of many GPLs. The %match construct is composed of a set of rules where the left-hand side is a pattern, i.e., a tree that may contain variables, and the right-hand side an action, given by a Java block that may in turn contain Tom constructs.\n\nA second construct provided by Tom is the backquote (`) term. Given an algebraic term, i.e., a tree, a backquote term builds the corresponding data structure by allocating and initializing the required objects in memory.\n\nA third component of the Tom language is a formalism named Gom to describe algebraic data structures by means of the %gom construct. This corresponds to the definition of an inductive types in classical functional programming. There are two main ways of using this formalism: the first one is defining an algebraic data type in Gom and generating Java classes which implement the data type. This is similar to the EMF [5], in which a Java implementation can be generated from a meta-model definition. The second approach assumes that a data structure implementation, for example in Java, already exists. Then one can define an algebraic data type in Gom and provide a mapping to connect the algebraic type to the existing implementation.\n\nListing 2.1 illustrates a simple example of a Tom program. The program starts with a Java class definition. The %gom construct defines an algebraic data type with one module, Peano. The module defines a sort Nat with two constructors: zero and suc. The constructor suc takes a variable n as a field. Given a signature, a well-formed and well-typed term can be built using the backquote (`) construct. For example, for Peano, `zero()` are `suc(zero())` are correct terms, while `suc(zero(),zero())` or `suc(3)` are not well-formed and not well-typed, respectively.\npublic class PeanoExample {\n\n module Peano {\n Nat = zero() | suc(n: Nat)\n }\n\n public Nat plus(Nat t1, Nat t2) {\n %match(t1,t2) {\n x,zero() -> {\n return 'x;\n }\n x,suc(y) -> {\n return 'suc(plus(x,y));\n }\n }\n }\n\n boolean greaterThan(Nat t1, Nat t2) {\n %match(t1,t2) {\n x,x -> {\n return false;\n }\n suc(_,zero()) -> {\n return true;\n }\n zero(),suc(_) -> {\n return false;\n }\n suc(x),suc(y) -> {\n return 'greaterThan(x,y);\n }\n }\n }\n\n public final static void main(String[] args) {\n Nat N = `zero();\n for (int i=0 ; i<10 ; i++) { N = `suc(N); }\n }\n}\n\nListing 2.1: An example of a Tom program\n\nIn the example of Listing 2.1, the plus() and greaterThan() methods are implemented by pattern matching. The semantics of pattern matching in Tom is close to the match that exists in functional programming languages, but in an imperative context. A %match is parametrised by a list of subjects, i.e., expressions evaluated to ground terms, and contains a list of rules. The left-hand side of the rules are patterns built upon constructors and new variables, without any restriction on linearity (a variable may appear twice, as in x,x). The right-hand side is a Java statement that is executed when the pattern matches the subject. Using the backquote construct (`) a term can be created and returned. Similar to the standard switch/case construct, patterns are evaluated from top to bottom. In contrast to the functional match, several actions (i.e., right-hand side) may be fired for a given subject as long as no return or break is executed.\n\nIn addition to the syntactic matching capabilities illustrated above, Tom also supports more complex matching theories such as matching modulo associativity, associativity with neutral element, and associativity-commutativity.\nChapter 3\n\nModular EBNF (MEBNF) Syntax Formalism\n\nThis chapter presents the MEBNF syntax formalism for defining context-free grammars. MEBNF provides means for defining modular grammars in EBNF. The version of the GLL algorithm we are currently using does not natively support EBNF. Therefore, we perform an EBNF to BNF conversion step prior to generating a GLL parser. In this chapter, we first give an abstract syntax for EBNF, in Section 3.1, and its conversion to BNF, in Section 3.2, with which our GLL parser generator works. We introduce the concrete syntax of the MEBNF formalism in sections 3.3 and 3.4. We conclude this chapter by briefly discussing modularity in context-free grammars and its implementation in MEBNF in Section 3.6.\n\n3.1 An Abstract Syntax for EBNF\n\nListing 3.1 introduces an abstract syntax for EBNF. The abstract syntax is implemented in Gom. For implementation details, the reader is referred to Chapter 8. As can be seen, a context-free grammar, represented by Grammar, consists of a name, a start symbol, a set of context-free rules, and a set of lexical rules. Lists in Gom are defined with the * operator. For example, concSymbol(Symbol*) is a constructor for defining a list of Symbols. The name conc... is chosen to comply with Gom’s naming convention, and it stands for a concatenation of types. This Gom module imports a Lexical module containing the abstract syntax of lexical rules. We discuss the lexical syntax in detail in Section 3.4.\nmodule EBNF\nimports String char Lexical\nabstract syntax\n\nGrammar = Grammar(name:String, startSymbol:Symbol,\n contextFreeRules:ContextFreeRuleList,\n lexicalRules:LexicalRuleList)\n\nContextFreeRuleList = concContextFreeRule(ContextFreeRule*)\n\nLexicalRuleList = concLexicalRule(LexicalRule*)\n\nContextFreeRule = ContextFreeRule(head:Symbol, body:SymbolList)\n\nSymbolList = concSymbol(Symbol*)\n\nSymbol = Nonterminal(name:String)\n | Terminal(name:String)\n | Star(symbol:Symbol)\n | Plus(symbol:Symbol)\n | Opt(symbol:Symbol)\n | Alt(first:SymbolList, second:SymbolList)\n | Group(symbols:SymbolList)\n\nListing 3.1: The algebraic definition describing the abstract syntax of EBNF\n\nIn the current version of Gom, a constructor’s parameters can only be types, defined on the left hand side and not other constructors. This is the reason that we defined a context-free rule as ContextFreeRule(head:Symbol, ...) and not ContextFreeRule(head:Nonterminal, ...), although based on the definition in Section 2.1, the head of a context-free rule can only be a nonterminal. In the automatic translation of MEBNF’s concrete syntax to the abstract syntax in 3.1, correct constructors are selected to instantiate a Symbol.\n\nDifferent EBNF symbols are defined as follows:\n\n- Star(s), Plus(s), Opt(s) denote, zero or more, one or more, zero or one, occurrences of s, respectively, where s is a Symbol.\n- Alt(l1, l2) denotes a choice between l1 and l2, where l1 and l2 are instances of SymbolList, a list of symbols.\n- Group(symbolList) groups a list of symbols, an instance of SymbolList.\n\n3.2 EBNF to BNF Conversion\n\nAs mentioned before, the version of the GLL parsing algorithm we are currently using does not natively support EBNF. As part of the parser gener-\nation process, we convert a grammar written in EBNF into an equivalent BNF one. The conversion rules are as follows.\n\n1. Replace a group $(\\alpha)$, where $\\alpha$ denotes a sequence of symbols, by a nonterminal $X$, and add the rule $X ::= \\alpha$ to the set of context-free rules.\n\n2. Replace context-free rules of the form $X ::= \\alpha | \\beta$, where $\\alpha$ and $\\beta$ denote a sequence of symbols, by two rules: $X ::= \\alpha$ and $X ::= \\beta$.\n\n3. Replace a symbol $X*$ by a nonterminal $Y$, and add the production rules $Y ::= XY$ and $Y ::= \\epsilon$ to the set of context-free rules.\n\n4. Replace a symbol $X+$ by a nonterminal $Y$, and add the production rules $Y ::= XY$ and $Y ::= X$ to the set of context-free rules.\n\n5. Replace a symbol $X?$ by a nonterminal $Y$, and add the production rules $Y ::= X$ and $Y ::= \\epsilon$ to the set of context-free rules.\n\nWe demonstrate the above procedure by converting the production rule $S ::= (A* | B (C | D)) + E$ to its equivalent BNF. The steps are shown in Table 3.1. Each row in the table shows the production rules at a step of the conversion, the applicable rule, and the symbols being rewritten. The result of each conversion step is shown in its next row. Note that in steps two and three, two different actions are being performed at the same time.\n\nThe EBNF to BNF conversion produces intermediate nonterminals which will appear in the parse tree. The presence of these nodes in the parse tree leads to a derivation structure which does not directly correspond to the underlying grammar. Figure 3.1 shows the resulting SPPF from parsing the string \"aaacc\" using a parser for the following grammar:\n\n\\[\nS ::= A* B? C*\n\\]\n\\[\nA ::= a\n\\]\n\\[\nB ::= b\n\\]\n\\[\nC ::= c\n\\]\n\nIn Figure 3.1, nodes with the labels $A_*$, $B_?$, and $C_*$ correspond to the intermediary nodes of converting $A*$, $B?$, and $C*$, respectively. This naming convention has been chosen to have similar nonterminal names in EBNF and BNF.\n\nAfter the parsing is finished, one can traverse the SPPF and remove the intermediary EBNF nodes. Based on the lexical definition of Nonterminal in Listing 3.3, the specific EBNF symbols, such as \"*\", \"+\", \"?\", \")\", and \"]\", cannot appear in the name of a symbol node in the SPPF. Thus, any symbol\nTable 3.1: A step-by-step example of EBNF to BNF conversion\n\nThe SPPF without intermediary EBNF nodes is particularly suitable for list matching. Let us consider that we need to collect all the nodes labeled $A$ from the SPPF in Figure 3.2. We achieve this by a single Tom pattern as follows:\n\nnode whose label contains one of these characters is an intermediary EBNF node and should be removed. The removal is performed bottom-up and the children of the removed node will be connected to its parent. In addition, nodes having the label $\\epsilon$ will be removed after the removal of intermediary nodes. Note that EBNF intermediary nodes may be ambiguous, in which case the node should be disambiguated before removal, see Section 5.4. This removal process transforms the SPPF in Figure 3.1 into the SPPF in Figure 3.2.\nThe `getAs()` method in Listing 3.2 gets an SPPF node and returns its children labeled “A”. The body of the `match` construct is executed for each “A” node. Performing the same task for the SPPF in Figure 3.1, which contains the intermediary EBNF nodes, requires much more effort and is slower.\n### 3.3 A Concrete Syntax for MEBNF\n\nA syntax definition in MEBNF is comprised of four sections: the context-free section defining context-free rules, the lexical section defining lexical rules, the disambiguation section defining disambiguation rules, and the associativity and priority section defining the associativity and priorities of arithmetic operators.\n\n---\n\n```plaintext\nmodule MEBNF\n\nimport ContextFree\nimport Lexical\nimport Disambiguation\nimport AssociationAndPriority\n\nstart symbol Module\n\ncontext-free syntax\n\nModule ::= \"module\" ModuleName Import* StartSymbolSection? Section*\n\nImport ::= \"import\" ModuleName Retract*\n\nRetract ::= \"retract\" (ContextFreeRule | LexicalRule)*\n\nStartSymbolSection ::= \"start\" \"symbol\" Nonterminal\n\nSection ::= LexicalSection\n | ContextFreeSection\n | DisambiguationSection\n | AssociationAndPrioritySection\n | LayoutDefinitionSection\n\nlexical syntax\n\nModuleName ::= Id\nNonterminal ::= Id\nId ::= [a-zA-Z][a-zA-Z0-9\\-_]*\n\n---\n\nListing 3.2: The starting rules of MEBNF’s concrete syntax\n\nListing 3.2 shows the starting rules of MEBNF’s concrete syntax, which is written in MEBNF itself. A context-free grammar defined in MEBNF starts with a module definition followed by imports and sections. The retract keyword in a module definition is used to indicate the rules which should not be imported from the module. The retract mechanism is, however, not implemented in the current version of MEBNF. As can be seen, the MEBNF specification in Listing 3.2 imports four other modules: ContextFree, Lexical, Disambiguation, and AssociationAndPriority. In the rest of this\nsection, we describe the syntax for defining context-free rules, imported from the ContextFree module. The other imported modules are discussed in other chapters, where the functionality of the modules are described.\n\n---\n\n**module** ContextFree\n\n**context-free syntax**\n\nContextFreeSection ::= \"context-free\" \"syntax\" ContextFreeRule*\n\nContextFreeRule ::= Nonterminal \"::=\" Symbol* (\"|\" Symbol*)*\n\nSymbol ::= Symbol \"*\" | Symbol \"+\" | Symbol \"?\" | Keyword | Nonterminal | (\"(\" Alt \")\")\n\nAlt ::= Alt \"|\" Alt | Symbol+\n\n**lexical syntax**\n\nNonterminal ::= Id\nKeyword ::= String\nId ::= [a-zA-Z][a-zA-Z0-9-\\_]*\nString ::= [\"](\\^\\)[\\\"](\\^\\n\\)[\\\"]*[\\\"]\n\n---\n\nListing 3.3: A concrete syntax for defining context-free rules in MEBNF\n\nListing 3.3 presents the concrete syntax for defining context-free rules. As can be seen, a context-free rule consists of a head, denoted by `Nonterminal`, and a body which is a sequence of symbols. Alternates of a nonterminal can be separated by a \"|\", instead of repeating the nonterminal definition for each alternate. For example, `S ::= A B | C` defines the nonterminal `S` with two alternates. The first alternate consists of `A B` and the second one of `C`. Note that the \"|\" operator defines an alternation between the longest group of symbols surrounding it. In this example, if the user wants to express an alternation only between `B` and `C`, the alternate `Symbol ::= (\"(\" Alt \")\")` should be used, i.e., `S ::= A (B | C)`. To sum up, \"|\" inside a group definition, i.e., inside opening and closing parentheses, always denotes an alternation between the two surrounding sequence of symbols, whereas \"|\" outside a group always separates alternates for a nonterminal.\n\nThe grammar definition in Listing 3.3 is ambiguous. For example `(A | B | C)` can be interpreted as either `(A | B | C)` or `(A | (B | C))`. This ambiguity can be resolved by defining the \"|\" operator left associative, i.e., selecting `(A | B | C)` over `(A | (B | C))`. Disambiguation by assigning associativity to\noperators is explained in detail in Section 5.3.\n\n3.4 Lexical Syntax\n\nIn MEBNF every lexical definition is a regular expression which is defined as follows:\n\n- A character \"c\" is represented by itself.\n- \".\" is a special character matching all characters.\n- Special characters, which have a specific meaning in regular expressions, should be escaped using a backslash. These characters are \".\", \"[\", \"]\", \";\", \",\", and \"\\\".\n- In addition to special characters, whitespace characters should also be escaped. The supported whitespace characters are \\\", \\n\", \\r\", \\t\".\n- A character range is represented by c₁-c₂ where c₁ and c₂ are characters, and c₁ is before c₂ in the unicode character ordering. This is because the lexical definitions will be encoded into a Java Lexer implementation, and Java strings are represented in the unicode encoding. An example of a character range is 1-9 denoting the characters from 1 to 9.\n- A character class is defined as [r₁r₂...rₙ] where each rᵢ is either a character or a character range. A character class represents a choice between its enclosing elements, i.e., one of its elements should match. The character class is the smallest building block of in our lexical definition. All characters or character ranges should be expressed inside character classes.\n- [^r₁r₂...rₙ] defines the negation of a character class, meaning that none of rᵢs should match.\n- If α and β are regular expressions, αβ is a regular expression matching the concatenation of α and β.\n- If α and β are regular expressions, α|β is a regular expression matching either α or β.\n- If α is a regular expression, α* is a regular expression matching zero or more αs.\n- If α is a regular expression, α+ is a regular expression matching one or more αs.\n• If $\\alpha$ is a regular expression, $\\alpha?$ is a regular expression matching zero or one $\\alpha$.\n\n• If $\\alpha$ is a regular expression, $(\\alpha)$ is a regular expression denoting a group of regular expressions containing $\\alpha$.\n\nSome examples of regular expressions defined in the lexical syntax of MEBNF are:\n\n• $[a-zA-Z][a-zA-Z0-9\\-_]*$ matching a sequence of characters starting with a letter followed by any number of letters, numbers, hyphen or underscore. This lexical pattern corresponds to the definition of identifiers in programming languages such as Java.\n\n• $[\\ \\ \\r \\n \\t]+$ matching a sequence of whitespace characters.\n\n• $[1-9][0-9]+[.][0-9]+$ matching a floating point number such as 102.34.\n\n• $'[^\"'\\r\\n\\t]+[^\"'\\r\\n\\t]*'$ matching a string. A string should start and end with a double quote character. In between, all characters with the exception of \" and \\ may appear. The only characters which are allowed to be escaped are explicitly defined: ', t, r, n, and \\.\n\n• $[/\\][^\\r \\n]*$ matching a single line C-style comment. Based on this pattern, all the characters appearing after two \"\\\" are matched until a newline character is encountered.\n\nThe Gom signature corresponding to the regular expression definition is given in Listing 3.4. The constructor Any() corresponds to \".*\" matching any character. The constructor LexNonterminal is used to compose a lexical definition from other lexical definitions.\nLexicalRule = LexicalRule(head:Symbol, pattern:RegularExpression, exclusions:RegularExpressionList)\n\nRegularExpressionList = concRegularExpression(RegularExpression*)\n\nRegularExpression = CharClass(list:CharClassTypeList)\n| NotCharClass(notlist:CharClassTypeList)\n| LexAlt(lhs:RegularExpression, rhs:RegularExpression)\n| LexStar(re:RegularExpression)\n| LexPlus(re:RegularExpression)\n| LexOpt(re:RegularExpression)\n| LexGroup(re:RegularExpression)\n| LexNonterminal(name:String)\n| Keyword(text:String)\n| Concat(re1:RegularExpression, re2:RegularExpression)\n| Any()\n\nCharClassType = Char(c:char)\n| Escape(c:char)\n| CharRange(first:char, second:char)\n\nCharClassTypeList = concCharClassType(CharClassType*)\n\nListing 3.4: The abstract syntax of MEBNF’s lexical definition\n\ncontext-free syntax\n\nLexicalSection ::= \"lexical\" \"syntax\" LexicalRule*\n\nLexicalRule ::= Nonterminal \"::=\" RegularExpression LexicalExclusion?\n\nLexicalExclusion ::= \":/-\" \":/\" RegularExpression (\",\" RegularExpression)* \":/\"\n\nRegularExpression ::= RegularExpression RegularExpression\n| RegularExpression \"!\" RegularExpression\n| RegularExpression \"*\"\n| RegularExpression \"+\"\n| RegularExpression \"?\"\n| \"(\" RegularExpression \")\"\n| Nonterminal | Keyword | CharClass | \".\"\n\nCharClass ::= \"[\" Not? Character+ \"]\"\n\nCharacter ::= Char\n| EscapedChar\n| WordChar \".\" WordChar\n| Digit \".\" Digit\n\nListing 3.5: MBNF’s concrete syntax for lexical definitions\nListing 3.5 shows the concrete syntax of lexical definitions in MEBNF. As can be seen, the definition is straightforward and closely follows the definition of regular expressions provided before. The concrete syntax provides three more features than the standard regular expression definition given before. These features are keywords, lexical exclusions, and the composition of lexical definitions.\n\nThe basic regular expression definition needs separate character classes for each character. This makes the definition of lexical rules for keywords difficult. For example, one should write class ::= [c][l][a][s][s] to express a pattern matching the string \"class\". We provide a shorthand syntactic sugar for keyword definition. With this new syntax, the lexical rule is written as class = \"class\". In the abstract syntax of Listing 3.4, a keyword is identified by the constructor Keyword(text:String).\n\nThe lexical exclusion mechanism excludes certain patterns to be matched. The set of lexical exclusions is specified by the \"/-/-\" operator. For example, in the lexical definition Id ::= [a-zA-Z][a-zA-Z0-9\\-\\_]* -/- {\"class\", \"import\"}, the recognition of \"class\" and \"import\" as an identifier is disallowed. Lexical exclusions are described as regular expressions. When the lexer matches a pattern, if a match has been found, none of the exclusions should match the matched lexeme, otherwise the lexeme is discarded. The lexical exclusion can be used as a powerful disambiguation mechanism which is described in more detail in Section 5.\n\nA lexical definition in MEBNF can be composed of other lexical definitions. For example one may define the lexical definition for a floating number as follows:\n\nFloat ::= NonZeroDigit Digit\\* [\\.] Digit+ \nNonZeroDigit ::= [1-9] \nDigit ::= [0-9]\n\nThe parser generator rewrites the composing definitions before generating a lexer. For example, the final lexical definition for Float would be [1-9][0-9]*[\\.][0-9]+. In composing lexical definitions the head of a lexical definition cannot appear as the first symbol in the body of a lexical definition. For example, the definition Digit :::= Digit [\\.] Digit is illegal. Moreover, lexical definitions containing direct or indirect cycles are not allowed. Such definitions should be moved to a context-free section as regular expressions are not able to deal with such recursive constructs. It should also be mentioned that the provided concrete syntax for lexical rules is ambiguous. In Section 5.3, we show how to resolve the ambiguities by setting the operators' associativity and priority.\n3.5 Layout\n\nWe distinguish a special kind of lexical rules and dedicate a separate section, the layout section, to it. The term “Layout”, which is borrowed from SDF [21], describes whitespace and comments. In MEBNF, layout symbols are automatically added to the grammar. This frees the user of explicitly adding whitespace and comment nonterminals to context-free rules. An example of a layout definition is given in Listing 3.6. As can be seen, two layout elements are defined. The first definition, Comment, corresponds to a single-line C-comment comment, while the second definition corresponds to whitespace characters.\n\n```\nlayout syntax\n\nComment ::= [/\\[/\\]^\\n\\r\nWhitespace ::= [\\ \\n\\r\\t]+\n```\n\nListing 3.6: An example of a layout definition section\n\nOur parser generator inserts the nonterminal Layout, after each terminal and before the start symbol of a grammar, before generating a parser for the grammar. To add the Layout nonterminal before the start symbol, a nonterminal named Start is added to the grammar. The definition for the added Start nonterminal is as follows:\n\n```\nStart ::= Layout S\n```\n\nwhere $S$ is the actual start symbol of the grammar. The body of the Layout nonterminal is composed of the lexical heads defined in the layout section. For the example in Listing 3.6, the layout definition is as follows:\n\n```\nLayout ::= (Comment | WhiteSpace)*\n```\n\n3.6 Modularity\n\nModular grammars allow a separation of rules into several smaller modules. A module can then import the context-free and lexical-rules from other modules. Modularity in context-free grammars has many benefits. For example, it allows the separation of concerns in grammar definitions and facilitates reuse. However, the semantics of importing rules is not yet well understood. In addition, should imported grammars have different layout definitions, the resulting language might not be able to correctly recognize all sentences of the resulting language.\nThere are currently two approaches in importing context-free rules from another module. The first approach changes the name of the imported nonterminals to ensure unique names across modules, whereas the second approach imports the nonterminals without rewriting, effectively a textual import of rules. As an example, let us consider the following two grammars.\n\nAs can be seen, the module \\texttt{M1} imports the module \\texttt{M2}. The results of this importing, using both approaches, are shown below:\n\nIn the approach with rewriting, (a), an additional rule \\( E := M2.E \\) is added to provide a bridge for reaching the imported rules. In this scheme, there is no way to reach a nonterminal of the importing module from a nonterminal of an imported module. As a result, for example, one cannot derive the string \\( 1 + 2 * 3 + 4 \\) using the the grammar in (a) because the nonterminal \\( M2.E \\) cannot produce a \\( * \\). However, a derivation such as \\( 1 * 2 + 3 * 4 \\) is possible. In the approach without rewriting, (b), both derivations are possible. The approach without rewriting is more powerful as it can extend the grammar, but it may also lead to unexpected results, as alternates of all nonterminals with the same name will be merged. In some cases, two nonterminals with the same in two different modules do not necessarily should be merged.\n\nFor this thesis, we use the import mechanism which imports all the reachable nonterminals without changing the name of the imported nonterminals. In this scheme, if a nonterminal, appearing in the body of a production rule in the importing module, exists as the head of a production rules in an imported module, all rules reachable from the imported nonterminal are imported. Moreover, only the layout definition in the highest level importing module is considered as the layout for the whole composed grammar. In the future, we will provide a more sophisticated import mechanism, possibly using two different import commands, corresponding to the two import mechanism, to allow the user select how the rules for a nonterminal should be imported.\nChapter 4\n\nError Reporting in Generalized LL Parsers\n\nParser generators usually provide means for reporting syntax errors in generated parsers. However, error reporting in generated parsers is usually not satisfactory. Error messages in a generated parser are derived from the syntax of the language, and therefore cannot usually provide good hints on how the error should be fixed. Good error messages often rely on the semantics of a language, e.g., block and statement structures, and are manually added to a parser. In this section, we primarily focus on reporting the location of parsing errors from generated GLL parsers, without trying to provide hints how the error should be fixed. Providing a mechanism to allow the user to customize error messages, based on the semantics of a language, is outside the scope of this thesis.\n\nDetecting the exact location where a parse error is occurred is virtually impossible, even in deterministic parsers. Anyone who has worked with the \\LaTeX typesetting system has experienced that the reported location of an error is usually not where the error is actually occurred, rather the reported location is where the input could no longer be matched. Deterministic parsers have the viable-prefix property [14], meaning that as soon as a prefix of the input has been read which cannot be completed to form a sentence of the language, an error has occurred. In deterministic parsers, the location where the parser cannot match further is reported to the user. As a hint on how to fix an error, the expected token(s) at the error location, derived from the first and follow sets, is also reported to the user.\n\nError reporting in generated generalized parsers is even more challenging. In deterministic parsers, only one correct derivation can possibly exist. Therefore, if at one point, the parsing cannot proceed, an error is reported to the user. In contrast, in generalized parsers, many paths are explored in\nparallel, and failure in matching the input in one path does not necessarily imply an error.\n\nIn GLL parsing, for selecting the location where the matching of input fails, we use a heuristic similar to the visible-prefix. We record the locations where the input could no longer be matched, and when the parsing fails, the location with the longest input prefix is reported as the error location.\n\nWe record a possible error location in the execution of a GLL parser if one of the following scenarios happen:\n\n- The grammar pointer is immediately before a terminal we attempt to match it to the current input symbol, but no match can be found, i.e., the set of tokens returned from the lexer is empty.\n- The grammar pointer is immediately before a nonterminal, but the current input symbol does not belong to the test set of the nonterminal.\n- The grammar pointer is at the start symbol, but the current input symbol does not belong to the test set of the start symbol’s alternates, thus no alternate can be selected.\n\nIn each of these scenarios no descriptor is added to the descriptors set. If before executing a parsing step in which one of these scenarios happen, the descriptor set is already empty, then this location is a definitive error location. However, if there are descriptors in the descriptors set, not adding a descriptor at this step does not necessarily indicate an error, as the current descriptors may lead to a successful parsing of the input. Nonetheless, we add an error message in all cases, regardless of the state of the descriptors set. This is to ensure we capture the error location with the longest input prefix.\n\nWhen one of these scenarios happen, a new error object containing the current input location and the grammar pointer is created. If no error object already exits, meaning that no error has occurred before, the newly created error object is recorded as the current error object. If an error object already exists, its location is checked against the location where the new error has occurred. If the new location is farther than or equal to the location of the current error object, the current error object is replaced by the new one. Otherwise, if the new error occurs in a location before the location of the current error object, the new error object is discarded. Based on this procedure, at each point during the parsing, at most one error object exists. If the parsing of an input fails, the location and grammar pointer of the current error object will be reported to the user.\n\nWith this error reporting method, we always get the location of a parse error when the parsing fails. However, the location may not be the best location\nfor diagnosing the error. The benefit of this error reporting technique is that it is fairly straightforward to implement. Based on our experience, this approach produces fairly accurate results for the MEBNF grammar introduced in Section 3.3. In the future, we should investigate the use of more advanced heuristics for improving the error reporting.\nChapter 5\n\nDisambiguation by Rewriting within the Parse Forest\n\nA context-free grammar is ambiguous if it produces a sentence in more than one way, leading to more than one left-most (or right-most) derivation. As different derivations may have different meanings, at some point in language processing, ambiguities should be resolved. The process of selecting a derivation from a set of ambiguous derivations is called disambiguation.\n\nAmbiguity detection in context-free grammars is undecidable [22]. However, for specific kinds of ambiguities, there are known disambiguation solutions. For example, for some grammars, one can eliminate the ambiguity by rewriting a grammar to an equivalent grammar, producing the same language. A classic example of disambiguation by rewriting the grammar is the grammar of arithmetic expressions. A grammar for arithmetic addition is shown in Figure 5.1.\n\n\\[\n\\begin{align*}\nE & ::= E + E \\\\\nE & ::= \\text{Digit} \\\\\nE & ::= E + T \\\\\nT & ::= T F \\\\\nF & ::= \\text{Digit}\n\\end{align*}\n\\]\n\nFigure 5.1: A grammar for arithmetic addition\n\nAs can be seen in Figure 5.1, the original grammar on the left side can be transformed to the grammar on the right side by applying the left-recursion elimination and left factorization. More information on these transformations can be found in [14]. The transformed grammar is not ambiguous, but it is difficult to read. More importantly, its parse trees are not as natural as those of the original grammar.\nNevertheless, disambiguation by rewriting a grammar is not applicable to all cases, as for some grammars no unambiguous, equivalent grammar exists [22]. A grammar for which no equivalent unambiguous grammar exists is called an inherently ambiguous grammar. Even for grammars which are not inherently ambiguous, disambiguation by rewriting grammar rules is not straightforward as there is no standard algorithm for that.\n\nDisambiguation can also be achieved by modifying a parser to disallow the creation of undesired derivations in the first place. This method of disambiguation is popular in deterministic parser generators. Deterministic parsers require that there be at most one chance of action at each step. Therefore, if at a step, multiple actions are possible, the parser should be able to select one of the actions. The selection is usually based on some heuristics embedded in the parser. For example, in Yacc [23], the rules for associativity and priority of operators can be embedded within the generated parsers, so that the parser can resolve shift/reduce conflicts resulting from operator ambiguities. In addition to the heuristics, more lookahead symbols may also be employed to help the parser eliminate choices.\n\nModifying a parser to cope with ambiguities is usually complex, and the modifications are not reusable for other ambiguity types. More importantly, only resolving some well-known ambiguities, such as operator associativities and priorities, is supported by conventional parser generators. For resolving other complex ambiguities, often a parser should be hand-crafted, which involves significant hacking. This approach is not accepted in a languages workbench whose main purpose is to provide an environment for language prototyping and experimentations. For this, the user should be provided with a disambiguation mechanism which is generic and easy to apply.\n\nGeneralized parsers produce a parse forest containing all the ambiguities occurred during the parsing. Packing all the ambiguities in a data structure, a parse forest provides the user with the opportunity to traverse the produced parse forest and select the desired derivation. An example of disambiguation by filtering unwanted derivations in the parse forest is implemented in SDF [21], which is based on Scannerless GLR [38]. SDF provides the prefer and avoid [35] mechanisms to mark nodes in the parse forest which should be kept or removed. These mechanisms, however, do not work in all cases and may result in unpredictable results [28, 34, 36].\n\nIn this chapter we describe our disambiguation method which is based on rewriting within the parse forest. In contrast to SDF, which provides mechanisms for filtering the parse forest based on top-level production rules, we provide concrete syntax for describing complete tree structures. Many ambiguities are not resolvable by merely examining the top-level production rule under ambiguity nodes. The main motivation for our disambiguation mechanism is building a generic, powerful disambiguation mechanism which\nis able to cope with complex ambiguities.\n\nThe rest of this chapter is organized as follows. First, we introduce pattern matching and rewriting within GLL’s parse forest in Section 5.1. Then, in Section 5.2, we provide concrete syntax, a wrapper for Tom, in order to make the writing of patterns easier and more intuitive. Section 5.3 provides a Yacc-like notation for assigning associativities and priorities to operators. Section 5.4 is dedicated to the Tom implementation of the disambiguation mechanism. Finally, in Section 5.5, we evaluate our disambiguation mechanism as a term rewriting system.\n\n5.1 Rewriting within the SPPF\n\nAs discussed in Section 2.2, an SPPF provides efficient means for representing ambiguities by sharing common subtrees. An ambiguity node in an SPPF is a symbol or an intermediate node having more than one packed node as children. For example, consider a simple grammar for arithmetic addition defined in Listing 5.1.\n\n<table>\n<thead>\n<tr>\n<th>context-free syntax</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>E ::= E "+" E</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>lexical syntax</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Digit ::= [1-9]+</td>\n</tr>\n</tbody>\n</table>\n\nListing 5.1: A simple grammar for arithmetic addition\n\nFor this grammar, the input string “1+2+3” is ambiguous. The corresponding SPPF resulting from parsing this input is presented in Figure 5.2. For the SPPF visualization in this chapter, packed nodes are represented by small circles, intermediate nodes by rectangles, and symbol nodes by rounded rectangles in which the name of the symbol node is written. Moreover, for a more compact visualization, the nodes associated with the recognition of layout are removed from the graphs in this section. The SPPF of Figure 5.2 contains an ambiguity which occurs below the first symbol node labeled E.\n\nWhile an SPPF is built, intermediate nodes are added for binarization, which is essential for controlling the complexity of GLL parsing algorithm. Furthermore, the version of the GLL algorithm we are using creates packed nodes even when there are no ambiguities. These additional nodes lead to a derivation structure which does not directly correspond to the expected abstract syntax of the grammar from which the SPPF has been created.\n\nAfter the successful construction of an SPPF, one can traverse the SPPF and remove all packed nodes which are not part of an ambiguity, i.e., the\nFigure 5.2: The complete SPPF resulting from parsing “1+2+3”.\n\npacked nodes which are the only child. The intermediate nodes which only have one child, the ones which do not present an ambiguity, can also be removed. When a node is removed, its children are attached to the parent of the node. Care should be taken that the order of children in the parent remains intact. By removing unnecessary packed and intermediate nodes, the SPPF presented in Figure 5.2 can be reduced to the SPPF in Figure 5.3.\n\nThe removal of unnecessary intermediate and packed nodes is not applicable to SPPFs containing cycles. An SPPF contains a cycle only if its underlying grammar contains a cycle. Cycles do not affect the language produced by a grammar and can be removed from the grammar. However, the automatic removal of cycles may significantly alter the grammar, and is not supported\nin MEBNF. Moreover, the EBNF to BNF conversion may also introduce cycles, for example, if there is a nonterminal $X$ producing epsilon, i.e., $X ::= \\epsilon$, and $X*$ exists in the grammar. In the future, we shall notify the user of the presence of cycles in a grammar and assist her in removing cycles from the grammar.\n\nFigure 5.3: The SPPF resulting from parsing \"1+2+3\" without unambiguous intermediate and packed nodes.\n\nFor disambiguating an SPPF, we use the pattern matching and rewriting facilities of Tom. Listing 5.2 defines an algebraic data type for SPPF using Gom. The algebraic type defines a sort `SPPFNode` with three constructors, corresponding to three node types present in an SPPF, and the sort `NodeList` defining a list of nodes. The `SymbolNode` constructor creates a symbol node with its name and list of the children. The attribute `name` is the name of a terminal or nonterminal in the grammar. `PackedNode` and `IntermediateNode` constructors create a packed or intermediate node by their list of children. `concNode` constructs a list of `SPPFNode` terms. The name `concNode` is selected in compliance with Gom's naming conventions, and it represents the concatenation of nodes as a list.\n\n```\nSPPFNode = SymbolNode(name:String, children:NodeList)\n| PackedNode(children:NodeList)\n| IntermediateNode(children:NodeList)\n```\n\n```\nNodeList = concNode(SPPFNode*)\n```\n\nListing 5.2: An algebraic type definition for the SPPF\n\nThe ambiguity shown in Figure 5.3 can be resolved by preferring the left-associative derivation, i.e., the input \"1+2+3\" should be interpreted as $(1+2)+3$ and not as $1+(2+3)$.\nListing 5.3 shows a Tom rewrite rule resolving the ambiguity in Figure 5.3. As can be seen, the packed nodes under the symbol node labeled $E$ are examined, and if there is a right-associative derivation, it will be removed. The reason that we do not directly write a pattern to select the desired derivation is that we do not know about other packed nodes under an ambiguity node. Rewriting a symbol node by selecting a packed node matching the desired pattern may remove other packed nodes which should not be removed. To have a generic disambiguation mechanism, we search for a packed node matching the opposite pattern, e.g., right-associativity, which we call the illegal pattern. The illegal patterns are not desired, regardless of where they appear, and should be removed. In Listing 5.3, $z1^*$ and $z2^*$ match other packed nodes which should be kept, while the packed node matching the illegal pattern is rewritten to nothing, and hence removed.\n\nFor the arithmetic addition example, in Listing 5.1, inputs having more than three digits have another derivation. For example, $1+2+3+4$ can also be interpreted as $((1+2)+(3+4))$. This derivation, however, is automatically eliminated, as it matches both the left and right associative patterns, considering that $(1+2)$ and $(3+4)$ can be seen as single $E$.\n\nFigure 5.4: The SPPF resulting from parsing $1+2*3$\nWe extend the grammar of arithmetic expressions in Listing 5.1 by adding the rule \\( E ::= E \\ast E \\). The resulting grammar is ambiguous, for example, for the input \\( 1+2\\ast3 \\), whose SPPF is shown in Figure 5.4. To resolve this ambiguity, one can assign a higher priority to the \\( \\ast \\) operator, preferring the derivation \\( 1+(2\\ast3) \\) to \\((1+2)\\ast3\\). This means that a \\( \\ast \\) should appear in a deeper subtree in relation to a \\( + \\). The rewrite rule disambiguating this example is shown in Listing 5.4. Note that for defining the precedence relation between the \\( + \\) and \\( \\ast \\) operators, one should consider all orderings of the operators. Listing 5.4 shows the two different possible orderings. The first pattern describes a priority relation in which the \\( + \\) operator appears first, whereas in the second pattern, the \\( \\ast \\) operator appears first.\n\nListing 5.4: A rewrite rule in Tom giving \\( \\ast \\) a higher priority over \\( + \\)\n\nSo far, in the presented examples, we assumed that no layout definition is present in the grammar. Should a grammar have layout definitions, one should incorporate them in rewrite rules. This can be simply achieved by putting a \\( _- \\) after each terminal symbols in the patterns. \\( _- \\) will match the layout symbol after terminal symbols, see Section 3.5 for more information. Considering the layout definition, the rewrite rule of Listing 5.3 is written as in Listing 5.5.\nThe rewrite rules presented so far can only remove one packed node matching an illegal pattern. As described before, an ambiguous node has more than one packed node. Each rewrite rule matching a packed node reduces the number of packed nodes by one. To fully disambiguate an ambiguity node, a rewrite rule should be applied as long as it can be matched. The disambiguation is successful if only one packed node remains. Then, the children of the remaining packed node replace the packed node. This replacement resolves the ambiguity.\n\nIf a rewrite rule cannot disambiguate a node, other available rules should be applied. The disambiguation process fails if after applying all the available rewrite rules, still more than one packed nodes is present under an ambiguity node. The disambiguation process should be applied bottom up to disambiguate the whole SPPF. In many cases, resolving an ambiguity in a higher level in an SPPF depends on first resolving the ambiguities in deeper levels of the SPPF, i.e., subtrees of an ambiguous node in a higher level are ambiguous themselves. By performing the disambiguation bottom up, it is ensured that the subtrees of an ambiguous nodes are not ambiguous, thus can uniquely be specified by a tree pattern.\n\nThe successful disambiguation of an SPPF transforms it to a tree only consisting of symbol nodes. Packed and intermediate nodes which are not part of an ambiguity node are removed before applying a rewrite rule, as discussed at the beginning of this chapter. Ambiguous intermediate nodes, having more than one packed node, are removed when they are disambiguated, as part of disambiguating higher level ambiguity nodes. Packed nodes which are part of an ambiguity node are removed one by one by disambiguation rules. The remaining packed node under an ambiguity node is replaced by its children as the last step of disambiguating a node. After all the ambiguities are resolved, no intermediate or packed node can exist under disambiguated nodes. To give the SPPF a unified shape, we traverse the SPPF, now a tree, from the root and remove the rest of packed and intermediate nodes.\n\nThe procedure for removing unnecessary packed and intermediate nodes, regardless of where they appear, is as follows:\n\n```\nSymbolNode(\"E\", concNode(z1*,\nPackedNode(concNode(SymbolNode[name=\"E\"],\n SymbolNode[name=\"+\"], _,\n SymbolNode(\"E\", concNode(SymbolNode[name=\"E\"],\n SymbolNode[name=\"+\"], _,\n SymbolNode[name=\"E\"]))))\n ), z2*)) -> { SymbolNode(\"E\", concNode(z1*, z2*)); }\n```\n\nListing 5.5: The rewrite rule for preferring the left-associativity by taking the layout definition into account.\n1. Remove the packed node under a non-ambiguous symbol node. The children of the packed node are attached to the symbol node.\n\n2. Remove the packed node under a non-ambiguous intermediate node. The children of the packed node are attached to the intermediate node.\n\n3. Remove intermediate nodes which are not ambiguous. The children of an intermediate node are attached to its parent (a packed node).\n\n5.2 Concrete Syntax for Disambiguation Rules\n\nExpressing disambiguation rules using the algebraic terms is tedious for the user because there are many technical aspects the user should be aware of. For example, the user should explicitly create a list of symbol nodes using the concNode constructor. To overcome these obstacles, we present a higher level syntax for writing disambiguation rules. In the syntax, the user only focuses on the name of symbol nodes in an SPPF, rather than their full algebraic representation.\n\nIn principle, the user can write a disambiguation rule removing more than one packed node at once. We, however, do not allow such a rewrite rule in the simplified syntax. In the syntax, the user can either specify that a single packed node matching an illegal pattern should be rewritten to nothing, i.e., to be removed, or a packed node should be preferred over another sibling packed node. We call the former type of rule a remove rule and the latter type a prefer rule.\n\nThe user can always write a remove or prefer rule for an ambiguity node. In an SPPF, ambiguity nodes always contain more than two packed nodes, otherwise there would have not been an ambiguity in the first place. Furthermore, subtrees under the sibling packed nodes are different, otherwise there would have not been different packed nodes. Given these two facts, there are always two packed nodes with different subtrees available under an ambiguity node, and the user can write a remove rule, describing which one is illegal, or a prefer rule, describing which one is preferred.\n\nConsidering this, the simplified syntax is as follows:\n\n- An ambiguous symbol node is specified as $[p_1]$ or $[p_1], [p_2]$, where $p_1$ and $p_2$ are packed nodes. The former case corresponds to a remove rule, whereas the latter case describes prefer rule. For prefer rules, the order in which $p_1$ and $p_2$ appear, or how many other packed nodes are before, after, or in between does not matter.\n\n- $\\text{PackedNode(concNode(t_1, t_2, ..., t_n))}$, a packed node whose children are $t_1, t_2, ..., t_n$ is written as $[t_1, t_2, ..., t_n]$, where each $t_i$ describes a symbol node. In-\nside a packed node, the order of children should be explicitly stated. Moreover, the user does not need to specify the layout nodes, as they are automatically matched.\n\n- SymbolNode(\"E\", _) or SymbolNode[name=\"E\"], a symbol node whose children are not important, is represented by \\( E \\), its name.\n\n- SymbolNode(\"E\", concNode(t_1, t_2, ..., t_n)) where \\( t_1, t_2, ..., t_n \\) are the subterms of the SymbolNode, is written as \\( E(t_1, t_2, ..., t_n) \\). In other words, the name of a symbol node becomes the root of the tree.\n\n- _ matches any symbol node while _* matches any sequence of symbol nodes.\n\nIn this syntax, no packed node can appear below another packed node. The reason is that the deepest ambiguity node has packed nodes as only its direct children, while the rest of the nodes in its subtrees are symbol nodes. Subtrees under the deepest ambiguous node are either not ambiguous, or have been previously disambiguated, as the disambiguation process is performed bottom up.\n\n---\n\n**context-free syntax**\n\n```\nDisambiguationSection ::= \"disambiguation\" \"rules\" Rules*\n\nRule ::= \"remove\" PackedNode\n | \"prefer\" PackedNode \",\" PackedNode\n\nPackedNode ::= \"[\" (SymbolNode | Any) (\"*,\" (SymbolNode | Any))]* \"]\"\n\nSymbolNode ::= SymbolName\n | SymbolName \"(\" (SymbolNode | Any) (\"*,\" (SymbolNode | Any)))* \")\"\n```\n\n**lexical syntax**\n\n```\nAny ::= [_][*]?\nName ::= String\n```\n\nListing 5.6: The MEBNF specification for disambiguation rewrite rules\n\nListing 5.6 illustrates the MEBNF grammar that defines the disambiguation rewrite rules. As can be seen, a disambiguation rule can be either a remove or prefer rule. A remove rule describes a packed node which should be removed, rewritten to nothing, while a prefer rule prefers the first packed node to the second one, i.e., if both packed nodes are found, the one which is not preferred is eliminated. With the simplified notation, the rewrite rule in Listing 5.5 can be written as:\n\n```\nremove [E, \"+\", E(E, \"+\", E)]\n```\n5.3 Binary and Unary Operators\n\nAs we have seen in the above examples, some natural grammars for binary any unary operator expressions are ambiguous. For disambiguation, the user can directly write disambiguation rules, as shown in Section 5.1. However, due to the large number of associativity and priority combinations between operators, it is tedious for the user to manually write all the combinations. In addition, as the need for disambiguating binary and unary operators often occurs in practice, a Yacc-like notation for defining the associativity and priority between operators can be helpful. In this section, we provide a concrete syntax for describing the associativity and priority between the operators, and explain how each combination is translated into the disambiguation rules.\n\n5.3.1 Concrete Syntax for Operator Associativities and Priorities\n\nListing 5.7: Concrete syntax for the associativity and priority of operators\n\n```plaintext\ncontext-free syntax\nPriorityGroup ::= \"{\" (AssociativityGroup (\">\" AssociativityGroup))? \"}\"\nAssociativityGroup ::= (Modifier \":\")?\n OperatorRule (\",\" OperatorRule)*\nOperatorRule ::= BinaryOperatorRule\n | LeftUnaryOperatorRule\n | RightUnaryOperatorRule\nBinaryOperatorRule ::= Head \"::=\" Operand Operator? Operand\nLeftUnaryOperatorRule ::= Head \"::=\" Operator Operand\nRightUnaryOperatorRule ::= Head \"::=\" Operand Operator\nOperator ::= String | Id\nModifier ::= \"left\" | \"right\"\n\nlexical syntax\nHead ::= Id\nOperand ::= Id\nModifier ::= \"left\" | \"right\"\n```\n\nListing 5.7 provides a concrete syntax for describing the associativity and priority of operators. As can be seen, a PriorityGroup defines a set of priority rules for a nonterminal head. Each priority group is composed of a number of associativity groups. An associativity group defines the associativity for each rule and between the rules it contains. For example, to give the \"*\" operator a higher priority than the \"+\" operator in the grammar of arithmetic expressions, we write:\nThe example above defines a priority group containing two associativity groups. The priority is determined by the greater-than sign, separating associativity groups. The type of associativity is identified by Modifier. In case the modifier is not specified, no associativity is applied to the associativity group. In the example above, both associativity groups are left-associative.\n\nThe classic notion of associativity is defined for only one binary operator. We, however, generalize this notion to more than one operator, to be able to disambiguate expressions containing operators of the same priority. For example, the user can write \\( \\text{left: } E ::= E \\ +\\ E, E ::= E \\ \\ast\\ E \\) to express that \\( + \\) and \\( \\ast \\) are left-associative in respect to each other. Under the hood, for each pair of left-associative binary operators, four Tom rules are generated. One for each operator and one for each ordering of the operators. Note that if the user wants to give an operator a different associativity than the one given for a associativity group the operator belongs to, the operator should be moved to a separate associativity group.\n\nWe provide two more examples for illustrating the usage of the associativity and priority syntax. The first example, which is a grammar for arithmetic expressions, is shown in Listing 5.8.\n\n```plaintext\ncontext-free syntax\n\nE ::= E \\ +\\ E\n | E \\ -\\ E\n | E \\ \\ast\\ E\n | E \\ /\\ E\n | \\ -\\ E\n | E \\ ^\\ E\n | Digit\n```\n\nListing 5.8: A grammar for arithmetic expressions\n\nThe associativity and priority of operators in Listing 5.8 is shown in Listing 5.9.\nListing 5.9 defines four associativity groups. The first group gives the power operator right associativity. This production rule has the highest priority as well. The second group has a rule defining the unary negation operator. This rule cannot be left or right associative, thus no modifier is given. The purpose of defining the negation rule in a separate group, without providing an associativity modifier, is only to give it a different priority. The third group defines the priorities of the multiplication and division operators, both left associative themselves and in respect to each other. The same holds for the fourth group, which has the lowest priority. Using the associativities and priorities defined in Listing 5.9, the expression \\(1-2^3^4^5^3\\) is interpreted as \\(1-((-2)*(3^(-4^5))*3)\\), whose parse tree is shown in Figure 5.5.\n\nThe second example of using associativity and priority rules is resolving the ambiguities in MEBNF’s lexical syntax defined in Listing 3.5. The ambiguity is caused by the alternates of \\(RegularExpression\\). The associativity and priority of the operators involved in the ambiguity is specified Listing 5.10.\n\nAs shown in Listing 5.10, the operators \"*\", \"+\", and \"?\" should have a higher priority than \"|\" or the concatenation operator in \\(RegularExpression\\) ::= \\(RegularExpression RegularExpression\\). The priority relationship implies\nthat the expression \\(XY^*\\), for example, should be interpreted as \\(X(Y^*)\\) and not \\((XY)^*\\). The same holds for the \"+\" and \"?\" operators. In addition, the concatenation operator is defined as left-associative, so that the the regular expression \\(XYZ\\) is interpreted as \\((XY)Z\\) and not as \\(X(YZ)\\). The same holds for the \"|\" operator. Finally, \"|\" has a lower priority than the concatenation operator. As a result, the regular expression \\(X \\ Y \\ | \\ Z\\) should be interpreted as \\((XY) \\ | \\ Z\\) and not as \\(X(Y \\ | \\ Z)\\).\n\n### 5.3.2 Translation to Disambiguation Rules\n\nIn this section we give a formal description of the translation of associativity and priority rules to disambiguation rules, which are eventually translated to Tom rules. A production rule describing a binary, left-unary, and right-unary rule is of the form \\(A ::= A \\ x \\ A\\), \\(A ::= x \\ A\\), and \\(A ::= A \\ x\\), respectively, where \\(A\\) is a nonterminal, and \\(x\\) is either a terminal, nonterminal. For binary rules, \\(x\\) can be \\(\\epsilon\\), defining a concatenation operator. The supported operators and their translation to disambiguation rules are as follows:\n\n- **left**: \\(A ::= A \\ x \\ A\\), the left associativity of a binary operator is translated to: remove \\([A, x, A\\{A, x, A\\}]\\).\n• **left:** $A ::= A \\times A, A ::= A \\circ A$, the left associativity of two binary operators is translated to: remove $[A, x, A(A, y, A)]$ and remove $[A, y, A(A, x, A)]$. Note that both operators are left-associative themselves, i.e., the previous rule applies to both operators.\n\n• **right:** $A ::= A \\times A$, the right associativity of a binary operator is translated to remove $[A(A, x, A), x, A]$.\n\n• **right:** $A ::= A \\times A, A ::= A \\circ A$, the right associativity of two binary operators is translated to: remove $[A(A, x, A), y, A]$ and remove $[A(A, y, A), x, A]$. Note that both operators right-associative themselves, i.e., the previous rule applies to both operators.\n\n• $A ::= A \\times A > A ::= A \\circ A$, the priority between two binary operators, where $x$ has a higher priority than $y$ is translated to: remove $[A, x, A(A, y, A)]$ and remove $[A(A, y, A), x, A]$.\n\n• $A ::= x A > A ::= A \\circ A$, the priority between a left-unary operator and a binary operator, where the left-unary operator has a higher priority, is translated to: remove $[x, A(A, y, A)]$.\n\n• $A ::= A \\circ A > A ::= x A$, the priority between a binary operator and a left-unary operator, where the binary operator has a higher priority, is translated to: remove $[A(x, A), y, A]$.\n\n• $A ::= A \\circ A > A ::= A \\times A$, the priority between a right-unary operator and a binary operator, where the right-unary operator has a higher priority, is translated to: remove $[A(A, y, A), x]$.\n\n• $A ::= A \\times A > A ::= A \\circ A$, the priority between a binary operator and a right-unary operator, where the binary operator has a higher priority, is translated to: remove $[A, y, A(A, x)]$.\n\n### 5.4 Implementation\n\nIn Section 5.1 we described our disambiguation mechanism without exploring the implementation details. Our Java implementation of GLL is not aware of Tom and creates SPPF nodes as pure Java objects. Creating SPPF nodes as Tom terms is difficult, if not impossible. Tom terms are immutable, meaning that after the construction, they can no longer change. A change in a term, in fact, returns a new term. In SPPF construction, however, children are often added to a node without any specific order, which updates the parent node. In addition, there are always many references to SPPF nodes, from GSS for example. Implementing SPPF nodes as immutable objects implies that each time a new child is added to an SPPF node, all references should be updated, and in fact, a complete new SPPF should be created.\nAlthough Tom uses maximum sharing and has a memory efficient strategy for creating a new term from an existing term, updating all the references is neither efficient nor easy.\n\nNevertheless, for pattern matching using Tom, we need to provide a bridge between SPPF nodes as Java objects and the Gom type defined in Listing 5.2. As a first approach we consider the conversion of an SPPF to a Tom term after the SPPF construction has finished. The conversion is straightforward, and as Tom provides maximum sharing of subterms, the storage of a converted Tom term is memory efficient. The problem is the traversal and rewriting strategies, as Tom terms are trees, and not graphs. When a subterm is being rewritten, the subterm is only rewritten in the current traversing path. If the subterm is shared by other nodes in another path, the other node still has a pointer to the original subterm.\n\nAs an Example, consider the SPPF in Figure 5.6 (a), in which both nodes B and C share the node D. From Tom’s point of view, the SPPF is seen as in Figure 5.6 (b). Let us now consider the rewrite rule $D \\rightarrow E$. Applying the rule to the node D under B results in the SPPF in Figure 5.6 (c). As can be seen, the rewriting has only taken place in the current path, and other node, node C, maintains its original subterm. Rewriting a node in all paths is not feasible as the number paths in SPPFs containing many ambiguity nodes is exponential.\n\n\n\nThe first approach, converting an SPPF after parsing is finished, is only suitable for small SPPFs or SPPFs containing few ambiguities. This makes it virtually unusable in real-world settings. A second approach is to keep the SPPF as Java objects and use a Tom mapping to view the Java structure as a Tom term. The price paid here is performance, as Java’s List type\nis not as efficient as Gom’s generated List type in pattern matching and rewrting. The difference in performance was, however, not noticeable in the whole disambiguation process. The Tom mapping for SPPF is given in Appendix B.\n\nUsing a mapping for SPPF, one cannot simply rewrite a term as before, and should manipulate the matched node manually. This is to avoid creating immutable objects. For example, the rewrite rule in Listing 5.3 is changed to the rule in Listing 5.11. As can be seen, instead of creating a new term, the $\\text{setChildren}$ method of the matched node, identified by $\\text{node}@$, is called in the body of the rule. The last point about the Tom mapping is that Tom strategies do not just simply work with mapping. To be able to use strategies with mapping, an specific $\\text{Introspector}$ should be used. An introspector is a Java object providing Tom strategies with the access to children of a term through a standard interface. The introspector for SPPF is provided in Appendix C.\n\n\\begin{verbatim}\nnode@SymbolNode(\"E\", concNode(z1*),\nPackedNode(concNode(SymbolNode[name=\"E\"],\n SymbolNode[name=\"+\"],\n SymbolNode(\"E\", concNode(SymbolNode[name=\"E\"],\n SymbolNode[name=\"+\"])),\n SymbolNode[name=\"E\"])))\n )} , z2*) -> { `node.setChildren(`concNode(z1*, z2*)); }\n\\end{verbatim}\n\nListing 5.11: A rewrite rule in Tom for preferring the left-associative derivation\n\nThe disambiguation rules and patterns presented so far assume that unnecessary packed and intermediate nodes are removed from an SPPF. Moreover, it is assumed that the EBNF to BNF conversion has been performed before the pattern matching. Performing these transformations, both removing unnecessary nodes and EBNF to BNF conversion, on an SPPF containing ambiguities may not be efficient. Due to many shared subtrees under ambiguous nodes, transforming an ambiguous SPPF may lead to the exponential worst case complexity. To overcome this, the removal of unnecessary and intermediary EBNF nodes is performed only under the direct subtrees of the deepest ambiguity node prior to pattern matching. By performing the disambiguation bottom up, we ensure that the transformations are applied only on trees, without sharing, in linear time. To sum up, the disambiguation process is as follows:\n\n1. Find the deepest ambiguity node. An ambiguity node is a symbol or intermediate node having more than one packed node as children.\n2. Remove unnecessary packed and intermediate nodes under the am-\nbiguous packed nodes. Unnecessary packed nodes are the packed nodes which do no represent an ambiguity, i.e., are the only child. Unnecessary intermediate nodes are the intermediate nodes which are not ambiguous, i.e., have only one packed node as child.\n\n3. Perform the EBNF to BNF conversion on the subtree under the ambiguous node. Note that no ambiguous intermediary EBNF node may appear here as the deepest ambiguity node is currently being processed.\n\n4. Mark the transformed nodes so that these nodes are not checked for transformation while resolving ambiguities in higher levels of the SPPF.\n\n5. Select a rewrite rule and apply it as long as it can match a packed node. If a rewrite rule cannot be applied anymore, go to the next rewrite rule. After applying all the available rewrite rules only one packed node should be remained, otherwise the disambiguation process fails.\n\n6. If the disambiguation process is successful, replace the remained packed node with its children. The disambiguation process continues bottom up in an attempt to disambiguate the whole SPPF.\n\n5.5 Disambiguation as a Term Rewriting System\n\nIn this section, we introduce the notion of a term rewriting system (TRS) in an informal way, and then examine our disambiguation mechanism as a TRS. A detailed, formal account can be found in [19].\n\nA term rewriting system is a set of terms and their subterms, $T$, and a set of rewrite rules applying on the terms (and their subterms). Terms are usually defined using a signature, e.g., by a formalism such as Gom. A rewrite rule is a function from $T$ to $T$ and is written as $t_i \\rightarrow t_j$, stating that the term $t_i$ can be rewritten to $t_j$. A TRS is terminating if the rewriting of terms (and their subterms) using the set of rules can not infinitely continue, i.e., at one point no rewrite rule can be applied on a term anymore. A term which can no loner be rewritten is called a normal form. A TRS is confluent, if after applying the rules in any arbitrarily order, the same normal form is produced. More formally, if $t$ is a term, and $t \\Rightarrow u$ and $t \\Rightarrow w$, where $\\Rightarrow$ denotes rewriting in zero or more steps, and $u$ and $w$ are in normal forms, then the TRS is confluent if and only if $u = w$.\n\nOur disambiguation mechanism can be considered as a TRS, where each SPPF is a term, and disambiguation rules are its rewrite rules. As discussed before, there are two types of rules: remove rules, written as $\\text{remove}(P)$,\nrewriting a packed node matching the pattern \\( P \\) to nothing, and prefer rules, \\( \\text{prefer}(P_i, P_j) \\), preferring the packed node matching \\( P_i \\) over the packed node matching \\( P_j \\).\n\nThe TRS corresponding to the disambiguation of an SPPF is terminating. In a fully built SPPF, there are at most \\( n^2 \\) symbol and intermediate nodes, each having at most \\( n \\) packed nodes [31]. Considering the worst case, in which all symbol and intermediate nodes except for the leaves are ambiguous, there are at most \\( n^2 - n \\) ambiguity nodes. The number of disambiguation rewrite rules is also finite, thus in the disambiguation, a finite number of rewriting will be performed. Moreover, each rewrite rule which matches a packed node decreases the size of the SPPF, removing one packed node. Unsuccessful rewrite rules, which cannot match a packed node, leave the SPPF intact. However, there are a finite number of rewrite rules, and if they cannot disambiguate an ambiguity node, the disambiguation process prematurely terminates. In a successful disambiguation, ambiguity nodes are disambiguated one by one, until there is no disambiguation node, and the process terminates. In an unsuccessful disambiguation, at least one ambiguity node cannot be disambiguated, which terminates the whole process.\n\nIf only \\( \\text{remove} \\) rules are used in disambiguation, the process is confluent. The reason is that the removal rules act independently of each other, thus the order in which they are applied does not matter. In a successful disambiguation of a rule, each packed node should be removed by one of the \\( \\text{remove} \\) rules, regardless of in which order they are applied. In an unsuccessful disambiguation, at least one of the packed nodes cannot be matched. In both cases, the final result is the same.\n\nHowever, if there are \\( \\text{prefer} \\) rules, the disambiguation may not be confluent. We demonstrate this by the following example grammar:\n\n\\[\n\\begin{align*}\nS &::= A \\mid B \\mid C \\\\\nA &::= a \\\\\nB &::= a \\\\\nC &::= a\n\\end{align*}\n\\]\n\nThe SPPF corresponding to parsing a single “a” is shown in Figure 5.7.\n\nLet us consider three patterns named \\( A \\), \\( B \\), and \\( C \\) matching symbol nodes with the same name, and the rewrite rules \\( \\text{prefer}(A, B) \\) and \\( \\text{prefer}(B, C) \\). If, first, \\( \\text{prefer}(A, B) \\) is applied on the SPPF in Figure 5.7, node \\( B \\) is eliminated and node \\( A \\) remains. As no rules can be applied anymore, the disambiguation fails. However, if first \\( \\text{prefer}(B, C) \\) is applied, node \\( B \\) remains, and then by applying \\( \\text{prefer}(A, B) \\), node \\( A \\) remains. This disambiguates the SPPF.\nAs shown by this example, the lack of transitivity may lead to successful disambiguation in some orderings of applying rules, but not in some others.\n\nLet us again consider the three patterns, $A$, $B$, and $C$, from the previous example and the rewrite rules $prefer(A, B)$, $prefer(B, C)$, and $prefer(C, A)$. There is a circular relationship between these patterns. Applying the rules $prefer(A, B)$ and $prefer(C, A)$ will result in a derivation tree containing $C$, but applying $prefer(C, A)$ and $prefer(B, C)$ will result in a derivation tree containing $B$. This counter example shows that a circular relationship between patterns may lead to different final trees.\n\nOur current conclusion is that if prefer rules are not antisymmetric, not transitive, or there is a circular relationship between them, the disambiguation may not be confluent, but we cannot say with certainty when the disambiguation is confluent, if ever. We shall extend these theoretical analysis in the future.\nChapter 6\n\nDisambiguation by Example\n\nIn this chapter we illustrate the applicability of our disambiguation mechanism, by applying it on complex examples. We provide examples of ambiguities in programming languages and island grammars, and show how these ambiguities can be resolved. This chapter shows how hard ambiguity cases can be resolved by our method, thus answering the third research question in Chapter 1.\n\n6.1 Complex Ambiguities in Programming Languages\n\nThe examples presented in this section are taken from the SDF Disambiguation Medkit [37].\n\n6.1.1 Postfix Expressions with Guarded Children\n\nConsider the grammar of postfix expressions in Listing 6.1. For this grammar, the input string e+e(e+e) is ambiguous whose associated SPPF is shown in Listing 6.1. The first derivation, (e+e)(\" ( e+e ) \") the one under the left packed node, is not desired because e+e before the opening parenthesis is\nreduced to $\\varepsilon$. Based on this pattern $\\varepsilon(\\varepsilon, \\varepsilon)$ should bind stronger than $\\varepsilon + \\varepsilon$. We resolve the ambiguity by defining the illegal pattern as follows:\n\n$$\\text{remove} \\ [ \\varepsilon(\\varepsilon, \\varepsilon), \\varepsilon, \\varepsilon]$$\n\nFigure 6.1: The SPPF resulting from parsing $e+e(e+e)$\n\n### 6.1.2 Overloaded Commas\n\nConsider the expression grammar in Listing 6.2. For this grammar, the input $f(e, e)$ is ambiguous whose associated SPPF is shown in Figure 6.2. As can be seen, the list of arguments, i.e., $e, e$, can be recognized in two different ways: as a list of comma-separated $e$s derived from $(\\varepsilon(\\varepsilon, \\varepsilon))$ or through the binary operator $\\varepsilon , \\varepsilon$. The former derivation should be preferred to the latter.\n\n```\ncontext-free-syntact\n\nE ::= E , E\n| \"f\" \"(\" ( E (\"\\varepsilon\") )? \")\"\"\n| \"e\"\n```\n\nListing 6.2: A grammar for expression languages with overloaded commas\n\nA naive way of resolving the ambiguity in Figure 6.2 is to disallow the presence of a subtree $\\varepsilon(\\varepsilon, \\varepsilon, \\varepsilon)$ inside $f()$ by the following rewrite rule:\n\n$$\\text{remove} \\ [\\text{\"f\"(\\varepsilon, \\varepsilon, \\varepsilon, \\varepsilon)}]$$\n\nAlthough this rewrite rule works for the input $f(e, e)$, it does not work for an input with more \"e\"s such as $f(e, e, e)$. The reason is that some ambiguities\nhappen in deeper nodes, thus the pattern will not apply. To match the deeper ambiguity nodes we should write the pattern without considering \\( f \\).\n\nIn deeper ambiguity nodes, however, both derivations \\( E \\), \\( E \\) and \\( E \\{,\" E \\} \\) are valid, but if they both occur under an ambiguous node, one of them should be removed. This ambiguity can be resolved by a preference rewrite rule which selects a derivation from \\( E \\{,\" E \\} \\) over the one from \\( E \",\" E \\):\n\n\\[\n\\text{prefer } [-*, E(E, \",\", E), _*], [-*, E, \",\", E, _*]\n\\]\n\nIn this example, some packed nodes may have additional children before or after the described pattern. To capture them, we add \\( _* \\) before and after the actual pattern.\n\n### 6.1.3 The Dangling Else Ambiguity\n\nListing 6.3 shows a grammar for conditional statements. This grammar illustrates a classic ambiguity happening in most programming languages. The ambiguity, which is called “the dangling else” ambiguity, occurs in nested if-then-else statements, where the inner else can be either interpreted as belonging to the inner if or to the outer if. For example, consider the statement \"if expr then if expr then other else other\". The SPPF resulting from parsing this example is shown in Figure 6.3.\nE ::= \"expr\"\nS ::= \"if\" E \"then\" S+ |\n| \"if\" E \"then\" S+ \"else\" S+\n| \"other\"\n\nListing 6.3: A grammar for conditional statements\n\nFigure 6.3: The dangling else ambiguity\n\nAs can be seen from Figure 6.3, the else statement under the left packed node\nbelongs to the inner if, whereas the else statement under the right packed node\nbelongs to the outer if. The left and right packed nodes correspond to the\nderivations \"if expr then (if expr then other else other)\" and \"if expr then (if\nexpr then other) else other\", respectively. Selecting one of these two derivations\ndepends on the semantics of a programming language. For example, in Java,\nthe derivation which binds an else to the closest if statement is selected. The\nrewrite rule for this selection is shown in Listing 6.4.\n\nprefer [\"if\", E, \"then\", S],\n[\"if\", E, \"then\", S, \"else\", S]\n\nListing 6.4: Resolving the dangling else ambiguity\n\nThe rewrite rule states that if under an ambiguous node, under one packed\nnode, there is an if-then statement, while under another one there is an\nif-then-else statement, the packed node containing the if-then should be\npreferred. The presence of if-then implies that the else part is recognized as\na part of S, hence it is matched with an inner if statement.\n\nThe grammar of conditional statements defined in Listing 6.3 contains\nanother ambiguity which is related to the length of the recognized then part.\nFor example, consider the input \"if expr then if expr then other other\", whose\ncorresponding SPPF is depicted in Figure 6.4.\n\n49\nAs can be seen from Figure 6.4, the left packed node corresponds to a derivation in which the last statement, \\texttt{S}, is recognized as part of \\texttt{then}, \\textit{i.e.}, \"\\texttt{if expr then (if expr then (other other))}\". In contrast, the right packed node corresponds to two separate statements, in which the last \\texttt{S} constitutes the second statement, \\textit{i.e.}, \"\\texttt{if (expr then (if expr then) other) other}\". The ambiguity in Figure 6.4 can be resolved by the rewrite rule shown in Listing 6.5.\n\n### Listing 6.5: Resolving the ambiguity of the \\texttt{then} part\n\n\\begin{verbatim}\nprefer [S(\"if\", E, \"then\", S), _*],\n[S(\"if\", E, \"then\", S, _*)]\n\\end{verbatim}\n\nThe rewrite rule in Listing 6.5 indicates that if under an ambiguity node there is a packed node containing only one \\texttt{if} statement, while under another packed node, the first child is an \\texttt{if} statement followed by some other nodes, the packed node containing only one \\texttt{if} statement should be preferred. Using the rules in Listings 6.4 and 6.5 we can disambiguate complicated, nested \\texttt{if-then-else} statements.\n\n### 6.1.4 Syntactic Overloading Between Identifiers and Keywords\n\nIn languages without reserved keywords, an ambiguity may occur between the identifier and keywords of the language when an identifier takes one of the keywords as its value. As an example, consider the grammar in Listing 6.7.\ncontext-free syntax\n\n\\[\nS ::= \\text{\"return\" } E;\n\\]\n\\[\n\\mid E \\text{ \"(\" } (E \\text{ ',\" E')? \")\"\n\\]\n\\[\nE ::= \\text{\"(\" } E \\text{ \")\"}\n\\]\n\\[\n\\mid \\text{Identifier}\n\\]\n\nListing 6.6: A grammar for showing the ambiguity in syntactic overloading\n\nThe SPPF corresponding to the parsing of \"return (x)\" is shown in Figure 6.5. As can be seen under the left packed node, \\textit{return} is recognized as \\textit{E}, while under the right packed node, it is recognized as a keyword \"return\". The ambiguity in Figure 6.5 can be resolved by a rewrite rule preferring the recognition of keywords, see Listing 6.7.\n\n![Figure 6.5: The SPPF corresponding to the parsing of \"return (x)\"\n]\n\nListing 6.7: preferring the keyword \\textit{return} to identifiers\n\nUsing pattern matching for resolving this type of ambiguity allows more freedom than having reserved keywords. For example, the keyword \"return\" may be used in other places, but it will be rejected only if there is an ambiguity with recognizing a \"return\" \\textit{E} rule.\n\nMEBNF also allows keyword restriction through lexical exclusions mechanism. Using lexical exclusions, keywords can be excluded from being re-\nported by the lexer to the parser as their recognized types. For example, in the example in Listing 6.7, one can exclude the recognition of \"return\" as an \"Identifier\" as follows:\n\n**lexical syntax**\n\nIdentifier ::= [a-zA-Z_][a-zA-Z0-9_\\-]* { \"return\" }\n\nUsing the lexical exclusions leads to a faster parser, as the ambiguity is prevented in the first place. However, lexical exclusions reduce the freedom in choosing identifier names.\n\n### 6.2 Ambiguities in Island-Grammar based languages\n\nIsland grammars [26, 33] are a method for describing the syntax of a language, concentrating only on relevant constructs. An island grammar consists of two sets of context-free rules. Rules for islands describing the relevant language constructs which should be fully parsed, and rules for water which describe the rest of the input which we are not concerned with. One of the applications of island grammars is in the parsing of embedded languages, where the embedded language and host language constructs are captured as island and water, respectively.\n\nTo illustrate the use of our disambiguation mechanism in island grammars for parsing embedded languages, we define a simple island grammar which extends general-purpose programming languages. This island grammar, which is a simplified version of Tom's **match** construct, is shown in Listing 6.8. The complete island grammar of Tom is presented in Appendix D.\n\n**context-free syntax**\n\nProgram ::= Chunk*\n\nChunk ::= Water | Island\n\nIsland ::= \"%match\" \"(\" Chunk* \")\"\n\n**lexical syntax**\n\nWater ::= Identifier | Integer | String | Char | SpecialChar\n\nIdentifier ::= [a-zA-Z_]+[a-zA-Z0-9\\-_]*\n\nInteger ::= [0-9]+\n\nString ::= [\"\\]()([\\^\\]s\\^\\trnu]\\[*\\]\"\n\nChar ::= [\\'][\\'] | [\\']\\[\\hfr\\\\'\\\\] [\\']\n\nSpecialChar ::= [; : += - * / = & ! < > ! % @ \\[ \\] ^ { } . $ # ~]\n\nListing 6.8: The starting rules of an island grammar\nAs shown in Listing 6.8, the production rule defining Program contains Chunk*, meaning that other Match and host-language constructs can be nested inside a Match construct. In defining an island grammar, the overlaps and boundaries between the water and island tokens should be recognized. Therefore, we define fine-grained water tokens being as small as the building blocks of the supported host languages.\n\nA water definition such as Water ::=[^ \\n \\r \\t]+, which defines water as a sequence of non-whitespace characters, is inadequate in recognizing the boundaries. For example, consider the input \"%match(x)\". Given the lexical definition for Water, no match construct can be recognized. The lexer reports a sequence of \"match\", \"(\" , and \")\" tokens to the parser. After consuming the first parenthesis, the parser asks for a Water, but the lexer returns the whole chunk of text until the next whitespace or the end of line character, creating the token \")\". As no closing parentheses left, the parsing fails. For more information about the interaction between the parser and lexer, the reader is referred to Chapter 8.\n\nIn addition, the island grammar presented in Listing 6.8 is designed to be host-language agnostic, although it may not possible to completely achieve it. For being host-agnostic, the water definition should be flexible and capture the different varieties of tokens appearing in different supported host languages. For example, SpecialChar contains the union of all different symbols which appear in the host languages supported by our island grammar.\n\n6.2.1 The Island-Water Ambiguity\n\nThe SPPF corresponding to the parsing of \"%match(x)\" is shown in Figure 6.6. As can be seen, an ambiguity has been occurred between the recognition of an island, under the right packed node, and a set of water, under the left packed node. We call this ambiguity the island-water ambiguity happening in almost all island grammars. If the ambiguity contains more than one water element, the ambiguity occurs under a node labeled \"Chunk_*\", which is in fact an intermediary node resulting from the EBNF to BNF conversion. For more information on the EBNF to BNF conversion, see Section 3.2. The conversion, however, does not affect the writing of patterns, as patterns describe tree structures under packed nodes and not their parent, the ambiguous node.\n\nThe ambiguity in Figure 6.6 can be resolved by the rewrite rule in Listing 6.9. As can be seen, the rewrite rule prefers the packed node having a complete island to another packed node whose first child is a water element. Using this simple rule, we are able to resolve all the island-water ambiguities involving more than one water. In case an ambiguity occurs between an island and a\n6.2.2 The Island-Island Ambiguity\n\nFigure 6.7 shows the SPPF resulting from the parsing of input \"match(x)\". The rewrite rule of Listing 6.9 has already been applied to the SPPF, thus the island-water ambiguities are resolved.\n\nAs can be seen from Figure 6.7, an ambiguity has been occurred between a collection of islands and water elements under two packed nodes. We call this type of ambiguity the island-island ambiguity. Resolving the island-island ambiguity is difficult, mainly because it depends on the semantics of the language. For example, in Figure 6.7, the derivation under the left packed node is preferred since it has well-balanced parentheses under its island. Unfortunately, one cannot use our disambiguation syntax to check the well-balancedness property. For this, a simple Tom program should be written to manually check this. See Section 5.4 for details on how to attach a handwritten Tom specification into the disambiguation process.\n\nFor this specific island-island ambiguity, one can also rewrite the grammar to avoid the ambiguity. The idea is that we enforce the well-balancedness of parentheses in the grammar itself. For this, the definition of Chunk* will be\nFigure 6.7: The island-island ambiguity\n\nA third way of selecting a derivation in the island-island ambiguity is to use a heuristic. For this example, one can select the largest formed island, thus selecting the derivation under the second packed node. The parser of the host language will eventually complain about the unbalanced parenthesis. This way, the island grammar’s parser does not assume anything about the host language, and the check for well-balancedness of parentheses is delegated to the host language’s parser.\n\nA second usage of island grammars is in reverse engineering, especially the fact extraction from source code. Listing 6.10 gives an island grammar definition for extracting integer definitions and assignments from C code. The lexical definitions for Water, Integer, and Identifier is the same as in 6.8. The example is taken from [36].\nProgram ::= Chunk*\n\nChunk ::= Water | Island\n\nIsland ::= \"const\" \"int\" Identifier\n | Identifier \"=\" Integer\n\nListing 6.10: An island grammar for integer definitions and assignments\n\nThe SPPF corresponding to the parsing of \"const int x = 1\" is given in Figure 6.8. The rewrite rule of Listing 6.9 has already been applied to the SPPF, thus the island-water ambiguities are resolved. As shown in [36], SDF’s prefer mechanism fails to resolve the island-water ambiguities in this example.\n\n\n\nAs can be seen from Figure 6.8, under the left packed node, \"x = 1\" is recognized as an island, while under the right packed node \"const int x\" is an island. Again, the disambiguation of this island-island ambiguity depends on the semantics. Here, we simply prefer an assignment over a definition. The rewrite rule implementing this preference is shown in Listing 6.11. Using this rewrite rule the ambiguity in Figure 6.8 can be resolved.\n\nprefer [\\_*, Chunk(Island(Identifier, \"=\"), Integer))],\n [\\_*, Chunk(Island(\"const\", \"int\", Identifier)), \\_*]\n\nListing 6.11: Resolving the island-water ambiguity in Figure 6.11\nChapter 7\n\nExperiments\n\nIn this chapter we present the result of applying our disambiguation mechanism to three case studies. The first case is the grammar of arithmetic expressions in Listing 5.8 and its associativity and priority relationships in Listing 5.9 as disambiguation rules. The reason for selecting this grammar was that it is fairly ambiguous, and more importantly, and we can easily control the number of ambiguities by increasing the size of input. The second case is mCRL2 [10], a formal language for analysis of behavior of systems. mCRL2 is a very ambiguous language, due to its many operators. The last case is Tom, an embedded language within Java and other general-purpose programming languages, providing advanced pattern matching and tree traversal functionalities. The reason for selecting Tom was to evaluate our disambiguation mechanism on island grammars. Tom has also been used to implement the disambiguation mechanism in this thesis.\n\n7.1 Arithmetic Expressions\n\nFor conducting the experiments on the grammar of arithmetic, we generated random arithmetic expressions of different sizes and recorded the disambiguation results. The size of the generated examples ranges from 6 to 340 tokens, and in total 50 examples were executed. Moreover, the associativity and priority rules were translated into 30 removal disambiguation rules.\n\nTable 7.1 summarizes the obtained disambiguation results. The data is divided into 10 categories, each represented by the average value for the metrics. As can be seen, inputs with an average size of 20 are almost immediately parsed and disambiguated. Even with 50 tokens, the total time for parting and disambiguation is acceptable. Longer expressions are extreme cases and rarely happen in practice.\nThe parsing and disambiguation times are plotted in Figure 7.1. As can be seen, as the size of input increases, and as result the number of ambiguity nodes, the disambiguation time increases. In the future, we will present a theoretical analysis of the complexity of our disambiguation mechanism. Moreover, one of the reasons that the parsing time is relatively low is that the grammar only has seven production rules, without any layout rules.\n7.2 mCRL2\n\nThe second case study is the grammar of mCRL2. The EBNF grammar of mCRL2 can be found at mCRL2’s website [10]. The grammar is rather large, with a significant number of operators. Converting the priority and associativity rules has resulted in about 600 Tom rules. Besides, there were a number of “Postfix Expressions with Guarded Children”, see Section 6.1.1, ambiguities which have been manually resolved by rewrite rules. Another important point about the grammar of mCRL2 was the presence of unary operators with a prefix or postfix, i.e., $A ::= \\alpha \\ x \\ A$ or $A ::= A \\ x \\ \\alpha$, where $\\alpha$ is a sequence of grammar symbols, and $x$, the operator is is a terminal or nonterminal. The current translation technique in Section 5.3.2 cannot be used to generate rules for such rules. Therefore, the rules concerning the priority of unary and binary operators with a prefix or postfix are written manually. The complete set of disambiguation rules for mCRL2 can be found in Appendix E.\n\n\n\nWe have parsed and disambiguated all mCRL2 files present in the the source release of the software. In total 93 files have been parsed, ranging from 3 to 8037 tokens. Moreover the number of ambiguity nodes in the mCRL2 example files ranges from zero to 897, with an average of 95 ambiguity nodes. The result of this experiment is plotted in Figure 7.2. As can be seen the disambiguation time for mCRL2 files is constant.\n7.3 Tom\n\nThe last case study is parsing the island grammar of Tom. The island grammar is presented in Appendix F. Using the island grammar and its disambiguation rules, we are able to parse most of the Tom programs from the tom-examples package. This package, which is shipped with a source distribution of Tom, contains more than 400 examples (for a total of 70,000 lines of code) showing how Tom is used in practice. The size of these examples varies from 24 lines of code (679 characters) to 1,103 lines of code (30,453 characters).\n\nThe parsed examples which have a size of about 10,000 characters can be parsed and disambiguated in less than one second, and the disambiguation time of an instance is always lower than its parsing time. Moreover, from what we have observed, the parsing time for Tom instances is linear. For this study, we only focused on the core Tom examples, about 300 files. The other examples were related to XML processing and were not considered. The result of parsing the Tom examples is shown in Figure 7.3.\n\n\nChapter 8\n\nJGLL Parser Generator\n\nIn this chapter we present JGLL, a parser generator for generating GLL-based Java parsers. JGLL, written in Java and Tom, uses Gom-generated data types. This provided us with a declarative way of performing different transformation tasks using Tom. JGLL generates parsers, which are based on an improved version of the GLL parsers presented in [24]. The improvements include optimization in data structures and faster lexing.\n\nThe rest of this chapter is organized as follows. Section 8.1 presents the architecture of JGLL. Next, in Section 8.2, we describe the interaction between the parser and lexer in generated parsers. We also demonstrate how generated parsers can deal with the overlapping between tokens and tokens with different types. We conclude this chapter by explaining the improvement in the lexer implementation.\n\n8.1 Architecture\n\nThe architecture of JGLL parser generator is shown in Figure 8.1. As can be seen, a GLL parser is generated in six steps. The input to these steps is an MEBNF specification for a language \\( L \\), and the output is a GLL parser for language \\( L \\). The function of each step is described as follows:\n\n1. **EBNF Parser** is a GLL parser for parsing MEBNF specifications. It parses the provided syntax of a language and produces an SPPF. If the syntax is not correct, an error message indicating the position where the error happened is shown to the user, and the parser generation process terminates.\n\n2. **SPPF2EBNF** is a Tom specification translating the produced SPPF from the previous step to an EBNF term, as shown in 3.1. The SPPF\ncorresponding to parsing an MEBNF specification may be ambiguous. The disambiguation is performed in this step. Furthermore, an MEBNF specification has more information than context-free rules: lexical rules are translated into regular expressions, disambiguation rules and priorities into Tom rules, and EMF annotations into Java classes which process annotations. See Chapter 10 for more information on EMF integration.\n\n3. **LoadModules** loads the imported modules from the loaded EBNF term produced in the previous step. If a module is already loaded, it will be reused. Otherwise, the process goes to Step 1, and the module is loaded. When all the modules are loaded, modularity rules are applied, and a EBNF term from all the loaded modules is produced. As explained in Section 3.6, currently, all reachable nonterminals are added to the importing module, without considering module names.\n\n4. **EBNF2BNF** converts an EBNF specification to its equivalent BNF specification. The conversion is performed according to Section 3.2. Note that there is no explicit signature for BNF. An EBNF term is transformed into another EBNF term without specific EBNF constructs. See Section 3.1 for more information.\n\n5. **BNFUtil** extracts first and follow sets, among other required information, from the provided BNF term. These information are fed into parser generator.\n\n6. **Parser Generator** generated a Java parser and related components, such as lexer and disambiguation rules, using the provided information from Step 2 and 5. The generated parsers are in pure Java, and thus there is no dependency to Tom.\n\n## 8.2 Parsing with a separate Lexer\n\nOur GLL implementation uses a separate lexer, which is very simple and is driven by the parser. The lexer returns all possible token types seen at a particular point of the input. The token types are explicitly requested by the parser, and they may overlap. Being a top-down parser, GLL traverses the rules of a grammar, and at each grammar position, decides whether the tokens received from the lexer are relevant. This check is performed by testing the received tokens against the first and follow sets of alternates. All the relevant tokens at a position are consumed, and irrelevant ones are simply ignored. With this strategy, GLL parsers with a separate lexer are able to detect the overlapping between tokens and tokens with multiple types. These features are essential in parsing embedded languages.\nAs an example, consider the rules from Listing 6.8, which describes the starting rules of an island grammar. The generated parsing code for choosing between an Island or Water is shown in Listing 8.1.\n\n```java\nprivate void parse_Chunk_Label() {\n if (test(lexer.get(ci, \"%match\"))) {\n add(Water_Label, cu, ci, SPPFNode.DUMMY);\n } \n if (test(lexer.get(ci, \"Water\"))) {\n add(Island_Label, cu, ci, SPPFNode.DUMMY);\n }\n label = 0;\n}\n```\n\nListing 8.1: A Java function associated with\n\nThe `test` method in Listing 8.1 checks whether the set of tokens returned by the lexer is not empty. The first parameter of this method, `ci`, denotes the current input position, and the second parameter is the token type. The `add` method creates a descriptor for processing a grammar label. In Listing 8.1, if the first `if` at Line 2 evaluates to true, the grammar label corresponding to Water, Water_Label is added to the set of descriptors. Similarly, at Line 6, the label for processing Island is added.\n\nLet us consider the input `%match`. When the parser executes the `parse_Chunk_Label` method, it requests two different token types: the keyword `%match` and `Water`. As Lexer can match both token types, returning `%match` and `Water`, respectively, both island and water nonterminals will be processed. This example shows\nhow overlapping between tokens can be recognized using a separate lexer.\n\nFor showing how a GLL parser with a separate lexer treats tokens with different types, we use the grammar in Listing 8.2, which defines an if statement. In this grammar, keywords are not reserved.\n\n```\ncontext-free syntax\n\nProgram ::= S*\nS ::= \"if\" E \"then\" S\nS ::= E \"=\" E\n\nlexical syntax\n\nE ::= [a-z]+\n```\n\nListing 8.2: A grammar for if statements without reserved keywords\n\nThe input \"if if then then = if\" can be successfully parsed, without introducing any ambiguity. The parse tree corresponding to this string is shown in Figure 8.2. Other parses, in which the second \"if\" has been interpreted as the beginning of an if statement, were unsuccessful.\n\n\n\nFigure 8.2: Parse tree for \"if if then then = if\"\n\nGLR parsers cannot deal with such cases without additional help. For example, in the Schrödinger’s Token method [15], it is shown how to modify the lexer to report the type of a token with multiple types as the Schrödinger type, which is in fact a meta type representing all the actual types. When the parser receives a Schrödinger’s token, for each of its actual types, parsing will be continued in parallel.\n\nScannerless GLR parsers [38] can successfully deal with this example. In scannerless parsing, there is no explicit lexer present, so the parser directly works on the character level. This has the advantage of giving the parser the opportunity to decide about the type of a token based on the context in which the token’s characters appear. Scannerless parsing is a powerful paradigm for dealing with tokens with multiple types and overlapping, but\nthere are some disadvantages to this approach. First, because the parser works on the character level, the size of the parse forest is bigger. Second, in recognizing sequence of characters as a token, ambiguities may occur. For example, the string \"if\" can be interpreted as two tokens, \"i\" and \"f\", or a single token \"if\". These ambiguities should be explicitly addressed. Using GLL with a separate lexer, one does not require any specific treatment for tokens which overlap or have different types. Our parser implementation is as powerful as a scannerless parser, and at the same time, has the benefits of a separate lexer.\n\n8.3 Lexer Implementation\n\nThe original implementation of [24] used Java’s regular expression library as the underlying implementation of the lexer. Our early investigations showed that the lexer is a performance bottleneck. The reason is that Java’s regular expressions is an NFA-based library, and as NFA-based regular expressions use backtracking for matching a pattern, the matching may become very slow. We replaced Java’s regular expression with dk.brics.automaton [25] regular expression library, which is a DFA-based. DFA-based regular expressions do not provide features such as capturing groups, which are also not needed for a lexer, but they can match a pattern linear in the length of a string, independently of the complexity of the pattern. This led to a considerable performance gain in the whole parsing process.\n\n8.4 Attaching Custom Disambiguation Rules\n\nIn Section 6.2, we mentioned that one can resolve the island-island ambiguity by using a custom Tom program. In this section, we show how to do this. Listing 8.3 shows the Java code for parsing and disambiguating an input. The parser in line 1 refers to an instance of a GLL parser. If parsing the provided input was successful, i.e., the returned SPPF from the parse method was not null in line 3, the disambiguation phase starts. Disambiguation rules can be added to a BottomUpDisambiguator instance, as shown in Line 10 and 11. In this example, two disambiguation rules are added. The disambiguate method, in line 14, tries to disambiguate the SPPF using the provided rules. If the rules could not successfully disambiguate an SPPF, an exception is thrown. Otherwise, if the disambiguation was successful, the SPPF will only contain symbol nodes. A non-ambiguous SPPF can be processed by any Java or Tom programs.\nSymbolNode sppf = parser.parse(input);\n\nif (sppf == null) {\n ParseError parseError = parser.getParseError();\n System.out.println(parseError);\n System.exit(1);\n}\n\nBottomUpDisambiguator disambiguator = new BottomUpDisambiguator();\ndisambiguator.addDisambiguationRule(new DisambiguationRule1());\ndisambiguator.addDisambiguationRule(new DisambiguationRule2());\n\ntry {\n disambiguator.disambiguate(sppf);\n} catch (DisambiguationFailure e) {\n e.printStackTrace();\n}\n\nListing 8.3: Needed steps for parsing and disambiguation\n\nA custom disambiguator can be added to the disambiguator instance. To do this, the user should implement the DisambiguationRule interface, shown in Figure 8.4. The interface provides a single method, apply which takes an SPPF node and disambiguates the subtree under it. This interface can be implemented using pure Java or a combination of Java and Tom.\n\nListing 8.4: The DisambiguationRule interface\n\npublic interface DisambiguationRule {\n public void apply(SPPFNode node);\n}\nChapter 9\n\nThe Eclipse Plugin\n\nModern IDEs such as IntelliJ IDEA [9] and Eclipse [3] provide sophisticated environments for editing the source code of Java, and other general-purpose programming languages. These environments provide editors capable of syntax highlighting, code completion, and live error reporting. Most domain-specific languages, however, do not enjoy such tooling, as creating similar environments for domain-specific languages is very expensive. It is, therefore, desirable to generate such editing environment with a set of standard features, such as syntax highlighting, from a DSL’s specification. The generated editor can be used as the basis for a full-fledged IDS for the DSL.\n\nIn this chapter we show how to create an Eclipse-based editor from a generated MEBNF grammar. The editor is based on the IDE Meta-Tooling Platform (IMP) [18, 8]. IMP provides an automated, yet customizable platform for creating Eclipse-based IDEs. In the rest of this chapter we first introduce IMP in Section 9.1 and how it facilitates IDE development. Then, in Section 9.2, the integration of GLL and IMP is explained. We conclude this chapter by demonstrating some screenshots from an IDE for MEBNF.\n\n9.1 IMP\n\nIMP is an Eclipse project aiming at making the creation of IDEs for custom languages easier. The ultimate goal of IMP is to provide a similar environment to Eclipse Java Development Tools (JDT) [4] for DSLs. IMP produces an Eclipse plugin project with a set of IDE services, each providing a facility such as syntax highlighting, code folding, and many other features found in popular IDEs. IDE services rely on the Abstract Syntax Tree (AST) of a language. IMP makes few assumptions about the type of AST nodes and treat them as instances of Java java.lang.Object classes. This provides great\nflexibility in attaching custom parsers and AST node types.\n\nThe core part of an IMP plugin is a ParseController. A parser controller implements a parse method which receives an string as input and returns the root of the produced AST. The parse method is called by IMP at each update of the editor, and the text in current active editor is provided as input. Furthermore, a ParserController implements a getTokenIterator method providing an iterator for the leaves of a parse tree. The produced AST or iterator is then passed to different IDE services for further processing. After the processing, IMP updates the UI components to reflect the changes.\n\nFrom the set of IMP IDE services, we implemented the following IDE services. The actual implementation of these services using a GLL parser is presented in Section 9.2.\n\n- **Token Colorer** or syntax highlighter provides the editor with information to color a piece of text based on its token type. This service uses the token iterator from the ParserController.\n- **Tree-Model Builder and Label Provider** creates a labeled tree from the AST. The labeled tree can, for example, be used in the outline view, giving an overview of the structure of a program.\n- **Text Folding** provides the editor with information to collapse a block of code. An example is to fold Java methods in JDT.\n\n### 9.2 Integrating GLL and IMP\n\nIn this section we discuss the technical details of integrating GLL parsers with IMP. The examples in this section are from an editor for the MEBNF syntax, i.e., an editor for editing MEBNF specifications.\n\n#### 9.2.1 Implementation of Parser Controller\n\nListing 9.1 shows a parse controller implementation for MEBNF. The class extends ParseControllerBase which is provided by IMP as a base class for parse controllers. The parse method, line 6, receives the input as an argument, parses the input, and then disambiguates the resulting SPPF. If a parse error occurs, i.e., sppf == null, the handleSimpleMessage from the provided handler object is called. This results in showing the error message in the editor window. As a produced SPPF may be ambiguous, it is disambiguated before returning the root of the SPPF. If disambiguation fails, e.g., the corresponding disambiguation rule is not present, an error is shown to the user, see line 20.\npublic class MEBNFParseController extends ParseControllerBase {\n private MEBNFParser parser;\n private BottomUpDisambiguator disambiguator;\n\n public Object parse(String input, IProgressMonitor monitor) {\n SymbolNode sppf = parser.parse(input);\n if (sppf == null) {\n ParseError error = parser.getParseError();\n handler.handleSimpleMessage(error.toString(), error.getInputIndex(),\n error.getInputIndex(), 0, 0, 0, 0);\n return null;\n }\n\n try {\n disambiguator.disambiguate(sppf);\n } catch (DisambiguationFailure e) {\n handler.handleSimpleMessage(e.toString(), e.getInputIndex(),\n e.getInputIndex(), 0, 0, 0, 0);\n }\n\n fCurrentAst = sppf;\n return sppf;\n }\n\n public Iterator<SymbolNode> getTokenIterator(IRegion region) {\n if (fCurrentAst == null) {\n return null;\n }\n\n return SPPFUtil.getTerminalIterator((SPPFNode) fCurrentAst);\n }\n}\n\nListing 9.1: A parser controller implementation for MEBNF\n\nThe getTokenIterator method returns an java.util.Iterator instance from the set of tokens. The set of tokens is calculated by SPPFutil which is a Tom program. Listing 9.2 shows how the getTokenIterator method is implemented. As can be seen, a TopDown strategy is employed to gather all SPPF nodes having no children, Line 13.\npublic static Iterator<SymbolNode> getTerminalIterator(SPPFNode node) {\n List<SymbolNode> terminals = new ArrayList<SymbolNode>();\n try {\n TopDown(GetTerminals(terminals)).visitLight(node, new SPPFIntrospector());\n } catch (VisitFailure e) {\n e.printStackTrace();\n }\n return terminals.iterator();\n}\n\n%strategy GetTerminals(list:List) extends Identity() {\n visit SPPFNode {\n s@SymbolNode(name, concNode()) -> { list.add(s); }\n }\n}\n\nListing 9.2: Getting the token iterator using Tom\n\n9.2.2 Token Coloring\n\nToken coloring is done through the ITokenColorer interface, provided by IMP. A language-specific class should implement the getColoring method of the ITokenColorer interface in order to provide coloring rules for the tokens of the language.\n\n```\npublic TextAttribute getColoring(IParseController controller, Object o) {\n if (o == null) { return null; }\n SymbolNode token = (SymbolNode) o;\n if(keywords.contains(token.getSymbolName())) {\n return keywordAttribute;\n }\n if(\"Comment\".equals(token.getSymbolName())) {\n return commentAttribute;\n }\n return super.getColoring(controller, token);\n}\n```\n\nListing 9.3: Token coloring for MEBNF’s keywords\nListing 9.3 shows how this method is implemented for MEBNF’s keywords. Line 1 and 5 declare text attributes specifying font properties such as color and type. The implementation of the `getColoring` method begins at Line 9. The provided `Object` parameter to this method is the token to be colored. The tokens are obtained through the MEBNFParserController in Listing 9.1. Lines 14 and 17 check the token type, by calling the method `getSymbolName`, and select a text attribute accordingly. If no match is found, the default text attribute is returned from Line 20.\n\n### 9.2.3 Tree-Model Builder and Label Provider\n\nIMP’s tree-model builder provides means for creating a tree model from the AST. This tree, augmented by a label provider assigning a label to each node of the tree-model, can be used to create an outline view for the source code. An outline view provides a tree user interface for navigating the structure of code. For example, in JDT, the outline view gives an overview of the methods, constructors, and fields defined in a class.\n\nA tree model in IMP is specified by instances of `ModelTreeNode`. A `ModelTreeNode` is a simple Java object defining a tree node holding an AST node and keeping references to its parent and children. To implement a tree model, the AST should be traversed and the desired parts be added to a tree model. For example, the Tom program in Listing 9.4 creates a tree model from MEBNF’s lexical and context-free sections.\n\n```java\nModelTreeNode root = new ModelTreeNode(node);\n\nmatch(node) {\n SymbolNode(\"Section\",\n concNode(_, section@SymbolNode[name=\"ContextFreeSection\"], _*)) -> {\n ModelTreeNode m = new ModelTreeNode('section);\n root.addChild(m);\n }\n SymbolNode(\"Section\",\n concNode(_, section@SymbolNode[name=\"LexicalSection\"], _*)) -> {\n ModelTreeNode m = new ModelTreeNode('section);\n root.addChild(m);\n }\n}\n```\n\nListing 9.4: Creating tree models from MEBNF’s AST\n\nIn Listing 9.4, `node` refers to a SPPF node having the label `Section`, corresponding to the `Section` nonterminal in Listing 3.2. A `ModelTreeNode` named `root` holding the root node of AST. The `match` construct, matches the SPPF\nnodes, and if a node labeled ContextFreeSection or LexicalSection is found, a new ModelTreeNode holding the matched section is created. The newly created child tree model object is added to the root node as a child.\n\n### 9.2.4 Text Folding\n\nThe text folding service is provided by IMP’s FolderBase class. To provide language-specific text folding, the sendVisitorToAST method of the Folder class should be implemented. In the implemented method, AST nodes associated with foldable blocks should be passed to makeAnnotation(). Listing 9.5 shows how to add make MEBNF’s sections foldable. The provided ast is the root of AST. In this example, we only need to examine direct children of the root node. Therefore, a simple for loop suffices. For complex, nested text folding, one should examine deeper nodes in the AST.\n\n```java\npublic class MEBNFFoldingUpdater extends FolderBase {\n protected void sendVisitorToAST(HashMap<Annotation, Position> newAnnotations,\n List<Annotation> annotations, Object ast) {\n for (SPPFNode child : ((SPPFNode) ast).getChildren()) {\n SymbolNode node = (SymbolNode) child;\n if (node.getSymbolName().equals(\"Section\")) {\n makeAnnotation(node);\n }\n }\n }\n}\n```\n\nListing 9.5: Making MEBNF’s sections foldable\n\n### 9.3 An IDE for MEBNF\n\nIn this section we show a number of screenshots from an IMP-based Eclipse plugin for MEBNF. Figure 9.1 shows an overview of the plugin. As can be seen, the plugin provides syntax highlighting, an outline, and text folding. In the figure, the declaration node in the outline view is selected, and as a result, the declaration nonterminal in the editor is highlighted. In addition, the annotations associated with the alternates of Statement are folded.\n\nError messages appear in the editor as a parse error occurs. For example, Figure 9.2 shows a parse error caused by inserting a character t after the definition of the Program nonterminal.\nFigure 9.1: An overview of an IMP-based Eclipse plugin for MEBNF.\n\nFigure 9.2: Error messages appear in the editor as soon as a parse error occurs.\nChapter 10\n\nEMF Model Generation\n\nOne of the initial goals of this project was to provide a mapping from parse trees to EMF models. The first effort lead to the thesis “mlBNF: A syntax formalism for domain-specific languages” [24]. The thesis describes a syntax formalism for defining domain-specific languages, in BNF, and provides a mapping to EMF models through annotations. Two shortcomings of mlBNF, no EBNF support and no disambiguation mechanism, have been addressed in this work. Together with the Eclipse plugin introduced in Chapter 9, we provide a viable alternative to the state of the art tools in the area of metamodeling and concrete syntax, such as XText [13] and EMFText [6].\n\nIn this chapter, we introduce a revised version of the annotations in [24] for defining the mappings to EMF. The annotations, resembling attribute grammars, define how an SPPF should be evaluated to create corresponding EMF models. The revised annotations and an example of how they can be used is given in Section 10.1. The EBNF support and disambiguation mechanism impose difficulties in the evaluation of annotations. We conclude this chapter by discussing these implementation challenges in Section 10.2.\n\n10.1 Concrete Syntax for Annotations\n\nFor defining a mapping from an SPPF to EMF models, we provide the concrete syntax of MEBNF, shown in Listing 3.3, with an annotation facility. For this, an Annotations nonterminal is added to each context-free rule. In addition, a separate import type, for importing meta-models, and a label for symbols of the grammar is provided. The labels are used during the evaluation of annotations to access a specific part of the parse tree. The resulting grammar from these changes is shown in Listing 10.1.\nThe rules defining an Annotation itself are given in Listing 10.2. As can be seen, each alternate of a nonterminal can be annotated with one of the six provided annotation types. An annotation starts with its name, followed by a set of parameters, denoted by Name.\n\nListing 10.2: Concrete syntax for defining annotations\nListing 10.3: EMF mapping annotations for arithmetics expressions\nListing 10.3 shows the EMF mapping for the grammar of arithmetic expressions, shown in Listing 5.8. In lines 3 and 4, two meta-models are imported. Imported meta-models have a namespace, which can be used to refer to them in annotations. The imported meta-models, the Arithmetics meta-model, shown in Figure 10.1, and the standard Ecore EMF meta-model, is used to instantiate EMF models.\n\n\n\nIn lines 4-50, the alternates of ε are defined. The first alternate contains three annotations. The class annotation in line 6 is used to instantiate the class `BinaryExpression` from the Arithmetics meta-model, indicated by the meta-model’s namespace, `expr` before ::. In lines 8 and 9, reference annotations are used to instantiate references of an instance of the `BinaryExpression` class. Reference annotations take two parameters. The first parameter is a meta-model reference identifier, and the second one is a symbol label. The meta-model reference identifier is used to refer to a reference of a meta-class. The symbol label is used to indicate the part of the parse tree corresponding to the alternate of a context-free rule. This part of the tree should be traversed and evaluated. The meta-model reference will then be instantiated with the result of this traversal. For the reference annotation in line 7, the `leftHandSide` reference from the `BinaryExpression` class is instantiated with the value of the traversal of the tree corresponding to `lhs`.\n\nThe attribute annotation in line 10 is used to instantiate the `operator` attribute of an instance of the `BinaryExpression` class. There are three kinds of attribute annotations. 1) `Enumeration attribute` annotations, instantiating an attribute of a class instance with an enumeration value, `literal attribute` annotations, instantiating an attribute with a literal value, and 3) `reference attribute` annotations, instantiating an attribute with the result of a traversal. The attribute annotation in line 10 is an example of an enumeration attribute annotation. The literal `Addition` of the `BinaryOperators` enumeration is assigned to the `operator` attribute of the `BinaryExpression` class. An example of a reference attribute annotation is given in line 48.\nLine 51 shows the usage of a \\textit{datatype} annotation, denoted by \\texttt{type}. Datatype annotations indicate that the result of evaluation of a tree is casted to the indicated data type. In this case, the literal value of a \\texttt{Number} is casted to \\texttt{EBigInteger}, which is a standard Ecore datatype. As a result, the \\texttt{value} attribute of an instance of an \\texttt{IntegerExpression}, as defined in lines 45-59, is instantiated with an instance of \\texttt{EBigInteger}. The \\texttt{enum} and \\texttt{propagate} annotations are not discussed here. For more information on how to use these annotations, see [24]. Moreover, as another example, an ambiguous version of the Pico language grammar, written in EBNF, and its mapping to EMF is provided in Appendix D. The pico example has also been used in [24]. Therefore it can be used for comparing the new and old versions of mappings to EMF.\n\n10.2 Implementation\n\nAs explained in Section 2.2, the SPPF keeps the information related to grammar positions in packed nodes. These information are essential in retrieving the labels and annotations of nodes for the conversion of an SPPF to an EMF model. In our disambiguation mechanism, we remove the packed nodes and intermediate nodes which are not part of an ambiguity node. This removal leads to the loss of position information in an SPPF. To overcome this, we move the grammar position information from the packed nodes, which should be removed, to appropriate symbol nodes.\n\nA packed node can be removed only if its the only child. If a packed node has packed node siblings, it is part of an ambiguity node, and will be removed after disambiguation. When a packed node is removed, its grammar position information is added to its parent symbol node. This information is used later to add retrieve the labels and annotations for the symbol nodes.\n\nIn principle, the label of a symbol node is retrieved using the position information of its parent, while the annotation information come from its child. We, however, move the position information of a packed node to its parent, and not its child. The reason is that symbol nodes may be shared and we cannot simply push down the position information to all the children. This leads a symbol node having multiple positions. After ambiguities are resolved, and a correct derivation has been chosen, we can retrieve the labels of a symbol node using the information from its parent. In an unambiguous SPPF, only some \\texttt{\\epsilon} nodes can be shared. Moreover, we remove the \\texttt{\\epsilon} nodes during while removing intermediary EBNF nodes, see Section 3.2. As a result, in an unambiguous SPPF, each symbol node has only one parent. Furthermore, the annotations are retrieved from the position information of a symbol node itself.\nAnother important implementation note is how to treat intermediary EBNF nodes. These nodes, similar to any other symbol node, contain the position information after the removal of unnecessary packed and intermediate nodes. Therefore, while removing the EBNF intermediary nodes, in Section 3.2, the position information should be pushed down to their children, so that their corresponding labels and annotations can be retrieved.\n\nAfter the label and annotation information are added to symbol nodes of an unambiguous SPPF, one can traverse the SPPF, using Java or Tom, and generate models using these information. The generation of models from an annotated SPPF is basically the same as in [24].\nChapter 11\n\nFuture Work\n\nIn this chapter we discuss how the work presented in this thesis can be extended in the future. Each section discusses a possibility of improving this work, or introduces a new idea for future research, based on what have already been done.\n\n11.1 Extending the syntax of disambiguation rules\n\nThe presented syntax for disambiguation rules in Section 5.2 can be extended to support more complicated patterns. The following extensions to this syntax is desirable.\n\n- EBNF style modifiers, such as ?, *, + for matching specific numbers of terminals and nonterminals.\n- A depth search operator for matching patterns in arbitrary depth of an SPPF.\n- A not follow operator, disallowing a specific sequence of terminals and nonterminals in an SPPF.\n\n11.2 A Framework for Parsing Language Embeddings\n\nParsing language embeddings and extensions poses a considerable challenge from the parsing point of view. One of our goals in developing GText, and its disambiguation mechanism, was to provide an environment to facilitate\nexperimenting with hard, ambiguous grammars, such as grammars of language embeddings. In this thesis we showed how to parse Tom, using island grammars, and disambiguate it, using term rewriting within the SPPF. In the future, this approach should be tested on other language combinations, such as Java+SQL and Java+XML. The ultimate goal is to provide a generic framework for language extensions. Using GLL to parse layout-sensitive languages, which is another difficult parsing topic, is another possibility for future work.\n\n11.3 Embedding Precedence and Associativity Rules Inside the Parser\n\nGrammars with recursive binary and unary operators, such as the grammar of mCRL2, considerably slow down the performance of parsing. For these specific ambiguities, which often occur in practice, we should try to perform the disambiguation while parsing, and disallow the accumulation of ambiguity nodes in the first place. One possible approach for disambiguating binary and unary operators while parsing is to use more look ahead symbols, i.e., implementing GLL(k) parsers. It is, however, not clear how more look ahead symbols will affect the complexity of GLL. Another possible approach is to internally transform the grammar of binary operators to an equivalent unambiguous grammar. This approach will produce different parse trees than expected by the user. Therefore, one should provide a mechanism to transform parse trees corresponding to unambiguous grammars into the parse trees of the original ambiguous grammar.\n\n11.4 Improving the Modularity in MEBNF\n\nAs discussed in Section 3.6, both modularity paradigms, importing with and without considering the namespace, have their own shortcomings. While importing by considering module names allows two nonterminals with the same name in two modules be totally separated, it does not allow grammar extension. On the other hand, importing without preserving the namespace, may lead to unexpected results, as the production rules of all nonterminals with the same name will be merged. A better approach may be the combination of these two import mechanisms, using separate import commands. Improving the modularity mechanism is of high priority in future work.\n11.5 Performance Improvements\n\nOur GLL implementation is not thoroughly optimized. Specifically, the SPPF construction phase has shown performance problems while constructing parse forests for fairly ambiguous grammars, e.g., for the grammar of mCRL2 which uses a considerable number of binary and unary operators. Moreover, we have not yet tested our GLL implementation with considerably large grammars, e.g., the grammar of Java. Such large grammars will likely cause performance problems, as their SPPF will grow very large. An important part of future work will be the optimization of our GLL implementation.\n\n11.6 Error Recovery for GLL Parsers\n\nChapter 4 introduces a simple error reporting mechanism, which works fairly well. The current mechanism can report the location of a parse error and the grammar pointer where the error occurred. The mechanism, however, provides no help in recovering from the error. A possible research path for the future can be the development of error recovery mechanisms for GLL parsers. In addition, a study should be conducted on the use of complex heuristics in detecting the location of parse errors.\n\n11.7 Improving the Eclipse Plugin for MEBNF\n\nThe Eclipse plugin presented in Chapter 9 is just a proof of concept, and not much effort has put into making it usable for production use. Moreover, some essential features such as hyperlinking and building is missing. With hyperlinking, the user can, for example, jump to a nonterminal definition by clicking on the nonterminal name in the body of a context-free rule. In addition, hyperlinking should support modularity, e.g., clicking on a nonterminal, defined in another module, should open the module and show the nonterminal definition. A building service for MEBNF can compile the parsed MEBNF files and provide semantic errors, e.g., reporting nonterminals which do not have a definition.\n\nA next step after completing the Eclipse plugin for MEBNF would be the automatic generation of Eclipse plugins for MEBNF grammars. A default set of features such as syntax highlighting and error reporting should be provided. In addition, the generated plugin should be easily customizable, so that the user can augment the generated plugin with language-specific features.\n11.8 Parse Tree Visualization in Eclipse\n\nIn order to make the process of developing languages easier, a parse tree visualization should be integrated into the Eclipse plugin for MEBNF. Currently, we generate a GraphViz dot [7] file from an SPPF and then manually generate a graph from the dot file. This process is slow, and more importantly, the produced graph is a large image, thus cannot be rearranged or filtered. It will be a very useful feature to provide an Eclipse-based SPPF visualization tool, capable of filtering nodes, e.g., removing layout nodes, showing ambiguity nodes, and rearranging SPPF nodes.\n\n11.9 Scala Support\n\nAs shown in Section 8.4, the SPPF mapping in Appendix B can be used to write arbitrary disambiguation or SPPF processing code in Tom. Tom is a very powerful term rewriting and pattern matching language. However, it is not a major language and not many developers know Tom. Moreover, the tooling for Tom is far from perfect. Scala, a Java Virtual Machine language, provides identical term rewriting features to Tom, and is becoming a mainstream language. It will be essential for the widespread usage of our workbench to provide Scala support, next to Tom and Java support, for SPPF processing.\nChapter 12\n\nConclusions\n\nIn this thesis we presented $\\mathcal{G}_\\text{text}$, a language workbench based on GLL and term rewriting. $\\mathcal{G}_\\text{text}$ is composed of three main components. The first component is the JGLL parser generator, introduced in Chapter 8, being used to generate Java-based GLL parsers. JGLL is based on the presented context-free syntax formalism, MEBNF, introduced in Chapter 3. The second component is the Eclipse plugin, presented in Chapter 9, providing an environment for editing MEBNF grammars. In the future, we plan to generate Eclipse plugins with a basic set of features, such as syntax highlighting, from an MEBNF specification. The third component of our language workbench is the mapping of concrete syntax to EMF models, through the annotations introduced in Chapter 10.\n\nThe main research question in this thesis was how to disambiguate an SPFF, produced by a GLL parser. In Chapter 5 we introduced our disambiguation mechanism which is based on rewriting within the parse forest, without modifications in the parser. We provided real-world hard cases which can be disambiguated with our technique in Chapter 6. To validate our disambiguation mechanism, we used three case studies in Chapter 7. The results of these case studies suggest that our disambiguation mechanism is suitable for ‘real’ languages with a reasonable number of ambiguities. With further optimizations in the parser, and embedding the priority and associativity rules within the parser, we expect to obtain performance improvements in the future.\n\n$\\mathcal{G}_\\text{text}$, as presented in this thesis, is a prototype of a language workbench, and there is still a long way to prepare it for production use. Nevertheless, this thesis provided the basis for developing a language workbench based on GLL. With work that will be done in the future, we hope that one day we introduce $\\mathcal{G}_\\text{text}$ as a mainstream language workbench.\nBibliography\n\n\nAppendix A\n\nMEBNF’s Concrete Syntax\n\n```plaintext\nmodule MEBNF\nimport Annotations\nimport Disambiguation\nimport Basics\n\nstart symbol Module\n\ncontext-free syntax\nModule ::= \"module\" ModuleName Import* StartSymbolSection? Section*\nImport ::= \"import\" ModuleName Retract* | \"import\" \"meta-model\" NameSpace \"=\" URI\nRetract ::= \"retract\" (ContextFreeRule | LexicalRule)*\nSection ::= LexicalSection | ContextFreeSection | DisambiguationSection\nStartSymbolSection ::= \"start\" \"symbol\" Nonterminal\nContextFreeSection ::= \"context-free\" \"syntax\" ContextFreeRule*\nContextFreeRule ::= Nonterminal \"::=\" Symbol (\"|\" Symbol*)\nSymbol ::= Symbol \"*\" | Symbol \"+\" | Symbol \"?\" | Keyword | Nonterminal | \"(\" Alt \")\"\nAlt ::= Alt \"|\" Alt | Symbol+\nLexicalSection ::= \"lexical\" \"syntax\" LexicalRule*\nLexicalRule ::= Nonterminal \"::=\" RegularExpression LexicalExclusion?\nLexicalExclusion ::= \"-/\" \"{\" RegularExpression (\",\" RegularExpression)* \"}\"```\n\n88\nListing A.1: The MEBNF module\n\nmodule Annotations\nimport Basics\nstart symbol Annotation\n\ncontext-free syntax\nAnnotation ::= Class | Attribute | Reference | DataType | Enum | Propagate\nClass ::= \"class\" \"(\" Name ( \":=\" Name )? \")\"\nAttribute ::= \"attribute\"\n \"(\" (LiteralAttribute | ReferenceAttribute | EnumAttribute) \")\"\nLiteralAttribute ::= Name \",\" String\nReferenceAttribute ::= Name \",\" Name\nEnumAttribute ::= Name \",\" Name \",\" Name ( \":=\" Name )* \":\" Name\nReference ::= \"reference\" \"(\" Name \",\" Name \")\"\n\n89\nListing A.2: The Annotations module\n\nmodule Disambiguation\nimport Basics\nstart symbol DisambiguationSection\ncontext-free syntax\nDisambiguationSection ::= \"disambiguation\" \"rules\" Rules*\nRule ::= \"remove\" PackedNode\n| \"prefer\" PackedNode \",\" PackedNode\nPackedNode ::= \"[\" (SymbolNode | Any) (\",\" (SymbolNode | Any) )* \"]\"\nSymbolNode ::= SymbolName\n| SymbolName \"(\" (SymbolNode | Any) (\",\" (SymbolNode | Any) )* \")\"\nlexical syntax\nAny ::= \\[\\]*\nSymbolName ::= String | Id\n\nListing A.3: The Disambiguation module\n\nmodule Priorities\nimport Basics\nstart symbol PrioritiesSection\ncontext-free syntax\nPrioritiesSection ::= \"associativity\" \"and\" \"priority\" Group*\nGroup ::= \"{\" (AssociativityGroup (\">\" AssociativityGroup)* )? \"}\"\nAssociativityGroup ::= (Modifier \":\" )? OperatorRule (\",\" OperatorRule)*\nOperatorRule ::= BinaryOperatorRule | LeftUnaryOperatorRule | RightUnaryOperatorRule\nBinaryOperatorRule ::= Head \":=\" Operand Operator? Operand\nLeftUnaryOperatorRule ::= Head \":=\" Operator Operand\nRightUnaryOperatorRule ::= Head \":=\" Operand Operator\nOperator ::= String | Id\nlexical syntax\nHead ::= Id\nOperand ::= Id\nModifier ::= \"left\" | \"right\"\n\nListing A.4: The Priorities Module\n\nmodule Basics\n\ncontext-free syntax\n\nlexical syntax\n\nId ::= [a-zA-Z][a-zA-Z0-9-__]*\nDigit ::= [0-9]*\nString ::= \"\\\"([\"\\\"\\r\\n\\t]+|[^\"\\r\\n\\t])\\\"[\"\\\"]\n\nListing A.5: The Basics module\nAppendix B\n\nTom mapping for SPPF\n\n```java\n%include {int.tom}\n%\ntypeterm SPPFNode {\n implement { nl.tue.win.set.jgll.sppf.SPPFNode }\n is_sort(t) { $t instanceof nl.tue.win.set.jgll.sppf.SPPFNode }\n equals(t1,t2) { ($t1.equals($t2)) }\n}\n%\n%op SPPFNode SymbolNode(name:String, children:NodeList) {\n is_fsym(t) { ($t instanceof nl.tue.win.set.jgll.sppf.SymbolNode) }\n get_slot(name,t) { ((SymbolNode)$t).getSymbolName() }\n get_slot(children,t) { ($t.getChildren()) }\n}\n%\n%op SPPFNode PackedNode(children:NodeList) {\n is_fsym(t) { ($t instanceof nl.tue.win.set.jgll.sppf.PackedNode) }\n get_slot(children,t) { ($t.getChildren()) }\n}\n%\n%op SPPFNode IntermediateNode(children:NodeList) {\n is_fsym(t) { ($t instanceof nl.tue.win.set.jgll.sppf.IntermediateNode) }\n get_slot(children,t) { ($t.getChildren()) }\n}\n%\ntypeterm NodeList {\n implement { java.util.List<nl.tue.win.set.jgll.sppf.SPPFNode> }\n is_sort(t) { $t instanceof java.util.List<?> }\n equals(l1,l2) { $l1.equals($l2) }\n}\n%\n%oplist NodeList concNode(SPPFNode*) {\n is_fsym(l) { ($l!= null) && ($l instanceof java.util.List<?>) }\n make_empty() { new java.util.LinkedList<nl.tue.win.set.jgll.sppf.SPPFNode>() }\n make_insert(o,l) { concListAppend($o,$l) }\n get_head() { $l.get(0) }\n get_tail() { concListgetTail($l) }\n is_empty() { ($l.size()==0) }\n}\n\nprivate static <T> java.util.List<T> concListAppend(T o, java.util.List<T> l) {\n```\njava.util.List<T> res = new java.util.LinkedList<T>(l);\nres.add(0, o);\nreturn res;\n}\n\nprivate static <T> java.util.List<T> concListGetTail(java.util.List<T> l) {\njava.util.List<T> res = new java.util.LinkedList<T>(l);\nres.remove(0);\nreturn res;\n}\nAppendix C\n\nAn Introspector for SPPF mapping\n\n```java\npackage nl.tue.win.set.jgll.sppf;\nimport tom.library.sl.Introspector;\n\npublic class SPPFIntrospector implements Introspector {\n\n @Override\n public Object getChildAt(Object o, int i) {\n return ((SPPFNode) o).getChildren().get(i);\n }\n\n @Override\n public int getChildCount(Object o) {\n return ((SPPFNode) o).getChildren().size();\n }\n\n @Override\n public Object[] getChildren(Object o) {\n return ((SPPFNode) o).getChildren().toArray();\n }\n\n @SuppressWarnings(\"unchecked\")\n @Override\n public Object setChildAt(Object o, int i, Object child) {\n return o;\n }\n\n @SuppressWarnings(\"unchecked\")\n @Override\n public Object setChildren(Object o, Object[] children) {\n return o;\n }\n}\n```\nAppendix D\n\nAn Ambiguous Pico Grammar in EBNF\n\n```\nmodule Pico\n\nimport meta-model pico = 'http://pico/1.0/base'\nimport meta-model ecore = 'http://www.eclipse.org/emf/2002/Ecore'\n\nstart symbol Program\n\ncategory context-free syntax\n\nProgram ::= \"begin\" \"declare\" (declarations:Declaration (\",\" declarations:Declaration)*)? \";\"; statements:Statement* \"end\"\n{\n class(pico::Program),\n reference(declarations, declarations),\n reference(statements, statements)\n }\n\nDeclaration ::= id:PicoID \":=\" expr:Expr \";\"\n{\n class(pico::Declaration),\n attribute(name, id),\n attribute(type, type)\n }\n\nPicoType ::= \"string\" { enum(pico::Types#Natural) } | \"natural\" { enum(pico::Types#MyString) } | \"\" | \"\" | \"\" | \"\" |\n\nStatement ::= id:PicoID \":=\" expr:Expr \";\"\n{\n class(pico::AssignStatement),\n attribute(name, id),\n reference(expression, expr)\n }\n\n| \"while\" \"(\" condition:Expr \")\" \"do\" body:Statement* \"end\"\n{\n class(pico::LoopStatement),\n reference(condition, condition),\n reference(body, body)\n\n```\nclass(pico::ConditionalStatement),\nreference(condition,condition),\nreference(trueBranch,if)\n}\n\n<table>\n<thead>\n<tr>\n<th>"if" "(" condition:Expr ")" "then" if:Statement* "end"?</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{</td>\n</tr>\n<tr>\n<td>class(pico::ConditionalStatement),</td>\n</tr>\n<tr>\n<td>reference(condition,condition),</td>\n</tr>\n<tr>\n<td>reference(trueBranch,if),</td>\n</tr>\n<tr>\n<td>}</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>"if" "(" condition:Expr ")" "then" if:Statement* "else" else:Statement* "end"?</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{</td>\n</tr>\n<tr>\n<td>class(pico::ConditionalStatement),</td>\n</tr>\n<tr>\n<td>reference(condition,condition),</td>\n</tr>\n<tr>\n<td>reference(trueBranch,if),</td>\n</tr>\n<tr>\n<td>reference(falseBranch,else),</td>\n</tr>\n<tr>\n<td>}</td>\n</tr>\n</tbody>\n</table>\n\nExpr ::= natcon:PicoNatCon\n{\n class(pico::pico_expressions::NaturalExpression),\n attribute(value,natcon)\n}\n\n<table>\n<thead>\n<tr>\n<th>strcon:PicoStrCon</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>{</td>\n</tr>\n<tr>\n<td>class(pico::pico_expressions::StringExpression),</td>\n</tr>\n<tr>\n<td>attribute(value,strcon)</td>\n</tr>\n<tr>\n<td>}</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>id:PicoID</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>{</td>\n</tr>\n<tr>\n<td>class(pico::pico_expressions::VariableReference),</td>\n</tr>\n<tr>\n<td>attribute(name,id)</td>\n</tr>\n<tr>\n<td>}</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>lhs:Expr operator:Plus rhs:Expr</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>{</td>\n</tr>\n<tr>\n<td>class(pico::pico_expressions::BinaryExpression),</td>\n</tr>\n<tr>\n<td>attribute(operator,operator),</td>\n</tr>\n<tr>\n<td>reference(lhs(lhs),lhs),</td>\n</tr>\n<tr>\n<td>reference(rhs,rhs)</td>\n</tr>\n<tr>\n<td>}</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>lhs:Expr operator:Minus rhs:Expr</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>{</td>\n</tr>\n<tr>\n<td>class(pico::pico_expressions::BinaryExpression),</td>\n</tr>\n<tr>\n<td>attribute(operator,operator),</td>\n</tr>\n<tr>\n<td>reference(lhs(lhs),lhs),</td>\n</tr>\n<tr>\n<td>reference(rhs,rhs)</td>\n</tr>\n<tr>\n<td>}</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>lhs:Expr operator:Concat rhs:Expr</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>{</td>\n</tr>\n<tr>\n<td>class(pico::pico_expressions::BinaryExpression),</td>\n</tr>\n<tr>\n<td>attribute(operator,operator),</td>\n</tr>\n<tr>\n<td>reference(lhs(lhs),lhs),</td>\n</tr>\n<tr>\n<td>reference(rhs,rhs)</td>\n</tr>\n<tr>\n<td>}</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>"(" expr:Expr ")"</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>{</td>\n</tr>\n<tr>\n<td>propagate(expr)</td>\n</tr>\n<tr>\n<td>}</td>\n</tr>\n</tbody>\n</table>\nPlus ::= \"+\" { enum(pico::pico_expressions::Operators#Addition) }\nMinus ::= \"-\" { enum(pico::pico_expressions::Operators#Subtraction) }\nConcat ::= \"||\" { enum(pico::pico_expressions::Operators#Concatenation) }\n\nPicoID ::= Id { type(ecore::EString) }\nPicoStrCon ::= StrCon { type(ecore::EString) }\nPicoNatCon ::= NatCon { type(ecore::EIntegerObject) }\n\nlexical syntax\nId ::= [A-Za-z][A-Za-z0-9]*\nNatCon ::= [0-9]*\nStrCon ::= [\"]([\"\\\"]|[^\"\\n])*[\"\\\"]\n\nlayout syntax\nWhitespace ::= [ \\t \\n \\r]+\nMultilineComment ::= [/\\n]*[^*/]+[^*/]+[/\\n]*\nSingleLineComment ::= [\\/*]/[^\\r\\n]*\n\ndisambiguation rules\nprefer [\"if\", \",\", Expr, \",\", \"then\", \",\", ]\n [\"if\", \",\", Expr, \",\", \"then\", \",\", \"else\", \",\", ]\nprefer [Statement(\"if\", \",\", Expr, \",\", \"then\", Statement), \",\",]\n [Statement(\"if\", \",\", Expr, \",\", \"then\", Statement, \",\", ]\n\nassociativity and priority\n{ left: Expr ::= Expr Concat Expr >\n left: Expr ::= Expr Minus Expr, Expr ::= Expr Plus Expr }\nFigure D.1: A metamodel for Pico\nAppendix E\n\nDisambiguation rules for mCRL2\n\ndisambiguation rules\n\nrem [ProcExpr(\"sum\", VarsDeclList, \".\", ProcExpr), \".\", ProcExpr]\nrem [ProcExpr(\"sum\", VarsDeclList, \".\", ProcExpr), @, DataExprUnit]\nrem [DataExpr(DataExpr, _, _, DataExpr), \"(\" DataExprList, \")\"]\nrem [DataExpr(\"lambda\", VarsDeclList, \".\", DataExpr), \"]\"]\nrem [ProcExpr(DataExprUnit, \"+\" ProcExpr), @, DataExprUnit]\nrem [ProcExpr(DataExprUnit, \"+\" ProcExpr), @, DataExprUnit]\nrem [DataExprUnit, \"+\" ProcExpr(ProcExpr, \"+\", ProcExpr)]\nrem [DataExprUnit, IfThen, ProcExpr(ProcExpr, \"+\", ProcExpr)]\nrem [DataExpr(\"!\", DataExpr), \"+\", DataExprList, \"]\"]\nrem [ DataExpr(\"#\", DataExpr), \"+\", DataExprList, \"]\"]\nrem [ProcExprNoIf(\"sum\", VarsDeclList, \".\", ProcExprNoIf), \"+\", ProcExprNoIf]\nrem [DataExpr(DataExpr, _, _, DataExpr), \"whr\", AssignmentList, \"end\"]\nnull\nleft: ProcExpr ::= ProcExpr \"<<\" ProcExpr >\nright: ProcExpr ::= ProcExpr \"||\" ProcExpr,\n ProcExpr ::= ProcExpr \"||_\" ProcExpr >\nleft: ProcExpr ::= ProcExpr \"+\" ProcExpr\n }\n\n{ left: ProcExprNoIf ::= ProcExprNoIf \"|\" ProcExprNoIf >\nright: ProcExprNoIf ::= ProcExprNoIf \".\" ProcExprNoIf >\nleft: ProcExprNoIf ::= ProcExprNoIf \"<<\" ProcExprNoIf >\nright: ProcExprNoIf ::= ProcExprNoIf \"||\" ProcExprNoIf,\n ProcExprNoIf ::= ProcExprNoIf \"||_\" ProcExprNoIf >\nleft: ProcExprNoIf ::= ProcExprNoIf \"*\" ProcExprNoIf\n }\n\n{ BesExpr ::= \"!\" BesExpr >\nright: BesExpr ::= BesExpr \".&\" BesExpr >\nright: BesExpr ::= BesExpr \"||\" BesExpr >\nright: BesExpr ::= BesExpr \"=>\" BesExpr\n\n{ PbesExpr ::= \"!\" PbesExpr >\nright: PbesExpr ::= PbesExpr \"||\" PbesExpr >\nright: PbesExpr ::= PbesExpr \".&\" PbesExpr >\nright: PbesExpr ::= PbesExpr \"=>\" PbesExpr\n }\n\n{ ActFrm ::= \"!\" ActFrm >\nright: ActFrm ::= ActFrm \"||\" ActFrm >\nright: ActFrm ::= ActFrm \"&&\" ActFrm >\nright: ActFrm ::= ActFrm \"=>\" ActFrm\n }\n\n{ RegFrm ::= RegFrm \"+\", RegFrm ::= RegFrm \"*\" >\nleft: RegFrm ::= RegFrm \"+\" RegFrm >\nright: RegFrm ::= RegFrm \".\" RegFrm\n }\n\nStateFrm ::= \"!\" StateFrm >\nright: StateFrm ::= StateFrm \"&&\" StateFrm >\nright: StateFrm ::= StateFrm \"||\" StateFrm >\nright: StateFrm ::= StateFrm \"=>\" StateFrm\n}\n\nAppendix F\n\nAn MEBNF grammar for Tom\n\nmodule Tom\n\nstart symbol Program\n\nclass-free syntax\n\nProgram ::= Chunk*\n\nChunk ::= Water | Island\n\nWater ::= \"{\" Chunk* \"}\" | Identifier | Integer | String | Character | SpecialChar | SpecialChar2 | CamlChar | \",\" | \".\" | \")\" | \")\"\n\nIsland ::= TomConstruct | BackQuoteTerm\n\nTomConstruct ::= IncludeConstruct |\n MatchConstruct |\n GomConstruct |\n StrategyConstruct |\n OperatorConstruct |\n OperatorListConstruct |\n OperatorArrayConstruct |\n TypeTermConstruct |\n MetaQuoteConstruct\n\nIncludeConstruct ::= \"%include \"{\" Water* \"}\"\n\nBackQuoteTerm ::= \"'\" CompositeTerm | \"'\" \"(' CompositeTerm+ \")\"\n\nCompositeTerm ::= VariableStar |\n Variable |\n Identifier \"(\" (CompositeTerm+ (\",\" CompositeTerm+)? \"\")\" |\n \".\" Identifier \"(\" CompositeTerm+ \")\"\n\nBackQuoteWater ::= Identifier | Integer | String |\n Character | SpecialChar | SpecialChar2 | CamlChar\nMatchConstruct ::= \"%match\" (\"(\" MatchArguments \")\")? \n\"(\" PatternAction \")\"\n\nMatchArguments ::= Type? Term (\";\" Type? Term)*\n\nPatternAction ::= PatternList \":=\" \n\"(\" Chunk* \")\"\n\nConstraintAction ::= Constraint \":=\" \n\"(\" Chunk* \")\"\n\nTerm ::= Identifier\n| VariableStar\n| Identifier (\"( Term (\",\" Term)* )? \")\"\n\nGomConstruct ::= \"%gom\" (\"(\" Water* \")\")? \n\"(\" GomGrammar \")\"\n\nGomGrammar ::= Module\n\nModule ::= \"module\" ModuleName Imports? Grammar\nImports ::= \"imports\" ModuleName+\n\nGrammar ::= \"abstract\" \"syntax\" (TypeDefinition | HookDefinition)*\n\nTypeDefinition ::= SortName \"=\" OperatorDefinition (\"|\" OperatorDefinition)*\nOperatorDefinition ::= OperatorName (\"(\" SlotDefinition (\"|\" SlotDefinition)* \")\")\n| OperatorName (\"( Variable \"=\"\")\")\n\nSlotDefinition ::= SlotName (\"=\" SlotName)\n\nHookDefinition ::= HookType \"=\" HookOperation\n\nHookType ::= OperatorName\n| \"module\" ModuleName\n| \"sort\" SortName\n\nHookOperation ::= \"make\" (\"(\" (Identifier (\";\" Identifier)* \")\")? \")\" \n\"(\" Chunk* \")\"\n| \"make_insert\" (\"(\" Identifier \";\" Identifier \")\") \n\"(\" Chunk* \")\"\n| \"make_empty\" (\"(\" \")\") \n\"(\" Chunk* \")\"\n| \"Free\" (\"(\" \")\")\n| \"FL\" (\"(\" \")\")\n| (\"AU\" | \"ACU\") (\"(\" \")\") (\"(\" Term? \")\")\n| \"interface\" (\"(\" \")\") (\"(\" Identifier (\";\" Identifier)* \")\")\n| \"import\" (\"(\" \")\") (\"(\" Water* \")\")\n| \"block\" (\"(\" \")\") (\"(\" Chunk* \")\")\n| \"rules\" (\"(\" \")\") (\"(\" RulesCode \")\")\n| \"graphrules\" (\"(\" Identifier \";\" (\"Identity\" (\"|\" \"Fail\")\")\") \"(\" GraphRulesCode \")\")\n\nRulesCode ::= Rule*\n\nRule ::= Pattern \":=\" Term (\"if\" Condition)?\n\nPattern ::= (AnnotatedName \"@\")? PlainPattern\nPlainPattern ::= (\"!\" (Variable | VariableStar | ConstantValue)\n| \"!\" HeadSymbolList (\"(\" Pattern (\";\" Pattern)* \")\")\")\n\nGraphRulesCode ::= GraphRule*\n\nGraphRule ::= TermGraph \":=\" TermGraph (\"if\" Condition)\nTermGraph ::= (Label \":\")? TermGraph\n | \"&\" Label\n | Variable \"*\"\n | HeadSymbolList \"(\" (TermGraph (\",\" TermGraph)* )? \")\"\n\nCondition ::= \"{\" Condition \"}\"\n | Condition \"!!\" Condition\n | Condition \"&&\" Condition\n | Pattern \"<<\" Term\n | Term Operator Term\n\nOperatorConstruct ::= \"(op)\" Type Name \n | SimpleOperator Construct\n | Constructor\n\nSimpleOperator Construct ::= \"%op\" Type Name \"(\" (SlotName \":\" Type (\",\" SlotName \":\" Type)* )? \")\"\n | OperatorList Construct\n | OperatorArray Construct\n\nOperatorList Construct ::= \"(oplist)\" Type Name \"(\" Type \"*\" \")\"\n | Constructor\n\nOperatorArray Construct ::= \"(oparray)\" Type Name \"(\" Type \"*\" \")\"\n | Constructor\n\nKeywordIsFsym ::= \"is_fsym\" (\" Name \") \"{ Water+ \"}\nKeywordGetSlot ::= \"get_slot\" (\" Name \",\" Name \") \"{ Water+ \"}\nKeywordGetDefault ::= \"get_default\" (\" Name \") \"{ Water+ \"}\nKeywordMake ::= \"make\" (\" C Name \",\" Name \")? \"{ Water+ \"}\nKeywordGetHead ::= \"get_head\" (\" C Name \") \"{ Water+ \"}\nKeywordGetTail ::= \"get_tail\" (\" C Name \") \"{ Water+ \"}\nKeywordMakeEmptyList ::= \"make_empty\" (\" ( ) \")? \"{ Water+ \"}\nKeywordMakeInsert ::= \"make_insert\" (\" C Name \",\" Name \") \"{ Water+ \"}\nKeywordGetElement ::= \"get_element\" (\" C Name \",\" Name \") \"{ Water+ \"}\nKeywordGetSize ::= \"get_size\" (\" C Name \") \"{ Water+ \"}\nKeywordIsEmpty ::= \"is_empty\" (\" Name \") \"{ Water+ \"}\nKeywordMakeEmptyArray ::= \"make_empty\" (\" C Name \") \"{ Water+ \"}\nKeywordMakeAppend ::= \"make_append\" (\" C Name \",\" Name \") \"{ Water+ \"}\n\nTypeTerm Construct ::= \"%typeterm\" Type (\"extends\" Type)?\n | Constructor\n\nKeywordImplement ::= \"implement\" \"{ Water+ \"}\"\nKeywordIsSort ::= \"is_sort\" \"(\" Name \")\" \"{\" Water+ \"}\"\nKeywordEquals ::= \"equals\" \"(\" Name \",\" Name \")\" \"{\" Water+ \"}\"\nStrategyConstruct ::= \"strategy\" StrategyName \"(\" StrategyArguments? \")\"\n \"extends\" \"\"? Term \"{\" StrategyVisit* \"}\"\nStrategyArguments ::= SubjectName \":\" AlgebraicType (\" \", SubjectName \":\" AlgebraicType)*\n | AlgebraicType SubjectName (\",\" AlgebraicType SubjectName )* \nStrategyVisit ::= \"visit\" AlgebraicType \"{\" VisitAction* \"}\"\nVisitAction ::= (Label \":\")? PatternList \"->\" \"{\" Chunk* \"}\"\nPatternList ::= Pattern (\",\" Pattern)* ((\"&&\" | \"||\") Constraint)?\nConstraint ::= Pattern \"\\<<\" Type Term\n | Constraint \"&\" Constraint\n | Constraint \"||\" Constraint\n | \"{\" Constraint \"}\"\n | Term Operator Term\nHeadSymbolList ::= HeadSymbol ?\n | \"(\" HeadSymbol (\"!\" HeadSymbol )+ \")\"\nExplicitTermList ::= \"(\" Pattern (\",\" Pattern)? \"\")\"\nImplicitPairList ::= \"[\" (PairPattern (\",\" PairPattern)? \"]\"\nPairPattern ::= Identifier \"=\" Pattern\nConstantValue ::= String\n | Integer\n | Character\n | Float\nMetaQuoteConstruct ::= \"\\\\[\" Chunk \"\\]\\\"\n\nlexical syntax\n\nStrategyName ::= Identifier\nAlgebraicType ::= Identifier\nType ::= Identifier\nVariable ::= Identifier\nModuleName ::= Identifier\nSortName ::= Identifier\nAnnotatedName ::= Identifier\nSubjectName ::= Identifier\nLabel ::= Identifier\nOperatorName ::= Identifier\nName ::= Identifier\nSlotName ::= Identifier\nVariableStar ::= Identifier \"*\"\nHeadSymbol ::= Identifier | Integer | Float | String | AnyChar\nSpecialChar ::= \n | | \n | \n | \nCanlChar ::= Identifier \"\\\"\"\nSpecialChar2 ::= [*/\\]+ -/- { \"//\"* , \"/*\"*, \"*/\"* } \nOperator ::= \n | \"=\" | \"==\" | \"<\" | \"<=\" | \"<\" | \"&&\" | \"||\" |\nIdentifier ::= [a-zA-Z0-9-]*[a-zA-Z0-9-]* \nString ::= [\"]([\"\\\\\\]\\])\\[\"trnu\\]\\]\"[\"]\nCharacter ::= [''] ['\\'] | [''] ['\\'] EscapeChar ['']\nEscapeChar ::= [btnfr`\\\\]\nAnyChar ::= .\nInteger ::= [0-9]+\nFloat ::= [1-9]+[.][0-9]+\n\nlayout syntax\nWhiteSpace ::= [\\ \\r \\n \\t]+\nMultilineCommentCStyle ::= [/[*][^[/*][^/*]][*]+[/]\nMultilineCommentCamlStyle ::= [([/*][/*][/*]][*]+[/]\nSingleLineComment ::= [/[/][^r\n]*\n\ndisambiguation rules\nprefer Chunk(Island)], [Chunk(Water), _*]\nprefer [Variable], [BackQuoteWater]\nprefer Chunk(Island(BackQuoteTerm)),\n [Chunk(Island(BackQuoteTerm)), Chunk(Water(\"\")))]\nprefer Chunk(Island(BackQuoteTerm)),\n [Chunk(Island(BackQuoteTerm)), Chunk(Water(\"(\"))]"}}},{"rowIdx":167,"cells":{"id":{"kind":"string","value":"74ccdcfccbc5681ee93de5d9f6b381dce82a8a3e"},"text":{"kind":"string","value":"Joel is managing a project. The project is about three fourths done when the site engineer reports that due to inherent complexities in a certain task the deliverables would get delayed. This would involve additional analysis and then implementation. He requests that this new work that was not envisioned earlier be added to the scope and also the time required be added to the schedule. You and the site engineer have analyzed the impact of this change to cost, and have written up a change request and requested approval from change control board. Just today you have received approval from the change control board - what should be the immediate course of action?\n\nA. Start work immediately\n\nB. Ascertain the impact of this change to scope, schedule and cost before making any change.\n\nC. Perform Quality Assurance\n\nD. Make sure that the scope baseline and schedule baseline are updated to reflect the approved change before implementing the change.\n\nD is the correct answer.\n\nAs the change has been approved you should always update the baseline (in this case the scope and schedule baseline) before implementing the change. This will ensure that you track performance against the new scope and schedule and not the old benchmarks.\n\nQuestion - 2\n\nYou are in charge of managing a software development project which is related to simulations for driving racing cars. In one of your team meetings - it has been reported that a lot of issues have been reported in the air tunnel modelling module. On deeper analysis - it is found that many\nof the issues could have been prevented had a simple code review checklist been used. You\nprepare a code review checklist and ensure the code is reviewed as per the checklist. This is a\ngood example of:\n\nA. Corrective Action\nB. Preventive Action\nC. Defect Repair\nD. Quality Control\n\nA is the correct answer.\n\nThis question is meant to test your understanding of the difference between what corrective\naction and preventive action is. Defect repair might sound tempting - but it is only applicable for\nthe issues found for the current delivery. This is also not about Quality Control - so that leaves us\nwith only two options - Corrective or Preventive actions. Corrective actions are always preceded\nby nonconformity while preventive actions are never preceded by nonconformity. In this case\nnonconformity in the form of a lot of issues during Quality Assurance were reported. The root\ncause was identified to be the need of a standard checklist which was then used. Preventive action\nis always taken proactively - in the question stated there is no demonstration of any proactive\nsteps taken - hence this is not an example of Preventive action. The correct answer is option A -\nCorrective action\n\nQuestion - 3\n\nWhich of the following statements are not true regarding Network Diagrams?:\n\nA. Network Diagrams determine risks and causes of issues as they occur.\nB. Network diagrams are used to show interdependencies of all activities.\nC. Network diagrams depict the workflow so everyone knows the sequence in which activities\n need to be performed\nD. They help plan, organize and control the project and can help track schedule progress\n\nA is the correct answer.\n\nThe correct answer is A - All the other statements are valid regarding Network Diagrams.\nQuestion - 4\n\nYou have replaced an earlier project manager in a project. The earlier project manager has left the organization and you are now responsible for the project. On reviewing the project management plan you are disturbed because a number of procurement contracts have been signed and they all turn out to be Cost plus fixed fee types of contracts - why are you worried?\n\nA. All the risk is now with the seller\nB. Contracts should always be T and M\nC. Seller has no motivation to control cost and in fact cost could spiral\nD. Contracts should always be Fixed Price\n\nC is the correct answer.\n\nAs a project manager - you indeed have a reason to be worried if your project has already signed off on Cost Plus Fee type of contracts. This is because in such contracts - you the buyer needs to pay the seller for all the costs and in addition an agreed percentage of the cost. As a result there is no motivation on the seller to control the costs - in fact it is in the interest of the seller to increase the costs. It is not necessary that all projects should always be T and M or Fixed Price. Option A is clearly wrong since all the risks are in fact with the buyer not the seller! The correct answer is Option C\n\nQuestion - 5\n\nYour team is in its second month of development. You are managing a software development project for a banking product. In one of the team meetings a debate arises if defects found during Quality control need to undergo change control. Some team members are convinced that all defects should undergo change control while the other half is convinced that defects do not need to undergo change control. Which of the following statements are untrue?\n\nA. Defects to deliverables need to undergo change control\nB. Defects to deliverables need not undergo change control\nC. Corrective actions need to undergo change control\n\nA. Defects to deliverables need to undergo change control\n\nB. Defects to deliverables need not undergo change control\n\nC. Corrective actions need to undergo change control\nD. Preventive actions need to undergo change control\n\nB is the correct answer.\n\nDefects to deliverables, corrective actions and preventive actions - all of these need to undergo change control. So all the above statements are true except option B\n\nQuestion - 6\n\nYou are responsible for managing a project that deals with laying out a freeway connecting two major port cities. Progress on the project has been smooth and you and your team are very confident on completing the project well within the stipulated timelines. On reviewing you see that the project has also run below the budget resulting in savings. You decide to add an extra feature of reflector strips on the road every mile. You do a quick calculation and are satisfied that neither budget nor schedule will slip. You feel that by adding these extra features you could also bag some future projects as well. This is an example of:\n\nA. Scope Creep\nB. Gold Plating\nC. Integrated Change Control\nD. Fast Tracking\n\nB is the correct answer.\n\nThis is an example of Gold Plating. Integrated change control deals with formally approving or rejecting changes before they are implemented so it is not the correct answer. Fast tracking is a schedule compression technique - so it too is not the correct answer. While Scope Creep is related to change in scope it is related to uncontrolled changes in product or projects scope and is often due to client interference. Gold plating is done intentionally or knowingly for some strategic purpose. Here the manager believes that by adding the extra features future projects could be bagged.\n\nQuestion - 7\n\nYou are in charge of a project that deals with laying out a lavish 18 hole golf course. The project\nwork is in progress. You also have a number of contractors working on the project. Being an experienced manager you know that communication is key to success of the project. You have identified 10 stakeholders with whom you need to communicate. Due to some internal and external organizational changes at the client end three new stakeholders have been added with whom you need to communicate with. You also had to reduce one of the contractors with whom you were communicating. How many communication channels do you have now?\n\nA. 45\nB. 78\nC. 91\nD. 66\n\nD is the correct answer.\n\nOriginally you had 10 stakeholders to communicate with so number of communication channels were $10 \\times (10-1)/2 = 45$. However the question states that 3 new stakeholders got added while 1 stakeholder got reduced. So total number of stakeholders = $10 + 3 - 1 = 12$. So the total number of communication channels are $(12 \\times (12-1))/2 = 66$. So the correct answer is option D.\n\nQuestion - 8\n\nYou are in charge of a project and to ensure things go well you have had monthly meetings with the stakeholders. The project is running on schedule and budget. You are in your fourth month of execution but the stakeholder indicates dissatisfaction with the deliverables. To make changes in the deliverables would mean a delay in the schedule. What would have been the most important process that could have prevented this situation?\n\nA. Scope Planning\nB. Scope Control\nC. Schedule Control\nD. Risk Monitoring and Control\n\nA is the correct answer.\nThe most important process that could have prevented this situation would have been - Scope Planning. Project deliverables are defined during scope planning so proper implementation of this process could have prevented this situation.\n\nQuestion - 9\n\nThe project that you are in charge has been successfully completed. The last of the deliverables have been formally accepted by the client. You had several contractors with whom contracts were prepared. With the project done you decide to communicate the completion details and closure of contracts. Which is the best form of communication?\n\nA. Formal written\nB. Formal verbal\nC. Informal verbal\nD. Informal written\n\nA is the correct answer.\n\nAs this is related to a contract it must be a formal written form of communication. Any other form of communication related to contracts is not acceptable.\n\nQuestion - 10\n\nYour company has bagged a number of government contracts dealing with setting up infrastructure. This includes setting up roads and bridges. This is a very big and prestigious project so your company would like to ensure everything is planned well in advance. You are the project manager of this project. Considering its importance - you and your team come up with a list of risks. One of the subject matter experts indicates that during the months of July and August the construction work of the bridge across the river would need to stop on account of past history of flooding of the river. You agree with the expert and plan the schedule accordingly. What strategy did you just apply?\n\nA. Accept\nB. Exploit\nC. Mitigate\nD. Transfer\n\nA is the correct answer.\n\nThis is an example of Risk acceptance strategy as there is nothing you can do about situations not in our control. Exploit is meant for positive situations while risk mitigation is where you have a strategy to either reduce the risk impact or probability. Neither is transfer correct as the question does not state that someone else will be responsible for handling the risk.\n\nQuestion - 11\n\nYou are in the process of defining activities and have broken down the WBS into individual activities. You now decide to uniquely tag each activity with a unique code. So here what you have done is defined an ___ for each Activity\n\nA. Schedule Network Diagram\nB. Activity List\nC. Milestone List\nD. Activity Identifier\n\nD is the correct answer.\n\nThe correct option is D - Activity Identifier. The question states that we have decided to uniquely tag each identified activity - which is nothing but Activity Identifier. This is done during creation of the Activity List.\n\nQuestion - 12\n\nYou are managing a project that has teams located in different parts of the world. While the advantage of colocation is beneficial - the team structure or locations cannot be changed. Being an experienced manager that you are - you realize that without a proper communication channel can quickly lead to chaos. What would your choice of communication be?\nA. Formal and Verbal\nB. Formal and Written\nC. Informal and written\nD. Informal and Verbal\n\nB is the correct answer.\n\nConsidering cross located teams and difference in cultures involved the best choice of communication in this case would be formal and written.\n\nQuestion - 13\n\nRather than use Triangular Distribution while doing Three Point Estimation you choose to use Beta Distribution. Based on your analysis and understanding you are confident that the project would be completed with a total cost of 108,000 $. You also estimate that a best case estimate would be 90000 $ while a worst case scenario would result in the costs incurred to shoot up to 138000 USD. What would the Three point Cost estimate be using Beta Distribution?\n\nA. 112000 $\nB. 110000 $\nC. 101000 $\nD. None of the above\n\nB is the correct answer.\n\nThe correct answer is B. The question states we should use Three point estimate using Beta distribution. The formula for this estimation technique is $4a + b + c / 6$ where $a =$ Most Likely estimate, $b =$ Estimate based on Best case scenario and $c =$ Estimate based on Worst case scenario. So the Three point estimate using Beta distribution is $(4 \\times 108000) + 90000 + 138000 / 6 = 660000/6 = 110000 \\$$\n\nQuestion - 14\nYou are developing strategies to effectively engage stakeholders throughout the project life cycle. What is process you are working on?\n\nA. Plan Stakeholder Management\nB. Identify Stakeholders\nC. Manage Stakeholder Engagement\nD. Control Stakeholder Engagement\n\nA is the correct answer.\n\nPlan Stakeholder Management is the process to develop strategy to effectively engage stakeholders throughout the project life cycle.\n\nQuestion - 15\n\nYou head the engineering department in your company. Lately you have observed that certain deliveries are missing the schedule. On closer scrutiny you observe this to be occurring with a specific team member. You decide to discuss it out with the team member. Initially the team member is reluctant to discuss but finally opens up and indicates that the cause of the delays is often different instructions coming in from you as well as the project manager. She indicates that at such times she is confused related to whose instructions to follow - thereby causing delays - what kind of an Organizational structure is this most likely to be?\n\nA. Functional\nB. Projectized\nC. Weak Matrix\nD. Balanced Matrix\n\nD is the correct answer.\n\nHere the team member is being expected to follow instructions from both the Project Manager and the Functional Manager. This is never the case in a Functional or Projectized organization where the lines of authority are clearly defined. A weak matrix organization is more like a Functional Organization where the project manager has almost no authority. The scenario\nexplained above is typical of a balanced matrix organization where power resides equally distributed between the functional and project manager. Here the correct answer is Option D - Balanced Matrix\n\nQuestion - 16\n\nThe release criteria includes:\n\nA. the timing of the release of team members\nB. the method in which you will release them\nC. Both of the above are true\nD. None\n\nC is the correct answer.\n\nC is the correct answer. The release criteria include both the timing of the release of team members and the method in which you will release them.\n\nQuestion - 17\n\nAs a project manager you have successfully delivered all project deliverables within stipulated timelines - your senior management wants you to calculate the Cost of Quality - as a project Manager what costs would you NOT consider while making this calculation ?\n\nA. Cost of Hiring.\nB. Prevention costs.\nC. Appraisal costs.\nD. External and Internal Failure costs.\n\nA is the correct answer.\nAll of the above are correct - except option A - since Hiring Costs have nothing to do with Cost of Quality. prevention and Appraisal Costs are the expenditures during the project to AVOID failures while Internal and External Failure Costs are those incurred during and after the project BECAUSE of failures.\n\nQuestion - 18\n\nWhich of the following is part of the Perform Quality Assurance process?\n\nA. Benchmarking\nB. Cost of Quality\nC. Design of experiments\nD. Quality audits\n\nD is the correct answer.\n\nQuality audits are part of the Perform Quality Assurance process.\n\nQuestion - 19\n\nYou are the project manager for a Project. You are updating the WBS during Define Activities, which is often called ________?\n\nA. Refinements\nB. Updates\nC. Activities\nD. Supporting detail\n\nA is the correct answer.\n\nA is the correct answer. updating the WBS during Define Activities, is often called Refinements. It occurs with riskier projects.\nQuestion - 20\n\nThe Project Quality Management process must __________.\n\nA. Address the quality of the management and product\nB. Improve the project management and the quality of the product\nC. Ensure that the project satisfies customer requirements\nD. All of the above\n\nD is the correct answer.\n\nProject Quality Management: Addresses both the management of the project and of the product of the project, Improves project management as well as the quality of the product, Delivery of both high quality and high grade of product, Quality is planned in, not inspected in, Ensures that the project will satisfy customer requirements.\n\nQuestion - 21\n\nYou are a project manager of a company and your project is currently in execution phase. The customer has requested you for additional work. This work will affect the budget, but not the schedule of the project. What should you do next?\n\nA. Add the additional requirements to the project plan.\nB. Ignore the request.\nC. Explain the change procedure and ask to submit a request for change.\nD. Discuss with the project team about the change.\n\nC is the correct answer.\n\nExplain the change procedure and ask to submit a request for change is the best choice.\nQuestion - 22\n\nYou are the project manager and have decided to outsource a part of the project to a vendor. You have offered a bonus to the vendor if the work is completed in two months. This is an example of ____________.\n\nA. project incentive\nB. project goal\nC. fixed price contract\nD. None\n\nA is the correct answer.\n\nThis is an example of project incentive.\n\nQuestion - 23\n\nYou and your team have just created a schedule network diagram. You have come up with the estimates and have defined the durations and subsequently have identified the Critical Path. You now decide to do a 'Backward Pass' through the Schedule Network Diagram - what would you be calculating?\n\nA. The Early Start and Early Finish for each activity\nB. The Late Start and Late Finish for each activity\nC. The duration of the other paths\nD. The duration of the critical path\n\nB is the correct answer.\n\nThe correct answer is - B. Option C and D are incorrect as the Backward Pass is not used to calculate the duration. In fact, based on duration, the critical path is calculated. Option A talks about\nEarly Start and Early Finish - which are calculated using 'Forward Pass'. Using 'Backward Pass' - we calculate the Late Start and Late Finish of all the activities in the network diagram.\n\nQuestion - 24\n\nOf the following types of contracts - which has the HIGHEST risk for the seller?\n\nA. Cost plus fixed fee - CPFF\nB. Time and Material - T and M\nC. Firm Fixed Price Contract - FFP\nD. Cost plus Incentive fee - CPIF\n\nC is the correct answer.\n\nThe riskiest for the seller in the options stated above is - Firm Fixed Price Contract - FFP. This is because it's a Fixed price contract in which total costs are fixed - the scope of work is clearly defined and stated. Cost-reimbursable contracts are the least risky for the seller since the costs are not fixed and paid at actuals. Time and material have medium risk from the perspective of the buyer and seller and are typically used for smaller dollar amounts. The correct answer is option C.\n\nQuestion - 25\n\nWhat is the BEST use of a Work Authorization System?\n\nA. It manages the timing and sequence of when activities need to be performed\nB. It manages who performs the activity\nC. It identifies the resources needed to complete activities\nD. It is used for comparing actual work against the baselines\n\nA is the correct answer.\nIt defines how work will be authorized and how work will be done at the right time and in the right sequence. Option B is not correct since who performs the work comes from the responsibility assignment matrix and neither is option C the right answer. Option D is related to monitoring and controlling work performace data which is not covered by Work Authorization System - so - option A is the correct answer.\n\nQuestion - 26\n\nYou are in charge of a software project and you are almost 40% complete. The project stakeholders want a performance report to date. You had planned to use Earned Value Management methodology. You come up with the following numbers: EV = 100 AC = 300 PV = 150 BAC = 600 You and your team have faced numerous issues till now. However you choose to ignore the current work performance and decide to go with what was originally planned. Based on this information what would be the EAC for the project?\n\nA. 800\nB. 200\nC. 600\nD. 1800\n\nA is the correct answer.\n\nThe correct answer is A - this is because here it is stated that whatever issues or lack of them experienced in the project were ignored - so here the past performance is not considered while the planned values are considered. So the formula: EAC = AC + ( BAC - EV ) = 300 + ( 600 - 100 ) EAC = 800\n\nQuestion - 27\n\nYour team has delivered phase one to the client. Based on client feedback and issues found by client - you decide to do some introspection to identify root causes so that the subsequent deliverables do not face the same issues. What techniques would you choose to apply?\n\nA. Perform Quality Audits\nB. Review Activity Network Diagrams\nC. Lookup Process decision program charts\n\nD. Process Analysis\n\nD is the correct answer.\n\nQuality Audits are meant to ascertain if the project activities confirm to the policies and procedures - so it is not the correct answer. Activity Network diagrams are used for scheduling while Process decision program charts are used to anticipate intermediate steps. The correct answer is Process Analysis - which is used to identify a problem, identify the cause of the problem and develop preventive actions.\n\nQuestion - 28\n\nOver lunch you meet a colleague who is managing a large turnover project for setting up a chemical plant. Your colleague is worried because the client is being unreasonable and asking for changes that will have a severe impact to the scope schedule and also cost. The client is also not ready to absorb the additional impact to schedule and cost. She seeks your advise - what should she do?\n\nA. Refuse to budge and not make any changes\n\nB. Request her executive management to initiate legal action against the client\n\nC. Ultimately the customer is always right - so go ahead and make the changes and absorb the impact to cost, schedule and scope\n\nD. Set up a meeting with the client to better understand the need of the changes being asked for\n\nD is the correct answer.\n\nWhy is the client being unreasonable? Why does the client want to make these changes? Obviously your colleague is in a tough situation and not in a nice place to be. However tough the problem - a project manager must not act impulsively by seeking legal action or refuse or immediately start making the changes. Whenever faced with a problem a project manager should first try and find the root cause and not react. So in this case the best advise would be for your colleague to set up a discussion with the client and try and understand the needs of the client for asking for the change is causing\nQuestion - 29\n\nYou are managing a project to set up a brand new play area for the community. You and your team have been working as per plan and things are moving smoothly. Suddenly one of the stakeholders indicates that the play area must also include a sand pit. This was not originally planned for so you analyze the impact to the cost, schedule and scope. You then submit the change request to the Change control board for their approval. You have immediately received an approval - what should your next step be?\n\nA. Get the work done immediately and start executing\nB. Update the impacted baselines - scope, cost and schedule\nC. Update the work performance reports and share with stakeholders\nD. Setup a meeting with the change control board\n\nB is the correct answer.\n\nOnce you have created the change request and submitted for approval - you don't need to set up a separate meeting with the change control board - unless asked for. Work performance reports will be shared as per agreed frequency - however it is irrelevant to the question. You might be tempted to jump in and start work immediately - but the first thing that should be done is to update the impacted baselines. In this case all the three baselines - this is necessary to ensure that performance information is tracked against the new baselines and not the old ones - the correct answer is option B.\n\nQuestion - 30\n\nAs a project manager - you are expected to calculate the cost of Poor Quality - the project work is in progress - what costs would you consider?\n\nA. Cost of Hiring.\nB. Prevention costs.\nC. Appraisal costs.\nD. External and Internal Failure costs.\nD is the correct answer.\n\nCost of Hiring has nothing to do with cost of Poor Quality - so it is not the correct answer. Cost of Poor Quality is just another term for Failure Costs. Failure Cost is generally categorized into External and Internal Failure costs - so option D is correct. Prevention and Appraisal costs are actually costs of conformance - which is the cost incurred to avoid failures - so these are not considered as cost of Poor Quality.\n\nQuestion - 31\n\nYou are in charge of building a bridge across a river. All the initial groundwork and structural designs have been completed and work is in progress. You know that the next two months will be particularly critical involving some critical activities such as Arc welding of stiffener plates. You know your company employs welders who specialize in this kind of work. However you are apprehensive regarding their availability for the next two months. What should you refer to first to find if these welders are available for the next two months?\n\nA. Milestone List\nB. Pareto Chart\nC. Histograms\nD. Resource Calendars\n\nD is the correct answer.\n\nThe correct answer is - Resource Calendars. Resource Calendars provide information regarding availability of resources and also the duration of their availability so referring to this document would be the first course of action.\n\nQuestion - 32\n\nYou and a group of managers who conduct a weekly meeting for sharing information and project management best practices. Joe who is a colleague of yours explains the need of correctly identifying all the project stakeholders. He explains that in his current project he has made use of Stakeholders Engagement Assessment Matrix. Many of the other colleagues are not quite aware\nof the need and usage of this matrix - which of the following is the BEST choice?\n\nA. Lists all the stakeholders along with their current engagement and desired engagement\n\nB. Lists all the stakeholders\n\nC. Lists only those stakeholders who are Resistant\n\nD. Lists only those stakeholders who are Supportive\n\nA is the correct answer.\n\nAs the name suggests this document is used to identify the current engagement level of project stakeholders. It can also be used to indicate desired level of engagement. Through this analytical process gaps in engagement levels can be identified and action plans and communication plans can be generated to bridge these gaps. The Stakeholder Engagement Assessment Matrix does not list stakeholders depending on their engagement level - so options C and D are clearly wrong. While you might be tempted to choose option B - since we do list down all the stakeholders in a matrix in this document - the better and more qualified answer is Option A - where along with the complete list of stakeholders we also indicate their current and desired engagement level.\n\nQuestion - 33\n\nYour company policy allows you to gift customers within certain limit. By mistake, you have given a gift to the customer's representative already which is beyond the limit mentioned in your company policy. What should you do?\n\nA. Forget it and don't tell anyone.\n\nB. Contact your company's senior management and ask for assistance.\n\nC. Ask your customer to return the gift.\n\nD. Ask your customer to give you a gift which has the same cost\n\nB is the correct answer.\n\nBest option is to contact your company's senior management and ask for assistance.\nQuestion - 34\n\nEarned Value Analysis is used to measure performance based on following parameters:\n\nA. Scope and Cost\n\nB. Scope and Schedule\n\nC. Scope, Cost and Schedule\n\nD. Cost and Schedule\n\nC is the correct answer.\n\nThe correct answer is - C - Earned Value Analysis is performed based on Scope, Schedule and Cost.\n\nQuestion - 35\n\nWhich of the following statements are not true regarding Scope Verification?\n\nA. Consists of conducting inspections, reviews and audits.\n\nB. Used to determine if results conform to requirements\n\nC. Used to get formal sign off from clients\n\nD. Used to determine schedule variance\n\nD is the correct answer.\n\nAll the options except schedule variance are true regarding scope verification. Note that this process can also be done at the end of each project phase in the project lifecycle. So the correct answer to the question is option D since scope verification has nothing to do with schedule variance.\nQuestion - 36\n\nWhat is the purpose of fishbone diagram?\n\nA. To illustrate how various factors might be linked to potential problems or effects\nB. Are used to determine if the process are in control\nC. Show trends in a process over time\nD. Shows the pattern of relationship between two variables\n\nA is the correct answer.\n\nFishbone diagram : To illustrate how various factors might be linked to potential problems or effects.\n\nQuestion - 37\n\nWhich of the following best describes Vrooms Expectancy theory ?\n\nA. Employees will put in efforts dependant on expectancy, valence, and instrumentality\nB. Employee motivation is not achievable - employees must be forced to get things done\nC. Hygiene factors will ensure that job dissatisfaction not occur - however it does not ensure job satisfaction\nD. People have needs starting with Physiological Needs and ending with self actualization\n\nA is the correct answer.\n\nVrooms Expectancy theory is based on the idea that people believe there are relationships between the effort they put in at work, the performance reviews / ratings they are credited for the effort, and the rewards they receive from their effort and performance review ratings. So people will be motivated if they believe that hard work and effort will lead to good performance reviews and good performance reviews will lead to desired rewards. This theory consists of three key elements: Expectancy - Perception of employee of how much and what amount of effort will lead to a desirable performance rating. Instrumentality - Perception or expectation that a good performance rating would translate into a hefty salary hike Valence - Preference of an employee\nfor a certain reward. Option B is clearly unrelated to this theory - so it is not the correct answer. Option C is related to Herzbergs Hygiene theory - so it too is not the correct answer Option D is talking about Maslows Theory of Hierarchial needs - so again not the correct answer. Option A is the correct answer.\n\nQuestion - 38\nYou are managing a project that that your company won after making a bid. The clients have negotiated long and hard and have driven a hard bargain. The project is scheduled to span over eight months and you are in your fifth month of execution. You are extremely worried since you have about four more months of work remaining and the project is at the 'Point of total assumption' - what does this mean?\n\nA. As a seller you are running behind schedule\nB. As a seller you are ahead of schedule\nC. The project is going to have a cost overrun which will need to be negotiated with the client\nD. As a seller all subsequent costs will have to be borne by the seller\n\nD is the correct answer.\n\nThe point of total assumption is the point at which the seller has consumed all the fees and will now bear the costs. This means that the project is a firm fixed price contract and seller has consumed all the contract fees and is forced to shell out money which is a loss. Since point of total assumption is applicable to firm fixed price contract - option C is not an option where seller can negotiate with the buyer for additional cash flow. The correct answer is option D\n\nQuestion - 39\nYou are managing a project which involves building software for the aeronautical domain. The nature of the work is complex and needs a lot of research. During Quality assurance both the development team and testing team suggest that the quality assurance process be changed to also include White Box testing and not only rely on Black box testing. The team wants to make this shift in approach as they believe this would lead to better quality of deliverables - what is the best course of action?\n\nA. As the changes will help improve quality - execute white box testing\nB. Create a change request\n\nC. Refuse to adopt this change as this would mean a change in agreed process\n\nD. Analyze the impact of the change to scope, schedule and cost and then write up a Change Request\n\nD is the correct answer.\n\nThis is a question meant to test your understanding of change management. Any change however small or big should always be first analyzed for its impact to the constraints - scope, cost and schedule and then should be submitted to change control for approval. Changes without formal approval should not be implemented.\n\nQuestion - 40\n\nThe Scope Baseline consists of the following:\n\nA. Approved Project Scope Statement, WBS, WBS Dictionary\n\nB. Preliminary Project Scope Statement, Approved Project Scope Statement, WBS, WBS Dictionary\n\nC. Scope Management Plan, WBS, WBS Dictionary\n\nD. Scope Management Plan, Approved Project Scope Statement, WBS Dictionary\n\nA is the correct answer.\n\nThe correct answer is A.\n\nQuestion - 41\n\nYou are the project manager and decided to outsource a part of the project to a vendor. The vendor discovered some issues that impact the cost and schedule of its work. How does the vendor update the agreement?\nA. A new contract needs to be signed by your company and the vendor\n\nB. A contract addendum needs to be signed by your company and the vendor\n\nC. An SOW needs to be signed by you and the vendor\n\nD. None of the above\n\nB is the correct answer.\n\nA contract addendum needs to be signed by your company and the vendor.\n\nQuestion - 42\n\nAs a manager on a project your key outlook is to ensure that the project delivers within the scheduled timelines with minimal rework and customer delight. For some time now the project work is proceeding smoothly with a CPI and SPI a perfect 1. One of your team members approaches you and indicates that she might possibly need a long vacation on personal grounds. She indicates this could possibly occur in two months from now. You look up the schedule and as luck would have it - this team member happens to be scheduled to execute activities which are on the critical path - and her absence in two months time would cause a delay in schedule. You decide to take some action and reschedule task allocation to ensure that this team member is not planned to work on any of the critical path activities. What did you just do?\n\nA. Mitigate the risk\n\nB. Avoid the risk\n\nC. Transfer the risk\n\nD. Exploit the risk\n\nB is the correct answer.\n\nYou have avoided the risk where by interchanging the tasks you have ensured that the resource who could go on a long vacation does not work on critical path activities. There is no question of exploiting the risk as this is not a positive risk. This is not a case of Risk mitigation since neither have you created a backup plan nor have you come up with an alternate strategy - so the correct answer is Risk avoidance - option B.\nQuestion - 43\n\nYou are in the process of executing a project that deals with laying out electrical cables connecting two cities. You have been reporting progress on a monthly basis. In this month due to unplanned vacations many of the staff have not turned up at work. This has caused a delay in the schedule. You decide to check if the schedule variance is within the allowable threshold - what document should you refer to?\n\nA. Project Management Plan\n\nB. Schedule Management Plan\n\nC. Project Schedule Network Diagram\n\nD. Activity Definition\n\nB is the correct answer.\n\nThe correct answer is Option B - the acceptable schedule variances are defined in the Schedule Management Plan.\n\nQuestion - 44\n\nWhich of the following activities is not performed as a part of Project Closure?\n\nA. Ensure all the deliverables as per contract are met\n\nB. Create lessons learned and update Organizational Process Assets\n\nC. Formal acceptance\n\nD. Verify scope\n\nD is the correct answer.\n\nAll the options except Verify scope are performed during project closure. Ensuring deliverables meet contract requirements and formal acceptance are key activities of project closure. Lessons learned is also a very important activity performed during project closure. However Verify scope\nis not performed during project closure - rather it belongs to the Monitoring and Controlling process group.\n\nQuestion - 45\n\nOf the following types of contracts - which has the HIGHEST risk for the buyer?\n\nA. Cost plus fixed fee - CPFF\n\nB. Time and Material\n\nC. Firm Fixed Price Contract - FFP\n\nD. Fixed Price Incentive Fee Contracts - FPIF\n\nA is the correct answer.\n\nThe riskiest for the buyer in the options stated above is - Cost plus fixed fee. This is because its a Cost-reimbursable type of contract in which total costs are unknown - so there is an element of risk involved as total scope of work is not clear. Time and material have medium risk from the perspective of the buyer and are typically used for smaller dollar amounts. Of the options the Fixed price options are the least risky for the buyer since the cost will not change no matter what for the buyer! The correct answer is option A.\n\nQuestion - 46\n\nYou are in charge of building a shopping portal. You are fairly confident as you have a team experienced in doing such work. As per the agreement at the end of the first month you organize a demonstration of the software. You invite the sponsor and key stakeholders. Later the sponsor informs you that she is not very happy with the progress indicating that one of the clients who would be using this software is not satisfied as her needs are not being met. To satisfy this client's needs would mean some radical changes with an impact to both cost and schedule. What could be the root cause of this issue?\n\nA. Deliverables were not as per requirement\n\nB. The stakeholder is making unrealistic demands\n\nC. The scope statement was ambiguous leading to this\nD. All the stakeholders were not identified\n\nD is the correct answer.\n\nThe correct answer in this case is improper stakeholder analysis - Option D. While options A, B and C could be true the question gives no indication of these being the case. The question does mention about an important client whose expectations were not met. Stakeholder analysis deals with identifying all the stakeholders, their needs and expectations and their influence. In this case as the client's needs are not being met - it means that stakeholder analysis and identification was not done correctly.\n\nQuestion - 47\n\nTop-down estimating is also called _______ estimating.\n\nA. Analogous\nB. Primary\nC. Organizational\nD. Simple\n\nA is the correct answer.\n\nA is the correct answer. Top-down estimating is also called Analogous.\n\nQuestion - 48\n\nThe _________ is the international organization that controls the standards for quality.\n\nA. ISO\nB. PMP\nC. PMI\nA is the correct answer.\n\nThe ISO is the international organization that controls the standards for quality.\n\n**Question - 49**\n\nYour company has won a large project for one of the fund houses to administer their funds. The project work has been going on smoothly and the customer has been singing praises about the work done so far. The client has planned a visit the next month to go over the plans for the next phase of the project as well as to meet with the project team. Your senior management realizes that this client could potentially need additional capabilities in the derivatives segment. Your company happens to have a strong exposure to this segment having executed numerous such projects. Your senior manager also invites key managers from the derivatives segment to showcase the organization's abilities in the derivatives vertical - this is an example of?\n\nA. Mitigating the risk\n\nB. Avoiding the risk\n\nC. Transferring the risk\n\nD. Exploiting the risk\n\nD is the correct answer.\n\nThis is an example of exploiting the risk. As the question states the client is happy with the work progress and also there might be an opportunity that the client might be interested in the derivatives segment. So this is an opportunity that could lead to more business. By inviting key managers from the other segment - you are enhancing the possibility of generating additional revenue - so this is an example of exploiting the risk. Note that this is a positive risk.\n\n**Question - 50**\n\nProject Team has created sub plans for each activity in project plan. These plans are called:\n\nA. resource plans\nB. activity plans\nC. sub plans\nD. management plans\n\nD is the correct answer.\n\nD is the correct answer. These plans are called management plans.\n\nQuestion - 51\n\nYou are responsible for the complete makeover of a shopping mall which involves civil work and painting. After going through the details you have come up with the cost estimates which have been approved to arrive at the cost baseline. Work is now in progress and you and senior management are happy with the work throughput. Suddenly you realize the ceiling repair work was not factored in the estimates - though it was very much a part of the scope. You decide to make use of Contingency reserves - but your senior manager advises you to make use of the Management reserve - what is the correct option?\n\nA. Neither of the two are correct options\nB. Making use of Management Reserve is the correct option\nC. Making use of Contingency Reserve is the correct option\nD. None of the above\n\nB is the correct answer.\n\nManagement reserve is meant for unknown unknowns and which is part of the scope of the project. The question clearly states that the work is in scope. Contingency reserves are for known unknowns which is not the case here. The correct answer is Management Reserve.\n\nQuestion - 52\n\nYou are in your third month of project execution which is expected to continue for a duration of\n14 calendar months. Your sponsor has asked for a performance report. You decide to create a S curve. Based on the S curve you report your Actual Cost which is more than the Earned Value. Also the Planned Value is greater than the Earned Value. What would be the interpretation of this data?\n\nA. The project is over budget and behind schedule\nB. The project is on schedule and on budget\nC. The project is over budget but on schedule\nD. The project is on budget but behind schedule\n\nA is the correct answer.\n\nThe correct answer is A - this is because the SPI is less than 1 and the CPI is also less than 1.\n\nQuestion - 53\n\nYou have been asked to provide Cost estimates for a project which would be responsible for the complete electrical installation in warehouses. As a project manager - you have had past experience in similar projects in your previous organization. The organization you have joined - also has recently done a similar project - and there is an urgency in providing the estimate as mandated by executive management - so what estimation technique would you adopt?\n\nA. Ask your prior organization for the estimates\nB. Use Parametric Estimating technique\nC. Use Bottom Up Estimating\nD. Analogous Estimates\n\nD is the correct answer.\n\nThe correct answer is Analogous estimates - since it relies on previous similar project as the basis of estimation - which is available - so it relies on historical information. This technique is used when there is limited amount of detailed information like during early phases of the project, it is less costly and less time consuming - and as time is a constraint stated in the question - this is the best choice.\nQuestion - 54\n\nYou are a project manager managing a project that has not been making good progress. Certain issues like a flash flood have significantly delayed the laying out of the plinth for the shopping complex. There have been a lot of escalations from key stakeholders and executive management is pressing for getting the project on track. In a review meeting - your lead architect sensing the urgency - suggests a change that could significantly decrease the schedule. She is very confident that the suggested change will work to get things on track. As a project manager what is the best course of action?\n\nA. The project is lagging - so implement the change request as it would reduce the schedule\n\nB. Reject the idea of making the change as this will need an approval from change control\n\nC. Create a change request and submit to change control board\n\nD. Identify the impact of the change to the scope and cost and then include this information in the change request\n\nD is the correct answer.\n\nNo changes should be made without a formal approval - so option A is clearly wrong. Rejecting ideas without doing a thorough analysis of the impact is also not the correct approach. Now the option of creating a change request and submitting for approval sounds like the right option - however the better approach is to always do an analysis of the impact to scope, time and cost and then submit the change request. So while option C is correct the better option is D\n\nQuestion - 55\n\nYou are in charge of managing a software development project which is related to simulations for driving racing cars. In one of your team meetings - it has been reported that a lot of issues have been reported in the air tunnel modelling module. On deeper analysis - it is found that many of the issues could have been prevented had a simple code review checklist been used. You decide to mandate usage of the code review checklist for all subsequent deliveries to ensure other deliveries are less issue prone. This is a good example of:\n\nA. Corrective Action\n\nB. Preventive Action\nC. Defect Repair\nD. Quality Control\n\nB is the correct answer.\n\nThis question is meant to test your understanding of the difference between what corrective action and preventive action is. Defect repair might sound tempting - but it is only applicable for the issues found for the current delivery. Here the question also states some additional steps being mandated (code review for all subsequent deliveries). This is also not about Quality Control - so that leaves us with only two options - Corrective or Preventive actions. Corrective actions are always preceded by nonconformity while preventive action is never preceded by nonconformity. In this case nonconformity in the form of a lot of issues during Quality Assurance were reported. The root cause was identified to be the need of a standard checklist which was then used. This would have been a case of Corrective action had no other actions been taken other than usage of the code review checklist for the current delivery. In addition a decision was taken to use the checklist for all subsequent deliveries - to ensure the same issues did not occur - Preventive action is always taken proactively - here mandating usage of code review checklist for other deliveries is a demonstration of proactive steps taken - hence this is an example of Preventive action. The correct answer is option B - Preventive action.\n\nQuestion - 56\n\nYou are in charge of constructing a High Rise residential building. After creating a Network diagram - you have identified the Critical Path. Work has started - but suddenly due to inclement weather plinth work has got delayed. This plinth work activity was on the critical path. As a manager driving this project would you be worried and why?\n\nA. No - It will not matter if the Plinth work is delayed.\nB. No - Activities on the critical path do not impact the schedule\nC. Yes - Any delay of activities on the critical path would lead to a delay of the entire project\nD. Yes - you will now have to relay this bad news to the client\n\nC is the correct answer.\n\nThe correct answer is - C - since activities on critical path if delayed can lead to a delay in the entire Project. Options A and B are incorrect while option D is a very subjective answer and\nnowhere does the problem state how the stakeholders would take the news - so the best answer in this case is option C\n\nQuestion - 57\n\nYou know that the success of your project will be determined by how well you manage risks. You know that identifying risks upfront can help you be better prepared with risk response strategies. You discuss and consult with other project managers in the company. One manager suggests usage of SWOT to identify risks. What would you do next as a part of this technique?\n\nA. Gather team members and experts together and discuss to identify risks\nB. Gather anonymous responses from experts and identify risks\nC. Perform root cause analysis to identify problems, their cause and potential response\nD. Identify the Organizations strengths and weaknesses\n\nD is the correct answer.\n\nSWOT involves identification of the strengths and weaknesses of the organization. This technique then identifies the threats due to organization weakness as well as opportunities due to the organizations strengths. So option D is the correct answer. The other three options are also risk identification techniques but the question is specific to SWOT\n\nQuestion - 58\n\nYou have been assigned to a project that deals with developing a software product for the BFSI domain. You and your team are building the schedule network diagram. While sequencing activities one of the team members - who is an Architect indicates that rather than interacting with the database on every activity - we should introduce an activity which would cache the data. He argues that this will improve performance and hence this activity should be introduced in the sequence prior to the other activities that deal with database interaction. What kind of a dependency is this?\n\nA. This is an example of Mandatory Dependency\nB. This is an example of External Dependency\nC. This is an example of Discretionary Dependency or Soft Logic\n\nD. This is an example of Hard Logic\n\nD is the correct answer.\n\nThe correct answer is C. Discretionary Dependency is also known as Soft Logic or Preferred Logic or Preferential Logic. Note that this is not a mandatory dependency - as it is not a 'Must Have' but more a 'Should have'. Discretionary dependency decisions are usually based upon best practices, business knowledge. In this case a Software architect can be assumed to be an expert in his field.\n\nQuestion - 59\n\nYou and your team are in the process of creating WBS and WBS Dictionary. What would be the BEST choice of attributes in a WBS Dictionary?\n\nA. Work Package ID and Work Package Description\n\nB. Work Package ID, Control Account ID and Work Package Description\n\nC. Work Package Description\n\nD. Work Package ID, Control Account ID, Work Package Description, Acceptance Criteria, Responsible Organization, Cost, Assumptions\n\nD is the correct answer.\n\nOptions C, A, B each provide greater details of what a WBS Dictionary should contain - so they all seem like the right choices. However the question asks about the BEST choice of attributes in a WBS Dictionary - which is provided in Option D. Note that the WBS and WBS Dictionary are co-related by WBS Name and Work Package ID.\n\nQuestion - 60\n\nWhich of the following statements is NOT true regarding change log?\n\nA. Change log is used to log only approved change requests\nB. It is used to document changes that occur during a project\n\nC. The changes along with their impact to cost, time, and risk are logged\n\nD. Rejected change requests are also captured in the change log\n\nA is the correct answer.\n\nThe change log is used to log all change requests - approved and rejected changes. Along with the changes, their impact to cost, time, and risk details are also documented. So option A is not true regarding change logs and hence is the correct answer.\n\nQuestion - 61\n\nWhat does S Curve depict a relationship between?\n\nA. Resource Availability over time\n\nB. Remaining budget\n\nC. A relationship between Actual Cost, Planned Value and Earned Value\n\nD. Shows the relationship between Cost and Quality\n\nC is the correct answer.\n\nThe correct answer is C - S curve shows a relationship between Actual Cost, Planned Value and Earned Value.\n\nQuestion - 62\n\nWhich of the following statements are false regarding Risk Management?\n\nA. All identified risks are maintained in the Risk Register.\n\nB. Risk prioritization occurs in Qualitative Risk Analysis.\nC. Risk prioritization occurs in Quantitative Risk Analysis.\n\nD. Low priority risks are maintained in a Watch List.\n\nC is the correct answer.\n\nAll of the statements are true except the statement regarding Quantitative Risk Analysis. Quantitative Risk analysis does not deal with prioritizing risks. The prioritization occurs in the Qualitative Risk Analysis process. Quantitative Risk Analysis deals with assigning numeric values to risks.\n\nQuestion - 63\n\nWhich of the following statements is not true regarding a Contract?\n\nA. Legally binding in nature\n\nB. Obligates buyer to provide compensation and obligates seller to provide some product or service in return\n\nC. By careful administration of terms and conditions the buyer can transfer some of the risks to the seller\n\nD. Contracts undergo an approval process as any other plan\n\nD is the correct answer.\n\nThis question tests your knowledge about contracts and procurement. At the onset all the answers seem to be correct with respect to the contract. A contract is legally binding in nature, its an agreement of seller providing some service or product and buyer compensating the seller. Some of the risks can indeed be transferred to the seller through terms and conditions. Because of the legal nature of a contract - generally contracts are subject to a more intensive approval process - much more intense than our other plans - hence in the context of the question - option D is the right answer.\n\nQuestion - 64\n\nYou are in charge of a project for the electrical layout of a 5 star hotel. You see this as a very\nsimple project as you and your team have a lot of experience executing similar such projects. As a result your organization has a wealth of Organizational Process assets. You have worked out the exact details of the work involved and have a very detailed WBS with granular level activities defined. You decide to employ the services of a contractor for laying out of the cable trays. What kind of a contract would be the best choice?\n\nA. Cost-reimbursable contract \nB. Fixed-price contract \nC. T and M contract \nD. None of the above\n\nB is the correct answer. \n\nWhen as a buyer you are clear of the scope and statement of work - the contract choice should be Fixed-price. This is because in this type of contract if scope is clearly defined - then almost all of the risk lies with the seller. Here the buyer is smug with the confidence of having had experience in executing similar projects in the past and has also broken down WBS into detailed activities - so scope is clear - so the correct answer is option B.\n\nQuestion - 65 \n\nWhich hierarchical chart shows resources?\n\nA. RBS \nB. OBS \nC. WBS \nD. Scope statement\n\nA is the correct answer. \n\nA is the correct answer. The Resource Breakdown Structure shows various resources, both human and mechanical needed for the project.\nQuestion - 66\n\nYour company has won a project to build a school playground with specific toys and a sandpit. The school has mandated that the project be completed prior to start of the school after Holidays. You review the plan and see that the estimated completion date is nearly a month after the desired completion date. As resources are sparse you do not have the option to add additional resources. However, you see that the sandpit work can start in parallel to the play kits being installed. Your analysis tells you that by performing these activities in parallel - the project would meet its schedule. This is an example of:\n\nA. Scope Creep\nB. Resource Levelling\nC. Crashing\nD. Fast Tracking\n\nD is the correct answer.\n\nThe correct answer is D - Crashing deals with adding additional resources which is not an option here. Crashing is a schedule compression technique by performing activities in parallel if they can be overlapped. NOTE Fast Tracking may result in increased risk and rework.\n\nQuestion - 67\n\nYou are in charge of a project to build a bridge across a river. You are midway through the project. However, due to changes in environmental laws the project can no longer proceed and would need to be terminated. Executive management has asked you to document the level of work completed for the project. This would be done in which of the processes?\n\nA. Project Closure\nB. Contract closure\nC. Project charter\nD. Scope Verification\n\nD is the correct answer.\nThe correct answer is option D. Not only is Scope verification performed while the project is executing - it is also performed when a project is terminated. It is used to determine the level of completion.\n\nQuestion - 68\n\nYou have asked your team members to provide estimates of tasks. Based on the estimate provided you see a specific team member seems to have provided estimates on the higher side. You decide to discuss with the concerned team member. She replies that as she did not have an idea of how long it would take she had guessed the estimate and then to be on the safer side simply doubled it! What is this known as?\n\nA. This is a Lead\n\nB. This is a Lag\n\nC. This is Free Float\n\nD. This is a Pad\n\nD is the correct answer.\n\nThe correct answer is D - Pad is adding time as a buffer to project estimate. As the team member was uncertain of what it would take and as stated to be on the safer side she simply doubled the estimate. Padding is a sign of poor Project Management.\n\nQuestion - 69\n\nYou are in the process of making cost estimates for a project. However detailed requirements are not yet available. A similar project was executed by your company and you decide to use the past projects historical data to come up with your estimates. This is called -\n\nA. Analogous estimating\n\nB. Parametric estimating\n\nC. Bottom-up estimating\n\nD. Three point estimating\nA is the correct answer.\n\nThe correct answer is Analogous estimating - since analogous estimation relies on past or historical data of similar nature. As the project is at an early state - where the detailed requirements are not yet available - this is the best technique suited to come to an early estimate - though it may not be very accurate.\n\nQuestion - 70\n\nYou are the project manager for a large Project. You are currently busy with approximating number of work periods required to complete individual activities with estimated resources. Which of the following inputs do you need for this ?\n\nA. Activity List\nB. Activity resource requirements\nC. Resource Breakdown structure\nD. All of the above\n\nC is the correct answer.\n\nC is the correct answer. Approximating number of work periods required to complete individual activities with estimated resources is done in Estimate Activity Duration process. Activity List, Activity resource requirements and Resource Breakdown structure are inputs of Estimate Activity Duration process. PMBOK Page no 142.\n\nQuestion - 71\n\nYou and your team are planning out the work to be done. You break up the work into discrete workpackages. To ensure that each work package has all the necessary details - you and your team decide to write down detailed information for each work package such as Statement of work, details of the work package and who will be the responsible individual for the work package. Where would you store this information in ?\n\nA. Approved Project Scope Statement\nB. WBS Dictionary\nC. WBS\nD. Project Management Plan\n\nB is the correct answer.\nThe correct answer is B - which is where this information is stored.\n\nQuestion - 72\nYou are the project manager of a software project. You have just analyzed activity sequences, durations, resource requirements, schedule constraints and created project schedule. The above task belongs to which process?\nA. Define Activities\nB. Sequence Activities\nC. Develop Schedule\nD. Control Schedule\n\nC is the correct answer.\nC is the correct answer. analyzing activity sequences, durations, resource requirements, schedule constraints and creating project schedule belongs to Develop Schedule process.\n\nQuestion - 73\nYou know that the success of your project will be determined by how well you manage risks. You know that identifying risks upfront can help you be better prepared with risk response strategies. So you decide to identify risks by taking help of experts. You have identified some good experts and rather than calling them into your office - you send them questionnaires. You promise them complete anonymity so that they give unhindered responses. What information gathering technique are you adopting?\nA. Brainstorming\nB. Root Cause Identification\nC. SWOT analysis\nD. Delphi Technique\n\nD is the correct answer.\n\nAll four options listed above are information gathering techniques - but the correct answer is Delphi Technique. This is a form of information gathering technique where inputs from experts is solicited anonymously without gathering them together.\n\nQuestion - 74\n\nWhich of the following best describes Achievement Theory of Motivation?\n\nA. Employees given a reward are most likely to be motivated\nB. People cannot be trusted and must be governed and monitored regularly to ensure tasks get done\nC. People are motivated by achievement, power and affiliation\nD. Employees will put in an effort in direct proportion to the perceived review and reward\n\nC is the correct answer.\n\nOption A and Option D are related to Expectancy theory, Option B is related to Theory X style of management - so these options are not the correct answers. Option C - is the correct answer - this theory states - there are three types of motivational needs: Need for achievement, need for authority and power, need for affiliation. As per this theory a strong 'affiliation-motivation' undermines a manager's objectivity, because of their need to be liked, and that this affects a manager's decision-making capability. A strong 'authority-motivation' will produce a determined work ethic and commitment to the organisation. such people are attracted to the leadership role, though they may not possess the required flexibility and people-centred skills. People with strong 'achievement motivation' make the best leaders, although there can be a tendency to demand too much of their staff in the belief that they are all similarly and highly achievement-focused and results driven, which of course most people are not. As per this theory achievement-motivated\nindividuals set goals which they can influence with their effort and ability, and as such the goal is considered to be achievable. This determined results-driven approach is almost invariably present in the character make-up of all successful business people and entrepreneurs. Achievement is more important than material or financial reward. Achieving the aim or task gives greater personal satisfaction than receiving praise or recognition. Financial reward is regarded as a measurement of success, not an end in itself. Security is not prime motivator, nor is status. Feedback is essential, because it enables measurement of success, not for reasons of praise or recognition (the implication here is that feedback must be reliable, quantifiable and factual). Achievement-motivated people constantly seek improvements and ways of doing things better.\n\n**Question - 75**\n\nThe key benefits of ____________ process is that it will maintain or increase the efficiency and effectiveness of stakeholder engagement activities as the project evolves and environment changes.\n\nA. Plan Stakeholder Management \nB. Identify Stakeholders \nC. Manage Stakeholder Engagement \nD. Control Stakeholder Engagement\n\nD is the correct answer.\n\nThe key benefits of Control Stakeholder Engagement process is that it will maintain or increase the efficiency and effectiveness of stakeholder engagement activities as the project evolves and environment changes.\n\n**Question - 76**\n\nYou are managing a project constructing a bridge over a river. All of the risks have been identified and the design phase is just completed. The team is in its second week of actual construction. One of the subject matter experts reports that there is a possibility of the monsoons to be heavier this year. She points out that the load bearing plates earlier designed may have to be redesigned considering the additional water pressure expected because of additional rain water. What would be your best immediate course of action?\nA. Schedule an emergency meeting with all stakeholders to discuss this risk\n\nB. Risk mitigation by immediately redesigning the load bearing plates\n\nC. Write up a change and submit to the Change Control Board for approval\n\nD. Update the Risk register to add this risk along with its probability and impact\n\nD is the correct answer.\n\nThe question is asking about the best immediate course of action. The first course of action should be to add this risk in the Risk register and also adding the possible impact and risk probability. No other action should be performed prior to this. So - scheduling an emergency meeting while might sound as the first thing to do is not correct and neither making any change to the design. Writing up a change will only come after the risk is documented, its probability and impact accessed and then based on this information can you choose to write up a change request. So the first course of action should be to Update the Risk register.\n\nQuestion - 77\n\nYou are managing a project responsible for doing plantation on a large reserve land. You have created the schedule network diagram and have identified two paths. Path 1 consists of two activities of a duration of 2 and 5 weeks respectively. Path 2 consists of 3 activities with durations of 1, 3 and 3 weeks respectively. Which of the two paths is the Critical Path?\n\nA. Path 1\n\nB. Path 2\n\nC. Neither\n\nD. Both Paths 1 and 2 are Critical Paths\n\nD is the correct answer.\n\nThe correct answer is D - since the duration of both the paths is 7 weeks. Remember that the path with the longest duration is the critical path and you can have more than 1 Critical Path!\nQuestion - 78\n\nWhat is the role of the Project Manager in Procurement?\n\nA. Ensure contract contains all the project management requirements such as status reporting, meeting attendance and communication needs\n\nB. Ensure contract is satisfying the needs of the project\n\nC. Control changes to the contract\n\nD. All of the above\n\nD is the correct answer.\n\nOption D is the right answer - the project manager must ensure all of the above in Procurement. Many a times the project manager works with the contract manager. Here an important point is that the Project Manager must be assigned before the contract is signed.\n\nQuestion - 79\n\nAs a manager in an organization - which believes in the Theory X style of management - which of the following describes correctly the assumptions of this theory?\n\nA. Employees are inherently lazy, dislike work and will avoid work if they can.\n\nB. Employees are motivated and enjoy doing their work.\n\nC. Employees want to do well at work.\n\nD. Employees are trustworthy and are motivated by doing a good job.\n\nA is the correct answer.\n\nTheory X assumes employees cannot be trusted and will only work if rewarded or under threat and coercion. This theory does not consider an employee to work on their own - so the correct option is A. The other options consider an employee to be self motivated and self starter - which is not what Theory X is based on.\nQuestion - 80\n\nYou have recently joined an organizations project management office. After reviewing the organizational assets you realize that project managers have not routinely documented lessons learned for their projects. There are a few projects that are about to start - You decide to call up a meeting of all the project managers and explain the need of Lessons Learned. In order to get a buy in from your managers - What would you focus on as the best use of this document\n\nA. It helps the team to plan tasks\nB. It helps in performance reporting\nC. It will help the manager to better control the project\nD. The historical information can be used for other projects\n\nD is the correct answer.\n\nNote that the question states that new projects are about to start - and past lessons learned of projects could have served as good inputs for the other projects. Not having lessons learned handicaps the managers. So here the correct answer is D\n\nQuestion - 81\n\nYour project is in a critical phase. You notice one of the team members comes in late into office and leaves early. This is clearly impacting delivery. You decide to discuss the details with the concerned team member to better understand the details. On discussion you find no specific reasons so you explain the necessity and criticality of the project expecting the team member improves. However next week your lead engineer reports about inadequate time being spent by the same person in office. What would be the best choice of communication in this case?\n\nA. Informal and verbal\nB. Formal and written\nC. Informal and written\nD. Formal and verbal\nB is the correct answer.\n\nIn this case you have already tried out the option of discussing with the team member once - which is an example of Informal verbal. Clearly that has not worked so it calls for a more stricter reprimand - so here the correct form of communication would be a formal written communication.\n\nQuestion - 82\n\nDecomposition is best described as:\n\nA. Creating control accounts.\nB. Creating work packages.\nC. Breaking down deliverables into smaller work packages so they can be better planned\nD. Planning and scheduling of work packages\n\nC is the correct answer.\n\nDecomposition deals with breaking down deliverables into small discrete work packages that can be planned better. It also helps prevent work from slipping through the cracks and gives the project team a better picture of the work involved.\n\nQuestion - 83\n\nAs a part of the Executive Management team - you have a number of project managers reporting into you. One of the project managers has reported data for her project that has got you worried regarding health of the project. EV = 300000 USD, PV = 550000 USD, AC = 200000 USD\nYou are worried since as per your calculations the project is behind schedule. However the Project Manager disagrees and she feels the project is ahead of schedule - what is the correct interpretation of the data?\n\nA. Both are incorrect - the health of the project cannot be determined from this information\nB. Both are correct as interpretation is very subjective\nC. You are correct - the project is behind schedule\n\nD. Your Project Manager is correct - the project is ahead of schedule\n\nC is the correct answer.\n\nThe correct answer is C - this is because SPI = EV / PV = 300000/550000 = less than 1 . A SPI less than 1 indicates the project is behind schedule.\n\nQuestion - 84\n\nTo facilitate, measure and control Quality - you have been asked to use the seven basic quality tools - also known as 7QC tools - which ones would they be?\n\nA. Cause and effect diagrams, Flowcharts, Checksheets, Pareto diagrams, Histograms, Control Charts, Sequence Diagrams\n\nB. Cause and effect diagrams, Flowcharts, Checksheets, Pareto diagrams, Histograms, Control Charts, Scatter Diagrams\n\nC. Activity diagrams, Flowcharts, Checksheets, Pareto diagrams, Histograms, Control Charts, Sequence Diagrams\n\nD. Cause and effect diagrams, Monte Carlo analysis, Checksheets, Pareto diagrams, Histograms, Control Charts, Scatter Diagrams\n\nB is the correct answer.\n\nOption B is the correct answer.\n\nQuestion - 85\n\nYou have scheduled regular weekly team meetings with project team members. Things have been going to plan and there have been no variances till date with respect to the work performance baselines. A site engineer reports that he had to perform a couple of corrective actions - however they were not logged - as a Project Manager what should you do?\n\nA. Reprimand the team member for not documenting the corrective action\nB. Reprimand the team member and ensure the corrective action is reverted\n\nC. Do nothing - this is bound to happen on a project\n\nD. Document the corrective actions performed in the historical records\n\nD is the correct answer.\n\nAll changes - including corrective actions, preventive actions and defect repair must undergo change control prior to the change being made. It is also necessary to document the corrective and preventive actions taken in historical data as this can serve as a good input for subsequent projects. Reprimanding the team member now is of no use and allowing uncontrolled changes to happen is a recipe for disaster in project management! Option D is the right answer.\n\nQuestion - 86\n\nYou are negotiating with a contractor for additional staff augmentation - a number of software developers and a few testers. As a buyer you don't quite have the exact statement of work ready. What kind of contract is MOST appropriate for this kind of work?\n\nA. Time and Materials - T and M\n\nB. Cost plus fixed fee - CPFF\n\nC. Firm Fixed Price Contract - FFP\n\nD. Fixed Price Incentive Fee Contracts - FPIF\n\nA is the correct answer.\n\nAs the nature of work is not quite clear and this deals with contracting additional staff - the best choice of contract is T and M. Fixed price contracts are applicable where scope of work is quite clear which is not the case here. Here choosing a Cost-reimbursable contract makes no sense - since the unit rate of staff can be determined and agreed between you and the seller - so the best option is A - T and M\n\nQuestion - 87\nA process with lack of consistency and predictability is called:\n\nA. in control\nB. out of control\nC. bad quality\nD. quality noise\n\nB is the correct answer.\n\nA process with lack of consistency and predictability is called out of control.\n\nQuestion - 88\n\nThe ________ details the different tasks for members in the project.\n\nA. Responsibility Assignment Matrix (RAM)\nB. WBS\nC. SOW\nD. Scope statement\n\nA is the correct answer.\n\nA is the correct answer. Responsibility Assignment Matrix (RAM) details the different tasks for the members in the project.\n\nQuestion - 89\n\nISO Stands for __________ ?\n\nA. International Organization for Standardization\nB. International Standardized Organization\nC. In Standardized Organization\nD. None\n\nA is the correct answer.\n\nISO Stands for International Organization for Standardization.\n\nQuestion - 90\n\nYour project activity float is negative 10. What is your course of action?\nA. add more resources\nB. ask more time to complete the project\nC. use less experienced team members\nD. Ignore It.\n\nA is the correct answer.\n\nA is the correct answer. Negative activity float means your project is behind. Add more resources is best option.\n\nQuestion - 91\n\nThe purpose of a quality audit is:\nA. To identify inefficient and ineffective policies\nB. To identify project quality for customer\nC. Study organizational behavior\nD. Prepare a report for the quality team\nA is the correct answer.\n\nPurpose of quality audit is to identify inefficient and ineffective policies.\n\nQuestion - 92\n\nWhich of the following statements are not true regarding the Scope Management Plan?\n\nA. Scope Management Plan is not a Part of the Project Management Plan.\n\nB. Provides guidance on how the Project Scope will be verified.\n\nC. Provides guidance on how the scope will be defined, documented monitored and controlled.\n\nD. Provides guidance regarding the enterprise environmental factors and organizational process assets that would play a part.\n\nA is the correct answer.\n\nAll the options except Option A are true regarding the Scope Management plan. The Scope Management Plan is very much a part of the Project Management Plan.\n\nQuestion - 93\n\nYou are the project manager of a project and you have added some dummy activities to correctly show all logical relationships. Which network diagramming method have you used?\n\nA. ADM (Arrow Diagramming Method)\n\nB. Precedence Diagramming Method (PDM)\n\nC. PERT\n\nD. None\n\nA is the correct answer.\nA is the correct answer. ADM (Arrow Diagramming Method) uses dummy activities to correctly show all logical relationships. Arrow Diagramming Method (ADM) uses arrows as activities, and nodes are used to connect and show dependencies. The Precedence Diagramming Method (PDM) uses boxes or nodes as activities and arrows as dependencies between the nodes.\n\nQuestion - 94\n\nYou are in charge of a painting project for a high rise building. As part of the planning - you need to take a decision of buy Vs lease for some stilt ladders needed on site. The cost of the ladder is 1000 $ and a daily cost of 4$ while the daily lease cost is 12$. If you were to lease the ladder - what should be the duration to ensure your decision is correct?\n\nA. A duration less than 126 days\nB. A duration less than 150 days\nC. A duration greater than 126 days\nD. A duration greater than 126 days\n\nA is the correct answer.\n\nLets assume the duration to be X days. $12 \\times X = 1000 + 4 \\times X$, $8X = 1000$, $X = 125$. This means that if the ladder is used for any duration equal or greater than 125 days it is economical to purchase rather than lease - so in other words to lease the duration should be equal to or less than 125 days - so option A is the right answer.\n\nQuestion - 95\n\nIn which of the following situation network diagram is better than bar chart?\n\nA. to show inter dependencies between activities\nB. analysis of schedule progress\nC. analysis of WBS\nD. analysis of project plan\nA is the correct answer.\n\nA is the correct answer. network diagram is best to show Interdependencies between activities.\n\nQuestion - 96\n\nYour company has been tasked with providing estimates for a road construction project. You have data available related to costs per square feet. You now need to provide an estimate of the cost of the project based on this data - what estimation technique is most applicable in such a scenario?\n\nA. Top Down estimates\nB. Parametric Estimating technique\nC. Bottom Up Estimating\nD. Analogous Estimation\n\nB is the correct answer.\n\nHere the correct answer would be Parametric Estimation - this is because the cost per unit is readily available. Parametric estimation uses the relationship between variables to determine cost or duration. It calculates the cost or duration of the unit and also determines the number of units required which helps in calculating the cost / duration of the project.\n\nQuestion - 97\n\nA data point in a control chart that requires investigation is called:\n\nA. a special cause\nB. a quality fault\nC. a rule of seven\nD. a rule of five\nA data point in a control chart that requires investigation is called a special cause.\n\nQuestion - 98\nA Heuristics is best described as:\nA. thumb rule.\nB. activity diagram.\nC. workaround.\nD. control tool.\n\nA is the correct answer.\n\nA is the correct answer. Heuristics is thumb rule. Examples are cost per square feet etc.\n\nQuestion - 99\nYou have successfully completed a project. You have now been assigned a project which is midway into its execution. You have had to take this project due to non-availability of the current project manager due to health. This is a complex project involving multiple contractors and teams at various geographical locations. You decide to look up the requirements of the types of reports and frequency of sending them. Where would you find this information?\n\nA. Project Management Plan\nB. Scope Management Plan\nC. Communication Management Plan\nD. Stakeholder Analysis\n\nC is the correct answer.\nThe correct answer is Communication Management Plan. This Plan provides information such as frequency of communication, type of communication, who is responsible for communication. Hence this is the correct answer.\n\nQuestion - 100\n\nYou are managing a project and to ensure things run smoothly - you have decided to provide project information periodically to all the stakeholders. You have decided that you would report against the baselines for scope, cost and schedule. Which of the following would be the best choice?\n\nA. Performance reporting\nB. Status reports\nC. Forecasts\nD. Risk Register\n\nA is the correct answer.\n\nThe best choice is Performance reporting with respect to the triple constraints - Scope, Schedule and Cost. Forecasts are future projections while risk register deals with risks which are not the right options. While status reports could be an option the best answer is Performance reporting.\n\nQuestion - 101\n\nYou have replaced a project manager on a project that is already in the execution phase. The project is behind schedule and you have been specifically brought in to ensure the project meets its schedule. You decide to review the schedule network diagram created by the earlier project manager and you realize that the project is 3 weeks behind schedule. After reviewing the activities and the network diagram you decide to Crash the schedule. So this means you\n\nA. Decrease the scope of the project after discussing with the sponsors\nB. Add additional resources to the activities on the Critical path\nC. Perform activities in Parallel to decrease the schedule\nD. Discuss with the sponsors and explain how it is not going to be possible to meet the schedule.\n\nB is the correct answer.\n\nOption B is the correct answer. Crashing is a technique used to shorten the schedule by adding resources. Option A and D are clearly not correct - and Option C is really an example of Fast Tracking.\n\nQuestion - 102\n\nWhich of the following best describes the assumptions made by Herzberg's Hygiene theory?\n\nA. Employees are basically lazy and need to be monitored\nB. Hygiene factors help avoid job dis-satisfaction and lead to motivated employees\nC. Hygiene factors help avoid job dis-satisfaction and their absence could create dissatisfaction but it will not lead to motivated employees\nD. Job content factors have no influence in keeping people happy on the job and motivated.\n\nC is the correct answer.\n\nAccording to Herzberg Hygiene theory - certain factors exist termed as 'Hygiene factors' - which if not present can lead to dis-satisfaction - so to avoid dis-satisfaction they must be present. However these 'Hygiene factors' will not directly lead to employee satisfaction - they would only avoid dis-satisfaction. Option A is clearly unrelated while Option B is incorrect since Hygiene factors do not contribute to employee motivation. Option C is correct. Herzberg's theory also states that what motivates employees is the Job content - hence Option D is incorrect since it states the opposite.\n\nQuestion - 103\n\nYou are managing a software development project in the banking domain. Things have been proceeding as per plan - but with the economic meltdown the client has had to abruptly shutdown the project due to lack of funds to source the projects any longer. As a Project manager what is the next thing to do?\nA. Free up project resources so they can be utilized on other tasks\n\nB. As there are very few tasks remaining - get those completed\n\nC. Ensure all project closure procedures are followed and lessons learned are updated\n\nD. Publish work performance reports for the project\n\nC is the correct answer.\n\nProject closure procedures must be followed. They must be followed irrespective of whether project was successfully completed or if it was terminated - we always follow closure procedures - so in this case the Project Manager should choose option C\n\nQuestion - 104\n\nWhich of the following statements is true regarding Critical Path?\n\nA. There can be more than one Critical Path in a Schedule Network Diagram\n\nB. Critical Paths generally always have negative float\n\nC. Activities on Critical Path have positive float\n\nD. Critical Path has duration less than the non critical paths.\n\nA is the correct answer.\n\nThe correct answer is Option A. Generally activities on Critical Path have Zero float. Critical Path is the one which has the longest duration - so options B, C and D are not correct. You can always have more than one Critical Path in a project.\n\nQuestion - 105\n\nYour company policy allows accepting gifts from customers within certain limit. Your customer is giving you a gift which is beyond the limit of your company policy. You have given a gift to the customer’s representative already which has similar in value. What should you do?\nA. Accept it and don't tell anyone.\n\nB. Contact your company's senior management and ask for assistance.\n\nC. Ask your customer about company policy.\n\nD. Refuse it.\n\nB is the correct answer.\n\nBest option is to contact your company's senior management and ask for assistance.\n\n**Question - 106**\n\nYou are responsible for a project with high risks particularly during the early phases - your sponsor has asked for performance reports on a monthly basis. At the end of the first month you report a CPI greater than 1 and also the SPI greater than 1. What would this mean?\n\nA. The project is behind schedule and over budget\n\nB. The project is ahead of schedule and under budget\n\nC. The project is ahead of schedule but over budget\n\nD. The project is behind schedule but under budget\n\nB is the correct answer.\n\nThe correct answer is B - SPI greater than 1 indicates the project is ahead of schedule while a value less than 1 indicates the project is behind schedule. CPI value greater than 1 indicates project is under budget while a value less than 1 indicates the project is over budget.\n\n**Question - 107**\n\nYou are the project manager of a software project. Your team member want to make technical changes to an activity which will add more time to that activity. What should you do?\n\nA. Check if the activity is on critical path\nB. Allow team members to change the activity\nC. Report to senior management\nD. Ignore change in activities.\n\nA is the correct answer.\nA is the correct answer. Check the activity if it is on critical path is the best option.\n\nQuestion - 108\nYou have replaced an earlier project manager. The project is already in its third month of execution. You need to determine if the project is ahead or behind schedule. What would be the BEST source of this information?\n\nA. Work performance data\nB. Work performance Measurement\nC. Project Management software\nD. Pareto Chart\n\nB is the correct answer.\nWork performance measurement provides details of planned Vs actual values which helps in determining the health of the project. Work performance data is the at actuals information that helps in measuring performance. Project management software helps facilitate track data while Pareto chart is used in Quality Control. The correct answer is Option B - Work performance Measurement\n\nQuestion - 109\nCommunication can be of the following forms except:\n\nA. Formal and Informal\nB. Written and Verbal\nC. Precise and Vague\nD. Vertical and Horizontal\n\nC is the correct answer.\n\nPrecise and Vague is not a form of communication while all others are.\n\nQuestion - 110\n\nYou are the project manager of a project and one of the functional managers wants to make a major scope change during the execution of the project. What should be your action?\n\nA. Prepare an impact detail of the change for the functional manager\nB. Refuse the change\nC. Complain to the sponsor\nD. Ignore the request\n\nA is the correct answer. If there is scope change by a functional manager during the execution of the project, then the project manager sends the impact detail of the changes to functional manager.\n\nQuestion - 111\n\nWith a lot of expertise in project management - many of your companies co managers consult you for advise and inputs. One of your colleagues who is relatively inexperienced in managing projects wants to compare the project work and measure the deviations - which document should he refer to? Choose the option that BEST answers the question?\n\nA. He should refer to the Project Management Plan\nB. He should refer to the Scope Management Plan\nC. He should refer to the Schedule Management Plan\nD. He should refer to the Performance Measurement Baseline\n\nD is the correct answer.\n\nThere are multiple options that seem correct - however they are partially correct. The scope baseline and schedule baseline are not the only baselines against which project performance is measured so options B and C are definitely not the best options. The project management plan contains details of all the baselines - but a more specific plan to refer to is the Performance Measurement Baseline. It contains details of the scope, schedule and cost baseline and it could also contain quality and technical parameters. While the project management plan includes he baselines - it is actually the Performance Measurement Baseline which is used for comparing performances and the Performance Measurement Baseline is a part of the Project Management Plan. So the BEST answer is option D\n\nQuestion - 112\n\nAs a manager on a project your key outlook is to ensure that the project delivers within the scheduled timelines with minimal rework and customer delight. For some time now the project work is proceeding smoothly with a CPI and SPI a perfect 1. One of your team members approaches you and indicates that she might possibly need a long vacation on personal grounds. She indicates this could possibly occur in two months from now. You look up the schedule and as luck would have it - this team member happens to be scheduled to execute activities which are on the critical path - and her absence in two months time would cause a delay in schedule. You decide to take some action and ask the team member to start regular knowledge transfers to a couple of trainees. Your thought is though the trainees would be relatively inexperienced they would more than make up for it with two people rather than one person to perform these tasks should this team member need to go on leave. What did you just do?\n\nA. Mitigate the risk\nB. Avoid the risk\nC. Transfer the risk\nD. Exploit the risk\n\nA is the correct answer.\nYou have mitigated the risk where by asking for the trainees to be trained you have created a Risk response strategy. Should this team member go on leave the trainees would execute the task. So you have not avoided the risk. Again there is no question of exploiting the risk as this is not a positive risk. This is not a case of Risk avoidance either - so the correct answer is Risk Mitigation - option A.\n\nQuestion - 113\n\nYou are a project manager of Software Product company. After a person is hired, you come to know that many of this person's ideas were developed by a competitor company. Are you going to implement the same ideas?\n\nA. Accept the new ideas.\n\nB. Ignore the ideas because it may be a violation of the code of conduct.\n\nC. Ask to sign NDA.\n\nD. Tell the person that he should not mention that the ideas came from another company.\n\nA is the correct answer.\n\nUnless the employee has signed the NDA with his or her previous organization, there is no obligation for him or her not to share knowledge that was gained while working for the competitor.\n\nQuestion - 114\n\nA product description of a project can help in creating procurement details. Which one of the following best describes the product description?\n\nA. A product description defines the contracted work based on the requirements of the customer\n\nB. A product description defines the contracted work\n\nC. A product description defines the requirements for the contract work\n\nD. All of the above\nA is the correct answer.\n\nA product description defines the contracted work based on the requirements of the customer.\n\nQuestion - 115\n\nAs a project manager of a project, you have just completed Schedule network diagram. Which of the following time management activities have you completed?\n\nA. Estimate Activity Resources\nB. Sequence Activities\nC. Estimate Activity Durations\nD. Develop Schedule\n\nB is the correct answer.\n\nB is the correct answer. Schedule network diagram is an output of Sequence Activities.\n\nQuestion - 116\n\nYou are in the process of making a cost estimate for a large prestigious project. You decide to use the Three Point Estimation technique with Triangular Distribution. Based on your analysis and understanding you are confident that the project would be completed with a total cost of 108,000 $. You also estimate that a best case estimate would be 90000 $ while a worst case scenario would result in the costs incurred to shoot up to 138000 USD. What would the Three point Cost estimate be using Triangular Distribution?\n\nA. 112000 $\nB. 110000 $\nC. 28000 $\nD. None of the above\nA is the correct answer.\n\nThe correct answer is A. The question states we should use Three point estimate using triangular distribution. The formula for this estimation technique is $a + b + c / 3$ where $a = \\text{Most Likely estimate}$, $b = \\text{Estimate based on analysis of the Best case scenario}$ and $c = \\text{Estimate based on analysis of the Worst case scenario}$. So the Three point estimate using Triangular distribution is $108000 + 90000 + 138000 / 3 = 336000/3 = 112000$ $\\text{\\$}\n\nQuestion - 117\n\nMidway through the project as a Manager you are performing Earned Value Methodology to report performance. Based on your calculations you realize that the initial plan is no longer valid. However you still need to provide an EAC - what is the best course of action?\n\nA. Calculate EAC as $EAC = BAC / CPI$\nB. Calculate EAC as $EAC = AC + BAC - EV$\nC. Calculate EAC as $EAC = AC + (BAC - EV/(CPI * SPI )$\nD. Calculate EAC as $EAC = AC + \\text{Bottom up Estimate}$\n\nD is the correct answer.\n\nThe correct answer is D - Option A is to be used if past CPI is expected to continue. Option B is to be used if future work is going to be performed at the planned rate. Option C is to be used if both CPI and SPI influence remaining work. Option D is to be used when the initial plan is no longer valid - which is the case here.\n\nQuestion - 118\n\nAs a manager on a project you have identified and created the WBS and WBS Dictionary. You also plan to ensure that each deliverable gets the blessings of your stakeholders and sponsors. Which process are you planning to perform?\n\nA. Scope Verification\nB. Perform Quality Control\nC. Control Scope\nD. Define Scope\n\nA is the correct answer.\n\nThe correct answer is Scope Verification which deals with verifying that what was delivered was what was required.\n\nQuestion - 119\nYou have received a number of seller responses for contracting work related to setting up office cubicles. One of the bids received happens to be from a very good friend of yours. You know she has done good work in the past. What should be the BEST course of action?\n\nA. Do nothing and let the seller selection proceed\nB. Ensure that your friend gets the contract as she has done good work in the past\nC. Inform your company regarding the conflict of interest and disqualify your friend\nD. Inform your company regarding the conflict of interest and let selection of seller happen with no prejudice\n\nD is the correct answer.\n\nExplanation.\n\nQuestion - 120\nIn order to determine the details of the work to be performed in work packages - which of the following can be used?\n\nA. WBS\nB. WBS Dictionary\nC. Control Account\nD. Work Packages\n\nB is the correct answer.\n\nThe correct answer is Option B - WBS Dictionary. It provides details such as description of work to be done for each work package, any schedule milestones, statement of work. It is also used to prevent scope creep.\n\nQuestion - 121\n\nYou need to provide estimates for activities on the project. You and your team discuss and conclude that as detailed information is not yet available - the best option would be to use Parametric Estimates. The various ways to create Parametric Estimates are:\n\nA. Critical Path Method\nB. One Time Estimate\nC. Regression Analysis and Learning Curve\nD. Monte Carlo Analysis\n\nC is the correct answer.\n\nThe correct answer is C - Regression analysis and Learning Curve are ways of creating a Parametric Estimate. Regression analysis is also known as Scatter Diagram. Scatter diagrams consist of a graphical representation of two variables from a data set. They are used to detect the correlation between the variables being examined. Learning curve takes into consideration that if the nature of the work is repetitive - the person will perform subsequent work faster as efficiency improves. Option A has nothing to do with Parametric Estimates while Option D though is an estimation technique - it uses simulation and three time estimates - so it is not the correct answer.\n\nQuestion - 122\n\nWhich of the following best describes the role of a project sponsor?\nA. Project Sponsor is responsible for managing the project\nB. Project Sponsor is responsible for managing the quality of deliverables\nC. Project Sponsor is responsible for providing funding for the project\nD. Project Sponsor is responsible for identifying key stakeholders\n\nC is the correct answer.\n\nThe project sponsor is not responsible for managing the project nor the quality of deliverables - it is the role of the project manager. While the sponsor can aid in identifying key stakeholders - the key area a sponsor plays a part is in providing funding. The sponsor provides funding directly or indirectly and is responsible for approving or denying the budget. The project sponsor is also generally the one who approves the Project Charter - but that is not mentioned in the question. So the correct answer is Option C\n\nQuestion - 123\n\nYou are a project manager for a project. While reviewing the cost estimates for the project, you notice that one of the cost estimates for an element in the WBS is 20% higher than the previous project for a very similar work. What should you do next?\n\nA. Accept the estimate.\nB. Ask the person responsible about the difference.\nC. Ignore it.\nD. Reduce the estimate.\n\nB is the correct answer.\n\nBest option is to ask the person responsible about the difference and create the most accurate estimate that is practical.\n\nQuestion - 124\nYou are the sponsor of a project which has just kicked off. This is an ambitious project to build a top of the line 18 hole golf course. Which of the following BEST describes your role as a sponsor?\n\nA. Managing changes to the project\nB. Create the Work Performance Baselines\nC. Publish Work Performance Reports\nD. Publish the approved Project charter\n\nD is the correct answer.\n\nThe main objective of the sponsor is to create and publish a formally approved project charter. While the sponsor can help assist in preventing and managing changes to the project - this is the project manager’s job. Creating baselines and publishing work performance reports is also the job of the project manager - so option D is the correct answer.\n\nQuestion - 125\n\nAs a project manager of a project, you have just completed Schedule network diagram. What should you do NEXT in time management?\n\nA. Estimate Activity Resources\nB. Sequence Activities\nC. Estimate Activity Durations\nD. Develop Schedule\n\nA is the correct answer.\n\nA is the correct answer. Schedule network diagram is an output of Sequence Activities, NEXT process is Estimate Activity Resources.\n\nQuestion - 126\nThe key difference between Work performance data and Work performance Measurement is:\n\nA. There are no differences - both are the same\n\nB. Work performance data is the 'as of now' status of deliverables while Work performance measurement is a comparison between planned Vs Actuals\n\nC. Work performance measurement is the 'as of now' status of deliverables while Work performance data is a comparison between planned Vs Actuals\n\nD. Work performance data are the planned objectives\n\nB is the correct answer.\n\nWork performance data is a key output of 'Direct and Manage Project Work'. The key difference between the two is that the Work performance data consists of raw observations and measurements DURING activities being performed. It is the 'as of now' status while Work performance measurements is used to compare actual performance against what was planned. The correct answer is Option B\n\nQuestion - 127\n\nThe purpose of a contract is to distribute a reasonable amount of _____________ between the buyer and seller.\n\nA. Risk\n\nB. Responsibility\n\nC. Reward\n\nD. None\n\nA is the correct answer.\n\nA fair contract shares a reasonable amount of risk between the buyer and the seller.\nQuestion - 128\n\nA friend of yours approaches you seeking advice. She indicates she has offers from two organizations. Her role in one of the organization is that of a project Co-ordinator while in the other organization her role is that of a Project expediter. She is not quite clear of the difference between the two roles and seeks your advice. Which of the following statement is true?\n\nA. There is really no difference between the two\nB. Project Expediter has no authority and cannot take decisions. Project co-ordinator has some authority and decision making authority.\nC. Project co-ordinator has no authority and cannot take decisions. Project Expediter has some authority and decision making authority.\nD. Project expediters are found in projectized organizations and Project co-ordinators are found in Functional organizations\n\nB is the correct answer.\n\nA project expediter has no authority or decision making ability. A project co-ordinator has some amount of authority and some amount of decision making ability. So the correct answer is Option B.\n\nQuestion - 129\n\nIf a person desires to excel in his tasks - as per Maslow's Hierarchy of Needs - what type of a need is the person exhibiting?\n\nA. Love or Belonging\nB. Physiological\nC. Self-actualization\nD. Safety\n\nC is the correct answer.\nOption C is the correct answer. When a person desires to exceed or excel in their tasks - it is considered as the highest level of need where the person now wants to realize their full potential - which is Self-actualization.\n\nQuestion - 130\n\nAccording to Theory Y style of management - which of the following are correct assumptions?\n\nA. Employees are inherently lazy and not motivated.\n\nB. Employees need to be closely supervised and comprehensive systems of controls developed.\n\nC. Employees are only interested in self benefits and money.\n\nD. Employees are trustworthy and are motivated by doing a good job.\n\nD is the correct answer.\n\nOption D is the correct choice. Theory Y believes positively about employees and only option D reflects a positive attitude and belief. Option A,B and C are not the correct answer as they are the opposite of belief in employees - they indicates lack of trust in an employee which is not a correct assumption in the Theory Y style of management.\n\nQuestion - 131\n\nConformance to specifications document is a description of:\n\nA. Quality\n\nB. Scope\n\nC. Integration\n\nD. None of the above\n\nA is the correct answer.\nQuality on a project means that you are conforming to a standard that is set before you start the project.\n\nQuestion - 132\n\nYou are the project manager of a marketing project and need to purchase some equipment. The accounting department needs a unilateral contract from you. Accounting is referring to which of the following:\n\nA. Legal Binding Contract\nB. Purchase Order\nC. Statement of Work\nD. WBS\n\nB is the correct answer.\n\nA unilateral contract is simply a purchase order.\n\nQuestion - 133\n\nYou are out for lunch with a fellow project manager. She is in charge of a project that deals with laying out electrical cables across two towns. As you understand the plan of the layout - you realize that the cabling would cover a neighborhood with a history of criminal problems. You advise your fellow team manager that it would be prudent to insure the copper cables through a theft insurance. You also advise her regarding which insurance companies would give her the best insurance covers against theft. What risk response strategy did you just adopt?\n\nA. Risk mitigation\nB. Risk avoidance\nC. Risk transfer\nD. Risk acceptance\nC is the correct answer.\n\nThis is an example of Risk transfer where you have advised your fellow manager to insure against theft through insurance. Note that this does not eliminate the risk rather the risk is simply to be borne by the insurance company. It is also worthwhile to note that the transfer of negative risks comes with a premium to be paid to the party responsible for handling the risk. In this case the insurance company would need to be paid a premium for bearing this risk.\n\nQuestion - 134\n\nTo Complete Performance Index is used to determine ?\n\nA. When the project would be complete\nB. To determine the feasibility of the project\nC. To identify the risks in the project\nD. The cost performance required to meet certain objectives\n\nD is the correct answer.\n\nThe correct answer is - D . TCPI is a measure of the ratio of the work remaining to the funds remaining.\n\nQuestion - 135\n\nYou are managing a project and based on risk identification - you feel very confident that the project should run smoothly. The next day the lead architect indicates a risk which was not envisioned. He indicates a 10% possibility of the risk occurring and the effort involved of choosing an alternate path worth 2000 USD. The side effect of alternate path implementation is that a lot of testing efforts would get reduced worth 4500 USD and the possibility being 30%. What would be the EMV ?\n\nA. -$200\nB. $1350\nC. $1150\nD. $1550\n\nC is the correct answer.\n\nThe correct answer is $1150. In the case of the rework effort the EMV is -$200. The EMV of the side effect is $1350. So the total EMV is $1150.\n\nQuestion - 136\n\nAn estimate is required for a new project of an R and D nature - and it has been decided to create the estimates using WBS - with an emphasis on accuracy of the estimates. Your project manager also indicates sufficient time is being made available to provide the estimates - what would be the best estimation approach in this case?\n\nA. Parametric Estimation approach\nB. Analogous Estimation approach\nC. Top Down Approach\nD. Bottom Up Approach\n\nD is the correct answer.\n\nParametric and Analogous are clearly not the right choices. Being a new project - we do not have any historical data to rely on - so Analogous estimation is not an option. We also don't have any data of costs per unit - so Parametric estimation is also not an option. Now between Top down and Bottom up - both of these approaches use the WBS to come up with the estimates. With Top down we start with the high level and then drill down into the lower levels. Bottom-up estimates are more accurate as compared to Top down. Bottom up is also a more expensive and time-consuming type of estimate - however the question clearly indicates that time is not a concern - so the correct answer is Bottom up approach. Top down approach is used only if we have enough historical information on the project which is not true.\n\nQuestion - 137\nWhich of the following could not be provided with Activity Attributes\n\nA. Provide details regarding predecessor and successor activities.\n\nB. Provide details regarding Leads and Lags\n\nC. Provide details regarding who and where the activity will be performed\n\nD. Provide details regarding root causes of issues\n\nD is the correct answer.\n\nAll the options are correct - except option D Activity attributes do not provide details of root causes of issues.\n\nQuestion - 138\n\nAs a project manager you understand the importance of identifying all relevant stakeholders, their interest and influence and their needs and expectations. You have been assigned to handle a large construction project. You decide to do a thorough stakeholder analysis and you identify Laura and Sean. Based on your interactions and analysis - you know that both Sean and Laura are low in the pecking order so they do not wield any significant authority or power. However where it differs is in their interest in the project. Laura has a lot of interest while Sean is disinterested. You decide to plot them in a Power / Interest grid to help determine how you would manage these stakeholders. Which of the following is the best approach to handle these two stakeholders?\n\nA. Both Sean and Laura should be Kept Informed.\n\nB. Sean should be Monitored and Laura should be Kept informed.\n\nC. Both Sean and Laura should be Monitored.\n\nD. Sean should be Kept informed and Laura should be Monitored.\n\nB is the correct answer.\n\nBoth Sean and Laura do not wield a lot of power and authority. However the differentiator seems to be their level of interest. While Sean is disinterested, Laura has a high level of interest in the project. Stakeholders who have a high level of interest but who wield insignificant authority or power should be Kept informed - in this case Laura. Stakeholders who have a low level of\ninterest and who wield insignificant authority or power should be Monitored - in this case Kelly. The correct answer being - Option B\n\nQuestion - 139\n\nYou are in charge of managing a software development project which is related to simulations for driving racing cars. During Quality Assurance - a number of issues have been reported in the air tunnel modelling module. On deeper analysis - it is found that many of the issues were due to not understanding the requirements clearly and now additional time would be expended to fix the issues identified. This is a good example of:\n\nA. Corrective Action\nB. Preventive Action\nC. Defect Repair\nD. Quality Assurance\n\nC is the correct answer.\n\nThe question is intended to cause a confusion between preventive or corrective action. However the question does not state any example of any steps taken proactively so Preventive Action is not the right answer. If we were to consider Corrective action - It is a future response to the defect repair process or the correction, so that the cause of error or non-conformity will not occur again - which the above question does not state - so this is not an example of Corrective action. As is obvious the question does not state anything other than reporting defects which is really Quality Control so again it is not the right answer. Here the straightforward answer is option C - Defect repair.\n\nQuestion - 140\n\nWhich of the following is NOT part of a quality plan?\n\nA. Benchmarking\nB. Cost of Quality\nC. Design of experiments\nQuestion - 141\n\nAs a senior member in the executive management team - you have tasked project managers within your team to provide cost estimates for a huge project. You easily foresee the cost estimate of the project to run into millions of dollars. Along with the cost estimate - you are also expecting the Basis of estimates. What would you expect to be included in the documentation for Basis of estimates?\n\nA. Basis of estimate, assumptions, known constraints, range of estimate, confidence level\n\nB. Cost at unit level and confidence level\n\nC. WBS\n\nD. None of the above\n\nA is the correct answer.\n\nThe correct answer here is A which states all the necessary details to be provided as the Basis of estimates.\n\nQuestion - 142\n\nYour team has just bagged a software development project. The executive management is very pleased as this is a very prestigious project. However you are a little worried considering the complex nature of the project. You decide to try and identify the possible risks. You get all relevant stakeholders together and conduct mammoth discussions. Together you have come up with a number of risks. However based on your experience - you still feel that not all the risks have been identified. You decide to set aside some budget for the risks that you have not identified but are sure you will encounter. Where does this budget come from?\nA. Cost Management Plan\n\nB. Cost Baseline\n\nC. Contingency Reserves\n\nD. Management Reserve\n\nD is the correct answer.\n\nThe type of risk here is an unknown risk. For known risks risk responses can be proactively planned for. For the known risks where we cannot plan proactively - we set aside a reserve called Contingency Reserves. For unknown risks we set aside a Management Reserve. Cost management Plan deals with how you will manage costs on your project and Cost baseline is the baselined cost expected to be expended on the project.\n\nQuestion - 143\n\nYou have been assigned to manage a project that deals with setting up a railway line connecting two cities. The project is complex with a lot of contracting involved. You and experts in your organization are evaluating if the rail line alignment machinery should be purchased outright or if it would be better to lease. The cost of leasing the equipment is 1200 $ per day while the cost of an outright purchase is 96000 $ and a daily cost of 200 $. The duration of laying out the railway lines is scheduled to be an activity duration of 150 days. Should you purchase the machinery or be leased - which option would be more economical?\n\nA. Lease the machinery as it will be cheaper by 84000 USD\n\nB. Purchase the machinery as it its usage beyond the 80th day would be more cost effective to purchase rather than lease\n\nC. Purchase the machinery as it its usage beyond the 96th day would be more cost effective to purchase rather than lease\n\nD. Lease the machinery as it will be cheaper by 36000 USD\n\nC is the correct answer.\n\nThe question is actually looking for a simple mathematical formula!. Do not get flustered by all the numbers. The activity duration is 150 Days. So cost of leasing is 150 * 1200 = 180000 $, while cost of an outright purchase is 96000 + 200 * 150 = 96000 + 30000 = 126000 USD. So\ndefinitely leasing is not cheaper and purchasing the machinery is the better option. Now what is the break even point of a purchase - on the 96th day of usage of the machinery - the cost of purchase incurred is 115200 $ which is exactly the cost incurred if it were leased so 96th day is the break even point and hence the correct answer is option C. Take a breather - relax and digest the details - they are not as hard as they look!\n\nQuestion - 144\n\nAn activity has an Early Start(ES) of 5 days and Late Start of 16 days. What is the activity's float?\n\nA. 11 days\nB. 21 days\nC. 5 days\nD. 16 days\n\nA is the correct answer.\n\nA is the correct answer. Activity float = Late Start - Early Start = 16-5 = 11 days\n\nQuestion - 145\n\nWhich of the following statements are not true regarding WBS?\n\nA. Provides a graphical picture of the hierarchy of the project.\nB. Identifies all of the work that needs to be performed.\nC. Can help facilitate in estimating costs and schedule.\nD. Helps identify dependencies\n\nD is the correct answer.\n\nThe correct answer is D as WBS does not help identify dependencies.\nQuestion - 146\n\nYou are in charge of a project that is running behind schedule. Your lead architect approaches you and indicates that should he introduce a change - the project could possibly catch up on lost time. What should be the FIRST thing you should do?\n\nA. It's a great suggestion which can bring the project back on schedule - so go ahead and implement it.\n\nB. Ascertain the impact of the change to your cost and scope and then write a change request and get a formal approval\n\nC. Write a change request and get a formal approval before making any changes\n\nD. Flatly refuse to make any changes\n\nB is the correct answer.\n\nBoth options of refusing to make the change outright or making the change immediately without analyzing are incorrect - so clearly options A and D are not the right choices. The question asks about what you should do first - so though writing a change request and getting an approval is logical - even better is to first ascertain the impact of the change. You already know that the change can reduce the schedule but you should also try and find the impact of this change to your other constraints - which are scope and cost - so once you have analyzed the impact of this change - you can now submit a change request and seek approval - hence option B is the BEST course of action.\n\nQuestion - 147\n\nYou are in a very happy state today as you have completed all the deliverables. This was a complex project involving a lot of challenges - but with good management and a motivated team things have been completed successfully. What should you do next as a project manager?\n\nA. Perform Quality Control\n\nB. Update lessons learned\n\nC. Verify scope\nD. Disband the team\n\nB is the correct answer.\n\nThe question is looking for details related to the closing process group. Scope verification is performed during the monitoring and controlling process group. So is the case with Perform Quality Control. One of the most important things to do during project closure is to create the lessons learnt prior to disbanding the team. The correct answer is option B.\n\nQuestion - 148\n\nYour company has won a prestigious project which deals with building software to be used on spaceships landing on the moon. After building the schedule network diagram - you identify the critical path and also a number of Near-Critical Paths. What does this mean with respect to Risks related to Project Schedule?\n\nA. The project is at high risk of meeting its schedule considering additional near critical paths\nB. The project has no risks of meeting its schedule considering additional near critical paths\nC. Near Critical Path will have no impact on the schedule - hence no risks at all\nD. The Near Critical Path activities have a lot of Float - so there is no fear of not meeting the project completion.\n\nA is the correct answer.\n\nThe correct answer is A - greater the number of near critical paths greater the risk of the project not meeting its scheduled completion dates. This is because the Near Critical Path activities will have very little float - so thereby hardly any flexibility - so any slippages in these tasks - in addition to tasks on the Critical Path can lead to schedule slippage. This is why Options B, C and D are incorrect.\n\nQuestion - 149\n\nYou and your team have just created a schedule network diagram. You have come up with the estimates and have defined the durations and subsequently have identified the Critical Path. You now decide to do a 'Forward Pass' through the Schedule Network Diagram - what\nwould you be calculating?\n\nA. The Early Start and Early Finish for each activity\n\nB. The latest start and latest finish for each activity\n\nC. The duration of the other paths\n\nD. The duration of the critical path\n\nA is the correct answer.\n\nThe correct answer is - A. Option C and D are incorrect as the Forward Pass is not used to calculate the duration. In fact, based on duration, the critical path is calculated. Option B talks about Late Start and Late Finish - which are calculated using Backward Pass. Using 'Forward Pass' - we calculate the Early Start and Early Finish of all the activities in the network diagram.\n\nQuestion - 150\n\nYou and your team have done extensive brainstorming and discussions. You have also looked up the Organizations process assets and have come up with an exhaustive list of risks. You and your team members feel fairly confident now that you know all the risks. You decide to prioritize the risks and only focus on the high priority ones. A team member indicates that a large number of risks have very low priority. She suggests we simply ignore them. You disagree and decide to maintain a list of such low priority risks. Where will you maintain these low priority risks?\n\nA. Risk Register\n\nB. Risk Management Plan\n\nC. Watch List\n\nD. Issue Log\n\nC is the correct answer.\n\nThe risks have been identified - in the Risk register. Based on prioritization, risk priorities are also updated in the risk register. All risks which are deemed low on priority though maintained in the Risk Register are maintained in the Watch List specifically. The Risk Management Plan and the Issue Log are not meant to note or log risks - so the correct answer is Watch List.\nQuestion - 151\n\nAll of the following are false regarding the project scope statement:\n\nA. Describes the projects deliverables and the work required to create these deliverables.\nB. Project scope statement is expanded from the Preliminary Project Scope Statement.\nC. It defines what is in scope and what is not in scope.\nD. It defines the Project's product acceptance criteria.\n\nD is the correct answer.\n\nAll the options except option D are true regarding the project scope statement. The acceptance criteria are not defined in the Project Scope Statement. Rather they are taken care of in the Scope verification process.\n\nQuestion - 152\n\nA software development project has been awarded to one of the many vendors. Your company and the vendor have agreed to build this project using the Waterfall Methodology. You decide to check with the progress regarding when development will start. The Vendor informs you that the actual Development can only start after completion of the Design. Which type of relationship best describes the dependency between Design and actual Development?\n\nA. Finish-to-Finish\nB. Finish-to-Start\nC. Start-to-Start\nD. Start-to-Finish\n\nB is the correct answer.\n\nThe correct answer is Option B - Finish-to-Start which means that the Successor Activity cannot start without the Predecessor activity completing. In this case the Design is the Predecessor.\nactivity and Development is the Successor Activity. So here Development (Successor Activity) cannot start without completion of Design (Predecessor Activity)\n\nQuestion - 153\n\nYour friend who works as a project manager in a pharmaceutical company meets you over dinner. You see a drastic change in his temperament as compared to when you last met him. He seems dejected and complains that in his present organization - as a project manager - he has almost no authority and hardly any decision making ability. What kind of an organizational structure does your friend work in?\n\nA. A Product organization\nB. A Functional Organizational Structure\nC. A Strong Matrix Organizational Structure\nD. A Projectized Organizational Structure\n\nB is the correct answer.\n\nYour friend works in a Functional Organizational Structure. In such an organizational structure all the power and authority resides with the Functional Manager. Such organizations are hierarchial in nature - where each employee has one clear superior. People are grouped by specialities (Functional) - Example - Mechanical, Accounts, Marketing etc. These departments work independently of each other. So the correct answer is option B - Functional Organization\n\nQuestion - 154\n\nA weighted average duration estimate to calculate duration is called:\n\nA. PERT\nB. CPM\nC. GERT\nD. pareto chart\nA is the correct answer.\n\nA is the correct answer. Program Evaluation and Review Technique (PERT): Uses a weighted average duration estimate to calculate duration. Uses the probability of an estimate's accuracy. Expected Time = (Low + 4*Medium + High) / 6\n\nQuestion - 155\n\nWhich type of relationship is often used in Precedence Diagramming Method (PDM)?\n\nA. Finish-to-Finish\nB. Finish-to-Start\nC. Start-to-Start\nD. Start-to-Finish\n\nB is the correct answer.\n\nOption B is the correct answer - Finish-to-Start. This means that Successor Activity cannot happen till Predecessor Activity completes.\n\nQuestion - 156\n\nYou are managing a project related to building a skyscraper. However, as per regulations no work can be started till the government body has approved and provided necessary clearance. This is an example of what kind of dependency?\n\nA. Mandatory Dependency\nB. Hard Logic\nC. Discretionary Dependency\nD. External Dependency\nD is the correct answer.\n\nThe correct answer is D - this is an externally imposed or mandated dependency. Options A and B are both the same and are not the correct choices.\n\nQuestion - 157\n\nThe primary benefit of meeting Quality Requirements are (Choose all that apply)\n\nA. Less Rework, Higher productivity, Lower costs, Increased stakeholder satisfaction, Increased profitability.\nB. Decreased productivity due to time spent on Quality Requirements.\nC. Increased costs due to rework.\nD. Decreased stakeholder satisfaction.\n\nA is the correct answer.\n\nOption A is the correct answer - All of the details stated are correct benefits of meeting Quality Requirements. By doing a cost benefit analysis of each quality activity - we can compare the cost of Quality with expected benefit. Options B, C and D infact are results of poor Quality.\n\nQuestion - 158\n\nWhich of the following statements is TRUE regarding Fixed Price Contract\n\nA. The buyer has the least risk in this type of contract if scope is clearly defined\nB. Changes can be made in scope by the buyer with no impact to cost\nC. Should be the choice of contract when you need work to begin right away\nD. All of the above\n\nA is the correct answer.\nDid you choose option D? - if so read again - which options sound incorrect?. Changes to scope cannot be made without a cost implication - in fact this is best applicable when the seller clearly defines the scope. If work needs to begin right away the contract type should be Time and Money - not Fixed price since you may not have everything clearly defined. So the right answer is option A.\n\nQuestion - 159\n\n**Control chart helps:**\n\nA. determine if the process is \"in control\"\n\nB. how various elements of a system are interrelated\n\nC. showS trends in a process over time\n\nD. shows the pattern of a relationship between two variables\n\nA is the correct answer.\n\nControl Charts: Control charts are graphic display of the results over a time of a process. They are used to determine if the process is \"in control\".\n\nQuestion - 160\n\nYou are managing a project that is responsible for setting up an alcohol distillery. Your team is in its eighth month of execution. One of the vendors informs you that the agitators delivery is going to be delayed by a week. You look up the project management plan and the schedule baselines and decide to set up all the reactors first. Based on your analysis by moving tasks around you see that there would be no impact to any of the performance measurement baselines. What should you do next?\n\nA. Go ahead and execute the rescheduled tasks as there is no impact to any of the baselines\n\nB. Write up a change request and submit to change control for approval\n\nC. Analyze the impact of the change to the triple constraints and then submit a change request\n\nD. Do nothing as this would cause changes to the baselines\nA is the correct answer.\n\nBe careful and read carefully regarding the situation you are being asked to evaluate. In this case the change is not going to impact any of the baselines. In such cases the project manager has the authority to make changes to the project if there is no impact to the baselines. This is one condition where changes can be made without undergoing change control - but note that this is done after ensuring that there is no impact to the baselines - so the correct answer is option A.\n\nQuestion - 161\n\nWhich of the following statements are true regarding Control Account?\n\nA. It is used as a Tool and Technique in Activity Definition process.\n\nB. Used to estimate cost at a level lower than the work package.\n\nC. Used to control costs of the project.\n\nD. Used in Integrated Change Control.\n\nA is the correct answer.\n\nControl Accounts are used to provide a cost estimate at a level higher than the work package. They are used as a technique in activity definition process. They are not used to control costs of the project and neither in Integrated change control. So the correct answer is option A.\n\nQuestion - 162\n\nGiven a project which reports a CPI less than 1 - you have asked one of your managers to generate the TCPI - what formula should the project manager use in this case?\n\nA. \\( \\frac{BAC - EV}{BAC - AC} \\)\n\nB. \\( \\frac{BAC - EV}{EAC - AC} \\)\n\nC. \\( \\frac{EV}{AC} \\)\nD. EV / PV\n\nB is the correct answer.\n\nThe correct answer is Option B - Option A is to be used when the project is within budget - in our case the CPI value is less than 1 so the project is not within budget. Option B is to be used when the project is over budget - which is the case for us - so it is the correct formula to use. Options C and D are not TCPI formulae - they are the CPI and SPI calculations so they are not the correct choice.\n\nQuestion - 163\n\nIn which process \"meeting\" is not used as Tools and Techniques.\n\nA. Identify Stakeholders\nB. Plan Stakeholder Management\nC. Manage Stakeholder Engagement\nD. Control Stakeholder Engagement\n\nC is the correct answer.\n\n\"meeting\" is not used as Tools and Techniques in Manage Stakeholder Engagement process.\n\nQuestion - 164\n\nWhile planning for a project you decide to keep a good grip over project risks. You and your team members have come up with the list of possible risks and would now like to prioritize them based on their probability and impact. This activity would take place in which process?\n\nA. Perform Qualitative Risk Analysis\nB. Perform Quantitative Risk Analysis\nC. Risk Identification\nD. Risk Register\n\nA is the correct answer.\n\nAfter the Risks are identified - risk prioritization based on impact and probability is done in the Qualitative Risk Analysis. The question states that the risks are already identified - so Risk Identification is already done. Risk Register is an output of the Risk Identification process - there is no such process as Risk Register. Quantitative Risk Analysis deals with assigning a numerical value to each risk - so the correct answer is Qualitative Risk Analysis.\n\nQuestion - 165\n\nWhich hierarchical chart shows all the tasks in a list?\n\nA. RBS\nB. OBS\nC. WBS\nD. Scope statement\n\nC is the correct answer.\n\nC is the correct answer. Work Breakdown Structure shows all the tasks.\n\nQuestion - 166\n\nWhich of the following is NOT part of the Control Quality process?\n\nA. fishbone diagram\nB. Quality audits\nC. Pareto Diagram\nD. Histogram\nB is the correct answer.\n\nQuality audits are part of the Perform Quality Assurance process.\n\nQuestion - 167\n\nYou have a team of project managers reporting to you. Recently a new manager relatively inexperienced has joined your team. Considering his level of experience you assign him to a small project. Considering low complexity and few stakeholders involved - you envision the project to have no surprises or hiccups. You have identified the number of communication channels to be only 6. However with increase in scope of work 2 additional stakeholders who need to be communicated with join the team. You ask the manager to identify the number of communication channels now. The correct answer is:\n\nA. 6 \nB. 10 \nC. 8 \nD. 15\n\nD is the correct answer.\n\nThe correct answer is 15. Note that the question provides the initial number of communication channels as 6. This means the number of stakeholders are 4. With the addition of two more stakeholders - the number of stakeholders would increase to 6. So the number of communication channels would be 15.\n\nQuestion - 168\n\nYou are managing a project which is in its first month of execution. In one of the meetings with a key stakeholder - the stakeholder asks for some changes to be made in the current ongoing work. The stakeholder is asking for the change to be implemented immediately. You realize that the changes being asked for will need the Project Management Plan and the Scope baseline to be updated which have already been baselined. As a Project manager what is the BEST course of action?\nA. Make the changes as they are being asked for by a key stakeholder\n\nB. Analyze the impact of the change to triple constraints\n\nC. Generate a change request and submit to Integrated change control\n\nD. Refuse to make the change as it is a deviation from approved Scope\n\nC is the correct answer.\n\nAny changes being asked for or requested to any approved plan need to be formally reviewed by the Change Control Board. Option A is not the correct answer as no changes should be made without a formal approval from CCB. Option B while sounds like the best choice the question states the impact of the change to the scope - so the impact analysis to 'triple constraints' is already done - so though option B is the best choice - it is already taken care of. Option D is clearly incorrect as any project is bound to have changes and the very purpose of change control is to ensure changes are governed and controlled in a systematic manner - hence the correct answer is Option C.\n\nQuestion - 169\n\nComparing target dates with the actual or forecast start and finish dates is called:\n\nA. Variance Analysis\n\nB. Earned Value\n\nC. Progress Reporting\n\nD. Crashing\n\nA is the correct answer.\n\nA is the correct answer. Variance Analysis: Comparing target dates with the actual or forecast start and finish dates.\nYou are in charge of a large software development project. As a part of the project schedule - it was planned to complete two core components by the end of October. You are now in August and you realize that the project is falling behind schedule. You do a quick review and decide that the schedule can be met by adding additional staff to the activities on the critical path. This is an example of:\n\nA. Fast Tracking\nB. Resource Levelling\nC. Crashing\nD. Scope Creep\n\nC is the correct answer.\n\nThe correct answer is option C - As the project is falling behind schedule and deliveries cannot be impacted - the manager has chosen to add additional resources to activities on the critical path. This is an example of Crashing - NOTE Crashing may result in increased risk and rework.\n\nQuestion - 171\n\nYou are in the process of determining how long it would take to complete your project. What would be the best tool to use in this case?\n\nA. Go through the WBS\nB. Go through the Activity List\nC. Perform a Root Cause Analysis\nD. Use a Network Diagram\n\nD is the correct answer.\n\nThe correct answer is Option D - A Network Diagram is the best choice to identify the Activity Duration.\nQuestion - 172\n\nA project is overbudget when\n\nA. CPI > 1\nB. SPI > 1\nC. CPI and SPI > 1\nD. CPI less than 1\n\nD is the correct answer.\n\nThe correct answer is D - CPI = EV / AC - so if the EV is less than AC then CPI less than 1 which means the project is over budget.\n\nQuestion - 173\n\nYou and your team have worked hard and are about to successfully deliver the project. The customer is also happy with the deliverables and overall everyone is happy with how the project was delivered. You have written up the performance reviews of each individual in the project team. As a Project Manager in your current organization you know that the team will get disbanded and in the next project you may not get the same team members who so successfully delivered the current project. What kind of Organization Structure does this represent?\n\nA. Weak Matrix\nB. Balanced Matrix\nC. Projectized\nD. Functional\n\nC is the correct answer.\n\nThis represents a Projectized Organization structure. In a Projectized organization teams are disbanded at the end of the project. In a Functional organization teams report to the Functional manager and are never disbanded. They continue in their own departments and continue to report to the Functional Manager. A weak matrix organization is very similar to a Functional Organization and role of Project Manager is limited. In a balanced matrix organization staff\nreports to a Project manager and a Functional Manager - in the question above there is no mention of a functional manager - so Balanced Matrix is also not the correct option. Hence the answer is Projectized - Option C\n\nQuestion - 174\n\nThe process of communicating and working with the stakeholders to meet their expectations, address issues and foster appropriate stakeholder engagement in project activities throughout project lifecycle is called ____________?\n\nA. Plan Stakeholder Management\nB. Identify Stakeholders\nC. Manage Stakeholder Engagement\nD. Control Stakeholder Engagement\n\nC is the correct answer.\n\nThe process of communicating and working with the stakeholders to meet their expectations, address issues and foster appropriate stakeholder engagement in project activities throughout project lifecycle is called Manage Stakeholder Engagement\n\nQuestion - 175\n\nChoose all that are true regarding Management Reserves and Contingency Reserves\n\nA. Management reserves are part of Cost Baseline but Contingency reserves are not\nB. Contingency Reserves are for unknown unknowns\nC. Management Reserves are for known unknowns\nD. None of the above\n\nD is the correct answer.\nThe correct answer is D - none of the above. Contingency Reserves are part of cost baseline while Management reserves are not - so Option A is clearly incorrect. Contingency Reserves are meant to take care of risk mitigating cost for identified risks - they are the costs of known unknowns while Management reserve is for unknown unknowns - things like unforeseen work which is part of the scope. Options B and C state exactly the opposite - so they are not the correct answers - which leaves us with D - None of the above.\n\nQuestion - 176\n\nYou are managing a project that is scheduled to un for an entire year. Things were looking good after the first two months. However due to some mistakes made by the construction crew at the end of the third month - you realize that the expected work to be completed at this stage is not complete. As a result the project is behind schedule and is also over budget. However there are stiff penalties in the contract should the project not complete within the stipulated timelines. Your senior management as a result has committed to additional staff to the project if required. What would be the Estimate at Completion for this project?\n\nA. EAC = BAC / CPI\nB. EAC = AC + BAC - EV\nC. EAC = AC + (BAC - EV)/(CPI * SPI )\nD. EAC = AC + Bottom up Estimate\n\nC is the correct answer.\n\nThe correct answer is C - Option A is to be used if past CPI is expected to continue. Option B is to be used if future work is going to be performed at the planned rate. Option C is to be used if deadlines must be met and both CPI and SPI influence remaining work - here the project must be completed within stipulated timelines. Option D is to be used when the initial plan is no longer valid - which is not the case here.\n\nQuestion - 177\n\nOne of your project managers reports that her project has hit a roadblock. You are surprised since just the week before on reviewing the project everything seemed to be on track. She explains that a team member has identified a problem which was never envisioned in the risk identification process. Based on the analysis the impact would be to the cost to rectify the issue. What would be\nthe best course of action?\n\nA. Add this risk with its impact and probability to the Risk register.\n\nB. Use the Management reserve to correct the issue\n\nC. Use the Contingency reserve to correct the issue\n\nD. Schedule a meeting with stakeholders and explain the problem\n\nB is the correct answer.\n\nThe best course of immediate action on identifying a risk is to add it into the risk register along with its probability and impact. That is applicable for risks and not issues! In this case, the risk has already occurred - it is no longer a risk - it's a reality - an issue! While scheduling a meeting is an option, it is not the best choice. Being a project manager, you are empowered and calling up meetings every time you run into issues would not be looked upon favorably. The correct answer is using the management reserve which is meant for unknown risks when they occur. Contingency reserves are meant to be used for known risks when they occur.\n\nQuestion - 178\n\nOf the following baselines which is not a part of the Project Management Plan?\n\nA. Scope Baseline\n\nB. Quality Baseline\n\nC. Cost Baseline\n\nD. Schedule Baseline\n\nB is the correct answer.\n\nThe project management plan contains the following baselines: Scope, Schedule and Cost. In fact, there is no such thing as a Quality Baseline - so the correct answer is option B.\n\nQuestion - 179\nA company wants to hire a PMP, and you are applying for the position in the company. You are scheduled to take the PMP exam in a few days. At your interview, a comment is made implying that you are PMP certified. What do you do?\n\nA. Clarify that you are scheduled to take your PMP certification exam soon, but are not yet PMP certified.\n\nB. Confirm that you are a PMP certified and you will be certified soon if you pass the exam.\n\nC. Both of the above are true.\n\nD. None of the above\n\nA is the correct answer.\n\nYou have the responsibility to provide accurate, truthful representations concerning your qualifications, experience, and performance of services to a company.\n\nQuestion - 180\n\nA project is reporting a negative Cost Variance - what does this mean?\n\nA. The project is under Budget\n\nB. The project is over Budget\n\nC. The project is running as per Budget\n\nD. None of the above\n\nB is the correct answer.\n\nThe correct answer is - B : CV = (EV - AC) So if the Cost Variance is in the negative the Actual Cost is greater than the earned value which means the project is running over budget.\n\nQuestion - 181\nWhich of the following is not a Risk Identification tool or technique?\n\nA. Risk Register\nB. Documentation Reviews\nC. Brainstorming\nD. Interviewing\n\nA is the correct answer.\n\nDocumentation reviews helps identify risks based on the plans and assumptions - so this is a Risk Identification tool. Brainstorming deals with getting together various stakeholders and identifying potential risks. Interviewing experienced project participants, stakeholders and subject matter experts is also a great source of identifying risks. Risk Register is not a tool - rather it is the document in which identified risks are documented - so the Risk Register is not a Risk Identification tool.\n\nQuestion - 182\n\nAs a project manager of a large product - you and your team have shipped the deliverables to your customer. However the customer has reported a number of serious issues in the quality of deliverables - as a result of which the cost of quality of your project is deemed high. In the above scenario which type of cost would have caused the cost of quality to increase?\n\nA. Less Rework.\nB. Higher productivity.\nC. Lower costs.\nD. Increased stakeholder satisfaction.\n\nD is the correct answer.\n\nOptions A, B and C are benefits of meeting Quality Requirements. The question states what has contributed to increased cost of Quality. As the stakeholder is not satisfied with the deliverables - there is rework involved, there is an impact on productivity and increases cost. It also decreases stakeholder satisfaction - so amongst the choices option D is the correct option.\nQuestion - 183\n\nProject Quality Management includes:\n\nA. Customer satisfaction\nB. Prevention over inspection\nC. Continuous improvement\nD. All of the above\n\nD is the correct answer.\n\nProject Quality Management includes: Customer satisfaction, Prevention over inspection, Continuous improvement and Management responsibility.\n\nQuestion - 184\n\nA relatively new project manager joins your company. You have assigned her to handle a project that deals with laying out electrical cables. One day she informs you that some government body has been sending her a lot of queries related to the project and its layout. It seems that the government body was not considered as a stakeholder by her. You decide to review the list of identified Stakeholders - so you ask her to provide you with the comprehensive list - where should this information be found?\n\nA. Project Management Plan\nB. Stakeholder Management Plan\nC. Stakeholder Engagement Matrix\nD. Stakeholder Register\n\nD is the correct answer.\n\nStakeholder information contains information such as details of stakeholders - name, location etc, their expectations, interest, influence. Whether they are internal or external, are they\nsupportive or in resistance or neutral. So the best source of information regarding stakeholders is the Stakeholder Register which is option D.\n\nQuestion - 185\n\nA project is in execution. A team member approaches the project manager and indicates that she is not sure of what work she needs to perform. Which document would be the best source of this information?\n\nA. Project Scope Management Plan\nB. Project Scope Statement\nC. Project Management Plan\nD. Work Breakdown Structure Dictionary\n\nD is the correct answer.\n\nThe correct answer is Option D - WBS Dictionary which provides details of the work to be done in detail.\n\nQuestion - 186\n\nWhich of the following statement is true regarding Procurement Documents?\n\nA. These are the response documents provided by Seller to the Buyer.\nB. It is the formal agreed contract between the buyer and seller\nC. It is used to solicit proposals from sellers and contains details of expected services or work to be done\nD. Describes how product or services will be acquired externally and type of contract to be administered\n\nC is the correct answer.\nProcurement documents are used to solicit responses from sellers. As such it contains sufficient information regarding the work in the form of Procurement statement of work. Option A is incorrect since this document serves as an input for sellers to provide response and it is not the response of the seller. This is not the contract as we are still looking for prospective sellers. Option D is wrong since it is the Procurement Management plan which determines how product or services will be acquired externally and type of contract to be administered. The correct answer is option C\n\nQuestion - 187\n\nYou have a large complex project to deliver and you are evaluating different motivational strategies to motivate your team to get the job done. You subscribe to the belief that to get things done and to motivate staff - they must be rewarded with monetary rewards. You believe that by rewarding employees they would get motivated - which of the following motivational theories are you applying?\n\nA. Herzberg Hygiene Theory\nB. Maslows theory of Hierarchy of needs\nC. Expectancy theory\nD. Theory of coercion\n\nC is the correct answer.\n\nHerzberg's Hygiene theory states that it is the Job content that motivates staff - so in this case Option A is not the correct answer. Maslows theory of Hierarchy of needs indicates the levels of needs starting with Physiological needs and ending with Self Actualization - so Option B is not correct as well. Vrooms Expectancy theory states that employees can be motivated by altering the person's effort-to-performance expectancy, performance-to-reward expectancy, and reward valences - so Option C is correct. Option D is clearly incorrect as the question does not indicate any imposed mandates or threats which would fall under Theory X style of management.\n\nQuestion - 188\n\nWhich of the following statement is NOT true regarding starting a project without a charter?\n\nA. There is a risk of constant change without a formal approved charter\nB. There is no risk of greater number of changes and disruption without a project charter.\n\nC. Managing expectations of different stakeholders can be an increased challenge without a formal approved charter.\n\nD. The project manager will be undermined since the project manager would lack formal authority.\n\nB is the correct answer.\n\nAll the options A, C and D correctly state the disadvantages of starting a project without a formal approved charter. These are the very reasons why a project should not be started without an approved charter where risks of constant change, managing stakeholder expectation, lack of visibility of project's vision, mission, business case and also lack of authority to the project manager to execute the project. So the correct answer to the question is option B since it incorrectly states that there is no risk of increased changes without an approved project charter.\n\nQuestion - 189\n\nA project is ahead of schedule when\n\nA. CPI > 1\nB. SPI > 1\nC. CPI and SPI > 1\nD. SPI less than 1\n\nB is the correct answer.\n\nThe correct answer is B - SPI = EV / PV - so if the EV is greater than PV then SPI > 1 which means the project is ahead of schedule.\n\nQuestion - 190\n\nYou are in charge of a software project and you are almost 40% complete. The project\nstakeholders want a [performance report to date. You had planned to use Earned Value Management methodology. You come up with the following numbers: \\( EV = 300 \\), \\( AC = 100 \\), \\( PV = 150 \\), \\( BAC = 600 \\), \\( ETC = 300 \\). You and your team are very confident of continuing at the same rate as till now. The project has not faced any major issues and you and your team's confidence level is high that the project would complete without any hiccups. Based on this information what would be the EAC for the project?\n\nA. 400 \nB. 200 \nC. 400 \nD. 106 \n\nB is the correct answer.\n\nThe correct answer is B - this is because here it is stated that whatever issues or lack of them experienced in the project are expected to continue - so here the past performance is expected to continue. So the formula: \\( EAC = BAC / CPI \\). CPI = \\( EV / AC = 300 / 100 = 3 \\). EAC = \\( 600 / 3 = 200 \\)\n\nQuestion - 191\n\nAs a project manager you understand the importance of identifying all relevant stakeholders, their interest and influence and their needs and expectations. You have been assigned to handle a large construction project. You decide to do a thorough stakeholder analysis and you identify Bob and Kelly. Based on your interactions and analysis - you know that Bob wields a lot of authority and also has a huge interest in the project. Kelly too wields a lot of power but is largely uninterested. You decide to plot them in a Power / Interest grid to help determine how you would manage these stakeholders. Which of the following is the best approach to handle these two stakeholders?\n\nA. Both Bob and Kelly should be Managed closely. \nB. Both Bob and Kelly should be Kept satisfied. \nC. Kelly should be monitored while Bob should be Kept satisfied. \nD. Kelly should be kept satisfied while Bob should be Managed closely.\nD is the correct answer.\n\nBoth Bob and Kelly have power and authority. However, the differentiator seems to be their level of interest. While Kelly is disinterested, Bob has a high level of interest in the project. Stakeholders who have a high level of interest and who wield a lot of authority or power should be Managed closely - in this case Bob. Stakeholders who have a low level of interest but who wield a lot of authority or power should be Kept satisfied - in this case Kelly. The correct answer being - Option D\n\nQuestion - 192\n\nRegarding Rolling Wave Planning which of the following statements are true - choose all that apply?\n\nA. Rolling Wave Planning is a form of progressive elaboration.\n\nB. It is a planning technique performed only once.\n\nC. Work that is to be performed in the long term is planned in greater detail as compared to work in near term\n\nD. It is a form of planning where all the details are estimated upfront.\n\nA is the correct answer.\n\nOption A is the correct answer which correctly explain Rolling Wave Planning. Option B, C and D are clearly not correct since not all details are estimated upfront - rather only the immediate activities or tasks are estimated upfront. This process is performed iteratively and not only once.\n\nQuestion - 193\n\nYou have worked in the current organization and from managing projects you have now graduated to portfolio management and have a number of project managers reporting into you. Your company has bagged a prestigious project of a very similar nature to the one you had executed some years back. You ask the current project manager to look up the lessons learned for the past project - where would these be stored?\n\nA. Projects performance reports\nB. Projects status reports\n\nC. Projects record management system\n\nD. Organizational process assets\n\nD is the correct answer.\n\nWhile all the options seem to be good choices - the best choice in this case would be Organizational Process Assets. Lessons learned are always a part of the Organizations process assets. It is such assets that enable an organization take informed decisions.\n\nQuestion - 194\n\nYour company has just bagged a project for electric cable layout and routing for a large shopping complex - and you have been tasked with providing the cost estimates. You choose to rely on your past experience of similar such projects. You breakdown the costs of the cables per foot and unit cost of cable trays. What type of cost estimating technique are you relying on?\n\nA. Analogous cost estimate\n\nB. Top down cost estimate\n\nC. Bottom up cost estimate\n\nD. Parametric estimates\n\nD is the correct answer.\n\nParametric estimates is the correct choice - this is so because we have derived the cost per unit - cost of cables per feet etc. Based on the unit cost parametric estimates are used to determine an estimate of the total cost.\n\nQuestion - 195\n\nWhen does Scope Verification Occur?\nA. At the end of the project\nB. At the beginning of the project\nC. At the end of each phase of the project\nD. During Quality Control\n\nC is the correct answer.\n\nScope Verification occurs at the end of each phase of the project. Option A relates to Product verification not Scope verification.\n\nQuestion - 196\n\nWhich of the following statements below is NOT true regarding differences between administrative closure and contract closure?\n\nA. Contract closure is performed before administrative closure\nB. Administrative closure is not complete without Contract closure\nC. Administrative closure is done only once per phase or once for the project - while Procurement closure can be done as many times as needed depending on the number of contracts\nD. Lessons learned is performed only during administrative closure\n\nD is the correct answer.\n\nAll the options except Option D correctly state the differences between administrative and contract closure. In fact option D is not true since in both forms of closure lessons learned are documented and updated to the OPA.\n\nQuestion - 197\n\nYou are responsible for managing a project that deals with laying out a freeway connecting two major port cities. Progress in the past has been smooth but lately in the past few months you have observed a schedule and budget overrun. You decide to hold a meeting with your team\nmembers. On discussions you realize team members went ahead and made changes at the behest of the client requests on site. You are pretty sure the changes were not a part of the project scope statement - this is an example of:\n\nA. Scope Creep \nB. Gold Plating \nC. Integrated Change Control \nD. Fast Tracking \n\nA is the correct answer.\n\nThis is an example of Scope Creep. Integrated change control deals with formally approving or rejecting changes before they are implemented so it is not the correct answer. Fast tracking is a schedule compression technique - so it too is not the correct answer. While Gold Plating is related to change in scope it is generally done intentionally or knowingly for some strategic purpose. Scope creep relates to uncontrolled changes in product or projects scope and is often due to client interference.\n\nQuestion - 198\n\nYou are part of a Quality Assurance team and have scheduled a Quality Audit for one of the projects - what would not be a goal or objective of performing this audit?\n\nA. To determine if the project activities comply to the organizations policies, processes and procedures \nB. Identify all the good and best practices being implemented \nC. Identify all gaps, non-conformity and shortcomings \nD. Identify the root cause of the Quality issues \n\nD is the correct answer.\n\nOption A, B and C are the objectives or goals of this exercise. The purpose of the audit is to identify what is working well, what is missing but never to find root cause of issues - which is done in Process analysis. Since the question is asking what is not a goal or objective of performing a Quality Audit - option D is the correct answer.\nQuestion - 199\n\nAs per Maslows theory of Hierarchy of needs - which is the correct order of needs?\n\nA. Psychological, Physiological, Safety, Love / belonging, Esteem\nB. Safety, Love / belonging, Esteem, Self-actualization, Physiological\nC. Self-actualization, Love / belonging, Esteem, Safety, Physiological\nD. None of the above\n\nD is the correct answer.\n\nOption D is the correct answer. As per Maslows theory of Hierarchical needs - the first need of humans is a basic need for survival (air, water, food etc) - this need is termed as Physiological. Once this need is met - the next need is the need of Safety and Security - this can be in the form of a Secure Job, Health, Insurance etc. The next need is termed as need of Love or Belonging. As per Maslows theory - humans need to belong and find acceptance among their social groups. The fourth need is termed as the need of Esteem - to be respected and valued by others. Once the above four needs are met - then the final need - Self Actualization - which is the desire to accomplish. So the correct order of needs as per this theory is: Physiological, Safety, Love/Belonging, Esteem, Self-actualization.\n\nQuestion - 200\n\nYou have just completed developing the Schedule Network Diagram for a project that deals with building super sonic state of the art Jet planes. You have identified your critical path which includes building a wind tunnel. You see that in addition there is another path which deals with building the tail of the plane - whose duration is close to the critical path. You also notice considerable floats on the other paths. You now need to assign resources to the tasks - you have a few team members who are highly skilled and a team of resources who are relatively inexperienced. What would be the best course of action while assigning resources?\n\nA. It is irrelevant which resources are assigned to tasks - resource skills and critical paths have nothing in common\n\nB. Assign all the skilled resources to building the wind tunnel which is the critical path - assign the non skilled task to building the tail.\nC. Assign the inexperienced staff to the task of building the wind tunnel - and assign the skilled staff to all other tasks.\n\nD. Assign one half of the skilled resources to the task of building the wind tunnel and the other half to building the tail and assign the less experienced staff to all the other tasks.\n\nD is the correct answer.\n\nOption D is the best option. Option A and C are just plain wrong - you should always ensure activities on the critical path do not get delayed - so having the best equipped staff on critical path activities is important. While Option B is an option - it cannot be the BEST choice since if we assign all the experienced staff on building the wind tunnel - the critical path activities are taken care of - but the question also states of a path which is near Critical - building of the tail. Not paying attention to this path by assigning inexperienced staff is not a good option. Amongst the choices option D is the best fit - where you are paying attention to both the critical path and near critical path by assigning your best and most skilled or experienced resources to the activities on the Critical path and Near Critical Path."}}},{"rowIdx":168,"cells":{"id":{"kind":"string","value":"479a01a683fb3b8b03e8947d020fdc3746db407e"},"text":{"kind":"string","value":"Abstract. We define a procedure for canonicalising SPARQL 1.1 queries. Specifically, given two input queries that return the same solutions modulo variable names over any RDF graph (which we call congruent queries), the canonicalisation procedure aims to rewrite both input queries to a syntactically canonical query that likewise returns the same results modulo variable renaming. The use-cases for such canonicalisation include caching, optimisation, redundancy elimination, question answering, and more besides. To begin, we formally define the semantics of the SPARQL 1.1 language, including features often overlooked in the literature. We then propose a canonicalisation procedure based on mapping a SPARQL query to an RDF graph, applying algebraic rewritings, removing redundancy, and then using canonical labelling techniques to produce a canonical form. Unfortunately a full canonicalisation procedure for SPARQL 1.1 queries would be undecidable. We rather propose a procedure that we prove to be sound and complete for a decidable fragment of monotone queries under both set and bag semantics, and that is sound but incomplete in the case of the full SPARQL 1.1 query language. Although the worst case of the procedure is super-exponential, our experiments show that it is efficient for real-world queries, and that exponential cases are rare.\n\nKeywords: SPARQL, RDF, query, semantics, caching, canonicalisation, congruence, equivalence\n\n1. Introduction\n\nThe Semantic Web provides a variety of standards and techniques for enhancing the machine-readability of Web content in order to increase the levels of automation possible for day-to-day tasks. RDF [1] is the standard framework for the graph-based representation of data on the Semantic Web. In turn, SPARQL [2] is the standard querying language for RDF, composed of basic graph patterns extended with expressive features that include path expressions, relational algebra, aggregation, federation, among others.\n\nThe adoption of RDF as a data model and SPARQL as a query language has grown significantly in recent years [3, 4]. Prominent datasets such as DBpedia [5] and Wikidata [6] comprise in the order of hundreds of millions or even billions of RDF triples, and their associated SPARQL endpoints receive millions of queries per day [7, 8]. Hundreds of other SPARQL endpoints are likewise available on the Web [4]. However, a survey carried out by Buil-Aranda et al. [4] found that a large number of SPARQL endpoints experience performance issues such as latency and unavailability. The same study identified the complexity of SPARQL queries as one of the main causes of these problems, which is perhaps an expected result given the expressivity of the SPARQL query language where, for example, the decision problem consisting of determining if a solution is given by a query over a graph is PSPACE-hard for the SPARQL language [9].\n\nOne way to address performance issues is through caching of sub-queries [10, 11]. The caching of queries is done by evaluating a query, then storing its result set, which can then be used to answer future instances of the same query without using any additional resources. The caching of sub-queries identifies common query patterns whose results can be returned for queries that contain said query patterns. However, this is complicated by the fact that a given query can be expressed in different, semantically equivalent ways. As a result, if we are unable to verify if a given query is equivalent to\none that has already been cached, we are not using the cached results optimally: we may miss relevant results.\n\nIdeally, for the purposes of caching, we could use a procedure to canonicalise SPARQL queries. To formalise this idea better, we call two queries equivalent if (and only if) they return the same solutions over any RDF dataset. Note however that this notion of equivalence requires the variables of the solutions of both queries to coincide. In practice variable names will often differ across queries, where we would still like to be able to cache and retrieve the results for queries whose results are the same modulo variable names. Hence we call two queries congruent if they return the same solutions, modulo variable names, over any RDF dataset; in other words, two queries are congruent if (and only if) there exists a one-to-one mapping from the variables in one query to the variables of the other query that makes the first equivalent to the latter.\n\nIn this paper, we propose a procedure by which congruent SPARQL queries can be “canonicalised”. We call such a procedure sound if the output query is congruent to the input query, and complete if the same output query is given for any two congruent input queries.\n\nExample 1.1. Consider the following two SPARQL queries asking for names of aunts:\n\n```sparql\nSELECT DISTINCT ?z WHERE {\n ?w :mother ?x .\n UNION\n { ?w :father ?x .}\n}\n```\n\nBoth queries are congruent: they always return the same results for any RDF dataset. Now rather consider a third SPARQL query:\n\n```sparql\nSELECT DISTINCT ?n WHERE {\n UNION\n UNION\n}\n```\n\nNote that the pattern ?b :name ?n . in this query is redundant. This query is not equivalent to the former two because the variable that is returned is different, and thus the solutions (which contain the projected variable), will not be the same. However all three queries are congruent; for example, if we rewrite ?n to ?x in the third query, all three queries become equivalent.\n\nCanonicalisation aims to rewrite all three (original) queries to a unique, congruent, output query.\n\nThe potential use-cases we foresee for a canonicalisation procedure include the following:\n\n**Query caching:** As aforementioned, a canonicalisation procedure can improve caching for SPARQL endpoints. By capturing knowledge about query congruence, canonicalisation can increase the cache hit rate. Similar techniques could also be used to identify and cache frequently appearing (congruent) sub-queries [11].\n\n**Views:** In a conceptually similar use case to caching, our canonical procedure can be used to describe views [12]. In particular, the canonicalisation procedure can be used to create a key that uniquely identifies each of the views available.\n\n**Log analysis:** Logs are often analysed to gain statistics on real-world queries that are useful to understand the importance of different SPARQL features, or to build suitable benchmarks, etc. [7, 13]. Our canonicalisation procedure could be used as a pre-processing step to group congruent queries.\n\n**Query optimisation:** Canonicalisation may help with query optimisation by reducing the variants to be considered for query planning, detecting duplicate sub-queries that can be evaluated once, removing redundant patterns (as may occur under query rewriting strategies for reasoning [14]), etc.\n\n**Learning over queries:** Canonicalisation can reduce superficial variance in queries used to train machine learning models. For example, recent question answering systems learn translations from natural language questions to queries [15], where canonicalisation can be used to homogenise the syntax of queries used for training.\n\nOther possible but more speculative use-cases involve signing or hashing SPARQL queries, discovering near-duplicate or parameterised queries (by considering constants as variables), etc. Furthermore, with some adaptations the methods proposed here could be generalised to other query languages, such as to canonicalise SQL queries, Cypher queries [16], etc.\n\nA key challenge for canonicalising SPARQL queries is the prohibitively high computational complexity that it entails. More specifically, the query equivalence problem takes two queries and returns true if and only if they return the same solutions for any dataset, or false otherwise. In the case of SPARQL, this problem is intractable (NP-complete) even when simply permitting joins (with equality conditions). Even worse,\nthe problem becomes undecidable when features such as projection and optional matches are added [17]. Since a canonicalisation procedure can be directly used to decide equivalence, this means that canonicalisation is at least as hard as the equivalence problem in computational complexity terms, meaning it will likewise be intractable for even simple fragments and undecidable when considering the full SPARQL language. There are thus fundamental limitations in what can be achieved for canonicalising SPARQL queries.\n\nWith these limitations in mind, we propose a canonicalisation procedure that is always sound, but only complete for a monotone fragment of SPARQL under set or bag semantics. This monotone fragment permits unions and joins over basic graphs patterns, some examples of which were illustrated in Example 1.1. We further provide sound, but incomplete, canonicalisation of the full SPARQL 1.1 query language, whereby the canonicalised query will be congruent to the input query, but not all pairs of congruent input queries will result in the same output query. In the case of incomplete canonicalisation, we are still able to find novel congruences, in particular through canonical labelling of variables, which further allows for ordering operands in a consistent manner. Reviewing the aforementioned use-cases, we believe that this “best-effort” form of canonicalisation is still useful, as in the case of caching, where missing an equivalence will require re-executing the query (which would have to be done in any case), or in the case of learning over queries, where incomplete canonicalisation can still increase the homogeneity of the training examples used.\n\nAs a high-level summary, our procedure combines four main techniques for canonicalisation.\n\n1. The first technique is to convert SPARQL queries to an algebraic graph, which abstracts away syntactic variances, such as the ordering of operands for operators that are commutative, and the grouping of operands for operators that are associative.\n\n2. The second technique is to apply algebraic rewritings on the graph to achieve normal forms over combinations of operators. For example, we rewrite monotone queries – that allow any combination of join, union, basic graphs patterns, etc. – into unions of basic graph patterns; this would rewrite the first and third queries shown in Example 1.1 into a form similar to the second query.\n\n3. The third technique is to apply redundancy elimination within the algebraic graph, which may involve the removal of elements of the query that do not affect the results; this technique would remove the redundant ?b :name ?n . pattern from the third query of Example 1.1.\n\n4. The fourth and final technique is to apply a canonical labelling of the algebraic graph, which will provide consistent labels to variables, and which in turn allows for the (unordered) algebraic graph to be serialised back into the (ordered) concrete syntax of SPARQL in a canonical way.\n\nWe remark that the techniques do not necessarily follow the presented order; in particular, the second and third techniques can be interleaved in order to provide further canonicalisation of queries.\n\nThis paper extends upon our previous work [18], where we initially outlined a sound and complete procedure for canonicalising monotone SPARQL queries. The novel contributions of this extended paper include:\n\n- We close a gap involving translation of monotone queries under bag semantics that cannot return duplicates into set semantics.\n- We provide a detailed semantics for SPARQL 1.1 queries; formalising and understanding this is a key prerequisite for canonicalisation.\n- We extend our algebraic graph representation in order to be able to represent SPARQL 1.1 queries, offering partial canonicalisation support.\n- We implement algebraic rewriting rules for specific SPARQL 1.1 operators, such as those relating to filters; we further propose techniques to canonicalise property path expressions.\n- We provide more detailed experiments, which now include results over a Wikidata query log, a comparison with existing systems from the literature that perform pairwise equivalence checks, and more detailed stress testing.\n\nWe also provide extended proofs of results that were previously unpublished [19], as well as providing extended discussion and examples throughout.\n\nThe outline of the paper is then as follows. Section 2 provides preliminaries for RDF, while Section 3 provides a detailed semantics for SPARQL. Section 4 provides a problem statement, formalising the notion of canonicalisation. Section 5 discusses related works in the areas of systems that support query containment, equivalence, and congruence. Sections 6 and 7 discuss our SPARQL canonicalisation framework for monotone queries, and SPARQL 1.1, respectively. Section 8 presents evaluation results. Section 9 concludes.\n2. RDF Data Model\n\nWe begin by introducing the core concepts of the RDF data model over which the SPARQL query language will later be defined. The following is a relatively standard treatment of RDF, as can be found in various papers from the literature [20, 21]. We implicitly refer to RDF 1.1 unless otherwise stated.\n\n2.1. Terms and Triples\n\nRDF assumes three pairwise disjoint sets of terms: IRIs (I), literals (L) and blank nodes (B). Data in RDF are structured as triples, which are 3-tuples of the form \\((s, p, o)\\) \\(\\in\\) IBL, denoting the subject \\(s\\), the predicate \\(p\\), and the object \\(o\\) of the triple.\\(^1\\) There are three types of literals: a plain literal \\(s\\) is a simple string, a language-tagged literal \\((s, l)\\) is a pair of a simple string and a language tag, and \\((s, d)\\) is a pair of a simple string and an IRI (denoting a datatype).\n\nIn this paper we use Turtle/SPARQL-like syntax, where \\(\\text{_:a} \\text{, xsd:string, etc.}\\), denote IRIs; \\(\\text{_:b} \\text{, _:x1, etc.}\\), denote blank nodes; \"a\", \"xy z\", etc., denote plain literals; \"hello\"@en, \"hola\"@es, etc., denote language-tagged literals; and \"true\"^^xsd:boolean, \"1\"^^xsd:int, etc., denote datatype literals.\n\n2.2. Graph\n\nAn RDF graph \\(G\\) is a set of RDF triples. It is called a graph because each triple \\((s, p, o)\\) \\(\\in\\) \\(G\\) can be viewed as a directed labelled edge of the form \\(s \\xrightarrow{p} o\\), and a set of such triples forms a directed edge-labelled graph.\n\n2.3. Simple Entailment and Equivalence\n\nBlank nodes in RDF have special meaning; in particular, they are considered to be existential variables. The notion of simple entailment [20, 22] captures the existential semantics of blank nodes (among other fundamental aspects of RDF). This same notion also plays a role in how the SPARQL query language is defined. Given two RDF graphs \\(G\\) and \\(H\\), we say that \\(G\\) simple-entails \\(H\\), denoted \\(G \\models H\\), if and only if there exists a blank node mapping \\(\\alpha\\) such that \\(\\alpha(H) \\subseteq G\\) [20, 22]. Furthermore, if \\(G \\models H\\) and \\(H \\models G\\), then we say that they are simple equivalent, denoted \\(G \\equiv H\\).\n\nDeciding simple entailment \\(G \\models H\\) is known to be NP-complete [20]. Deciding the simple equivalence \\(G \\equiv H\\) is likewise known to be NP-complete.\n\nWe remark that the RDF standard defines further entailment regimes that cover the semantics of datatypes and the special RDF and RDFS vocabularies [22]; we will not consider such entailment regimes here.\n\n2.4. Isomorphism\n\nGiven that blank nodes are defined as existential variables [22], two RDF graphs differing only in blank node labels are thus considered isomorphic [21, 23].\n\nFormally, if a blank node mapping of the form \\(\\alpha : B \\rightarrow B\\) is one-to-one, we call it a blank node bijection. Two RDF graphs \\(G\\) and \\(H\\) are defined as isomorphic, denoted \\(G \\simeq H\\), if and only if there exists a blank node bijection \\(\\alpha\\) such that \\(\\alpha(G) = H\\); i.e., the two RDF graphs differ only in their blank node labels. We remark that if \\(G \\simeq H\\), then \\(G \\equiv H\\); however, the inverse does not always hold as we discuss in the following.\n\nDeciding the isomorphism \\(G \\simeq H\\) is known to be GI-complete [21] (as hard as graph isomorphism).\n\n2.5. Leanness and core\n\nExistential blank nodes may give rise to redundant triples. In particular, an RDF graph \\(G\\) is called lean if and only if there does not exist a proper subgraph \\(G' \\subseteq G\\) of it such that \\(G' \\models G\\); otherwise \\(G\\) is called non-lean. Non-lean graphs can be seen, under the RDF semantics, as containing redundant triples. For example, given an RDF graph \\(G = \\{(\\text{x, y, z}), (\\text{x, y, z}), (\\text{x, y}, :b)\\}\\), the second triple is seen as redundant: it states that \\(x\\) has some value on \\(y\\), but we know this already from the first triple, so the second triple says nothing new.\n\nThe core of an RDF graph \\(G\\) is then an RDF graph \\(G'\\) such that \\(G' \\equiv G\\) and \\(G\\) is lean; intuitively it is a version of \\(G\\) without redundancy. For example the core of the aforementioned graph would be \\(G' = \\{(\\text{x, y, z}), (\\text{x, y})\\}\\); note that \\(G' \\equiv G\\) and \\(G\\) is lean, but \\(G' \\nleq G\\). The core of a graph is unique modulo isomorphism [20]; hence we refer to the core of a graph.\n\nDeciding whether or not an RDF graph is lean is known to be coNP-complete [20]. Deciding if \\(G'\\) is the core of \\(G\\) is known to be DP-complete [20].\n\n\\(^1\\) In this paper we concatenate set names to denote their union; e.g., IBL is used as an abbreviation for the union I \\(\\cup\\) B \\(\\cup\\) L.\n2.6. Merge\n\nBlank nodes are considered to be scoped to a local RDF graph. Hence when combining RDF graphs, applying a merge (rather than union) avoids blank nodes with the same name in two (or more) graphs clashing. Given two RDF graphs G and G’, and a blank node bijection α such that bnodes(α(G)) ∩ bnodes(G’) = ∅, we call α(G) ∪ G’ an RDF merge, denoted G ⊔ G’. The merge of two graphs is unique modulo isomorphism.\n\n3. SPARQL 1.1 Semantics\n\nWe now introduce SPARQL 1.1 [2]. We will begin by defining a SPARQL dataset over which queries are evaluated. We then introduce the syntax of queries. Thereafter we discuss the evaluation of queries under both set and bag semantics. These definitions extend similar preliminaries found in the literature [20, 24]. However, our definitions of the semantics of SPARQL 1.1 extend beyond the core of the language and rather than including the entire language, this section provides a novel formalisation of the SPARQL 1.1 language that is key for our discussion on canonicalisation, but may also be of independent interest. Henceforth, when we mention SPARQL, we refer to SPARQL 1.1 unless otherwise stated.\n\n3.1. Query Syntax\n\nBefore we introduce an abstract syntax for SPARQL queries, we provide some preliminaries:\n\n- A triple pattern \\((s, p, o)\\) is a member of the set \\(\\text{VIBL} \\times \\text{VI} \\times \\text{VIBL}\\) (i.e., an RDF triple allowing variables in any position and literals as subject).\n- A basic graph pattern \\(B\\) is a set of triple patterns.\n We denote by \\(\\text{vars}(B) := \\bigcup_{(s, p, o) \\in B} \\text{V} \\cap \\{s, p, o\\}\\) the set of variables used in \\(B\\).\n- A path pattern \\((s, o, e)\\) is a member of the set \\(\\text{VIBL} \\times \\text{P} \\times \\text{VIBL}\\), where \\(\\text{P}\\) is the set of all path expressions defined by Table 1.\n- A navigational graph pattern \\(N\\) is a set of paths patterns and triple patterns (with variable predicates). We denote by \\(\\text{vars}(N) := \\bigcup_{(s, e, o) \\in N} \\text{V} \\cap \\{s, e, o\\}\\) the set of variables used in \\(N\\).\n- A term in \\(\\text{VIBL}\\) is a built-in expression. Let \\(\\bot\\) denote an unbound value and \\(\\varepsilon\\) an error. We call \\(\\phi\\) a built-in function if it takes a tuple of values from \\(\\text{IBL} \\cup \\{\\bot, \\varepsilon\\}\\) as input and returns a single value in \\(\\text{IBL} \\cup \\{\\bot, \\varepsilon\\}\\) as output. An expression \\(\\phi(R_1, \\ldots, R_n)\\), where each \\(R_1, \\ldots, R_n\\) is a built-in expression, is itself a built-in expression.\n- An aggregation function \\(\\psi\\) is a function that takes a bag of tuples from \\(\\text{IBL}\\) as input and returns a value in \\(\\text{IBL} \\cup \\{\\bot, \\varepsilon\\}\\) as output. An expression \\(\\psi(R_1, \\ldots, R_n)\\), where each \\(R_1, \\ldots, R_n\\) is a built-in expression, is an aggregation expression.\n- If \\(R\\) is a built-in expression, and \\(\\Delta\\) is a boolean value indicating ascending or descending order, then \\((R, \\Delta)\\) is an order comparator.\n\nWe then define the abstract syntax of a SPARQL query as shown in Table 2. Note that we abbreviate \\PARTIAL\\ OPTIONAL as OPT, \\FILTER EXISTS\\ as FE, and FILTER NOT EXISTS\\ as FNE. Otherwise mapping from SPARQL’s concrete syntax to this abstract syntax is straightforward, with the following exceptions:\n\n- For brevity, we assume that operators usable in the built-in expressions of the concrete syntax – including \\(!\\) for negation, \\&\\& for conjunction, \\(||\\ for disjunction, \\(=, <, <=, >=, !=\\ for equality and inequality; + and - for unary plus and minus; and + for addition, and - for subtraction, * for multiplication, / for division, – are denoted as unary, binary and/or n-ary functions, e.g., \\text{SUM(?a, ?b, ?c)}\\) rather than \\text{?a+?b+?c}.\n- We combine \\text{FROM} and \\text{FROM\\ NAMED}\\ into one feature, FROM, so they can be evaluated together.\n\n\\begin{table}[h]\n\\centering\n\\caption{SPARQL property path syntax}\n\\begin{tabular}{|l|}\n\\hline\nThe following are path expressions:\n\\hline\n\\hline\n\\(p\\) & a predicate (IRI) \\\\\n\\hline\n\\((p_1|\\ldots|p_k)^+\\) & any (inv.) predicate not listed \\\\\n\\hline\n\\hline\nand if \\(e_1, e_2\\) are path expressions:\n\\hline\n\\hline\n\\(\\varepsilon\\) & an inverse path \\\\\n\\hline\n\\(e_1/e_2\\) & a path of \\(e_1\\) followed by \\(e_2\\) \\\\\n\\hline\n\\(e_1|e_2\\) & a path of \\(e_1\\) or \\(e_2\\) \\\\\n\\hline\n\\(e^+\\) & a path of zero or more \\(e\\) \\\\\n\\hline\n\\(e^\\ast\\) & a path of one or more \\(e\\) \\\\\n\\hline\n\\(e?\\) & a path of zero or one \\(e\\) \\\\\n\\hline\n\\(\\langle\\rangle\\) & brackets used for grouping \\\\\n\\hline\n\\end{tabular}\n\\end{table}\nAggregates without grouping can be expressed\n\n\\[\nB = \\{ \\text{a basic graph pattern}. \\}\n\\]\n\n\\[\nN = \\{ \\text{a navigational graph pattern}. \\}\n\\]\n\n\\[\nQ_1 = \\{ \\text{a graph pattern on } V_1. \\}\n\\]\n\n\\[\nQ_2 = \\{ \\text{a graph pattern on } V_2. \\}\n\\]\n\n\\[\nQ = \\{ \\text{a graph pattern on } V. \\}\n\\]\n\n\\[\nR = \\{ \\text{a built-in expression}. \\}\n\\]\n\n\\[\n\\mathcal{M} = \\{ \\text{a bag of solution mappings on } V_\\mathcal{M} = \\bigcup_{\\mathcal{M} \\in \\text{Dom}(\\mathcal{M})}. \\}\n\\]\n\n\\[\n\\{ \\text{a graph pattern on } V \\}\n\\]\n\n\\[\n\\text{x is an IRI.}\n\\]\n\n\\[\n\\text{v is a variable.}\n\\]\n\n\\[\n\\Delta \\text{ is a boolean value.}\n\\]\n\n\\[\n\\text{A is a (possibly empty) set of pairs } \\{(A_1, v_1), \\ldots, (A_n, v_n)\\}, \\text{ where } A_1, \\ldots, A_n \\text{ are aggregation expressions, } v_1, \\ldots, v_n \\text{ are variables not appearing in } V \\cup V' \\text{ such that } v_i \\neq v_j \\text{ for } 1 \\leq i < j \\leq n, \\text{ and where } \\text{vars}(A) = \\{v_1, \\ldots, v_n\\}\n\\]\n\n\\[\n\\{ \\text{a graph pattern on } V^c, V. \\}\n\\]\n\n\\[\nV^c \\text{ is a non-empty set of variables.}\n\\]\n\n\\[\n\\Lambda = \\{ \\text{an aggregation expression}. \\}\n\\]\n\n\\[\n\\text{Q is a group-by pattern on } (V', V).\n\\]\n\n\\[\n\\text{Q is a group-by pattern on } (\\emptyset, V).\n\\]\n\n\\[\n\\text{Q is a group pattern on V'.}\n\\]\n\n\\[\n\\text{GROUP}_{\\text{op}}(Q) \\text{ is a group-by pattern on } (V', V).\n\\]\n\n\\[\n\\text{HAVING}_{\\text{op}}(Q') \\text{ is a group-by pattern on } (V', V).\n\\]\n\n\\[\n\\text{AGG}_{\\text{op}}(Q') \\text{ is a graph pattern on } (V' \\cup \\text{vars}(A), V).\n\\]\n\n\\[\n\\text{Q is a graph pattern on } V.\n\\]\n\n\\[\n\\text{Q is a sequence pattern on } V.\n\\]\n\n\\[\n\\text{Q is a sequence pattern on } V.\n\\]\n\n\\[\n\\text{k is a non-zero natural number.}\n\\]\n\n\\[\n\\text{Q is a sequence pattern on } V \\text{ that does not contain the same blank node in two different graph patterns.}\n\\]\n\n\\[\n\\text{V is a set of variables.}\n\\]\n\n\\[\nB = \\{ \\text{a basic graph pattern}. \\}\n\\]\n\n\\[\nX = \\{ \\text{a set of IRIs and/or variables}. \\}\n\\]\n\n\\[\n\\text{Q is a query but not a from query}\n\\]\n\n\\[\n\\text{X and } X' \\text{ are sets of IRIs}\n\\]\n\n\\[\n\\text{FROM}_{\\text{op}}(Q) \\text{ is a from query and a query.}\n\\]\n\n\\[\n\\text{A query such as DESCRIBE } \\langle x \\rangle \\langle y \\rangle \\text{ in the concrete syntax can be expressed in the abstract syntax with an empty pattern } \\text{DESCRIBE}_{\\{x,y\\}}().\n\\]\n\n\\[\n\\text{Aggregates without grouping can be expressed with } \\text{GROUP}_{\\{\\}}(Q)(D). \\text{ We assume that every query in the abstract syntax with a group-by pattern uses } \\text{AGG} - \\text{ possibly } \\text{AGG}_{\\{\\}}(Q) - \\text{ to generate a graph pattern (and “flatten” groups).}\n\\]\n\n\\[\n\\text{Some aggregate functions accept arguments in the case of SPARQL, including a DISTINCT modifier, or a delimiter in the case of CONCAT. For simplicity, we assume that these are distinct functions, e.g., COUNT(\\cdot) versus COUNTDISTINCT(\\cdot).}\n\\]\n\n\\[\n\\text{SPARQL allows SELECT } \\ast \\text{ to indicate that values for all variables should be returned. Otherwise SPARQL requires that at least one variable be specified. A SELECT } \\ast \\text{ clause can be written in the abstract syntax as SELECT}_{\\{\\}}(Q) \\text{ where } Q \\text{ is a graph pattern on } V. \\text{ Also the abstract syntax allows empty projections SELECT}_{\\{\\}}(Q), \\text{ which greatly simplifies certain definitions and proofs; this can be represented in the concrete syntax as}\n\\]\nSELECT ?empty, where ?empty is a fresh variable not appearing in the query.\n\n- In the concrete syntax, SELECT allows for built-in expressions and aggregate expressions to be specified. We only allow variables to be used. However, such expressions can be bound to variables using BIND or AGG.\\(^2\\)\n\n- In the concrete syntax, ORDER BY allows for using aggregate expressions in the order comparators. Our abstract syntax does not allow this as it complicates the definitions of such comparators. Ordering on aggregate expressions can rather be achieved using sub-queries.\n\n- We use \\([Q_1 \\text{ SERVICE}^2 Q_2]\\) to denote SERVICE, where \\(\\Delta = \\text{true}\\) indicates the SILENT keyword is invoked, and \\(\\Delta = \\text{false}\\) indicates that it is not.\n\n- We do not consider SERVICE with variables as it has no normative semantics in the standard [25].\n\nAside from the latter point, these exceptions are syntactic conveniences that help simplify later definitions.\n\n3.2. Datasets\n\nSPARQL allows for indexing and querying more than one RDF graph, which is enabled through the notion of a SPARQL dataset. Formally, a \\textit{SPARQL dataset} \\(D := (G, \\{(x_1, G_1), \\ldots, (x_n, G_n)\\})\\) is a pair of an RDF graph \\(G\\) called the \\textit{default graph}, and a set of \\textit{named graphs} of the form \\((x_i, G_i)\\), where \\(x_i\\) is an IRI (called a \\textit{graph name}) and \\(G_i\\) is an RDF graph; additionally, graph names must be unique, i.e., \\(x_i \\neq x_k\\) for \\(1 \\leq j < k \\leq n\\). We denote by \\(G_D\\) the default graph \\(G\\) of \\(D\\) and by \\(D^* = \\{(x_1, G_1), \\ldots, (x_n, G_n)\\}\\) the set of all named graphs in \\(D\\). We further denote by \\(G_{D[s]}\\) the graph \\(G_i\\) such that \\((x_i, G_i) \\in D^*\\) or the empty graph if \\(x_i\\) does not appear as a graph name in \\(D^*\\).\n\n3.3. Services\n\nWhile the SPARQL standard defines a wide range of features that compliant services must implement, a number of decisions are left to a particular service. First and foremost, a service chooses what dataset to index. Along these lines, we define a SPARQL service as a tuple \\(S = (D, R, A, \\leq, \\text{describe})\\), where:\n\n- \\(D\\) is a dataset;\n- \\(R\\) is a set of supported built-in expressions;\n- \\(A\\) is a set of supported aggregate expressions;\n- \\(\\leq\\) is a total ordering of RDF terms and \\(\\bot\\);\n- describe is a function used to describe RDF terms.\n\nWe will denote by \\(D_S\\) the dataset of a particular service. The latter two elements will be described in more detail as they are used. The SPARQL standard does define some minimal requirements on the set of built-in expressions, the set of aggregate expressions, the ordering of terms, etc., that a standards-compliant service should respect. We refer to the SPARQL standard for details on these requirements [2].\n\n3.4. Query Evaluation\n\nThe semantics of a SPARQL query \\(Q\\) can be defined in terms of its evaluation over a SPARQL dataset \\(D\\), denoted \\(Q(D)\\) which returns \\textit{solution mappings} that represent “matches” for \\(Q\\) in \\(D\\).\n\n3.4.1. Solution mappings\n\nA \\textit{solution mapping} \\(\\mu\\) is a partial mapping from variables in \\(V\\) to terms \\(\\text{IBL}\\). We denote the set of all solution mappings by \\(B\\). Let \\(\\text{dom}(\\mu)\\) denote the domain of \\(\\mu\\), i.e., the set of variables for which \\(\\mu\\) is defined. Given \\(\\{v_1, \\ldots, v_n\\} \\subseteq V\\) and \\(\\{x_1, \\ldots, x_n\\} \\subseteq \\text{IBL} \\cup \\{\\bot\\}\\), we denote by \\(\\{v_1/x_1, \\ldots, v_n/x_n\\}\\) the mapping \\(\\mu\\) such that \\(\\text{dom}(\\mu) = \\{v_i \\mid x_i \\notin \\{\\bot, \\varepsilon\\}\\} \\text{ for } 1 \\leq i \\leq n\\) and \\(\\mu(v_i) = x_i \\text{ for } v_i \\in \\text{dom}(\\mu)\\). We denote by \\(\\mu_\\emptyset\\) the empty solution mapping (such that \\(\\text{dom}(\\mu_\\emptyset) = \\emptyset\\)).\n\nWe say that two solution mappings \\(\\mu_1\\) and \\(\\mu_2\\) are \\textit{compatible}, denoted \\(\\mu_1 \\sim \\mu_2\\), if and only if \\(\\mu_1(v) = \\mu_2(v)\\) for every \\(v \\in \\text{dom}(\\mu_1) \\cap \\text{dom}(\\mu_2)\\). We say that two solution mappings \\(\\mu_1\\) and \\(\\mu_2\\) are \\textit{overlapping}, denoted \\(\\mu_1 * \\mu_2\\), if and only if \\(\\text{dom}(\\mu_1) \\cap \\text{dom}(\\mu_2) \\neq \\emptyset\\).\n\nGiven two compatible solution mappings \\(\\mu_1 \\sim \\mu_2\\), we denote by \\(\\mu_1 \\cup \\mu_2\\) their combination such that \\(\\text{dom}(\\mu_1 \\cup \\mu_2) = \\text{dom}(\\mu_1) \\cup \\text{dom}(\\mu_2)\\), and if \\(v \\in \\text{dom}(\\mu_1)\\) then \\((\\mu_1 \\cup \\mu_2)(v) = \\mu_1(v)\\), otherwise if \\(v \\in \\text{dom}(\\mu_2)\\) then \\((\\mu_1 \\cup \\mu_2)(v) = \\mu_2(v)\\). Since the solution mappings \\(\\mu_1\\) and \\(\\mu_2\\) are compatible, for all \\(v \\in \\text{dom}(\\mu_1) \\cap \\text{dom}(\\mu_2)\\), it holds that \\((\\mu_1 \\cup \\mu_2)(v) = \\mu_1(v) = \\mu_2(v)\\), and thus \\(\\mu_1 \\cup \\mu_2 = \\mu_2 \\cup \\mu_1\\).\n\nGiven a solution mapping \\(\\mu\\) and a triple pattern \\(t\\), we denote by \\(\\mu(t)\\) the image of \\(t\\) under \\(\\mu\\), i.e., the result of replacing every occurrence of a variable \\(v\\) in \\(t\\) by \\(\\mu(t)\\) (generating an unbound \\(\\bot\\) if \\(v \\notin \\text{dom}(\\mu)\\)). Given a basic graph pattern \\(B\\), we denote by \\(\\mu(B)\\) the image of \\(B\\) under \\(\\mu\\), i.e., \\(\\mu(B) := \\{\\mu(t) \\mid t \\in B\\}\\). Likewise,\ngiven a navigational graph pattern \\( N \\), we analogously denote by \\( \\mu(N) \\) the image of \\( N \\) under \\( \\mu \\).\n\nBlank nodes in SPARQL queries can likewise play a similar role to variables though they cannot form part of the solution mappings. Given a blank node mapping \\( \\alpha \\), we denote by \\( \\alpha(B) \\) the image of \\( B \\) under \\( \\alpha \\) and by \\( bnodes(B) \\) the set of blank nodes used in \\( B \\); we define \\( \\alpha(N) \\) and \\( bnodes(N) \\) analogously.\n\nFinally, we denote by \\( R(\\mu) \\) the result of evaluating the image of the built-in expression \\( R \\) under \\( \\mu \\), i.e., the results of replacing all variables \\( v \\) in \\( R \\) (including in nested expressions) with \\( \\mu(v) \\) and evaluating the resulting expression. We denote by \\( \\mu \\models R \\) that \\( \\mu \\) satisfies \\( R \\), i.e., that \\( R(\\mu) \\) returns a value interpreted as true.\n\n### 3.4.2. Set vs. bag vs. sequence semantics\n\nSPARQL queries can be evaluated under different semantics, which may return a set of solution mappings \\( M \\), a bag of solution mappings \\( \\mathcal{M} \\), or a sequence of solution mappings \\( M \\). Sets are unordered and do not permit duplicates. Bags are unordered and permit duplicates. Sequences are ordered and permit duplicates.\n\nGiven a solution mapping \\( \\mu \\) and a bag of solution mappings \\( \\mathcal{M} \\), we denote by \\( \\mathcal{M}(\\mu) \\) the multiplicity of \\( \\mu \\) in \\( \\mathcal{M} \\), i.e., the number of times that \\( \\mu \\) appears in \\( \\mathcal{M} \\); we say that \\( \\mu \\in \\mathcal{M} \\) if and only if \\( \\mathcal{M}(\\mu) > 0 \\) (otherwise, if \\( \\mathcal{M}(\\mu) = 0 \\), we say that \\( \\mu \\notin \\mathcal{M} \\)). We denote by \\( |\\mathcal{M}| = \\sum_{\\mu \\in \\mathcal{M}} \\mathcal{M}(\\mu) \\) the (bag) cardinality of \\( \\mathcal{M} \\). Given two bags \\( \\mathcal{M} \\) and \\( \\mathcal{M}' \\), we say that \\( \\mathcal{M} \\subseteq \\mathcal{M}' \\) if and only if \\( \\mathcal{M}(\\mu) \\leq \\mathcal{M}'(\\mu) \\) for all \\( \\mu \\in \\mathcal{M} \\). Note that \\( \\mathcal{M} \\subseteq \\mathcal{M}' \\) and \\( \\mathcal{M}' \\subseteq \\mathcal{M} \\) if and only if \\( \\mathcal{M} = \\mathcal{M}' \\).\n\nGiven a sequence \\( M \\) of length \\( n \\) (we denote that \\( |M| = n \\)), we use \\( M[i] \\) (for \\( 1 \\leq i \\leq n \\)) to denote the \\( i \\)th solution mapping of \\( M \\), and we say that \\( \\mu \\in M \\) if and only if there exists \\( 1 \\leq i \\leq n \\) such that \\( M[i] = \\mu \\). We denote by \\( M[i..j] \\) (for \\( 1 \\leq i \\leq j \\leq n \\)) the sub-sequence \\( (M[i], M[i+1], \\ldots, M[j-1], M[j]) \\) of elements \\( i \\) to \\( j \\) of \\( M \\), inclusive, in their original order; if \\( i > n \\) then \\( M[i..j] \\) is defined as the empty sequence (); otherwise if \\( j > n \\), then \\( M[i..j] \\) is defined to be \\( M[i..n] \\). Given two sequences \\( M_1 \\) and \\( M_2 \\), we denote by \\( M_1M_2 \\) their concatenation. For a sequence \\( M \\) of length \\( n > 0 \\), we define the deletion of index \\( i \\leq n \\), denoted \\( del(M, i) \\), as the concatenation \\( M[1..i-1]M[i+1..n] \\) if \\( i < 1 \\), or \\( M[2..n] \\) otherwise. We call \\( j \\) a repeated index of \\( M \\) if there exists \\( 1 \\leq i < j \\) such that \\( M[i] = M[j] \\). We define \\( dist(M) \\) to be the fixpoint of recursively deleting repeated indexes from \\( M \\). We say that \\( M' \\) is contained in \\( M \\), denoted \\( M' \\subseteq M \\), if and only if we can derive \\( M' \\) by recursively removing zero-or-more indexes from \\( M \\). Note that \\( M' \\subseteq M \\) and \\( M \\subseteq M' \\) if and only if \\( M = M' \\).\n\nNext we provide some convenient notation to convert between sets, bags and sequences. Given a sequence \\( M \\) of length \\( n \\), we denote by \\( \\text{bag}(M) \\) the bag that preserves the multiplicity of elements in \\( M \\) (such that \\( \\text{bag}(M)(\\mu) := |\\{i \\mid 1 \\leq i \\leq n \\text{ and } M[i] = \\mu\\}| \\)). Given a set \\( M \\), we denote by \\( \\text{bag}(M) \\) the bag such that \\( \\text{bag}(M)(\\mu) = 1 \\) if and only if \\( \\mu \\in M \\); otherwise \\( \\text{bag}(M)(\\mu) = 0 \\). Given a bag \\( \\mathcal{M} \\), we denote by \\( \\text{set}(\\mathcal{M}) := \\{ \\mu \\mid \\mu \\in \\mathcal{M} \\} \\) the set of elements in \\( \\mathcal{M} \\); we further denote by \\( \\text{seq}(\\mathcal{M}) \\) a random permutation of the bag \\( \\mathcal{M} \\) (more formally, any sequence \\( \\text{seq}(\\mathcal{M}) \\) satisfying \\( \\text{bag}(\\text{seq}(\\mathcal{M})) = \\mathcal{M} \\)). Given a sequence \\( M \\), we use \\( \\text{set}(M) \\) as a shortcut for \\( \\text{set}(\\text{bag}(M)) \\), and given a set \\( M \\), we use \\( \\text{seq}(M) \\) as a shortcut for \\( \\text{seq}(\\text{bag}(M)) \\). Finally, given a set \\( M \\), a bag \\( \\mathcal{M} \\) and a sequence \\( M \\), we define that \\( \\text{set}(M) = M \\), \\( \\text{bag}(\\mathcal{M}) = \\mathcal{M} \\) and \\( \\text{seq}(M) = M \\).\n\nWe continue by defining the semantics of SPARQL queries under set semantics. Later we cover bag semantics, and subsequently discuss aggregation features. Finally we present sequence semantics.\n\n### 3.5. Query Patterns: Set Semantics\n\nQuery patterns evaluated under set semantics return sets of solution mappings without order or duplicates. We first define a set algebra of operators and then define the set evaluation of SPARQL graph patterns.\n\n#### 3.5.1. Set algebra\n\nThe SPARQL query language can be defined in terms of a relational-style algebra consisting of unary and binary operators [26]. Here we describe the operators of this algebra as they act on sets of solution mappings. Unary operators transform from one set of solution mappings (possibly with additional arguments) to another set of solution mappings. Binary operators transform two sets of solution mappings to another set of solution mappings. In Table 3, we define the operators of this set algebra. This algebra is not minimal: some operators (per, e.g., the definition of left-outer join) can be expressed using the other operators.\n\n#### 3.5.2. Navigational graph patterns\n\nGiven an RDF graph \\( G \\), we define the set of terms appearing as a subject or object in \\( G \\) as follows: \\( \\text{so}(G) := \\{ x \\mid \\exists p, y : (x, p, y) \\in G \\text{ or } (y, p, x) \\in G \\} \\). We can then define the evaluation of path expressions as shown in Table 4 [24], which returns a set of pairs of nodes connected by a path in the RDF graph \\( G \\) that satisfies the given path expression.\n\nLet \\( \\text{paths}(N) := \\{ e \\in P \\mid \\exists s, o : (s, e, o) \\in N \\} \\) denote the set of path expressions used in \\( N \\) (includ-\ning simple IRIs, but not variables). We define the path graph of $G$ under $N$, which we denote $G^N$, as the set of triples that materialise paths of $N$ in $G$; more formally $G^N := \\{(s, e, o) \\mid e \\in \\text{paths}(N) \\text{ and } (s, o) \\in e(G)\\}$. \n\n### 3.5.3. Service federation\n\nThe SERVICE feature allows for sending graph patterns to remote SPARQL services. In order to define this feature, we denote by $\\omega$ a federation mapping from IRIs to services such that, given an IRI $x \\in I$, then $\\omega(x)$ returns the service $S$ hosted at $x$ or returns $\\varepsilon$ in the case that no service exists or can be retrieved. We denote by $S.Q(D_S)$ the evaluation of a query $Q$ on a remote service $S$. When a service of the query evaluation is not indicated (e.g., $Q(D)$), we assume that it is evaluated on the local service. Finally, we define that $e.Q(D_e)$ invokes a query-level error $\\varepsilon$ – i.e., the evaluation of the entire query fails – while $e.Q^+(D_e)$ returns a set with the empty solution mapping $\\emptyset$. \n\n### 3.5.4. Set evaluation\n\nThe set evaluation of a SPARQL graph pattern transforms a SPARQL dataset $D$ into a set of solution mappings. The base evaluation is given in terms of $B(D)$ and $N(D)$, i.e., the evaluation of a basic graph pattern $B$ and a navigational graph pattern $N$ over a dataset $D$, which generate sets of solution mappings. These solution mappings can then be transformed and combined using the aforementioned set algebra by invoking the corresponding pattern. The set evaluation of graph patterns is then defined in Table 5.\n\n### 3.6. Query Patterns: Bag Semantics\n\nQueries patterns evaluated under bag semantics return bags of solution mappings. Like under set semantics, we first define a bag algebra of operators and then define the bag evaluation of SPARQL graph patterns.\n\n#### 3.6.1. Bag algebra\n\nThe bag algebra is analogous to the set algebra, but further operates over the multiplicity of solution mappings. We define this algebra in Table 6.\n3.6.2. Bag evaluation\n\nThe bag evaluation of a graph pattern is based on the bag evaluation of basic graph patterns and navigational graph patterns, as defined in Table 7, where the multiplicity of each individual solution is based on how many blank node mappings satisfy the solution. With the exceptions of FE and FNE which are also defined in Table 7—the bag evaluation of other graph patterns then follows from the set evaluation defined in Table 5 by simply replacing the set algebra (from Table 3) with the bag algebra (from Table 6). The set evaluation of paths (from Table 4) is again used with the exception that certain path expressions in navigational patterns are rewritten (potentially recursively) to analogous query operators under bag semantics. These rewritings are then listed in Table 8.\n\n3.7. Group-by Patterns: Aggregation\n\nLet \\((\\mu, \\mathfrak{M})\\) denote a solution group, where \\(\\mu\\) is a solution mapping called the key of the solution group, and \\(\\mathfrak{M}\\) is a bag of solution mappings called the bag of the solution group. Group-by patterns then return a set of solution groups to a set of solution mappings. We now define their semantics along with the AGG graph pattern, which allows for converting a set of solution groups to a set of solution mappings.\n\n3.7.1. Aggregate algebra\n\nWe define an aggregation algebra in Table 9 under bag semantics with four operators that support the generation of a set of solution groups (aka., group by), the selection of solution groups (aka., having), the binding of new variables in the key of the solution group,\nas well as the flattening of a set of solution groups to a set of solution mappings by projecting their keys. Note that analogously to the notation for built-in expressions, given an aggregate expression A, we denote by A(Ω) the result of evaluating A over Ω, and we denote by Ω |= A the condition that Ω satisfies A, i.e., that A(Ω) returns a value interpreted as true. The aggregation algebra can also be defined under set semantics: letting M denote a set of solution mappings, we can evaluate γV(bag(M)) before other operators.\n\n3.7.2. Aggregate evaluation\n\nWe can use the previously defined aggregate algebra to define the semantics of group-by patterns in terms of their evaluation. The corresponding definitions are given in Table 10.\n\n3.8. Sequence Patterns and Semantics\n\nSequence patterns return sequences of solutions as their output, which allow duplicates and also maintain an ordering. These sequence patterns in general refer to solution modifiers that allow for ordering solutions, slicing the set of solutions, and removing duplicate solutions. We will again first define an algebra before defining the evaluation of sequence patterns.\n\n3.8.1. Sequence algebra\n\nSequences deal with some ordering over solutions. We assume a total order ≤ over IBL ∪ {⊥} to be defined by the service (see Section 3.3), i.e., over the set of all RDF terms and unbounds. Given a non-empty sequence of order comparators Ω := ((R₁, Δ₁),..., (Rₙ, Δₙ)), we define the total ordering ≤₁Ω of solutions mappings as follows:\n\n- μ₁ =₁Ω μ₂ if and only if Rᵢ(μ₁) = Rᵢ(μ₂) for all 1 ≤ i ≤ n;\n- otherwise let j denote the least value 1 ≤ j ≤ n such that Rᵢ(μ₁) ≠ Rᵢ(μ₂); then:\n * Rᵢ(μ₁) < Rᵢ(μ₂) and Δᵢ implies μ₁ <₁Ω μ₂;\n * Rᵢ(μ₁) > Rᵢ(μ₂) and Δᵢ implies μ₁ >₁Ω μ₂;\n * Rᵢ(μ₁) < Rᵢ(μ₂) and not Δᵢ implies μ₁ >₁Ω μ₂;\n * Rᵢ(μ₁) > Rᵢ(μ₂) and not Δᵢ implies μ₁ <₁Ω μ₂.\n\nIn Table 11, we present an algebra composed of three operators for ordering sequences of solutions based on order comparators, and removing duplicates.\n\n3.8.2. Sequence evaluation\n\nUsing the sequence algebra, we can then define the evaluation of sequence patterns as shown in Table 12.\n\n3.9. Safe and possible variables\n\nWe now characterise different types of variables that may appear in a graph pattern in terms of being always bound, never bound, or sometimes bound in the solutions to the graph pattern. This characterisation will become important for rewriting algebraic expressions [27]. Specifically, letting Q denote a graph pattern, recall that we denote by vars(Q) all of the variables mentioned (possibly nested) in Q; furthermore:\n\n- we denote by svars(Q) the safe variables of Q, defined to be the set of variables v ∈ V such that, for all datasets D, if μ ∈ Q(D), then v ∈ dom(μ);\n- we denote by pvars(Q) the possible variables of Q, defined to be the set of variables v ∈ vars(Q) such that there exists a dataset D and a solution μ ∈ Q(D) where v ∈ dom(μ).\nPut more simply, svars(\\(Q\\)) denotes variables that are never unbound in any solution, while pvars(\\(Q\\)) denotes variables that may be unbound but are bound in at least one solution over some dataset.\\(^4\\)\n\n**Example 3.1.** Consider the query (pattern) \\(Q\\):\n\n\\[\n\\begin{align*}\n\\text{SELECT } & \\text{ WHERE } \\{ \\\\\n( & ?s : \\text{sister ?x} ) \\text{ UNION } \\{ ?s : \\text{brother ?y} \\} \\\\\n\\text{FILTER NOT EXISTS } & \\{ ?s : \\text{twin ?z} \\}\n\\end{align*}\n\\]\n\nNow:\n\n- \\(\\text{vars}(Q) = \\{ ?s, ?x, ?y, ?z \\} \\);\n- \\(\\text{svars}(Q) = \\{ ?s \\} \\);\n- \\(\\text{pvars}(Q) = \\{ ?s, ?x, ?y \\} \\).\n\n\\(^4\\)It may be tempting to think that svars(\\(Q\\)) \\(\\subseteq\\) pvars(\\(Q\\)), but if \\(Q\\) never returns results (e.g., \\(Q = [Q' \\ \\text{MINUS} \\ Q']\\)), then svars(\\(Q\\)) = \\(V\\) and pvars(\\(Q\\)) = \\(\\emptyset\\) per the previous definitions.\n\nUnfortunately, given a graph pattern \\(Q\\), deciding if \\(v \\in \\text{svars}(Q)\\) or \\(v \\in \\text{pvars}(Q)\\) is undecidable for the full SPARQL 1.1 language as it can answer the question of the satisfiability of \\(Q\\), i.e., whether or not \\(Q\\) has any solution over any dataset; specifically, \\(v \\notin \\text{svars}(Q)\\) is safe in \\(Q\\) if and only if \\(Q\\) is unsatisfiable, while \\(v \\notin \\text{pvars}(Q)\\) is possible in \\(\\text{BIND}_{1,v}(Q)\\) if and only if \\(Q\\) is satisfiable. For this reason we resort to syntactic approximations of the notions of safe and possible variables. In fact, when we say that \\(Q_1\\) is a graph pattern on \\(V_1\\), we can consider \\(V_1\\) to be a syntactic over-approximation of the possible variables of \\(Q\\) (called “in-scope” variables by the standard [2]), which ensures no clashes of variables in solutions (e.g., defining \\(\\text{BIND}_{1,v}(Q)\\) when \\(Q\\) can bind \\(v\\)). Later (in Table 20) we will define a syntactic over-approximation of safe variables to decide when it is okay to apply rewriting rules that are invalid in the presence of unbound variables.\n\n### 3.10. Issues with (NOT) EXISTS\n\nThe observant reader may have noticed that in Table 5 and Table 7, in the definitions of \\([Q, \\text{FE} \\ Q_2]\\) (FILTER EXISTS) and \\([Q, \\text{FNE} \\ Q_2]\\) (FILTER NOT EXISTS), we have used the expression \\(\\mu(Q_2)\\). While we have defined this for a basic graph pattern \\(B\\) and a navigational graph pattern \\(N\\) – replace any variable \\(v \\in \\text{dom}(\\mu)\\) appearing in \\(B\\) or \\(N\\), respectively, with\nμ(v) – per the definition of the syntax, Q2 can be any graph pattern. This leaves us with the question of how μ(select v(Q)) or μ([Q1 MINUS Q2]), for example, is defined. Even in the case where Q2 is a basic graph pattern, it is unclear how we should handle variables that are replaced with blank nodes, or predicate variables that are replaced with literals. The standard does not define such cases unambiguously [28–30]. The precise semantics of [Q1 IE Q2] and [Q1 FNE Q2] thus cannot be defined until the meaning of μ(v) – which the standard calls substitution – is clarified. We provide an example illustrating one issue that arises.\n\nExample 3.2. We will start with a case that is not semantically ambiguous. Take a query:\n\n```sparql\nSELECT DISTINCT * WHERE {\n (?x :sister ?y )\n FILTER NOT EXISTS (?y :sister ?z )\n}\n```\n\nTo evaluate it on a dataset D, we take each solution μ ∈ {(?x :sister, ?y)}(D) from the left of the FILTER NOT EXISTS and keep the solution μ in the final results of the query if and only if the evaluation of the pattern {μ(?y), :sister, ?z})(D) is empty.\n\nWe next take an example of a query that is syntactically valid, but semantically ill-defined.\n\n```sparql\nSELECT DISTINCT * WHERE {\n (?x :sister ?y )\n FILTER NOT EXISTS ( SELECT ?y WHERE ( ?y :sister ?z ) )\n}\n```\n\nGiven a solution μ from the left, if we follow the standard literally and replace “every occurrence of a variable v in [the right pattern] by μ(v) for each v in dom(μ)”, the result is a pattern select(μ(?y)) μ(Q2)). For example, if μ(?y) = :a, then the right pattern, in concrete syntax, would become:\n\n```sparql\nSELECT :a WHERE (:a :sister ?z )\n```\n\nwhich is syntactically invalid.\n\nA number of similar issues arise from ambiguities surrounding substitution, and while work is underway to clarify this issue, at the time of writing two competing proposals are being discussed [28, 30]. We thus postpone rewriting rules for negation until a standard semantics for substitution is agreed upon.\n\n3.11. Queries\n\nA query accepts a set, bag or sequence of solution modifiers, depending on the semantics selected (and features supported). In the case of a SELECT query, the output will likewise be a set, bag or sequence of solution modifiers, potentially projecting away some variables. An ASK query rather outputs a boolean value. Finally, CONSTRUCT and DESCRIBE queries output an RDF graph. We will define the evaluation of these queries in terms of solution sequences, though the definitions generalise naturally to bags and sets (through bag(·) and set(·)). First we give preliminary notation.\n\nGiven a sequence of solution mappings M, we denote by πv(M) a projection that preserves the input order of solution mappings (and such that bag(πv(M)) = πv(bag(M))). Given a dataset D and a set of RDF terms X, we assume a function describe(X, D) that returns an RDF graph “describing” each term x ∈ X to be defined by the service (see Section 3.3); as a simple example, describe(X, D) may be defined as the set of triples in G_D that mention any x ∈ X. The evaluation of queries is then shown in Table 13.\n\n3.12. Dataset modifier\n\nQueries are evaluated on a SPARQL dataset D, where dataset modifiers allow for changing the dataset considered for query evaluation. First, let X and X′ denote (possibly empty or overlapping) sets of IRIs and let D denote a SPARQL dataset. We then denote by D(X, X′) := (∪x∈X \\{G_D[x], \\{x′, G_D[x′] | x′ ∈ X′\\} \\}) a new dataset formed from D by merging all named graphs of D named by X to form the default graph of D(X, X′), and by selecting all named graphs of D named by X′ as the named graphs of D(X, X′). We define the semantics of dataset modifiers in Table 14.\n\n3.13. Non-determinism\n\nA number of features can lead to non-determinism in the evaluation of graph patterns as previously defined. When such features are used, there may be more than one possible valid result for the graph pattern on a dataset. These features are as follows:\n\n- Built-in expressions and aggregation expressions may rely on non-deterministic functions, such as rand(·) to generate a random number, SAMPLE to randomly sample solutions from a group, etc.\n- REDUCED(Q)(D) permits a range of multiplicities for solutions (between those for Q(D) under bag semantics and DISTINCT(Q)(D))\n- The use of sequence patterns without an explicit ORDERn(Q) gives a non-deterministic ordering (e.g., with OFFSETn(Q) and/or LIMITn(Q)).\nIn non-deterministic cases, we can say that \\( Q(D) \\) returns a family of (potentially infinite) valid set/s/bag/sequence of solutions, denoting the space of possible results for evaluating the graph pattern. In practice any such set/bag/sequence of solution can be returned. If the family must be a singleton for any dataset \\( D \\), we assume that \\( Q(D) \\) is deterministic (even if using a non-deterministic feature), and returns the set/bag/sequence of solutions rather than the singleton; for example, we assume that \\( \\text{REDUCED}(Q) \\) is deterministic if \\( Q \\) cannot generate duplicates.\n\n### 3.14. Relationships between the semantics\n\nThe SPARQL standard is defined in terms of sequence semantics, i.e., it is assumed that the solutions returned have an order. However, unless the query explicitly uses the sequence algebra (and in particular ORDER BY), then the semantics is analogous to bag semantics in the sense that the ordering of solutions in the results is arbitrary. Likewise when a query does not use the sequence algebra or the aggregate algebra, but invokes SELECT DISTINCT (in the outermost query), ASK, CONSTRUCT or DESCRIBE, then the semantics is analogous to set semantics. It is important to note however that when the aggregate or sequence algebra is included, set semantics is not the same as bag semantics with DISTINCT. Under set semantics, intermediate results are treated as sets of solutions. Under bag semantics, intermediate results are treated as bags of solutions, where final results are deduplicated. If we apply a count aggregation, for example, then set semantics will disregard duplicate solutions, while bag semantics with distinct will consider duplicate solutions (the distinct is applied to the final count, with no effect).\n\n### 3.15. Query containment and equivalence\n\nQuery containment states that the results of one graph pattern are contained in the other. To begin, take two deterministic graph patterns \\( Q_1 \\) and \\( Q_2 \\). We say that \\( Q_1 \\) is contained in \\( Q_2 \\) under set, bag or sequence semantics, denoted \\( Q_1 \\subseteq Q_2 \\), if and only if for every dataset \\( D \\), it holds that \\( Q_1(D) \\subseteq Q_2(D) \\).\n\nIf \\( Q_1 \\) and \\( Q_2 \\) are non-deterministic, then under set semantics we assume that \\( Q_1(D) \\) and \\( Q_2(D) \\) will return a family of sets of solutions. If for every dataset \\( D \\) and for all \\( M_1 \\in Q_1(D) \\) there exists an \\( M_2 \\in Q_2(D) \\) such that \\( M_1 \\subseteq M_2 \\), then we say that \\( Q_1 \\) is contained in \\( Q_2 \\) under set semantics, again denoted \\( Q_1 \\subseteq Q_2 \\). On the other hand, if \\( Q_1 \\) is deterministic, and \\( Q_2 \\) is non-deterministic, then \\( Q_1 \\nsubseteq Q_2 \\) if and only if for every dataset \\( D \\) and for all \\( M_1 \\in Q_1(D) \\) there exists an \\( M_2 \\in Q_2(D) \\) such that \\( M_1 \\not\\subseteq M_2 \\). Conversely, if \\( Q_2 \\) is deterministic, and \\( Q_1 \\) is non-deterministic, then \\( Q_1 \\nsubseteq Q_2 \\) if and only if for every dataset \\( D \\) we have that \\( Q_1 \\not\\subseteq Q_2 \\).\n\nTable 13\n\n<table>\n<thead>\n<tr>\n<th>Evaluation of queries where ( V ) is a set of variables, ( B ) a basic graph pattern, and ( X ) is a set of IRIs</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>( \\text{SELECT}(Q)(D) := \\pi_V(Q(D)) )</td>\n</tr>\n<tr>\n<td>( \\text{ASK}(Q)(D) := \\text{true if set}(Q(D)) \\neq \\emptyset ; \\text{false otherwise} )</td>\n</tr>\n<tr>\n<td>( \\text{CONSTRUCT}(Q)(D) := \\bigcup_{\\mu \\in \\text{set}(Q(D))} { \\mu(s, p, o) : (s, p, o) \\in B } )</td>\n</tr>\n<tr>\n<td>( \\text{DESCRIBE}(Q)(D) := \\text{describe}(X', D) ) where ( X' := { s' \\in \\text{IBL} : \\exists x \\in X \\cap V, \\mu \\in \\text{set}(Q(D)) : \\mu(x) = x' } )</td>\n</tr>\n</tbody>\n</table>\n\nTable 14\n\n<table>\n<thead>\n<tr>\n<th>Evaluation of dataset modifiers where ( X ) and ( X' ) are sets of IRIs</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>( \\text{REDUCED}(Q)(D) := Q(D(X, X')) )</td>\n</tr>\n</tbody>\n</table>\n\nExample 3.3. In Figure 1 we provide examples of query containment and equivalence. The least formal query finds the maternal grandparents of :Bob while the latter three queries find both maternal and paternal grandparents. Hence the first query is contained in the latter three queries, which are themselves equivalent.\n\nRegarding equivalence of non-deterministic graph patterns, we highlight that any change to the possible space of results leads to a non-equivalent graph pat-\n\n---\n\n5For example, if \\( Q_1(D) = \\{ \\{ \\mu_1, \\mu_2 \\}, \\{ \\mu_1 \\} \\} \\) and \\( Q_2(D) = \\{ \\{ \\mu_1, \\mu_2 \\}, \\{ \\mu_2 \\} \\} \\), this is consistent with \\( Q_1 \\) and \\( Q_2 \\) being contained in each other, but not with their being equivalent.\ntemp; for example, for a graph pattern \\( Q \\), it holds that \\( \\text{DISTINCT}(Q) \\subseteq \\text{REDUCED}(Q) \\subseteq Q \\), and also that \\( Q \\not\\subseteq \\text{REDUCED}(Q) \\), but if \\( Q \\) may give duplicates, then \\( \\text{DISTINCT}(Q) \\not\\equiv \\text{REDUCED}(Q) \\not\\equiv Q \\not\\equiv \\text{DISTINCT}(Q) \\) under bag or sequence semantics. This also means, for example, that replacing a function like \\( \\text{RAND}(\\cdot) \\) in \\( Q \\) with a constant like \\( 0.5 \\) changes the semantics of \\( Q \\) and generates a non-equivalent graph pattern.\n\nWhile the previous discussion refers to graph patterns (which may include use of (sub)\\( \\text{SELECT} \\)), we remark that containment and equivalence can be defined for \\( \\text{ASK} \\), \\( \\text{CONSTRUCT} \\) and \\( \\text{DESCRIBE} \\) in a natural way. For two deterministic \\( \\text{ASK} \\) queries \\( Q_1 \\) and \\( Q_2 \\), we say that \\( Q_1 \\) is contained in \\( Q_2 \\), denoted \\( Q_1 \\subseteq Q_2 \\), if and only if for any dataset \\( D \\), it holds that \\( Q_1(D) \\) implies \\( Q_2(D) \\); i.e., for any dataset which \\( Q_1 \\) returns true, \\( Q_2 \\) also returns true. For two deterministic \\( \\text{CONSTRUCT} \\) queries or \\( \\text{DESCRIBE} \\) queries \\( Q_1 \\) and \\( Q_2 \\), we say that \\( Q_1 \\) is contained in \\( Q_2 \\), denoted \\( Q_1 \\subseteq Q_2 \\), if and only if for any dataset \\( D \\), it holds that \\( Q_2(D) \\models Q_1(D) \\) under simple entailment. Two queries \\( Q_1 \\) and \\( Q_2 \\) are then equivalent, denoted \\( Q_1 \\equiv Q_2 \\) if and only if \\( Q_1 \\subseteq Q_2 \\) and \\( Q_2 \\subseteq Q_1 \\). Containment and equivalence of non-deterministic queries are then defined as before.\n\n### 3.16. Query isomorphism and congruence\n\nMany use-cases for canonicalisation prefer not to distinguish queries that are equivalent up to variable names. We call a one-to-one variable mapping \\( \\rho : V \\rightarrow V \\) a variable renaming. We say that \\( Q_1 \\) and \\( Q_2 \\) are isomorphic, denoted \\( Q_1 \\simeq Q_2 \\) if and only if there exists a variable renaming \\( \\rho \\) such that \\( \\rho(Q_1) = Q_2 \\). Note that in the case of \\( \\text{SELECT} \\) queries, isomorphism does not imply equivalence as variable naming matters to the solutions produced. For this reason we introduce the notion of query congruence. Formally we say that two graph patterns \\( Q_1 \\) and \\( Q_2 \\) are congruent, denoted \\( Q_1 \\equiv Q_2 \\), if and only if there exists a variable renaming \\( \\rho \\) such that \\( \\rho(Q_1) = Q_2 \\). It is not difficult to see that isomorphism implies congruence.\n\n**Example 3.4.** We provide an example of non-equivalent but congruent queries in Figure 2. If we rewrite the variable \\(?gp\\) to \\(?x\\) in the first query, we see that the two queries become equivalent.\n\nLike equivalence and isomorphism, congruence is reflexive (\\( Q \\equiv Q \\)), symmetric (\\( Q_1 \\equiv Q_2 \\Rightarrow Q_2 \\equiv Q_1 \\)) and transitive (\\( Q_1 \\equiv Q_2 \\wedge Q_2 \\equiv Q_3 \\Rightarrow Q_1 \\equiv Q_3 \\)). In other words, congruence is an equivalence relation.\n\nWe remark that congruence is the same as equivalence for \\( \\text{ASK} \\), \\( \\text{CONSTRUCT} \\) and \\( \\text{DESCRIBE} \\) queries since the particular choice of variable names does not affect the output of such queries in any way.\n\n#### 3.17. Query classes\n\nBased on a query of the form \\( \\text{SELECT}_V(Q) \\), we define six syntactic query classes corresponding to classes that have been well-studied in the literature.\n\n- **basic graph patterns** (BGPs): \\( Q \\) is a BGP and \\( V = \\text{vars}(Q) \\).\n- **unions of basic graph patterns** (UBGPs): \\( Q \\) is a graph pattern using BPGs and \\( \\text{UNION} \\) and \\( V = \\text{vars}(Q) \\).\n- **conjunctive queries** (CQs): \\( Q \\) is a BGP.\n- **unions of conjunctive queries** (UCQs): \\( Q \\) is a graph pattern using BPGs and \\( \\text{UNION} \\).\n- **monotone queries** (MQs): \\( Q \\) is a graph pattern using \\( \\text{BGPs} \\) and \\( \\text{AND} \\).\n- **first order queries** (FOQs): \\( Q \\) is a graph pattern using \\( \\text{BGPs} \\), \\( \\text{UNION} \\), and \\( \\text{MINUS} \\).\n3.18. Complexity\n\n- **Navigational graph patterns** (NGPs): $Q$ is an NGP and $V = \\text{vars}(Q)$.\n- **Unions of navigational graph patterns** (UNGPs): $Q$ is a graph pattern using NGPs and UNION and $V = \\text{vars}(Q)$.\n- **Conjunctive path queries** (CPQs): $Q$ is an NGP.\n- **Unions of conjunctive path queries** (UCPQs): $Q$ is a graph pattern using NGPs and UNION.\n- **First order path queries** (FOPQs): $Q$ is a graph pattern using NGPs, UNION, AND, and FILTER.\n\nThese query classes are evaluated on an RDF graph (the default graph) rather than an RDF dataset, though results extend naturally to the RDF dataset case. Likewise, since we do not consider the sequence algebra, we have the (meaningful) choice of set or bag semantics under which to consider the tasks; furthermore, since the aggregate algebra is not considered, set and distinct-bag semantics coincide.\n\nUnlike UCQs, which are strictly unions of joins (expressed as basic graph patterns), MQs further permit joins over unions. As such, UCQs are analogous to a conjunctive normal form. Though any monotone query (under set semantics) can be rewritten to an equivalent UCQ, certain queries can be much more concisely expressed as MQs versus UCQs, or put another way, there exist MQs that are exponentially longer when rewritten as UCQs. For example, the first three queries of Figure 1 are MQs, but only the third is a UCQ: if we use a similar pattern as the third query to go search back $n$ generations, then we would require $2^n$ BGPs with $n$ triple patterns each; if we rather use the most concise MQ, based on the second query, we would need $2n$ BGPs with one triple pattern each.\n\nCPQs and UCPQs are closely related to the query fragments of conjunctions of 2-way regular paths queries (C2RPQs) and unions of conjunctions of 2-way regular paths queries (UC2RPQs), but additionally allow negated property sets and variables in the predicate position [24]. FOQs are semantically related to the fragment with BGPs, projection, UNION, AND, OPTIONAL and FILTER, as studied by Pérez et al. [9].\n\n### 3.18. Complexity\n\nWe here consider four decision problems:\n\n**Query Evaluation** Given a solution $\\mu$, a query $Q$ and a graph $G$, is $\\mu \\in Q(G)$?\n\n**Query Containment** Given two queries $Q_1$ and $Q_2$, does $Q_1 \\subseteq Q_2$ hold?\n\n**Query Equivalence** Given two queries $Q_1$ and $Q_2$, does $Q_1 \\equiv Q_2$ hold?\n\n**Query Congruence** Given two queries $Q_1$ and $Q_2$, does $Q_1 \\equiv Q_2$ hold?\n\nIn Table 15, we summarise known complexity results for these four tasks considering both bag and set semantics along with a reference for the result. The results refer to combined complexity, where the size of the queries and data (in the case of evaluated) are included. The “Full” class refers to any SELECT query using any of the deterministic SPARQL features, while BGPs, UBGPs, NGPs and UNGPs refer to BGPs, UBGPs, NGPs and UNGPs without blank nodes, respectively. We do not present results for query classes allowing paths under bag semantics as we are not aware of work in this direction; lower bounds can of course be inferred from the analogous fragment without paths under bag semantics.\n\nAn asterisk implies that the result is not explicitly stated, but trivially follows from a result or technique used. These cases include analogous results for relational settings, upper-or-lower bounds from tasks with obvious reductions to or from the stated problem, etc. A less obvious case is that of CONGRUENCE, which has not been studied in detail. However, with the exception of BGPs, the techniques used to prove equivalence (typically based on variations on the theme of homomorphic or isomorphic equivalence between the input queries) apply analogously for CONGRUENCE, which is similar to resolving the problem of non-projected variables whose names may differ across the input queries without affecting the given relation. In the case of BGPs (without projection), it is sufficient to find an isomorphism between the input queries; in fact, without projection, since the input graph is a set of triples, BGPs cannot produce duplicates, and thus results for set and bag semantics coincide.\n\nSome of the more notable results include:\n\n- The decidability of CONTAINMENT of CQs under bag semantics is a long open problem [31].\n- EQUIVALENCE (and CONGRUENCE) of CQs and UCQs are potentially easier under bag semantics (GI-complete) than under set semantics.\n\n---\n\n6 We assume that built-in and aggregate expressions can be evaluated using at most polynomial space, as is the case for SPARQL.\n7 Blank nodes act like projection, where their complexity then follows that of *CQs and *CPQs.\n8 This is also known as bag–set semantics, where the data form a set of tuples, but the query is evaluated under bag semantics [31].\n(NP-complete) as the problem under bag semantics relates to isomorphism, rather than homomorphic equivalence under set semantics.\n\n- Although UCQ and MQ classes are semantically equivalent (each UCQ has an equivalent MQ and vice versa), under set semantics the problems of Containment and Equivalence (and Congruence) are potentially harder for MQs than UCQs; this is because MQs are more concise.\n\n- While Containment for FOQs is undecidable under set semantics (due to the undecidability of FOL satisfiability), the same problem for UCQs under bag semantics is already undecidable (it can be used to solve Hilbert’s tenth problem).\n\nThese results – in particular those of Congruence – form an important background for this work.\n\n4. Problem\n\nWith these definitions in hand, we now state the problem we wish to address: given a query \\( Q \\), we wish to compute a canonical form of the query \\( \\text{can}(Q) \\) such that \\( \\text{can}(Q) \\cong Q \\) (sound), and for all queries such that \\( Q' \\cong Q \\), it holds that \\( \\text{can}(Q) = \\text{can}(Q') \\) (complete). In other words, we aim to compute a syntactically canonical form for the class of queries congruent to \\( Q \\) where the canonical query is also in that class.\n\nWith this canonicalisation procedure, we can decide the congruence \\( Q \\cong Q' \\) by deciding the equality \\( \\text{can}(Q) = \\text{can}(Q') \\). We can thus conclude from Table 15 that canonicalisation is not feasible for queries in FOQ as it could be used to solve an undecidable problem. Rather we aim to compute a sound and complete canonicalisation procedure for MQs (which is evidently \\( \\Pi_2^p \\)-hard, per Table 15) under both bag and set semantics, and a sound procedure for the full language under any semantics. This means that for two queries \\( Q \\) and \\( Q' \\) that fall outside the MQ class, with a sound but incomplete canonicalisation procedure, \\( \\text{can}(Q) = \\text{can}(Q') \\) implies \\( Q \\cong Q' \\), but \\( \\text{can}(Q) \\neq \\text{can}(Q') \\) does not necessarily imply \\( Q \\ncong Q' \\).\n\nIndeed, even in the case of MQs, deciding \\( \\text{can}(Q) = \\text{can}(Q') \\) is likely to be a rather inefficient way to decide \\( Q \\cong Q' \\). Our intended use-case is rather to partition a set of queries \\( Q = \\{ Q_1, \\ldots, Q_n \\} \\) into the quotient set \\( Q/\\cong \\), i.e., to find all sets of congruent queries in \\( Q \\).\n\nThis is useful, for example, in the context of caching applications where \\( Q \\) represents a log or stream of queries, where given \\( Q_j \\), we wish to know if there exists a query \\( Q_i \\) (\\( i < j \\)) that is congruent in order to reuse its results. Rather than applying pairwise congruence checks, we can canonicalise queries and use their canonical forms as keys for partitioning.\n\n5. Related Works\n\nIn this section, we discuss implementations of systems relating to containment, equivalence and canonicalisation of SPARQL queries.\n\nA number of systems have been proposed to decide the containment of SPARQL queries. Among these, Letelier et al. [38] propose a normal form for quasi-well-designed pattern trees – a fragment of SPARQL allowing restricted use of OPTIONAL over BGPs – and implement a system called SPARQL Algebra for deciding containment and equivalence in this fragment based on the aforementioned normal form. The problem of determining equivalence of SPARQL queries can also be addressed by reductions to related problems. Chekol et al. [39] have used a \\( \\mu \\)-calculus solver and an XPath-equivalence checker to implement SPARQL containment/equivalence checks. These works implement pairwise checks.\n\nSome systems have proposed isomorphism-based indexing of sub-queries. In the context of a caching system, Papailiou et al. [11] apply a canonical labelling algorithm (specifically Bliss [40]) on BGPs in order to later find isomorphic BGPs with answers available; their approach further includes methods for generalising BGPs such that it is more likely that they will be reused later. More recently, Stadler et al. [41] propose a system called JSAG for solving the containment of SPARQL queries. The system computes normal forms for queries, before representing them as a graph and applying subgraph isomorphism algorithms to detect containments. Such approaches do not discuss completeness, and would appear to miss containments for CQs under set semantics (and distinct-bag semantics), which require checking for homomorphisms rather than (sub-graph) isomorphisms.\nWe remark that in the context of relational database systems, there are likewise few implementations of query containment, equivalence, etc., as also observed by Chu et al. [42, 43], who propose two systems for deciding the equivalence of SQL queries. Their first system, called Cosette [42], translates SQL into logical formulae, where a constraint solver is used to try to find counterexamples for equivalence; if not found, a proof assistant is used to prove equivalence. Chu et al. [43] later proposed the UDP system, which expresses SQL queries – as well as primary and foreign key constraints – in terms of unbounded semiring expressions, thereafter using a proof assistant to test the equivalence of those expressions; this approach is sound and complete for testing the equivalence of UCQs under both set and bag semantics. Zhou et al. [44] recently propose the EQUITAS system, which converts SQL queries into FOL-based formulae, reducing the equivalence problem to a satisfiability-modulo-theories (SMT) problem, which allows for capturing complex selection criteria (inequalities, boolean expressions, cases, etc.). Aside from targeting SQL, a key difference with our approach is that such systems apply pairwise checks.\n\nIn summary, while problems relating to containment and equivalence have been well-studied in the theoretical literature, relatively few practical implementations have emerged, perhaps because of the high computational costs, and indeed the undecidability results for the full SPARQL/SQL language. Of those that have emerged, they either offer sound and complete checks in a pairwise manner for query fragments, such as UCQs (e.g., [43]), or they offer sound but incomplete canonicalisation focused on isomorphic equivalence (e.g., [11]). To the best of our knowledge, the approach that we propose here, which we call QCan, is the only system that allows for canonicalising queries with respect to congruence, and that is sound and complete for monotone queries under both set and bag semantics. Our experiments will show that despite high theoretical computational complexity, QCan can be deployed in practice to detect congruent equivalence classes in large-scale, real-world query logs or streams, which are dominated by relatively small and simple queries.\n\n---\n\n### Table 15: Complexity of SPARQL tasks on core fragments (considering combined complexity for Evaluation)\n\n<table>\n<thead>\n<tr>\n<th>Set semantics</th>\n<th>Evaluation</th>\n<th>Containment</th>\n<th>Equivalence</th>\n<th>Congruence</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>BGP'</td>\n<td>PTIME [9]</td>\n<td>PTIME</td>\n<td>PTIME</td>\n<td>NP-complete</td>\n</tr>\n<tr>\n<td>UBGP'</td>\n<td>PTIME [9]*</td>\n<td>PTIME</td>\n<td>PTIME</td>\n<td>NP-complete</td>\n</tr>\n<tr>\n<td>CQ</td>\n<td>NP-complete [9]</td>\n<td>NP-complete [32]*</td>\n<td>NP-complete [32]*</td>\n<td>NP-complete [32]*</td>\n</tr>\n<tr>\n<td>MQ</td>\n<td>NP-complete</td>\n<td>Π₂<sup>P</sup>-complete [33]*</td>\n<td>Π₂<sup>P</sup>-complete [33]*</td>\n<td>Π₂<sup>P</sup>-complete [33]*</td>\n</tr>\n<tr>\n<td>FOQ</td>\n<td>PSPACE-complete [9]</td>\n<td>Undecidable [34]*</td>\n<td>Undecidable [34]*</td>\n<td>Undecidable [34]*</td>\n</tr>\n<tr>\n<td>UNGP'</td>\n<td>PTIME [24]*</td>\n<td>PSPACE-complete [24]*</td>\n<td>PSPACE [24]*</td>\n<td>PSPACE [24]*</td>\n</tr>\n<tr>\n<td>FOPQ</td>\n<td>PSPACE-complete [24]*</td>\n<td>Undecidable [34]*</td>\n<td>Undecidable [34]*</td>\n<td>Undecidable [34]*</td>\n</tr>\n<tr>\n<td>Full</td>\n<td>PSPACE-complete</td>\n<td>Undecidable [34]*</td>\n<td>Undecidable [34]*</td>\n<td>Undecidable [34]*</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Bag semantics</th>\n<th>Evaluation</th>\n<th>Containment</th>\n<th>Equivalence</th>\n<th>Congruence</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>BGP'</td>\n<td>PTIME [9]*</td>\n<td>PTIME [35]*</td>\n<td>PTIME [35]*</td>\n<td>GI-complete [35]*</td>\n</tr>\n<tr>\n<td>CQ</td>\n<td>NP-complete [9]*</td>\n<td>Decidability open</td>\n<td>GI-complete [31]*</td>\n<td>GI-complete [31]*</td>\n</tr>\n<tr>\n<td>UCQ</td>\n<td>NP-complete [9]*</td>\n<td>Undecidable [36]*</td>\n<td>GI-complete [37]*</td>\n<td>GI-complete [37]*</td>\n</tr>\n<tr>\n<td>MQ</td>\n<td>NP-complete</td>\n<td>Undecidable [36]*</td>\n<td>GI-hard [37]*</td>\n<td>GI-hard [37]*</td>\n</tr>\n<tr>\n<td>FOQ</td>\n<td>PSPACE-complete [9]*</td>\n<td>Undecidable [17]*</td>\n<td>Undecidable [17]*</td>\n<td>Undecidable [17]*</td>\n</tr>\n<tr>\n<td>Full</td>\n<td>PSPACE-complete</td>\n<td>Undecidable [36]*</td>\n<td>Undecidable [36]*</td>\n<td>Undecidable [36]*</td>\n</tr>\n</tbody>\n</table>\n6. Canonicalisation of Monotone Queries\n\nIn this section, we will first describe the different steps of our proposed canonicalisation process for monotone queries (MQs), i.e., queries with basic graph patterns, joins, unions, outer projection and distinct (see Section 3.17). In fact, we consider a slightly larger set of queries that we call extended monotone queries (EMQs), which are monotone queries that additionally support property paths using the (non-recursive) features “/” (followed by), “\\*” (inverse) and “|” (disjunction); property paths using such queries can be rewritten to monotone queries. We will cover the (sound but incomplete) canonicalisation of other features of SPARQL 1.1 later in Section 7.\n\nAs mentioned in the introduction, the canonicalisation process consists of: algebraic rewriting of parts of the query into normal forms, the representation of the query as a graph, the minimisation of the monotonic parts of the query by leaning and containment checks, the canonical labelling of the graph, and finally the mapping back to query syntax. We describe these steps in turn and then conclude the section by proving that canonicalisation is sound and complete for EMQs.\n\n6.1. UCQ normalisation\n\nIn this section we describe the rules used to rewrite EMQs into a normal form based on unions of conjunctive queries (UCQs). We first describe the rewritings we apply for rewriting property paths into monotone features (where possible), thus converting EMQs into MQs. We then describe the rewriting of MQs into UCQ normal form. We subsequently describe some postprocessing of variables to ensure that those with the same name are correlated and that variables that are always unbound are removed. Finally we extend the normal form to take into account set vs. bag semantics.\n\n6.1.1. Property path elimination\n\nPer Table 8, property paths that can be rewritten to joins and unions are considered to be equivalent to their rewritten form under both bag and set semantics. We make these equivalences explicit by rewriting such property paths to joins and unions; i.e.:\n\n\\[\n(o, \\ast e, s) \\Rightarrow (s, e, o)\n\\]\n\\[\n(s, e_1|e_2, o) \\Rightarrow (s, e_1, x), (x, e_2, o)\n\\]\n\\[\n(s, e_1|e_2, o) \\Rightarrow [(s, e_1, o) \\lor (s, e_2, o)]\n\\]\n\nwhere \\(x\\) denotes a fresh blank node. The exact rewriting is provided in Table 8. These rewritings may be applied recursively, as needed. If the input query is an EMQ, then the output of the recursive rewriting will be an MQ, i.e., a query without property paths.\n\nExample 6.1. Consider the following query based on Example 1.1 looking for names of aunts.\n\n\\[\n\\text{SELECT DISTINCT ?z WHERE } \\{ \\\\\n\\quad \\{ ?w :mother ?x . \\\\\n\\quad \\quad \\text{\\langle} ?x \\ast (:mother|:father) ?w . \\text{\\rangle} \\\\\n\\quad \\quad \\text{\\langle} ?x :sister/:name ?z . \\text{\\rangle} \\\\\n\\quad \\} \\}\n\\]\n\nThis query will be rewritten to:\n\n\\[\n\\text{SELECT DISTINCT ?z WHERE } \\{ \\\\\n\\quad \\{ ?w :mother ?x . \\\\\n\\quad \\quad \\text{\\langle} ?x \\ast (:mother|:father) ?w . \\text{\\rangle} \\\\\n\\quad \\quad \\text{\\langle} ?x :sister/:name ?z . \\text{\\rangle} \\\\\n\\quad \\} \\}\n\\]\n\nAnd then recursively to:\n\n\\[\n\\text{SELECT DISTINCT ?z WHERE } \\{ \\\\\n\\quad \\{ ?w :mother ?x . \\\\\n\\quad \\quad \\text{\\langle} ?x \\ast (:mother|:father) ?w . \\text{\\rangle} \\\\\n\\quad \\quad \\text{\\langle} ?x :sister/:name ?z , ?y :name ?w . \\text{\\rangle} \\\\\n\\quad \\} \\}\n\\]\n\nIn this case we succeed in removing all property paths; however, property paths with \\(*\\) or \\(|\\) cannot be rewritten to other query features in this way.\n\n6.1.2. Union normalisation\n\nPérez et al. [9] establish that, under set semantics, joins and unions in SPARQL are commutative and associative, and that joins distribute over unions. We summarise these results in Table 16. Noting that under set semantics, the multiplicity of joins and unions is given by the multiplication and addition of natural numbers, respectively, that both multiplication and addition are commutative and associative, and that multiplication distributes over addition, the same results also apply under bag semantics.\n\nAnother (folklore) result of interest is that BGPs can be rewritten to equivalent joins of their triple patterns. However, care must be taken when considering blank nodes in BGPs; otherwise the same blank node in two different triple patterns might be matched to two different terms, breaking the equivalence. Along these lines, let \\(\\eta : B \\rightarrow V\\) denote a one-to-one mapping of blank nodes to variables; we assume that \\(\\eta\\) will rewrite blank nodes to fresh variables not appearing elsewhere in a query. Given a basic graph pattern \\(B = \\{ t_1, \\ldots, t_n \\}\\) and a mapping \\(\\eta\\) such that \\(\\eta(B) = \\{ t'_1, \\ldots, t'_n \\}\\), we can then state the following equivalence:\n\n\\[\nB \\equiv \\text{SELECT}_{\\text{vars}(B)}([t'_1] \\lor \\ldots \\lor [t'_n])\n\\]\ni.e., a BGP \\( B \\) is equivalent to the result of rewriting its blank nodes to fresh variables and joining the individual triple patterns, finally projecting only the variables originally in \\( B \\). This equivalence again holds under bag semantics since the multiplicity of a solution \\( \\mu \\in B(D) \\) under bag semantics is defined in SPARQL as the number of blank node mappings that satisfy the solution \\( \\mu \\). Note that even if there are duplicate triple patterns (more precisely, singleton BGPs) in a join, the result still holds under bag semantics, as each triple pattern can produce the same (compatible) solution only once when evaluated on an RDF graph: a set of RDF graphs.\n\nThese known results give rise to a UCQ normal form for MQs. More specifically, given a pattern \\([Q_1, Q_2, \\ldots, Q_n] \\), we can rewrite this to \\([Q_1, Q_2, \\ldots, Q_n] \\) in other words, we translate unions of joins to (equivalent) patterns involving joins of unions. Also, as Schmidt et al. [27] observe, \\([Q_1 \\cup Q_2 \\cup Q_3] \\equiv Q_1 \\cup Q_2 \\cup Q_3 \\) under set semantics. Hence we can abstract the commutativity and associativity of both joins and unions by introducing two new syntactic operators:\n\n\\[\n\\text{AND}(Q_1, \\ldots, Q_n) := [Q_1 \\text{ AND } \\ldots ] \\text{ AND } Q_n]\n\\]\n\\[\n\\text{UNION}(Q_1, \\ldots, Q_n) := [Q_1 \\text{ UNION } \\ldots ] \\text{ UNION } Q_n]\n\\]\n\nGiven the aforementioned equivalences, the arguments of \\( \\text{AND}(\\cdot) \\) and \\( \\text{UNION}(\\cdot) \\) can be considered as a set of operands under set semantics and a bag of operands under bag semantics (under bag semantics, duplicate operands change the multiplicity of results).\n\nThe UCQ normal form for MQs is then of the form\n\n\\[\n\\text{SELECT}_\\text{V}(\\text{UNION}(Q_1, \\ldots, Q_n)), \\text{ where each } Q_i \\text{ (1} \\leq i \\leq n) \\text{ is of the form } \\text{AND}(t_{i1}, \\ldots, t_{im}) \\text{, where each } t_{ij} \\text{ (1} \\leq k \\leq m) \\text{ is a triple pattern. Given that duplicate triple patterns in a join do not affect the multiplicity of results, we can further remove these duplicates such that in our normal form, } t_{ij} \\neq t_{ik} \\text{ for } 1 \\leq j<k \\leq m. \\text{ For this reason, in the case of UCQs, we can analogously consider each } Q_1, \\ldots, Q_n \\text{ to be a set of triple patterns without blank nodes.}\n\\]\n\nExample 6.2. We show a case where the multiplicity of union operands changes the multiplicity of results under bag semantics. Consider the following MQ \\( Q \\):\n\n\\[\n\\text{SELECT } ?s \\text{ WHERE }\n\\]\n\\[\n\\begin{aligned}\n(\\text{ ?s :p } ?o ) \\text{ UNION } (\\text{ ?s :p } ?o ) \\\\\n(\\text{ ?s :p } ?o ) \\text{ UNION } (\\text{ ?s :p } ?o )\n\\end{aligned}\n\\]\n\nAssume a dataset \\( D \\) with a default graph \\( \\{(s, :p :o)\\} \\). Let \\( \\mu = \\{(s : :p : o)\\} \\). Note that \\( Q(D)(\\mu) = 4 \\) since each union generates \\( \\mu \\) twice, where the multiplicity of the join is then the product of both. We can describe the multiplicity of \\( \\mu \\) as \\((1+1)(1+1) = 4\\).\n\nIf we rewrite this query to a UCQ, in the first step, pushing the first join inside the union, we generate:\n\n\\[\n\\begin{aligned}\n\\text{SELECT } ?s \\text{ WHERE }\n\\end{aligned}\n\\]\n\\[\n\\begin{aligned}\n(\\text{ ?s :p } ?o ) \\text{ UNION } (\\text{ ?s :p } ?o ) \\\\\n(\\text{ ?s :p } ?o ) \\text{ UNION } (\\text{ ?s :p } ?o )\n\\end{aligned}\n\\]\n\nWe may now describe the multiplicity of \\( \\mu \\) as \\( 1(1+1)+1(1+1) = 4 \\). In the next step, we have:\n\n\\[\n\\begin{aligned}\n\\text{SELECT } ?s \\text{ WHERE }\n\\end{aligned}\n\\]\n\\[\n\\begin{aligned}\n(\\text{ ?s :p } ?o ) \\text{ UNION } (\\text{ ?s :p } ?o . \\text{ ?s :p } ?o ) \\\\\n(\\text{ ?s :p } ?o . \\text{ ?s :p } ?o ) \\text{ UNION } (\\text{ ?s :p } ?o . \\text{ ?s :p } ?o )\n\\end{aligned}\n\\]\n\nThe multiplicity of this query is described as \\( (1+1)(1+1)+(1+1) = 4 \\). Since BGPs are sets of triple patterns, we should remove the duplicates. Subsequently unnesting the unions, the query then becomes:\n\n\\[\n\\begin{aligned}\n\\text{SELECT } ?s \\text{ WHERE }\n\\end{aligned}\n\\]\n\\[\n\\begin{aligned}\n(\\text{ ?s :p } ?o ) \\\\\n(\\text{ ?s :p } ?o ) \\\\\n(\\text{ ?s :p } ?o )\n\\end{aligned}\n\\]\n\nThe multiplicity is then \\( 1+1+1+1 = 4 \\). In this case, the duplicate union operands are needed to preserve the original multiplicities of the query.\n\nAs was previously mentioned, the UCQ normal form may be exponentially larger than the original MQ: for example, a relatively concise EMQ of the form \\( \\{ (s, (p_1|q_1))/ \\ldots / (p_m|q_m), y) \\} \\) would be rewritten...\nto an MQ with a join of \\( n \\) unions with two triple patterns each, and then to a UCQ with a union of \\( 2^n \\) BGPs (for each combination of \\( p_i \\) and \\( q_j \\)), with each BGP containing \\( n \\) triple patterns.\n\n**Example 6.3.** Let us take the output query of Example 6.1 and apply the UCQ normal form.\n\n```sql\nSELECT DISTINCT ?z WHERE {\n (?w :mother ?x .) UNION (?w :father ?x .)\n ?x :sister _y .. _y :name ?z .\n}\n```\n\nBlank nodes are rewritten to variables, and then join is distributed over union, giving the following query:\n\n```sql\nSELECT DISTINCT ?z WHERE {\n}\n```\n\nIf we were to consider the names of aunts or uncles (:sister,:brother) then we would end up with four unions of BGPs with four triple patterns each. If we were to consider the names of children (:son,:daughter) of aunts or uncles, we would end up with eight unions of BGPs with five triple patterns each. In this way, the UCQ rewriting may result in a query that is exponentially larger than the input. \n\n### 6.1.3. Unsatisfiability normalisation\n\nWe recall that a graph pattern \\( Q \\) is considered unsatisfiable if and only if there does not exist a dataset \\( D \\) such that \\( Q(D) \\) is non-empty; i.e., the graph pattern never generates solutions. There is one trivial case of unsatisfiability for UCQs that must be taken into account: when subjects are literals. Specifically, SPARQL allows literal subjects even though they are disallowed in RDF graphs; this was to enable forwards-compatibility with a possible future generalisation of RDF to allow literal subjects, which has not happened as of RDF 1.1. As such, BGPs with any literal subject are unsatisfiable.\n\n**Lemma 6.1.** Let \\( Q \\) denote a BGP. \\( Q \\) is unsatisfiable if and only if it contains a literal subject.\n\n**Proof.** First assume that \\( Q \\) does not contain a literal subject. Define \\( G \\) to be the result of replacing all variables in \\( Q \\) with an IRI, say :x ; observe that \\( G \\) is a valid RDF graph. Define \\( D \\) to be the dataset with the default graph \\( G \\). Let \\( \\mu \\) denote the solution such that \\( \\text{dom}(\\mu) = \\text{vars}(Q) \\) and \\( \\mu(v) = :x \\) for all \\( v \\in \\text{dom}(\\mu) \\). Observe that \\( \\mu \\in Q(D) \\). Hence there exists a dataset \\( D \\) such that \\( Q(D) \\) is non-empty; \\( Q \\) is satisfiable.\n\nNext assume that \\( Q \\) contains a literal subject. Take any blank node mapping \\( \\alpha \\) and solution mapping \\( \\mu \\). Observe that \\( \\mu(\\alpha(Q)) \\) will still contain a literal subject, and hence for any RDF graph \\( G \\), blank node mapping \\( \\alpha \\) and solution mapping \\( \\mu \\), it holds that \\( \\mu(\\alpha(Q)) \\not\\subseteq G \\) as \\( G \\) cannot contain a triple with a literal subject. Hence \\( Q \\) cannot have any solution over any dataset, \\( Q \\) is unsatisfiable, and the result holds.\n\nMoving to UCQs, it is not difficult to see that a union is satisfiable if and only if one of its operands is satisfiable, or, equivalently, that it is unsatisfiable if and only if all of its operands are unsatisfiable.\n\n**Lemma 6.2.** Let \\( Q = \\bigcup Q_i \\) be a UCQ. \\( Q \\) is unsatisfiable if and only if all of its operands \\( Q_1, \\ldots, Q_n \\) are unsatisfiable. Further assume that \\( Q_k \\) is unsatisfiable and let \\( Q' = \\bigcup (Q_1, \\ldots, Q_{k-1}, Q_{k+1}, \\ldots, Q_n) \\) denote \\( Q \\) removing the operand \\( Q_k \\). It holds that \\( Q \\equiv Q' \\).\n\n**Proof.** Recall: \\( \\bigcup Q_i(D) = \\bigcup_{i=1}^{n} Q_i(D) \\) (with union being bag or set union depending on the semantics). The result is (always) empty if and only if all \\( Q_i(D) \\) are (always) empty. Removing any \\( Q_k \\) such that \\( Q_k(D) \\) is (always) empty will not affect the results of the query. Thus the result holds.\n\nTo deal with CQs of the form \\( \\text{SELECT}_V(Q) \\), where \\( Q \\) is a BGP containing a triple pattern with a literal subject, we simply replace this CQ with an arbitrary but canonical unsatisfiable query \\( Q_0 \\); for example, \\( Q_0 := \\text{SELECT}_V(\\{\"uns\", ?u, ?u\\}) \\). In the case of UCQs, we remove operand BGPs that are unsatisfiable; if all operands are unsatisfiable, we replace the entire UCQ with the canonical query \\( Q_0 \\). If \\( Q_0 \\) is produced, canonicalisation can stop.\n\n**Example 6.4. Take the CQ:**\n\n```sql\nSELECT DISTINCT ?x WHERE ( \"x\" :x ?x )\n```\n\nWe replace this with the canonical query (where \\(?\\emptyset\\) is used here to denote an empty projection in the concrete syntax):\n\n```sql\nSELECT ?empty WHERE ( \"uns\" ?u ?u )\n```\n\nNext take the UCQ:\n\n```sql\nSELECT ?x WHERE ( \"x\" :x ?x ) UNION (?x :x \"x\" )\n```\n\nWe will rewrite this to\n\n```sql\nSELECT ?x WHERE ( ?x :x \"x\" )\n```\n\nby removing the unsatisfiable operand.\n6.1.4. Variable normalisation\n\nThe same variable may sometimes appear in multiple query scopes such that the variable does not need to be bound to the same term in a solution. We say that such variables are not correlated. There is one case where this issue may arise in UCQs. We call a variable \\( v \\) a union variable if it appears in a union \\( Q = \\text{UNION}(Q_1, \\ldots, Q_n) \\) \\((n > 1)\\). A union variable \\( v \\) does not correlate with other appearances of \\( v \\) in different operands of the same union unless \\( v \\) is correlated outside of \\( Q \\) in a query.\\(^9\\) In the case of UCQs, union variables that appear in different operands of the union, but are not projected, do not correlate.\n\n**Lemma 6.3.** Let \\( Q = \\text{SELECT}_{\\lambda}(\\text{UNION}(Q_1, \\ldots, Q_n)) \\) denote a UCQ. Let \\( \\lambda_1, \\ldots, \\lambda_n \\) denote variable-to-variable mappings such that for \\( 1 \\leq i \\leq n \\), \\( \\lambda_i : V \\rightarrow V \\) where \\( \\text{dom}(\\lambda_i) = \\text{vars}(Q_i) \\setminus V \\), and, for all \\( v \\in \\text{dom}(\\lambda_i) \\), it holds that \\( \\lambda_i(v) \\notin \\text{vars}(Q) \\) and there does not exist \\( \\lambda_j (1 \\leq i < j \\leq n) \\) and \\( v' \\in \\text{dom}(\\lambda_j) \\) such that \\( \\lambda_i(v) = \\lambda_j(v') \\). In other words, each variable-to-variable mapping rewrites each non-projected variable of each union operand to a fresh variable. Then the following equivalence holds:\n\n\\[\n\\text{SELECT}_{\\lambda}(\\text{UNION}(Q_1, \\ldots, Q_n)) \\equiv \\\\\n\\text{SELECT}_{\\lambda}(\\text{UNION}(\\lambda_1(Q_1), \\ldots, \\lambda_n(Q_n)))\n\\]\n\n*Proof.* Take any \\( Q_i \\) \\((1 \\leq i \\leq n)\\). Given any dataset \\( D \\), for any solution \\( \\mu \\in Q_i(D) \\), there must exist a corresponding solution \\( \\lambda_i(\\mu) \\in \\lambda_i(Q_i(D)) \\) with the same multiplicity, where \\( \\text{dom}(\\lambda_i(\\mu)) = \\lambda_i(\\text{dom}(\\mu)) \\), and \\( \\lambda_i(\\mu)(\\lambda_i(v)) = \\mu(v) \\), i.e., a solution that is the same but with variables renamed per \\( \\lambda_i \\). Furthermore, \\( \\text{SELECT}_{\\lambda}(Q_i)(D) = \\text{SELECT}_{\\lambda}(\\lambda_i(Q_i))(D) \\) as by definition \\( \\lambda_i \\) does not rewrite variables in \\( V \\). We now have:\n\n\\[\n\\text{SELECT}_{\\lambda}(\\text{UNION}(Q_1, \\ldots, Q_n)) \\equiv \\\\\n\\text{UNION}(\\text{SELECT}_{\\lambda}(Q_1), \\ldots, \\text{SELECT}_{\\lambda}(Q_n)) \\equiv \\\\\n\\text{UNION}(\\lambda_1(Q_1), \\ldots, \\lambda_n(Q_n)) \\equiv \\\\\n\\text{SELECT}_{\\lambda}(\\text{UNION}(\\lambda_1(Q_1), \\ldots, \\lambda_n(Q_n)))\n\\]\n\nwhich concludes the proof. \\( \\square \\)\n\nThese non-correlated variables rise to non-trivial equivalences based on the “false” correspondences between variables with the same name that have no effect on each other. We address such cases by differentiating union variables that appear in multiple operands of the union but not outside the union.\n\n**Example 6.5.** We take the output of Example 6.3:\n\n\\[\n\\text{SELECT DISTINCT } ?z \\text{ WHERE } \\\\\n\\text{UNION} \\\\\n\\]\n\nThe variable \\( ?z \\) correlates across both operands because both appearances correlate with the same external appearance of \\( ?z \\) in the SELECT clause. Conversely, the variables \\( ?w \\), \\( ?x \\) and \\( ?y \\) do not correlate across both operands of the union as they do not correlate with external appearances of the same variable. Hence we differentiate \\( ?w \\), \\( ?x \\) and \\( ?y \\) in both operands:\n\n\\[\n\\text{SELECT DISTINCT } ?z \\text{ WHERE } \\\\\n\\text{UNION} \\\\\n\\]\n\nThe resulting query is equivalent to the original query, but avoids “false correspondences” of variables. \\( \\square \\)\n\nNext we apply a simple rule to remove variables that are always unbound in projections. Left unattended, such variables could otherwise constitute a trivial counterexample for the completeness of canonicalisation. We recall from Section 3.9 the notation \\( \\text{pvars}(Q) \\) to denote the possible variables of a graph pattern, i.e., the variables that are bound to some RDF term in some solution of \\( Q \\) over some dataset \\( D \\).\n\n**Lemma 6.4.** Let \\( Q \\) be a graph pattern, let \\( V' \\) be a set of variables, and let \\( V'' \\) be a set of variables such that \\( \\text{pvars}(Q) \\cap V'' = \\emptyset \\). It holds that:\n\n\\[\n\\text{SELECT}_{\\lambda}(Q) \\equiv \\text{SELECT}_{\\lambda \\cup \\lambda''}(Q)\n\\]\n\n*Proof.* Let \\( V = \\text{pvars}(Q) \\) denote the possible variables of \\( Q \\); then, for any dataset \\( D \\), if \\( \\mu \\in Q(D) \\) then \\( \\text{dom}(\\mu) \\subseteq V \\). For each solution \\( \\mu \\in Q(D) \\), the projection \\( \\text{SELECT}_{\\lambda}(Q)(\\mu) \\) produces a solution \\( \\mu' \\) such that \\( \\text{dom}(\\mu') \\subseteq V' \\cap \\text{dom}(\\mu) \\) and \\( \\mu \\sim \\mu' \\), while the projection \\( \\text{SELECT}_{\\lambda \\cup \\lambda''}(Q) \\) produces a solution \\( \\mu'' \\) such that \\( \\text{dom}(\\mu'') = (V' \\cup V'') \\cap \\text{dom}(\\mu) \\) and \\( \\mu \\sim \\mu'' \\). But since \\( \\text{dom}(\\mu) \\subseteq V \\) and \\( V \\cap V'' = \\emptyset \\), this means that \\( \\text{dom}(\\mu) \\cap V'' = \\emptyset \\). Hence \\( \\text{dom}(\\mu'') = (V' \\cup V'') \\cap \\text{dom}(\\mu) \\). Further, we can conclude that \\( \\mu' \\sim \\mu'' \\). We have thus shown a\n\n---\n\n\\(^9\\)If considering the direct results of a query pattern, then the naming of variables matters as they are bound in the solutions.\none-to-one mapping from solutions of the form $\\mu'$ to $\\mu''$ such that $\\mu' = \\mu''$, from which the result holds. \\hfill \\square\n\nWe deal with such cases by removing variables that are always unbound from the projection.\\footnote{In concrete SPARQL syntax, a SELECT query must specify either $*$ or at least one variable. Allowing an empty projection in the abstract syntax avoids having to deal explicitly with the empty projection case, simplifying matters. When mapping from abstract syntax to concrete syntax we can simply add a fresh canonical variable to the SELECT clause in order to represent empty projections.}\n\n**Example 6.6.** Take a query:\n\n\\[\n\\text{SELECT DISTINCT ?w ?z WHERE }\n\\{ \n\\text{?w :mother ?m .}\n\\}\n\\]\n\nWe can remove the variable $?z$ without changing the semantics of the query as it will always be unbound, no matter what dataset is considered. In practice engines may return solution tables with blank columns for variables like $?z$, but our definitions do not allow such columns (such columns can easily be added in practice if required). \\hfill \\square\n\n\\subsection{6.1.5. Set vs. bag normalisation}\n\nThe presence or absence of DISTINCT (or REDUCED) in certain queries does not affect the solutions that are generated because no duplicates can occur. In the case of UCQs, this can occur under two specific conditions. The first such case involves CQs.\n\n**Lemma 6.5.** Let $Q$ denote a satisfiable BGP. It holds that:\n\n\\[\n\\text{DISTINCT}(\\text{SELECT}_V(Q)) \\equiv \\text{SELECT}_V(Q).\n\\]\n\nif and only if $\\text{vars}(Q) \\subseteq V$ and $\\text{bnodes}(Q) = \\emptyset$.\n\n**Proof.** First we prove that if $\\text{vars}(Q) = V$ and $\\text{bnodes}(Q) = \\emptyset$, then $\\text{DISTINCT}(\\text{SELECT}_V(Q)) \\equiv \\text{SELECT}_V(Q)$. It suffices to show that $\\text{SELECT}_{\\text{vars}(Q)}(Q)$ cannot produce duplicate results, which we prove by contradiction. Assume a dataset $D$ such that there exists a solution $\\mu$ where $\\text{SELECT}_{\\text{vars}(Q)}(Q)(D)(\\mu) > 1$; i.e., the solution is duplicated. Since all variables are projected, $\\text{SELECT}_{\\text{vars}(Q)}(Q) \\equiv Q$. For $\\mu$ to be duplicated, there must then exist multiple blank node mappings $\\alpha$ such that $\\text{dom}(\\alpha) \\subseteq \\text{bnodes}(Q)$ and $\\mu(\\alpha(Q)) \\subseteq D$ (see Table 7), but since $\\text{bnodes}(Q) = \\emptyset$, there is only the single empty mapping $\\alpha$, and hence we have a contradiction. The case $\\text{vars}(Q) \\subseteq V$ follows from this result and Lemma 6.4.\n\nNext we prove that if $\\text{vars}(Q) \\not\\subseteq V$ or $\\text{bnodes}(Q) \\neq \\emptyset$, and $Q$ is satisfiable, then $\\text{DISTINCT}(\\text{SELECT}_V(Q)) \\not\\equiv \\text{SELECT}_V(Q)$. It suffices to show that there exists a dataset $D$ for which $\\text{SELECT}_V(Q)$ can produce duplicates if $V \\not\\equiv \\text{vars}(Q)$ or $\\text{bnodes}(Q) \\neq \\emptyset$. Let $\\mu$ denote a solution mapping such that $\\text{dom}(\\mu) = V$ and for all $v \\in \\text{dom}(\\mu), \\mu(v) = :x$. Let $\\mu'$ and $\\mu''$ denote two solution mappings such that $\\text{dom}(\\mu') = \\text{dom}(\\mu'') = \\text{vars}(Q) \\setminus V$ and for all $v \\in \\text{vars}(Q) \\setminus V, \\mu'(v) = :y$ and $\\mu''(v) = :z$. Let $\\alpha'$ and $\\alpha''$ denote two blank node mappings such that $\\text{dom}(\\alpha') = \\text{dom}(\\alpha'') = \\text{bnodes}(Q)$ and for all $b \\in \\text{bnodes}(Q), \\alpha'(b) = :y$ and $\\alpha''(b) = :z$. Consider a dataset $D$ whose default graph is defined as $\\mu(\\alpha'(Q))) \\cup \\mu(\\alpha''(Q)))$; this is a valid RDF graph as $Q$ is satisfiable and thus does not contain literal subjects. We see that $\\text{SELECT}_V(Q)(D)(\\mu) \\geq 2$, where the mapping to $:y$ and the mapping to $:z$ (the blank node mappings or solution mappings) are counted in the multiplicity of $\\mu$. Thus there exists a dataset $D$ for which $\\text{SELECT}_V(Q)$ can produce duplicates, which concludes the proof. \\hfill \\square\n\nThe second case involves unions.\n\n**Lemma 6.6.** Let $Q_1, \\ldots, Q_n$ denote satisfiable BGPs and let $Q = Q_1 \\cup \\ldots \\cup Q_n$ denote the set union of their triple patterns. It holds that:\n\n\\[\n\\text{DISTINCT}(\\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n))) \\equiv \\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n))\n\\]\n\nif and only if $\\text{vars}(Q) \\subseteq V$, $\\text{bnodes}(Q) = \\emptyset$ and $\\text{vars}(Q_i) \\neq \\text{vars}(Q_j)$ for all $1 \\leq i < j \\leq k$.\n\n**Proof.** As before, we first prove that if blank nodes are not present ($\\text{bnodes}(Q) = \\emptyset$), all variables are projected ($\\text{vars}(Q) \\subseteq V$) and no BGP has the same set of variables ($\\text{vars}(Q_i) \\neq \\text{vars}(Q_j)$ for all $1 \\leq i < j \\leq k$), then $\\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n))$ cannot produce duplicate results. We know from Lemma 6.5 that if blank nodes are not present and all variables are projected, then no individual BGP in $Q_1, \\ldots, Q_n$ can produce duplicate results. Hence we are left to check for duplicates produced by unions of BGPs. We will assume for the purposes of contradiction that there exists a dataset $D$ and a solution $\\mu$ such that $\\mu \\in Q_i(D)$ and $\\mu \\in Q_j(D)$ where $1 \\leq i < j \\leq k$. However, $\\mu \\in Q_i(D)$ implies that $\\mu(\\alpha) = \\text{vars}(Q_i)$, while $\\mu(\\alpha') = \\text{vars}(Q_j)$ implies that $\\mu(\\alpha) = \\text{vars}(Q_j)$. Given the assumption that $\\text{vars}(Q_i) \\neq \\text{vars}(Q_j)$, it follows that $\\text{dom}(\\mu) \\neq \\text{dom}(\\mu')$: a contradiction. It then holds as\na consequence that if \\( \\text{vars}(Q) = V \\), \\( \\text{bnodes}(Q) = \\emptyset \\) and \\( \\text{vars}(Q_i) \\neq \\text{vars}(Q_j) \\) for all \\( 1 \\leq i < j \\leq k \\), then \\( \\text{DISTINCT}((\\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n))) \\equiv \\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n)) \\). The special case of \\( \\text{vars}(Q) \\subseteq V \\) follows from this result and Lemma 6.4.\n\nIn the other direction, we are left to show that if \\( \\text{vars}(Q) \\subseteq V \\), or \\( \\text{bnodes}(Q) \\neq \\emptyset \\), or there exist \\( 1 \\leq i < j \\leq k \\) such that \\( \\text{vars}(Q_i) = \\text{vars}(Q_j) \\), then it follows that \\( \\text{DISTINCT}((\\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n))) \\neq \\text{SELECT}_V(\\text{UNION}(B_1, \\ldots, B_n)) \\). First, if \\( \\text{vars}(Q) \\subseteq V \\) or \\( \\text{bnodes}(Q) \\neq \\emptyset \\), then Lemma 6.5 tells us that an individual basic graph pattern with a blank node or non-projected variable can produce duplicates. Hence we are left to show that if there exists \\( 1 \\leq i < j \\leq k \\) such that \\( \\text{vars}(Q_i) = \\text{vars}(Q_j) \\), then duplicates can always arise for the query \\( \\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n)) \\). Let \\( \\mu \\) be a solution such that \\( \\text{dom}(\\mu) = \\text{vars}(Q_j) = \\text{vars}(Q_i) \\) and \\( \\mu(v) = x \\) for all \\( v \\in \\text{dom}(\\mu) \\). Consider a dataset \\( D \\) whose default graph is defined as \\( \\mu(Q_i) \\cup \\mu(Q_j) \\); again this is an RDF graph as \\( Q_i \\) and \\( Q_j \\) are assumed to be satisfiable. Now \\( \\mu \\in \\text{SELECT}_V(\\text{UNION}(D)) \\) and \\( \\mu \\in \\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n)) \\), and hence \\( \\mu \\) will be duplicated in \\( \\text{SELECT}_V(\\text{UNION}(Q_1, \\ldots, Q_n)) \\).\n\nThe same equivalences trivially hold for REDUCED, which becomes deterministic when no duplicate solutions are returned. We deal with all such equivalences by simply adding \\( \\text{DISTINCT} \\) in such cases (or replacing \\( \\text{REDUCED} \\) with \\( \\text{DISTINCT} \\)).\n\n**Example 6.7.** Take a query such as:\n\n```\nSELECT ?w ?x ?y ?z ?n WHERE {\n```\n\nSince the query is a BGP with all variables projected and no blank nodes, no duplicates can be produced, and thus we can add a \\( \\text{DISTINCT} \\) keyword to ensure that canonicalisation will detect equivalent or congruent queries irrespective of the inclusion or exclusion of \\( \\text{DISTINCT} \\) or \\( \\text{REDUCED} \\) in such queries. If the query were to project a single variable, such as \\( ?z \\), then duplicates become possible and adding \\( \\text{DISTINCT} \\) would change the semantics of the query.\n\nAn example of a case involving \\( \\text{DISTINCT} \\) is as follows:\n\n```\nSELECT ?n WHERE {\nUNION\n {\n```\n\nFirst we note that the individual basic graph patterns forming the operands of the \\( \\text{UNION} \\) do not contain blank nodes and have all of their variables projected; hence they cannot lead to duplicates by themselves. Regarding the union, the set of variables is different in each operand, and hence no duplicates can be given: the first operand will (always and only) produce unbounds for \\( ?y, ?z \\) in its solutions; the second will produce unbounds for \\( ?x, ?z \\); and the third will produce unbounds for \\( ?x, ?y \\). Hence no operand can possibly duplicate a solution from another operand. Since the query cannot produce duplicates, we can add \\( \\text{DISTINCT} \\) without changing its semantics. If we were instead to project \\( (?w, ?n) \\), then adding \\( \\text{DISTINCT} \\) would change the semantics of the query as the three operands may produce the same solution, and individual BGP may duplicate solutions.\n\n**6.1.6. Summary**\n\nGiven an EMQ \\( Q \\), we denote by \\( \\U(Q) \\) the process described herein involving the application of:\n\n1. property path elimination (§ 6.1.1);\n2. union normalisation (§ 6.1.2);\n3. variable normalisation (§ 6.1.4);\n4. unsatisfiability normalisation (§ 6.1.3);\n5. set vs. bag normalisation (§ 6.1.5).\n\n**6.2. Graph Representation**\n\nGiven an EMQ as input, the previous steps either terminate with a canonical unsatisfiable query, or provide us with a satisfiable query in UCQ normal form, with blank nodes replaced with fresh variables, non-correlated variables differentiated, variables that are always unbound removed from the projection (while ensuring that the projection is non-empty), and the \\( \\text{DISTINCT} \\) keyword invoked in cases where duplicate solutions can never be returned. Before continuing, we first review an example that illustrates the remaining syntactic variations and redundancies in congruent UCQs that are left to be canonicalised.\n\n**Example 6.8.** Consider the following UCQs:\n\n```\nSELECT \\text{DISTINCT} ?n WHERE { \n UNION\n}\n```\n\nThe choice to add rather than remove \\( \\text{DISTINCT} \\) is for convenience: it allows us to later keep track of queries that can be normalised under set semantics. However, if performance were a focus, removing \\( \\text{DISTINCT} \\) might lead to slightly more efficient queries where the planner will not invoke unnecessary deduplication.\nThese queries are congruent, but differ in:\n\n1. the ordering of triple patterns within BGPs;\n2. the ordering of BGPs within the UCQ;\n3. the naming of variables;\n4. a redundant triple pattern in each BGP of the first query (those containing ?z and ?d, ?e);\n5. the redundant third BGP in the second query.\n\nWe are left to canonicalise such variations.\n\nOur overall approach is to address such variations is to encode queries as RDF graphs that we call representation graphs (r-graphs). This representation will allow for identifying and removing redundancies, and for canonically labelling variables such that elements of the query can be ordered deterministically.\n\nWe first establish some notation. Let \\(\\lambda(\\cdot)\\) denote a function that returns a fresh blank node, and \\(\\iota(\\cdot)\\) denote a function that returns a fresh blank node unique to \\(x\\). Let \\(\\iota(\\cdot)\\) denote an id function such that:\n\n- if \\(x \\in \\mathbb{IL}\\), then \\(\\iota(x) = x\\);\n- if \\(x \\in \\mathbb{VB}\\), then \\(\\iota(x) = \\lambda(x)\\);\n- if \\(x\\) is a natural number then \\(\\iota(x) = \"x\"^^xsd:integer\\);\n- if \\(x\\) is a boolean value then \\(\\iota(x) = \"x\"^^xsd:boolean\\);\n- otherwise \\(\\iota(x) = \\lambda(x)\\).\n\nWe assume that natural numbers and boolean values produce datatype literals in canonical form (for example, we assume that \\(\\iota(2) = \"2\"^^xsd:integer\\) rather than, say, \"+02\"^^xsd:integer).\n\nTable 17 then provides formal definitions for transforming a UCQ \\(Q\\) in abstract syntax into its r-graph \\(R(Q)\\); we assume that a BGP is expressed as a join of its triple patterns. Note that for brevity, when we write \\(\\iota(\\cdot)\\), we assume that the same blank node is used for the current expression as was assigned in the parent expression. The result is then deterministic modulo isomorphism. In order to capture the intuition, we provide a more visual depiction of this transformation of UCQs in Table 18, where dashed nodes of the form \\(\\lambda(\\cdot)\\) are replaced with \\(\\iota(\\cdot)\\), and the graph extended with \\(R(x)\\). We further provide the following example.\n\n**Example 6.9.** We present an example of a UCQ and its r-graph in Figure 3. For clarity (in particular, to avoid non-planarity), we embed the types of nodes into the nodes themselves; e.g., the uppermost node expands to \\(\\textit{union}\\) \\(\\textit{type}\\) \\(\\textit{arg}\\). Given an input query \\(Q_1\\) that varies from \\(Q_1\\) in the naming of variables, applying the same process, the r-graph for \\(Q_1\\) and \\(Q_1'\\) would be isomorphic, varying only in blank node labels.\n\nPart of the benefit of this graph representation is that it abstracts away the ordering of the operands of query operators where such order does not affect the semantics of the operator. This representation further allows us to leverage existing tools to eliminate redundancy and later canonically label variables.\n\n### 6.3. Minimisation\n\nThe minimisation step removes two types of redundancies: redundant triple patterns in BGPs, and redundant BGPs in unions. It is important to note that such redundancies only apply in the case of set semantics [33]; under bag semantics, these “redundancies” affect the multiplicity of results, and thus cannot be removed without changing the query’s semantics.\n\n#### 6.3.1. BGP minimisation\n\nThe first type of redundancy we consider stems from redundant triple patterns. Consider a BGP \\(Q\\) (without blank nodes, for simplicity). We denote by\nDefinitions for representational graphs $R(Q)$ of a UCQ $Q$, where “$a$” abbreviates `rdf:type`, $B$ is a basic graph pattern, and $V$ is a set of variables\n\n| $R(Q)$ | $\\{((i\\cdot),\\cdot)\\} \\cup R(Q) \\cup \\{((i\\cdot),a,\\cdot)\\}$ |\n| $\\text{AND}(Q_1,\\ldots,Q_n)$ | $\\{((i\\cdot),\\cdot,((i\\cdot),a,\\cdot))\\}$ |\n| $\\text{UNION}(Q_1,\\ldots,Q_n)$ | $\\{ ((i\\cdot),\\cdot,((i\\cdot),a,\\cdot)) \\}$ |\n| $\\text{SELECT}_V(Q)$ | $\\{ ((i\\cdot),\\cdot,((i\\cdot),a,\\cdot)) \\}$ |\n| $\\text{DISTINCT}(Q)$ | $\\{ ((i\\cdot),\\cdot,((i\\cdot),a,\\cdot)) \\}$ |\n\nTable 17\n\nMapping UCQs to r-graphs\n\n<table>\n<thead>\n<tr>\n<th>SPARQL</th>\n<th>Representational graph</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>${x}$ for $x \\in H$</td>\n<td>$\\xymatrix{\\circ \\ar@{-}[r]^{s} & \\circ \\ar@{-}[r]^{p} & \\circ \\ar@{-}[r]^{o}}$</td>\n</tr>\n<tr>\n<td>${x}$ for $x \\in V$</td>\n<td>$\\xymatrix{\\circ \\ar@{-}[r]^{s} & \\circ \\ar@{-}[r]^{p} & \\circ \\ar@{-}[r]^{o} & \\circ \\ar@{-}[r]^{r}}$</td>\n</tr>\n<tr>\n<td>$\\text{AND}(Q_1,\\ldots,Q_n)$</td>\n<td>$\\xymatrix{\\circ \\ar@{-}[r]^{s} & \\circ \\ar@{-}[r]^{p} & \\circ \\ar@{-}[r]^{o} & \\circ \\ar@{-}[r]^{r}}$</td>\n</tr>\n<tr>\n<td>$\\text{UNION}(Q_1,\\ldots,Q_n)$</td>\n<td>$\\xymatrix{\\circ \\ar@{-}[r]^{s} & \\circ \\ar@{-}[r]^{p} & \\circ \\ar@{-}[r]^{o} & \\circ \\ar@{-}[r]^{r}}$</td>\n</tr>\n<tr>\n<td>$\\text{SELECT}_V(Q)$</td>\n<td>$\\xymatrix{\\circ \\ar@{-}[r]^{s} & \\circ \\ar@{-}[r]^{p} & \\circ \\ar@{-}[r]^{o} & \\circ \\ar@{-}[r]^{r}}$</td>\n</tr>\n<tr>\n<td>$\\text{DISTINCT}(Q)$</td>\n<td>$\\xymatrix{\\circ \\ar@{-}[r]^{s} & \\circ \\ar@{-}[r]^{p} & \\circ \\ar@{-}[r]^{o} & \\circ \\ar@{-}[r]^{r}}$</td>\n</tr>\n</tbody>\n</table>\n\n$\\rho : V \\rightarrow \\text{VIBL}$ a partial mapping from variables to variables and RDF terms, whose domain is denoted by $\\text{dom}(\\rho)$. Now, for a given mapping $\\rho$, such that $\\text{dom}(\\rho) = \\text{vars}(Q)$, it holds that $\\rho(Q) = \\text{DISTINCT}(\\text{SELECT}_{\\text{vars}(\\rho(Q))}(Q))$ if and only if $\\rho(Q) \\subseteq Q$. This is due to a classical result by Chandra and Merlin [32], where $\\rho$ is a homomorphism of $Q$ onto itself: $Q$ and $\\rho(Q)$ are homomorphically equivalent.\n\nOne may note a correspondence to RDF entailment (see Section 2.5), which is also based on homomorphisms, where the core of an RDF graph represents a redundancy-free (lean) version of the graph. We can exploit this correspondence to remove redundancies in BGP by computing their core. However, care must be taken to ensure that we do not remove variables from the BGP that are projected; we achieve this by temporarily replacing them with IRIs so that they cannot be eliminated during the core computation.\n\nExample 6.10. Consider the following query, $Q$:\n\n$$\\text{SELECT DISTINCT } ?z \\text{ WHERE } \\{ ?x : \\text{father } ?y . \\} \\cup \\{ ?x : \\text{mother } ?y . \\} \\cup \\{ ?x : \\text{son } ?y . \\} \\cup \\{ ?z : \\text{son } ?y . \\}.$$ \n\nThough perhaps not immediately obvious, this query is congruent with the three queries of Example 1.1. After creating the base r-graph for $Q$ and applying UCQ normal forms, we end up with an r-graph analogous to the following query with a union of three BGP:\n\n$$\\text{SELECT DISTINCT } ?z \\text{ WHERE } \\{ \\text{father } ?x . \\} \\cup \\{ \\text{mother } ?x . \\} \\cup \\{ \\text{son } ?x . \\} \\cup \\{ \\text{son } ?z . \\}.$$ \n\nWe then replace the blank node for the projected variable $?z$ with a fresh IRI, and compute the core of the sub-graph for each BGP (the graph induced by the BGP node with type $\\text{And}$ and any node reachable from that node in the directed r-graph). Figure 4 depicts the sub-r-graph representing the third BGP (omitting the $\\text{And}$-typed node for clarity: it will not\nwith the other nodes mapped to themselves. Observe that the projected variable :vz is now an IRI, and hence it cannot be removed from the graph.\n\nIf we consider applying this core computation over all three conjunctive queries, we would end up with an r-graph corresponding to the following query:\n\n\\[\n\\text{SELECT DISTINCT } ?z \\text{ WHERE } \\{\n\\}\n\\]\n\nWe see that the projected variable is preserved in all BGPs. However, we can still see (inter-BGP) redundancy with respect to the first and third BGPs (the first is contained in the third), which we handle later.\n\n6.3.2. Union minimisation\n\nAfter removing redundancy from the individual BGPs, we may still be left with a union containing redundant BGPs as highlighted by the output of Example 6.10, where the first BGP is contained in the third BGP: when we take the union, the names of Jo’s aunts returned by the first BGP will already be contained in the third, and since we apply distinct/set semantics, the duplicates (if any) will be removed. Hence we must now apply a higher-level normalisation of unions of BGPs in order to remove such redundancy.\n\nSpecifically, we must take into consideration the following equivalence [33]; let \\( Q = \\text{UNION}(Q_1, \\ldots, Q_n) \\) and \\( Q' = \\text{UNION}(Q_1, \\ldots, Q_{k-1}, Q_{k+1}, \\ldots, Q_n) \\); then:\n\n\\[\n\\text{DISTINCT} (\\text{SELECT}_{V}(Q)) \\equiv \\text{DISTINCT} (\\text{SELECT}_{V}(Q'))\n\\]\n\nif and only if \\( \\text{SELECT}_{V}(Q_k) \\subseteq \\text{SELECT}_{V}(Q_j) \\) for \\( 1 \\leq j \\leq n, i \\leq k \\leq n, j \\neq k. \\)\n\nTo resolve such equivalences, we remove from \\( Q \\):\n\n1. all \\( Q_k (1 \\leq k \\leq n) \\) such that there exists \\( Q_j (1 \\leq j < k \\leq n) \\) such that \\( \\text{SELECT}_{V}(Q_j) \\equiv \\text{SELECT}_{V}(Q_k) \\); and\n2. all \\( Q_k (1 \\leq k \\leq n) \\) where there exists \\( Q_j (1 \\leq j \\leq n) \\) such that \\( \\text{SELECT}_{V}(Q_j) \\subseteq \\text{SELECT}_{V}(Q_k) \\) (and \\( \\text{SELECT}_{V}(Q_j) \\not\\subseteq \\text{SELECT}_{V}(Q_k) \\));\n\ni.e., we first remove all but one BGP from each group of equivalent BGPs and then remove all BGPs that are properly contained in another (considering in both cases the projected variables \\( V \\)).\n\nTo implement condition (1), let us first assume that all BGPs contain all projected variables. Note that in the previous step we have removed all redundancy from the CQs and hence it is sufficient to check for isomorphism between them; we can thus take the current r-graph \\( G_i \\) for each \\( Q_i \\) and apply iso-canonicalisation of \\( G_j \\), removing any other \\( Q_k (k > j) \\) whose \\( G_k \\) is isomorphic. Thereafter, to implement step (2), we can check the simple entailment \\( G_k \\models G_j (j \\neq k) \\), where if such an entailment holds, we can remove \\( G_k \\) (and thus \\( Q_k \\)); more specifically, we can implement this entailment check using a boolean SPARQL ASK query encoding \\( G_j \\) and evaluated over \\( G_k \\) (which will return true if the entailment holds). Note that in both processes, we should preserve projected variables in \\( V \\), meaning they should only be mapped to each other; to ensure this, we can simply maintain the unique IRIs created for them earlier.\n\nPer this process, the first BGP in the output of Example 6.10 is removed as it is contained in the third BGP, with the projected variable corresponding to the following query:\n\n\\[\n\\]\n\nFig. 4. BGP (above) and its r-graph (below) with the sub-graph removed during the core computation shown dashed (and in blue)\nIf we consider the first two BGPs, they do not contribute the same results to ?n; however, had we left the blank node \\( \\_:\\text{vn} \\) to represent ?n, their r-graphs would be isomorphic whereas temporarily grounding \\( \\_:\\text{vn} \\) ensures they are no longer isomorphic. On the other hand, the r-graphs of the second and third BGP will remain isomorphic and thus one will be removed (for the purposes of the example, let’s arbitrarily say the third is removed). There are no further isomorphic CQs and thus we proceed to containment checks.\n\nThe fourth BGP maps to (i.e., contains) the first BGP, and thus the first BGP will be removed. This containment check is implemented by creating the following ASK query from the r-graph for the fourth BGP:\n\n\\[\n\\text{ASK WHERE } \\{ \\_\\text{and1 a :And ; :arg _\\text{tp11} .} \\\\\n\\_\\text{tp41 a :TP ; :s _\\text{x4} ; :p _\\text{y4} ; :o :vn .} \\}\n\\]\n\nThis returns true and hence the first BGP is removed. Likewise the fourth BGP maps to the fifth BGP and also the sixth BGP and hence the fifth and sixth BGPs will also be removed. This leaves us with an r-graph representing the following UCQ query:\n\n\\[\n\\text{SELECT DISTINCT ?n WHERE (} \\\\\n( ?m :cousin ?n .) \\cup \\cup ( ?m :cousin ?n2 .) \\\\\n\\cup \\cup ( ?m :cousin ?x3 .) \\cup ( ?x4 ?y4 ?n .) \\\\\n\\cup \\cup ( ?x5 ?x5 ?n .) \\cup ( ?y5 ?x5 .) \\\\\n\\cup \\cup ( ?x6 name ?n .) \\\\\n\\}\n\\]\n\nThis UCQ query is redundancy-free.\n\nNow we drop the assumption that all CQs contain the same projected variables in \\( V \\), meaning that we can generate unbounds. To resolve such cases, we can partition the BGP operands \\( Q = \\{ Q_1, \\ldots, Q_6 \\} \\) of the union into sets of queries \\( \\{ Q_1, \\ldots, Q_m \\} \\) based on the projected variables they contain. More formally, given two graph patterns \\( Q_1 \\) and \\( Q_2 \\), let \\( Q_1 \\sim_V Q_2 \\) denote the equivalence relation such that pvars\\( (Q_1) \\cap V = \\text{pvars}(Q_2) \\cap V \\). Then \\( \\{ Q_1, \\ldots, Q_m \\} \\) is the quotient set of \\( Q \\) by \\( \\sim_V \\). We can then apply the same procedure as described previously, checking equivalence and containment within each such set \\( Q_1, \\ldots, Q_m \\).\n\nExample 6.12. Take the following UCQ, where the BGPs now contain different projected variables:\n6.4. Canonical Labelling\n\nThe second-last step of the canonicalisation process consists of applying a canonical labelling to the blank nodes of the RDF graph output from the previous process [21]. Specifically, given an RDF graph $G$, we apply a canonical labelling function $L(\\cdot)$ such that $L(G) \\simeq G$ and for all RDF graphs $G'$, it holds that $G \\simeq G'$ if and only if $L(G) \\simeq L(G')$; in other words, $L(\\cdot)$ bijectively relabels the blank nodes of $G$ in a manner that is deterministic modulo isomorphism, meaning that any isomorphic graph will be assigned the same labels. This is used to assign a deterministic labelling of query variables represented in the r-graph as blank nodes; other blank nodes presenting query operators will also be labelled as part of the process but their canonical labels are not necessary.\n\n6.5. Inverse mapping\n\nThe final step of the canonicalisation process is to map from the canonically labelled r-graph to query syntax. More specifically, we define an inverse r-mapping, denoted $R^{-1}(G)$, to be a partial mapping from RDF graphs to query expressions such that $R^{-1}(R(Q)) = Q$, i.e. converting $Q$ to its r-graph and then applying the inverse r-mapping yields the query $Q$ again. We can achieve this by applying the inverse of Table 17, where canonical blank nodes in variable positions (specifically, the objects of triples in the r-graph with predicate $:_a$, $:_p$, $:_o$, or $:_e$) are mapped to canonical variables using a fixed, total, one-to-one mapping $\\xi : B \\rightarrow V$ [18].\n\nTo arrive at a canonical concrete syntax, we order the operands of commutative operators using a syntactic ordering on the canonicalised elements, and then serialise these operands in their lexicographical order. This then concludes the canonicalisation of EMQs.\n\n6.6. Soundness and completeness\n\nGiven an EMQ as input, we prove soundness – i.e., that the output query is congruent to the input query – and completeness – i.e., that the output for two input queries is the same if and only if the input queries are congruent – for the proposed canonicalisation scheme.\n\n13Here we assume the use of \\textsc{union}(\\cdot), etc., to abstract away the ordering of operands of commutative operators.\n\n14A straightforward way to implement $\\xi$ is to define $\\xi(_-;a) = ?a$, and so forth for all blank node and variable labels.\n\n6.6.1. Soundness\n\nWe begin the proof of soundness by showing that the UCQ normalisation preserves congruence.\n\nLemma 6.7. For an EMQ $Q$, it holds that:\n\n$$U(Q) \\cong Q.$$\n\nProof. This follows from the fact that each step preserves the congruence of $Q$, as follows:\n\n1. property path elimination: by definition, Table 8;\n2. union normalisation: proven by Pérez et al [9];\n3. variable normalisation: Lemmas 6.3, 6.4;\n4. unsatisfiability normalisation: Lemmas 6.1, 6.2;\n5. set vs. bag normalisation: Lemmas 6.5, 6.6.\n\nSince congruence is an equivalence relation, it is transitive, and thus the composition of multiple steps where each preserves congruence also preserves congruence. The result thus holds.\n\nNext we prove that the canonical labelling of blank nodes in the r-graph does not affect the properties of the inverse r-mapping.\n\nLemma 6.8. Given a UCQ $Q$, it holds that:\n\n$$R^{-1}(L(R(Q))) \\cong Q.$$\n\nProof. By definition, we have that $R^{-1}(R(Q)) \\simeq Q$, where $R^{-1}(\\cdot)$ relies on a one-to-one mapping of blank nodes to variables (namely $\\xi$). Since $L(\\cdot)$ performs a one-to-one mapping of blank nodes to blank nodes in $R(Q)$, thus producing an isomorphic graph to $R(G)$, this implies that $R^{-1}(L(R(Q)))$ produces a query that is isomorphic to $R^{-1}(R(Q))$. Hence we have that $R^{-1}(R(Q)) \\simeq R^{-1}(R(Q)) \\simeq Q$. Further given that isomorphism implies congruence, we have that $R^{-1}(L(R(Q))) \\cong R^{-1}(R(Q)) \\cong Q$. The result then holds per the transitivity of congruence.\n\nFinally we prove that the minimisation of UCQs through their r-graphs preserves congruence.\n\nLemma 6.9. Given a UCQ $Q$, it holds that:\n\n$$R^{-1}(M(R(Q))) \\cong Q.$$\n\nProof. We consider two cases.\n\nSet semantics: Minimising CQs by computing their cores is a classical technique based on the idea that two CQs are equivalent if and only if they are homomorphically equivalent (with corre-\nThus, if any premise 1–5 is satisfied, it holds that \\( \\text{If } Q_1 \\simeq Q_2, \\text{ then } U(Q_1) \\simeq U(Q_2). \\)\n\n**Lemma 6.10.** Let \\( Q_1 \\) and \\( Q_2 \\) denote UCQs. If \\( Q_1 \\) or \\( Q_2 \\) is unsatisfiable, and \\( Q_1 \\simeq Q_2 \\), then:\n\n\\[\n\\text{Ra}^{-1}(L(M(R(U(Q_1))))) = \\text{Ra}^{-1}(L(M(R(U(Q_2))))) .\n\\]\n\n**Proof.** If \\( Q_1 \\) or \\( Q_2 \\) is unsatisfiable, and \\( Q_1 \\simeq Q_2 \\), this implies that both \\( Q_1 \\) and \\( Q_2 \\) are unsatisfiable. As a result of Lemmas 6.1, 6.2, \\( U(Q_1) = Q_3 \\) and \\( U(Q_2) = Q_0 \\), recalling that \\( Q_0 \\) denotes the canonical unsatisfiable query. Thus \\( U(Q_1) = U(Q_2) \\) and the result holds per premise 2 of Remark 6.1 since equality implies isomorphism.\n\nIn practice, if a UCQ \\( Q \\) is unsatisfiable, then the canonicalisation process can stop after \\( U(Q) \\) yields \\( Q_0 \\). We state the result in this way to align the process for both satisfiable and unsatisfiable cases. We can now focus on cases where both queries are satisfactory.\n\nWe will start with satisfiable CQs evaluated under set semantics (with distinct).\n\n**Lemma 6.11.** Let \\( Q_1 \\) and \\( Q_2 \\) denote satisfiable BGPs and \\( V_1 \\) and \\( V_2 \\) sets of variables. Further let \\( Q'_1 = \\text{DISTINCT}(\\text{SELECT}_{V_1}(Q_1)) \\) and likewise let \\( Q'_2 = \\text{DISTINCT}(\\text{SELECT}_{V_2}(Q_2)) \\). If \\( Q'_1 \\simeq Q'_2 \\) then:\n\n\\[\n\\text{Ra}^{-1}(L(M(R(U(Q'_1))))) = \\text{Ra}^{-1}(L(M(R(U(Q'_2))))) .\n\\]\n\n**Proof.** Since \\( Q'_1 \\) and \\( Q'_2 \\) are satisfiable, and evaluated under set semantics, we know from the result of Chandra and Merlin [32] that \\( Q'_1 \\equiv Q'_2 \\) if and only if both are homomorphically equivalent with respect to a homomorphism that is the identity on projected variables. Now \\( M(R(U(Q'_1))) \\) computes the core of each BGP, which is known to be unique modulo isomorphism [20]. Thus if \\( Q'_1 \\equiv Q'_2 \\) and both are satisfiable, we have that \\( M(R(U(Q'_1))) \\simeq M(R(U(Q'_2))) \\). On the other hand, if \\( Q'_1 \\simeq Q'_2 \\), we know that there exists a variable renaming such that \\( \\rho(Q'_1) \\equiv Q'_2 \\); combining this with the fact that \\( M(R(U(Q'_1))) \\simeq M(R(U(Q'_2))) \\), and the fact that congruence is an equivalence relation, we know that \\( Q'_1 \\simeq Q'_2 \\) implies \\( M(R(U(Q'_1))) \\simeq M(R(U(Q'_2))) \\). The result then holds from premise 4 of Remark 6.1.\nWe move to CQs evaluated under bag semantics (without distinct; the result also considers cases where the CQ cannot return duplicates).\n\n**Lemma 6.12.** Let \\( Q_1 \\) and \\( Q_2 \\) denote satisfiable BGPs and \\( V_1 \\) and \\( V_2 \\) sets of variables. Further let \\( Q'_1 = \\text{SELECT}_{V_1}(Q_1) \\) and \\( Q'_2 = \\text{SELECT}_{V_2}(Q_2) \\). If \\( Q'_1 \\equiv Q'_2 \\), then\n\n\\[\n\\text{R}^{-}(L(M(R(U(Q'_1))))) = \\text{R}^{-}(L(M(R(U(Q'_2)))))\n\\]\n\n**Proof.** First we note that for a satisfiable BGP \\( Q \\), given \\( \\text{SELECT}_V(Q) \\) such that \\( V \\setminus \\text{vars}(Q) \\neq \\emptyset \\), that \\( U(\\text{SELECT}_V(Q)) \\) will remove the unbound variables \\( (V \\setminus \\text{vars}(Q)) \\) from \\( V \\) per Lemma 6.4, and thus \\( U(\\text{SELECT}_V(Q)) = U(\\text{SELECT}_{V \\setminus \\text{vars}(Q)}(Q)) \\). Further note that as part of \\( U(\\cdot) \\), during union normalisation, blank nodes are rewritten to variables. This allows us to focus on cases where \\( V \\subseteq \\text{vars}(Q) \\) and \\( Q \\) does not contain blank nodes.\n\nIf \\( V_1 = \\text{vars}(Q_1) \\), then \\( Q'_1 \\) cannot return duplicates (Lemma 6.5), and since \\( Q'_1 \\equiv Q'_2 \\), then \\( Q'_2 \\) cannot return duplicates, and thus \\( V_2 = \\text{vars}(Q_2) \\). Thus \\( U(Q'_1) \\) and \\( U(Q'_2) \\) will add distinct in both cases, and the result follows from Lemma 6.11.\n\nThis leaves us with the case that \\( V_1 \\subseteq \\text{vars}(Q_1) \\). In this case, \\( Q'_1 \\) will return duplicates for certain datasets (Lemma 6.5), and must be evaluated under bag semantics. Given that \\( Q'_1 \\equiv Q'_2 \\), this likewise means that \\( Q'_2 \\) returns duplicates. Under bag semantics, and assuming that \\( Q'_1 \\) and \\( Q'_2 \\) are satisfiable, then Theorem 5.2 of Chaudhuri and Vardi [31] tells us that \\( Q'_1 \\equiv Q'_2 \\) if and only if \\( Q'_1 \\equiv Q'_2 \\), with an isomorphism that is the identity on projected variables. Noting that \\( Q'_1 \\equiv Q'_2 \\) implies that there exists a variable renaming \\( \\rho \\) such that \\( \\rho(Q'_1) \\equiv Q'_2 \\), it follows that there exists \\( \\rho \\) such that \\( \\rho(Q'_1) \\simeq Q'_2 \\), or put more simply, that \\( Q'_1 \\equiv Q'_2 \\) (without the restriction on projected variables). The result then follows from premise 1 of Remark 6.1.\n\nWe now move to UCQs evaluated under set semantics (with distinct).\n\n**Lemma 6.13.** Let \\( Q_1 \\) and \\( Q_2 \\) denote satisfiable UCQs with distinct. If \\( Q_1 \\equiv Q_2 \\) then\n\n\\[\n\\text{R}^{-}(L(M(R(U(Q_1))))) = \\text{R}^{-}(L(M(R(U(Q_2)))))\n\\]\n\n**Proof.** We show that given a satisfiable UCQ \\( Q \\) evaluated under set semantics, the minimisation function \\( M(Q) \\) will produce an r-graph corresponding to a minimal UCQ that is unique, modulo isomorphism, for the set of UCQs congruent to \\( Q \\). The minimisation of CQs (i.e., unary UCQs) is covered by Lemma 6.11. The minimisation of (non-unary) UCQs is based on Corollary 4 of Sagiv and Yannakakis [33], where we minimise the UCQ while maintaining this equivalence relation, more specifically, such that each BGP in the input UCQ will be contained in some BGP of the output UCQ (with a containment homomorphism that is the identity on projected variables). Note that this minimisation includes the removal of all unsatisfiable BGPs (per Lemma 6.2; if all are removed, then Lemma 6.10 applies as the UCQ is unsatisfiable). There are, however, two non-deterministic elements to consider in this minimisation:\n\n- The containment only considers projected variables as fixed. Hence the naming of other variables (and blank nodes) in BGPs does not matter. However, this issue is resolved prior to minimisation by \\( U(\\cdot) \\), which maps blank nodes to fresh (non-projected) variables, and then renames non-projected variables in each BGP to fresh variables, per Lemma 6.3, such that the naming of variables is deterministic modulo isomorphism.\n- We non-deterministically choose one BGP from each quotient set of equivalent BGPs with the same projected variables. However, since BGPs were previously minimised, all equivalent BGPs are isomorphic, and hence the choice is deterministic modulo isomorphism.\n\nThus, given a satisfiable UCQ \\( Q \\) evaluated under set semantics, \\( M(Q) \\) will produce an r-graph corresponding to a minimal UCQ that is unique, modulo isomorphism, for the set of UCQs congruent to \\( Q \\). Returning to the claim, we note that \\( Q_1 \\) and \\( Q_2 \\) are satisfiable UCQs evaluated under set semantics (with distinct), that \\( Q_1 \\equiv Q_2 \\), and thus we have that \\( M(Q_1) \\simeq M(Q_2) \\): the result holds per premise 4 of Remark 6.1.\n\nWe next consider UCQs under bag semantics (without distinct; again, this also holds in the case that the UCQs cannot return duplicates).\n\n**Lemma 6.14.** Let \\( Q_1 \\) and \\( Q_2 \\) denote satisfiable UCQs without distinct. If \\( Q_1 \\equiv Q_2 \\) then\n\n\\[\n\\text{R}^{-}(L(M(R(U(Q_1))))) = \\text{R}^{-}(L(M(R(U(Q_2)))))\n\\]\n\n**Proof.** Under bag semantics, observe that \\( U(\\cdot) \\) removes all unsatisfiable operands from the UCQ and \\( M(\\cdot) \\) acts as the identity (no minimisation is applied).\nPer the results for CQs, any minimisation of BGPs (aside from the implicit removal of duplicate triple patterns) will reduce the multiplicity of results on some datasets. Likewise removing satisfiable BGPs will reduce the multiplicities for any dataset where the removed BGP generates solutions. This leaves one source of non-determinism (the same as in the case for set semantics) per Lemma 6.3: that non-projected variables across BGPs may have the same label whereas the query is equivalent if they have distinct labels. As before for set semantics, \\( U(\\cdot) \\), maps blank nodes to fresh (non-projected) variables in the case of bag semantics. This implies that if \\( Q_1 \\equiv Q_2 \\) then \\( \\sim \\) letting \\( Q'_1 \\) and \\( Q'_2 \\) denote the result of removing unsatisfiable BGPs from \\( Q_1 \\) and \\( Q_2 \\) and distinguishing variables per Lemma 6.3\\( - Q'_1 \\simeq Q'_2 \\).\n\nThere are then two cases to consider:\n\n1. Either \\( Q_1 \\) or \\( Q_2 \\) cannot return duplicates, per the conditions of Lemma 6.6, but given that \\( Q_1 \\equiv Q_2 \\), then this implies that both \\( Q_1 \\) and \\( Q_2 \\) cannot return duplicates, which means that both satisfy the conditions of Lemma 6.6, and thus both will have distinct invoked by \\( U(\\cdot) \\).\n\n2. Both \\( Q_1 \\) and \\( Q_2 \\) may return duplicates, i.e., they do not satisfy the conditions of Lemma 6.6, and in neither case will distinct be invoked by \\( U(\\cdot) \\).\n\nThus we can conclude that \\( U(Q_1) \\simeq U(Q_2) \\), satisfying premise 2 of Remark 6.1, from which the result follows.\n\nFinally we consider what happens when one \\( U(\\cdot) \\)CQ has distinct, and the other does not but is congruent to the first query.\n\n**Lemma 6.15.** Let \\( Q \\) denote a satisfiable UCQ without distinct. Let \\( Q' = \\text{DISTINCT}(Q) \\). If \\( Q \\equiv Q' \\), then:\n\n\\[\nR^-(L(M(R(U(Q)))))) = R^-(L(M(R(U(Q'))))).\n\\]\n\n**Proof.** Since \\( Q \\) cannot return duplicates and \\( Q \\equiv Q' \\), it holds that \\( Q' \\) cannot return duplicates, and hence it must satisfy the conditions of Lemma 6.5. Thus \\( U(Q') \\) will add distinct, and we have that \\( U(Q) \\simeq U(Q') \\). The result then follows per premise 2 of Remark 6.1.\n\nHaving stated all of the core results, we are left to make the final claim of completeness.\n\n**Theorem 6.2.** Given two EMQs \\( Q_1 \\) and \\( Q_2 \\), if \\( Q_1 \\equiv Q_2 \\) then\n\n\\[\nR^-(L(M(R(U(Q_1)))))) = R^-(L(M(R(U(Q_2))))).\n\\]\n\n**Proof.** First we remark that for any EMQ \\( Q \\), the first steps of \\( U(Q) \\) – property path and union normalisation yield a UCQ. We denote by \\( Q'_1 \\) and \\( Q'_2 \\) the UCQs derived from \\( Q_1 \\) and \\( Q_2 \\). We now consider the cases:\n\n1. If \\( Q'_1 \\) or \\( Q'_2 \\) are unsatisfiable, then the result holds from Lemma 6.2.\n\n2. Otherwise \\((Q'_1 \\) and \\( Q'_2 \\) are satisfiable):\n \n (a) If \\( Q'_1 \\) and \\( Q'_2 \\) use distinct, the result holds from Lemma 6.13.\n \n (b) If neither \\( Q'_1 \\) nor \\( Q'_2 \\) use distinct, the result holds from Lemma 6.14.\n \n (c) If \\( Q'_1 \\) uses distinct, and \\( Q'_2 \\) does not, then \\( Q'_1 \\equiv Q'_2 \\) implies that \\( Q'_2 \\) cannot produce duplicates (since \\( Q'_1 \\) cannot). From this it follows that \\( Q'_1 \\equiv Q'_2 \\equiv \\text{DISTINCT}(Q'_2) \\). Now given that \\( Q'_1 \\equiv \\text{DISTINCT}(Q'_2) \\), it follows from Lemma 6.13 that \\( R^-(L(M(R(U(Q'_1)))))) = R^-(L(M(R(U(DISTINCT(Q'_2)))))) \\) (noting that \\( Q'_1 \\) and \\( \\text{DISTINCT}(Q'_2) \\) use distinct). Further given that \\( Q'_2 \\equiv \\text{DISTINCT}(Q'_2) \\), it follows from Lemma 6.15 that \\( R^-(L(M(R(U(Q'_1)))))) = R^-(L(M(R(U(DISTINCT(Q'_2)))))). \\) We have \\( R^-(L(M(R(U(Q'_1)))))) = R^-(L(M(R(U(Q'_2)))))). \\)\n\n (d) Otherwise, if \\( Q'_1 \\) does not use distinct, and \\( Q'_2 \\) uses distinct, the result follows from the previous case and the symmetry of congruence.\n\nThis concludes the proof.\n\nFinally we can leverage soundness and completeness for the following stronger claim.\n\n**Theorem 6.3.** Given two EMQs \\( Q_1 \\) and \\( Q_2 \\), it holds that \\( Q_1 \\equiv Q_2 \\) if and only if\n\n\\[\nR^-(L(M(R(U(Q_1)))))) = R^-(L(M(R(U(Q_2))))).\n\\]\n\n**Proof.** Let \\( Q'_1 \\) denote \\( R^-(L(M(R(U(Q_1)))))) \\), and \\( Q'_2 \\) denote \\( R^-(L(M(R(U(Q_2)))))) \\).\n\n\\( Q'_1 = Q'_2 \\) implies \\( Q_1 \\equiv Q_2 \\): follows from Theorem 6.1 (soundness), which tells us that \\( Q_1 \\equiv Q'_1 \\) and \\( Q'_2 \\equiv Q_2 \\), from which we have that \\( Q_1 \\equiv Q'_1 = Q'_2 \\equiv Q_2 \\), and thus that \\( Q_1 \\equiv Q_2 \\).\n\n\\( Q_1 \\equiv Q_2 \\) implies \\( Q'_1 = Q'_2 \\): is given in Theorem 6.2 (completeness).\n7. Canonicalisation of SPARQL 1.1 Queries\n\nWhile the previous section describes a sound and complete procedure for canonicalising EMQs, many SPARQL 1.1 queries in practice use features that fall outside of this fragment. Unfortunately we know from Table 15 that deciding equality for the full SPARQL 1.1 language is undecidable, and thus that an algorithm for sound and complete canonicalisation (that is guaranteed to halt) does not exist. Since completeness is not a strong requirement for certain use-cases (e.g., for caching, it would imply a “cache miss” that would otherwise happen without canonicalisation), we rather aim for a sound canonicalisation procedure that supports all features of SPARQL 1.1. Such a procedure supports all queries found in practice, preserving congruence, but may produce different canonicalised output for congruent queries.\n\n7.1. Algebraic rewritings\n\nWe now describe the additional rewritings we apply in the case of SPARQL 1.1 queries that are not EMQs, in particular for filters, for distinguishing local variables, and for property paths (RPQs). We further describe how canonicalisation of monotone sub-queries is applied based on the previous techniques.\n\n7.1.1. Filter normalisation\n\nSchmidt et al. [27] propose a number of rules for filters, which form the basis for optimising queries by applying filters as early as possible to ensure that the number of intermediate results are reduced. We implement the rules shown in Table 19. It is a folklore result that such rewritings further hold in the case of bag semantics, where they are used by a wide range of SPARQL engines for optimisation purposes: intuitively, filters set the multiplicity of solutions that do not pass to zero in the case of both bag or set semantics. We will rewrite this as follows:\n\n```\nSELECT DISTINCT ?x ?y ?z WHERE {\n (?x :sibling ?y FILTER(?x != ?y))\n OPTIONAL (?x :twin ?z FILTER(?x != ?z))\n FILTER(isiri(?x)) FILTER(strlen(str(?x))) > 4\n}\n```\n\n```\nSELECT DISTINCT ?x ?y ?z WHERE {\n (?x :sibling ?y)\n OPTIONAL (?x :twin ?z FILTER(?x != ?z))\n FILTER(isiri(?x) & ?x != ?y & strlen(str(?x))) > 4)\n```\n\nNote that the FILTER inside the optional cannot be pushed outwards: if there is a solution µ such that µ(?x) = µ(?z), having the filter inside the OPTIONAL may result in ?z being unbound, while having it outside would always filter the solution entirely.\n\n7.1.2. Local variable normalisation\n\nLike in the case of union variables, we identify another case where the correspondences between variables in different scopes is coincidental; i.e., where variables with the same name do not correlate. Specifically, we call a variable \\( v \\) local to a graph pattern \\( Q \\) on \\( V \\) (see Table 2) if \\( v \\in \\text{vars}(Q) \\) and \\( v \\not\\in V \\). Much like in the case of union variables, we can simply rename local variables to distinguish them from variables with the same name in other scopes.\n\nExample 7.2. Consider the following query looking for the names of aunts of people without a father or without a mother:\nTable 19\nEquivalences given by Schmidt et al. [27] for filters under set semantics\n\n<table>\n<thead>\n<tr>\n<th>Pushing filters inside/outside union</th>\n<th>[\\text{FILTER}<em>{R_1}(Q_1) \\cup \\text{FILTER}</em>{R_2}(Q_2) \\equiv \\text{FILTER}_{R_1}(Q_1 \\cup Q_2)]</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Filter conjunction</td>\n<td>[\\text{FILTER}<em>{R_1}(Q_1) \\land \\text{FILTER}</em>{R_2}(Q_2) \\equiv \\text{FILTER}_{R_1 \\cup R_2}(Q)]</td>\n</tr>\n</tbody>\n</table>\n\nTable 20\nSyntactic approximation of safe variables where \\(B\\) is a basic graph pattern; \\(N\\) is a navigational graph pattern; \\(Q'\\), \\(Q_1\\) and \\(Q_2\\) are graph patterns; \\(x\\) is an IRI, \\(v\\) is a variable; \\(V\\) is a set of variables; \\(R\\) s a built-in expression; \\(M\\) is a bag of solution mappings; \\(\\Lambda\\) is a set of aggregation expression–variable pairs; and \\(Q''\\) is a group-by pattern\n\n\\[Q = B\\]\n\\[Q = N\\]\n\\[Q \\in \\{(Q_1 \\text{ AND } Q_2), [Q_1 \\text{ SERVICE}^\text{false} Q_2]\\}\\]\n\\[Q = \\{Q_1 \\text{ UNION } Q_2\\}\\]\n\\[Q \\in \\{Q_1 \\text{ MINUS } Q_2, [Q_1 \\text{ OPT } Q_2], [Q_1 \\text{ SERVICE}^\text{true} Q_2]\\}\\]\n\\[Q \\in \\{\\text{SELECT}_V(Q'), \\text{GROUP}_V(Q'), \\text{GRAPH}_4(Q')\\}\\]\n\\[Q = \\text{VALUES}_M(Q)\\]\n\\[Q \\in \\{\\text{HAVING}(Q'), \\text{AGG}_A(Q')\\}\\]\n\\[\\text{vars}(Q) = \\text{vars}(B)\\]\n\\[\\text{vars}(Q) = \\text{vars}(N)\\]\n\\[\\text{vars}(Q) = \\text{vars}(Q_1 \\cup Q_2)\\]\n\\[\\text{vars}(Q) = \\text{vars}(Q_1 \\cap \\text{vars}(Q_2))\\]\n\\[\\text{vars}(Q) = \\text{vars}(Q_1 \\cup V)\\]\n\\[\\text{vars}(Q) = \\text{vars}(Q' \\cup \\{v\\})\\]\n\nTable 21\nIn this case, we distinguish the union variables. However, the variables \\(?f\\) and \\(?m\\) are local to the first and second \\text{MINUS} clauses, respectively, and thus we can also differentiate them as follows:\n\n\\[\n\\text{SELECT DISTINCT ?z WHERE} \\quad \\text{UNION} \\quad \\text{MINUS} \\quad \\}\n\\[\n\\text{SELECT DISTINCT ?z WHERE} \\quad \\text{UNION} \\quad \\text{MINUS} \\quad \\}\n\\]\n\nThe resulting query is equivalent to the original query, but avoids “false correspondences” of variables.\n\n7.1.3. UCQ normalisation\n\nWe continue to apply many of the rules of UCQ normalisation described in Section 6.1. Most of these rules were stated in a general way, and thus apply when other (non-EMQ) features are used in the subqueries of the union and join operators (or outside such operators). There are, however, certain caveats to consider in the more general case:\n\n- In the case of variable normalisation, deciding the set of possible variables becomes undecidable for the full language. It suffices for soundness (but not completeness) to use an overapproximation; given a graph pattern \\(Q\\) on \\(V\\), we can thus simply take \\(V\\) as the set of possible variables.\n\n- In the case of unsatisfiability normalisation, there are now many other possible causes of unsatisfiable graph patterns; unfortunately, deciding if a pattern is unsatisfiable or not for the full language is undecidable [34]. We currently only remove BGP s with literal subjects, as before for EMQs.\n\n- In the case of set vs. bag normalisation, deciding whether or not a query can return duplicate solutions is undecidable (noting that \\(\\text{UNION}(Q, Q)\\) cannot return duplicates if and only if \\(Q\\) is unsatisfiable). Currently we only apply this normalisation in EMQs, though this could be extended in future to consider other cases (such as C2RPQs).\n\n7.1.4. Summary\n\nGiven a SPARQL 1.1 query \\(Q\\), we denote by \\(A(Q)\\) the process involving the application of:\n\n1. filter normalisation;\n2. local variable normalisation;\n3. UCQ normalisation.\n\n### 7.2. Graph Representation\n\nWe extend the graph representation defined for EMQs in Section 7.2 so as to cover all SPARQL 1.1 query features. This extension is provided in Table 21 (we again include the EMQ features for reference).\n\nThe reader may have noted that we omitted three details from Table 21: how to represent built-in and aggregate expressions, and property paths. We now discuss these representations in turn.\n\n#### 7.2.1. Expressions\n\nWe recall that a term in **VIBL** is a *built-in expression*, and that if \\( \\phi \\) takes a tuple of values from \\( \\text{IBL} \\cup \\{ \\bot, \\epsilon \\} \\) as input and returns a single value in \\( \\text{IBL} \\cup \\{ \\bot, \\epsilon \\} \\) as output, then an expression \\( \\phi(R_1, \\ldots, R_n) \\), where each \\( R_1, \\ldots, R_n \\) is a built-in expression, is itself a built-in expression. If a built-in expression \\( R \\) is simply a term \\( R \\in \\text{VIBL} \\), then we use \\( \\iota(R) \\) to represent the expression, where \\( R(R) = \\emptyset \\). Otherwise, if \\( R = \\phi(R_1, \\ldots, R_n) \\) and either \\( \\phi \\) has at most one argument, or \\( \\phi \\) is an commutative function – i.e., the order of arguments is not meaningful – then:\n\n\\[\nR(R) = \\{(\\iota(R), a : \\text{BIExp}), (\\iota(R), : \\text{func}, \\iota(\\phi))\\}\n\\]\n\n\\[\n\\cup \\bigcup_{i=1}^{n} \\{(\\iota(R), : \\text{arg}, \\iota(R_i)) \\cup R(R_i)\\}\n\\]\n\nwhere \\( \\iota(\\phi) \\) is an IRI that is assumed to uniquely identify the function, and \\( \\iota(R), \\iota(R_i) \\) are fresh blank nodes. If \\( \\phi \\) has more than one argument and is not commutative – i.e., if the order of argument is meaningful – then for each \\( R_i \\), we additionally add a triple \\((\\iota(R_i), : \\text{ord}, \\iota(i))\\) to the above transformation.\n\nAs previously remarked, we consider operators (e.g., \\&\\&, +, =, etc.) to be represented by functions. We assume that commutative (and associative) operators – e.g., \\(?a+?b+?c\\), are represented as commutative \\( n \\)-ary functions – e.g., \\( \\text{SUM}(?a, ?b, ?c) \\). This allows for the representational graphs to abstract away details regarding the ordering of operands of commutative functions. We further remark that \\([Q_1, \\text{FE } Q_2]\\) and \\([Q_1, \\text{FNE } Q_2]\\) are considered to be filters in the concrete syntax; given that they do not use a built-in expression, we have rather defined their representation in Table 17.\n\nWith respect to aggregation expressions, we recall that if \\( \\psi \\) is a function that takes a bag of tuples from **IBL** and returns a value in **IBL** \\( \\cup \\{ \\bot, \\epsilon \\} \\), then an expression \\( A = \\psi(R_1, \\ldots, R_n) \\), where each \\( R_1, \\ldots, R_n \\) is a built-in expression, is an aggregation expression. An expression \\( A \\) of this form can be represented as:\n\n\\[\nR(A) = \\{(\\iota(A), a : \\text{AggExp}), (\\iota(A), : \\text{func}, \\iota(\\psi))\\}\n\\]\n\n\\[\n\\cup \\bigcup_{i=1}^{n} \\{(\\iota(A), : \\text{arg}, \\iota(R_i)) \\cup R(R_i)\\}\n\\]\n\nwhere \\( \\iota(\\psi) \\) is an IRI that uniquely identifies the function \\( \\psi \\), and \\( \\iota(A), \\iota(R_i) \\) are fresh blank nodes.\\(^{15}\\)\n\n#### 7.2.2. Property Paths\n\nBecause property paths without inverses and negated property sets are regular expressions, and any regular expression can be transformed into a finite automaton, and a finite automaton has a graph-like structure, we opt to represent property paths based on finite automata. This approach allows us to apply known normal forms for finite automata, providing, in turn, a normal form for RPQs, i.e., property paths without inverses or negated property sets; it further provides partial canonicalisation in the case of full property paths. Another benefit of this approach is that the automaton can be converted straightforwardly into RDF and used for the graph representation.\n\nGiven an RPQ, we apply the following process:\n\n1. we construct a non-deterministic finite automaton (NFA) based on Thompson’s construction for transforming regular expressions to NFAs [45];\n2. we convert this NFA into a deterministic finite automaton (DFA) by a standard subset expansion (the resulting DFA may be exponential on the number of states in the NFA);\n3. we perform a minimisation of the DFA using Hopcroft’s algorithm [46], which produces a canonical DFA such that all regular expressions that express the same language will produce the same DFA (modulo isomorphism on states).\n\nWe now provide an example to illustrate the process.\n\n**Example 7.3.** Consider an RPQ \\( <p^* : p^* > \\). In Figure 5 we provide an example of the corresponding NFA produced by Thompson’s algorithm, the DFA produced by subset expansion, and the minimal DFA produced by Hopcroft’s algorithm.\n\n\\(^{15}\\)Given that \\( \\psi \\) operates over bags of solution mappings, the ordering of the operands \\( \\{R_1, \\ldots, R_n\\} \\) does not matter.\nTable 21\nDefinitions for representational graphs $K(Q)$ of graph patterns $Q$, where \"a\" abbreviates rdfs: type. $B$ is a basic graph pattern, $N$ is a navigational graph pattern, $c$ is an RDF term, $e$ is a non-simple property path (not an IRI), $k$ is a non-zero natural number, $v$ is a variable, $w$ is a variable or IRI, $y$ is a variable or property path, $\\mu$ is a solution mapping, $\\Delta$ is a boolean value, $V$ is a set of variables, $X$ and $X'$ are sets of IRIs, $R$ is a built-in expression, $A$ is a bag of solution mappings, $\\Lambda$ is a set of aggregate expression–variable pairs, and $\\Omega$ is a non-empty sequence of order comparators.\n\n<table>\n<thead>\n<tr>\n<th>$\\gamma$</th>\n<th>$R(\\gamma)$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$B$</td>\n<td>${(\\cdot, a: \\text{And}) \\cup \\bigcup_{(s,p,o) \\in B} {(\\cdot, \\text{arg}(i(s,p,o))) \\cup R(s,p,o)}$</td>\n</tr>\n<tr>\n<td>$N$</td>\n<td>${(\\cdot, a: \\text{And}) \\cup \\bigcup_{(x,y,o) \\in N} {(\\cdot, \\text{arg}(i(s,y,o))) \\cup R(s,y,o)}$</td>\n</tr>\n<tr>\n<td>AND($Q_1, \\ldots, Q_n$)</td>\n<td>${(\\cdot, \\text{arg}(i(Q_1))) \\cup \\cdots \\cup {(\\cdot, \\text{arg}(i(Q_n))) \\cup (\\cdot, a: \\text{And}) \\cup R(Q_1) \\cup \\cdots \\cup R(Q_n)}$</td>\n</tr>\n<tr>\n<td>UNION($Q_1, \\ldots, Q_n$)</td>\n<td>${(\\cdot, \\text{arg}(i(Q_1))) \\cup \\cdots \\cup {(\\cdot, \\text{arg}(i(Q_n))) \\cup (\\cdot, a: \\text{Union}) \\cup R(Q_1) \\cup \\cdots \\cup R(Q_n)}$</td>\n</tr>\n<tr>\n<td>$\\text{Q1 MINUS Q2}$</td>\n<td>${(\\cdot, \\text{left}(i(Q_1))), (\\cdot, \\text{right}(i(Q_2))), (\\cdot, a: \\text{Minus}) \\cup R(Q_1) \\cup R(Q_2)}$</td>\n</tr>\n<tr>\n<td>$\\text{Q1 OPT Q2}$</td>\n<td>${(\\cdot, \\text{left}(i(Q_1))), (\\cdot, \\text{right}(i(Q_2))), (\\cdot, a: \\text{Optional}) \\cup R(Q_1) \\cup \\cdots \\cup R(Q_n)}$</td>\n</tr>\n<tr>\n<td>$\\text{FILTER}_d(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{exp}(R)), (\\cdot, a: \\text{Filter}) \\cup R(Q') \\cup R(R)}$</td>\n</tr>\n<tr>\n<td>$\\text{Q1 FE Q2}$</td>\n<td>${(\\cdot, \\text{left}(i(Q_1))), (\\cdot, \\text{right}(i(Q_2))), (\\cdot, a: \\text{Exists}) \\cup R(Q_1) \\cup R(Q_2)}$</td>\n</tr>\n<tr>\n<td>$\\text{Q1 FNE Q2}$</td>\n<td>${(\\cdot, \\text{left}(i(Q_1))), (\\cdot, \\text{right}(i(Q_2))), (\\cdot, a: \\text{NotExists}) \\cup R(Q_1) \\cup R(Q_2)}$</td>\n</tr>\n<tr>\n<td>$\\text{BIND}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{exp}(R)), (\\cdot, a: \\text{Bind}) \\cup R(Q') \\cup R(R)}$</td>\n</tr>\n<tr>\n<td>$\\text{VALUES}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{vals}({\\text{IRI}})), (\\cdot, a: \\text{Values}) \\cup R(Q') \\cup R({\\text{IRI}})}$</td>\n</tr>\n<tr>\n<td>$\\text{GRAPH}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{graph}({\\text{IRI}})) \\cup R(Q')}$</td>\n</tr>\n<tr>\n<td>$\\text{Q1 SERVICE}_{k} Q2$</td>\n<td>${(\\cdot, \\text{left}(i(Q_1))), (\\cdot, \\text{right}(i(Q_2))), (\\cdot, \\text{serv}(a)), (\\cdot, a: \\text{Service}) \\cup R(Q_1) \\cup R(Q_2)}$</td>\n</tr>\n<tr>\n<td>$\\text{GROUP}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{vars}(V)), (\\cdot, a: \\text{GroupBy}) \\cup R(Q') \\cup R(V)}$</td>\n</tr>\n<tr>\n<td>$\\text{HAVING}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{exp}(A)), (\\cdot, a: \\text{Having}) \\cup R(Q') \\cup R(A)}$</td>\n</tr>\n<tr>\n<td>$\\text{AGG}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{exp}(A)), (\\cdot, a: \\text{Aggregate}) \\cup R(Q') \\cup R(A)}$</td>\n</tr>\n<tr>\n<td>$\\text{ORDER}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{exp}(I)), (\\cdot, a: \\text{OrderBy}) \\cup R(Q') \\cup R(I)}$</td>\n</tr>\n<tr>\n<td>$\\text{DISTINCT}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, a: \\text{Distinct}) \\cup R(Q')}$</td>\n</tr>\n<tr>\n<td>$\\text{REDUCED}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, a: \\text{Reduced}) \\cup R(Q')}$</td>\n</tr>\n<tr>\n<td>$\\text{OFFSET}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{off}(k)), (\\cdot, a: \\text{Offset}) \\cup R(Q')}$</td>\n</tr>\n<tr>\n<td>$\\text{LIMIT}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{limit}(k)), (\\cdot, a: \\text{Limit}) \\cup R(Q')}$</td>\n</tr>\n<tr>\n<td>$\\text{SELECT}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{vars}(V)), (\\cdot, a: \\text{Select}) \\cup R(Q') \\cup R(V)}$</td>\n</tr>\n<tr>\n<td>$\\text{ASK}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, a: \\text{Ask}) \\cup R(Q')}$</td>\n</tr>\n<tr>\n<td>$\\text{CONSTRUCT}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{cons}(B)), (\\cdot, a: \\text{Construct}) \\cup R(Q') \\cup R(B)}$</td>\n</tr>\n<tr>\n<td>$\\text{DESCRIBE}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{desc}(X)), (\\cdot, a: \\text{Describe}) \\cup R(Q') \\cup R(X)}$</td>\n</tr>\n<tr>\n<td>$\\text{FROM}_{k}(Q')$</td>\n<td>${(\\cdot, \\text{arg}(i(Q'))), (\\cdot, \\text{from}(X)), (\\cdot, \\text{from}(X')) \\cup R(Q') \\cup R(X) \\cup R(X')}$</td>\n</tr>\n</tbody>\n</table>\n\n$\\{(x,p,o)\\}$ $\\{(\\cdot, a: \\text{And}) \\cup \\bigcup_{(x,p,o) \\in B} \\{(\\cdot, \\text{arg}(i(s,p,o))) \\cup R(s,p,o)\\}$ |\n\n$\\{(x,e,o)\\}$ $\\{(\\cdot, a: \\text{And}) \\cup \\bigcup_{(x,e,o) \\in N} \\{(\\cdot, \\text{arg}(i(s,y,o))) \\cup R(s,y,o)\\}$ |\n\n$\\langle e \\rangle$ minimal DPA with $e$ as start node; see Section 7.2.2\n\n$V$ $\\{(\\cdot, a: \\text{VarSet}) \\cup \\bigcup_{v \\in V} \\{(\\cdot, \\text{el}(v))\\}$ |\n\n$X$ $\\{(\\cdot, a: \\text{Iriset}) \\cup \\bigcup_{i \\in X} \\{(\\cdot, \\text{el}(i))\\}$ |\n\n$\\mathbb{N}$ $\\{(\\cdot, a: \\text{SoilBag}) \\cup \\bigcup_{(\\cdot, a: \\{\\text{iri}, \\text{soil}(\\mu, \\mathbb{N}(\\mu))\\})} \\cup R(\\{\\mu, \\mathbb{N}(\\mu))\\}$ |\n\n$\\mu(k)$ $\\{(\\cdot, a: \\text{Binding}) \\cup \\{\\cdot, \\text{num}(k)\\} \\cup \\bigcup_{k \\in \\mathbb{N}^{\\mathbb{N}}} \\{(\\cdot, \\text{el}(v(v,\\mu(v)))) \\cup R(v,\\mu(v)))\\}$ |\n\n$\\langle r, c \\rangle$ $\\{(\\cdot, a: \\text{Var}) \\cup \\{\\cdot, \\text{val}(i(c))\\}$ |\n\n$R$ see Section 7.2.1\n\n$\\Lambda$ see Section 7.2.1\n\n$\\Omega$ $\\{(\\cdot, a: \\text{OBESeq}) \\cup \\bigcup_{1 \\leq k} \\{(\\cdot, \\text{arg}(i(\\Omega[k], k))) \\cup R(\\Omega[k], k))\\}$ |\n\n$\\{(\\cdot, a: \\text{Exp}(R)), (\\cdot, a: \\text{asc}(\\Delta)), (\\cdot, a: \\text{ord}(i(k))) \\cup R(R)$\nThe minimal DFA produced by Hopcroft’s algorithm for the RPQ $e$ can then be encoded as an r-graph $R(e)$ where each state is assigned a fresh blank node, non-empty transitions are identified by the corresponding IRI of the predicate, and empty transitions are represented by a custom IRI $:\\epsilon$.\n\nIn order to generalise this process to full property paths, we must also support inverses and negated property sets. For inverses, we initially attempt to eliminate as many inverses as possible; for example, $^*(:p)^*$ would be rewritten to simply $:p^*$. Thereafter, any remaining inverses or negated property sets are represented with a canonical IRI; for example, $^:p^*$ becomes $:p-inv^*$. Thus the property path again becomes a regular expression, and is converted into a DFA using the aforementioned process. It is worth noting that the resulting DFA may not be canonical, and may thus miss equivalences between property paths (e.g., $:p^*/^:p^*$, $^:p^*/:p^*$ and $^:p^*/^:p^*$, $^:p^*/:p^*$, respectively). The r-graph can then be computed as before, where for a negated property set $e = !(p_1 \\ldots | p_n)$, we also add:\n\n$$R(e) = \\{(e,a,:notOneOf), (e,:arg,t(p_1)), \\ldots, (e,:arg,t(p_n))\\}.$$ \n\nWe will discuss the inverse mapping from the minimal DFA back to a path expression in Section 7.4.\n\n7.3. Minimisation and Canonicalisation\n\nMinimisation is applied only to BGPs and UBGPs that are contained within the larger query in the r-graph, considering any variable appearing outside of the BGP or union as a projected variable. We apply canonicalisation on the entire r-graph as before, computing a deterministic labelling for blank nodes.\n\n7.4. Inverse Mapping\n\nThe inverse mapping is defined analogously such that $R^-(R(Q)) = Q$, with one exception: property paths. This is because we do not represent property paths syntactically in the r-graph, but rather convert them to a minimal DFA, from which we must construct the property path once again. In order to construct the property path from the minimal DFA, we convert it into a regular expression by using the state elimination method [47], from which we can retrieve a normalised RPQ. Finally the inverse and negated property set IRIs are substituted accordingly (if present).\n\nExample 7.4. Consider the following DFA:\n\nThe first step consists in transforming this DFA into an equivalent NFA by introducing a new initial state $q_0$ and a single accepting state $q_f$. We add an $\\epsilon$ transition from $q_0$ to $q_1$, and from all accepting states to $q_f$.\n\nTo eliminate a state $q_a$ we have to replace all transitions that pass through $q_a$. Assuming there exists a\npath between \\( q_i \\) and \\( q_j \\) that passes through \\( q_a \\), we define the new transition \\( e_{ij} \\) as \n\\[ e_{ij} = (e_{a1}e_{a2}e_{a3})e'_{ij} \\]\nIn this expression, we have \\( e_{a0} \\), the transition from \\( q_i \\) to \\( q_a \\), followed by zero or more instances of \\( e_{a0} \\) which represents any self-loops in \\( q_a \\) or \\( e \\) if no such self-loops exist. This is then followed by \\( e_{a0} \\), the transition from \\( q_a \\) to \\( q_j \\). Finally, we have to consider the fact that there may have already been a path from \\( q_i \\) to \\( q_j \\), denoted here by \\( e'_{ij} \\); hence we append \\( \\ldots | e'_{ij} \\) to the expression to include the existing transition.\n\nWe now eliminate \\( q_i \\) following the expression. Since \\( q_i \\) has no self-loops and there are no existing paths between \\( q_0 \\) and \\( q_2 \\), these terms are excluded from the expression. We have \\( e_{02} = (e_{01}e_{12})e_{02} = e' : a = : a \\) and \\( e_{03} = (e_{01}e_{13})e_{03} = e' : c = : c \\).\n\nNext we eliminate \\( q_2 \\). In this case, \\( q_2 \\) does have a self-loop, and there exists a transition between \\( q_0 \\) and \\( q_3 \\) so the expression is as follows: \n\\[ e_{03} = (e_{02}e_{23})e_{03} = (e' : d' : b-inv) \\cdot c \\]\n\nWe now eliminate \\( q_3 \\). In this case:\n\\[ (e' : d' : b-inv) \\cdot c \\]\n\nFinally, we substitute the IRI \\( : b-inv \\) for the inverse expression \\( : b \\), yielding \\( (e' : d' : b-inv) \\cdot c \\).\n\n### 7.5. Soundness, completeness and incompleteness\n\nGiven a SPARQL 1.1 query \\( Q \\), the canonicalisation procedure is then defined by \n\\[ R^-(L(M(R(A(Q))))) \\]. We now discuss some formal properties of this procedure.\n\n#### 7.5.1. Soundness and completeness for EMQs\nFirst we look at the case of EMQs, and ask if the extended canonicalisation procedure is sound and complete for this fragment.\n\n**Lemma 7.1.** Given two EMQs \\( Q_1 \\) and \\( Q_2 \\), it holds that \\( Q_1 \\cong Q_2 \\) if and only if \n\\[ R^-(L(M(R(A(Q_1))))) = R^-(L(M(R(A(Q_2))))) \\]\n\n**Proof.** The result holds from observing that given an EMQ \\( Q \\), each step of the process returns precisely the same result as in the case of monotone canonicalisation. In particular, \\( A(Q) \\) applies filter normalisation and local variable normalisation in addition to \\( U(...) \\), but neither filters nor local variables appear in EMQs. Extensions to other functions do not affect EMQs in any way. Hence given an EMQ \\( Q \\), it holds that \n\\[ R^-(L(M(R(A(Q))))) = R^-(L(M(R(U(Q))))) \\]. The result then follows from Theorem 6.3.\n\n#### 7.5.2. Soundness for SPARQL 1.1\nNext we show that the process is sound for queries in the full SPARQL 1.1 query language.\n\n**Lemma 7.2.** For an SPARQL 1.1 query \\( Q \\), it holds that:\n\\[ R^-(L(M(R(A(Q))))) \\cong Q \\]\n\n**Proof.** We show that each step preserves congruence.\n\nIn \\( A(Q) \\) we apply filter normalisation, local variable normalisation, and UCQ normalisation. Each step preserves query equivalence, and thus congruence.\n\nNext we compute the r-graph, and apply minimisation. However, if the query is not in UCQ normal form, we only apply minimisation on BGPs and UBGPs contained in the query, considering any variables external to the (U)BGP as being “projected”, and thus fixed. More formally, taking a UBGQ \\( Q' \\) inside a larger query \\( Q \\), and letting \\( V' \\) denote the variables of \\( Q \\) used both inside and outside \\( Q \\), observe that we can replace \\( Q' \\) with \\( SELECT_{V'}(Q') \\) inside \\( Q \\) without changing the semantics of \\( Q \\) as variables not in \\( V' \\) are not used elsewhere in \\( Q \\), and since \\( Q \\) is a query, it must contain a SELECT, ASK, CONSTRUCT or DESCRIBE clause, whose results will not change if a variable not mentioned in the clause is projected away. Now since \\( SELECT_{V'}(Q') \\) is a UCQ, the minimisation process preserves congruence per Theorem 7.2.\n\nRegarding the r-graph, we assume that this (and the inverse r-mapping) has been defined such that \\( R^-(R(Q)) = Q \\) with the exception of property paths, but in this case it is clear that \\( R^-(R(Q)) \\cong Q \\) since the r-graph representation of RPQs relies on well-known automata techniques – Thompson’s construction, subset expansion, Hopcroft’s algorithm and state elimination – that will produce an equivalent RPQ (similar automata-based techniques were also used by Kostylev et al. [24] for their analysis of the containment of property paths). Thus \\( R^-(L(M(R(A(Q))))) \\cong Q \\).\n\\( R^-(M(R(A(Q)))) \\cong R^-(R(A(Q))) \\cong R^-(R(Q)) \\cong Q \\), from which the result holds.\n\n### 7.5.3. Incompleteness for SPARQL 1.1\n\nWe provide some examples of incompleteness to illustrate the limitations of the canonicalisation process for the full SPARQL 1.1 language.\n\nWe start with filters, which, when combined with a particular graph pattern, may always be true, may never be true, may contain redundant elements, etc.; however, detecting such cases can be highly complex.\n\n**Example 7.5.** Consider the following example:\n\n```sparql\nSELECT ?o\nWHERE {\n FILTER(!isiri(?p))\n}\n```\n\nThe `FILTER` here will always return false as the predicate in an RDF graph must always be an IRI. Thus the query is unsatisfiable and thus ideally would be rewritten to \\( Q_\\emptyset \\); however, we do not consider the semantics of filter functions (other than boolean combinations).\n\nNote that reasoning about filters is oftentimes far from trivial. Consider the following example:\n\n```sparql\nSELECT ?o\nWHERE {\n FILTER(!contains(\":\\\", str(?p)))\n}\n```\n\nThis query is unsatisfiable because predicates must be IRIs, and IRIs must always contain a colon (to separate the scheme from the hierarchical path) [48].\n\nNext we consider issues with property paths.\n\n**Example 7.6.** Consider the following example:\n\n```sparql\nSELECT ?anc\nWHERE {\n}\n```\n\nClearly this is equivalent to:\n\n```sparql\nSELECT ?anc\nWHERE {\n}\n```\n\nBut also to:\n\n```sparql\nSELECT ?anc\nWHERE {\n}\n```\n\nCurrently we rewrite concatenation, inverse and disjunction in paths (not appearing within a recursive expression) to UCQ features. This means that we currently capture equivalence between the first and second query, but not the first and third.\n\nOther examples are due to inverses, or negated property sets; consider for example:\n\n```sparql\nSELECT ?anc\nWHERE {\n}\n```\n\nThis is equivalent to:\n\n```sparql\nSELECT ?anc\nWHERE {\n}\n```\n\nHowever, we consider \\(!(:parent)\\) to be a fresh IRI and thus lose its semantic relation with \\(:parent\\).\n\nIncompleteness can also occur due to negation, which is complicated by the ambiguities surrounding `NOT EXISTS` as discussed in Section 3.10. We have postponed algebraic rewritings involving negation until this issue is resolved.\n\nWe could list an arbitrary number of ways in which arbitrary features can give rise to unsatisfiability or redundancy, or where queries using seemingly different features end up being equivalent. We could likewise provide an arbitrary number of rewritings and methods to deal with particular cases. However, any such method for canonicalising SPARQL 1.1 queries will be incomplete. Furthermore, many such “corner cases” would be rare in practice, where dealing with them might have limited impact. We then see two interesting directions for future work to address these limitations:\n\n1. Use query logs or other empirical methods to determine more common cases that this query canonicalisation framework may miss and implement targeted methods to deal with such cases.\n2. Extend the query fragment for which sound and complete canonicalisation is possible; an interesting goal, for example, would be to explore EMQs with full property paths (such queries are similar to C2RPQs [24], for which containment and related problems are decidable).\n\n### 8. Experiments\n\nIn these experiments, we wish to address two principal questions, as follows:\n\nQ1: How is the performance of the canonicalisation procedure in terms of runtime? Which aspects of the procedure take the most time? What kinds of queries are most expensive?\nQ2: How many more additional congruent queries can the procedure find in real-world logs versus baseline methods? Which aspects of the procedure are most important for increasing the number of congruent queries detected?\n\nWith respect to the first question, noting that the UCQ rewriting can produce a query that is exponentially large with respect to the input, upon which we run further exponential procedures such as minimisation and canonical labelling, the worst-case of the algorithm is super-exponential. However, this is a worst-case analysis with respect to the size of the query, where queries in practice are often relatively small and simple. Hence our hypothesis is that although there exist queries for which canonicalisation is not computationally feasible in theory, it should run efficiently (in fractions of a second) for the majority of real-world queries in practice (as found in public query logs).\n\nWith respect to the second question, most of our expected use-cases benefit from being able to find a wider range of congruent, real-world queries, as found in public query logs; for example, in the case of caching, finding more congruent queries will translate into higher cache hit rates. Thus it is of interest to see how many additional congruent queries our canonicalisation procedure can find from public query logs when compared with baseline (syntactic) methods, and in particular, which parts of the procedure have the most impact in terms of finding more congruent queries. In general, we hypothesise that canonical labelling will be an important component as variable naming would likely be a common variation in real-world queries; on the other hand, we hypothesise that minimisation will be less impactful in terms of finding more congruent queries as we expect few real-world queries to contain the types of redundancy dealt with in Section 6.3.\n\nWe thus design a number of experiments over real-world and synthetic queries in order to address these questions and evaluate our expectations.\n\n8.1. Implementation: QCan\n\nWe have implemented the canonicalisation procedure in a system that we call QCan written in Java. The system uses Jena ARQ for query parsing and processing. Algebraic rewritings are implemented on top of the query algebra that Jena ARQ provides. Constructing the r-graph is likewise implemented on top of Jena. Minimisation is conducted by using the blabel system [21] to compute the core of RDF graphs representing BGPs, thereafter implementing containment checks across BGPs using ASK queries evaluated in Jena. Finally canonical labelling is implemented using blabel [21]. All other aspects of the procedure are implemented directly in QCan, including the steps involving the representation and manipulation of property paths as automata. The source code of QCan, along with a suite of congruence test-cases, are available online at: http://github.com/RittoShadow/QCan. The machine used for these experiments has 12 Intel®Xeon®1.9GHz processors, and runs on Devuan GNU/Linux 2.1, with a maximum heap size of 10GB.\n\n8.2. Real-world query logs\n\nIn order to test our algorithm in a real-world setting, we used two query log datasets: the LSQ dataset [7]16, which itself contains queries from DBpedia, Linked Geo Data, RKB Explorer/Endpoint and Semantic Web Dog Food logs; and Wikidata logs [8] (Interval 7; organic queries)17. With respect to the datasets:\n\n- DBpedia [5] (DBP) is an RDF dataset extracted principally from Wikipedia, with the richest source of content being info-boxes.\n- LinkedGeoData [49] (GEO) is an RDF dataset that contains spatial data extracted from the OpenStreetMap [50] project.\n- The RKB Endpoint (REN) and Explorer (REX) datasets [51] primarily pertain to cultural and heritage data from the British Museum.\n- Semantic Web Dog Food (SWDF) [52] was a dataset that is now part of the Scholarlydata dataset [53], containing information about scholarly publications and conferences.\n- Wikidata [6] (WD) is a collaboratively-edited knowledge graph that complements the projects of Wikimedia with central, structured content.\n\nAll of these datasets have public SPARQL endpoints that receive queries over the Web from the public. These queries have been published as the Wikidata and LSQ logs for research purposes. Table 22 contains the distribution of features in each of the query sets in our real-world setting. In total we consider 2.8 million queries for our experiments. Despite the fact that BGPs are equivalent to joins of triple patterns, we only count as “AND” those joins for features other than triple pat-\n\n16https://aksw.github.io/LSQ/\n17https://iccl.inf.tu-dresden.de/web/Wikidata_SPARQL_Logs/en\nTable 22\nDistribution of queries using SPARQL features in the query logs; we mark features new to SPARQL 1.1 with an asterisk\n\n<table>\n<thead>\n<tr>\n<th>Feature</th>\n<th>DBP</th>\n<th>Geo</th>\n<th>REN</th>\n<th>REX</th>\n<th>SWDF</th>\n<th>WD</th>\n<th>All</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>BGP</td>\n<td>424,328</td>\n<td>842,794</td>\n<td>169,425</td>\n<td>335,450</td>\n<td>112,398</td>\n<td>861,383</td>\n<td>2,745,778</td>\n</tr>\n<tr>\n<td>DISTINCT</td>\n<td>192,368</td>\n<td>5,477</td>\n<td>147,575</td>\n<td>210,058</td>\n<td>57,195</td>\n<td>538,878</td>\n<td>1,151,351</td>\n</tr>\n<tr>\n<td>AND</td>\n<td>58,952</td>\n<td>78,575</td>\n<td>19,355</td>\n<td>34,180</td>\n<td>54,702</td>\n<td>321,239</td>\n<td>919,969</td>\n</tr>\n<tr>\n<td>MODES</td>\n<td>4,376</td>\n<td>412,343</td>\n<td>40,957</td>\n<td>80,655</td>\n<td>60,199</td>\n<td>321,239</td>\n<td>919,969</td>\n</tr>\n<tr>\n<td>OrP</td>\n<td>31,211</td>\n<td>19,914</td>\n<td>9,741</td>\n<td>23,587</td>\n<td>27,824</td>\n<td>343,838</td>\n<td>456,115</td>\n</tr>\n<tr>\n<td>FILTER</td>\n<td>200,001</td>\n<td>125,849</td>\n<td>8,974</td>\n<td>14,938</td>\n<td>4,716</td>\n<td>92,807</td>\n<td>447,285</td>\n</tr>\n<tr>\n<td>SERVICE*</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>406,990</td>\n<td>406,990</td>\n</tr>\n<tr>\n<td>UNIOEX</td>\n<td>89,766</td>\n<td>49,299</td>\n<td>1,653</td>\n<td>5,550</td>\n<td>32,459</td>\n<td>57,029</td>\n<td>235,756</td>\n</tr>\n<tr>\n<td>PATHS*</td>\n<td>0</td>\n<td>0</td>\n<td>96</td>\n<td>192</td>\n<td>37</td>\n<td>268,530</td>\n<td>268,535</td>\n</tr>\n<tr>\n<td>BIND*</td>\n<td>0</td>\n<td>0</td>\n<td>19,641</td>\n<td>31,507</td>\n<td>71,102</td>\n<td>106,050</td>\n<td>106,050</td>\n</tr>\n<tr>\n<td>AGG*</td>\n<td>0</td>\n<td>0</td>\n<td>16,444</td>\n<td>10,268</td>\n<td>42,777</td>\n<td>69,489</td>\n<td>69,489</td>\n</tr>\n<tr>\n<td>VALUES*</td>\n<td>0</td>\n<td>174</td>\n<td>0</td>\n<td>86</td>\n<td>55,037</td>\n<td>55,294</td>\n<td>55,294</td>\n</tr>\n<tr>\n<td>MINUS*</td>\n<td>0</td>\n<td>0</td>\n<td>192</td>\n<td>25</td>\n<td>5,700</td>\n<td>5,917</td>\n<td>5,917</td>\n</tr>\n<tr>\n<td>TOTAL</td>\n<td>424,362</td>\n<td>842,794</td>\n<td>169,617</td>\n<td>335,833</td>\n<td>112,470</td>\n<td>868,993</td>\n<td>2,754,069</td>\n</tr>\n</tbody>\n</table>\n\nterns. We further gather together under \"MODS\" the solution modifiers ORDER BY, LIMIT, OFFSET and projection. We observe that BGP is present in almost all queries, which is an expected result. Features new to SPARQL 1.1 are used more rarely in the LSQ logs, but this is likely because these logs predate the release of the standard; such features are quite widely used in the more recent Wikidata logs. The large use of SERVICE on Wikidata relates to the use of the custom label service offered by the endpoint as a syntactic convenience to help choose language preferences. With respect to the use of property paths, many are quite simple, usually used to find objects of a certain class or its transitive subclasses. Further details of these queries can be found in analyses by Saleem et al. [7], Malyshev et al. [8], Bonifati et al. [13], etc.\n\n8.2.1. Canonicalisation runtimes\n\nWe now present the runtimes for canonicalising the queries of the aforementioned logs. All queries in all six logs were successfully canonicalised. The results in Figure 6 indicate that the fastest queries to canonicalise take around 0.004 seconds (DBP), median times vary from 0.0135 seconds (DBP) up to 0.034 seconds (WD), while max times vary from 0.278 seconds (SWDF) up to 64 seconds (WD). The construction of the r-graph is the step that takes the most time on average, perhaps because many queries in the logs are relatively simple. On the other hand, the minimisation step presents the largest variation of all the steps, and dominates other processes in certain cases.\n\nFigure 7 shows that the WD set of queries produces the largest graphs, with the largest graph containing 3,224 nodes (WD). This is consistent with the results in Figure 6 since the total runtimes for WD queries can be much higher than those of the other query sets.\n\nThe results in Figure 8 show the runtimes for all query sets grouped by the features they use (at least once, possibly in conjunction with other features). We include SPARQL 1.0 features along with property paths for those logs using such features. These results indicate that queries containing UNION tend to take a longer time to process; i.e., it is the most computationally challenging feature to deal with in these queries. This is an expected result since the minimisation step\nmay cause an exponential blow-up on the number of\nbasic graph patterns in a monotonic fragment of a\nquery. Since most real world queries are not in a UCQ\nform, but rather contain combinations of joins and\nunions, it is likely that any query that contains unions\nwill produce larger r-graphs than those without any\nunions. We also see that\nOPTIONAL\nis an expensive fea-\nture, particularly for the GEO\ndataset. However, look-\ning into the GEO\nresults in more detail, most of the\nqueries with\nOPTIONAL\nappear to come from a single\nagent – an application using the SPARQL endpoint as\na backend – and also feature numerous disjunctive fil-\nters (using bound(·) over multiple\nOPTIONAL\nclauses)\nthat are rewritten into\nUNION,\nwhich is then the under-\nlying reason that the queries are slower.\n\n8.2.2. Duplicates found\nWe now look at the number of duplicates found,\nwhere we compare the following methods:\n\nRAW The raw query string is used, without any kind\nof normalisation.\n\nLABEL The raw query string is parsed using Jena\nARQ into its query algebra, and then serialised back into concrete SPARQL syntax.\n\nREWRITE The raw query string is parsed using Jena\nARQ into its query algebra, the query is rewritten per the algebraic rules, the r-graph is constructed and canonically labelled, and then serialised back into concrete SPARQL syntax.\n\nFULL The raw query string is parsed using Jena ARQ\ninto its query algebra, the query is rewritten per the algebraic rules, the r-graph is constructed, minimised, canonically labelled, and then serialised back into concrete SPARQL syntax.\n\nTables 23, 24, 25 denote the total number of duplic-\nate queries found, the most duplicates found for a sin-\ngle query, and the number of distinct queries produced\nfor each method, respectively. In general, there is a\nhigh number of exact duplicate query strings, possibly\nfrom the same query being sent many times to refresh\nthe results. Thereafter, the number of duplicates found either remains the same or increases in each successive algorithm. In particular, excluding duplicate query strings (RAW), the highest increase occurs with PARSE and thereafter LABEL, with WD being the query set for which the most additional duplicates are found with these methods, where the duplicates detected increase by a few thousand in each step. In the other query sets this increase is less. In addition, there is almost no difference beyond LABEL, meaning that algebraic rewritings and minimisation find very few additional congruent queries in these logs.\n\n8.3. Comparison with Existing Systems\n\nIn this section, we may compare the runtime performance of our algorithm with existing systems that can perform pairwise SPARQL containment checks. We provide an overview of these tools in Table 26. In our experiments, we consider SA [38] and JSAG [54] as they support cyclic queries. The queries used are part of the test suite designed by Chekol et al. [55] as part of their experiments. These correspond to two sets of queries: one of CQs without projection, and one of UCQs with projection. As discussed in Section 5, the SA and JSAG systems are not analogous to ours. We focus on query equivalence and congruence, and not on containment; conversely, SA and JSAG support containment. On the other hand, we compute a canonical form of a query, whereas SA and JSAG focus on pairwise checks (though JSAG offers indexing approaches based on constants in the query and isomorphic DAGs). Our approach is sound and complete for UCQs under both bag and set semantics; conversely, SA and JSAG focus on pairwise checks. In the case of CQs without projection, checking containment is tractable (see Table 15), and quite trivial, requiring checking that one BGP is set-contained in the other.\n\nFigure 9 shows the runtimes for our comparison of both containment checkers and our method (QCan). Note that there are no values for SA with UCQs because the UCQ set uses projection and SA does not support queries with projection. The results indicate that most queries for SA and JSAG take between one and ten milliseconds, whereas most queries under our method take between ten and one hundred milliseconds. In terms of the slowest queries, our method is faster than JSAG but slower than SA.\n\nTable 26\n\n<table>\n<thead>\n<tr>\n<th>Method</th>\n<th>ABGP</th>\n<th>BGP</th>\n<th>Projection</th>\n<th>Union</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SA</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n<td></td>\n</tr>\n<tr>\n<td>AFMU</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>TS</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>JSAG</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>QCan</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n</tbody>\n</table>\n\nIn general, the conclusion is that our method is slower for testing equivalence than existing containment checkers, but this is perhaps not surprising as our approach addresses the more difficult problem of first computing a canonical form for both input queries, and further considers congruence rather than the more trivial case of equivalence where variable names are fixed. Furthermore, once these canonical forms are computed, equivalence classes of congruent queries can be found in constant time using simple data structures (e.g., (ideal) hashing of the canonical query strings). If we estimate that our system is 10 times slower to canonicalise two queries than these systems can perform a pairwise check (per Figure 9), QCan will begin to outperform these systems for partitioning a set of 11 or more queries by equivalence (or congruence); in the case of 11 queries, these systems must perform \\( \\binom{11}{2} = 55 \\) pairwise checks (in the worst case), while QCan will canonicalise 11 queries and partition them...\nin constant time (in the best and the worst case). The time savings thereafter grow quadratically.\n\n8.4. Stress test\n\nWith the exception of some outliers, most queries that we have evaluated thus far have been canonicalised in fractions of a second. On the other hand, we know that our algorithms are super-exponential in the worst case. Such cases occur when we have monotone queries that are in conjunctive normal form (i.e., consisting of joins of unions), in which case our UCQ normal form can be exponential in size, upon which we perform further potentially exponential processes. In order to stress-test our method and explore such worst cases, we designed the following experiment.\n\nFor this experiment, we generate queries of the form \\( \\text{AND}(U_1, \\ldots, U_n) \\) where each union pattern is of the form \\( U_i = \\text{UNION}(T_1, \\ldots, T_m) \\), and each triple pattern is of the form \\( T_j = (s_j, p, o_j) \\), where \\( s_j \\) and \\( o_j \\) are variables with random names. The UCQ normal form for this query will consist of a union of \\( m^n \\) BGPs, each containing \\( n \\) triple patterns.\n\nFigure 10 shows the times for each step of the canonicalisation procedure on the synthetic UCQs. On the \\( x \\)-axis we increase \\( m \\) (the base of the exponent), while across the different series we increase \\( n \\) (the exponent). The \\( y \\)-axis is shown in log scale. We see that along the \\( x \\)-axis, the runtimes increase in a polynomial trend, with the polynomial depending on the constant \\( n \\). On the other hand, across the series, the runtimes increase exponentially as the number of conjunctions increases. In addition, the number of containment checks performed in the minimisation step is quadratic on the number of BGPs, where containment checks are themselves NP-complete, which may explain why the minimisation step exhibits the highest growth across the different series, reaching a maximum runtime of over four hours for \\( m = 8 \\) and \\( n = 4 \\). The runtime of the canonical labeling does not increase significantly as the number of unions or conjunctions increases, which is due to the minimisation step reducing the graph significantly due to the construction of the queries.\n\nThese results illustrate the poor worst-case behaviour of our canonicalisation procedure, particularly when considering queries with joins of many unions, and particularly when considering the minimisation procedure. However, as shown by the results presented in Section 8.2, virtually no queries in our real-world setting caused this worst-case behaviour.\n\n9. Conclusion\n\nIn this paper, we have presented a formal semantics of SPARQL 1.1 and a canonicalisation procedure that produces a deterministic query string modulo congruence (equivalence modulo variable naming). This procedure involves the application of algebraic rewritings of the query, the representation of the query as a graph, the minimisation of the query in order to remove redundancy, and finally the canonical labelling of the graph in order to produces canonical variable names based on the structure of the graph. We have proven this procedure to be sound and complete with respect to “extended monotone queries” under bag and set semantics, i.e., queries that can be rewritten to the features involving BGPs, joins, unions, projection, and distinct. We have further extended this procedure to provide sound and incomplete canonicalisation of the queries under the full SPARQL 1.1 language.\n\nDespite the super-exponential worst-case complexity of our procedure, the experimental results indicate that our method is efficient for most queries, running in a fraction of a second – in the median case – over millions of queries from real-world logs; the slowest query to canonicalise took over a minute. Such results are achieved because most real-world queries tend to be relatively small and simple. In this analysis, we de-\ndetermined that the graph representation is the step that takes the longest time on average. This implies that any further optimisations should first focus on this step. We further found that the \\texttt{UNION} feature is the most costly to canonicalise in general, with \\texttt{OPTIONAL} also proving costly in some datasets. We have compared the performance of our method for finding equivalent queries versus existing containment checkers, finding that our method is indeed slower, but produces a canonical form that thereafter allows for constant-time detection of congruent queries in large sets of queries. Running stress-tests over queries featuring joins of unions of increasing size, we have confirmed that our procedure quickly becomes inefficient, taking hours to canonicalise four joins of unions over eight triple patterns.\n\nWe have further confirmed that our procedure allows for detecting additional congruent queries over real-world logs versus baseline methods. We first observed that the vast majority of congruent queries are actually syntactically identical in terms of raw query strings, likely due to clients reissuing precisely the same query in order to intermittently refresh results. Of our canonical procedures, canonical labelling is the most important for finding additional congruent queries. On the other hand, minimisation and algebraic rewritings – though necessary to ensure completeness for monotone queries – lead to finding only a very small fraction of additional congruent queries. This would tend to suggest that in a practical caching system, where completeness can be traded for efficiency, it may be sufficient to apply canonical labelling without algebraic rewritings and minimisation. However, minimisation may be useful in cases where completeness is an important criterion. Also, in certain setting, queries with redundancy may be automatically generated; an interesting use-case along these lines is that of ontology-based data access (OBDA) [56], where rewritings may produce queries (typically UCQs) with redundancies that are inefficient to evaluate over large graphs.\n\nWith respect to future directions, a natural continuation of this work is to explore larger fragments of SPARQL 1.1 for which sound and complete canonicalisation can be performed. In particular, we have already begun to investigate such procedures for a fragment akin to UC2RPOs. At first glance, this should be analogous to the minimisation and canonicalisation of basic graph patterns and unions, where property paths are represented as automata and we can check for containment of automata to find redundant path patterns. However, we have already found that this requires entailment of paths with inverses, which is not as straightforward as checking for containment [24]. Another possible fragment to consider would be to include \\texttt{OPTIONAL}, which is a popular feature in practice; per the results of Picher and Skritek [17], however, we know that even for well-designed queries, equivalence for projection and \\texttt{OPTIONAL} is already undecidable.\n\nSPARQL 1.2 is on the horizon. We believe that the formal semantics of SPARQL 1.1 defined herein may serve as a useful reference for the standardisation effort. If the semantics of \\texttt{FILTER (NOT) EXISTS} is clarified as part of SPARQL 1.2, it would also be of interest to (partially) capture equivalences between the negation features of SPARQL. With respect to new features, our canonicalisation procedure should be extensible to SPARQL 1.2 following similar processes, though such canonicalisation cannot be complete.\n\nFinally, we are currently exploring use-cases for our canonicalisation procedure in the context of two ongoing projects: one relating to caching, and one relating to query answering. Regarding caching, we have seen that most congruences in real-world query logs are exact (syntactic) duplicates; however, rather than considering congruencies between full queries, a more promising approach for caching is to mine common sub-queries, where canonicalisation can be used for such purposes. In the context of question answering, we have also used canonicalisation in order to normalise training data for sequence-to-sequence models that translate natural language to SPARQL queries. Though work on these use-cases is ongoing, preliminary results are promising in terms of illustrating the practical benefits of having the option of canonicalising SPARQL queries. An important future line of research is then to explore and evaluate SPARQL canonicalisation in the context of these and further use-cases.\n\n\\textbf{Online material} We provide code and other material online at: http://github.com/RittoShadow/QCan. A demo is available at: http://qcan.dcc.uchile.cl.\n\n\\textbf{Acknowledgements} This work was supported by Fondecyt Grant No. 1181896 and by ANID – Millennium Science Initiative Program – Code ICN17_002. We would also like to thank the reviewers of the conference version of this paper for useful comments that helped to improve this work.\n\n\\textbf{References}\n\n\n[92] S. Cohen, Equivalence of queries that are sensitive to multiplicities, VLDB J. 18(3) (2009), 765–785.\n\n\n"}}},{"rowIdx":169,"cells":{"id":{"kind":"string","value":"b49f7ca5dc055a4791e6deb741ec51e00cce4a7c"},"text":{"kind":"string","value":"Predicting User Behavior over the Web\n\nAmal Adnan Al Safadi\n\nMaster of Science in Information Technology\nFaculty of Informatics\nBritish University in Dubai\n2010\nDeclaration\n\nI declare that this thesis was composed by myself and that the work contained therein is my own, except where explicitly stated otherwise in the text.\n\n(Amal Adnan Al Safadi)\nTo my parents soul, to my husband and my daughters Noor and Nada\nAcknowledgements\n\nI would like to express my gratitude to all those who made the completion of this thesis possible.\n\nI am deeply grateful to my supervisor, Dr. Sherief Abdullah for his guideness. His understanding, encouraging and support have provided a real help in passing all the difficulties and obstacles during the thesis research and writing.\n\nI would like to thank Mr. Krzysztof Dembczynski, the winner of ECML/PKDD 2007 Discovery Challenge for his kind response to my questions and providing me with his paper copy.\n\nI want to express my gratitude to Mr. Malik Tahir Hassan, the runner-up of ECML/PKDD 2007 Discovery Challenge for providing me with the labelled test set and for his cooperation and answering all my questions.\n\nI would like to express my deep and sincere gratitude to my sisters, brothers and friends for their continuous support and praying.\n\nI owe my loving thanks to my husband, Qusai Al Ja’ouni. Without his encouragement and understanding it would have been impossible for me to finish this work.\nAbstract\n\nWeb Usage Mining is the application of discovering useful patterns from web data using statistical and data mining techniques. It has recently a wide range of applications in E-commerce web site and E-services such as building interactive marketing strategies, Web recommendation and Web personalization. Due to its importance, the ECML/PKDD conference announced a competition (challenge) where researchers analyze a web-usage data set and attempt to make predictions about user behavior.\n\nThe purpose of this thesis is to analyze the first problem of ECML/PKDD 2007 challenge and apply web usage mining techniques in order to predict the user navigation behavior, such as the user visit duration and type of visited pages, based on user real historical data. Toward this goal, I applied web usage mining, data preprocessing, and visualization techniques. I also applied different classification algorithms and studied the effect of attribute selection on each classifier performance. The results I report are comparable to the challenge winner and outperform the runner-up on two out of the three challenge problems.\n## Contents\n\n<table>\n<thead>\n<tr>\n<th>Chapter</th>\n<th>Title</th>\n<th>Pages</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Abstract</td>\n<td></td>\n<td>5</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Introduction</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.1</td>\n<td>Overview</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.2</td>\n<td>Problem Statement</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.3</td>\n<td>Contributions</td>\n<td>13</td>\n</tr>\n<tr>\n<td>1.4</td>\n<td>Organization of the thesis</td>\n<td>14</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Background</td>\n<td>15</td>\n</tr>\n<tr>\n<td>2.1</td>\n<td>Web Mining</td>\n<td>15</td>\n</tr>\n<tr>\n<td>2.1.1</td>\n<td>Web Usage Mining</td>\n<td>16</td>\n</tr>\n<tr>\n<td>2.1.2</td>\n<td>Data Preparation</td>\n<td>16</td>\n</tr>\n<tr>\n<td>2.1.3</td>\n<td>Pattern Discovery</td>\n<td>17</td>\n</tr>\n<tr>\n<td>2.1.4</td>\n<td>Pattern Analysis</td>\n<td>18</td>\n</tr>\n<tr>\n<td>2.2</td>\n<td>ECML/PKDD Discovery Challenge</td>\n<td>18</td>\n</tr>\n<tr>\n<td>2.3</td>\n<td>Problem Definition</td>\n<td>19</td>\n</tr>\n<tr>\n<td>2.4</td>\n<td>Data</td>\n<td>19</td>\n</tr>\n<tr>\n<td>2.4.1</td>\n<td>General Notation</td>\n<td>19</td>\n</tr>\n<tr>\n<td>2.4.2</td>\n<td>Data Description</td>\n<td>20</td>\n</tr>\n<tr>\n<td>2.5</td>\n<td>Evaluation Criteria</td>\n<td>20</td>\n</tr>\n<tr>\n<td>2.5.1</td>\n<td>Score Function</td>\n<td>22</td>\n</tr>\n<tr>\n<td>2.6</td>\n<td>Challenge Results</td>\n<td>23</td>\n</tr>\n<tr>\n<td>2.7</td>\n<td>Related Work</td>\n<td>24</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Data Analysis and Reprocessing</td>\n<td>26</td>\n</tr>\n</tbody>\n</table>\n3.1 Exploratory Data Analysis ........................................... 26\n3.2 Data Reprocessing ...................................................... 31\n 3.2.1 Attributes Selection ........................................... 31\n 3.2.2 Test Options ...................................................... 32\n\n4 Analysis .................................................................. 34\n 4.1 Task1 ................................................................. 34\n 4.1.1 Analysis of Task1 .............................................. 34\n 4.1.2 Using Nominal Attributes ................................... 35\n 4.1.3 Using Numeric Attributes ................................... 39\n 4.1.4 Task1 Summary ............................................... 41\n 4.1.5 Task1 Evaluation .............................................. 43\n 4.2 Task 2 ................................................................. 43\n 4.2.1 Analysis of Task2 .............................................. 43\n 4.2.2 Using Nominal Attributes ................................... 44\n 4.2.3 Using Numeric Attributes ................................... 50\n 4.2.4 Task2 Summary ............................................... 51\n 4.2.5 Task2 Evaluation .............................................. 51\n 4.3 Task3 ................................................................. 51\n 4.3.1 Task3 Results ................................................... 52\n\n5 Conclusion and Further Work ........................................ 53\n\nA Methodologies ......................................................... 54\n A.1 Classification Methods ........................................... 54\n A.1.1 Naive Bayes .................................................... 54\n A.1.2 Decision tree ................................................... 55\n A.1.3 Decision Table ................................................ 56\n A.1.4 DTNB ............................................................ 56\n A.1.5 SVM .............................................................. 57\n A.1.6 Association Rules .............................................. 57\n A.2 Discretization ....................................................... 58\nList of Figures\n\n2.1 Web Usage Mining Process, (Srivastava et al., 2000) . . . . . . . . . . . . . . 16\n2.2 Potential Data Sources (Ye, 2003) . . . . . . . . . . . . . . . . . . . . . . . . 17\n2.3 Confusion Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21\n2.4 ROC Space (Wikipedia, 2007) . . . . . . . . . . . . . . . . . . . . . . . . . . . 22\n\n3.1 Number of records per user . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26\n3.2 Class distribution for train dataset. . . . . . . . . . . . . . . . . . . . . . . . . 27\n3.3 Sessions distribution in train data on days of week and during hours of day. . 27\n3.4 Sessions distribution in test data on days of week and during hours of day. . . 28\n3.5 Histogram of user table attributes. . . . . . . . . . . . . . . . . . . . . . . . . 29\n3.6 The class distribution on user’s attributes in train dataset. . . . . . . . . . . 29\n3.7 Distribution of first three categories visited by the users in the train data. . . . 30\n\n4.1 Task1: ROC Curve for NB Classifier using ‘discretize’ filter. . . . . . . . . . . 36\n4.2 Task1: ROC Curve for NB Classifier using “PKIDiscretize” filter. . . . . . . 37\n4.3 Task1: ROC Curve for NB Classifier using NumericToNominal filter. . . . . . 38\n4.4 Task1: a small section of the induced tree of J48 Classifier, CF 0.43 . . . . . . 40\n4.5 Task1: a small section of Weka output of J48 pruned tree, CF 0.43 . . . . . . 41\n\nA.1 Tree Induction Algorithm (Ferreira, n.d.). . . . . . . . . . . . . . . . . . . . . 56\n\nC.1 Score Function Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65\n## List of Tables\n\n4.1 Task1: Classification results using \\{userId, day, hour\\} after discretizing the data. 35 \n4.2 Task1: Confusion Matrix for NB, J48, SVM using ‘discretize’ Filter. 35 \n4.3 Task1: Results of PKIDiscretize filter/NB Classifier using \\{userId\\}. 36 \n4.4 Task1: Results of PKIDiscretize filter/NB Classifier using \\{userId, day, hour\\}. 36 \n4.5 Task1: Detailed Accuracy by class for PKIDiscretize Filter/NB Classifier. 37 \n4.6 Task1: Naive Bayes Classifier using ‘NumericToNominal’ filter. 37 \n4.7 Task1: Detailed Accuracy by class for NumericToNominal filter/NB Classifier. 37 \n4.8 Task1: Confusion Matrix for NumericToNominal/NB Classifier. 38 \n4.9 Task1: Including \\{browserId\\} as input attribute for NB Classifier. 38 \n4.10 Task1: Confusion Matrix for NB Classifier including \\{browserId\\}. 39 \n4.11 Task1: Summary of NB classifier with different inputs. 39 \n4.12 Task1: J48 classifier with different pruning. 40 \n4.13 Task1: J48 classifier with different pruning including the first category. 41 \n4.14 Task1 Evaluation. 43 \n4.15 Task2: NB Classifier using \\{userId\\} with ‘Discretize’ filter. 45 \n4.16 Task2: Confusion Matrix of 3rd category prediction using NB Classifier. 45 \n4.17 Task2: NB Classifier using attributes \\{userId, day, hour\\} with ‘Discretize’ filter. 46 \n4.18 Task2: J48 Classifier using attributes \\{userId\\} with ‘Discretize’ filter. 46 \n4.19 Task2: J48 Classifier using attributes \\{userId, day, hour\\} with ‘Discretize’ filter. 46 \n4.20 Task2: NB Classifier using userId with ‘NumericToNominal’ filter. 47 \n4.21 Task2: Detailed Accuracy By Class for 1st category prediction. 47 \n4.22 Task2: NB Classifier using \\{userId, day, hour\\} with ‘NumericToNominal’. 47 \n4.23 Task2: Results of NB classifier with different inputs. 48 \n4.24 Task2: The score function for NB classifier. 48\n4.25 Task2: Results of NB classifier with different inputs including Class Attribute . 49\n4.26 Task2: Results of NB classifier with different inputs including ClassAB Attribute 49\n4.27 Task2: Results of DT classifier with different inputs . . . . . . . . . . . . . . . 50\n4.28 Task2: Results of DT classifier with Class Attributes . . . . . . . . . . . . . . 50\n4.29 Task2 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51\n4.30 Task3 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52\nChapter 1\n\nIntroduction\n\n1.1 Overview\n\nThe term Web mining was defined by Etzioni (1996) to denote the use of data mining techniques to automatically discover Web documents and services, extract information from Web resources, and uncover general patterns on the Web. Web mining is an interdisciplinary research area that spans over machine learning, databases, data mining, information retrieval and Web retrieval. Typically, web mining is divided into three types: web content mining, web structure mining and web usage mining.\n\nThis dissertation focuses on Web Usage Mining (WUM), which is about using data mining techniques to analyze the traces of web users in order to find interesting patterns. WUM plays an important role in E-commerce web site and E-services. WUM is a very helpful tool to gather the important information from the site visitors. The analysis of this information allows the company to improve its productivity by directing its efforts towards the most effective ways of their promotional strategies and internet traffic.\n\nWUM has a wide range of applications such as building interactive marketing strategies, Web recommendation and Web personalization. In fact, WUM was the topic of KDD Cup 2000 competition and one of the problems proposed in ECML/PKDD 2007 Discovery Challenge. This challenge is a good representation of WUM since the dataset is acquired from a real company, not synthesized one.\n\n1.2 Problem Statement\n\nThe objective of this study is to solve the first problem of ECML/PKDD Discovery Challenge 2007 which was concerned with predicting user behavior by characterizing the nature of a user’s visit. The challenge provided a real web traffic data that was collected by Gemius (an internet market research company) using cookies technology and special scripts placed on the\nmonitored web-pages (Gemius, 2007). The accumulated information consisted of the user id and the timestamp along with category-view path. User’s details such as social and demographic data were collected too. The data were collected after one month of monitoring polish web sites and divided into two data sets, the training data consisted of the first three weeks of the month while the test data consisted of the last week of the month (ECML/PKDD, 2007).\n\nThe first discovery challenge has three sub-problems as follows:\n\n- **Problem 1: The length of the visit**\n A visit is a sequence of page views by one user where each page belongs to a specific category. During one visit, a user may view pages of one or more categories. The goal of problem 1 is to predict whether a user will have a short or a long visit according to the following definition:\n\n **Short visit:** is a visit with page views of only one category.\n **Long visit:** is a visit with views of pages belonging to at least two categories.\n\n The input for this task is the user id and the timestamp and the output should be the correct predicted class.\n\n- **Problem 2: The most probable categories**\n Solution of Problem 2 is a list of the most three probable categories in a given visit of a given user.\n\n- **Problem 3: The most probable categories and ranges of numbers of page views**\n Solution of problem 3 is a list of the most three probable categories in a given visit for a given user with range of number of page views in each category.\n\n### 1.3 Contributions\n\nThis dissertation aims to explore and discover WUM through solving the research problems. This dissertation presents the following contributions:\n\n- Demonstration of how to visualize WUM data and extract useful information from it.\n\n- In-depth analysis of preprocessing techniques on the challenge data and identifying key preprocessing steps (not published by any of the competitors) that significantly improves the performance of all classifiers.\n\n- Comparative study of large number of classifiers, including the ones used by winner and runner up. In addition, trying a new technique (DTNB) that none of the competitors could have used it since it was published in 2008, while the challenge was in 2007.\n• Studying the effect of attribute selection on the classifiers performance. In most tasks I outperformed the runner up for the contest and was slightly worse than the winner.\n\n1.4 Organization of the thesis\n\nThe rest of this thesis is organized as follows. In Chapter 2, I introduce a short background of Web Mining and the main three phases of WUM process. Then I give a brief description of the ECML/PKDD Discovery Challenge. I outline ECML/PKDD discovery challenge 2007 problems, describe the data, and explore the contest results. In addition, the literature review section explores the work of others which is related to web usage mining field, mainly predicting web usage.\n\nChapter 3 presents the data analysis and visualization and describes the preprocessing strategy I have employed. The implementation part is introduced in chapter 4 where I describe the details of applying the technical part of the selected methodologies for each task. Moreover I present and analyze the results of my approach and compare it with the contest results. Finally, the conclusion and future work is given in Chapter 5.\nChapter 2\n\nBackground\n\nThis chapter provides a basic knowledge about the Web Usage Mining. It gives a brief background about the main three phases of WUM process. Then it describes the ECML challenge and introduces the research problem in details. Finally it surveys the previous/related work in WUM.\n\n2.1 Web Mining\n\nWeb Mining is defined as the application of data mining techniques to discover patterns from the Web. Web mining can be divided into three different types, depending on the nature of the data, which are Web content mining, Web structure mining and Web usage mining (Srivastava et al., 2000).\n\n- Web Content Mining: Extracting useful information from page content (text, images, other ... etc). It is used by search engines, agents, recommendation engines to help users find what they are looking for. The technologies that are normally used in web content mining are Natural language processing and Information retrieval.\n\n- Web Structure Mining: using the hyperlink structure of the Web as an additional information source. Graph theory is normally used to analyze the node and connection structure of a web site.\n\n- Web Usage Mining: applying statistical and data mining techniques to the preprocessed Web log data, in order to discover useful patterns.\n\nThe task we are addressing in this dissertation falls under the Web Usage Mining type.\n2.1.1 Web Usage Mining\n\nDesigners and owners of the websites often have a great interest in understanding the patterns of how people navigate their sites. This knowledge could help designers to improve their sites structure, provide better service, increase sales, attract new customers, and retain current customers by personalizing their user profiles. The Web usage mining process can be regarded as a three-phase process, consisting of the data preparation, pattern discovery, and pattern analysis phases (Cooley et al., 2000).\n\n\n\n2.1.2 Data Preparation\n\nThe data collected to this phase comes from three different locations: the server side, the client side and the proxy side. The first step is to clean the raw web log files from entries involving pages that returned an error or graphics file accesses and insert the processed data into a relational database or a data warehouse (Ferreira, n.d.).\n\nAnother important step is the user identification. There are several ways to identify individual visitors. The easiest way is assuming that each IP address identifies a single visitor. Nevertheless, that may be not very accurate because a visitor may access the Web from different computers, or if a proxy is used, many users may use the same IP address. A further assumption can then be made, that consecutive accesses from the same host during a certain time interval come from the same user (Eirinaki and Vazirgiannis, 2003). The best way to identify unique visitors is using cookies or similar mechanisms or the requirement for user registration. However, the reluctance of users to share personal information is a potential problem in using\nsuch methods.\n\nThe next step is performing session identification by dividing the clickstream of each user into sessions. A thirty minute timeout is often used as the default method of breaking a user’s clickstream into sessions.\n\nIn this dissertation, the log data is already prepared and reprocessed and the users are identified by the cookies technology and the 30 minutes timeout is used to define the sessions. The focus of this dissertation is on analyzing and visualizing the given data to extract useful information to help in the second phase of WUM which is Pattern Discovery.\n\n### 2.1.3 Pattern Discovery\n\nIn the second phase, statistical methods, as well as data mining methods (such as association rules, sequential pattern discovery, clustering, and classification) are applied in order to detect interesting patterns.\n\nThere are a wide variety of data mining algorithms, drawn from the fields of statistics, pattern recognition, machine learning, and databases. Here is brief information about some of them:\n\n1. **Statistical Analysis**: it’s the most common method to extract information about web site visitors. By analyzing the session file, many descriptive statistical analyses can be performed such as frequency, medium, mean, etc. This information can be potentially useful in deciding the next step.\n\n2. **Link Analysis**: is a descriptive approach to explore data that can help identify relationships among values in a database. The two most common approaches to link analysis are Association discovery and Sequence discovery.\n\n - **Association rule mining**: is a technique for finding frequent patterns, associations, and correlations among sets of items. It is used in order to reveal correlations between pages accessed together during a server session. Such rules indicate the possible relationship between pages that are often viewed together even if they are not di-\nrectly connected, and can reveal associations between groups of users with specific interests (Eirinaki and Vazirgiannis, 2003).\n\n**Sequence discovery mining:** is very similar, in that a sequence is an association related over time. Because of ordered nature of click-streams in web log data, this technique can have a very important role in knowledge discovery. We can have an example like this: “If user visits page X, and then page Y, it will visit page Z with c% of chance”. The algorithms for sequence mining inherited much from the association mining algorithms (Ferreira, n.d.).\n\n3. **Clustering:** is used to group together items that have similar characteristics. In Web mining, there are two types of clustering, user clusters and page clusters. Page clustering identifies groups of pages that seem to be conceptually related which is used in Internet Search Engines and Web Assistance Providers (Srivastava et al., 2000). User clustering tends to group users that seem to behave similarly when navigating through a Web site. Such knowledge is used in e-commerce in order to perform market segmentation but is also helpful when the objective is to personalize a web site (Eirinaki and Vazirgiannis, 2003).\n\n4. **Classification:** is a process that maps a data item into one of several predetermined classes. This pattern can be used both to understand the existing data and to predict how new instances will behave. In the Web domain classes usually represent different user profiles and classification is performed using selected features that describe each user’s category. The most common classification algorithms are decision trees, naive bayesian classifier, neural networks (Srivastava et al., 2000).\n\n### 2.1.4 Pattern Analysis\n\nPattern Analysis is the final stage of the Web usage mining. The main task of this stage is to evaluate the patterns produced by the data mining algorithms and to eliminate the irrelevant rules or patterns and to extract the interesting rules or patterns from the output of the pattern discovery process.\n\nThe most common ways of analyzing such patterns are either by using a query mechanism like SQL on a database where the results are stored, or by loading the results into a data cube and then performing OLAP operations. Additionally, visualization techniques are used for an easier interpretation of the results (Eirinaki and Vazirgiannis, 2003). This stage will not be addressed in this dissertation.\n\n### 2.2 ECML/PKDD Discovery Challenge\n\nThe aim of this dissertation is to solve the first problem of ECML/PKDD discovery challenge of year 2007. The 2007 Discovery Challenge was devoted to three problems: User behavior\nprediction from web traffic logs, HTTP traffic classification, and Sumerian literature understanding (ECML/PKDD, 2007).\n\nThe annual Discovery Challenge constitutes a collection of data and problems as a common ground for better comparisons and discussions of the applicability of KDD methods on a real-world problems with respect to both KDD and application viewpoints.\n\n2.3 Problem Definition\n\nThe first problem of 2007 Discovery Challenge is divided into three separate tasks. The first task is predicting the length of the user’s visit. The result should be either short for one visited category or long for more than one visited category. Constructing such a model will help web designers to save resources by focusing on users that spend longer time. For example the advertisement or offers can be sent for those specific users instead of sending it randomly for all users. The second task is predicting the first 3 visited categories, which indicates the user’s interest. Finally the third task is predicting the number of pages seen in each of the 3 categories in task 2.\n\n2.4 Data\n\nThe data (provided by 2007 ECML/PKDD Discovery Challenge) were collected during one month of monitoring Polish web sites. The data had information about 4882 users that generated 545,784 sessions. These sessions had been separated into two datasets; the training data file contains data gathered during the first three weeks of the month (379,485 session paths), while the test data consists of the last week of the month (166,299 session paths). All users are shown in the test data are presented also in the training data.\n\n2.4.1 General Notation\n\nThese general notations of the problem have been given by the Discovery Challenge 2007 and have been used in the dissertation (ECML/PKDD, 2007):\n\n- “Page: any web page participating in the research. Pages are distinguishable only by the category they belong to.”\n- “Page View: the event of displaying the monitored web page.”\n- “Visit: an uninterrupted series of Page Views on a given web site executed by the same visitor (cookie), counted as a closed whole. This represents an Internet user’s total stay on the web site in question for any individual visit. It is assumed that one Page View cannot exceed 30 minutes (a longer Page View duration / gap will result in the series being counted as two separate Visits).”\n• “Visit Path: series of web pages visited during one Visit. This represents the clickstream that the user followed in navigating a web site.”\n\n• “Category: each page is qualified as a member of a relevant category that is a group of web sites of a similar leading theme, e.g., entertainment, technology, news, communication, education, e-commerce, business, etc. These categories have been assigned certain identifiers.”\n\n### 2.4.2 Data Description\n\nThe provided data gives information about users as well as visit paths.\n\ni. Users Table: This table gives demographic information (country, region and city) and system characteristics information (operating system, browsers and versions) where each user has been given a unique id. An example record in Users table is as follows:\n\n<table>\n<thead>\n<tr>\n<th>UserId</th>\n<th>CountryId</th>\n<th>RegionId</th>\n<th>CityId</th>\n<th>SystemId</th>\n<th>SysSubId</th>\n<th>BrowserId</th>\n<th>BrowVerId</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>10</td>\n<td>42</td>\n<td>11</td>\n<td>44</td>\n<td>3</td>\n<td>9</td>\n<td>1</td>\n<td>517</td>\n</tr>\n</tbody>\n</table>\n\nii. Visit Paths table: This table consists of records of individual visit sessions described by the fields: path-id, user-id, timestamp, path category-id, pageviews-number. An example record in this table is as follows:\n\n<table>\n<thead>\n<tr>\n<th>pathId</th>\n<th>UserId</th>\n<th>timestamp</th>\n<th>Path(category-id, pageviews-number)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>27</td>\n<td>1</td>\n<td>1169814548</td>\n<td>(7,1) (16,2) (17,9) (16,1)</td>\n</tr>\n</tbody>\n</table>\n\nEach session has a unique number, path-id, generated by a single user, user-id, identified based on the user’s cookie. The timestamp attribute, given in UNIX timestamp format, is the number of seconds that have elapsed since January 1, 1970 (midnight UTC/GMT), not counting leap seconds. The timestamp records the time of the start of the visit while the path field shows the sequence of visited categories by that user and number of page views during one visit in one category not interrupted by a page view from a different category.\n\n### 2.5 Evaluation Criteria\n\nTo evaluate the three tasks initially I use the accuracy, which defined as:\n\n\\[\nprediction \\text{ accuracy} = \\frac{\\text{the number of correctly classified instances}}{\\text{number of total instances}} \\times 100\\%\n\\]\nBut since the data set is unbalanced (the number of short visits class is greatly more than the long visits class), the accuracy and the error rate of a classifier is not representative of the true performance of the classifier since the classifier can easily be biased towards the major class. That’s why we use the Confusion Matrix. Each column of the matrix represents the instances in a predicted class, while each row represents the instances in an actual class.\n\nFor a binary classification, where the outcomes are labeled either as positive \\((p)\\) or negative \\((n)\\) class, there are four possible outcomes from a binary classifier. If the outcome from a prediction is \\(p\\) and the actual value is also \\(p\\), then it is called a true positive \\((TP)\\); however if the actual value is \\(n\\) then it is said to be a false positive \\((FP)\\). Conversely, a true negative has occurred when both the prediction outcome and the actual value are \\(n\\), and false negative is when the prediction outcome is \\(n\\) while the actual value is \\(p\\).\n\n\n\nMany statistical measures can be done using the confusion matrix, such as:\n\n**ROC Curve:** a Receiver Operating Characteristic, which represents the relative trade-offs between true positive (benefits) and false positive (costs). It can be represented by plotting the fraction of true positives \\((TPR)\\) vs. the fraction of false positives \\((FPR)\\).\n\nThe diagonal line divides the ROC space in areas of good or bad classification. Points above the diagonal line indicate good classification results, while points below the line indicate wrong results.\n\n**Precision:** for a class is the number of true positives divided by the total number of elements labeled as belonging to the class.\n\n\\[\nPrecision = \\frac{tp}{tp + fp}\n\\]\n\n**Recall:** is defined as the number of true positives divided by the total number of elements that actually belong to the class.\n\n\\[\nRecall = \\frac{tp}{tp + fn}\n\\]\n\nA Precision score of 1.0 for a class \\(C\\) means that every item labeled as belonging to class \\(C\\) does indeed belong to class \\(C\\) (but says nothing about the number of items from class...\nC that were not labeled correctly) whereas a Recall of 1.0 means that every item from class C was labeled as belonging to class C (but says nothing about how many other items were incorrectly also labeled as belonging to class C). Precision vs. recall can be plotted in a manner similar to ROC curves.\n\n**F-measure:** can be used as a single measure of performance of the test. The F-measure is the harmonic mean of precision and recall:\n\n\\[\nF = \\frac{2 \\times (\\text{Precision} \\times \\text{Recall})}{\\text{Precision} + \\text{Recall}}\n\\]\n\nF-measure tends to be closer to the smaller one between the precision and recall estimates. F-measure is high if both precision and recall is high.\n\n### 2.5.1 Score Function\n\nThe contest organizers proposed a specific score function to measure the prediction performance of the second and third tasks. For the second task, the estimated vector will be compared with the actual vector of category identifiers according to the formula:\n\n\\[\n\\text{CategoryId}_{\\text{predicted}}(i) = \\text{CategoryId}_{\\text{actual}}(j)\n\\]\n\nThen two score vectors are created, one for the actual vector and one for the predicted categories vector, accordingly to the following rule: 5 points for the first category, 4 points for second category, 3 for third, etc. (from fifth category on one point is given). Afterwards, mini-\nmums of corresponding elements of both vectors are determined. These numbers are summed up and give the final result score.\n\nSince many of the actual vectors and predicted vectors has repeated categories, we assume that when a category appears more than once in the sequence, each time it is regarded as new, different category and replace the repeated category with a new category ID and compute the score accordingly.\n\nFor the third task, the values of given categories are checked as described above in the second task and the ranges of numbers of page views are checked according to the condition:\n\n\\[\n\\text{number of pageviews}_{\\text{actual}}(i) \\in \\text{range of pageviews}(i)\n\\]\n\nSimilarly as for the second task, the score of actual and predicted vectors are calculated according to the same rule above and at the last step; the award vector is determined by taking minimums of corresponding elements of both vectors and adding 1 point for giving a correct range or 0 points for wrong range of page views. These numbers are summed up and give the final result score.\n\n### 2.6 Challenge Results\n\nThe winner of KDD 2007 first challenge used at the beginning Simple Global Model which related to visit’s granule. J48 classifier has been used for the first task by using many selected features such as (user data, week day, hour, etc..). Due to the unsatisfied results of the simple global model, they developed Enhanced Global Model which depends on estimating additional values describing the behavior of the users by using estimation set isolated from the training set. These values are category-based (210 attributes in total) and visit-length based (only two type of visits, short or long). User data such as (country, region, city... etc) and time-based (hour, week-day) were included in this approach which gave better results. Finally, User Models approach was used for the three tasks. This approach used user id number directly without extracting any additional information about the user. the User Models had three versions: the first one was the Simple Classification where the classification process had done by doing a simple call to the look-up table containing probability estimates.\n\nIn the second model, Trend Prediction, data for each user was regarded as a short time series with values 0 for short visit or 1 for long visit. Then a polynomial trend was fitted to the time series for each user and was used as a probability estimator. The last and the most sophisticated model was the Auto-regression Model. for each user a separate linear model is fitted to the user’s time series, based on the following attributes: normalized timestamp, time from the last visit, average length of the last 2,4 and 8 visits. Almost all the user models have very similar results which was better from the global models results. This motivated the authors to choose the simplest model which was the Simple Classification Model.\nDepending on the analysis of the first task, the winner did not perform tests on the global models and choose to use the User Model for the second and third task taking into account only one predictor - user id number. (Dembczynski et al., 2009).\n\nThe Runner-Up of KDD 2007 presented a Bayesian Classifier for the three tasks. They model the sequence of page categories visited as a Markov chain. Naive Bayes classifier was used for the first task by assuming that User Id and the timestamp are conditionally independent. This approach gave the same result which has been got by applying SVM with more efficiency since it took only less than one minute to get the same results of several hours of SVM to learn. For the second task the sequence of page categories visited are modeled as a Markov chain where the start state is determined by Bayes classifier where the subsequent states are determined by combining the posterior probability estimates given by the Markov chain with that of the Bayes classifier for that particular position. Using the predicted page categories in Task2, Bayes classifier was used to predict the range of page views made at the first three positions in each visit session (Hassan et al., 2007).\n\n2.7 Related Work\n\nA variety of data mining techniques and algorithms have been used for the purpose of web data analysis.\n\nWhile this dissertation focus on predicting the expected behaviors of the user, such as his visit period or his preferred subjects, (Ting et al., 2005) presented a new approach called UBB Mining which was based on discovering the unexpected browsing behaviors of the user according to predefined patterns specified by the site designer. The result allowed the designers to review, improve or redesign their sites and could be a good step to model a user browsing behavior. The core of the approach was defining the expected route in the form of continuous common subsequences which was specified by the site owner or designer which is not practical for large sites with different designers.\n\n(Velayathan and Yamada, 2007) presented a method to automatically detect and log user behavior at the client-side by creating a client-side browser. It focused on other factors other than time that evaluate user interest such as scroll action, form action, searching text, copying text etc. In this dissertation, the user identity, timestamp and the categories of visited pages are the main factors that determine user interest.\n\n(Sun et al., 2002) proposed the use of Support Vector Machine (SVM) classifiers to classify web pages using both their text and context feature sets while Dumais and Chen (2000) used SVM classifiers to build a hierarchical structure model for classifying a large, heterogeneous collection of web content to support classification of search results while in this dissertation I use SVM to predict the visit length depending on the user id and timestamp.\n\n(Manavoglu et al., 2003) presented a mixture model based approach for learning individualized\nbehavior models for the web users. To overcome the insufficient data problem they used global model first to capture patterns of general behavior of the users, and once it learned, it was personalized by optimizing the weights of each component for each known user individually. They used Markov Model and Maximum Entropy Model. In this dissertation, according to the type of data provided, working on the user-level gives better result.\n\nWhile I use Association Rules as an exploratory tool to discover any significant information helps in choosing the best classifier, (Shyu et al., 2005) applied Association rule mining technique to approximate and construct the predictive model. They used the shortest path algorithm in graph theory to prune the results from the association rule mining to reduce the state-space complexity of the model.\n\n(Khalil et al., 2006) proposed a combination of Markov model and association rules for predicting Web page accesses. The integration is based on a low order Markov model to predict multiple pages to be visited by a user. To resolve ambiguous predictions, sets of subsequence association rules are used to complement the Markov model by using long history data. The integration avoids the complexity of high order Markov model and the limitation of Markov model using short history. This model also reduces the large number of association rules since association rules are only used when ambiguous predictions occur.\n\nThe same author presented another integrating of Markov Model with Clustering to predict web page accesses. The Web pages in the user sessions are first allocated into categories according to Web services that are functionally meaningful. Then, k-means clustering algorithm is implemented using the most appropriate number of clusters and distance measure. Prediction techniques are applied using each cluster as well as using the whole data set (Khalil et al., 2007). In this dissertation I examine a new classifier DTNB, which is introduced by Frank Hall1 (2008) as a hybrid classifier combining Naive Bayes and Decision Tables techniques.\n\nOn the other hand, (Gunduz and Ozsu, 2003) proposed a model that considers both the order information of pages in a session and the time spent on them. They clustered user sessions based on their similarity and represented the resulting clusters by a click-stream tree. The new user sessions is then assigned to a cluster based on a similarity measure. The click-stream tree of that cluster is used to generate the recommendation set. In this dissertation I used visit type, long or short, to help in predicting the most desired categories for each user.\nChapter 3\n\nData Analysis and Reprocessing\n\nIn this chapter, the exploratory data analysis and data pre-processing, have been applied on the data.\n\n3.1 Exploratory Data Analysis\n\nThe collected data is belonging to 4882 different users and 20 different web page categories. One of the notes about the data is that it has non-uniform data distribution. While some users have only few sessions others have multi sessions. For train data the maximum records for a user is 497 while the minimum is 7 and the average is 77.7 records. While in the test data the maximum records is 215 and the minimum is 1 and the average is 34.06.\n\nFigure 3.1: Number of records per user\n\nFigure 3.1 shows the number of records per user in both training and testing sets while Figure 3.2 shows the distribution of the two classes in the train data. The blue color represents the short class frequency while the red color represents the long class frequency.\n\nThe timestamp attribute is transferred to a readable date/time format. The histograms in Figure 3.3 and Figure 3.4 show the distribution of the sessions of the train and test data on the days of the week and during the hours of the day. The left side of the figures shows the hourly visits\nFigure 3.2: Class distribution for train dataset. The x-axis represents user id while the y-axis represents the frequency.\n\nFigure 3.3: Sessions distribution in train data on days of week and during hours of day. The x-axis represents the day and hour attributes while the y-axis represents its frequency. Each hour is distinguished by a different color.\n\nfrequency where each hour is distinguished by a different color. On the other hand, the right side of the figure shows the days of the week visits frequency where the different colors in each column represent the hourly frequency visits in that day.\n\nFor the training data, more than 33% of the visits were on the weekend days (Sun, Sat) while\nFigure 3.4: Sessions distribution in test data on days of week and during hours of day. The x-axis represents the day and hour attributes while the y-axis represents its frequency. Each hour is distinguished by a different color.\n\nFigure 3.5: Histogram of user table attributes. The x-axis in each histogram represents the corresponding attribute while the y-axis shows its frequency over the train data.\nthe distribution was almost similar for other week days. Most visits were on the night hours while the minimum visits were between 7:00 to 8:00 morning and it starts rising gradually during the day. This is somehow expectable since it is the time people start their work hours.\n\nHowever on the test data (Figure 3.4), the maximum activity was on the middle days of the week while the hourly activity is similar to the training set.\n\n\n\nFigure 3.5 visualizes the user table attributes. More than 97% of the users are belonging to “Country Id = 42” while the region Id and city Id vary from user to user. Similarly more than 99% of the users are belonging to “system Id = 1”. 46% of the users use “Browser Id = 1” while 40% use “Browser Id = 21”. These results help out in deciding which attributes to select as input attributes for the selected classifiers since some of it like ‘country Id’ and ‘system Id’ do not distinguish the users effectively and doesn’t give any extra information about the user characteristics.\n\nThe histograms in Figure 3.6 show the distribution of the two classes in the train data. The blue column in the right-bottom histogram represents the short class frequency (276,709 records, 72.917%) while the red column represents the long class frequency (102,776 records, 27.28%). The other histograms show the distribution of the two classes for each attribute (user, day, hour, countryId, regionId, cityId, systemId, systemSubId, browserId, browserVerId).\n\nThe x-axis of the histograms represents each of the mentions above attributes respectively and the y-axis is the frequency of each one. Each attribute is represented by two colors (blue, red) which demonstrates the classes’ distribution for each. The figure shows evidently that the\nclasses’ distribution over each of the attributes is proportional with the classes’ distribution on the sessions itself.\n\nThe histogram in Figure 3.7 shows the distribution of the 20 categories on the first three visited positions (cat1, cat2, cat3) in the train data. The x-axis represents the attributes (cat1, cat2, cat3) respectively and y-axis represents the frequency of each one.\n\nThe first visited category is shown in the left histogram where each category Id is represented by a different color. The middle and right histogram illustrate the distribution of the 20 categories on the second and third visited positions and in the same time the colors in each column illustrate the relation between the occurrence of the first visited category (cat1) on the second and third visited categories (cat2 and cat3).\n\nHere is some information that can be extracted from Figure 3.7:\n\n- The first column in the middle and right histogram represent (category Id = 0), which refers to no category visited (i.e. short visit). Most users have a short visit path. The users in 72.92% of the sessions visit only one category while in 27.08% of the sessions have long visits i.e. visit more than one category in a single session.\n\n- During a single visit path, 15.56% of the sessions have two visited categories while only 9.25% of the visits paths have more than 3 visited categories.\n\n- The distribution of the first three categories is homogeneous on the global level. We\nnote that globally users tend to visit specific categories and usually they re-visit same categories in the next sessions.\n\n- The 1st and 3rd visited categories in the long sessions mostly tend to be the same.\n- Category 17 was the most popular category in general. Around 44% of the total sessions started by visiting Category17. It was also the second and third visited category for nearly 32% of the total sessions. Category 7 was the second popular category where around 28% of the total sessions visited this category in the first three categories.\n- The first column (category Id = 0) in the 2nd and 3rd position shows that mostly if category 17, category 7 and category 12 are visited in the 1st position, the user will not visit any more categories.\n\n3.2 Data Reprocessing\n\nDepending on the previous data analysis and visualization I have taken some decisions:\n\n1. Since only 9% of the users visit more than 3 categories in each session, I keep only the first three categories in each visit path and remove the remaining of the visit path. One of the reasons to take this decision is the large size of the train data and the limitations WEKA have in memory heap size, beside that the tasks focus on the first 3 categories.\n\n2. Both WEKA and MATLAB read only the data files that have equal columns sizes. So the empty cells of the short visits have to be filled with “0” to indicate the absence of second and third category for task 2 and task 3.\n\n3. While the timestamp has been transformed to the complete readable time/date; (day, second, minute, hour), only day and hour are selected as input attributes since (minute and second) attributes are implied already in (hour) attribute.\n\n3.2.1 Attributes Selection\n\nAccording to the data exploratory results, the input data attributes have been chosen to be as the following forms:\n\n1. Using only the \\{userId\\} attribute as the input for all tasks.\n2. Using the fields \\{hour and day\\} from the timestamp attribute with \\{userId\\} as data inputs for all tasks.\n3. Using the field \\{browserId\\} with the previous attributes \\{userId, hour, day, and browserId\\} for all tasks.\n4. Using the field \\{browserId\\} with \\{userId\\} as data inputs for all tasks.\n\n5. Using all users’ details field beside the userId and timestamp fields.\n\n6. Adding \\{Cat1\\} attribute for the different attributes combination mentioned above for the first task.\n\n7. Adding \\{Class\\} attribute for the different attributes combination mentioned above for the second and third task.\n\nAll attributes have numeric and finite sets of possible values, it has to be discretized or converted to nominal values. Three different filters are used to convert these attributes:\n\n1. **Discretize Filter**: an instance filter that discretizes a range numeric attributes in the dataset into nominal attributes. In this dissertation number of bins=10 for all attributes.\n\n2. **PKIDiscretize Filter**: (Proportional k-interval discretization) tunes discretization bias and variance by adjusting discretized interval size and number proportional to the number of training instances.\n\n3. **NumericToNominal Filter**: a filter for turning numeric attributes into nominal ones. Unlike discretization, it just takes all numeric values and adds them to the list of nominal values of that attribute.\n\n**Note**: for the three filters (Discretize, PKI Discretize and NumericToNominal) in WEKA, if the training set and test set are filtered separately, a problem of incompatibility between the training set and the supplied test set appears. To overcome this incompatibility problem, both training and testing data are joined in one file and I apply the specific filter on that file, and then split it again for exactly the same original ratio and instances.\n\n### 3.2.2 Test Options\n\nThe trained classifiers are tested using different methods, such as using training data itself, Hold-out (percentage split of the training data), cross validation with 10 folds and finally using the testing data supplied by the organizers.\n\n1. **Training Set**: The classifier is evaluated on how well it predicts the class of the instances it was trained on. This usually gives very optimistic results.\n\n2. **Cross Validation**: In this method, the training set is partitioned into K subsamples where a single subsample of it is retained as the validation data for testing the model, and the remaining \\( K - 1 \\) sub-samples are used as training data. The cross-validation process is then repeated K times (the folds), with each of the K subsamples used exactly once as the validation data. The K results from the folds then can be averaged to produce a single\nestimation. The advantage of this method over repeated random sub-sampling is that all observations are used for both training and validation, and each observation is used for validation exactly once. In this dissertation 10-fold cross-validation is used.\n\n3. **Hold-out ‘Percentage split’**: The classifiers are evaluated on how well it predicts a certain percentage of the data which is held out for testing. The ratio of data held out is similar to the ratio between the training data and supplied test data. The total train Data is 379,485 Records, while the supplied test data is 166,299 records which is around one third of the training set. Training data had been divided to 69.53% (263,555 Records) as train data and 30.47% (115,629 Records) for test data.\n\n4. **Supplied Test data**: The classifier is evaluated on how well it predicts the class of a set of instances loaded from a file. The supplied test data is 166,299 records. All the users represented in the training set are as well represented in the testing set.\nChapter 4\n\nAnalysis\n\nThis chapter describes the analysis for each task. First, the initial analysis for each task and the criteria taken to solve it are presented. Then the result of each task is explored and compared with the contest results.\n\nThe three tasks of the contest are classification problems. In each task the unknown value of an attribute \\( y \\) has to be predicted using values of other attributes. These experiments had been done using WEKA3.6 on Intel Centrino T5900 2.2GHz processor and 4GB RAM.\n\n4.1 Task1\n\n4.1.1 Analysis of Task1\n\nThe first task is determining length of the visit whether it is long or short visit according to the definition:\n\n\\[\nLength = \\begin{cases} \n\\text{short} & \\iff m = 1 \\\\\n\\text{long} & \\iff m > 1 \n\\end{cases}\n\\]\n\nwhere: \\( m \\) stands for number of different Categories in one Visit.\n\nIn order to choose the best classifier, Association Rule has been applied on the training data to construct any useful information could help in the decision. Using association rule in WEKA gives these two rules:\n\n\\[\n\\begin{align*}\n\\text{Day} = \\text{Sun} & \\quad 67492 \\Rightarrow \\text{Class} = -1 \\quad 49361 \\quad \\text{conf} : (0.73) \\\\\n\\text{Day} = \\text{Sat} & \\quad 56541 \\Rightarrow \\text{Class} = -1 \\quad 41019 \\quad \\text{conf} : (0.73)\n\\end{align*}\n\\]\n\nThis means there is a 73% confidence that the visits on Sunday and Saturday are long visits, which agrees with the results from the previous analysis and visualization. Applying association rule after including the table users’ details did not give any significant information.\nTo solve this task I tried two ways to deal with dataset attributes. The first one is converting the numeric values to nominal values and explore the effect on the classification process using three different filters which are: Discretize PKIDiscretize, and NumericToNominal Filters. The second one is keeping the attributes as numeric values. Different classification methods are used for this task: Naive Bayes, SVM, Decision Tree C4.5 (JR48 in WEKA), Decision Table, and DTNB.\n\n4.1.2 Using Nominal Attributes\n\n1. Using “Discretize” Filter:\nThe first attempt is discretizing the data using “Discretize” filter. First data is discretized by equal binning where it has been divided to 10 intervals and then by equal frequency. The results are the same for both. Table 4.1 shows the accuracy of each classifier and the time taken of building the model for the four test options using {userId, day and hour} as input attributes for equal binning discretizing. The accuracy shown in this table is exactly the same when we use only {userId} as input attribute.\n\n<table>\n<thead>\n<tr>\n<th>Test Options</th>\n<th>Naive Bayes</th>\n<th></th>\n<th></th>\n<th>SVM</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>accuracy</td>\n<td>time</td>\n<td>accuracy</td>\n<td>time</td>\n<td>accuracy</td>\n</tr>\n<tr>\n<td>Training Data</td>\n<td>72.917%</td>\n<td>0.37 sec</td>\n<td>72.917%</td>\n<td>3.48 sec</td>\n<td>72.917%</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>72.914%</td>\n<td>0.36 sec</td>\n<td>72.914%</td>\n<td>3.48 sec</td>\n<td>72.914%</td>\n</tr>\n<tr>\n<td>Cross-Validation</td>\n<td>72.917%</td>\n<td>0.62 sec</td>\n<td>72.917%</td>\n<td>2.12 sec</td>\n<td>72.917%</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>73.313%</td>\n<td>0.53 sec</td>\n<td>73.313%</td>\n<td>3.99 sec</td>\n<td>73.313%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.1: Task1: Classification results using {userId, day, hour} after discretizing the data.\n\nThe results show that for the discretized data it gives always the majority vote for the three used classifiers. By looking at the confusion matrices we note that all visits is completely classified as short visits which results 100% correctly predicted values for (Class = short) while all classifiers fail to predict any of the long visits class.\n\n2. Using “PKIDiscretize” Filter:\nAt the beginning the default setting of the filter “Discretize” is used to discretize data to ranges of 10 bins. Later I note that as the bins number increases, the accuracy is getting better. But this will result a problem of memory capability in WEKA. This means that discretizing the data makes the input userId lose its individual characteristics. As a second attempt “PKIDiscretize” filter, which discretizes attributes using equal frequency binning, is used.\n\n<table>\n<thead>\n<tr>\n<th>Test Option</th>\n<th>Naive Bayes accuracy</th>\n<th>time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Training Data</td>\n<td>72.960%</td>\n<td>0.51 sec</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>72.862%</td>\n<td>0.55 sec</td>\n</tr>\n<tr>\n<td>Cross-Validation</td>\n<td>72.918%</td>\n<td>1.37 sec</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>73.342%</td>\n<td>0.42 sec</td>\n</tr>\n</tbody>\n</table>\n\nConfusion matrix\n\n<table>\n<thead>\n<tr>\n<th>attribute {'userId'}</th>\n<th>a</th>\n<th>b</th>\n<th>Classified as</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>121,446</td>\n<td>474</td>\n<td>a = '(-inf-0)' short</td>\n</tr>\n<tr>\n<td></td>\n<td>43,858</td>\n<td>522</td>\n<td>b = '(0-inf)' long</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.3: Task1: Results of PKIDiscretize filter/NB Classifier using {'userId'}.\n\nTable 4.3 and Table 4.4 illustrate the result of using Naive Bayes Classifier using {'userId'} and {'userId, day, hour'} attributes respectively, and show the confusion matrix in each case when “PKIDiscretize” filter is used on the data.\n\n<table>\n<thead>\n<tr>\n<th>Test Option</th>\n<th>Naive Bayes accuracy</th>\n<th>time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Training Data</td>\n<td>72.971%</td>\n<td>0.33 sec</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>72.885%</td>\n<td>0.38 sec</td>\n</tr>\n<tr>\n<td>Cross-Validation</td>\n<td>72.935%</td>\n<td>4.06 sec</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>73.363%</td>\n<td>0.61 sec</td>\n</tr>\n</tbody>\n</table>\n\nConfusion matrix\n\n<table>\n<thead>\n<tr>\n<th>attribute {'userId, day, hour'}</th>\n<th>a</th>\n<th>b</th>\n<th>Classified as</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>121,386</td>\n<td>534</td>\n<td>a = '(-inf-0)' short</td>\n</tr>\n<tr>\n<td></td>\n<td>43,763</td>\n<td>617</td>\n<td>b = '(0-inf)' long</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.4: Task1: Results of PKIDiscretize filter/NB Classifier using {'userId, day, hour'}.\n\nThere is a very slight increase in the accuracy and in the elapsed time taken to build the model. However, looking at the confusion matrix shows that the prediction of the minor class (long) has been improved from 0% by using \"discretize\" filter to 1.4% and the major class (short) accuracy has been decreased to 99.6%. The area under the ROC, where (Class=short) is the positive one, is improved to be 0.609 as shown in Figure 4.2.\n\nHowever, applying J48 classifier on the data after filtering it by “PKIDiscretize” filter gives exactly the same result we got by using “Discretize” filter without any change or improvement at all.\n<table>\n<thead>\n<tr>\n<th>TP Rate</th>\n<th>FP Rate</th>\n<th>Precision</th>\n<th>Recall</th>\n<th>F-Measure</th>\n<th>ROC Area</th>\n<th>Class</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0.996</td>\n<td>0.986</td>\n<td>0.735</td>\n<td>0.996</td>\n<td>0.846</td>\n<td>0.609</td>\n<td>‘(-inf-0)’</td>\n</tr>\n<tr>\n<td>0.014</td>\n<td>0.004</td>\n<td>0.536</td>\n<td>0.014</td>\n<td>0.027</td>\n<td>0.609</td>\n<td>‘(0-inf)’</td>\n</tr>\n<tr>\n<td>Avg.</td>\n<td>0.734</td>\n<td>0.724</td>\n<td>0.682</td>\n<td>0.734</td>\n<td>0.627</td>\n<td>0.609</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.5: Task1: Detailed Accuracy by class for PKIDiscretize Filter/NB Classifier\n\nFigure 4.2: Task1: ROC Curve for NB Classifier using “PKIDiscretize” filter.\n\n3. Using “NumericToNominal” Filter:\n\nThe slight improve of PKIDiscretize/Naive Bayes Classifier encourages me to try to keep the user’s granule by converting the numeric representation of the user identity to nominal values. By using “NumericToNominal” filter there are 4882 distinct users instead of aggregating a range of users into a single value according to number of bins. Table 4.6 shows the results of Naive Bayes classifier using “NumericToNominal” filter.\n\n<table>\n<thead>\n<tr>\n<th>Test Options</th>\n<th>Naive Bayes {userId}</th>\n<th>Naive Bayes {userId, day, hour}</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>accuracy</td>\n<td>time</td>\n</tr>\n<tr>\n<td>Training Data</td>\n<td>77.4489%</td>\n<td>0.39 sec</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>76.9219%</td>\n<td>0.41 sec</td>\n</tr>\n<tr>\n<td>Cross-validation</td>\n<td>77.0304%</td>\n<td>0.37 sec</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>76.6681%</td>\n<td>0.42 sec</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.6: Task1: Naive Bayes Classifier using ‘NumericToNominal’ filter\n\nThere is a good improvement of the classifier and prediction accuracy with a very slight increase of the time taken to build the models. The best result for the test set is 76.668% by considering {userId} attribute only. Including the attributes {day and hour} decrease the accuracy very slightly including a little increase of the time of model building.\n\n<table>\n<thead>\n<tr>\n<th>TP Rate</th>\n<th>FP Rate</th>\n<th>Precision</th>\n<th>Recall</th>\n<th>F-Measure</th>\n<th>ROC Area</th>\n<th>Class</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0.937</td>\n<td>0.701</td>\n<td>0.786</td>\n<td>0.937</td>\n<td>0.855</td>\n<td>0.746</td>\n<td>‘(-inf-0)’</td>\n</tr>\n<tr>\n<td>0.299</td>\n<td>0.063</td>\n<td>0.633</td>\n<td>0.299</td>\n<td>0.406</td>\n<td>0.746</td>\n<td>‘(0-inf)’</td>\n</tr>\n<tr>\n<td>Avg.</td>\n<td>0.767</td>\n<td>0.531</td>\n<td>0.745</td>\n<td>0.767</td>\n<td>0.735</td>\n<td>0.746</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.7: Task1: Detailed Accuracy by class for NumericToNominal filter/NB Classifier\n\nTable 4.7 gives more details about the classification performance. These results are the same for {userId} and {userId, day, hour} attributes. The prediction rate of the minor class ‘long\nvisits’ increases to 29.9%, however the prediction rate of the major class ‘short visits’ decreases to 93.7%. The area under ROC for the short class increases noticeably to 0.7461 as shown in Figure 4.3.\n\n\n\n<table>\n<thead>\n<tr>\n<th>Confusion Matrix using attribute {userId}</th>\n<th>Confusion matrix using attribute {userId, day, hour}</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>a = '(-inf-0)' short</td>\n<td>a = '(-inf-0)' short</td>\n</tr>\n<tr>\n<td>b = '(0-inf)' long</td>\n<td>b = '(0-inf)' long</td>\n</tr>\n<tr>\n<td>114,249</td>\n<td>7671</td>\n</tr>\n<tr>\n<td>31,130</td>\n<td>13250</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.8: Task1: Confusion Matrix for NumericToNominal/NB Classifier\n\nThe confusion matrices in Table 4.8 show the very slight difference results between using {userId} and {userId, day, hour} attributes. There is unnoticeable decrease in the short visit prediction and unremarkable increase in the long visit prediction. However, this implies the existence of time effect on user browsing behavior.\n\n<table>\n<thead>\n<tr>\n<th>Test Options</th>\n<th>Naive Bayes {userId, browserId}</th>\n<th>Naive Bayes {userId, day, hour, browserId}</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Training Data</td>\n<td>77.4207%</td>\n<td>0.55 sec</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>76.9037%</td>\n<td>0.5 sec</td>\n</tr>\n<tr>\n<td>Cross-validation</td>\n<td>76.9693%</td>\n<td>0.3 sec</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>76.6072%</td>\n<td>0.61 sec</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.9: Task1: Including {browserId} as input attribute for NB Classifier\n\nIncluding attribute {browserId}, with and without the timestamp, as inputs for Naive Bayes classifier decreases the accuracy a little as shown in Table 4.9, however the confusion matrices in Table 4.10 present improvement in the minor class prediction to 30.7% and the short class prediction decreases to 93.4%.\n\nThe final option is using all attributes including timestamp and users’ details fields which include 10 attributes: {userId, day, hour, countryId, regionId, cityId, systemId, systemSubId, browserId, browserVerId}. The result follows the previous trend; the overall accuracy decreases to (76.067%) while the minor class prediction accuracy rises to (33.1%) which is the best for that class in all models. The short class prediction accuracy falls to 91.7%.\nClassifiers J48 and SVM could not be applied on the data after using NumericToNominal filter because of WEKA memory heap size issues. Instead Decision Table and DTNB classifier are applied on the data. Both classifiers give always the same result regardless of the input attributes combined to {userId}. While Decision Table classifier gives accuracy of 76.6458%, DTNB classifier gives 76.6681% which is exactly the same as Naive Bayes classifier. However DTNB consumes more time than NB classifier.\n\nA very interesting result is shown when I include the first visited category as additional attribute. While it decreases the prediction of Naive Bayes and DTNB classifiers, it highly improves the Decision Table performance. It gives the best result so far which is 77.8904%.\n\nTable 4.11 summarizes the results of Naive Bayes classifier in all input cases by testing it on the supplied test set.\n\n<table>\n<thead>\n<tr>\n<th>Input Attributes</th>\n<th>accuracy</th>\n<th>Input Attributes</th>\n<th>accuracy</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{userId}</td>\n<td>76.6681%</td>\n<td>{userId,Cat1}</td>\n<td>76.4755%</td>\n</tr>\n<tr>\n<td>{userId,BrowserId}</td>\n<td>76.6072%</td>\n<td>{userId, browserId, Cat1}</td>\n<td>76.508%</td>\n</tr>\n<tr>\n<td>{userId, day, hour}</td>\n<td>76.6428%</td>\n<td>{userId, day, hour,Cat1}</td>\n<td>76.4953%</td>\n</tr>\n<tr>\n<td>{userId, day, hour, browserId}</td>\n<td>76.6282%</td>\n<td>{userId, day, hour, browserId, Cat1}</td>\n<td>76.5314%</td>\n</tr>\n<tr>\n<td>{All attributes}</td>\n<td>76.067%</td>\n<td>{All attributes, Cat1}</td>\n<td>76.1953%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.11: Task1: Summary of NB classifier with different inputs\n\n4.1.3 Using Numeric Attributes\n\nIn this experiment, the input attributes remains in its numeric states, however the class attribute has converted to Nominal since most classifiers in WEKA requires nominal class.\n\nApplying Naive Bayes on these attributes gives the majority vote (73.31%) which is the short class prediction. Even using a kernel estimator for numeric attributes rather than a normal distribution did not improve the results at all.\n\nHowever it becomes possible to apply J48 Classifier on the numeric dataset without memory heap size problem. C4.5 (J48 in Weka) has two parameters to tune: the first is the Confidence value where tree pruning is determined (tree pruning is removing branches that are deemed to provide little or no gain in statistical accuracy of the model). Decreasing the confidence factor will cause more drastic pruning, and a more general model of the data while increasing the confidence factor will decrease the amount of pruning that occurs and provide a more specific modeling based on the training data.\nThe second parameter determines the minimum number of instances that must be present in the training data for a new leaf to be created in the decision tree to handle those particular instances. This too can create a more generalized or specialized tree; a higher number will create a more generalized tree and a lower number will create a more specialized tree. However changing that parameter has no affect on classifying our data.\n\nTable 4.12 shows different values of the confidence factor and its effects on the classification accuracy.\n\n<table>\n<thead>\n<tr>\n<th>Attributes/ Confidence Factor</th>\n<th>0.15</th>\n<th>0.25</th>\n<th>0.35</th>\n<th>0.45</th>\n<th>0.55</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>userId</td>\n<td>76.378%</td>\n<td>76.481%</td>\n<td>76.556%</td>\n<td>76.534%</td>\n<td>76.471%</td>\n</tr>\n<tr>\n<td>userId, browserId</td>\n<td>76.637%</td>\n<td>76.653%</td>\n<td>76.6685%</td>\n<td>76.6884%</td>\n<td>76.6288%</td>\n</tr>\n<tr>\n<td>userId, day, hour</td>\n<td>76.115%</td>\n<td>76.119%</td>\n<td>76.0299%</td>\n<td>76.1114%</td>\n<td>75.6691%</td>\n</tr>\n<tr>\n<td>userId, day, hour, browserId</td>\n<td>76.393%</td>\n<td>76.233%</td>\n<td>76.0997%</td>\n<td>75.882%</td>\n<td>75.609%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.12: Task1: J48 classifier with different pruning\n\n\n\nThe best result is 76.7082% using attributes \\{userId, browserId\\} only with confidence factor equal to 0.43 (not shown in the table). The empirical experiments show that the classifier accuracy decreases gradually above and under this value. Figure 4.4 views a small section of the induced tree with pruning 0.43 while Figure 4.5 represents a small part of Weka output for this tree. Nodes that generate a classification are followed by a number (sometimes two) in parentheses. The first number tells how many instances are correctly classified by this node. The second number, if it exists (if not, it is taken to be 0.0), represents the number of instances incorrectly classified by the node.\n\nThe result in table 4.12 shows the instability of decision tree classifier. Any slight variations in the training data and the attribute selections or the confidence factor produce a significant\ndifference since attribute choices affect all descendant subtrees. Trees created from numeric data sets can be quite complex since attribute splits for numeric data are binary as shown in Figure 4.4.\n\nAdding \\{Cat1\\} attribute improves the performance of J48 classifier for all combinations. Again tuning the confidence factor changes the result in each group. The best result in this case is 77.5471% by using \\{userId, browserId, Cat1\\} attributes with confidence factor equal 0.35.\n\n\n\n<table>\n<thead>\n<tr>\n<th>Attributes/ Confidence Factor</th>\n<th>0.15</th>\n<th>0.25</th>\n<th>0.35</th>\n<th>0.45</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>userId, Cat1</td>\n<td>77.1478%</td>\n<td>77.3005%</td>\n<td>77.3138%</td>\n<td>77.2795%</td>\n</tr>\n<tr>\n<td>userId, browserId, Cat1</td>\n<td>77.5332%</td>\n<td>77.4833%</td>\n<td>77.5471%</td>\n<td>77.4978%</td>\n</tr>\n<tr>\n<td>userId, day, hour, Cat1</td>\n<td>76.8838%</td>\n<td>76.8994%</td>\n<td>76.8856%</td>\n<td>76.8014%</td>\n</tr>\n<tr>\n<td>userId, day, hour, browserId, Cat1</td>\n<td>77.1159%</td>\n<td>77.1039%</td>\n<td>77.0059%</td>\n<td>76.9367%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.13: Task1: J48 classifier with different pruning including the first category\n\n### 4.1.4 Task1 Summary\n\nThe results of task 1 can be summarized as follows:\n1. Using the ‘Discretize’ filter gives us always the same result which is the majority vote regardless of the used classifier or the test method. It failed to predict any of the minority class (long visits).\n\n2. While using ‘PKIDiscretize’ improves the performance of Naive Bayes classifier very slightly, it did not affect at all the act of J48 classifier. Moreover it increases the time taken to build the models.\n\n3. The time taken to build the models increases as we add more input attributes.\n\n4. Using ‘Discretize’ filter affects the classifiers accuracy since it joints several users in one interval causing the loss of user identity. And since we have only the user id as classifier input, discretizing it leads to very poor classifier.\n\n5. Using the ‘NumericToNominal’ filter helps to keep the individuality of the input userId which improves the accuracy in all classifiers with the different validation methods.\n\n6. Using Naive Bayes with ‘NumericToNominal’ filter and validating it on the supplied test set gives us accuracy of 76.668% which is the same result obtained by DTNB classifier. By looking at the confusion matrix, 93.7% of the short visits predicted correctly while the long visits correct prediction is around 29.9% only.\n\n7. Even though using more input attributes did not give significant difference in the overall accuracy, it improves the prediction accuracy of the minor class (longclass). The best prediction for that class is (33.1%) by using all attributes (userId, timestamp and users’ details) and (35.3%) by including {Cat1} attribute.\n\n8. Using Naive Bayes classifier with numeric attributes gives only the majority vote while J48 classifier gives better classification (76.7082%) with threshold value equals to 0.43 using {userId, browserId} attributes.\n\n9. Adding the first visited Category for the input attributes helps in predicting user behavior. It gives the best performance 77.8904% using Decision Table Classifier.\n\n10. While changing the specific threshold causes accuracy decreasing, the different iterations shows that increasing the confidence value of J48 tree increase the prediction accuracy of the minor class.\n\n11. Even when the accuracy is similar in all classifiers, the time of building the model varies. Naive Bayes is the fastest classifier while SVM is spending much longer time to achieve the same results.\n\n12. WEKA has a limitation in the used heap size. We increase it to the maximum size allowed for 32-bit operating system which is 1500MB. However we still face the same problem ‘Out of Memory’ when we run some classifiers such as SVM and J48 with Nominal values.\n4.1.5 Task1 Evaluation\n\nTable 4.14 shows the results of task1 comparing with the results of the winner and the runner-up of ECML_PKDD 2007 Discovery Challenge.\n\nThe best result I obtain is by using J48 classifier on numeric values using \\{userId, browserId\\} attributes (76.7082%) with confidence factor equal to (0.43). Naive Bayes classifier on WEKA platform gives accuracy (76.67%) using \\{userId\\} attribute only after converting the datasets to nominal attributes.\n\nWhile the winner results surpass my approach slightly (0.19%) by using attribute input userId my result is outperform slightly the runner-up result (better than it with nearly 0.07%). The winner got his result using (User Model- Trend Prediction) in the first case while they use WEKA-J48 classifier on (Enhanced Global Model) using many attributes in the second case.\n\nThe runner-up obtain their results using Naive Bayes classifier using their own Java code. However both of the winner and runner-up did not give any information about the distribution of their accuracy, i.e. the prediction performance of the major and minor classes, since the nature of the data is biased toward the short class. On the other hand, all the results agree that including other features such as timestamp or user’s details reduce the overall classification accuracy but I also show that using timestamp and user’s details, specially browserId, improve the minor class prediction.\n\nI also prove that knowing the first category of the visit affects on predicting the visit length. Except Naive Bayes classifier, adding the first visited category improves the performance of all other classifiers. The best result was 77.8904% using Decision Table classifier. This is important point since it provides website managers more accurate method of predicting user behavior with reasonable assumptions (the category of the first visited page is known prior to predicting whether the user will pursue to other categories or will end his/her session).\n\n<table>\n<thead>\n<tr>\n<th>Attributes</th>\n<th>Contest Winner</th>\n<th>Contest Runner-up</th>\n<th>My result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>userId</td>\n<td>76.90%</td>\n<td>76.64%</td>\n<td>76.67%</td>\n</tr>\n<tr>\n<td>userId, timestamp</td>\n<td>76.7%</td>\n<td>76.6%</td>\n<td>76.64%</td>\n</tr>\n<tr>\n<td>userId, browserId</td>\n<td></td>\n<td></td>\n<td>76.7082%</td>\n</tr>\n<tr>\n<td>userId, Cat1</td>\n<td></td>\n<td></td>\n<td>77.8904%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.14: Task1 Evaluation\n\n4.2 Task 2\n\n4.2.1 Analysis of Task2\n\nThe second task goal is predicting the most three probable categories for a given user. Input data basically will be userId and timestamp of the first Page View. The result should be three identifiers of the most probable categories during a given visit for a given user that appear in\nthe first three places of the visit path according to the following formula:\n\n\\[\n\\text{CategoryId}_{\\text{predicted}} = \\left( \\begin{array}{c}\n\\text{CategoryId}_{\\text{predicted1}} \\\\\n\\text{CategoryId}_{\\text{predicted2}} \\\\\n\\text{CategoryId}_{\\text{predicted3}}\n\\end{array} \\right)\n\\]\n\nAssociation Rule has been applied on the training data using only the first three categories visited by the user. Using only userId as input, we get these three rules:\n\n- \\( \\text{Cat2} = 0 \\ 121919 \\Rightarrow \\text{Cat3} = 0 \\ 121919 \\) \\( \\text{conf} : (1) \\)\n- \\( \\text{Cat1} = 17 \\ \\text{Cat2} = 0 \\ 58130 \\Rightarrow \\text{Cat3} = 0 \\ 58130 \\) \\( \\text{conf} : (1) \\)\n- \\( \\text{Cat1} = 7 \\ \\text{Cat2} = 0 \\ 34824 \\Rightarrow \\text{Cat3} = 0 \\ 34824 \\) \\( \\text{conf} : (1) \\)\n\nThe extracted rules are straightforward. The first rule assures with 100% confidence that whenever there is no second category, then no third category, which is simply the case in the short visits. The second rule states that in around 22.5% of the cases where category17 was the first category to visit, the user will not visit any more pages after it. So it is short visits. As well, the third rule states that in around 13.5% of the cases where category7 is visited first by the user, it is a short visit and no more categories will be visited.\n\nFinally, applying association rule using inputs \\{userId, Day, Hour\\} gives these rules:\n\n- \\( \\text{Day} = 1 \\ \\text{Cat3} = 0 \\ 57004 \\Rightarrow \\text{Cat2} = 0 \\ 49361 \\) \\( \\text{conf} : (0.87) \\)\n- \\( \\text{Day} = 7 \\ \\text{Cat3} = 0 \\ 47437 \\Rightarrow \\text{Cat2} = 0 \\ 41019 \\) \\( \\text{conf} : (0.86) \\)\n- \\( \\text{Day} = 2 \\ 51609 \\Rightarrow \\text{Cat3} = 0 \\ 43815 \\) \\( \\text{conf} : (0.85) \\)\n- \\( \\text{Day} = 4 \\ 51676 \\Rightarrow \\text{Cat3} = 0 \\ 43812 \\) \\( \\text{conf} : (0.85) \\)\n- \\( \\text{Day} = 5 \\ 51428 \\Rightarrow \\text{Cat3} = 0 \\ 43480 \\) \\( \\text{conf} : (0.85) \\)\n- \\( \\text{Day} = 1 \\ 67492 \\Rightarrow \\text{Cat3} = 0 \\ 57004 \\) \\( \\text{conf} : (0.84) \\)\n- \\( \\text{Day} = 3 \\ 49751 \\Rightarrow \\text{Cat3} = 0 \\ 41983 \\) \\( \\text{conf} : (0.84) \\)\n- \\( \\text{Day} = 6 \\ 50988 \\Rightarrow \\text{Cat3} = 0 \\ 42886 \\) \\( \\text{conf} : (0.84) \\)\n- \\( \\text{Day} = 7 \\ 56541 \\Rightarrow \\text{Cat3} = 0 \\ 47437 \\) \\( \\text{conf} : (0.84) \\)\n\nThese rules present the same information from our histogram in chapter 3 about the relations between the days of week and categories. It is not satisfactory to extract any information to help in predicting the visited categories; especially that it does not give any information depending on the user itself, which did not help us in choosing the best classifier, however it suggests to try Day and Hour attributes as inputs for the selected classifiers.\n\n### 4.2.2 Using Nominal Attributes\n\n1. Using ”Discretize” Filter:\nThe data has been discretized using 'Discretize' filter. Both Naive Bayes and J48 classifiers are applied on the data.\n\na. Naive Bayes Classifier:\n\nThe first classifier is Naive Bayes Classifier. It has been applied on data initially using input attribute \\{\\text{userId}\\}. For the third category, 142,931 instances are correctly classified meaning that the accuracy rate is 85.9477%.\n\n<table>\n<thead>\n<tr>\n<th>Test Options</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Training Data</td>\n<td>43.779%</td>\n<td>74.886%</td>\n<td>85.7927%</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>43.755%</td>\n<td>74.812%</td>\n<td>85.7547%</td>\n</tr>\n<tr>\n<td>Cross-Validation</td>\n<td>43.779%</td>\n<td>74.886%</td>\n<td>85.7788%</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>44.729%</td>\n<td>75.082%</td>\n<td>85.9477%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.15: Task2: NB Classifier using \\{\\text{userId}\\} with 'Discretize' filter\n\nThe reason of this relatively high accuracy maybe because most of visits are short visits hence the 3rd category is mostly zeros. 90.6% of the short visits have been predicted correctly. However if the prediction rate of (category Id=0) is eliminated; only 15,203 correctly predicted instances remain meaning that the actual prediction accuracy for other categories in this position is around 60%. This percentage is distributed almost between all categories as shown in the confusion matrix in Table 4.16.\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<th>h</th>\n<th>i</th>\n<th>j</th>\n<th>Classified as</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>127728</td>\n<td>27</td>\n<td>1</td>\n<td>3718</td>\n<td>616</td>\n<td>0</td>\n<td>1728</td>\n<td>1061</td>\n<td>6046</td>\n<td>24</td>\n<td>a = '-\\text{inf}-1.9]'</td>\n</tr>\n<tr>\n<td>187</td>\n<td>16</td>\n<td>0</td>\n<td>57</td>\n<td>3</td>\n<td>0</td>\n<td>6</td>\n<td>3</td>\n<td>73</td>\n<td>0</td>\n<td>b = '(1.9-3.8]'</td>\n</tr>\n<tr>\n<td>112</td>\n<td>1</td>\n<td>1</td>\n<td>26</td>\n<td>6</td>\n<td>0</td>\n<td>7</td>\n<td>1</td>\n<td>31</td>\n<td>0</td>\n<td>c = '(3.8-5.7]'</td>\n</tr>\n<tr>\n<td>1720</td>\n<td>3</td>\n<td>0</td>\n<td>4097</td>\n<td>48</td>\n<td>0</td>\n<td>138</td>\n<td>39</td>\n<td>563</td>\n<td>6</td>\n<td>d = '(5.7-7.6]'</td>\n</tr>\n<tr>\n<td>860</td>\n<td>2</td>\n<td>0</td>\n<td>753</td>\n<td>492</td>\n<td>0</td>\n<td>85</td>\n<td>30</td>\n<td>299</td>\n<td>4</td>\n<td>e = '(7.6-9.5]'</td>\n</tr>\n<tr>\n<td>144</td>\n<td>0</td>\n<td>0</td>\n<td>34</td>\n<td>20</td>\n<td>0</td>\n<td>101</td>\n<td>3</td>\n<td>38</td>\n<td>0</td>\n<td>f = '(9.5-11.4]'</td>\n</tr>\n<tr>\n<td>382</td>\n<td>0</td>\n<td>0</td>\n<td>151</td>\n<td>22</td>\n<td>0</td>\n<td>1237</td>\n<td>90</td>\n<td>165</td>\n<td>0</td>\n<td>g = '(11.4-3.3]'</td>\n</tr>\n<tr>\n<td>134</td>\n<td>1</td>\n<td>0</td>\n<td>64</td>\n<td>15</td>\n<td>0</td>\n<td>32</td>\n<td>3309</td>\n<td>118</td>\n<td>0</td>\n<td>h = '(13.3-5.2]'</td>\n</tr>\n<tr>\n<td>2757</td>\n<td>5</td>\n<td>0</td>\n<td>474</td>\n<td>28</td>\n<td>0</td>\n<td>41</td>\n<td>146</td>\n<td>6033</td>\n<td>5</td>\n<td>i = '(15.2-17.1]'</td>\n</tr>\n<tr>\n<td>60</td>\n<td>0</td>\n<td>0</td>\n<td>17</td>\n<td>4</td>\n<td>0</td>\n<td>6</td>\n<td>1</td>\n<td>27</td>\n<td>18</td>\n<td>j = '(17.1-\\text{inf}]'</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.16: Task2: Confusion Matrix of 3rd category prediction using NB Classifier.\n\nAs expected the accuracy has been dropped to 75.082% when the 2nd category is predicted depending on \\{\\text{userId and Cat1}\\} as input. In this position, 98.6% of the short visits are predicted correct while only 9.66% of the long visits are correctly classified and they are all belong to Category 7. The classifier fails to predict any of the other categories in that position.\n\nOnly accuracy of 44.729% has been got in predicting the 1st category depending only on the userId as input. The category 17 has been predicted correctly with accuracy of 98% and category 7 prediction accuracy is 3.4% while the classifier fails to predict any of the other categories. This somehow supports the extracted rules from applying Association rule on the data. However it is expected results since categories 17 and 7 are the most popular visited categories.\nTable 4.17: Task2: NB Classifier using attributes \\{userId, day, hour\\} with ‘Discretize’ filter\n\n<table>\n<thead>\n<tr>\n<th>Test Options</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Training Data</td>\n<td>43.794%</td>\n<td>74.886%</td>\n<td>85.899%</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>43.767%</td>\n<td>74.812%</td>\n<td>85.7605%</td>\n</tr>\n<tr>\n<td>Cross-Validation</td>\n<td>43.781%</td>\n<td>74.886%</td>\n<td>85.8637%</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>44.708%</td>\n<td>75.082%</td>\n<td>86.0432%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.17 shows the result of the same classifier using \\{userId, day, hour\\}. We note a very slight increase for the three categories using all the test options except for the supplied test set which shows a tiny decrease in the accuracy for the first category.\n\nb. TreeJ48 Classifier:\n\nWhile using J48 classifier improves slightly the accuracy of Cat3 prediction to 86.745%, the confusion matrix shows that this increase is in predicting (category Id =0) and the prediction of the other categories in the 3rd position falls to only 29.23%. Cat2 accuracy remains the same as Naive Bayes and Cat1 accuracy decreases slightly to 44.511% but here only Category 17 has been predicted correctly instead of categories 7 and 17 in Naive Bayes Classifier.\n\nTable 4.18: Task2: J48 Classifier using attributes \\{userId\\} with ‘Discretize’ filter.\n\n<table>\n<thead>\n<tr>\n<th>Test Options</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Training Data</td>\n<td>43.7199%</td>\n<td>74.886%</td>\n<td>86.7214%</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>43.7477%</td>\n<td>74.812%</td>\n<td>86.6072%</td>\n</tr>\n<tr>\n<td>Cross-Validation</td>\n<td>43.7199%</td>\n<td>74.886%</td>\n<td>86.6835%</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>44.5105%</td>\n<td>75.082%</td>\n<td>86.745%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.18 shows the result of the same classifier using \\{userId\\} attributes with J48 classifier mostly make no difference with the results except the increase of time taken to build the models in general as shown in table 4.19.\n\nUsing \\{userId, day, hour\\} attributes with J48 classifier mostly make no difference with the results except the increase of time taken to build the models in general as shown in table 4.19.\n\nTable 4.19: Task2: J48 Classifier using attributes \\{userId, day, hou\\} with ‘Discretize’ filter.\n\n<table>\n<thead>\n<tr>\n<th>Test Options</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Training Data</td>\n<td>43.7199%</td>\n<td>74.886%</td>\n<td>86.9865%</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>43.7477%</td>\n<td>75.082%</td>\n<td>86.6167%</td>\n</tr>\n<tr>\n<td>Cross-Validation</td>\n<td>43.7117%</td>\n<td>74.886%</td>\n<td>86.6698%</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>44.5108%</td>\n<td>75.082%</td>\n<td>86.7565%</td>\n</tr>\n</tbody>\n</table>\n\nI couldn’t calculate the score function for these classifiers with this filter because I couldn’t get the output prediction exactly since the instants are divided into intervals not individually.\n\n2. Using ”NumericToNominal” Filter:\n\na. Naive Bayes Classifier:\n\nUsing filter ‘Numeric2Nominal’ instead of ‘Discretize’ filter improves the accuracy noticeably especially for the first category prediction as shown in Table 4.20. For the 3rd category prediction the accuracy is 86.96%. While the prediction of (category Id = 0) stay the same, the prediction accuracy of other categories in that position increase to 64.48%. Similarly the\n2nd category prediction accuracy increases to 75.88% where 21.3% only belongs to categories other than ‘0’ category but in this case the percentage is distributed over all the categories not only category 7 as when using ‘Discretize’ filter. The great improve is the remarkable increase of 1st category prediction. The accuracy increases from 44.7% to 74.18% and it is spread over all categories not only category 7 and 17 as in the previous case.\n\nSome detailed Accuracy by class is shown in Table 4.21.\n\n<table>\n<thead>\n<tr>\n<th>TP Rate</th>\n<th>FP Rate</th>\n<th>Precision</th>\n<th>Recall</th>\n<th>F-Measure</th>\n<th>ROC Area</th>\n<th>Class</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0.072</td>\n<td>0</td>\n<td>0.872</td>\n<td>0.072</td>\n<td>0.134</td>\n<td>0.843</td>\n<td>1</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.822</td>\n<td>2</td>\n</tr>\n<tr>\n<td>0.159</td>\n<td>0.001</td>\n<td>0.589</td>\n<td>0.159</td>\n<td>0.251</td>\n<td>0.883</td>\n<td>3</td>\n</tr>\n<tr>\n<td>0.348</td>\n<td>0</td>\n<td>0.896</td>\n<td>0.348</td>\n<td>0.501</td>\n<td>0.824</td>\n<td>4</td>\n</tr>\n<tr>\n<td>0.124</td>\n<td>0</td>\n<td>0.674</td>\n<td>0.124</td>\n<td>0.209</td>\n<td>0.852</td>\n<td>5</td>\n</tr>\n<tr>\n<td>0.558</td>\n<td>0.002</td>\n<td>0.797</td>\n<td>0.558</td>\n<td>0.656</td>\n<td>0.929</td>\n<td>6</td>\n</tr>\n<tr>\n<td>0.775</td>\n<td>0.1</td>\n<td>0.744</td>\n<td>0.775</td>\n<td>0.759</td>\n<td>0.923</td>\n<td>7</td>\n</tr>\n<tr>\n<td>0.411</td>\n<td>0.007</td>\n<td>0.695</td>\n<td>0.411</td>\n<td>0.516</td>\n<td>0.88</td>\n<td>8</td>\n</tr>\n<tr>\n<td>0.74</td>\n<td>0.006</td>\n<td>0.843</td>\n<td>0.74</td>\n<td>0.788</td>\n<td>0.959</td>\n<td>9</td>\n</tr>\n<tr>\n<td>0.145</td>\n<td>0</td>\n<td>0.771</td>\n<td>0.145</td>\n<td>0.244</td>\n<td>0.794</td>\n<td>10</td>\n</tr>\n<tr>\n<td>0.428</td>\n<td>0.001</td>\n<td>0.774</td>\n<td>0.428</td>\n<td>0.531</td>\n<td>0.905</td>\n<td>11</td>\n</tr>\n<tr>\n<td>0.778</td>\n<td>0.027</td>\n<td>0.699</td>\n<td>0.778</td>\n<td>0.736</td>\n<td>0.972</td>\n<td>12</td>\n</tr>\n<tr>\n<td>0.311</td>\n<td>0</td>\n<td>0.804</td>\n<td>0.311</td>\n<td>0.449</td>\n<td>0.929</td>\n<td>13</td>\n</tr>\n<tr>\n<td>0.666</td>\n<td>0.013</td>\n<td>0.646</td>\n<td>0.666</td>\n<td>0.656</td>\n<td>0.967</td>\n<td>14</td>\n</tr>\n<tr>\n<td>0.34</td>\n<td>0</td>\n<td>0.947</td>\n<td>0.34</td>\n<td>0.5</td>\n<td>0.82</td>\n<td>15</td>\n</tr>\n<tr>\n<td>0.302</td>\n<td>0.01</td>\n<td>0.563</td>\n<td>0.302</td>\n<td>0.393</td>\n<td>0.873</td>\n<td>16</td>\n</tr>\n<tr>\n<td>0.845</td>\n<td>0.218</td>\n<td>0.755</td>\n<td>0.845</td>\n<td>0.797</td>\n<td>0.897</td>\n<td>17</td>\n</tr>\n<tr>\n<td>0.383</td>\n<td>0</td>\n<td>0.921</td>\n<td>0.383</td>\n<td>0.541</td>\n<td>0.938</td>\n<td>18</td>\n</tr>\n<tr>\n<td>0.319</td>\n<td>0</td>\n<td>0.917</td>\n<td>0.319</td>\n<td>0.473</td>\n<td>0.887</td>\n<td>19</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>?</td>\n<td>20</td>\n</tr>\n<tr>\n<td>Avg.</td>\n<td>0.742</td>\n<td>0.127</td>\n<td>0.739</td>\n<td>0.742</td>\n<td>0.729</td>\n<td>0.912</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.21: Task2: Detailed Accuracy By Class for 1st category prediction\n\nUsing other attributes \\{userId, day, hour\\} improve the classifier accuracy very slightly as shown in Table 4.22.\n\n<table>\n<thead>\n<tr>\n<th>Test Options</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Training Data</td>\n<td>76.078%</td>\n<td>0.65 sec</td>\n<td>76.2282%</td>\n</tr>\n<tr>\n<td>Percentage Split</td>\n<td>75.3323%</td>\n<td>0.65 sec</td>\n<td>75.878%</td>\n</tr>\n<tr>\n<td>Cross-Validation</td>\n<td>75.5004%</td>\n<td>1.94 sec</td>\n<td>75.9848%</td>\n</tr>\n<tr>\n<td>Supplied Test set</td>\n<td>74.2777%</td>\n<td>0.45 sec</td>\n<td>75.9217%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.22: Task2: NB Classifier using \\{userId, day, hour\\} with ‘NumericToNominal’\n\nThe next step is using the users’ details as input attributes. First the most significant factor\nshown in the visualization and analysis part is \\{browserId\\}. The following three forms of input attributes are included:\n\n- \\{userId, browserId\\}\n- \\{userId, Day, Hour, browserId\\}\n- \\{userId, Day, Hour, countryId, regionId, cityId, systemId, systemSubId, browserId, browserVerId\\}\n\nwhich means all attributes.\n\nThe following table summarizes the results of Naive Bayes classifier in all input cases by testing it on the supplied test set.\n\n<table>\n<thead>\n<tr>\n<th>Input Attributes</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{userId}</td>\n<td>74.19%</td>\n<td>75.89%</td>\n<td>86.96%</td>\n</tr>\n<tr>\n<td>{userId, BrowserId}</td>\n<td>74.13%</td>\n<td>75.91%</td>\n<td>86.99%</td>\n</tr>\n<tr>\n<td>{userId, day, hour}</td>\n<td>74.28%</td>\n<td>75.92%</td>\n<td>87.02%</td>\n</tr>\n<tr>\n<td>{userId, day, hour, browserId}</td>\n<td>74.12%</td>\n<td>75.91%</td>\n<td>87.03%</td>\n</tr>\n<tr>\n<td>{All attributes}</td>\n<td>72.09%</td>\n<td>75.04%</td>\n<td>87.03%</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.23: Task2: Results of NB classifier with different inputs\n\nEven though the results look very near to each other without significant differences, the real change is in predicting the other categories than \\{categoryId=0\\} for the second and third categories since this means the improvement of the minor class prediction.\n\nScore Function:\n\nCalculating the specific score function is another way to measure the classifiers and models performance. Table 4.24 shows the score function for Naive Bayes classifier in each case. The maximum possible score is 1,085,524.\n\n<table>\n<thead>\n<tr>\n<th>Input Attributes</th>\n<th>Score</th>\n<th>Percentage Score</th>\n<th>Average Score</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{userId}</td>\n<td>715,211</td>\n<td>65.89%</td>\n<td>4.301</td>\n</tr>\n<tr>\n<td>{userId, BrowserId}</td>\n<td>750,350</td>\n<td>69.12%</td>\n<td>4.512</td>\n</tr>\n<tr>\n<td>{userId, day, hour}</td>\n<td>751,803</td>\n<td>69.26%</td>\n<td>4.521</td>\n</tr>\n<tr>\n<td>{userId, day, hour, browserId}</td>\n<td>750,158</td>\n<td>69.11%</td>\n<td>4.511</td>\n</tr>\n<tr>\n<td>{All attributes}</td>\n<td>733,814</td>\n<td>67.6%</td>\n<td>4.413</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.24: Task2: The score function for NB classifier\n\nThe score function results prove the analysis I made at the beginning. It assures the relation between \\{userId, day, hour and browserId\\} and the users’ behavior. The best result was score (4.521) using inputs \\{userId, day, and hour\\} followed by including attribute only \\{browserId\\} which gives score (4.512). The score drops to (4.413) when all users’ details are included but still it is better than using the \\{userId\\} attribute alone which gives score (4.3) only.\n\nAdding Class attribute:\nSince the actual predicting for the second and third categories was 21.3% and 64.6% respectively for categories other than ‘categoryId=0’, which is not sufficient, I added Class attribute which has two values (long or short) depending on the visit type. Table 4.25 shows the prediction improvement especially for the second category which increased from 21.3% to 64.6% for the actual 20 categories. As well the third category prediction increased from 64.4% to 76.7%.\n\n<table>\n<thead>\n<tr>\n<th>Input Attributes</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n<th>Score</th>\n<th>Average Score</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{userId, Class}</td>\n<td>74.661%</td>\n<td>90.572%</td>\n<td>85.124%</td>\n<td>829,429</td>\n<td>4.988</td>\n</tr>\n<tr>\n<td>{userId, BrowserId, Class}</td>\n<td>74.616%</td>\n<td>90.575%</td>\n<td>85.127%</td>\n<td>829,334</td>\n<td>4.987</td>\n</tr>\n<tr>\n<td>{userId, day, hour, Class}</td>\n<td>74.681%</td>\n<td>90.565%</td>\n<td>85.139%</td>\n<td>829,382</td>\n<td>4.987</td>\n</tr>\n<tr>\n<td>{userId, day, hour, browserId, Class}</td>\n<td>74.639%</td>\n<td>90.554%</td>\n<td>85.135%</td>\n<td>829,156</td>\n<td>4.986</td>\n</tr>\n<tr>\n<td>{All attributes, Class}</td>\n<td>72.575%</td>\n<td>90.097%</td>\n<td>85.168%</td>\n<td>808,805</td>\n<td>4.864</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.25: Task2: Results of NB classifier with different inputs including Class Attribute\n\nTable 4.25 displays also the score function after adding {Class} attribute to the other different attributes. There is a significant increase comparing to the previous results. However the results of the different attributes are very close. the best score (4.988) is by using userId attribute alone. Using all attributes gives the minimum score function in this group (4.864) but still it is better than any of the results obtained without Class attribute.\n\nAnother attempt to improve the prediction for the actual categories is adding new attributes named {ClassAB} which has two values: (2 if there is third category and -2 if no third category in this visit). This improve the classification of the third category, however it decreases the overall efficiecy of the classifier. The best score function for this group is 4.837 as shown in 4.26 which is less than the score function in the previous step.\n\n<table>\n<thead>\n<tr>\n<th>Input Attributes</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n<th>Score</th>\n<th>Average Score</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{userId, ClassAB}</td>\n<td>74.275%</td>\n<td>90.551%</td>\n<td>96.276%</td>\n<td>804,339</td>\n<td>4.836</td>\n</tr>\n<tr>\n<td>{userId, BrowserId, ClassAB}</td>\n<td>74.247%</td>\n<td>90.569%</td>\n<td>96.262%</td>\n<td>804,237</td>\n<td>4.836</td>\n</tr>\n<tr>\n<td>{userId, day, hour, ClassAB}</td>\n<td>74.257%</td>\n<td>90.583%</td>\n<td>96.263%</td>\n<td>804,418</td>\n<td>4.837</td>\n</tr>\n<tr>\n<td>{userId, day, hour, browserId, ClassAB}</td>\n<td>74.141%</td>\n<td>90.568%</td>\n<td>96.250%</td>\n<td>803,512</td>\n<td>4.832</td>\n</tr>\n<tr>\n<td>{All attributes, ClassAB}</td>\n<td>72.229%</td>\n<td>90.149%</td>\n<td>96.012%</td>\n<td>785,029</td>\n<td>4.720</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.26: Task2: Results of NB classifier with different inputs including ClassAB Attribute\n\nI apply J48 on the data after using ‘PKIDiscretize’ filter and it only works for the prediction of the second and third categories but I face again the memory out problem when I try to predict the first category. Also applying J48 classifier on the data using ‘NumericToNominal’ filter succeed only to predict the third category with accuracy 88.13% and WEKA fails to continue in predicting the first and second category because of the memory heap size problem. So I decide to try other available classifiers on WEKA such as Decision Table and DNTB.\n\nb. Decision Table Classifier:\n\nApplying Decision table classifier on the nominal data gives approximately the same score function (4.383) for the different input attributes. even though the accuracy of each category prediction is more than Naive Bayes Classifier in each relative input (Cat1=74.46%, Cat2 = 76.99%, Cat3 = 88.39%), this has no affect on the final score function which means that the\naccuracy increasing is mainly in ‘categoryId = 0’ in the second and third category which is not significant in calculating the score function. Table 4.27 shows that especially the first category prediction didn’t change for all cases. Adding any attributes to userId has no affect at all in calculating the accuracy or the score function.\n\n<table>\n<thead>\n<tr>\n<th>Input Attributes</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n<th>Score</th>\n<th>Average Score</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{userId}</td>\n<td>74.459%</td>\n<td>76.986%</td>\n<td>88.386%</td>\n<td>728,391</td>\n<td>4.38</td>\n</tr>\n<tr>\n<td>{userId, BrowserId}</td>\n<td>74.459%</td>\n<td>76.95%</td>\n<td>88.131%</td>\n<td>728,899</td>\n<td>4.383</td>\n</tr>\n<tr>\n<td>{userId, day, hour}</td>\n<td>74.459%</td>\n<td>76.931%</td>\n<td>88.386%</td>\n<td>728,429</td>\n<td>4.38</td>\n</tr>\n<tr>\n<td>{userId, day, hour, browserId}</td>\n<td>74.459%</td>\n<td>76.931%</td>\n<td>88.387%</td>\n<td>728,426</td>\n<td>4.38</td>\n</tr>\n<tr>\n<td>{All attributes}</td>\n<td>74.459%</td>\n<td>76.985%</td>\n<td>88.386%</td>\n<td>728,391</td>\n<td>4.38</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.27: Task2: Results of DT classifier with different inputs\n\nAs done with Naive Classifier, table 4.28 represents the effect of adding Class and ClassAB attributes on the classifier quality. The table has the result of {userId, Class, ClassAB} attributes only because it is the same for all other attributes combination. The best score function in this case is (4.841) for ClassAB which still is less than Naive Bayes classifier results.\n\n<table>\n<thead>\n<tr>\n<th>Input Attributes</th>\n<th>Category1</th>\n<th>Category2</th>\n<th>Category3</th>\n<th>Score</th>\n<th>Average Score</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>{userId, Class}</td>\n<td>75.203%</td>\n<td>89.277%</td>\n<td>88.386%</td>\n<td>783,030</td>\n<td>4.708</td>\n</tr>\n<tr>\n<td>{userId, ClassAB}</td>\n<td>75.203%</td>\n<td>89.277%</td>\n<td>96.335%</td>\n<td>805067</td>\n<td>4.841</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.28: Task2: Results of DT classifier with Class Attributes\n\nc. DTNB Classifier:\n\nAgain using DTNB classifier which is a combination of Decision Table and Naive Bayes classifiers didn’t show a significant improvement in the score function. However, DTNB score function is better than what has gotten using Decision Table alone. The accuracy of the second and third category decrease which means that the predicting of the main 20 categories improves. The best score function for this classifier without using Classes attributes is 4.411 by using only the {userId} attribute.\n\nAdding {ClassA} and {ClassAB} attributes improve the score of DTNB classifier for all other input combination. The trend is the same as Naive Bayes and DT classifiers. The best score for this classifier is (4.88) using {UserId, ClassAB} attributes.\n\n### 4.2.3 Using Numeric Attributes\n\nAs done in Task1, the data input remains numeric while the class attribute is converted to nominal. The results obtained using Naive Bayes classifier is almost the same as the result of discretized inputs. While adding Class attributes improve the classification of second and third category, it has no affect on predicting the first category which remains 44.3% only.\n\nUsing J48 classifier, for each category, different tuning of confidence factor is experimented. The best result was by using attribute {userId} which gives score function of (4.412) which almost the same of DTNB classifier.\n4.2.4 Task2 Summary\n\n- The best score function is (4.988) obtained using Naive Bayes Classifier by Nominal attributes.\n\n- Using Naive Bayes classifier for the numeric attributes is not sufficient especially for the first category prediction.\n\n- Adding Class attributes prevents the false positive (FP) and false negative (FN) in predicting 'categoryId =0' which helps in improving the prediction of other categories.\n\n- J48 classifier and DTNB classifier almost give the same result which is still less than Naive Bayes result.\n\n- In most cases, adding timestamp or user details fields has no remarkable effect on the prediction performance. In contrast, knowing the visit length of the user increase the score function from 4.521 to 4.988.\n\n4.2.5 Task2 Evaluation\n\nThe score function of both the winner and runner-up of the contest outperform my result. For the second task the winner score function was 5.56 using the User Model, while the score function of the runner-up was 5.43 using Naive Bayes with Marcov chain rules. The winner used only the user id attribute and did not try other attributes on this task while the runner-up added timestamp attribute.\n\n<table>\n<thead>\n<tr>\n<th>Contest Winner</th>\n<th>Contest Runner-up</th>\n<th>My result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>5.56</td>\n<td>5.43</td>\n<td>4.988</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.29: Task2 Evaluation\n\n4.3 Task3\n\nThis task is regarding the prediction of the range of the number of page views for the first three page categories visited in a visit session.\n\n\\[ f_{predicted} \\left\\{ userId, timestamp \\right\\} = \\left\\{ \\begin{array}{c} \\text{categoryId}_1, \\text{range of pageview} \\\\ \\text{categoryId}_2, \\text{range of pageview} \\\\ \\text{categoryId}_3, \\text{range of pageview} \\end{array} \\right\\} \\]\n\nPossible ranges and their assigned identifiers:\nrange of Pageview = \\begin{cases} \n1 \\\\\n2 - 3 \\\\\n4 - \\infty\n\\end{cases}\n\nBy applying the Bayesian rule, the probability of the page views range at position \\(i(i = 1, 2, 3)\\) in a visit session \\(X\\) is:\n\n\\[\nP(R_i|C_i, X) = P(R_i = r_i|C_i = c_i)P(X|R_i = r_i, C_i = c_i)\n\\]\n\nwhere the page categories \\(c_i\\) is what we predicted in Task2.\n\n### 4.3.1 Task3 Results\n\nFor this task I use the predicted categories obtained by Naive Bayes Classifier with \\{UserID, Class\\}, which gets the best score for task2. The process is iterative. First the classifier is trained on \\{userID, Cat1, Pageview1\\} on training set, and then the model is applied on the test set with same attributes but using the predicted Cat1 and Pageview1 as class label. Then the classifier is trained using \\{UserID, Cat1, Pageview1, Cat2, Pageview2\\} from training dataset and the model is applied to test set \\{UserID, Predicted Cat1, Predicted Pageview1 from previous step, Predicted cat2, and Pageview2 as class label\\}. Similarly the third step for 3rd pageview. The score function is 6.254 which outperforms the runner-up result and close to the winner result.\n\n<table>\n<thead>\n<tr>\n<th>Contest Winner</th>\n<th>Contest Runner-up</th>\n<th>My result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>6.3147</td>\n<td>5.765</td>\n<td>6.254</td>\n</tr>\n</tbody>\n</table>\n\n*Table 4.30: Task3 Evaluation*\nChapter 5\n\nConclusion and Further Work\n\nThe first challenge of ECML/PKDD Discovery Challenge was a great opportunity to apply WUM techniques and algorithms in a real world problem. In this thesis I introduced a solution to the 2007 ECML/PKDD Discovery Challenge which centered about user behavior prediction over the web. An intensive exploratory data analysis was applied to capture the interesting information from user navigation session. The visualization of the data determined the factors that have influence on predicting user behavior accurately such as the day or hour of navigation process, the browser used to navigate, the type of page visited previously and the time spent on each visit. Based on this, different classification algorithms were applied on different combination of these attributes.\n\nFor the first task, I show that while using more input attributes did not increase the overall accuracy, it still improved the prediction of the minor class (long class) considering that the data is biased to the short class. This is important since it allows the website designers to target users who spend more time in their site. I also show that we can predict user visit type (short or long) by knowing the category of first visited page.\n\nFor the second task, the results provides an experimental evidence that even though adding timestamp or user details fields has no remarkable effect on categories prediction performance, knowing the visit type (short or long) actually helps in predicting the first three visited categories. In fact it particularly improves the second and third categories prediction. Again this can help in personalizing user profile, redirect online advertising.\n\nIn general, the results I report in this thesis are comparable to the challenge winner and surpass the runner-up on two out of the three challenge problems. Given further time, I would attempt to take categories sequence in consideration and study the effect on the classifiers performance.\nAppendix A\n\nMethodologies\n\nA.1 Classification Methods\n\nIn this section I explore and give a short description of the classifiers I used in the dissertation.\n\nA.1.1 Naive Bayes\n\nA naive Bayes classifier is a simple probabilistic classifier based on applying Bayesian theorem with strong independence assumptions. In spite of its simplicity, Naive Bayes can often outperform more sophisticated classification methods.\n\nBecause of the assumption of values independency, only its variances for each class need to be determined and not the entire covariance matrix, which considered as an advantage of Naive Bayes classifier since it requires a small amount of training data to estimate the necessary parameters, i.e. means and variances of the variables, for classification.\n\nAbstractly, the probability model for a classifier is a conditional model $P(C | F_1, ..., F_n)$ over a dependent class variable $C$ with a small number of outcomes or classes, conditional on several feature variables $F_1$ through $F_n$. Using Bayes’ theorem, we write:\n\n$$P(C | F_1, ..., F_n) = \\frac{P(C) P(F_1, ..., F_n | C)}{P(F_1, ..., F_n)}$$\n\nwhere: $P(C)$ is the prior probability of hypothesis $C$; $P(F)$ is the prior probability of training data $F$; $P(C | F)$ is the probability of $C$ given $F$ and; $P(F | C)$ is the probability of $F$ given $C$.\n\nIn practice we are only interested in the numerator of that fraction, since the denominator does not depend on $C$ and the values of the features $F_i$ are given, so that the denominator is effectively constant. The numerator is equivalent to the joint probability model $P(C, F_1, ..., F_n)$ which can be rewritten as follows, using repeated applications of the definition of conditional probability:\n\\[ P(C, F_1, ..., F_n) = P(C)P(F_1, ..., F_n|C) \\]\n\n\\[ = P(C)P(F_1|C)P(F_2|C, F_1)P(F_3|C, F_1, F_2)...P(F_n|C, F_1, F_2, F_3, ..., F_{n-1}) \\]\n\nBy assuming that each feature \\( F_i \\) is conditionally independent of every other feature \\( F_j \\) for \\( j \\neq i \\). This means that:\n\n\\[ P(F_i|C, F_j) = P(F_i|C) \\]\n\nand so the joint model can be expressed as:\n\n\\[ P(C, F_1, ..., F_n) = P(C)P(F_1|C)P(F_2|C)P(F_3|C)...P(F_n|C) \\]\n\n\\[ = P(C) \\prod_{i=1}^{n} P(F_i|C) \\]\n\nThis means that under the above independence assumptions, the conditional distribution over the class variable \\( C \\) can be expressed like this:\n\n\\[ P(C|F_1, ..., F_n) = \\frac{1}{Z} P(C) \\prod_{i=1}^{n} P(F_i|C) \\]\n\nwhere \\( Z \\) is a scaling factor dependent only on \\( F_1, ..., F_n \\), i.e., a constant if the values of the feature variables are known (Pop, 2006).\n\nA.1.2 Decision tree\n\nThe Decision Tree is one of the most popular classification algorithms in current use in Data Mining and Machine Learning. Decision trees are a way of representing a series of rules that lead to a class or value.\n\nIn data mining and machine learning, a decision tree is a predictive model that commonly used to examine the data and induce the tree and its rules that will be used to make predictions (Two Crows Corporation, 2005). Each branch node represents a choice between a number of alternatives, and each leaf node represents a classification or decision. Decision trees which are used to predict categorical variables are called classification trees because they place instances in categories or classes. Decision trees used to predict continuous variables are called regression trees.\n\nA number of different algorithms may be used for building decision trees including CHAID (Chi-squared Automatic Interaction Detection), CART (Classification and Regression Trees), Quest, and C4.5.\n\nC4.5 is an algorithm used to generate a decision tree developed by Ross Quinlan. C4.5 is an extension of Quinlan’s earlier ID3 algorithm. The decision trees generated by C4.5 can be used\nfor classification, and for this reason, C4.5 is often referred to as a statistical classifier.\n\nFigure A.1 describes the Tree Induction Algorithm:\n\n\n\n**Figure A.1:** Tree Induction Algorithm (Ferreira, n.d.).\n\n- The algorithm operates over a set of training instances, C.\n- If all instances in C are in class P, create a node P and stop, otherwise select a feature or attribute F and create a decision node.\n- Partition the training instances in C into subsets according to the values of V.\n- Apply the algorithm recursively to each of the subsets C.\n\nThe order in which attributes are chosen determines how complicated the tree is. ID3 uses information theory to determine the most informative attribute.\n\n### A.1.3 Decision Table\n\nA decision table has two components: A schema, which is a list of attributes and a body, which is a multi set of labeled instances. Each instance consists of a value for each of the attributes in the schema and a value for the label. The set of instances with the same values for the schema attributes is called a cell (Kohavi and Sommerfield, 1998).\n\nA DT stores the input data in condensed form based on a selected set of attributes and uses it as a lookup table when making predictions. Each entry in the table is associated with class probability estimates based on observed frequencies. The key to learning a DT is to select a subset of highly discriminative attributes (Hall1 and Frank, 2008).\n\nWhile Decision Trees provide a graphic, tree-like structure with nodes that correspond to conditions, and leaf nodes that correspond to results, Decision Tables present rules in an Excel table like format, with columns that correspond to conditions and actions.\n\n### A.1.4 DTNB\n\nHall and Frank (2008) introduced DTNB Classifier as a hybrid classifier combining Naive Bayes and Decision Tables techniques. At each point in the search, the algorithm\nevaluates the advantage of dividing the attributes into two disjoint subsets: one for the decision table, the other for Naïve Bayes. A forward selection search is used, where at each step, selected attributes are modeled by Naïve Bayes and the remainder by the decision table and all attributes are modeled by the decision table initially. At each step, the algorithm also considers dropping an attribute entirely from the model. The class probability estimates of the DT and NB must be combined to generate overall class probability estimates. All probabilities are estimated using Laplace corrected observed counts (Hall1 and Frank, 2008).\n\nA.1.5 SVM\n\nSupport Vector Machine (SVM) is a popular machine learning technique proposed by Vapnik and co-workers in 1992 for classification and regression. SVMs allow us to transform the data to a new space where the decision boundary can be linear, mapping back to the original space; we can get a non-linear decision boundary.\n\nViewing input data as two sets of vectors in an n-dimensional space, an SVM will construct a separating hyperplane in that space, one which maximizes the margin between the two data sets. To calculate the margin, two parallel hyperplanes are constructed, one on each side of the separating hyperplane, which are “pushed up against” the two data sets. Intuitively, a good separation is achieved by the hyperplane that has the largest distance to the neighboring data points of both classes, since in general the larger the margin the lower the generalization error of the classifier (Sun et al., 2002) and (Dumais and Chen, 2000). The optimal hyperplane (max margin, lowest capacity) can be uniquely constructed by solving a constrained quadratic optimization problem. The solution \\( w = \\sum v_i x_i \\) where only a subset of the training patterns is used. This subset is called support vectors. These vectors carry all the relevant information about the classification problem.\n\nSeveral existing tools are available for SVM such as: MySVM, SVMlight, Torch, LibSVM. Classifiers built on SVM have shown promising results in text classification.\n\nA.1.6 Association Rules\n\nAssociation rules identify collections of data attributes that are statistically related in the underlying data. An association rule is of the form \\( X \\rightarrow Y \\) where \\( X \\) and \\( Y \\) are disjoint conjunctions of attribute-value pairs.\n\nThe traditional association rule mining problem can be described as follows: Given a database of transactions, a minimal confidence threshold and a minimal support threshold, find all association rules whose confidence and support are above the corresponding thresholds. The support of the rule is the prior probability of \\( X \\) and \\( Y \\), \\( P(X \\text{and} Y) \\). Here probability is taken to be the proportion of transactions in the data set which contain the itemset. The confidence\nof the rule is the conditional probability of $Y$ given $X$, $P(Y|X)$ and is defined as:\n\n$$conf(X \\Rightarrow Y) = supp(X \\cup Y)/supp(X)$$\n\nTo illustrate the concepts, we use a small example from the supermarket domain. The set of items is $I = \\{\\text{milk, bread, butter}\\}$. An example rule for the supermarket could be $\\{\\text{milk, bread} \\Rightarrow \\text{butter}\\}$ meaning that if milk and bread is bought, customers also buy butter. In practical applications, a rule needs a support of several hundred item sets before it can be considered statistically significant, and datasets often contain thousands or millions of item sets.\n\nWhile the original goal of association rule mining is to solve market basket problem, it was used in Web data mining (Khalil et al., 2006). Let $P = p_1, p_2, ..., p_m$ be a set of pages in a Web site. Let $W$ be a user session including a sequence of pages visited by the user in a visit, and $D$ includes a collection of user sessions. Let $A$ be a subsequence of $W$, and $p_i$ be a page. We say that $W$ supports $A$ if $A$ is a subsequence of $W$, and $W$ supports $(A, p_i)$ if $(A, p_i)$ is a subsequence of $W$. The support of implication $A \\Rightarrow p_i$ is $supp(A, p_i)$ and the confidence of the implication is $supp(A, P)/supp(A)$, denoted by $conf(A \\Rightarrow p_i)$. Where $supp(A, p_i) = P(A, p_i)$, and $conf(A, p_i) = P(p_i|A)$.\n\nAn implication is called an association rule if its support and confidence are not less than some user specified minimum thresholds. Association rules are like classification rules, except that they can predict any attribute, not just the class.\n\nMany algorithms for generating association rules were presented over time. Apriori is the best-known algorithm to mine association rules. It reduces the number of item sets that are considered. The idea is using one-item sets to generate two-item sets, two-item sets to generate three-item sets, ... according to user-specified minimal support and return frequent item set and association rules. Apriori algorithm is fast and efficient when data is sparse (most items are relatively infrequent). When data is dense (a lot of items with the same frequency) Apriori algorithm generates too much frequent item sets.\n\nFinding Association rules can be considered as exploratory data analysis. Association or Sequence rules are not really rules, but rather descriptions of relationships in a particular database. There is no formal testing of models on other data to increase the predictive power of these rules. There is just an implicit assumption that the past behavior will continue in the future. It is often difficult to decide what to do with association rules you’ve discovered. Analysis and experimentation are usually required to achieve any benefit from association rules (Two Crows Corporation, 2005).\n\n### A.2 Discretization\n\nUsually a categorical attribute takes a small number of values, so does the class label. Accordingly $p(C = c)$ and $P(X_i = x_i|C = c)$ can be estimated with reasonable accuracy from\ncorresponding frequencies in the training data. A numeric attribute usually has a large or even an infinite number of values, thus for any particular value \\(x_i\\), \\(P(X_i = x_i|C = c)\\) might be arbitrarily close to 0. Therefore it is often advisable to aggregate a range of values into a single value for the purpose of estimating probabilities (Yang and Webb, 2009).\n\nThe use of different discretization techniques could affect the classification bias and variance. The interval number affects significantly on the classification error. Important distinctions are missed if it is too small and if it is too big, the data are over-discretized and the probability estimation may become unreliable. The best interval number depends upon the size of the training data (Yang and Webb, 2009). Hussain et al. (1999) have proposed that there is a trade-off between the interval number and its effect on the accuracy of classification tasks. A lower number can improve understanding of an attribute but lower learning accuracy. A higher number can degrade understanding but increase learning accuracy.\n\nIn this dissertation I use two types of discretization filters presented in WEKA platform for unsupervised learning, which are ’Discretize’ filter and ’PKIDiscretize’ filter.\nAppendix B\n\nSoftware\n\nI explored several software tools for analyzing and performing data mining techniques. This section provides a brief description of these software tools. I describe the reasons of choosing some of them in my dissertation and neglecting others.\n\nB.1 WEKA\n\nWEKA (Waikato Environment for Knowledge Analysis) is popular free software available under the GNU General Public License for machine learning written in Java, developed at the University of Waikato (Witten and Frank, 2005).\n\nWEKA consists of a large number of learning schemes for classification and regression numeric prediction like decision trees, support vector machines, Bayes classifier, neural networks etc. and clustering beside the Meta classifiers like bagging and boosting, evaluation methods like cross-validation and bootstrapping, numerous attribute selection methods and preprocessing techniques. A graphical user interface provides loading of data, applying machine learning algorithms and visualizing the built models (Dimov, 2007).\n\nWEKA input must be in ARFF (Attribute-Relation File Format). It consists of a header and data section. The first section contains metadata describing the second. It consists of all instances’ attributes and their types. The second section consists of attribute values separated by commas (Dimov, 2007). Here is an example of ARFF file:\n\n```\n@relation TrainData\n@attribute userId 46,333,537\n@attribute browserId 1, 25\n@attribute Day 1,2,3,4,5,6,7\n@attribute Class short,long\n@data\n46,1,7,long\n```\n\nIn addition to the native ARFF data file format, WEKA has the capability to read in ‘.csv’ format files. The first row of the csv file contains the attribute names, separated by commas, followed by each data row with attribute values listed in the same order.\n\n**WEKA Problems:**\n\n- One of the biggest problems in WEKA is the memory issue. Most classifiers need to see all the data before they can be trained, such as J48 or SMO; hence large datasets can be a problem. WEKA offers several filters for re-sampling a dataset and generating a new dataset reduced in size. However resampling the data didn’t help in my dissertation with J48 and SVM classifiers.\n\n- Most Java virtual machines only allocate a certain maximum amount of memory to run Java programs. Usually this is much less than the amount of RAM in the computer. I extend the memory available for the virtual machine (memory heap size) by increasing it to the maximum size allowable for 32bit system, which is 1500MB. This helps with some classifiers with limited input attributes, but when I added more attributes for the inputs I face the same problem again.\n\n- Running a filter twice, once with the train set as input and then the second time with the test set, will create almost certainly two incompatible files. The reason is that whenever a filter is running, it will get initialized based on the input data, and, of course, training and test set will differ, hence creating incompatible output.\n\n**B.2 MATLAB**\n\nMATLAB is a numerical computing environment and programming language maintained by The MathWorks, MATLAB allows easy matrix manipulation, plotting of functions and data, implementation of algorithms, creation of user interfaces, and interfacing with programs in other languages (The MathWorks, 2009).\n\nI used MATLAB initially in building Nave Bayes Classifier for the training data in its original numeric format. This gives me a very poor result since it only gives the majority vote. I tried to apply SVM algorithm on the data but I faced memory problem since in MATLAB 7.4 and earlier, there is a limit on the number of elements in an array of $2^{31} - 2$, or approximately $2 \\times 10^9$. Adding to this the fact that MATLAB is dealing only with numeric matrices, this push me to use WEKA in my approach instead of MATLAB.\n**B.3 ARMADA**\n\nARMADA is a data mining tool that extracts Association Rules from numerical data files using a variety of selectable techniques and criteria (Malone, 2003).\n\nThe name ARMADA stands for ‘Association Rule Miner And Deduction Analysis’. The actual knowledge extracted is presented in the form of easy-to-understand rules, while the details of the process, such as time taken and file size considered, are conveniently summarized in the mining report. The program also can allow the results to be displayed through various graphical representations, such as bar charts and line graphs. It is working under MATLAB version 5.x or greater platform. The selected file to mine must contain numerical data, separated by one of the five delimiting characters (comma, semi-colon, colon, full stop, space).\n\nI used ARMADA under MATLAB platform and WEKA Association Rules to extract any significant information about the data and both of them gives the same results as will be described in the next chapter.\n\n**B.4 PERL**\n\nPerl is a free general-purpose programming language originally developed for text manipulation and now used for a large variety of tasks, including system administration, web development, network programming, games, and GUI development. ActivePerl is a distribution, ready-to-install package of Perl in windows platform.\n\nI used Active Perl in writing Perl scripts to manipulate some tasks such as:\n\n1. Converting timestamp to a readable format.\n2. Identifying the class type (short or long) for the first task and produce new data files with the new format and attributes (userId, Day, Hour, and Class).\n3. Filling the empty cells of the short visits with '0' to indicate the absence of second and third category for task 2 and task 3 to get equal-columns files suitable for WEKA and MATLAB.\n4. Distinguishing the repeated categories of the visits path with new identifier.\n5. Computing the score function for the second and third task.\n\n**B.5 Microsoft Excel 2007**\n\nMicrosoft Excel is a spreadsheet-application written and distributed by Microsoft for Microsoft Windows and Mac OS X. It features calculation, graphing tools, pivot tables and a macro programming language called VBA.\nWhile the oldest versions of Excel had a limitation in the size of their data sets, Version 12.0 (Excel 2007) can handle 1M \\((2^{20} = 1048576)\\) rows, and \\((2^{14} = 16384)\\) columns. This feature helps a lot in dealing with the large train and test dataset and converting the txt files to csv file, the suitable format for WEKA. Moreover it helps in reading the result buffer of WEKA classifiers and extracts the prediction output in order to calculate the score function.\nAppendix C\n\nCalculating Score Function\n\nHere are the detailed steps of calculating score function for the second task:\n\n1. The actual visit path vector format is \\(\\{Cat_1, Cat_2, \\ldots, Cat_n\\}\\), where \\(n\\) is the number of visited categories on a single visit for each user. It differs from one to one. The maximum categories number in a single visit for a user in the test data is 200 and the minimum is 1. While the predicted visit path vector format is \\(\\{Cat_1, Cat_2, Cat_3\\}\\).\n\n2. Some of these categories are repeated, meaning that the user visits a specific category more than once during a single session. In this case the repeated category is considered as a new and different category and has a new category ID.\n\n3. In the case of the predicted vector, each category can appear once or twice or three times for each visit path. So each repeated category is renamed with a new id, which multiply the categories number three times to be 60 categories instead of 20 categories only.\n\n4. In the real vector, the maximum session has 200 visited categories in a single visit path, which means that some categories may be repeated more than three times. In this case renaming each category occurrence will increase the categories numbers a lot. Instead each repeated category is renamed for the first three occurrence and the third new category name is repeated for all the others occurrences.\n\n5. The score function, \\(Scr(R)\\), for the new renamed-categories version of the real vector is calculated according to the score given by the organizers (5 points for first category, 4 for second, etc...).\n\n6. \\(Scr(P)\\) is calculated also for the renamed-categories version of the predicted vector.\n\n7. The minimums of both score functions \\(Scr(R)\\) and \\(Scr(P)\\) for each category has been chosen to create \\(MIN\\) vector.\n\n8. All the elements of the \\(MIN\\) vector are summed up to get the final score of that visit path vector. The maximum sum of the score the best is the classifier.\n**Example:** Suppose that the actual category vector $R = [12\\ 7\\ 14\\ 12\\ 8\\ 12\\ 13\\ 12]$, and the predicted vector $P = [7\\ 12\\ 7]$. To create the new repeated-categories actual and predicted vectors, we replace the second occurrence of *category 12* in actual vector by $(12 + 20 = 32)$, third occurrence of the same category by $(12 + 40 = 52)$. Any new appearance of this category after three occurrences takes the same last identifier so the fourth occurrence is replaced by $(52)$, so the new repeated-categories actual vector $R = [12\\ 7\\ 14\\ 32\\ 8\\ 52\\ 13\\ 52]$. For the predicted vector, the second occurrence of *category 7* is replaced by $(7 + 20 = 27)$, etc. So the new repeated-categories predicted vector $P = [7\\ 12\\ 27]$.\n\nThe score vector $SCR(R)$ for $R$ and score vector $SCR(P)$ for $P$ are:\n\n<table>\n<thead>\n<tr>\n<th>Categories</th>\n<th>1</th>\n<th>...</th>\n<th>7</th>\n<th>8</th>\n<th>...</th>\n<th>11</th>\n<th>12</th>\n<th>13</th>\n<th>...</th>\n<th>27</th>\n<th>...</th>\n<th>32</th>\n<th>...</th>\n<th>52</th>\n<th>...</th>\n<th>60</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$Scr(R)$</td>\n<td>0</td>\n<td>0</td>\n<td>4</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n<td>5</td>\n<td>1</td>\n<td>3</td>\n<td>0</td>\n<td>0</td>\n<td>2</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>$Scr(P)$</td>\n<td>0</td>\n<td>0</td>\n<td>5</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>4</td>\n<td>0</td>\n<td>0</td>\n<td>3</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>MIN</td>\n<td>0</td>\n<td>0</td>\n<td>4</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>4</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\n\n\nFor the actual vector, *category 12* is in the first position so its score is 5, while the repeated *category 12* comes again in the fourth position so the new identifier of it {32} gets the score of 2. Same category is visited again in the sixth position, identified as {52}, gets the score 1. The fourth occurrence of this category in the 8th position takes the score of 1.\n\nAs well, for the predicted vector, *category 7* appears in the first place so it gets the score of 5, and when it has been visited again in the third place it is identified as {27} and its score is 3. Then the minimums of both vectors $MIN$ is calculated and finally all the elements of $MIN$ vector is summed up and the score $Scr(P) = 8$.\n\nThe maximum score of the predicted vector for a single visit path is $(5 + 4 + 3 = 12)$ if all of categories are predicted correctly and the minimum is (0) if all of it predicted incorrect.\n\nThe maximum possible overall score for the predicted vector of the test data is calculated as follows:\n\n- If the first category is predicted correctly for all instances:\n\n $Scr_{cat1}(P) = \\text{the occurrence of first category} \\times \\text{Score of first position}$\n \n $= 166,299 \\times 5$\n \n $= 831,495$\n\n- If the second category is predicted correctly for all instances:\n\n $Scr_{cat2}(P) = \\text{the occurrence of second category} \\times \\text{Score of second position}$\n \n $= 44,380 \\times 4$\n \n $= 177,520$\n\n65\n• If the third category is predicted correctly for all instances:\n\n\\[\nScr_{cat2}(P) = \\text{the occurrence of the third category} \\times \\text{Score of third position}\n\\]\n\n\\[\n= 25,503 \\times 3\n\\]\n\n\\[\n= 76,509\n\\]\n\n• \n\nThe maximum possible score \\(= 831,495 + 177,520 + 76509 \\)\n\n\\[\n= 1,085,524\n\\]\nBibliography\n\n\nI-Hsien Ting, Chris Kimble, and Daniel Kudenko. *UBB Mining: Finding Unexpected Browsing Behaviour in Clickstream Data to Improve a Web Site’s Design.* In *WI\n\n\n"}}},{"rowIdx":170,"cells":{"id":{"kind":"string","value":"7156da5bade489480700d4951fe0b93b1e26039b"},"text":{"kind":"string","value":"Algorithmic Analysis of Array-Accessing Programs\\textsuperscript{1,2}\n\nRAJEEV ALUR\nUniversity of Pennsylvania\n\nPAVOL ČERNÝ\nIST Austria\n\nand\n\nSCOTT WEINSTEIN\nUniversity of Pennsylvania\n\nFor programs whose data variables range over boolean or finite domains, program verification is decidable, and this forms the basis of recent tools for software model checking. In this paper, we consider algorithmic verification of programs that use boolean variables, and in addition, access a single read-only array whose length is potentially unbounded, and whose elements range over an unbounded data domain. We show that the reachability problem, while undecidable in general, is (1) \\textsc{Pspace}-complete for programs in which the array-accessing \\texttt{for}-loops are not nested, (2) decidable for a restricted class of programs with doubly-nested loops. The second result establishes connections to automata and logics defining languages over data words.\n\nCategories and Subject Descriptors: D.2.4 [Software Engineering]: Software/Program Verification—Formal Methods; F.3.1 [Logics and Meanings of Programs]: Specifying and Verifying and Reasoning about Programs—Mechanical verification\n\nGeneral Terms: Verification, Theory\n\nAdditional Key Words and Phrases: algorithmic software verification, arrays, automata\n\n1. INTRODUCTION\n\nVerification questions concerning programs are undecidable in general. However, for finite-state programs — programs whose data variables range over finite types such\nas boolean, the number of bits needed to encode a program state is a priori bounded, and verification questions such as reachability are decidable. This result, coupled with progress on symbolic techniques for searching the state-space of finite-state programs, and abstraction techniques for extracting boolean over-approximations of general programs, forms the basis of recent tools for software model checking [Ball and Rajamani 2002; Henzinger et al. 2002; Gulavani et al. 2006].\n\nA natural question is then whether it is possible to extend the boolean program model without losing decidability or worsening computational complexity of the reachability problem. However, adding integer variables and (Presburger) arithmetic over integers quickly leads to undecidability of verification problems. One can therefore investigate the possibility of adding only equality and order tests on integers to the language. We show that it is possible to extend the model further.\n\nThis paper focuses on algorithmic verification of programs that access a single array. The length of the input array is potentially unbounded. The elements of the array range over \\( \\Sigma \\times D \\), where \\( \\Sigma \\) is a finite set, and \\( D \\) is a data domain that is potentially unbounded and totally ordered. The array is thus modeled as a data word, that is, a sequence of pairs in \\( \\Sigma \\times D \\). For example an array that contains employees’ names, and for each name a tag indicating whether the employee is a programmer, a manager, or a director, can be modeled by setting \\( D \\) to be the set of strings, and \\( \\Sigma \\) to be a set with three elements. The program can have Boolean variables, index variables ranging over array positions, and data variables ranging over \\( D \\). The expressions in the program can use constants in \\( D \\), and equality tests and ordering over index and data variables. There are no restrictions on operations on elements of \\( \\Sigma \\). The programs are built using assignments, conditionals, and for-loops over the array. Even with these restrictions, one can perform interesting computational tasks including searching for a specific value, finding the minimum data value, checking that all values in the array are within specific bounds, or checking for duplicate data values. For example, Java midlets designed to enhance features of mobile devices include simple programs accessing the address books, and our methods can be at the core of an automatic verification tool that certifies their correctness. In order to analyze programs statically, it is often necessary to check relationships among values in the array, as well as their relationships to values of other variables and constants. For example, in the case of indirect addressing, it is needed to check that all the values in the array fall within certain bounds. For programs that fall outside the restrictions mentioned above, it is possible to use abstract interpretation techniques such as predicate abstraction [Graf and Saïdi 1997] to abstract some of the features of the program, and analyze the property of interest on the abstract program. As the abstract programs are nondeterministic, we will consider nondeterministic programs.\n\nOur first result is that the reachability problem for programs in which there are no nested loops is decidable. The construction is by mapping such a program to a finite-state abstract transition system such that every finite path in the abstract system is feasible in the original program for an appropriately chosen array. We show that the reachability problem for programs with non-nested loops is \\( \\text{PSPACE-complete} \\), which is the same complexity as that for finite-state programs with only boolean variables.\nOur second result shows decidability of reachability for programs with doubly-nested loops with some restrictions on the allowed expressions. The resulting complexity is non-elementary, and the interest is mainly due to the theoretical connections with the recently well-studied notions of automata and logics over data words [Bojańczyk et al. 2006; Björklund and Schwentick 2007; Kaminski and Francez 1994]. Among different kinds of automata over data words that have been studied, data automata [Bojańczyk et al. 2006] emerged as a good candidate definition for the notion of regularity for languages on data words. A data automaton first rewrites the $\\Sigma$-component to another finite alphabet $\\Gamma$ using a nondeterministic finite-state transducer, and then checks, for every data value $d$, whether the projection obtained by deleting all the positions in which the data value is not equal to $d$, belongs to a regular language over $\\Gamma$. In order to show decidability of the reachability problem for programs with doubly nested loops, we extend this definition as follows: An extended data automaton first rewrites the data word as in case of data automata. For every data value $d$, the corresponding projection contains more information than in case of data automata. It is obtained by replacing each position with data value different from $d$ by the special symbol 0. The projection is required to be in a regular language over $\\Gamma \\cup \\{0\\}$. We prove that the reachability problem for extended data automata can be reduced to emptiness of multicounter automata (or equivalently, to Petri nets reachability), and is thus decidable. We then show that a program containing doubly-nested loops can be simulated, under some restrictions, by an extended data automaton. Relaxing these restrictions leads to undecidability of the reachability problem for programs with doubly-nested loops.\n\nAnalyzing reachability problem for programs brings a new dimension to investigations on logics and automata on data words. We establish some new connections, in terms of expressiveness and decidability boundaries, between programs, logics, and automata on data words. Bojańczyk et al. [Bojańczyk et al. 2006] consider logics on data words that use two binary predicates on positions of the word: (1) an equivalence relation $\\approx$, such that $i \\approx j$ if the data values at positions $i$ and $j$ are equal, and (2) an order $\\prec$ which gives access to order on data values, in addition to standard successor ($+1$) and order $<$ predicates over the positions. They show that while the first order logic with two variables, $\\text{FO}^2(\\approx, <, +1)$, is decidable, introducing order on data values causes undecidability, that is, $\\text{FO}^2(\\approx, <, <, +1)$ is undecidable. In this context, our result on programs with non-nested loops is perhaps surprising, as we show that the undecidability does not carry over to these programs, even though they access order on the data domain and have an arbitrary number of index and data variables.\n\n2. PROGRAMS\n\nIn this section, we define the syntax and semantics of programs that we will consider. Let $D$ be an infinite set of data values. We will consider domains $D$ equipped with equality $(D, =)$, or with both equality and linear order $(D, =, <)$. Let $\\Sigma$ be a finite set of symbols. An array is a data word $w \\in (\\Sigma \\times D)^*$. The program can access the elements of the array via indices into the array.\n2.1 Syntax\n\nThe programs have one array variable $A$. Boolean variables are defined by the following grammar: $bvar ::= b, b_1, b_2, \\ldots$. Index variables are defined by the following grammar: $indvar ::= p, p_1, p_2, \\ldots$ and range over $\\mathbb{N}$. Loop variables are defined by the following grammar: $loopvar ::= i, j, i_1, i_2, \\ldots$ and range over $\\mathbb{N}$. We make a distinction between loop and index variables because loop variables cannot be modified outside of the loop header. Data variables are defined by the following grammar: $datavar ::= v, v_1, v_2, \\ldots$ and range over $D$. Constants in $D$ are defined by the grammar: $dconst ::= c, c_1, c_2, \\ldots$, and constants in $\\Sigma$ are defined by the grammar $sconst ::= s, s_1, s_2, \\ldots$.\n\nIndex expressions $IE$ are defined by the following grammar:\n\n$$IE ::= \\text{indvar} \\mid \\text{loopvar}$$\n\nData expressions $DE$ are of the form:\n\n$$DE ::= \\text{datavar} \\mid \\text{dconst} \\mid A[IE].d$$\n\nwhere $A[IE].d$ accesses the data part of the array.\n\n$\\Sigma$-expressions $SE$ are of the form:\n\n$$SE ::= \\text{sconst} \\mid A[IE].s$$\n\nwhere $A[IE].s$ accesses the $\\Sigma$ part of the array.\n\nBoolean expressions are defined by the following grammar:\n\n$$B ::= \\text{true} \\mid \\text{false} \\mid bvar$$\n$$\\mid B \\text{ and } B \\mid \\text{not } B$$\n$$\\mid IE = IE \\mid IE < IE$$\n$$\\mid DE = DE \\mid DE < DE$$\n$$\\mid SE = SE$$\n\nThe programs are defined by the grammar:\n\n$$P ::= \\text{skip}$$\n$$\\mid \\{ P \\}$$\n$$\\mid bvar:=B \\mid indvar:=IE \\mid datavar:=DE$$\n$$\\mid \\text{if } B \\text{ then } P \\text{ else } P$$\n$$\\mid \\text{if } * \\text{ then } P \\text{ else } P$$\n$$\\mid \\text{for } \\text{loopvar}:=1 \\text{ to } \\text{length}(A) \\text{ do } P$$\n$$\\mid P;P$$\n\nThe commands include a nondeterministic conditional. We consider nondeterministic programs in this paper, in order to enable modeling of abstracted programs. Software model checking techniques [Graf and Saïdi 1997; Ball and Rajamani 2002; Henzinger et al. 2002] often rely on predicate abstraction. For example, if the original program contains an assignment of the form $b := E$, where $E$ is a complicated expression that falls out of scope of the intended analysis, the assignment is abstracted into a nondeterministic assignment to $b$. This is modeled as $\\text{if } * \\text{ then } b:=\\text{true} \\text{ else } b:=\\text{false}$ in the language presented here.\n2.2 Semantics\n\nA global state of a program is a valuation of its boolean, loop, index and data variables, as well as of its array variable. We denote global states by \\( g, g_1 \\), and the set of global states by \\( G \\). For a boolean, index, loop or data variable \\( v \\), we denote the value of \\( v \\) by \\( g[v] \\). The value of the array variable \\( A \\) is a word \\( w \\in (\\Sigma \\times D)^* \\). It is denoted by \\( g[A] \\). The length of the array at global state \\( g \\) is denoted by \\( l(g[A]) \\) and evaluates to the length of \\( w \\). Note that the length and the contents of the array do not change over the course of the computation.\n\nSemantics of boolean expressions (index, data and \\( \\Sigma \\) expressions respectively) is given by a partial function \\([B]\\) from \\( G \\) to \\( B \\). For index expressions, \\([IE]\\) is a partial function from \\( G \\) to \\( \\mathbb{N} \\). For data expressions, \\([DE]\\) is a partial function from \\( G \\) to \\( D \\). For \\( \\Sigma \\)-expressions, \\([SE]\\) is a partial function from \\( G \\) to \\( \\Sigma \\). The semantics of an expression is not defined only when there is an out-of-bounds array access. For example, in a state \\( g \\) where \\( g[A] \\) is a word of length 10 and \\( g[p] \\) is 20, the semantics of the expression \\( A[p] \\cdot d \\) is undefined. The semantics of commands is defined as a relation on \\( G \\), \\([P]\\) \\( \\subseteq G \\times G \\).\n\n\\[\n\\begin{aligned}\n& (g, g) \\in [\\text{skip}], \\text{for all } g \\in G \\\\\n& (g, g') \\in [v := E], \\text{iff } g'[v] = g[v \\leftarrow [E](g)], \\text{for any assignment.} \\\\\n& (g, g') \\in [\\text{if } B \\text{ then } P_1 \\text{ else } P_2] \\text{ iff } [B](g) = \\text{true} \\text{ and } (g, g') \\in [P_1] \\text{ or } [B](g) = \\text{false} \\text{ and } (g, g') \\in [P_2]. \\\\\n& (g, g') \\in [\\text{if } i \\text{ = } 1 \\text{ to length}(A) \\text{ do } P] \\text{ iff } l(g[A]) = 0. \\\\\n& (g, g') \\in [\\text{for } i_1 := 1 \\text{ to length}(A) \\text{ do } P] \\text{ iff } l(g[A]) > 0 \\text{ and there exist } g_1, g_2, \\ldots, g_{l+1}, \\text{ such that } g_1 = g, g_{l+1} = g', \\text{ and for all } i \\text{ such that } 1 \\leq i \\leq l, \\text{ we have that there exists a } g'_{i+1}, \\text{ such that } (g_i, g'_{i+1}) \\in [P] \\text{ and } g_{i+1} = g'_{i+1}[i1 \\leftarrow i + 1]. \\\\\n& (g, g') \\in [P_1; P_2] \\text{ iff there exists } g'' \\text{ such that } (g, g'') \\in [P_1] \\text{ and } (g'', g') \\in [P_2].\n\\end{aligned}\n\\]\n\nGiven a program, a global state is initial if either i) the array variable contains a nonempty word, all boolean variables are set to false, all index and loop variables are set to 1, and all data variables are set to the same value as the first element of the array; or ii) the array variable contains an empty word, all boolean variables are set to false, all index and loop variables are set to 1, and all data variables are set to a constant \\( c_D \\in D \\). The intention is that the only unspecified part of the initial state, the part that models input of the program, is the array.\n\nFor programs we have defined, where the only iteration allowed is over the array, the termination is guaranteed. Therefore for all initial global states \\( g_1 \\) there exists a global state \\( g \\) such that \\( (g_1, g) \\in [P] \\).\n\n2.3 Restricted fragments\n\nWe classify programs using the nesting depth of loops. We denote programs with only non-nested loops by ND1, programs with nesting depth at most 2 by ND2, etc. Restricted-ND2 programs are programs with nesting depth at most 2, that do not use index or data variables, and do not refer to order on data or indices. Furthermore, a key restriction, such that if it is lifted, the reachability problem\nbecomes undecidable, is a restriction on the syntax of the code inside the inner loop. Let \\( P_1 \\) be the code inside an inner loop, and let \\( i \\) be the loop variable of the outer loop and let \\( j \\) be the loop variable for the inner loop. \\( P_1 \\) must be of the following form: if \\( A[i].d = A[j].d \\) then \\( P_2 \\) else \\( P_3 \\). Furthermore, \\( P_3 \\) cannot refer to \\( A[j] \\), i.e. it does not contain occurrences of \\( A[j].d \\) or \\( A[j].s \\).\n\n2.4 Examples\n\nWe present two illustrative examples for the classes of programs we defined.\n\n*Example* 2.1. Figure 1 shows an \\( \\text{ND1} \\) program that tests whether the array is sorted. It uses one data variable called \\( v \\) (note that by definition of the semantics, \\( v \\) is initialized to the same value as the first element of the array).\n\n*Example* 2.2. The Restricted-\\( \\text{ND2} \\) program in Figure 2 tests whether there is a data value that appears twice in the array.\n\n2.5 Program verification\n\nOur results on decidability of reachability for \\( \\text{ND1} \\) and Restricted-\\( \\text{ND2} \\) can be applied to assertion checking. Consider assertions of the form \\textbf{assert} \\( \\varphi \\), where \\( \\varphi \\) is a propositional formula over boolean variables of the program. If such an assertion appears in the program, it can be checked as follows: introduce a new boolean variable \\( f \\) (which is set to \\texttt{false} initially, as all the other boolean variables), and replace the assert statement by the assignment \\( f := \\varphi \\). The assertion holds in all executions of the program if and only if a boolean state where \\( f == \\texttt{true} \\) is reachable.\n\nMore generally, the results on decidability of reachability are applicable if the assertion for a program \\( P \\) is expressed as a program of the same class (\\( \\text{ND1} \\) and Restricted-\\( \\text{ND2} \\)) as \\( P \\). This is illustrated in the next example.\n\n*Example* 2.3. We consider a simple array accessing program \\( \\text{Min} \\) that scans through an array to find a minimal data value. It has one index variable, \\( p \\), and it is an \\( \\text{ND1} \\) program, as it does not contain nested loops. By the definition of program semantics, \\( p \\) is initialized to 1.\n\n\\[\n\\text{for } i := 1 \\text{ to length(A) do }\n\\begin{align*}\n&\\text{if } A[i].d < A[p].d \\text{ then } p := i \\\\\n\\end{align*}\n\\]\nThe correctness requirement for this program is that the index \\( p \\) points to a minimal element, that is \\( \\forall i : A[i].d \\geq A[p].d \\). Verifying the correctness of the program can be reduced to checking reachability, as the requirement itself can be expressed as a program:\n\n\\[\n\\begin{align*}\n b &:= \\text{true}; \\\\\n \\text{for } i:= 1 \\to \\text{length}(A) \\text{ do } \\{ \\\\\n &\\quad \\text{if } A[i].d < A[p].d \\text{ then } \\{ p := i \\} \\\\\n &\\quad \\text{for } i:= 1 \\to \\text{length}(A) \\text{ do } \\{ \\\\\n &\\quad\\quad \\text{if } A[i].d < A[p].d \\text{ then } \\{ b:=\\text{false} \\} \\\\\n &\\;\\}\n\\end{align*}\n\\]\n\nWe can now ask a reachability question: Does the control reach the end of the program in a state where \\( b == \\text{false} \\) holds?\n\nWe show that the reachability problem for programs with non-nested loops is PSPACE-complete, which is the same complexity as that for finite-state programs with only boolean variables. The latter is the basis of successful software verification tools, and therefore can suggest that, coupled with abstraction techniques, our decision procedure can potentially be the basis of a software model checking tool that better handles data structures with potentially unbounded size.\n\n3. REACHABILITY\n\n**Boolean states.** A boolean state is a valuation of all the boolean variables of a program. For a given global state \\( g \\), the corresponding boolean state is denoted by \\( \\text{bool}(g) \\). For any boolean variable \\( b \\) of the program, we have that \\( \\text{bool}(g)[b] = g[b] \\). We denote boolean states by \\( m, m_1 \\) and the set of boolean states by \\( M \\).\n\n**Reachability.** Given a program \\( P \\), a boolean state \\( m \\) is reachable if and only if there exists an initial global state \\( g_I \\) and a global state \\( g \\) such that \\( (g_I, g) \\in [P] \\) and \\( \\text{bool}(g) = m \\). The reachability problem is to determine, for a given program \\( P \\) and a given boolean state \\( m \\), whether \\( m \\) is reachable. In this section, we show that reachability is decidable (PSPACE-complete) for programs with only non-nested loops (ND1-programs).\n\n**Local states.** We will use a notion of a local state. Given a program, a local state is a valuation of all its boolean, index, loop, and data variables, as well as the values of array elements corresponding to index and loop variables. For each index and loop variable \\( v \\), local states have an additional variable \\( A_v \\) that stores the value of the array element at position given by \\( v \\). The main difference between local and global states is that local states do not contain a valuation of the array, the local states only store a finite number of values from the unbounded domain \\( D \\).\n\nFor a given global state \\( g \\), we denote the corresponding local state by \\( \\text{loc}(g) \\). For any variable \\( v \\) of the program, we have that \\( \\text{loc}(g)[v] = g[v] \\). If \\( v \\) is an index or a loop variable, we also have that \\( \\text{loc}(g)[A_v] = [A[v]](g) \\). We denote local states by \\( q, q_1 \\), and the set of local states by \\( Q \\). A local state \\( q \\) is initial if there exists an initial global state \\( g_I \\) such that \\( \\text{loc}(g_I) = q \\).\nNormal form. In order to simplify the presentation of proofs of the decidability results, we will first translate the programs into a normal form. A program is in normal form if the branches of if statements do not contain loops.\n\nWe define a translation function \\( \\text{norm}(P) \\), that given a program \\( P \\) returns an equivalent program in normal form. We use an auxiliary function \\( \\text{assume}(B, P) \\), and we set \\( \\text{norm}(P) = \\text{assume}(\\text{true}, P) \\). The function \\( \\text{assume}(B, P) \\) is defined inductively as follows:\n\n- \\( \\text{assume}(B, \\text{skip}) = \\text{skip} \\).\n- \\( \\text{assume}(B, v := E) = \\text{if } B \\text{ then } v := E \\text{ else } \\text{skip} \\), if \\( B \\) is not true, and \\( v := E \\) otherwise.\n- \\( \\text{assume}(B, \\text{if } B_1 \\text{ then } P_1 \\text{ else } P_2) = b := B_1; \\text{assume}(B \\text{ and } b, P_1); \\text{assume}(B \\text{ and } \\neg b, P_2), \\) where \\( b \\) is a new boolean variable\n- \\( \\text{assume}(B, \\text{for } i_1 := 1 \\text{ to } \\text{length}(A) \\text{ do } P) = \\text{for } i_1 := 1 \\text{ to } \\text{length}(A) \\text{ do assume}(B, P). \\)\n- \\( \\text{assume}(B, P_1; P_2) = \\text{assume}(B, P_1) ; \\text{assume}(B, P_2). \\)\n\nThe program \\( \\text{norm}(P) \\) has more variables than the program \\( P \\). However, intuitively the programs \\( \\text{norm}(P) \\) and \\( P \\) compute the same function on the common variables. We now formalize this notion.\n\nLet \\( P \\) be a program, let \\( G \\) be its set of global states and let \\( V \\) be its set of variables. Similarly, let \\( G' \\) and \\( V' \\) be the sets of states and variables of a program \\( P' \\). Furthermore, we will assume that \\( V \\subseteq V' \\). We define a relation \\( \\sim_{V,V'} \\) as follows. We have that \\( [P] \\sim_{V,V'} [P'] \\) if and only if for all \\( g_1', g_2' \\in G' \\) it holds that \\( (g_1', g_2') \\in [P'] \\) iff \\( (\\pi_{V,V'}(g_1'), \\pi_{V,V'}(g_2')) \\in [P] \\), where \\( \\pi_{V,V'} : G' \\to G \\) as follows: \\( \\pi_{V,V'}(g') = g \\) iff \\( g \\) and \\( g' \\) agree on variables from \\( V \\).\n\n**Lemma 3.1.** Let \\( P \\) be a program, let \\( V \\) be its set of variables, and let \\( V' \\) be the set of variables of \\( \\text{norm}(P) \\). We have that \\( [P] \\sim_{V,V'} [\\text{norm}(P)] \\). Furthermore, the nesting depth of loops is the same in \\( \\text{norm}(P) \\) as it is in \\( P \\). The number of boolean variables in \\( \\text{norm}(P) \\) increased by at most the number of if statements in \\( P \\). If \\( P \\) is an ND1 (Restricted-ND2) program, then \\( \\text{norm}(P) \\) is an ND1 (Restricted-ND2) program.\n\n**Proof.** Let \\( B \\) be a boolean expression. Let \\( \\text{vars}(P) \\) (\\( \\text{vars}(B) \\)) denote the set of variables in \\( P \\) (\\( B \\)). We assume that \\( \\text{vars}(P) \\cap \\text{vars}(B) \\) is empty.\n\nClaim: \\( [\\text{assume}(B, P)] \\sim_{V,V'} [\\text{if } B \\text{ then } P \\text{ else skip}] \\).\nWe prove the claim by induction on the structure of the program \\( P \\). If \\( P \\) is \\( \\text{skip} \\) or \\( v := E \\), the claim follows easily. The inductive cases are similar to each other; we\npresent the case of the loop construct.\n\nLet \\( P \\) be the program \\( \\text{for } i_1 := 1 \\text{ to } \\text{length}(A) \\text{ do } P_1 \\text{ else skip} \\). Let \\( V \\) be the set of variables and \\( G \\) the set of global states of \\( \\text{if } B \\text{ then } P \\text{ else skip} \\). Let \\( V' \\) be the set of variables of \\( \\text{assume}(B, P) \\) and \\( G' \\) its set of states. Let us now suppose that there are two states \\( g_1', g_2' \\in G' \\) such that \\( (g_1', g_2') \\in \\{ \\text{assume}(B, P) \\} \\).\n\nBy definition, we have \\( (g_1', g_2') \\in \\{ \\text{for } i_1 := 1 \\text{ to } \\text{length}(A) \\text{ do } \\text{assume}(B, P_1) \\} \\).\n\nBy definition of the semantics for loops, we obtain that there exist states \\( h_1, h_2, \\ldots, h_{l+1} \\in G' \\), where \\( l = l(g_1'[k]) \\), such that \\( h_1 = g_1' \\), \\( h_{l+1} = g_2' \\), and for all \\( i \\) such that \\( 1 \\leq i \\leq l \\), we have that there exists a \\( h_i' \\), such that \\( (h_i, h_i') \\in \\{ \\text{assume}(B, P_1) \\} \\) and \\( h_{i+1} = h_{i+1}'[i_1 \\leftarrow i + 1] \\). We now use induction hypothesis for the program \\( P_1 \\) to obtain that there exist states \\( k_1, k_2, \\ldots, k_{l+1} \\in G \\), such that (a) \\( \\pi_{V', V'}(k_i) = h_i \\), (b) \\( (k_i, k_{i+1}') \\in \\{ \\text{if } B \\text{ then } P_1 \\text{ else skip} \\} \\), (c) \\( k_{l+1}'[i_1 \\leftarrow i + 1] \\). This implies that there exist states \\( g_1, g_2 \\in G \\) such that \\( (g_1, g_2) \\in \\{ \\text{for } i_1 := 1 \\text{ to } \\text{length}(A) \\text{ do } \\{ \\text{if } B \\text{ then } P_1 \\text{ else skip} \\} \\} \\), \\( \\pi_{V', V'}(g_1) = g_1' \\), and \\( \\pi_{V', V'}(g_2) = g_2' \\). The last step consists in showing that \\( (g_1, g_2) \\in \\{ \\text{if } B \\text{ then } \\{ \\text{for } i_1 := 1 \\text{ to } \\text{length}(A) \\text{ do } P_1 \\} \\text{ else skip} \\} \\).\n\nThe claim above implies that we have that \\( \\{ \\text{norm}(P) \\} \\sim_{V', V'} [P] \\). The proofs of the other parts of the lemma are by simple structural induction. \\(\\square\\)\n\nThe following theorem is one of the two main results of the paper. It states that the reachability problem for ND1 programs is \\( \\text{PSPACE} \\)-complete, where the size of the input is the size of the program.\n\n**Theorem 3.2.** Reachability for ND1 programs is decidable. The problem is \\( \\text{PSPACE} \\)-complete.\n\nWe start by describing the structure of the proof. First, the semantics of a program \\( P \\) in terms of a transition system \\( T \\) whose states are (tuples of) local states. Intuitively, this is not surprising, as an ND1 program \\( P \\) that contains only one loop (e.g. \\( \\text{for } i_1 := 1 \\text{ to } \\text{length}(A) \\text{ do } P_1 \\)) can be seen as a transition system whose states are local states of \\( P \\) and which processes an input word in \\( \\Sigma \\times D \\), with each iteration consuming one symbol of the word (by applying \\( P_1 \\)). For sequential composition of loops, a product construction (augmented with some bookkeeping) is used.\n\nThe transition system \\( T \\) is still an infinite-state system, as its states store values from \\( D \\). Therefore, we construct a finite state system \\( T^\\alpha \\) that abstracts away the infinite part of the local states, that is, the values of index, loop and data variables. The abstract state transition system \\( T^\\alpha \\) keeps only order and equality information on the index, loop and data variables. More precisely, \\( T^\\alpha \\) stores an ec-order, that is, a total order on equivalence classes of a set. (We define the notion of ec-order formally below.) Let \\( IV \\) be the set of index and loop variables of \\( P \\). Let \\( DV \\) be the set of data variables of \\( P \\). An abstract state is a tuple \\( (m, S_I, S_D) \\), where \\( m \\) is a boolean state in \\( M \\), \\( S_I \\) is an ec-order on \\( IV \\) and \\( S_D \\) is an ec-order on \\( DV \\cup IV \\). An abstract state represents a set of local states. For example, if a program has an index variable \\( p_1 \\), a loop variable \\( i_1 \\) and a data variable \\( v_1 \\), a possible abstract state is \\( (m, p_1 < i_1, p_1 = i_1 < v_1) \\). This abstract state represents a set of concrete states whose boolean state is \\( m \\), and the value of \\( p_1 \\) is less than the value of \\( i_1 \\), the value of the array at position \\( p_1 \\) is the same as the value of the array at position...\nWe show that reachability of a boolean state \\( m \\) can be decided on the abstract system, in the sense that \\( m \\) is reachable in \\( T \\) if and only if it is reachable in \\( T^\\alpha \\). (A boolean state \\( m \\) is reachable in \\( T^\\alpha \\) iff there exist \\( SI \\) and \\( SD \\) such that \\( (m, SI, SD) \\) is reachable in \\( T^\\alpha \\).) The main part of the proof shows that every finite path in the abstract transition system \\( T^\\alpha \\) is feasible in the concrete transition system \\( T \\).\n\nThe first idea for a proof might be to show that the abstraction defines a bisimulation between abstract and concrete transition systems. However, this is not the case. We present a simple counterexample. Let us consider a program \\( P \\) and let us focus on two data variables \\( v1 \\) and \\( v2 \\). Let \\( q_1 \\) be a local state such that its boolean component is \\( m \\), the value of \\( v1 \\) at \\( q \\) is 5 and the value of \\( v2 \\) at \\( q \\) is 6. The abstract state corresponding to \\( r_1^\\alpha \\) is thus \\( (m, SI, SD) \\), where \\( SD \\), the ec-order on data and index variables, includes \\( v1 < v2 \\). Furthermore, let us suppose that the program is such that the abstract state \\( r_1^\\alpha \\) can transition (in a way that does not change the values of \\( v1 \\) and \\( v2 \\)) to an abstract state \\( r_2^\\alpha \\) that requires that another data variable \\( v3 \\) has a value greater than the value of \\( v1 \\), but smaller than the value of \\( v2 \\). Note now that the concrete state \\( r_1 \\) cannot transition to any state that would correspond to the order on data variables required by \\( r_2^\\alpha \\), because there is no value between 5 and 6.\n\nIn a key part of the proof, we show that if an abstract state \\( r_2^\\alpha \\) is reachable from \\( r_1^\\alpha \\), then there exists a state \\( r_1 \\) (abstracted by \\( r_1^\\alpha \\)) and a state \\( r_2 \\) (abstracted by \\( r_2^\\alpha \\)) such that \\( r_2 \\) is reachable from \\( r_1 \\). The main idea for proof by induction is that we can choose \\( r_1 \\) in such a way that the gaps between values are large enough. More precisely, if (1) \\( r_1^\\alpha \\) requires that e.g. \\( v1 > v2 \\) for two data variables \\( v1 \\) and \\( v2 \\) and (2) \\( r_2^\\alpha \\) is reachable from \\( r_1^\\alpha \\) in \\( k \\) steps, then it is sufficient to choose \\( r_1 \\) such that there are at least \\( 2^k - 1 \\) elements between \\( v1 \\) and \\( v2 \\).\n\nWe note that the proof applies to arbitrary linear orders (i.e. dense or not) on unbounded domains. The proof only requires (as explained in the previous paragraph) the existence of strictly increasing sequences of elements of unbounded length.\n\n**Remark.** In order to simplify the presentation of the proof, we make two assumptions: first, we assume that the length of the array is non-zero. (In the case the length of the array is zero, the program effectively contains no loops, and reachability can be computed in time polynomial in number of variables.) Second, we assume that there are no constants in \\( D \\) in the programs. At the end of this subsection, we will explain how the proof that follows can be extended to programs with constants from \\( D \\).\n\nWe now present the proof according to the above outline.\n\n**Transition system semantics.** We show that for programs that contain only non-nested loops and are in normal form, the semantics \\( [P] \\) can be represented by a triple \\( (e, T, f) \\), where \\( T = (R, \\delta \\subseteq R \\times (\\Sigma \\times D) \\times R, F) \\) is a transition system whose set of states is \\( R \\). The set \\( F \\subseteq R \\) is the set of final states. The transition relation \\( \\delta \\) will simulate executions of the loops that appear in the program. Its input will be, in addition to a state from \\( R \\), also a pair \\( (a, d) \\) from \\( (\\Sigma \\times D) \\) representing the current element of the input array. The relation \\( e \\) is a subset of \\( Q \\times R \\) and the\nrelation $f$ is a subset of $F \\times Q$. The relation $e$ will represent the loop-free part of the program before the first non-nested loop, and the relation $f$ will represent the loop-free part of the program after the last non-nested loop. Recall that for program in normal form, loops do not appear in branches of \\texttt{if} statements.\n\nWe define a function $[P]^{t}$ which for loop-free programs returns a binary relation over $Q$, and returns a triple $(e, T, f)$ for programs that contain non-nested loops. For a loop command we use the relation representing the (loop free) body of the loop to construct a transition system. For sequential composition of commands, a product construction augmented with some bookkeeping is used. Consider the case of two sequentially composed loops that iterate through the array: the transition system is a product of the transition systems defined by the two loops, and the bookkeeping part ensures that the second loop starts from a state where the first loop finished.\n\n**Construction of $[P]^{t}$.** For the following commands $P$: \\texttt{skip}, $v := E$, if $B$ then $P_1$ else $P_2$, if $*$ then $P_1$ else $P_2$, $[P]^{t}$ is defined by\n\n$$[P]^{t} = \\{(\\text{loc}(g), \\text{loc}(g'))|(g, g') \\in [P]\\}.$$ \n\nNote that for the conditionals, we have that $P_1$ and $P_2$ are loop-free. For loops and sequential composition we have the following, where $\\circ$ denotes composition of relations.\n\n- \\[\\text{for } i1:=1 \\text{ to } \\text{length}(A) \\text{ do } P1;P2 \\] \n - $[P1;P2]^{t}$ is defined as follows:\n 1. If $[P1]^{t} = f_1$ and $[P2]^{t} = f_2$, then $[P1;P2]^{t} = f_2 \\circ f_1$.\n 2. If $[P1]^{t} = f_1$ and $[P2]^{t} = (e_2, T_2, f_2)$, then $[P1;P2]^{t} = ((e_2 \\circ f_1), T_2, f_2)$.\n 3. If $[P1]^{t} = (e_1, T_1, f_1)$ and $[P2]^{t} = f_2$, then $[P1;P2]^{t} = (e_1, T_1, (f_2 \\circ f_1))$.\n 4. If $[P1]^{t} = (e_1, T_1, f_1)$ and $[P2]^{t} = (f_2, T_2, f_2)$, then $[P1;P2]^{t} = (e, T, f)$, where the components are defined as follows. Let $T_1 = (R_1, \\delta_1, F_1)$ and $T_2 = (R_2, \\delta_2, F_2)$. The transition system $T = (R, \\delta, F)$ is defined by: $R = R_1 \\times R_2 \\times R_2$, $((r_1, r_2, r_3), (a, d), (r_1', r_2', r_3')) \\in \\delta$ iff $(r_1, (a, d), r_1') \\in \\delta_1$, $r_2 = r_2'$, and $(r_3, (a, d), r_3') \\in \\delta_2$. A state $(r_1, r_2, r_3)$ is in $F$ if and only if $r_1 \\in F_1$, $r_3 \\in F_2$, and $(r_1, r_2) \\in (e_2 \\circ f_1)$. The function $e$ is defined in the following way: $(q, (r_1, r_2, r_3)) \\in e$ if and only if $r_2 = r_3$ and $(q, r_1) \\in e_1$. For the function $f$, we have $((r_1, r_2, r_3), q) \\in f$ if $(r_1, r_2, r_3) \\in F$ and $(q, r_3) \\in F_2$.\n\nWe now show that $[P]^{t} = (e, T, f)$ captures the semantics of $P$.\n\nGiven a transition system $T = (R, \\delta, F)$, where $\\delta$ is a subset of $R \\times (\\Sigma \\times D) \\times R$, we extend the definition of $\\delta$ to words in $(\\Sigma \\times D)^{*}$. We define a relation $\\delta^{*}$ on $R \\times (\\Sigma \\times D)^{*} \\times R$ as follows: for $w = w_1 \\ldots w_l$ we have that $(r, w, r') \\in \\delta^{*}$ iff $\\exists r_1, \\ldots, r_{l+1}$ such that $r = r_1$, $r' = r_{l+1}$ and for all $i$ such that $1 \\leq i \\leq l$ we have that $(r_i, w_i, r_{i+1}) \\in \\delta$.\n\nGiven a word $w$ in $(\\Sigma \\times D)^{*}$, we say that a state $q_2$ is reachable from $q_1$ in $[P]^{t}$ iff either (i) $[P]^{t} = e$ and $(q_1, q_2) \\in e$ or (ii) $[P]^{t} = (e, T, f)$, $T = (R, \\delta, F)$ and there exist $r_1, r_2 \\in R$ such that $(q_1, r_1) \\in e$, $(r_2, q_2) \\in f$, and $(r_1, w, r_2) \\in \\delta^{*}$. A boolean\nstate \\( m \\) is reachable in \\([P]^t\\) if there exist an initial local state \\( q_I \\), a local state \\( q \\) such that \\( \\text{bool}(q) = m \\) and \\( q \\) is reachable from \\( q_I \\) in \\([P]^t\\).\n\n**Lemma 3.3.** Given a program \\( P \\), a boolean state \\( m \\) is reachable if and only if \\( m \\) is reachable in \\([P]^t\\).\n\n**Proof.** We prove the following inductive claim. The lemma immediately follows.\n\n**Claim:** A local state \\( q_2 \\) is reachable from \\( q_1 \\) in \\([P]^t\\) if and only if there exist states \\( g_1 \\) and \\( g_2 \\) such that \\( \\text{loc}(g_1) = q_1 \\), \\( \\text{loc}(g_2) = q_2 \\), and \\( (g_1, g_2) \\in [P] \\).\n\nThe proof of the claim is by induction on the structure of the program \\( P \\). For the commands \\texttt{skip}, \\texttt{v := E}, \\texttt{if B then P1 else P2}, \\texttt{if \\ast then P1 else P2} and \\texttt{for i1:=1 to length(A) do P}, the lemma follows directly from the definition of \\([P]^t\\).\n\nLet us consider the inductive case, the sequential composition, i.e. \\( P \\) is \\( P_1 ; P_2 \\). We prove the left-to-right implication, i.e. we assume that a local state \\( q_2 \\) is reachable from \\( q_1 \\) in \\([P]^t\\). Let us assume that \\([P_1]^t = (e_1, T_1, f_1) \\) and \\([P_2]^t = (e_2, T_2, f_2) \\) (This is the case when both \\( P_1 \\) and \\( P_2 \\) contain loops. The other cases are simpler.)\n\nIf \\( q_2 \\) is reachable from \\( q_1 \\) in \\([P]^t\\), then by construction of \\([P]^t\\), there exists a state \\( q_m \\), such that \\( q_1 \\) is reachable from \\( q_1 \\) in \\([P_1]^t\\) and \\( q_2 \\) is reachable from \\( q_m \\) in \\([P_2]^t\\). By applying induction hypothesis twice, we obtain that there exist states \\( g_1, g_m \\) and \\( g_2 \\) such that \\( \\text{loc}(g_1) = q_1 \\), \\( \\text{loc}(g_m) = q_m \\), \\( \\text{loc}(g_2) = q_2 \\), and \\( (g_1, g_m, g_2) \\in [P] \\).\n\nFurthermore, if \\([P]^t = (e, T, f)\\) and \\( T = (R, \\delta, F) \\), we have that \\( R = Q^{2k-1} \\), where \\( k \\) is the number of loops in \\( P \\), as it can easily be shown that sequential composition is associative.\n\n**Abstract transition system.** We fix a program \\( P \\) for the rest of this subsection. Let \\([P]^t = (e, T, f)\\), where \\( T = (R, \\delta, F) \\), and \\( R = Q^{2k-1} \\). We show that we can find a finite state system \\( T^\\alpha \\) (and corresponding relations \\( e^\\alpha \\) and \\( f^\\alpha \\)) such that we can reduce reachability in \\( T \\) to reachability in \\( T^\\alpha \\). The main idea in the construction of the abstract transition system is that it will keep track of only the order of index and data variables, not their values.\n\nWe will need an abstract version of the set \\( Q \\). First, we define the notion of ec-order on a set of variables \\( V \\). An ec-order \\( \\rho = (\\equiv_\\rho, \\prec_\\rho) \\) is a pair where the first component is an equivalence relation on \\( V \\), and the second component is a total order on equivalence classes of \\( \\equiv_\\rho \\). For variables \\( v_1, v_2 \\), we write \\( v_1 \\prec_\\rho v_2 \\), if \\( v_1 \\) belongs to an equivalence class \\( c_1 \\), \\( v_2 \\) belongs to an equivalence class \\( c_2 \\), and \\( c_1 \\prec_\\rho c_2 \\). For example, if \\( V = \\{v_1, v_2, v_3\\} \\), all variables have a defined value, then a possible ec-order on \\( V \\) can be represented as \\( v_1 \\equiv_\\rho v_3 \\prec_\\rho v_2 \\).\n\nLet \\( IV \\) be the set of index and loop variables of \\( P \\). Let \\( DV \\) be the set of data variables of \\( P \\). An abstract state is a tuple \\((m, SI, SD)\\), where \\( m \\) is a boolean state in \\( M \\), \\( SI \\) is an ec-order on \\( IV \\) and \\( SD \\) is an ec-order on \\( DV \\cup IV \\). For example, if a program has an index variable \\( p_1 \\), a loop variable \\( i_1 \\) and a data variable \\( d_1 \\), a possible abstract state is \\((m, p_1 \\prec_{SI} i_1, p_1 \\equiv_{SD} i_1 \\prec_{SD} d_1)\\). This means that the program is in a boolean state \\( m \\), \\( p_1 \\) is less than \\( i_1 \\), and \\( A[p_1] \\) is equal to \\( A[i_1] \\) and is less than \\( d_1 \\). Let \\( Q^\\alpha \\) be the set of abstract states.\n\nACM Transactions on Computational Logic, Vol. V, No. N, Month 20YY.\nWe will also need an abstract version of \\( R \\), the set of states of \\( T \\). We consider sets \\( IV_R \\) and \\( DV_R \\), where there are \\( 2k - 1 \\) copies of each variable. Let \\( SI_R \\) be an ec-order on \\( IV_R \\) and let \\( SD_R \\) be an ec-order on \\( DV_R \\cup IV_R \\). We will consider the set \\( U = M^{2k-1} \\). Let \\( R^\\alpha \\) be the set of abstract states of the form \\((u, SI_R, SD_R)\\), where \\( u \\) is in \\( U \\).\n\nThe abstraction function \\( \\alpha_Q : Q \\to Q^\\alpha \\) can be defined straightforwardly: \\( \\alpha_Q(q) = (m, SI, SD) \\) iff \\( \\text{bool}(q) = m \\) and for all index and loop variables \\( p_1, p_2 \\), we have that \\( p_1 <_{SI} p_2 \\) iff \\( q[p_1] < q[p_2] \\), and \\( p_1 \\equiv_{SI} p_2 \\) iff \\( q[p_1] = q[p_2] \\). The definition is similar for \\( SD \\). We present the case of one index variable \\( p_1 \\) and one data variable \\( v_1 \\). We have that \\( p_1 <_{SD} v_1 \\) iff \\([A[p_1]] < q[v_1]\\), and \\( p_1 = v_1 \\) iff \\([A[p_1]] = q[v_1]\\). The abstraction function \\( \\alpha_R : R \\to R^\\alpha \\) is defined similarly.\n\nWe now define the abstract transition system. More precisely, we define \\( [P]^\\alpha = (e^\\alpha, T^\\alpha, f^\\alpha) \\) using \\([P]^\\alpha\\) as follows: Let \\( T^\\alpha = (R^\\alpha, \\delta^\\alpha, F^\\alpha) \\). The transition relation \\( \\delta^\\alpha \\subseteq R^\\alpha \\times R^\\alpha \\) is defined in a standard way: \\( \\delta^\\alpha(r^1_1, r^2_2) \\) iff there exist \\( r_1, r_2 \\) and a pair \\((a, d) \\in (\\Sigma \\times D)^*\\), such that \\((r_1, (a, d), r_2) \\in \\delta \\) and \\( \\alpha(r_1) = r^1_1 \\) and \\( \\alpha(r_2) = r^2_2 \\). The set \\( F^\\alpha \\) of final states is defined as follows: \\( r^\\alpha \\in F^\\alpha \\) iff there exists \\( r \\in F \\) and \\( \\alpha(r) = r^\\alpha \\). The relation \\( \\delta^{\\ast\\ast} \\) denotes the transitive closure of \\( \\delta^\\alpha \\). Given a relation \\( e \\) on \\( Q \\times R \\), we define its abstract version \\( e^\\alpha \\) on \\( Q^\\alpha \\times R^\\alpha \\) similarly to the definition of the abstract transition relation. Also, given a relation \\( f \\) on \\( R \\times Q \\), we define its abstract version \\( f^\\alpha \\) on \\( R^\\alpha \\times Q^\\alpha \\).\n\nThe following lemma is the key part of the proof. It relates reachability of a boolean state in the abstract and concrete systems.\n\n**Lemma 3.4.** For all \\( r^1_1, r^2_2 \\) in \\( R^\\alpha \\), we have that \\( \\delta^{\\ast\\ast}(r^1_1, r^2_2) \\) if and only if there exist \\( r_1, r_2 \\in R \\) and a word \\( w \\in (\\Sigma \\times D)^* \\) such that \\( \\alpha(r_1) = r^1_1 \\), \\( \\alpha(r_2) = r^2_2 \\), and \\( \\delta^\\ast(r_1, w, r_2) \\) then \\( \\delta^{\\ast\\ast}(r^1_1, r^2_2) \\). We only need to apply the definition of \\( \\delta^{\\ast\\ast} \\) inductively.\n\n**Proof.** It is straightforward to prove that if there exist \\( r_1, r_2 \\) and \\( w \\) such that \\( \\alpha(r_1) = r^1_1 \\), \\( \\alpha(r_2) = r^2_2 \\), and \\( \\delta^\\ast(r_1, w, r_2) \\) then \\( \\delta^{\\ast\\ast}(r^1_1, r^2_2) \\). We only need to apply the definition of \\( \\delta^{\\ast\\ast} \\) inductively.\n\nThe proof of the other implication uses induction on the length of the path from \\( r^1_1 \\) to \\( r^2_2 \\). We will also need the following notion: The relation \\( \\text{Gap}(r, o) \\) holds for \\( r \\in R \\) and \\( o \\in \\mathbb{N} \\) iff for all data variables (and values pointed to by index variables) \\( v_1, v_2 \\), we have that if \\( r[v_1] > r[v_2] \\), then the cardinality of the set \\( \\{d \\in D \\mid r[v_1] > d > r[v_2]\\} \\) is greater than or equal to \\( o \\). Furthermore, if the set \\( D \\) has a minimal element \\( b \\), we require that for all data variables (and values pointed to by index variables) \\( v_1 \\), we have that the cardinality of the set \\( \\{d \\in D \\mid r[v_1] > d > b\\} \\) is greater than or equal to \\( o \\). There is an analogical requirement for the case when \\( D \\) has a maximal element.\n\nThe relation \\( \\delta_k^\\alpha(r^1_1, r^2_2) \\) is defined as follows: \\( \\delta_0^\\alpha(r^1_1, r^2_2) \\) if there exists a state \\( r^3_3 \\in R^\\alpha \\) such that \\( \\delta^\\alpha(r^3_3, r^1_1) \\) and \\( \\delta^{\\ast\\ast}_{k-1}(r^3_3, r^2_2) \\) for \\( k > 1 \\); and \\( \\delta_1^\\alpha = \\delta^\\alpha \\).\n\nWe will prove the following inductive claim: If \\( \\delta_k^\\alpha(r^1_1, r^2_2) \\), then for all \\( r_1 \\) such that \\( \\alpha_R(r_1) = r^1_1 \\) and \\( \\text{Gap}(r_1, 2^k - 1) \\), there exists \\( r_2 \\) and a word \\( w \\in (\\Sigma \\times D)^k \\), such that \\((r_1, w, r_2) \\in \\delta \\), and \\( \\alpha_R(r_2) = r^2_2 \\).\n\nThe base case, where \\( k = 0 \\) is straightforward. The inductive case, suppose that \\( \\delta_k^\\alpha(r^1_1, r^2_2) \\). Then there exists a state \\( r^3_3 \\in R^\\alpha \\) such that \\( \\delta^\\alpha(r^3_3, r^1_1) \\) and \\( \\delta^{\\ast\\ast}_{k-1}(r^3_3, r^2_2) \\). Let \\( r_1 \\) be such that \\( \\alpha(r_1) = r^1_1 \\) and \\( \\text{Gap}(r_1, 2^k - 1) \\). (It is easy to show that such \\( r_1 \\) exists for all \\( r^1_1 \\).) We need to find a state \\( r_3 \\in R \\) and a\npair \\((a, d) \\in \\Sigma \\times D\\) such that (i) \\((r_1, (a, d), r_3) \\in \\delta\\), (ii) \\(\\alpha_R(r_3) = r_3^a\\) and (iii) \\(\\text{Gap}(r_3, 2^{k-1} - 1)\\).\n\nInformally, the transition can require that the data value \\(d\\) of the current position (the position pointed to by the loop variable) has to be between two stored values, but as \\(\\text{Gap}(r_1, 2^k - 1)\\) holds, we can always choose \\(d\\) such that we ensure that \\(\\text{Gap}(r_3, 2^{k-1} - 1)\\). More precisely, we construct \\(r_3\\) as follows: By definition of \\(\\delta^a\\), there exists \\(r_3^a\\), and a pair \\((a', d')\\) such that the properties (i) and (ii) hold for these values. Let us now compare the value \\(d'\\) with the data values of \\(r_1\\). Let \\(\\text{Data}(r)\\) be the set of data values that appear in the valuation of data variables given by a state \\(r\\). Let \\(r_1^a, r_2^a, \\ldots, r_l^a\\) be all the distinct data values in \\(\\text{Data}(r_1)\\). Let us assume that \\(r_1^a < r_{1,j}^a\\), for all \\(j\\). We now proceed by case analysis. First, if \\(d'\\) is equal to one of the values \\(r_1^a, r_2^a, \\ldots, r_l^a\\), then the property (iii) holds for \\(r_3^a\\), and \\((a', d')\\). This is because in this case, \\(\\text{Data}(r_3) \\subseteq \\text{Data}(r_1)\\). Second, let us consider the case where there exists \\(j\\) such that \\(r_1^a < d' < r_{1,j}^a\\). In this case, we consider the data value \\(d\\) such that the cardinality of \\(\\{d' \\in D \\mid d < d' > r_1^a\\}\\) is greater than or equal to \\(2^{k-1} - 1\\), and the cardinality of \\(\\{d' \\in D \\mid r_{1,j}^a > d' > d\\}\\) is also greater than or equal to \\(2^{k-1} - 1\\). Finding such a value \\(d\\) is possible, as we have that \\(\\text{Gap}(r_1, 2^{k-1} - 1)\\).\n\nLet us now consider \\(a', d\\) and \\(r_3\\) such that \\((r_1, (a', d), r_3) \\in \\delta\\) (such an \\(r_3\\) exists, as we have \\((r_1, (a', d'), r_3^a) \\in \\delta\\)). We now have that all three properties (i), (ii), and (iii) hold for \\(a', d\\) and \\(r_3\\), because \\(\\text{Data}(r_3) \\setminus \\{d\\} \\subseteq \\text{Data}(r_1)\\), and because of how \\(d\\) was chosen. The value \\(d\\) is chosen analogically if \\(d'\\) is smaller (greater) then the smallest (greatest) value in the set \\(\\text{Data}(r_1)\\).\n\nAs we constructed \\(r_3\\) such that the property (iii) holds, we can conclude by using induction hypothesis for \\(\\delta^a_{k-1}(r_3^a, r_2^a)\\). □\n\nA boolean state \\(m\\) is reachable in \\([P]^a\\) if there exists an initial state \\(q_1\\), an abstract state \\(q_2^a\\) such that \\(\\alpha(\\text{loc}(q_1)) = q_2^a\\), and states \\(q_3^a \\in Q^a, r_1^a, r_3^a \\in R^a\\) such that \\((q_2^a, r_1^a) \\in e^a, \\delta^a(r_1^a, r_2^a), (r_2^a, q_3^a) \\in f^a, \\text{ and } \\text{bool}(q_3^a) = m\\).\n\nThe next lemma follows from Lemmas 3.3 and 3.4.\n\n**Lemma 3.5.** Given a program \\(P\\), a boolean state \\(m\\) is reachable if and only if it is reachable in \\([P]^a\\).\n\nAs noted above, we presented the proof for programs without constants in \\(D\\). The proof can be extended to programs with constants in a straightforward way: Let \\(c_1\\) be the smallest and let \\(c_2\\) be the greatest constant that a given program \\(P\\) uses. The abstract system \\([P]^a\\) will need to track the values between \\(c_1\\) and \\(c_2\\) precisely, and track only the order between the stored values for values less than \\(c_1\\) or greater than \\(c_2\\). The resulting system will thus still have a finite number of states (the number of states will be polynomial in the largest constant \\(c_2\\)).\n\n**Proof (of Theorem 3.2).** Using Lemma 3.5, we reduce the reachability problem for ND1 programs to a reachability problem in a finite state system. Reachability in a finite state system is in NLOGSPACE. This means that the reachability problem for ND1-program is in PSPACE, as the number of states in \\(T^a\\) is exponential in the number of variables in the program. Furthermore, given two abstract states, \\(r_1^a\\) and \\(r_2^a\\), one can decide (in polynomial time in the number of variables), whether the tuple \\((r_1^a, r_2^a)\\) is in \\(\\delta^a\\).\nIn order to show that the problem is PSPACE-hard, we can reduce Succinct-Reachability (see [Papadimitriou 1994]) to our reachability problem. Note that the resulting instance will use only boolean variables, not data or index variables.\n\nA succinct representation of a graph with \\( n \\) nodes, where \\( n = 2^b \\) is a power of two, is a Boolean circuit \\( C \\) with \\( 2^b \\) input gates. The graph represented by \\( C \\), denoted \\( \\text{G}_C \\), is defined as follows: The nodes of \\( \\text{G}_C \\) are \\( \\{1, 2, \\ldots, n\\} \\). And \\([i, j]\\) is an edge of \\( \\text{G}_C \\) if and only if \\( C \\) accepts the binary representation of the \\( b \\)-bit integers \\( i \\) and \\( j \\) as inputs. The Succinct-Reachability problem is as follows: given a succinct representation of a graph, and a vertex \\( r \\) represented as a \\( b \\)-bit integer, is \\( r \\) reachable from vertex 1?\n\nGiven a succinct representation of a graph \\( \\text{G}_C \\) by a circuit \\( C \\), we construct a program \\( P \\) as follows: \\( P \\) consists of a single loop over an input array. The body of the loop nondeterministically encodes the edges of \\( \\text{G}_C \\), using \\( 2^b \\) boolean variables. More precisely, there are \\( b \\) variables encoding the current vertex, and in the body of the loop there is a program that can be described on a higher level as follows: (i) nondeterministically choose vertex \\( j \\) followed by (ii) if (current == \\( i \\) and \\( C[i,j] \\)) then current = \\( j \\). Each execution of the body of the loop thus amounts to traversing one edge of the graph. Furthermore, at the end of the body of the loop, there is a test whether the execution reached vertex \\( r \\). If the test succeeds, a specific boolean state \\( m \\) is entered. In \\( m \\), a boolean variable \\( f \\) is set to \\text{true} and all the other variables are set to \\text{false}. The \\text{ND1}-program can be constructed in polynomial time given the circuit \\( C \\). The state \\( m \\) is reachable if and only if the vertex \\( r \\) is reachable in \\( \\text{G}_C \\). This completes the proof of the lower bound.\n\n4. PROGRAMS, AUTOMATA AND LOGICS ON DATA WORDS\n\nIn this section, we will examine the decidability boundary for array-accessing programs, and compare the expressive power of these programs to that of logics and automata on data words. We will show that the reachability problem for Restricted-\\text{ND2} programs is decidable, and that it is undecidable for full \\text{ND2} programs. We start by reviewing the results on automata and logics on data words, as these will be needed for the decidability proof. We will reduce the reachability problem for Restricted-\\text{ND2} programs to the nonemptiness problem of extended data automata, a new variation of data automata. The latter is a definition intended to correspond to the notion of regular automata on finite words.\n\n4.1 Background\n\nWe briefly review the results on automata and logics on data words from [Bojańczyk et al. 2006]. Recall that a data word is a sequence of pairs \\( \\Sigma \\times D \\). A data language is a set of data words. Let \\( w \\) be a data word \\( (a_1, d_1)(a_2, d_2) \\ldots (a_n, d_n) \\). The string \\( \\text{str}(w) = a_1 a_2 \\ldots a_n \\) is called the string projection of \\( w \\). Given a data language \\( L \\), we write \\( \\text{str}(L) \\) to denote the set \\( \\{ \\text{str}(w) \\mid w \\in L \\} \\). A class is a maximal set of positions in a data word with the same data value. Let \\( S(w) \\) be the set of all classes of the data word \\( w \\). For a class \\( X \\) in \\( S(w) \\) with positions \\( i_1 < \\ldots < i_k \\), the class string \\( \\text{str}(w, X) \\) is \\( a_{i_1} \\ldots a_{i_k} \\).\n\nData automata. A data automaton (DA) \\( A = (G, C) \\) consists of a transducer \\( G \\) and a class automaton \\( C \\). The transducer \\( G \\) is a nondeterministic finite-state\nletter-to-letter transducer from $\\Sigma$ to $\\Gamma$ and $C$ is a finite-state automaton on $\\Gamma$. A data word $w = (a_1, d_1)(a_2, d_2)\\ldots(a_n, d_n)$ is accepted by a data automaton $A$ if there is an accepting run of $G$ on the string projection of $w$, yielding an output string $b = b_1\\ldots b_n$, and for each class $X$ in $S(w')$, the class automaton $C$ accepts $str(w', X)$, where $w' = w'_1\\ldots w'_n$ is defined by $w'_i = (b_i, d_i)$, for all $i$ such that $1 \\leq i \\leq n$. Given a DA $A$, $L(A)$ is the language of data words accepted by $A$. The nonemptiness problem for data automata is decidable. The proof is by reduction to a computationally complex problem, the reachability problem in Petri nets.\n\n**Logics on data words.** We define logics whose models are data words. We consider two predicates on positions in a data word whose definition also involves the data values at these positions. The predicate $i \\approx j$ is satisfied if both positions $i$ and $j$ have the same data value. The predicate $i \\prec j$ is satisfied if the data value at position $i$ is smaller than the data value at position $j$. Furthermore, standard successor (+1) and order ($<$) predicates on positions in a data word are used. We consider first order logic with $k$ variables, denoted by $\\text{FO}_k$. Similarly, $\\text{EMSO}_k$ stands for $\\text{FO}_k$ formulas preceded by a number of existential quantifications over sets of word positions.\n\nThe results in this paragraph are from [Bojańczyk et al. 2006]. Let us first consider logics that use the $\\approx$ predicate and not the $\\prec$ predicate. We first note that for a first order logic $\\text{FO}(\\approx, <, +1)$ satisfiability is undecidable, even if we restrict the number of variables to three. If we restrict the number of variables to two, the logic becomes decidable, and the proof is by reduction to the nonemptiness problem of data automata. The decidability naturally extends to existentially quantified second order monadic logic with two first order variables, denoted by $\\text{EMSO}^2(\\approx, +1, \\oplus 1)$. Moreover, $\\text{EMSO}^2(\\approx, +1, \\oplus 1)$ is precisely equivalent in expressive power to data automata. The predicate $\\oplus 1$ denotes the class successor, and $i \\oplus 1 = j$ is satisfied if $i$ and $j$ are two successive positions in the same class of the data word.\n\nFurthermore, the logic $\\text{EMSO}^2(\\approx, <, +\\omega, \\oplus 1)$ is included in $\\text{EMSO}^2(\\approx, +1, \\oplus 1)$. The symbol $+\\omega$ represents all predicates of the form $+k$, $k \\in \\mathbb{N}$, i.e. the logic includes all predicates $i + 2 = j$, $i + 3 = j$, etc.\n\n**Example 4.1.** Consider the following data automaton $A$. The transducer of $A$ computes the identity function, i.e. it accepts all words and its output string is the same as its input string. The class automaton ensures, for each class, that the class contains exactly one occurrence of $a$, one occurrence of $b$ and one occurrence of $c$. For $A$, we have that $str(L(A))$, the set of string projections, is exactly the set of all words over $\\{a, b, c\\}$ that contain the same number of $as$, $bs$, and $cs$.\n\n4.2 Extended data automata\n\n**Position-preserving class string** Note that the class automaton does not know the positions of symbols in the word $w$. The symbols from other classes have simply been erased. However, let us consider a program with a doubly-nested loop:\n\n```plaintext\nfor i:= 1 to length(A) do\n for j:= 1 to length(A) do {\n if (A[i].d=A[j].d) then P1 else P2\n }\n```\n\nACM Transactions on Computational Logic, Vol. V, No. N, Month 20YY.\nThe inner loop of the program scans the array from left to right and modifies the state in two different ways (given by P1 and P2), depending on whether (A[i].d=A[j].d) holds or not. The inner loop tests (A[i].d=A[j].d) and can thus be seen operating in a similar setting as the class automaton of a DA. The analogy does not quite work, because the class string is obtained by simply erasing all positions from other classes, whereas the inner loop scans the whole array. We thus define an extension of the notion of class string and a corresponding extension of the class automaton.\n\nGiven a data word \\( w \\in (\\Sigma \\times D)^* \\), a position-preserving class string \\( pstr(w, X) \\) is a string over \\( \\Sigma \\cup \\{0\\} \\). (We assume that \\( 0 \\notin \\Sigma \\).) Let \\( w = w_1w_2\\ldots w_n \\), let \\( i \\) be a position in \\( w \\), and let \\( w_i \\) be \\((a_i, d_i)\\). The string \\( v = pstr(w, X) \\) has the same length as \\( w \\), and for \\( v_i \\), we have that \\( v_i = a_i \\) if \\( i \\in X \\), and \\( v_i = 0 \\) otherwise. That is, for each position \\( i \\) which does not belong to \\( X \\), the symbol from \\( \\Sigma \\) at the position \\( i \\) is replaced by \\( 0 \\).\n\nAn extended data automaton (EDA) \\( E = (G, C) \\) consists of a transducer \\( G \\) and a class automaton \\( C \\). The transducer \\( G \\) is a finite-state letter-to-letter transducer from \\( \\Sigma \\) to \\( \\Gamma \\) and \\( C \\) is a finite-state automaton over \\( \\Gamma \\cup \\{0\\} \\). A data word \\( w = w_1\\ldots w_n \\) is accepted by the EDA \\( E \\) if there is an accepting run of \\( G \\) on the string projection of \\( w \\), yielding an output string \\( b = b_1\\ldots b_n \\), and for each class \\( X \\) in \\( \\mathcal{S}(w') \\), the class automaton \\( C \\) accepts \\( pstr(w', X) \\), where \\( w' = w'_1\\ldots w'_n \\) is defined as follows: \\( w'_i = (b_i, d_i) \\), for all \\( i \\) such that \\( 1 \\leq i \\leq n \\). Given an EDA \\( E \\), \\( L(E) \\) is the language of data words accepted by \\( E \\).\n\n**Example 4.2.** We consider \\( L \\), a language of data words defined by the following property: A data word \\( w \\) is in \\( L \\) iff for every class \\( X \\) in \\( \\mathcal{S}(w) \\), we have that between every two successive positions in the class, there is exactly one position from another class. We show that there exists an EDA \\( E = (G, C) \\) such that \\( L(E) = L \\). The transducer \\( G \\) computes the identity function. The class automaton \\( C \\) is given by the following regular expression: \\( 0^*(\\Sigma 0)^*0^* \\). It is easy to see that \\( E \\) accepts \\( L \\).\n\nWe first note that for each DA \\( A \\), it is easy to find an EDA \\( E \\) such that \\( L(E) = L(A) \\). We just modify the class automaton \\( C \\), by adding the tuple \\((q, 0, q)\\), for each \\( q \\), to the transition relation. This means that on reading \\( 0 \\) the state of the class automaton does not change.\n\nWe will also show in this section that for each EDA \\( E \\) we can find an equivalent DA \\( A \\). This might not be obvious at a first glance, as class automata of DAs do not get to see the distances between positions in a class. Indeed, we show that the language from Example 4.2 cannot be captured by a deterministic DA. However, we show that EMSO\\(^2\\)(\\( \\approx, +1, \\oplus 1 \\)) and EDAs are expressively equivalent, and since EMSO\\(^2\\)(\\( \\approx, +1, \\oplus 1 \\)) and DAs are also expressively equivalent, we conclude that for every EDA there exists a DA that accepts the same language. Showing that for every EDA there exists an equivalent EMSO\\(^2\\)(\\( \\approx, +1, \\oplus 1 \\)) formula also establishes that non-emptiness is decidable for EDAs. However, the proof of decidability of satisfiability of EMSO\\(^2\\)(\\( \\approx, +1, \\oplus 1 \\)) formulas is rather involved. We present a direct proof for decidability of emptiness for EDAs, as it gives an intuitive reason why emptiness is decidable for EDAs. This is the second main result of the paper.\nTHEOREM 4.3. Given an EDA $\\mathcal{E}$, it is decidable whether $L(\\mathcal{E}) = \\emptyset$.\n\nPROOF. Given an EDA $\\mathcal{E}$, we construct a multicounter automaton $V$, such that $L(\\mathcal{E})$ is empty if and only if $L(V)$ is empty. The emptiness problem is decidable for multicounter automata. The proof in [Bojańczyk et al. 2006] of decidability of emptiness of data automata also uses reduction to emptiness of multicounter automata. We extend the reduction.\n\nWe start by describing a more operational view of EDAs. Let $\\mathcal{E} = (G, C)$ be an EDA, let $G$ be defined by a tuple $(Q_G, \\Sigma, \\Gamma, \\delta_G, q_0^G, F_G)$, and let $C$ be defined by a tuple $(Q_C, \\Gamma, \\delta_C, q_0^C, F_C)$. A run of an EDA on a data word $w$ is a function $\\varrho$ from positions in $w$ to tuples of the form $(q, o, c)$, where $q \\in Q_G$ is a state of the transducer $G$, $o$ (a symbol from $\\Gamma$) is the output of the transducer, and $c$ is a function from $S(w)$ to $Q_C$, the set of states of $C$. Furthermore, we require that $\\varrho$ is consistent with $\\delta_G$ and $\\delta_C$, the transition functions of $G$ and $C$. We define $\\varrho(0)$ to be $(q_0^G, \\gamma, \\lambda X, q_{00}^C)$, i.e. the transducer and all the copies of the class automaton are in initial states. Furthermore, for each position $i$, $\\varrho(i)$ is equal to $(q', o', c')$ if and only if $w_i = (a, d)$, $\\varrho(i - 1) = (q, o, c)$ and (i) $(q', o') \\in \\delta_G(q, a)$, (ii) for the unique $X$ such that $i \\in X$ we have $c'(X) \\in \\delta_C(c(X), o')$, (iii) for $X$ such that $i \\notin X$ we have $c'(X) \\in \\delta_C(c(X), 0)$.\n\nA run is accepting iff $\\varrho(n) = (q, o, c)$, $q$ is a final state of $G$ and for all $X \\in S(w)$, we have that $c(X)$ is a final state of $C$.\n\nLet us consider the class automaton $C$. Without loss of generality, we suppose that $C$ is a complete deterministic automaton on $\\Gamma \\cup \\{0\\}$. The transition function $\\delta_C$ defines a directed graph $C_0$ with states of $C$ as vertices and 0-transitions as edges, i.e. there is an edge $(p_1, p_2)$ in $C_0$ if and only if $\\delta_C(p_1, 0) = p_2$. Every vertex in $C_0$ has exactly one outgoing edge (and might have multiple incoming edges). Therefore, each connected component of $C_0$ has exactly one cycle. A vertex is called cyclic if it is part of a cycle, and it is called non-cyclic otherwise. It is easy to see that each connected component is formed by the cyclic vertices and their 0-ancestors. An example of a connected component is in Figure 3. The vertex labeled $q_6$ is cyclic, its ancestors $q_9, q_{10}, q_{11}$ are non-cyclic.\n\nThe graph $C_0$ consists of a number of connected components. We denote these components by $C_0^j$, for $j \\in [1..k]$, where $k$ is the number of the components. Let $W$ be the set of all non-cyclic vertices. For each non-cyclic vertex $v$, let $D(v)$ be defined as follows: $D(v) = d$ for non-cyclic vertices connected to a cycle, where $d$\nis the length of the unique path connecting $v$ to the closest cyclic vertex. For the graph $C_0$, we define $D(C_0)$ to be $\\max_{v \\in W} D(v)$.\n\nLet $i$ be a position in a data word $w$. The data word $w_1 w_2 \\ldots w_i$ is denoted by $\\text{prefix}(w, i)$. Let us consider a position $i$ in a data word $w$ and the set of classes $S(w)$. Let $S_{\\text{act}}(w, i)$ be a set of active classes, i.e., classes $X$ such that there is a position in $X$ to the left of the position $i$. More formally, a class $X \\in S(w)$ is in $S_{\\text{act}}(w, i)$ if the string $\\text{str}(\\text{prefix}(w, i), X)$ is not equal to 0'.\n\n**Lemma 4.4.** Let $g$ be a run of $E$ on $w$. Let $i$ be a position in $w$. Let $g(i)$ be $(q, o, c)$. The number $N$ of classes $X$, such that $X$ is in $S_{\\text{act}}(w, i)$ and $c(X)$ is a noncyclic vertex, is bounded by $D(C_0)$, i.e. $N \\leq D(C_0)$.\n\n**Proof.** Let $i$ be a position in a word $w$. If $i \\leq D(C_0)$, then the number of active classes is at most $D(C_0)$, and we conclude immediately.\n\nLet us consider the case $i \\geq D(C_0)$. Let $g(i)$ be $(q, o, c)$ and let $s$ be the string of length $D(C_0)$ defined by $s = w_1 \\ldots w_{i-D(C_0)} w_{i+1} \\ldots w_{i+D(C_0)}$. There are two possible cases for each class $X$ in $S(w)$:\n\n$- \\text{pstr}(s, X) = 0^{D(C_0)}$. Let $g(i-D(C_0)) = (q', o', c')$, and let $c'(X) = v$. We can easily prove that $\\delta_X^c(p, 0^v)$ is not in $W$, for all $p$ and for all $e \\geq D(p)$. By definition, $D(C_0) \\geq D(q')$. Therefore, we can conclude that $c(X) \\notin W$.\n\n$- \\text{pstr}(s, X) \\neq 0^{D(C_0)}$. This is true for at most $D(C_0)$ classes, because, for all positions $x$, there is exactly one class $X$, such that the symbol at the position $x$ of the class string $\\text{pstr}(s, X)$ is not 0.\n\nTherefore we have that $c(X) \\in W$ for at most $D(C_0)$ classes. $\\square$\n\nWe reduce emptiness of EDAs to emptiness of multicounter automata. Multicounter automata are equivalent to Petri nets [Gischer 1981], and thus the emptiness of multicounter automata is decidable. We use the definition of multicounter automata from [Bojańczyk et al. 2006].\n\nA **multicounter automaton** is a finite, non-deterministic automaton extended by a number $k$ of counters. It can be described as a tuple $(Q, \\Sigma, k, \\delta, q_1, F)$. The set of states $Q$, the input alphabet, the initial state $q_1 \\in Q$ and final states $F \\subseteq Q$ are as in a usual finite automaton.\n\nThe transition relation is a subset of $Q \\times (\\Sigma \\cup \\{\\varepsilon\\}) \\times \\{\\text{inc}(i), \\text{dec}(i)\\} \\times Q$. The idea is that in each step, the automaton can change its state and modify the counters, by incrementing or decrementing them, according to the current state and the current letter on the input (which can be $\\varepsilon$). Whenever it tries to decrement a counter of value zero the computation stops and rejects. The transition of a multicounter automaton does not depend on the value of the counters in any other way. In particular, it cannot test whether a counter is exactly zero. Nevertheless, by decrementing a counter $v$ times and incrementing it again afterward it can check that the value of that counter is at least $v$.\n\nA **configuration** of a multicounter automaton is a tuple $(q, (c_i)_{1 \\leq i \\leq n})$, where $q \\in Q$ is the current state and $c_i \\in N$ is the value of the counter $i$. A transition $(p, e, \\text{inc}(i), q) \\in \\delta$ can be applied if the current state is $p$. For $a \\in \\Sigma$, a transition $(p, a, \\text{inc}(i), q) \\in \\delta$ can be applied if furthermore the current letter is $a$. In the successor configuration, the state is $q$, while each counter value is the same as...\nbefore, except for counter $i$, which now has value $c_i + 1$. Similarly, a transition $(p, a, \\text{dec}(i), q) \\in \\delta$ with $a \\in \\Sigma \\cup \\{\\epsilon\\}$ can be applied if the current state is $p$, the current letter is $a$, if $a \\in \\Sigma$, and counter $i$ is non-zero. In the successor configuration, all counter values are unchanged, except for counter $i$, which now has value $c_i = c_i - 1$. A run over a word $w$ is a sequence of configurations that is consistent with the transition function. A run is accepting if it starts in the state $q_I$ with all counters empty and ends in a configuration where all counters are empty and the state is final.\n\n**Lemma 4.5.** Let $E$ be an EDA. A multicounter automaton $V$ such that $\\text{str}(L(E)) = L(V)$ can be computed from $E$.\n\n**Proof.** We present the construction of a multicounter automaton $V$ that simulates $E$. The multicounter automaton $V$ simulates the transducer $G$ and a number of copies of $C$. There is one copy per class in $S(w)$, where $w$ is the word the automaton is reading. We say that a class automaton performs a 0-transition if the input symbol it reads is 0, and it performs a $\\Gamma$-transition if the input symbol it reads is from $\\Gamma$. Intuitively, at each step, the automaton $V$:\n\n1. Simulates the transducer $G$ using the finite state part (i.e. not the counters).\n2. It guesses to which class the current position belongs, and it executes the $\\Gamma$-transition of the automaton for that class with the symbol that is the output of the transducer at this step. For all the other simulated automata, $V$ executes the 0-transition. (This is sufficient because each position belongs to exactly one equivalence class.)\n\nThe counters of the multicounter automaton $V$ correspond to the cyclic vertices in $C_0$. (In what follows, we call a state of $C$ (non-)cyclic if it corresponds to a (non-)cyclic vertex in $C_0$.) The value of the counter $h$ corresponds to the number of copies of $C$ currently in the state $h$. The finite part of the automaton state tracks the number of copies in each non-cyclic state. The key idea of the proof is that the total number of copies in non-cyclic states is finite and bounded (by $D(C_0)$). This fact is implied by Lemma 4.4.\n\nFurthermore, one copy $e$ of the class automaton is used to keep track of all the classes that are not active yet, i.e. not in $\\mathcal{S}_{\\text{act}}(w, i)$ at step $i$ - thus when a position-preserving class string contains a symbol in $\\Gamma$ for the first time, a new copy of the automaton $C$ is started from the state at which the copy $e$ is.\n\nLet $\\gamma \\in \\Gamma$ be the current input symbol. The automaton works as follows: The first step consists of the automaton $V$ nondeterministically guessing the equivalence class $X$ to which the current position belongs. The copy of the class automaton for $X$ is then set aside while the second step is performed. That is, if the copy is in state $s$, then $s$ is remembered in a separate part of the finite state. In the second step, the automaton $V$ simulates 0-transitions for all the other copies (other than the copy that performed the $\\Gamma$-transition). For copies in non-cyclic states, this is done by a transition modifying the finite state of $V$. The copies that transition from a non-cyclic to a cyclic state are dealt with by modifying the finite state and increasing the corresponding counter. The copies in cyclic states are tracked in the counters. Note that if we restrict the graph to only cyclic states, each state has exactly one incoming and one outgoing 0-edge. For all the copies in cyclic\nstates, the 0-transition is accomplished by ‘relabeling’ the counters. This is done by remembering in the the finite state of $V$ for each loop for one particular state to which counter it corresponds. This is then shifted in the direction of the 0-transition.\n\nThe third step is to perform the $\\Gamma$ transition for the class $X$. For the copy of the automaton corresponding to this class, a $\\Gamma$-transition is performed. That is, if it is in state $q$, and $\\delta(q, \\gamma) = q'$, then there are four possibilities:\n\n- If $q, q'$ are cyclic states, the counter corresponding to $q$ is decreased and the counter corresponding to $q'$ is increased.\n- If $q, q'$ are non-cyclic state, a transition that changes the state of $V$ is made.\n- If $q$ is a cyclic state and $q'$ is a non-cyclic state, the counter corresponding to $q$ is decreased, and the finite state of $V$ is changed to reflect that the number of copies in $q'$ has increased.\n- If $q$ is a noncyclic state and $q'$ is a cyclic state, the transition is simulated similarly.\n\nThis concludes the proof of Lemma 4.5. □\n\nLemma 4.5 reduces the emptiness problem for EDAs to the emptiness problem for multicounter automata. As the latter is decidable, we can conclude the proof of Theorem 4.3. □\n\n4.3 Restricted doubly-nested loops\n\nLanguage of a program. Given a program and a boolean state $m$, the language $L_m(P)$ is the set of data words $w$, such that there exist an initial state $g$ and a state $g$, such that $g[A] = w$, $bool(g) = m$, and $(g, g) \\in [P]$. In order to define the language of a program, we extend the notion of a program by designating one of its boolean state as the final state. The language $L(P)$ is defined by $L(P) = L_m(P)$ where $m$ is the final state. We say that a program $P$ accepts the language $L(P)$.\n\n**Theorem 4.6.** Reachability for Restricted-$ND2$ programs is decidable.\n\n**Proof.** We will reduce the reachability problem of Restricted-$ND2$ programs to the emptiness problem of EDAs. The main idea of the proof is that the transducer $G$ guesses an accepting run of the outer loop, while the class automaton $C$ checks that the inner loop can be executed in a way that is consistent with the guess of the transducer.\n\nWe present the proof for programs where the loops are not sequentially composed. We assume a program $P$ of the following form:\n\n```plaintext\nfor i := 1 to length(A) do {\n P1;\n for j := 1 to length(A) do P2;\n P3\n}\n```\n\nwhere $P1$, $P2$, $P3$ are loop free programs. We present the proof for programs of this form. It can be extended for general Restricted-$ND2$ programs (which allow sequential composition of loops) using product construction techniques similar to those from the proof of Theorem 3.2. Similarly to the proof of Theorem 3.2, we\nAssume that that the length of the array is non-zero. (In the case the length of the array is zero, the program effectively contains no loops, and reachability can be computed in time polynomial in number of variables.) Recall that according to the definition of Restricted-ND2 programs, P2 must be of the following form: if A[11].d=A[j1].d then P21 else P22, where P22 cannot contain A[11].d or A[11].s.\n\nGiven a boolean state \\( m_r \\), we construct an EDA \\( \\mathcal{E} = (G, C) \\) such that \\( w \\in L_m, (P) \\) iff \\( w \\in L(\\mathcal{E}) \\).\n\nThe task of the transducer \\( G \\) is to guess an accepting run of the outer loop. The output alphabet \\( \\Gamma \\) of the transducer consists of tuples in \\( \\Sigma \\times M \\times M \\times V \\), where \\( M \\) is the set of boolean states of the program \\( P \\). The set \\( V \\) is defined as \\( V_C \\cup V'_C \\cup \\{ e \\} \\), with \\( e \\notin V \\). The set \\( V_C \\) is the set of all constants from \\( D \\) that appear in the program \\( P \\). The set \\( V'_C \\) contains a symbol \\( c' \\) for each \\( c \\in V_C \\). The symbol \\( e \\) will represent the fact that the current input is not equal to any of the constants in the program.\n\nIf a position \\( i \\) is marked with \\((a_i, m, m', v)\\), the class automaton corresponding to class \\( X \\) such that \\( i \\in X \\) will verify that if the inner loop, which ran when the loop variable of the outer loop pointed to \\( i \\), was started at \\( m \\), then it will finish at \\( m' \\).\n\nFirst, let us summarize the effect of the loop-free subprograms \\( P_1 \\) and \\( P_3 \\) by relations \\( f_1, f_3 \\subseteq M \\times (\\Sigma \\times V) \\times M \\). The programs \\( P_1 \\) and \\( P_3 \\) can access the boolean state, read the value \\([A[11].s]\\), compare the value \\([A[11].d]\\) to constants, and modify the boolean state.\n\nThe transducer reads a word \\( a_1 a_2 \\ldots a_l \\in \\Sigma^* \\), and produces a word \\( b_1 b_2 \\ldots b_l \\in \\Gamma^* \\) such that:\n\n1. \\( b_1 = (a_1, m, m', v) \\), for some \\( m \\) such that there exists a global state \\( g_l \\) such that \\((bool(g_l), (a_1, v), m) \\in f_1\\).\n2. For all \\( i \\) such that \\( 1 \\leq i < l \\), if \\( b_i = (a_i, m_1, m_2, v) \\) and \\( b_{i+1} = (a_{i+1}, m'_1, m'_2, v') \\), then there exist boolean states \\( m_3, m'_1, m'_2 \\) such that \\((m_2, (a_i, v), m_3) \\in f_3 \\) and \\((m_3, (a_{i+1}, v'), m'_1) \\in f_1\\).\n3. \\( b_l = (a_l, m, m', v) \\), for some \\( m \\in M \\) and \\( v \\in V \\) such that \\((m', (a_l, v), m_r) \\in f_3\\).\n\nThere is an additional requirement on the fourth component of the tuple \\((a, m, m', v)\\) that will enable the class automaton to verify that the position of constants has been guessed consistently. The transducer guesses a value in \\( V_C \\cup \\{ e \\} \\), but at the rightmost position where it guesses a particular value \\( v \\in V_C \\), it outputs \\( v' \\) instead of \\( v \\). This enables the class automata to check that each value \\( v \\in V_C \\) has been guessed for at most one class.\n\nWe now define the class automaton \\( C \\). Its task is to check that the inner loop can be executed in a way that is consistent with the guess of the transducer. The position preserving class string defined by a data value \\( d \\) looks as follows:\n\n\\[\n00(a_1, m_1, m'_1, v_1)000(a_2, m_2, m'_2, v_2) \\ldots 0(a_o, m_o, m'_o, v_o)00\n\\]\n\nIn more details, the task of the class automaton is twofold. First, it checks that if we consider only non-0 elements of the sequence and project to the fourth\ncomponent of the tuple, the sequence observed is either of the form $e^* \\text{ or } v^*v'$, for a constant $v$. This ensures that constants have been guessed consistently, i.e. that each constant has been assigned to a unique class, and at most one constant has been assigned to a class.\n\nSecond, the class automaton for a class $X$ checks that the inner loops that ran when $1i$, the variable of the outer loop, pointed to one of the positions belonging to $X$, can run as the transducer has guessed. That is, if the position $i \\in X$ has a tuple of the form $(a_i, m_i, m_i', v)$, the inner loop that started at state $m_i$, with the value of $1i$ equal to $i$, will finish at state $m_i'$. It is not difficult to construct a regular automaton for this condition.\n\nThe proof of Theorem 4.6 gives rise to a decision procedure, but one whose running time is non-elementary. The reason is that while the problem of reachability in multicounter automata is decidable, no elementary upper bound is known. However, the following proposition shows that the problem is at least as hard as the reachability in multicounter automata, which makes it unlikely that a more efficient algorithm exists. The best lower bound for the latter problem is EXPSPACE [Lipton 1976].\n\n**Proposition 4.7.** The reachability problem for multicounter automata can be reduced in polynomial time to the reachability problem for Restricted-ND2 programs.\n\n**Proof.** Given a multicounter automaton $A$, we construct a Restricted-ND2 program $P$ operating on data words that encode runs of $A$. The proof is similar to the proof of Theorem 14 from [Bojańczyk et al. 2006].\n\nMore precisely, we will construct a program $P$ with a boolean state $m$ such that $L_m(P)$ is non-empty if and only if there is an accepting run of $A$, i.e. iff $L(A)$ is non-empty.\n\nLet $A$ be defined by the tuple $(Q_A, \\Sigma_A, k_A, \\delta_A, q_A^I, F_A)$. The array of the program $P$ is a word on $\\Sigma_A \\times D$. The set $\\Sigma_A$ is defined as $Q_A \\cup \\{I_j \\mid 1 \\leq j \\leq k_A\\} \\cup \\{D_j \\mid 1 \\leq j \\leq k_A\\}$. $I_j$ models the increase operation of the counter $j$, and similarly, $D_j$ models the decrease operation of the counter $j$. A transition $(q_1, \\text{inc}(j), q_2) \\in \\delta_A$ is encoded by having $q_1$, $I_j$ and $q_2$ as $\\Sigma_A$ values in successive positions. A transition $(q_1, \\text{dec}(j), q_2) \\in \\delta_A$ is encoded by having $q_1$, $D_j$ and $q_2$ as $\\Sigma_A$ values in successive positions.\n\nThe program $P$ consists of two sequentially composed parts. The first part is a single non-nested loop that examines only the $\\Sigma_A$ part of the data word, and check whether: (a) the first symbol is the initial state of $A$, (b) the word encodes transitions in $\\delta_A$, and (c) the last position contains a state in $F_A$. The second part uses data values to check that each decrement matches exactly one previous decrement, and each increment matches exactly one subsequent decrement, that is, the counters are never less than zero, and are equal exactly to zero at the end of the computation. This is ensured by requiring that each occurrence of $I_j$ has a different data value, while each occurrence of $D_j$ has the same data value as exactly one preceding $I_j$.\n\nIt is easy to write a Restricted-ND2 program (of polynomial size) that checks the second part above.\n\n```plaintext\nb:=false;\n```\n\\begin{verbatim}\nb1:=true;\nfor i:= 1 to length(A) do {\n if (A[i].s = I_j) {\n for j:= 1 to length(A) do {\n b1 := checkForD_j\n }\n }\n...}\nif b1:=true then b:=true;\n\\end{verbatim}\n\nThe code fragment above shows the core structure of the program \\( P \\). The reachability question we will ask is whether a state where \\( b \\) is \\textbf{true} is reachable. The variable \\( b \\) is set to true at the end of the program if \\( b1 \\) is true, which will be the case only if no error was found during the tests such as \\texttt{checkForD}_j above. Note that \\texttt{checkForD}_j denotes a few lines of code, it is not a procedure call. This particular test is run if the \\( \\Sigma_A \\) part of the current element in the outer loop is equal to \\( I_j \\) and the test checks whether the equivalence class of the current element contains exactly two elements, with the other element at a position greater than the current value of \\( i \\) (no order tests need to be used, this can be checked by switching a boolean variable when \\( i = j \\) holds) and its \\( \\Sigma_A \\) part contains \\( D_j \\). ∎\n\n4.4 Undecidable extensions\n\nWe show that if we lift the restrictions we imposed on Restricted-ND2 programs, the reachability problem becomes undecidable.\n\n**Theorem 4.8.** The reachability problem for ND2 programs is undecidable.\n\n**Proof.** The proof is by reduction from the reachability problem of two-counter automata [Minski 1962]. We note that the proof also implies that the reachability problem is undecidable even for ND2 programs that do not access the order on the data domain and do not use index or data variables.\n\nTwo-counter automaton has a finite set of states and two integer counters. The main difference between two-counter automata and multicounter automata is that a two-counter automaton can test whether the value of a counter is equal to 0. More precisely, a two-counter machine is a tuple \\((Q, \\delta, q_0, F)\\), where \\( Q \\) is a set of states, \\( q_0 \\in Q \\) is an initial state and \\( F \\subseteq Q \\) is a set of final states. The transition relation \\( \\delta \\) is a subset of \\( Q \\times (\\{+\\} \\times \\{1, 2\\} \\times Q) \\cup (\\{-\\} \\times \\{1, 2\\} \\times Q \\times Q) \\). A configuration is a tuple in \\( Q \\times \\mathbb{N} \\times \\mathbb{N} \\) representing the current state and current values of the two counters. At each step, the machine can either increment one of the counters and transition to a new state, or (try to) decrement one of the counter and transition to one of two possible new states depending on whether the value of the counter was 0. The automaton accepts by final state. It is well-known that the nonemptiness problem for two-counter automata is undecidable [Minski 1962; Lambek 1961].\n\nGiven a two-counter automaton \\( A \\), we construct an ND2 program \\( P \\) that has a boolean state \\( m \\) such that for all data words \\( w \\), we have that \\( w \\in L_m \\) iff \\( w \\) encodes runs of \\( A \\). A configuration \\((q, i, j)\\) is encoded as a data word as follows: The \\( \\Sigma \\)\npart of the data word will be of the form\n\n$$(\\#q^h_1\\{a,b\\}^h_2)^*$$\n\nwhere $\\Sigma = \\{\\#,\\$\\} \\cup Q \\cup \\{a,b\\}$. The first counter is represented between the first and second $\\$ symbols and its value is given by the number of times the symbol $a$ occurs. Similarly, the second counter is represented between the second and third $\\$ symbols. A run is a sequence of configurations, and it will be encoded as a sequence of encodings of configurations. Note that the maximal value the counters can have in a run (denoted by $h_1, h_2$ above) does not change during the run in this encoding.\n\nThe $\\text{ND}_2$ program $P$ checks that the run has the form above, the first configuration has an initial state and the values of counters are zero, the last configuration in the input word has a final state, and that the transition relation $\\delta$ is respected at every step. We describe how the program checks the last condition.\n\nLet us consider two successive configurations, represented as follows:\n\n$\\ldots \\#q^C_1\\$C_2\\#q'^C_1\\$C_2'\\# \\ldots$\n\nLet us describe how the program check that the length of the string $C_1$ is the same as the length of the string $C'_1$. The program first checks that every data value that appears in the $C_1$ part appears there exactly once, and appears exactly once in the $C'_1$ part. Similarly, every data value that appears in the $C'_1$ part should appear there exactly once, and should appear exactly once in the $C_1$ part. The program also checks that every data value $d$ in the $C_1$ and $C'_1$ parts of the data word appears in pairs $(a,d)$ or $(b,d)$, and not in pairs with other symbols from $\\Sigma$.\n\nThe program guesses a transition and checks that it matches the two successive configurations. We proceed by case analysis on the form of tuples in the transition relation. Let us suppose that the transition guessed is given by the tuple $(q_1, +, 1, q_2)$. The automaton checks that $q = q_1$, $q' = q_2$, the value of the first counter (represented by $C_1$) has increased by one and the value of the second counter has not changed. We show how a program can check that the value of the first counter increased by one:\n\n- If a data value $d$ appeared in the $C_1$ part in a pair $(a,d)$, then it appears in the $C'_1$ part in a pair $(a,d)$.\n- Let $d$ be the leftmost data value $d$ that appears in the $C_1$ part in a pair $(b,d)$.\n \n The program checks that it appears in the $C'_1$ part in a pair $(a,d)$.\n- For all other data values that appear in the $C_1$ part in a pair $(b,d)$, the program checks that they appear in a pair $(b,d)$ in the $C'_1$ part.\n\nIt is easy to see that an $\\text{ND}_2$ program can check these conditions. In order to check the first condition in the list above, we can construct an $\\text{ND}_2$ program as follows: Let $i$ be the loop variable of the outer loop. The boolean state of the program keeps track of whether the $A[i].s$ is $\\#$, or is in the $C_1$ part or in the $C_2$ part. If it’s in the $C_1$ part and $A[i].s$ is $a$, the inner loop is used to find the data value $A[i].d$ in the $C'_1$ part. Once the inner loop finds this value, say at position $j$, it checks whether $A[j].s$ is $a$. (Note that the inner loop accesses the $A[j].s$ value even when $A[i].d$ is not equal to $A[j].d$, thus violating the syntactical restriction from the definition of Restricted-$\\text{ND}_2$ programs.) The program thus determines that the\nnumber of $a$'s has increased by one. Checking that the value of the second counter has not changed can be done similarly. Conformance to other transition tuples can be verified analogically. Therefore we can conclude that for all words $w$, we have that $w \\in L_m^2(P)$ if and only if $w$ represents an accepting run of the two-counter automaton. This concludes the proof of Theorem 4.8.\n\nThere are three restrictions in the definition of Restricted-ND2 programs — (i) they do not use data or index variables, (ii) they do not access the order on data values, and (iii) the syntactical restrictions on the inner loop. The proof of Theorem 4.8 shows that if we lift restriction (iii), the reachability problem becomes undecidable.\n\nWe now show that lifting restriction (i) or (ii) leads to undecidable reachability problem as well. Let OrderND2 programs be programs with nesting depth at most 2 that do not use index or data variables. Furthermore, there is a restriction on the syntax of the code inside the inner loop. Let $P_1$ be the code inside an inner loop, and let $i$ be the loop variable of the outer loop and let $j$ be the loop variable for the inner loop. $P_1$ must be of the following form: if $A[i].d=A[j].d$ then $P_2$ else $P_3$. Furthermore, $P_3$ cannot refer to $A[j].s$ (but note that $P_3$ can compare $A[i].d$ and $A[j].d$ e.g. by $A[i].d < A[j].d$). The DataVarND2 programs are defined similarly, the only difference from OrderND2 programs is that DataVarND2 cannot access order on the data values, but can have data and index variables, and can compare the value $A[j].d$ to the value of data variables.\n\n**Proposition 4.9.** Reachability for OrderND2 programs is undecidable. Reachability for DataVarND2 programs is undecidable.\n\n**Proof.** We modify the proof of Theorem 4.8. Let $i$ be the loop variable of the outer loop, and let $j$ be the loop variable of the inner loop, as before. Recall that in the proof of Theorem 4.8, it was necessary to access $A[j].s$ even if $A[j].d$ was different than $A[i].d$. This falls out of restriction given by OrderND2 programs. We thus have to modify the encoding of the computation of the two-counter automaton. We will still represent computations as strings of the form:\n\n$$\\ldots#qSC_1#C_2#q'\\bar{S}C'_1\\bar{S}C'_2#\\ldots$$\n\nThe inner loop had to access the $\\Sigma$ value of a position even if the data values $A[j].d$ and $A[i].d$ are not equal, because it had to determine if it had passed the $\\$ sign, in order to see whether the current position is in the $C_1$ or $C_2$ part. We will now use a different encoding to enable the inner loop to determine this. The even positions in the string will encode the computation of the two-counter automaton. The odd positions (more precisely, the data values at the odd positions) encode whether the next even position has a sentinel symbol (# or $\\$) or a value from the set \\{q, a, b\\} as the $\\Sigma$-value. Let $D_C$ be a set of data values, with size of $D_C$ being at least $\\max(h_1, h_2)$, where $h_1$ (resp. $h_2$) is the size of the substrings $C_1$ (resp. $C_2$). Let $d_1$ and $d_2$ be two values in $D$, such that $d_1$ is smaller than all the values in $D_C$ and $d_2$ is greater than all the values in $D_C$ (it is always possible to find such a set $D_C$ and values $d_1$ and $d_2$, as $D$ is infinite). The data values of odd positions will be either equal to $d_1$ or $d_2$, with $d_1$ indicating that the next position contains a sentinel symbol and $d_2$ indicating that the next position contains a symbol in\n\\{q, a, b\\}. When the loop variable of the outer loop is at a position in the \\(C_1\\) part or in the \\(C_2\\) part position, the inner loop can test whether the odd position contains \\(d_1\\) and \\(d_2\\) by testing \\(A[i].d < A[j].d\\).\n\nThe proof for the \\texttt{DataVarND2} programs is similar — we again use two different values for odd positions, and test these values via equality to a data variable. The data variable is set to the first position in the word.\n\n\\section{Expressiveness}\n\nIn this subsection, we compare expressiveness of logics and automata on data words and array-accessing programs. We make our comparisons in terms of languages of data words these formalisms can define. For logics and automata, the notion of expressiveness is standard. For programs, recall that we defined a language corresponding to a program and in Section 4.3.\n\nThe following proposition shows that EDAs and EMSO\\(^2\\)(\\(\\approx, +1, \\oplus 1\\)) are equally expressive. This means that somewhat surprisingly, DAs and EDAs are expressively equivalent.\n\n**Proposition 4.10.** EDAs and EMSO\\(^2\\)(\\(\\approx, +1, \\oplus 1\\)) are equally expressive.\n\n**Proof.** The fact that EDAs are at least as expressive as EMSO\\(^2\\)(\\(\\approx, +1, \\oplus 1\\)) follows from two facts mentioned in Sections 4.1 and 4.2. First, the logic EMSO\\(^2\\)(\\(\\approx, +1, \\oplus 1\\)) and data automata are equally expressive, and second, for each DA there exists an EDA that accepts the same language on data words.\n\nTo show that EMSO\\(^2\\)(\\(\\approx, +1, \\oplus 1\\)) is at least as expressive as EDAs, we present a construction that given an EDA \\(\\mathcal{E}\\) constructs an EMSO\\(^2\\)(\\(\\approx, +1, \\oplus 1\\)) formula \\(\\varphi\\) such that for all words \\(w \\in D^*\\), \\(w \\models \\varphi\\) iff \\(w \\in L(\\mathcal{E})\\).\n\nFirst, we recall a result of [Bojańczyk et al. 2006] that states that EMSO\\(^2\\)(\\(\\approx, +1, \\oplus 1\\)) and EMSO\\(^2\\)(\\(\\approx, <, +\\omega, \\oplus 1\\)) are expressively equivalent. It is thus sufficient to construct an EMSO\\(^2\\)(\\(\\approx, <, +\\omega, \\oplus 1\\)) formula. The construction is similar to classical simulation of finite state automata in EMSO\\(^2\\)(+1).\n\nWe present only the core part of the proof that is different from the classical construction. A formula \\(\\varphi\\) that simulates an accepting run of \\(\\mathcal{E}\\) is constructed. It needs to simulate the run of the transducer, as well as the run of a priori unbounded number of copies of the class automaton. We present the simulation of the runs of copies of the class automaton \\(C\\). Note that we cannot mark (via existentially quantified monadic second order variables) each position in the string with the state of all the copies of \\(C\\). Instead, monadic second order variables will correspond to single states of \\(C\\), and each position in a word is marked by exactly one of these state predicates. If the position \\(p\\) is in class \\(X\\), it will be marked with a state in which the copy of \\(C\\) corresponding to \\(X\\) is at \\(p\\). The task of the first order part of \\(\\varphi\\) is then to verify, for each class, that the labeling encodes an accepting run of the class automaton. As part of this task, it needs to verify that a correct number of 0 positions appeared between successive class positions. If \\(P_q\\) and \\(P_{q'}\\) are labels on successive class positions \\(p\\) and \\(p'\\), then one needs to verify that the class automaton that ran with the position-preserving class string as input and thus saw the 0 symbols will indeed be in the state \\(q'\\) after processing the string of 0s followed by the symbol at position \\(p'\\). The formula that verifies this condition of course depends closely on the transition relation of the class automaton. We will...\nThe following proposition sheds light on the difference between DAs and EDAs. We saw that DAs and EDAs are expressively equivalent. However, one difference between EDAs and DAs is that deterministic EDAs are more expressive than deterministic DAs. It is the nondeterminism that then levels the difference.\n\n**Proposition 4.11.** Deterministic EDAs are more expressive than deterministic DAs.\n\n**Proof.** Let $L$ be the language defined in Example 4.2. We showed that there is a deterministic EDA $\\mathcal{E}$ such that $L(\\mathcal{E}) = L$.\n\nWe now show that there is no deterministic DA $A = (G_A, C_A)$ such that $L(A) = L$. The proof will be by contradiction. We suppose that there is such a data automaton. As the alphabet $\\Sigma$ is a singleton, the $\\Sigma$ part of the data word is determined by the length of the word in this case. We therefore define data words only by their data part in the rest of this proof. Let $k$ be the number of states of the transducer $G_A$. We consider a data word $w_1 = (d_1d_2)^{k+1}$, where $d_1, d_2$ are two distinct values in $D$. This word is in $L$. There is therefore an accepting run of $G_A$. Let us consider the even positions in $w_1$. Clearly, there are two positions $2i$ and $2j$ such that $k + 1 > 2i > 2j$ and $G_A$ is in the same state at $2i$ as it is at $2j$. We now consider the words $w_2 = (d_1d_2)^i(d_1d_2)^{k+1-j}(d_1d_4)^{j-i}$ and $w_3 = (d_1d_2)^i(d_1d_3)^{j-i}(d_1d_4)^{k+1-j}$. Note that both $w_2$ and $w_3$ are in $L$ and the run of the transducer $G_A$ on both of these words is the same as on $w_1$, as $G_A$ is deterministic and the $\\Sigma$ parts of $w_1, w_2,$ and $w_3$ are the same.\n\nNow we look at the word $w_4 = (d_1d_2)^i(d_1d_3)^{j-i}(d_1d_2)^{k+1-j}$ and show that it is accepted by $\\mathcal{E}$. Again, the run of the transducer is the same as for $w_1$. The class automaton for the class corresponding to $d_1$ reads the same input as was the case for $w_1$. The class automaton for the class corresponding to $d_2$ reads the same input as was the case for $w_2$ (here the fact that the transducer is in the same state at $2i$ and $2j$ is used), and the class automaton for the class corresponding to $d_3$ gets the\n\n\\[\n\\forall x \\forall y \\left( x \\oplus 1 = y \\land P_q(x) \\land P_{q'}(y) \\right) \\Rightarrow \\\\\n\\left( \\bigwedge_{1 \\leq k \\leq 5} \\forall y \\left( (x + k = y) \\rightarrow (x \\not= y) \\right) \\right) \\land \\\\\nC_0(x) \\leftrightarrow C_1(y) \\land C_1(x) \\leftrightarrow C_2(y) \\land C_2(x) \\leftrightarrow C_3(y) \\land \\\\\nC_3(x) \\leftrightarrow C_4(y) \\land C_4(x) \\leftrightarrow C_0(y)\n\\]\n\nwhere $C_0, C_1, C_2, C_3, C_4$ are existentially quantified monadic second order predicates that are used for counting modulo the length of the cycle (which is 5 in the example). Note that this is an FO^2(\\approx, <, +, \\oplus, 1) formula. □\nsame input as was the case for $w_3$. Therefore in each case, the class automaton $C_A$ accepts its input. Thus we have reached a contradiction, as $w_4$ is not in $L$. □\n\nWe show that nondeterminism adds to the expressive power of EDAs. We will use the following example for the proof.\n\n**Example 4.12.** Let $L_\\#$ be the language of data words defined by the following properties: (1) $str(w) = a^n s a^*$, (2) the data value of the $\\$-$position occurs exactly once, and each other data value occurs precisely twice — once before and once after the $\\$-$sign, and (3) the order of data values in the first $a$-block is different from the order of data values in the second $a$-block.\n\n**Proposition 4.13.** Deterministic EDAs are strictly less expressive than EDAs.\n\n**Proof.** There exists a nondeterministic EDA for the language $L_\\#$ from Example 4.12 (we can use the DA constructed in [Bojańczyk et al. 2006] in Example 8). It remains to prove that there is no deterministic EDA that accepts the language $L_\\#$. The proof is by contradiction. Let us assume that there exists a deterministic EDA $E = (G, C)$ that accepts $L_\\#$.\n\nLet $n$ be the number of states $G$. For the automaton $C$, we assume (without loss of generality) that it is deterministic. Consider the graph $C_0$ and its components $C_0^j$, for $j \\in [1..k]$, as defined in the proof in Theorem 4.3. For each component $C_0^j$ let $loop(C_0^j)$ be the length of the loop in $C_0^j$. Let $K_0$ be the product of the lengths of the loops, i.e. $K_0 = \\prod_{1 \\le j \\le k} loop(C_0^j)$. Recall the definition of $D(C_0)$ from the proof of Theorem 4.3. Let $K$ be the smallest multiple of $K_0$ greater than $D(C_0)$.\n\nLet $w$ be the word $(a,d_1)(a,d_2)\\ldots(a,d_{K(n+2)})(\\$)(a,d_1)(a,d_2)\\ldots(a,d_{K(n+2)})$, where $d_1, \\ldots, d_{K(n+2)}$ are distinct. The word $w$ is not in the language, but we show that there is an accepting run of $E$ on this word. Let us consider the following $n + 1$ position in the first part of the word: $K, 2 \\cdot K, 3 \\cdot K, \\ldots, (n + 1) \\cdot K$. There exist integers $p_1$ and $p_2$, such that $1 \\le p_1 \\le p_2 \\le n + 1$ and $G$ has the same state after reading the positions $p_1$ and $p_2$, where $p_1 = p_1 \\cdot K$ and $p_2 = p_2 \\cdot K$. Let $v$ be the data word obtained by switching the data values at $p_1$ and $p_2$. We can observe that the run of $G$ on $v$ and $w$ is the same. The position-preserving class strings for classes other than the classes defined by $d_{p_1}$ and $d_{p_2}$ are the same. Consider the position-preserving class string $s_v$ of the word $v$ for the class defined by the value $d_{p_1}$. It is of the form $0^{p_2-1}(a,d_{p_1})0^{K(n+2)-p_1}0\\ldots$. The corresponding string $s_w$ in $w$ is of the form $0^{p_2-1}(a,d_{p_1})0^{K(n+2)-p_1}0\\ldots$. It is easy to see that $C$ does not distinguish between the two strings in the following sense: (a) $C$ has the same state after reading the position $p_2$ of $s_w$, and (b) $C$ has the same state after reading the position $K(n + 2) + 1$ in both $s_v$ and $s_w$. (We use (a) to show (b).) We now use the same argument for the class defined by $d_{p_2}$. We have thus shown that the accepting run of $E$ on $v$ can be used to construct the accepting run of $E$ on $w$, which creates a contradiction. □\n\nWe will now compare the expressive power of array-accessing programs to logics and automata on data words. Specifically, we will use the logic EMSO$^2(\\approx, +1, \\oplus 1)$ for comparison. Recall that this logic is expressively equivalent to data automata. We first show that Restricted-ND2 programs are not as expressive as EMSO$^2(\\approx, +1, \\oplus 1)$.\nProposition 4.14. Restricted-ND2 programs are strictly less expressive than EMSO²(≈, +1, ⊕1).\n\nProof. The proof of Theorem 4.6 gives, for each Restricted-ND2 program P and a boolean state m, an equivalent EDA E. In the proof of Proposition 4.10, we have constructed an EMSO²(≈, +1, ⊕1) formula equivalent to a given EDA. Therefore, for every Restricted-ND2 program P and its boolean state m, we can find an EMSO²(≈, +1, ⊕1) formula φ such that w ∈ L_m(P) iff w ⊨ φ.\n\nWe will now show that there is a language of data words that can be specified by an EMSO²(≈, +1, ⊕1) formula φ, but not by a Restricted-ND2 program. We will use Example 4.12. We have stated that the language L# can be captured by a nondeterministic EDA, and thus by an EMSO²(≈, +1, ⊕1) formula. We show that there is no Restricted-ND2 program P that captures L#.\n\nFor a proof by contradiction, let us assume that there is a Restricted-ND2 program P and a boolean state m, such that L_m(P) = L#. Without the loss of generality, we make the following two assumptions. First, we can assume that the program contains only one (nested) loop, because to every program with sequentially composed loops, we can construct an equivalent program with only one nested loop, by using a construction similar to the one in Theorem 3.2, where we combined sequentially composed loops into a single traversal. Second, we assume that the inner loop of the nested loop is deterministic, as the inner loop can be determinized using a subset construction, as for the classical finite state machines. The nondeterministic choices are then only in the outer loop.\n\nRecall the restriction on the code of the inner loop. The body of the loop must be of the following form: if A[i].d = A[j].d then P2 else P3, where i is the loop variable of the outer loop, and j is the loop variable of the inner loop. Furthermore, P3 cannot refer to A[j].d, i.e. it does not contain occurrences of A[j].d or A[j].s. The computation of the inner loop can therefore be seen as a computation of a finite automaton I on a string over the alphabet Σ ∪ {0}, similarly as for the class automaton of an EDA. As in the proof of Proposition 4.13, we analyze the restriction of the automaton I to the letter 0 in order to define the numbers K_0 and K as in that proof.\n\nLet us consider a data word w = (a, d_1)(a, d_2)...(a, d_N)(\\$, d)(a, d_1)(a, d_2)...(a, d_N), for N = K_0 + K + 2. Let e = K_0 + 1, and let f = K_0 + K + 1. Let v be a data word obtained by switching the first two occurrences of d_e and d_f. Clearly, w ∉ L#, but v ∈ L#. However, given an accepting execution r_v of P on v, we can construct an accepting execution r_w of P on w, and thus obtain a contradiction. We prove that given any value of i (the loop variable of the outer loop), and an execution r_v^i on v of the inner loop with that value of i, we can construct an execution r_w^i on w of the inner loop on w that starts and finishes in the same state as r_v^i. For values of i other than e, f, N + 1 + e, N + 1 + f, the execution of the (deterministic) inner loop on w is exactly the same as the execution on v. If the value of i is e, it can be shown that the execution r_w^e can be used. More precisely, we show that P is in the same boolean state when the execution r_v^f reaches position N + 1 + e (resp. N + 1 + f), as P is when the execution r_w^e reaches position N + 1 + e (resp. N + 1 + f). Similar arguments can be used when the value of i is f, N + 1 + e, N + 1 + f.\n\nWe have shown that v is in L(P), which is a contradiction. \n\nACM Transactions on Computational Logic, Vol. V, No. N, Month 20YY.\nWe also compare the expressive power of ND1 programs and EMSO²(≈, +1, ⊕1).\n\n**Proposition 4.15.** There exists an EMSO²(≈, +1, ⊕1) property that is not expressible by an ND1 program.\n\n**Proof.** Let us consider the language \\( L \\) of data words \\( w \\) such that every data value that appears in \\( w \\) appears at least twice. It is easy to construct a (deterministic) Restricted-ND2 program that checks this property. The property can thus be specified in EMSO²(≈, +1, ⊕1).\n\nWe now show that this property cannot be specified by an ND1 program. For the sake of contradiction, suppose that there exists an ND1 program \\( P \\) with \\( k \\) index and data variables. Let us consider a word \\( w = w_1 w_2 \\ldots w_{2(k+1)} \\) of length \\( 2(k+1) \\), such that corresponding data values are such that for all \\( i \\leq k + 1 \\), \\( d_{i+1} < d_i \\), and there exists a \\( d'_i \\) such that \\( d_i < d'_i < d_{i+1} \\). The positions greater than \\( k + 1 \\) are defined by \\( d_{k+1+i} = d_i \\). As \\( w \\) is in \\( L \\), there is an accepting run of \\( P \\). Let us consider this run after \\( k + 1 \\) steps. At this point, there is one value \\( d_j \\) among the first \\( k + 1 \\) values in \\( w \\) that is not stored in a data variable or pointed to by an index variable. Let us now construct a word \\( w' \\) by replacing the value at \\( k + 1 + j \\) by \\( d'_j \\). We can show that \\( P \\) accepts \\( w' \\) with the same run, even though \\( w' \\) is not in \\( L \\). We have thus reached a contradiction. □\n\nNote that ND1 programs allow order on the data domain, and thus can check a property specifying that the elements in the input data word are in increasing order. It is easy to see that this property is not specifiable in EMSO²(≈, +1, ⊕1). However, if we syntactically restrict ND1 programs not to use order on \\( D \\), they can be captured by EMSO²(≈, +1, ⊕1) formulas. The reason is that ND1 programs that do not refer to the order on \\( D \\) can be simulated by register automata introduced in [Kaminski and Francez 1994]. For every register automaton, there is an equivalent data automaton [Björklund and Schwentick 2007]. Another natural question is whether there is an order-invariant property that can be captured by ND1 programs (that have access to order), but is not expressible in EMSO²(≈, +1, ⊕1). We leave this question for future work.\n\n5. RELATED WORK\n\nOur results establish connections between verification of programs accessing arrays and logics and automata on data words. Kaminski and Francez [Kaminski and Francez 1994] initiated the study of finite-memory automata on infinite alphabets. They introduced register automata, that is automata that in addition to finite state have a fixed number of registers that can store data values. The results of Kaminski and Francez were recently extended in [Neven et al. 2004; Bojańczyk et al. 2006; Björklund and Schwentick 2007; Björklund and Bojańczyk 2007]. Data automata introduced in this line of research were shown to be more expressive than register automata. Furthermore, the logic EMSO²(≈, +1, ⊕1) was introduced, and [Bojańczyk et al. 2006] shows that EMSO²(≈, +1, ⊕1) and data automata are equally expressive. The reduction from EMSO²(≈, +1, ⊕1) to data automata and the fact that emptiness is decidable for data automata imply that satisfiability is decidable for EMSO²(≈, +1, ⊕1). We show that Restricted-ND2 programs can be encoded in EMSO²(≈, +1, ⊕1).\n\nACM Transactions on Computational Logic, Vol. V, No. N, Month 20YY.\nor allowing access to order on data variable makes satisfiability undecidable for the resulting logic, even for the first order fragment [Bojańczyk et al. 2006]. We show, perhaps somewhat surprisingly, that the undecidability does not translate into undecidability of reachability for \\( \\text{ND}^1 \\) programs that access order on the data domain and have an arbitrary number of index and data variables. Similarly, the main difference between our result for \\( \\text{ND}^1 \\) programs and the result of [Kaminski and Francez 1994] about decidability of emptiness for register automata is that the \\( \\text{ND}^1 \\) programs can test order of the elements of the data domain.\n\nThe results on automata and logics on data words model were applied in the context of XML reasoning [Neven et al. 2004] and extended temporal logics [Demri and Lazić 2006]. The connection to verification of programs with unbounded data structures is the first to the best of our knowledge.\n\nDeutsch et al. [Deutsch et al. 2009] consider a model of database-driven systems similar in some aspects to our model of programs. The key difference is that they consider a dense order. They specifically note that the model-checking problem they consider is open for the case of a discrete order. It would be interesting to see if our result on programs on structures with discrete order can be extended to the setting of database-driven systems.\n\nFragments of first order logic on arrays have been shown decidable in [Bradley et al. 2006; Habermehl et al. 2008; Balaban et al. 2005; Bouajjani et al. 2007]. These fragments do not restrict the number of variables (as was the case with EMSO\\(^2\\)(\\(\\approx, +1, \\oplus1\\)), but restrict the number of quantifier alternations. These papers focus on theory of arrays, rather than on analysis of array-accessing programs. Decidability of reachability for polymorphic systems with arrays (PSAs) was studied e.g. in [Lazić 2005]. PSAs use well-typed \\( \\lambda \\)-terms and do not allow iteration over arrays.\n\nStatic analysis of programs that access arrays is an active research area. As even simple properties such as reachability are undecidable in general, bulk of the literature is on abstraction. Recent results for this type of programs include [Gopan et al. 2008; Gulwani et al. 2008; Balaban et al. 2005]. The approach consists in finding inductive invariants for loops using abstraction methods, such as abstract domains that can represent universally quantified facts [Gulwani et al. 2008] and a predicate abstraction approach to shape analysis [Balaban et al. 2005]. In contrast, our results yield decision procedures for array-accessing programs. The methods based on abstraction are applicable to a richer class of programs, including programs that access more than one array, use nested loops, and write to the arrays. However, the abstraction based methods are sound but not complete. In contrast, our results lead to a sound and complete decision algorithm. Note also that the abstract domains used for examples and applications in the cited papers also track equality and order on array elements.\n\n6. CONCLUSION\n\nWe have presented decision procedures for reachability for classes of array-accessing programs. The arrays considered are unbounded in length and have elements from a potentially infinite ordered domain. For programs with non-nested loops, we showed that the problem is \\( \\text{PSPACE}\\)-complete, i.e. it is in the same complexity\nclass as the reachability problem for boolean programs, which is used in standard software verification tools. We have established connection to well-studied logics and automata on data words, and we have shown that the decidability boundary for the reachability problem lies in the class of programs with doubly-nested loops.\n\nREFERENCES\n\n\n"}}},{"rowIdx":171,"cells":{"id":{"kind":"string","value":"9cf19bee4ec5b040610980acd236e120cea439a9"},"text":{"kind":"string","value":"Contents\n\n1. DOCUMENT OVERVIEW \n\n2. DIAGRAM ELEMENTS \n 2.1 Graphs and their Contents \n 2.2 Drawing paths \n 2.3 Invisible Hyperlinks And The Role Of Tools \n 2.4 Background information \n 2.5 String \n 2.6 Name \n 2.7 Label \n 2.8 Keywords \n 2.9 Expression \n 2.10 Note \n 2.11 Type-Instance Correspondence \n\n3. MODEL MANAGEMENT \n 3.1 Packages and Model Organization \n\n4. GENERAL EXTENSION MECHANISMS \n 4.1 Constraint and Comment \n 4.2 Element Properties \n 4.3 Stereotypes \n\n5. STATIC STRUCTURE DIAGRAMS \n 5.1 Class diagram \n 5.2 Object diagram \n 5.3 Classifier \n 5.4 Class \n 5.5 Name Compartment \n 5.6 List Compartment \n 5.7 Attribute \n 5.8 Operation \n 5.9 Type vs. Implementation Class \n 5.10 Interfaces \n 5.11 Parameterized Class (Template) \n 5.12 Bound Element \n 5.13 Utility \n 5.14 Metaclass \n 5.15 Class Pathnames \n 5.16 Importing a package \n 5.17 Object \n 5.18 Composite object \n 5.19 Association \n 5.20 Binary Association\n\nUML v 1.1, Notation Guide\n## Contents\n\n5.21 Association End ............................................. 52 \n5.22 Multiplicity .................................................. 56 \n5.23 Qualifier ....................................................... 58 \n5.24 Association Class ........................................... 59 \n5.25 N-ary association ............................................ 61 \n5.26 Composition .................................................. 62 \n5.27 Links ........................................................... 65 \n5.28 Generalization ................................................ 67 \n5.29 Dependency ................................................... 71 \n5.30 Derived Element .......................................... 73\n\n6. **USE CASE DIAGRAMS** 75 \n6.1 Use Case Diagram .......................................... 75 \n6.2 Use Case ....................................................... 77 \n6.3 Actor ........................................................... 77 \n6.4 Use case relationships ........................................ 78\n\n7. **SEQUENCE DIAGRAMS** 80 \n7.1 Kinds of Interaction Diagrams ............................... 80 \n7.2 Sequence diagram ........................................... 80 \n7.3 Object lifeline ................................................ 83 \n7.4 Activation ..................................................... 84 \n7.5 Message ........................................................ 85 \n7.6 Transition Times ............................................. 87\n\n8. **COLLABORATION DIAGRAMS** 88 \n8.1 Collaboration .................................................. 88 \n8.2 Collaboration diagram ....................................... 89 \n8.3 Pattern Structure ............................................ 90 \n8.4 Collaboration Contents ..................................... 92 \n8.5 Interactions .................................................... 93 \n8.6 Collaboration Roles ........................................... 94 \n8.7 Multiobject ..................................................... 95 \n8.8 Active object ................................................ 96 \n8.9 Message flows ................................................ 98 \n8.10 Creation/destruction markers ............................... 102\n\n9. **STATECHART DIAGRAMS** 103 \n9.1 Statechart Diagram .......................................... 103 \n9.2 States .......................................................... 104 \n9.3 Composite States ............................................ 106 \n9.4 Events .......................................................... 108 \n9.5 Simple transitions ........................................... 111 \n9.6 Complex transitions ........................................ 113 \n9.7 Transitions to nested states .................................. 114 \n9.8 Sending messages ........................................... 116 \n9.9 Internal transitions ........................................ 120\n1. DOCUMENT OVERVIEW\n\nThis document describes the notation for the visual representation of the Unified Modeling Language (UML). This document should be used in conjunction with the companion *UML Semantics* document. This notation document contains brief summaries of the semantics of UML constructs, but the semantics document must be consulted for full details.\n\nThis document is arranged into chapters according to semantic concepts subdivided by diagram types. Within each diagram type are listed model elements that are found on that diagram and their representation. Note, however, that many model elements are usable in more than one diagram. An attempt has been made to place each description where it is used the most, but be aware that the document involves implicit cross-references and that elements may be useful in other places than the chapter in which they are described. Be aware also that the document is nonlinear: there are forward references in it. It is not intended to be a teaching document that can be read linearly but a reference document organized by affinity of concept.\n\nEach chapter is divided into numbered sections, roughly corresponding to important model elements and notational constructs. Note that some of these constructs are used within other constructs; do not be misled by the flattened structure of the chapter. Within each section the following subsections may be found:\n\n- **Semantics**: Brief summary of semantics. For a fuller explanation and discussion of fine points see the *UML Semantics* document.\n\n- **Notation**: Explains the notational representation of the semantic concept (“forward mapping to notation”).\n\n- **Presentation options**: Describes various options in presenting the model information, such as the ability to suppress or filter information, alternate ways of showing things, and suggestions for alternate ways of presenting information within a tool. Dynamic tools need the freedom to present information in various ways and we do not want to restrict this excessively. In some sense, we are defining the “canonical notation” that printed documents show, rather than the “screen notation”. We realize that the ability to extend the notation can lead to unintelligible dialects so we hope that this freedom will be used in intuitive ways. We have not sought to eliminate all the ambiguity that some of these presentation options may introduce, because the presence of the underlying model in a dynamic tool serves to easily disambiguate things. Note that a tool is not supposed to pick just one of the presentation options and implement it; tools should offer users the options of selecting among various presentation options, including some that are not described in this document.\n\n- **Style guidelines**: Suggestions for the use of stylistic markers, such as fonts, naming conventions, arrangement of symbols, etc., that are not explicitly part of the notation but that help to make diagrams more readable. These are similar to text indentation rules in C++ or Smalltalk. Not everyone will choose to follow these suggestions, but the use of some consistent guidelines of your own choosing is recommended in any case.\nExample: Shows samples of the notation. String and code examples are given in the following font: This is a string sample.\n\nMapping: Shows the mapping of notation elements to metamodel elements (\"reverse mapping from notation\"). This indicates how the notation would be represented as semantic information. Note that, in general, diagrams are interpreted in a particular context in which semantic and graphic information is gathered simultaneously. The assumption is that diagrams are constructed by an editing tool that internalizes the model as the diagram is constructed. Some semantic constructs have no graphic notation and would be shown to a user within a tool using a form or table.\n2. DIAGRAM ELEMENTS\n\nThis chapter discusses mechanisms of the notation. These are generic mechanisms that are used in various ways in subsequent chapters to represent semantics.\n\n2.1 GRAPHS AND THEIR CONTENTS\n\nMost UML diagrams and some complex symbols are graphs containing nodes connected by paths. The information is mostly in the topology, not in the size or placement of the symbols (there are some exceptions, such as a sequence diagram with a metric time axis). There are three kinds of visual relationships that are important: connection (usually of lines to 2-d shapes), containment (of symbols by 2-d shapes with boundaries), and visual attachment (one symbol being “near” another one on a diagram). These visual relationships map into connections of nodes in a graph, the parsed form of the notation.\n\nUML notation is intended to be drawn on 2-dimensional surfaces. Some shapes are 2-dimensional projections of 3-d shapes (such as cubes) but they are still rendered as icons on a 2-dimensional surface. In the near future true 3-dimensional layout and navigation may be possible on desktop machines but it is not currently practical.\n\nThere are basically four kinds of graphical constructs that are used in UML notation: icons, 2-d symbols, paths, and strings.\n\nAn icon is a graphical figure of a fixed size and shape; it does not expand to hold contents. Icons may appear within area symbols, as terminators on paths, or as stand-alone symbols that may or may not be connected to paths.\n\nTwo-dimensional symbols have variable height and width and they can expand to hold other things, such as lists of strings or other symbols. Many of them are divided into compartments of similar or different kinds. Paths are connected to two-dimensional symbols by terminating the path on the boundary of the symbol. Dragging or deleting a 2-d symbol affects its contents and any paths connected to it.\n\nPaths are sequences of line segments whose endpoints are attached. Conceptually a path is a single topological entity, although its segments may be manipulated graphically. A segment may not exist apart from its path. Paths are always attached to other graphic symbols at both ends (no dangling lines). Paths may have terminators, that is, icons that appear in some sequence on the end of the path and that qualify the meaning of the path symbol.\n\nStrings present various kinds of information in an “unparsed” form. UML assumes that each usage of a string in the notation has a syntax by which it can be parsed into underlying model information. For example, syntaxes are given for attributes, operations, and transitions. These syntaxes are subject to extension by tools as a presentation option. Strings may exist as singular elements of symbols or compartments of symbols, as elements in lists (in which case the position in the list conveys information), as labels attached to symbols or paths, or as stand-alone elements on a diagram.\nDiagram Elements\n\n2.2 Drawing Paths\n\nA path consists of a series of line segments whose endpoints coincide. The entire path is a single topological unit. Line segments may be orthogonal lines, oblique lines, or curved lines. Certain common styles of drawing lines exist: all orthogonal lines, or all straight lines, or curves only for bevels. The line style can be regarded as a tool restriction on default line input. When line segments cross, it may be difficult to know which visual piece goes with which other piece; therefore a crossing may optionally be shown with a small semicircular jog by one of the segments to indicate that the paths do not intersect or connect (as in an electrical circuit diagram).\n\nIn some relationships (such as aggregation and generalization) several paths of the same kind may connect to a single symbol. In some circumstances (described for the particular relationship) the line segments connected to the symbol can be combined into a single line segment, so that the path from that symbol branches into several paths in a kind of tree. This is purely a graphical presentation option; conceptually the individual paths are distinct. This presentation option may not be used when the modeling information on the segments to be combined is not identical.\n\n2.3 Invisible Hyperlinks and The Role of Tools\n\nA notation on a piece of paper contains no hidden information. A notation on a computer screen, however, may contain additional invisible hyperlinks that are not apparent in a static view, but that can be invoked dynamically to access some other piece of information, either in a graphical view or in a textual table. Such dynamic links are as much a part of a dynamic notation as the visible information, but this document does not prescribe their form. We regard them as a tool responsibility. This document attempts to define a static notation for the UML, with the understanding that some useful and interesting information may show up poorly or not at all in such a view. On the other hand, we do not know enough to specify the behavior of all dynamic tools, nor do we want to stifle innovation in new forms of dynamic presentation. Eventually some of the dynamic notations may become well enough established to standardize them, but we do not feel that we should do so now.\n\n2.4 Background Information\n\n2.4.1 Presentation options\n\nEach appearance of a symbol for a class on a diagram or on different diagrams may have its own presentation choices. For example, one symbol for a class may show the attributes and operations and another symbol for the same class may suppress them. Tools may provide style sheets attached either to individual symbols or to entire diagrams. The style sheets would specify the presentation choices. (Style sheets would be applicable to most kinds of symbols, not just classes.)\n\nNot all modeling information is most usefully presented in a graphical notation. Some information is best presented in a textual or tabular format. For example, much detailed programming informa-\ntion is best presented as text lists. The UML does not assume that all of the information in a model will be expressed as diagrams; some of it may only be available as tables. This document does not attempt to prescribe the format of such tables or of the forms that are used to access them, because the underlying information is adequately described in the UML metamodel and the responsibility for presenting tabular information is a tool responsibility. It is assumed, however, that hidden links may exist from graphical items to tabular items.\n\n2.5 STRING\n\nA string is a sequence of characters in some suitable character set used to display information about the model. Character sets may include non-Roman alphabets and characters.\n\n2.5.1 Semantics\n\nDiagram strings normally map underlying model strings that store or encode information about the model, although some strings may exist purely on the diagrams. UML assumes that the underlying character set is sufficient for representing multibyte characters in various human languages; in particular, the traditional 8-bit ASCII character set is insufficient. It is assumed that the tool and the computer manipulate and store strings correctly, including escape conventions for special characters, and this document will assume that arbitrary strings can be used without further fuss.\n\n2.5.2 Notation\n\nA string is displayed as a text string graphic. Normal printable characters should be displayed directly. The display of nonprintable characters is unspecified and platform-dependent. Depending on purpose, a string might be shown as a single-line entity or as a paragraph with automatic line breaks.\n\nTypeface and font size are graphic markers that are normally independent of the string itself. They may code for various model properties, some of which are suggested in this document and some of which are left open for the tool or the user.\n\n2.5.3 Presentation options\n\nTools may present long strings in various ways, such as truncation to a fixed size, automatic wrapping, or insertion of scroll bars. It is assumed that there is a way to obtain the full string dynamically.\n\n2.5.4 Example\n\nBankAccount\n\nintegrate (f: Function, from: Real, to: Real)\nDiagram Elements\n\n{ author = “Joe Smith”, deadline = 31-March-1997, status = analysis }\n\nThe purpose of the shuffle operation is nominally to put the cards into a random configuration. However, to more closely capture the behavior of physical decks, in which blocks of cards may stick together during several riffles, the operation is actually simulated by cutting the deck and merging the cards with an imperfect merge.\n\n2.5.5 Mapping\n\nA graphic string maps into a string within a model element. The mapping depends on context. In some circumstances, the visual string is parsed into multiple model elements. For example, an operation signature is parsed into its various fields. Further details are given with each kind of symbol.\n\n2.6 NAME\n\n2.6.1 Semantics\n\nA name is a string that is used to uniquely identify a model element within some scope. A pathname is used to find a model element starting from the root of the system (or from some other point). A name is a selector (qualifier) within some scope—the scope is made clear in this document for each element that can be named.\n\nA pathname is a series of names linked together by a delimiter (such as ‘::’). There are various kinds of pathnames described in this document, each in its proper place and with its particular delimiter.\n\n2.6.2 Notation\n\nA name is displayed as a text string graphic. Normally a name is displayed on a single line and will not contain nonprintable characters. Tools and languages may impose reasonable limits on the length of strings and the character set they use for names, possibly more restrictive than those for arbitrary strings such as comments.\n\n2.6.3 Example\n\nNames:\n\n BankAccount\n integrate\n controller\n abstract\nDiagram Elements\n\nthis_is_a_very_long_name_withunderscores\n\nPathname:\nMathPak::Matrices::BandedMatrix.dimension\n\n2.6.4 Mapping\n\nMaps to the name of a model element. The mapping depends on context, as with String. Further details are given with the particular element.\n\n2.7 LABEL\n\nA label is a string that is attached to a graphic symbol.\n\n2.7.1 Semantics\n\nA label is a term for a particular use of a string on a diagram. It is purely a notational term.\n\n2.7.2 Notation\n\nA label is a string that is graphically attached to another symbol on a diagram. Visually the attachment is normally by containment of the string (in a closed region) or by placing the string near the symbol. Sometimes the string is placed in a definite position (such as below a symbol) but most of the time the statement is that the string must be “near” the symbol. A tool maintains an explicit internal graphic linking between a label and a graphic symbol, so that the label drags with the symbol, but the final appearance of the diagram is a matter of aesthetic judgment and should be made so that there is no confusion about which symbol a label is attached to. Although the attachment may not be obvious from a visual inspection of a diagram, the attachment is clear and unambiguous at the graphic level (and therefore poses no ambiguity in the semantic mapping).\n\n2.7.3 Presentation options\n\nA tool may visually show the attachment of a label to another symbol using various aids (such as a line in a given color, flashing of matched elements, etc.) as a convenience.\n2.8 Keywords\n\nThe number of easily-distinguishable visual symbols is limited. The UML notation therefore makes use of text keywords in places to distinguish variations on a common theme, including metamodel subclasses of a base class, stereotypes of a metamodel base class, and groups of list elements. From the user’s perspective, the metamodel distinction between metamodel subclasses and stereotypes is often unimportant, although it is of course important to tool builders and others who implement the metamodel.\n\nThe general notation for the use of a keyword is to enclose it in guillemets («»):\n\n«keyword»\n\nCertain predefined keywords are described in the text of this document. These must be treated as reserved words in the notation. Others are available for users to employ as stereotype names. The use of a stereotype name that matches a predefined keyword is ill-formed.\n\n2.9 Expression\n\n2.9.1 Semantics\n\nVarious UML constructs require expressions, which are linguistic formulas that yield values when evaluated at run-time. These include expressions for types, boolean values, and numbers. UML does not include an explicit linguistic analyzer for expressions. Rather, expressions are expressed as strings in a particular language. The OCL constraint language is used within the UML semantic definition and may also be used at the user level; other languages (such as programming languages) may also be used.\nUML avoids specifying the syntax for constructing type expressions because they are so language-dependent. It is assumed that the name of a class or simple data type will map into a simple Classifier reference, but the syntax of complicated language-dependent type expressions, such as C++ function pointers, is the responsibility of the specification language.\n\n2.9.2 Notation\n\nAn expression is displayed as a string defined in a particular language; the syntax of the string is the responsibility of a tool and a linguistic analyzer for the language. The assumption is that the analyzer can evaluate strings at run-time to yield values of the appropriate type, or can yield semantic structures to capture the meaning of the expression. For example, a type expression evaluates to a Classifier reference, and a boolean expression evaluates to a true or false value. The language itself is known to a modeling tool but is generally implicit on the diagram, under the assumption that the form of the expression makes its purpose clear.\n\n2.9.3 Example\n\nBankAccount\n\nBankAccount * (*) (Person*, int)\n\narray [1..20] of reference to range (-1.0..1.0) of Real\n\n[ i > j and self.size > i ]\n\n2.9.4 Mapping\n\nAn expression string maps to an Expression element (possibly a particular subclass of Expression, such as ObjectSetExpression or TimeExpression).\n\n2.9.5 OCL Expressions\n\nUML includes a definition of the OCL language, which is used to define constraints within the UML metamodel itself. The OCL language may be supported by tools for user-written expressions as well. Other possible languages include various computer languages as well as plain text (which cannot be parsed by a tool, of course, and is therefore only for human information).\n\n2.9.6 Selected OCL Notation\n\nSyntax for some common navigational expressions are shown below. These forms can be chained together. The leftmost element must be an expression for an object or a set of objects. The expressions are meant to work on sets of values when applicable. For more details and syntax see the OCL description.\nDiagram Elements\n\n*item* `. selector` the selector is the name of an attribute in the item or the name of a role of the target end of a link attached to the item. The result is the value of the attribute or the related object(s). The result is a value or a set of values depending on the multiplicities of the item and the association.\n\n*item* `. selector `[ `qualifier-value` `]` the selector designates a qualified association that qualifies the item. The selector is a value for the qualifier attribute. The result is the related object selected by the qualifier. Note that this syntax is applicable to array indexing as a form of qualification.\n\n*set* `→` `select` `(` `boolean-expression` `)` the boolean-expression is written in terms of objects within the set. The result is the subset of objects in the set for which the boolean expression is true.\n\n2.9.7 Example\n\n```\nflight.pilot.training_hours > flight.plane.minimum_hours\ncompany.employees→select (title = “Manager” and self.reports→size > 10)\n```\n\n2.10 Note\n\nA note is a graphical symbol containing textual information (possibly including embedded images). It is a notation for rendering various kinds of textual information from the metamodel, such as constraints, comments, method bodies, and tagged values.\n\n2.10.1 Semantics\n\nA note is a notational item. It show textual information within some semantic element.\n\n2.10.2 Notation\n\nA note is shown as a rectangle with a “bent corner” in the upper right corner. It contains arbitrary text. It appears on a particular diagram and may be attached to zero or more modeling elements by dashed lines.\n\n2.10.3 Presentation options\n\nA note may have a stereotype.\nA note with the stereotype “constraint” or a more specific form of constraint (such as the code body for a method) designates a constraint that is part of the model and not just part of a diagram view. Such a note is the view of a model element (the constraint). Other kinds of notes are purely notation; they have no underlying model element.\n\n### 2.10.4 Example\n\nSee also Section 4.1.3 for a note symbol containing a constraint.\n\nFigure 2. Note\n\nThis model was built by Alan Wright after meeting with the mission planning team.\n\n### 2.10.5 Mapping\n\nA note may represent the textual information in several possible metamodel constructs; it must be created in context that is known to a tool, and the tool must maintain the mapping. The string in the note maps to the body of the corresponding modeling element. A note may represent: a constraint; a tagged value; the body of a method; or other string values within modeling elements. It may also represent a comment attached directly to a diagram element.\n\n### 2.11 Type-Instance Correspondence\n\nA major purpose of modeling is to prepare generic descriptions that describe many specific particular items. This is often known as the type-instance dichotomy. Many or most of the modeling concepts in UML have this dual character, usually modeled by two paired modeling elements, one of which represents the generic descriptor and the other of which the individual items that it describes. Examples of such pairs in UML include: Class-Object, Association-Link, Parameter-Value, Operation-Call, and so on.\n\nAlthough diagrams for type-like elements and instance-like elements are not exactly the same, they share many similarities. Therefore it is convenient to choose notation for each type-instance pair of elements such that the correspondence is immediately visually apparent. There are a limited number of ways to do this, each with advantages and disadvantages. In UML the type-instance distinction is shown by employing the same geometrical symbol for each pair of elements and by underlining the name string (including type name, if present) of an instance element. This visual distinction is generally easily apparent without being overpowering even when an entire diagram contains instance elements.\nDiagram Elements\n\nFigure 3. Classes and objects\n\n<table>\n<thead>\n<tr>\n<th>Point</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>x: Real</td>\n</tr>\n<tr>\n<td>y: Real</td>\n</tr>\n<tr>\n<td>rotate (angle: Real)</td>\n</tr>\n<tr>\n<td>scale (factor: Real)</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>p1: Point</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>x = 3.14</td>\n</tr>\n<tr>\n<td>y = 2.718</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Point</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>x = 1</td>\n</tr>\n<tr>\n<td>y = 1.414</td>\n</tr>\n</tbody>\n</table>\n\nA tool is free to substitute a different graphic marker for instance elements at the user’s option, such as color, fill patterns, or so on.\n3. MODEL MANAGEMENT\n\n3.1 PACKAGES AND MODEL ORGANIZATION\n\n3.1.1 Semantics\n\nA package is a grouping of model elements. Packages themselves may be nested within other packages. A package may contain both subordinate packages and ordinary model elements. Some packages may be Subsystems or Models. The entire system description can be thought of as a single high-level subsystem package with everything else in it. All kinds of UML model elements and diagrams can be organized into packages.\n\nNote that packages own model elements and model fragments and are the basis for configuration control, storage, and access control. Each element can be directly owned by a single package, so the package hierarchy is a strict tree. However, packages can reference other packages, so the usage network is a graph.\n\nThere are several predefined stereotypes of Model and Subsystem. See the metamodel document for details. In particular, the stereotype «system» of Subsystem denotes the entire set of models for the complete system being modeled; it is the root of the package hierarchy and the only model element that is not owned by some other model element.\n\n3.1.2 Notation\n\nA package is shown as a large rectangle with a small rectangle (a “tab”) attached on one corner (usually the left side of the upper side of the large rectangle). It is a manila folder shape.\n\nIf contents of the package are not shown, then the name of the package is placed within the large rectangle.\n\nIf contents of the package are shown, then the name of the package may be placed within the tab.\n\nA keyword string may be placed above the package name. The keywords subsystem and model indicate that the package is a metamodel Subsystem or Model. The predefined stereotypes system, facade, framework, and top package are also notated with keywords. User-defined stereotypes of one of these predefined kinds of package are also notated with keywords, but they must not conflict with the predefined keywords.\n\nA list of properties as may be placed in braces after or below the package name. Example: {abstract}. See Section 4.2.2 for details of property syntax.\n\nThe contents of the package may be shown within the large rectangle.\n\nThe visibility of a package element outside the package may be indicated by preceding the name of the element by a visibility symbol (‘+’ for public, ‘-’ for private, ‘#’ for protected). If the element\nModel Management\n\nis an inner package, the visibilities of its elements as exported by the outer package are obtained by combining the visibilities of an element within the package with the visibility of the package itself: the most restrictive visibility results.\n\nRelationships may be drawn between package symbols to show relationships between at least some of the elements in the packages. In particular, dependency between packages implies that there exist one or more dependencies among the elements.\n\n3.1.3 Presentation options\n\nA tool may also show visibility by selectively displaying those elements that meet a given visibility level, e.g., all of the public elements only.\n\nA tool may show visibility by a graphic marker, such as color or font.\n\n3.1.4 Style guidelines\n\nIt is expected that packages with large contents will be shown as simple icons with names, in which the contents may be dynamically accessed by “zooming” to a detailed view.\n3.1.5 Example\n\nFigure 4. Packages and their dependencies\n\n3.1.6 Mapping\n\nA package symbol maps into a Package element. The name on the package symbol is the name of the Package element. If the package has a keyword that is a predefined keyword, then the package symbol maps into the corresponding subclass of Package or into the corresponding stereotype of Package; otherwise it maps into a user-defined stereotype of Package.\n\nA symbol directly contained within the package symbol (i.e., not contained within another symbol) maps into a model element owned by the package element. However, a symbol whose name is a pathname maps into a reference to a model element owned by another package; only the reference is owned by the current package. Relationships from the package symbol boundary map into relationships to the package element.\n4. GENERAL EXTENSION MECHANISMS\n\nThe elements in this chapter are general purpose mechanisms that may be applied to any modeling element. The semantics of a particular use depends on a convention of the user or an interpretation by a particular constraint language or programming language, therefore they constitute an extensibility device for UML.\n\n4.1 CONSTRAINT AND COMMENT\n\n4.1.1 Semantics\n\nA constraint is a semantic relationship among model elements that specifies conditions and propositions that must be maintained as true (otherwise the system described by the model is invalid, with consequences that are outside the scope of UML). Certain kinds of constraints (such as an association “or” constraint) are predefined in UML, others may be user-defined. A user-defined constraint is described in words in a given language, whose syntax and interpretation is a tool responsibility. A constraint represents semantic information attached to a model element, not just to a view of it.\n\nA comment is a text string (including references to human-readable documents) attached directly to a model element. This is syntactically equivalent to a constraint written in the language “text” whose meaning is significant to humans but which is not conceptually executable (except inasmuch as humans are regarded as the instruments of interpretation). A comment can therefore attach arbitrary textual information to any model element of presumed general importance.\n\n4.1.2 Notation\n\nA constraint is shown as a text string in braces ( { } ). There is an expectation that individual tools may provide one or more languages in which formal constraints may be written. One predefined language for writing constraints is OCL (defined in a companion document). Otherwise the constraint may be written in natural language. A constraint may be a “comment”; it that case it is written in text (possibly including pictures or other viewable documents) for “interpretation” by a human. Each constraint is written in a specific language, although the language is not generally displayed on the diagram (the tool must keep track of it).\n\nFor an element whose notation is a text string (such as an attribute, etc.): The constraint string may follow the element text string in braces.\n\nFor a list of elements whose notation is a list of text strings (such as the attributes within a class): A constraint string may appear as an element in the list. The constraint applies to all succeeding elements of the list until another constraint string list element or the end of the list. A constraint attached to an individual list element does not supersede the general constraint but may augment or modify individual constraints within the constraint string.\nGeneral Extension Mechanisms\n\nFor a single graphical symbol (such as a class or an association path): The constraint string may be placed near the symbol, preferably near the name of the symbol, if any.\n\nFor two graphical symbols (such as two classes or two associations): The constraint is shown as a dashed arrow from one element to the other element labeled by the constraint string (in braces). The direction of the arrow is relevant information within the constraint.\n\nFor three or more graphical symbols: The constraint string is placed in a note symbol and attached to each of the symbols by a dashed line. This notation may also be used for the other cases. For three or more paths of the same kind (such as generalization paths or association paths) the constraint may be attached to a dashed line crossing all of the paths.\n\nA comment is shown by a text string placed within a note symbol that is attached to a model element. The braces are omitted to show that this is purely a textual comment. (The braces therefore indicate a constraint expressed in some interpretable constraint language.)\n\n4.1.3 Example\n\nFigure 5. Constraints\n\n4.1.4 Mapping\n\nThe constraint string maps into the body expression in a Constraint element. The mapping depends on the language of the expression, which is known to a tool but generally not displayed on a dia-\nGeneral Extension Mechanisms\n\nIf the string lacks braces (i.e., a Comment), then it maps into an expression in the language “text”.\n\nA constraint string following a list entry maps into a Constraint attached to the element corresponding to the list entry.\n\nA constraint string represented as a stand-alone list element maps into a separate Constraint attached to each succeeding model element corresponding to subsequent list entries (until superseded by another constraint or property string).\n\nA constraint string placed near a graphical symbol must be attached to the symbol by a hidden link by a tool operating in context. The tool must maintain the graphical linkage implicitly. The constraint string maps into a Constraint attached to the element corresponding to the symbol.\n\nA constraint string attached to a dashed arrow maps into a constraint attached to the two elements corresponding to the symbols connected by the arrow.\n\nA constraint string in a note symbol maps into a Constraint attached to the elements corresponding to the symbols connected to the note symbol by dashed lines.\n\n4.2 ELEMENT PROPERTIES\n\nMany kinds of elements have detailed properties that do not have a visual notation. In addition, users can define new element properties using the tagged value mechanism.\n\nA string may be used to display properties attached to a model element. This includes properties represented by attributes in the metamodel as well as both predefined and user-defined tagged values.\n\n4.2.1 Semantics\n\nNote that we use property in a general sense to mean any value attached to a model element, including attributes, associations, and tagged values. In this sense it can include indirectly reachable values that can be found starting at a given element.\n\nA tagged value is a keyword-value pair that may be attached to any kind of model element (including diagram elements as well as semantic model elements). The keyword is called a tag. Each tag represents a particular kind of property applicable to one or many kinds of model elements. Both the tag and the value are encoded as strings. Tagged values are an extensibility mechanism of UML permitting arbitrary information to be attached to models. It is expected that most model editors will provide basic facilities for defining, displaying, and searching tagged values as strings but will not otherwise use them to extend the UML semantics. It is expected, however, that back-end tools such as code generators, report writers, and the like will read tagged values to alter their semantics in flexible ways.\n4.2.2 Notation\n\nA property (either a metamodel attribute or a tagged value) is displayed as a comma-delimited sequence of property specifications all inside a pair of braces ( { } ).\n\nA property specification has the form\n\n\\[ \\text{keyword} = \\text{value} \\]\n\nwhere keyword is the name of a property (metamodel attribute or arbitrary tag) and value is an arbitrary string that denotes its value. If the type of the property is Boolean, then the default value is true if the value is omitted. (That is, to specify a value of true you may include just the keyword; to specify a value of false you omit the name completely.) Properties of other types require explicit values. The syntax for displaying the value is a tool responsibility in cases where the underlying model value is not a string or a number.\n\nNote that property strings may be used to display built-in attributes as well as tagged values.\n\n4.2.3 Presentation options\n\nA tool may present property specifications on separate lines with or without the enclosing braces, provided they are appropriately marked to distinguish them from other information. For example, properties for a class might be listed under the class name in a distinctive typeface, such as italics or a different font family.\n\n4.2.4 Style guidelines\n\nIt is legal to use strings to specify properties that have graphical notations but such usage may be confusing and should be used with care.\n\n4.2.5 Example\n\n\\{ author = “Joe Smith”, deadline = 31-March-1997, status = analysis \\}\n\n\\{ abstract \\}\n\n4.2.6 Mapping\n\nEach term within a string maps to either a built-in attribute of a model element or a tagged value (predefined or user-defined). A tool must enforce the correspondence to built-in attributes.\n4.3 Stereotypes\n\n4.3.1 Semantics\n\nA stereotype is, in effect, a new class of modeling element that is introduced at modeling time. It represents a subclass of an existing modeling element with the same form (attributes and relationships) but with a different intent. Generally a stereotype represents a usage distinction. A stereotyped element may have additional constraints on it from the base class. It is expected that code generators and other tools will treat stereotyped elements specially. Stereotypes represent one of the built-in extensibility mechanisms of UML.\n\n4.3.2 Notation\n\nThe general presentation of a stereotype is to use the symbol for the base element but to place a keyword string above the name of the element (if any); the keyword string is the name of the stereotype within matched guillemets, which are the quotation mark symbols used in French and certain other languages, as for example: «foo». (Note that a guillemet looks like a double angle-bracket but it is a single character in most extended fonts. Most computers have a Character Map utility. Double angle-brackets may be used as a substitute by the typographically challenged.) The keyword string is generally placed above or in front of the name of the model element being described. The keyword string may also be used as an element in a list, in which case it applies to subsequent list elements until another stereotype string replaces it, or an empty stereotype string («») nullifies it. Note that a stereotype name should not be identical to a predefined keyword applicable to the same element type.\n\nTo permit limited graphical extension of the UML notation as well, a graphic icon or a graphic marker (such as texture or color) can be associated with a stereotype. The UML does not specify the form of the graphic specification, but many bitmap and stroked formats exist (and their portability is a difficult problem). The icon can be used in one of two ways: it may be used instead of or in addition to the stereotype keyword string as part of the symbol for the base model element that the stereotype is based on; for example, in a class rectangle it is placed in the upper right corner of the name compartment. In this form, the normal contents of the item can be seen. Alternately, the entire base model element symbol may be “collapsed” into an icon containing the element name or with the name above or below the icon. Other information contained by the base model element symbol is suppressed. More general forms of icon specification and substitution are conceivable but we leave these to the ingenuity of tool builders, with the warning that excessive use of extensibility capabilities may lead to loss of portability among tools.\n\nUML avoids the use of graphic markers, such as color, that present challenges for certain persons (the color blind) and for important kinds of equipment (such as printers, copiers, and fax machines). None of the UML symbols require the use of such graphic markers. Users may use graphic markers freely in their personal work for their own purposes (such as for highlighting within a tool) but should be aware of their limitations for interchange and be prepared to use the canonical forms when necessary.\nThe classification hierarchy of the stereotypes themselves could be displayed on a class diagram; however, this would be a metamodel diagram and must be distinguished (by user and tool) from an ordinary model diagram. In such a diagram each stereotype is shown as a class with the stereotype «stereotype» (yes, this is a self-referential usage!). Generalization relationships may show the extended metamodel hierarchy. Because of the danger of extending the internal metamodel hierarchy, a tool may, but need not, expose this capability on class diagrams; this is not a capability required by ordinary modelers.\n\n**4.3.3 Example**\n\nFigure 6. Varieties of stereotype notation\n\n**4.3.4 Mapping**\n\nThe use of a stereotype keyword maps into the stereotype relationship between the Element corresponding to the symbol containing the name and the Stereotype of the given name. The use of a stereotype icon within a symbol maps into the stereotype relationship between the Element corresponding to the symbol containing the icon and the Stereotype represented by the symbol; a tool must establish the connection when the symbol is created and there is no requirement that an icon represent uniquely one stereotype. The use of a stereotype icon instead of a symbol must be created in a context in which a tool implies a corresponding model element and a Stereotype represented by the icon; the element and the stereotype have the stereotype relationship.\n5. STATIC STRUCTURE DIAGRAMS\n\nClass diagrams show the static structure of the model, in particular, the things that exist (such as classes and types), their internal structure, and their relationships to other things. Class diagrams do not show temporal information, although they may contain reified occurrences of things that have or things that describe temporal behavior. An object diagram shows instances compatible with a particular class diagram.\n\nThis chapter includes classes and their variations, including templates and instantiated classes, and the relationships between classes: association and generalization. It includes the contents of classes: attributes and operations.\n\n5.1 CLASS DIAGRAM\n\nA class diagram is a graph of Classifier elements connected by their various static relationships. (Note that a “class” diagram may also contain interfaces, packages, relationships, and even instances, such as objects and links. Perhaps a better name would be “static structural diagram” but “class diagram” is shorter and well established.)\n\n5.1.1 Semantics\n\nA class diagram is a graphic view of the static structural model. The individual class diagrams do not represent divisions in the underlying model.\n\n5.1.2 Notation\n\nA class diagram is a collection of (static) declarative model elements, such as classes, interfaces, and their relationships, connected as a graph to each other and to their contents. Class diagrams may be organized into packages either with their underlying models or as separate packages that build upon the underlying model packages.\n\n5.1.3 Mapping\n\nA class diagram does not necessarily match a single semantic entity. A package within the static structural model may be represented by one or more class diagrams; the division of the presentation into separate diagrams is for graphical convenience and does not imply a partitioning of the model itself. The contents of a diagram map into elements in the static semantic model. If a diagram is part of a package, then its contents map into elements in the same package.\n5.2 **Object Diagram**\n\nAn object diagram is a graph of instances, including objects and data values. A static object diagram is an instance of a class diagram; it shows a snapshot of the detailed state of a system at a point in time. The use of object diagrams is fairly limited, mainly to show examples of data structures.\n\nTools need not support a separate format for object diagrams. Class diagrams can contain objects, so a class diagram with objects and no classes is an “object diagram.” The phrase is useful, however, to characterize a particular usage achievable in various ways.\n\n5.3 **Classifier**\n\n*Classifier* is the metamodel superclass of *Class, DataType, and Interface*. All of these have similar syntax and are therefore all notated using the rectangle symbol with keywords used as necessary. Because classes are most common in diagrams, a rectangle without a keyword represents a class, and the other subclasses of *Classifier* are indicated with keywords. In the sections that follow, the discussion will focus on *Class*, but most of the notation applies to the other element kinds as semantically appropriate and as described later under their own sections.\n\n5.4 **Class**\n\nA *class* is the descriptor for a set of objects with similar structure, behavior, and relationships. UML provides notation for declaring classes and specifying their properties, as well as using classes in various ways. Some modeling elements that are similar in form to classes (such as interfaces, signals, or utilities) are notated using keywords on class symbols; some of these are separate metamodel classes and some are stereotypes of Class. Classes are declared in class diagrams and used in most other diagrams. UML provides a graphical notation for declaring and using classes, as well as a textual notation for referencing classes within the descriptions of other model elements.\n\n5.4.1 **Semantics**\n\nA class represents a concept within the system being modeled. Classes have data structure and behavior and relationships to other elements.\n\nThe name of a class has scope within the package in which it is declared and the name must be unique (among class names) within its package.\n\n5.4.2 **Basic notation**\n\nA class is drawn as a solid-outline rectangle with 3 compartments separated by horizontal lines. The top name compartment holds the class name and other general properties of the class (including ste-\nStatic Structure Diagrams\n\nreotype); the middle list compartment holds a list of attributes; the bottom list compartment holds a list of operations.\n\nSee the sections on Name Compartment and List Compartment for more details.\n\nReferences. By default a class shown within a package is assumed to be defined within that package. To show a reference to a class defined in another package, use the syntax\n\n\\[ \\text{Package-name}::\\text{Class-name} \\]\n\nas the name string in the name compartment. Compartment names can be used to remove ambiguity, if necessary (Section 5.6.1). A full pathname can be specified by chaining together package names separated by double colons (::).\n\n5.4.3 Presentation options\n\nEither or both of the attribute and operation compartments may be suppressed. A separator line is not drawn for a missing compartment. If a compartment is suppressed, no inference can be drawn about the presence or absence of elements in it.\n\nAdditional compartments may be supplied as a tool extension to show other predefined or user-defined model properties, for example, to show business rules, responsibilities, variations, events handled, exceptions raised, and so on. Most compartments are simply lists of strings. More complicated formats are possible, but UML does not specify such formats; they are a tool responsibility. Appearance of each compartment should preferably be implicit based on its contents. Compartment names may be used if needed.\n\nTools may provide other ways to show class references and to distinguish them from class declarations.\n\nA class symbol with a stereotype icon may be “collapsed” to show just the stereotype icon, with the name of the class either inside the class or below the icon. Other contents of the class are suppressed.\n\n5.4.4 Style guidelines\n\n(Note that these are recommendations, not mandates.)\n\nCenter class name in boldface.\n\nCenter stereotype name in plain face within guillemets above class name.\n\nBeing class names with an uppercase letter.\n\nLeft justify attributes and operations in plain face.\n\nBegin attribute and operation names with a lowercase letter.)\nShow the names of abstract classes or the signatures of abstract operations in italics.\n\nAs a tool extension, boldface may be used for marking special list elements, for example, to designate candidate keys in a database design. This might encode some design property modeled as a tagged value, for example.\n\nShow full attributes and operations when needed and suppress them in other contexts or references.\n\n### 5.4.5 Example\n\nFigure 7. Class notation: details suppressed, analysis-level details, implementation-level details\n\n---\n\n<table>\n<thead>\n<tr>\n<th>Window</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>size: Area</td>\n</tr>\n<tr>\n<td>visibility: Boolean</td>\n</tr>\n<tr>\n<td>display ()</td>\n</tr>\n<tr>\n<td>hide ()</td>\n</tr>\n</tbody>\n</table>\n\n**Window**\n\n- +default-size: Rectangle\n- #maximum-size: Rectangle\n- xptr: XWindow*\n- +create ()\n- +display ()\n- +hide ()\n- -attachXWindow(xwin:Xwindow*)\n\n---\n\n### 5.4.6 Mapping\n\nA class symbol maps into a Class element within the package that owns the diagram. The name compartment contents map into the class name and into properties of the class (built-in attributes or tagged values). The attribute compartment maps into a list of Attributes of the Class. The operation compartment maps into a list of Operations of the Class.\n\n### 5.5 NAME COMPARTMENT\n\n#### 5.5.1 Notation\n\nDisplays the name of the class and other properties in up to 3 sections:\nStatic Structure Diagrams\n\nAn optional stereotype keyword may be placed above the class name within guillemets, and/or a stereotype icon may be placed in the upper right corner of the compartment. The stereotype name must not match a predefined keyword.\n\nThe name of the class appears next. If the class is abstract, its name appears in italics. But note that any explicit specification of generalization status take precedence over the name font.\n\nA list of strings denoting properties (metamodel attributes or tagged values) may be placed in braces below the class name. The list may show class-level attributes for which there is no UML notation and it may also show tagged values. The presence of a keyword for a Boolean type without a value implies the value true. For example, a leaf class shows the property “{leaf}”.\n\nThe stereotype and property list are optional.\n\n5.5.2 Mapping\n\nThe contents of the name compartment map into the name, stereotype, and various properties of the Class represented by the class symbol.\n\n5.6 LIST COMPARTMENT\n\n5.6.1 Notation\n\nHolds a list of strings, each of which is the encoded representation of a feature, such as an attribute or operation. The strings are presented one to a line with overflow to be handled in a tool-dependent manner. In addition to lists of attributes or operations, optional lists can show other kinds of pre-defined or user-defined values, such as responsibilities, rules, or modification histories; UML does not define these optional lists. The manipulation of user-defined lists is tool-dependent.\n\nThe items in the list are ordered and the order may be modified by the user. The order of the elements is meaningful information and must be accessible within tools. For example, it may be used by a code generator in generating a list of declarations. The list elements may be presented in a different order, however, to achieve some other purpose. For example, they may be sorted in some way.\nStatic Structure Diagrams\n\nEven if the list is sorted, however, the items maintain their original order in the underlying model; the ordering information is merely suppressed in the view.\n\nAn ellipsis ( . . . ) as the final element of a list or the final element of a delimited section of a list indicates that there exist additional elements in the model that meet the selection condition but that are not shown in that list. Such elements may appear in a different view of the list.\n\n**Group properties**: A property string may be shown as a element of the list, in which case it applies to all of the succeeding list elements until another property string appears as a list element. This is equivalent to attaching the property string to each of the list elements individually. The property string does not designate a model element. Examples of this usage include indicating a stereotype and specifying visibility. Keyword strings may also be used in a similar way to qualify subsequent list elements.\n\n**Compartment name**: A compartment may display a name to indicate which kind of compartment it is. The name is displayed in a distinctive font centered at the top of the compartment. This capability is useful if some compartments are omitted or if additional user-defined compartments are added. For a Class, the predefined compartments are named **attributes** and **operations**. An example of a user-defined compartment might be **requirements**. The name compartment in a class must always be present and therefore does not require or permit a compartment name.\n\n### 5.6.2 Presentation options\n\nA tool may present the list elements in a sorted order, in which case the inherent ordering of the elements is not visible. A sort is based on some internal property and does not indicate additional model information. Example sort rules include alphabetical order, ordering by stereotype (such as constructors, destructors, then ordinary methods), ordering by visibility (public, then protected, then private), etc.\n\nThe elements in the list may be filtered according to some selection rule. The specification of selection rules is a tool responsibility. The absence of items from a filtered list indicates that no elements meet the filter criterion, but no inference can be drawn about the presence or absence of elements that do not meet the criterion (however, the ellipsis notation is available to show that invisible elements exist). It is a tool responsibility whether and how to indicate the presence of either local or global filtering, although a stand-alone diagram should have some indication of such filtering if it is to be understandable.\n\nIf a compartment is suppressed, no inference can be drawn about the presence or absence of its elements. An empty compartment indicates that no elements meet the selection filter (if any).\n\nNote that attributes may also be shown by composition (see Figure 25).\n5.6.3 Example\n\nFigure 9. Stereotype keyword applied to groups of list elements\n\n```\nRectangle\np1:Point\np2:Point\n\n«constructor»\nRectangle(p1:Point, p2:Point)\n\n«query»\narea (): Real\naspect (): Real\n.\n.\n«update»\nmove (delta: Point)\nscale (ratio: Real)\n.\n.\n```\n\nFigure 10. Compartments with names\n\n```\nReservation\noperations\nguarantee()\ncancel ()\nchange (newDate: Date)\n\nresponsibilities\nbill no-shows\nmatch to available rooms\n\nexceptions\ninvalid credit card\n```\n5.6.4 Mapping\n\nThe entries in a list compartment map into a list of ModelElements, one for each list entry. The ordering of the ModelElements matches the list compartment entries unless the list compartment is sorted in some way), in which case no implication about the ordering of the Elements can be made (the ordering can be seen by turning off sorting). However, a list entry string that is a stereotype indication (within guillemets) or a property indication (within braces) does not map into a separate ModelElement. Instead the corresponding property applies to each subsequent ModelElement until the appearance of a different stand-alone stereotype or property indicator. The property specifications are conceptually duplicated for each list Element, although a tool might maintain an internal mechanism to store or modify them together. The presence of an ellipsis (“...”) as a list entry implies that the semantic model contains at least one Element with corresponding properties that is not visible in the list compartment.\n\n5.7 ATTRIBUTE\n\nUsed to show attributes in classes. A similar syntax is used to specify qualifiers, template parameters, operation parameters, and so on (some of these omit certain terms).\n\n5.7.1 Semantics\n\nNote that an attribute is semantically equivalent to a composition association. However, the intent and usage is normally different.\n\nThe type of an attribute is a TypeExpression. It may resolve to a class name or it may be complex, such as `array[String] of Point`. In any case, the details of the attribute type expressions are not specified by UML; they depend on the expression syntax supported by the particular specification or programming language being used.\n\n5.7.2 Notation\n\nAn attribute is shown as a text string that can be parsed into the various properties of an attribute model element. The default syntax is:\n\n```\nvisibility name : type-expression = initial-value { property-string }\n```\n\nwhere `visibility` is one of:\n\n```\n+ public visibility\n#\nprotected visibility\n- private visibility\n```\nThe visibility marker may be suppressed. The absence of a visibility marker indicates that the visibility is not shown (not that it is undefined or public). A tool should assign visibilities to new attributes even if the visibility is not shown. The visibility marker is a shorthand for a full visibility property specification string.\n\nVisibility may also be specified by keywords (public, protected, private). This form is particularly used when used as an inline list element that applies to an entire block of attributes.\n\nAdditional kinds of visibility might be defined for certain programming languages, such as C++ implementation visibility (actually all forms of nonpublic visibility are language-dependent). Such visibility must be specified by property string or by a tool-specific convention.\n\nwhere name is an identifier string that represents the name of the attribute;\n\nwhere type-expression is a language-dependent specification of the implementation type of an attribute;\n\nwhere initial-value is a language-dependent expression for the initial value of a newly created object. The initial value is optional (the equal sign is also omitted). An explicit constructor for a new object may augment or modify the default initial value;\n\nwhere property-string indicates property values that apply to the element. The property string is optional (the braces are omitted if no properties are specified);\n\nA class-scope attribute is shown by underlining the name and type expression string; otherwise the attribute is instance-scope. The notation justification is that a class-scope attribute is an instance value in the executing system, just as an object is an instance value, so both may be designated by underlining. An instance-scope attribute is not underlined; that is the default.\n\n\\emph{class-scope-attribute}\n\nThere is no symbol for whether an attribute is changeable (the default is changeable). A nonchangeable attribute is specified with the property “\\{frozen\\}”.\n\nIn the absence of a multiplicity indicator an attribute holds exactly 1 value. Multiplicity may be indicated by placing a multiplicity indicator in brackets after the attribute name, for example:\n\n\\begin{quote}\n colors [3]: Color \n points [2..*]: Point\n\\end{quote}\n\nNote that a multiplicity of 0..1 provides for the possibility of null values: the absence of a value, as opposed to a particular value from the range. For example, the following declaration permits a distinction between the \\textit{null} value and the empty string:\n\n\\begin{quote}\n name [0..1]: String\n\\end{quote}\n\nA stereotype keyword in guillemets precedes the entire attribute string, including any visibility indicators. A property list in braces follows the entire attribute string.\n5.7.3 Presentation options\n\nThe type expression may be suppressed (but it has a value in the model).\n\nThe initial value may be suppressed, and it may be absent from the model. It is a tool responsibility whether and how to show this distinction.\n\nA tool may show the visibility indication in a different way, such as by using a special icon or by sorting the elements by group.\n\nA tool may show the individual fields of an attribute as columns rather than a continuous string.\n\nThe syntax of the attribute string can be that of a particular programming language, such as C++ or Smalltalk. Specific tagged properties may be included in the string.\n\nParticular attributes within a list may be suppressed (see List Compartment).\n\n5.7.4 Style guidelines\n\nAttribute names typically begin with a lowercase letter.\n\nAttribute names in plain face.\n\n5.7.5 Example\n\n+size: Area = (100,100)\n#visibility: Boolean = invisible\n+default-size: Rectangle\n#maximum-size: Rectangle\n-xptr: XWindowPtr\n\n5.7.6 Mapping\n\nA string entry within the attribute compartment maps into an Attribute within the Class representing the class symbol. The properties of the attribute map in accord with the preceding descriptions. If the visibility is absent, then no conclusion can be drawn about the Attribute visibilities unless a filter is in effect (e.g., only public attributes shown). Likewise if the type or initial value are omitted. The omission of an underline always indicates an instance-scope attribute, however. The omission of multiplicity denotes a multiplicity of 1.\n\nAny properties specified in braces following the attribute string map into properties on the Attribute. In addition, any properties specified on a previous stand-alone property specification entry apply to the current Attribute (and to others).\n5.8 **OPERATION**\n\nUsed to show operations defined on classes. Also used to show methods supplied by classes.\n\n5.8.1 **Operation**\n\nAn operation is a service that an instance of the class may be requested to perform. It has a name and a list of arguments.\n\n5.8.2 **Notation**\n\nAn operation is shown as a text string that can be parsed into the various properties of an operation model element. The default syntax is:\n\n\\[\n\\text{visibility name (parameter-list) : return-type-expression \\{ property-string \\}}\n\\]\n\nwhere `visibility` is one of:\n\n- + public visibility\n- # protected visibility\n- - private visibility\n\nThe visibility marker may be suppressed. The absence of a visibility marker indicates that the visibility is not shown (not that it is undefined or public). The visibility marker is a shorthand for a full `visibility` property specification string.\n\nVisibility may also be specified by keywords (`public`, `protected`, `private`). This form is particularly used when used as an inline list element that applies to an entire block of operations.\n\nAdditional kinds of visibility might be defined for certain programming languages, such as C++ `implementation` visibility (actually all forms of nonpublic visibility are language-dependent). Such visibility must be specified by property string or by a tool-specific convention.\n\nwhere `name` is an identifier string;\n\nwhere `return-type-expression` is a language-dependent specification of the implementation type or types of the value returned by the operation. If the return-type is omitted if the operation does not return a value (C++ void). A list of expressions may be supplied to indicate multiple return values.\n\nwhere `parameter-list` is a comma-separated list of formal parameters, each specified using the syntax:\n\n\\[\n\\text{kind name : type-expression = default-value}\n\\]\nwhere \\textit{kind} is \\textbf{in}, \\textbf{out}, or \\textbf{inout}, with the default \\textbf{in} if absent;\n\nwhere \\textit{name} is the name of a formal parameter;\n\nwhere \\textit{type-expression} is the (language-dependent) specification of an implementation type;\n\nwhere \\textit{default-value} is an optional value expression for the parameter, expressed in and subject to the limitations of the eventual target language;\n\nwhere \\textit{property-string} indicates property values that apply to the element. The property string is optional (the braces are omitted if no properties are specified);\n\nA class-scope operation is shown by underlining the name and type expression string. An instance-scope operation is the default and is not marked.\n\nAn operation that does not modify the system state (one that has no side effects) is specified by the property “\\{query\\}”; otherwise the operation may alter the system state, although there is no guarantee that it will do so.\n\nThe concurrency semantics of an operation are specified by a property string with one of the names: \\textit{sequential}, \\textit{guarded}, \\textit{concurrent}. In the absence of a specification the concurrency semantics are undefined and must be assumed to be sequential in the worst case.\n\nThe top-most appearance of an operation signature declares the operation on the class (and therefore inherited by all of its descendents). If this class does not implement the operation (i.e., does not supply a method) then the operation may be marked as “\\{abstract\\}” or the operation signature may be italicized to indicate that it is abstract. Any subordinate appearances of the operation signature indicate that the subordinate class implements a method on the operation. (The specification of “\\{abstract\\}” or italics on a subordinate class would not indicate a method but this usage of the notation would be poor form.)\n\nThe actual text or algorithm of a method may be indicated in a note attached to the operation entry.\n\nAn operation entry with the stereotype «signal» indicates that the class accepts the given signal. The syntax is identical to that of an operation.\n\nThe specification of operation behavior is given as a note attached to the operation. The text of the specification should be enclosed in braces if it is a formal specification in some language (a semantic Constraint), otherwise it should be plain text if it is just a natural-language description of the behavior (a Comment).\n\nA stereotype keyword in guillemets precedes the entire operation string, including any visibility indicators. A property list in braces follows the entire operation string.\n\n\\section*{5.8.3 Presentation options}\n\nThe argument list and return type may be suppressed (together, not separately).\nStatic Structure Diagrams\n\nA tool may show the visibility indication in a different way, such as by using a special icon or by sorting the elements by group.\n\nThe syntax of the operation signature string can be that of a particular programming language, such as C++ or Smalltalk. Specific tagged properties may be included in the string.\n\n5.8.4 Style guidelines\n\nOperation names typically begin with a lowercase letter.\n\nOperation names in plain face.\n\nAn abstract operation may be shown in italics.\n\n5.8.5 Example\n\nFigure 11. Operation list with a variety of operations\n\n+display (): Location\n+hide ()\n+create ()\n-attachXWindow(xwin:Xwindow*)\n\n5.8.6 Mapping\n\nA string entry within the operation compartment maps into an Operation or a Method within the Class representing the class symbol. The properties of the operation map in accord with the preceding descriptions. See the description of Attribute for additional details.\n\nThe topmost appearance of an operation specification in a class hierarchy maps into an Operation definition in the corresponding Class or Interface. Interfaces do not have methods. In a Class, each appearance of an operation entry maps into the presence of a Method in the corresponding Class, unless the operation entry contains the {abstract} property (including use of conventions such as italics for abstract operations). If an abstract operation entry appears within a hierarchy in which the same operation has already been defined in an ancestor, it has no effect but is not an error unless the declarations are inconsistent.\n\nNote that the operation string entry does not specify the body of a method.\n\n5.8.7 Signal reception\n\nIf the objects of a class accept and respond to a given signal, that fact can be indicated using the same syntax as an operation with the keyword «signal». The response of the object to the reception\nof the signal is shown with a state machine. Among other uses, this notation can show the response of objects of a class to error conditions and exceptions, which should be modeled as signals.\n\n5.9 TYPE VS. IMPLEMENTATION CLASS\n\n5.9.1 Semantics\n\nClasses can be specialized by stereotypes into Types and Implementation Classes (although they can be left undifferentiated as well). A Type characterizes a changeable role that an object may adopt and later abandon. An Implementation Class defines the physical data structure and procedures of an object as implemented in traditional languages (C++, Smalltalk, etc.). An object may have multiple Types (which may change dynamically) but only one ImplementationClass (which is fixed). Although the usage of Types and ImplementationClasses is different, their internal structure is the same, so they are modeled as stereotypes of Class. All kinds of Class require that a subclass fully support the features of the superclass, including support for all inherited attributes, associations, and operations.\n\n5.9.2 Notation\n\nAn undifferentiated class is shown with no stereotype. A type is shown with the stereotype “«type»”. An implementation class is shown with the stereotype “«implementation class»”. A tool is also free to allow a default setting for an entire diagram, in which case all of the class symbols without explicit stereotype indications map into Classes with the default stereotype; this might be useful for a model that is close to the programming level.\n\nThe implementation of a type by an implementation class is modeled as the Realizes relationship, shown as a dashed line with a solid triangular arrowhead (a dashed “generalization arrow”). This symbol implies inheritance of operations but not of structure (attributes or associations).\n5.9.3 Example\n\nFigure 12. Notation for types and implementation classes\n\n5.9.4 Mapping\n\nA class symbol with a stereotype (including “type” and “implementation class”) maps into a Class with the corresponding stereotype. A class symbol without a stereotype maps into a Class with the default stereotype for the diagram (if a default has been defined by the modeler or tool), otherwise it maps into a Class with no stereotype. This symbol is normally used between a class and an interface but may also be used between any two classifiers to show inheritance of operations only without inheritance of attributes or associations.\n\n5.10 INTERFACES\n\n5.10.1 Semantics\n\nAn interface is a specifier for the externally-visible operations of a class, component, or other entity (including summarization units such as packages) without specification of internal structure. Each interface often specifies only a limited part of the behavior of an actual class. Interfaces do not have\nimplementation; they lack attributes, states, or associations; they only have operations. Interfaces may have generalization relationships. An interface is formally equivalent to an abstract class with no attributes and no methods and only abstract operations, but Interface is a peer of Class within the UML metamodel; both are Classifiers.\n\n5.10.2 Notation\n\nAn interface is a Classifier and may also be shown using the full rectangle symbol with compartments and the keyword «interface». A list of operations supported by the interface is placed in the operation compartment. The attribute compartment may be omitted because it is always empty.\n\nAn interface may also be displayed as a small circle with the name of the interface placed below the symbol. The circle may be attached by a solid line to classes that support it (also to higher-level containers, such as packages that contain the classes). This indicates that the class provides all of the operations in the interface type (and possibly more). The operations provided are not shown on the circle notation; use the full rectangle symbol to show the list of operations. A class that uses or requires the operations supplied by the interface may be attached to the circle by a dashed arrow pointing to the circle. The dashed arrow implies that the class requires no more than the operations specified in the interface; the client class is not required to actually use all of the interface operations.\n\nThe Realizes relationship from a class to an interface that it supports is shown by a dashed line with a solid triangular arrowhead (a “dashed generalization symbol”). This is the same notation used to indicate realization of a type by an implementation class. In fact, this symbol can be used between any two classifier symbols, with the meaning that the client (the one at the tail of the arrow) supports at least all of the operations defined in the supplier (the one at the head of the arrow), but with no necessity to support any of the data structure of the supplier (attributes and associations).\n5.10.3 Example\n\nFigure 13. Interface notation on class diagram\n\n5.10.4 Mapping\n\nA class rectangle symbol with stereotype «interface» or a circle on a class diagram maps into an Interface element with the name given by the symbol. The operation list of a rectangle symbol maps into the list of Operation elements of the Interface.\n\nA dashed generalization arrow from a class symbol to an interface symbol or a solid line connecting a class symbol and an interface circle maps into a realization-specification relationship between the corresponding Class and Interface elements. A dependency arrow from a class symbol to an interface symbol maps into a «uses» dependency between the corresponding Class and Interface.\n\n5.11 Parameterized Class (Template)\n\n5.11.1 Semantics\n\nA template is the descriptor for a class with one or more unbound formal parameters. It therefore defines a family of classes, each class specified by binding the parameters to actual values. Typically the parameters represent attribute types, but they can also represent integers, other types, or\neven operations. Attributes and operations within the template are defined in terms of the formal parameters so they too become bound when the template itself is bound to actual values.\n\nA template is not a directly-usable class because it has unbound parameters. Its parameters must be bound to actual values to create a bound form that is a class. Only a class can be a superclass or the target of an association (a one-way association from the template to another class is permissible, however). A template may be a subclass of an ordinary class; this implies that all classes formed by binding it are subclasses of the given superclass.\n\nParameterization can be applied to other ModelElements, such as Collaborations or even entire Packages. The description given here for classes applies to other kinds of modeling elements in the obvious way.\n\n### 5.11.2 Notation\n\nA small dashed rectangle is superimposed on the upper right-hand corner of the rectangle for the class (or to the symbol for another modeling element). The dashed rectangle contains an parameter list of formal parameters for the class and their implementation types. The list must not be empty, although it might be suppressed in the presentation. The name, attributes, and operations of the parameterized class appear as normal in the class rectangle, but they may also include occurrences of the formal parameters. Occurrences of the formal parameters can also occur inside of a context for the class, for example, to show a related class identified by one of the parameters.\n\n### 5.11.3 Presentation options\n\nThe parameter list may be comma-separated or it may be one per line.\n\nParameters are restricted attributes, shown as strings with the syntax\n\n```plaintext\nname : type\n```\n\nwhere `name` is an identifier for the parameter with scope inside the template;\n\nwhere `type` is a string designating a `TypeExpression` for the parameter.\n\nIf the type name is omitted, it is assumed to be a type expression that resolves to a classifier, such as a class name or a data type. Other parameter types (such as `Integer`) must be explicitly shown; they must resolve to valid type expressions.\n### 5.11.4 Example\n\nFigure 14. Template notation with use of parameter as a reference\n\n```\nFArray\n\nk..k\n```\n\nA template cannot be used directly in an ordinary relationship such as generalization or association, because it has a free parameter that is not meaningful outside of a scope that declares the parameter. To be used, a template’s parameters must be bound to actual values. The actual value for each parameter is an expression defined within the scope of use. If the referencing scope is itself a template, then the parameters of the referencing template can be used as actual values in binding the referenced template, but the parameter names in the two templates cannot be assumed to correspond, because they have no scope outside of their respective templates.\n5.12.2 Notation\n\nA bound element is indicated by a text syntax in the name string of an element, as follows:\n\nTemplate-name ‘<’ value-list ‘>’\n\nwhere value-list is a comma-delimited non-empty list of value expressions;\nwhere Template-name is identical to the name of a template.\n\nFor example, VArray<Point,3> designates a class described by the template Varray.\n\nThe number and types of the values must match the number and types of the template parameters for the template of the given name.\n\nThe bound element name may be used anywhere that an element name of the parameterized kind could be used. For example, a bound class name could be used within a class symbol on a class diagram, as an attribute type, or as part of an operation signature.\n\nNote that a bound element is fully specified by its template, therefore its content may not be extended; declaration of new attributes or operations for classes is not permitted, for example, but a bound class could be subclassed and the subclass extended in the usual way.\n\nThe relationship between the bound element and its template may alternatively be shown by a Dependency relationship with the keyword «bind». The arguments are shown in parentheses after the keyword. In this case the bound form may be given a name distinct from the template.\n\n5.12.3 Style guidelines\n\nThe attribute and operation compartments are normally suppressed within a bound class, because they must not be modified in a bound template.\n\n5.12.4 Example\n\nSee Figure 14.\n\n5.12.5 Mapping\n\nThe use of the bound element syntax for the name of a symbol maps into a Binding dependency between the dependent ModelElement (such as Class) corresponding to the bound element symbol and the provider ModelElement (again, such as Class) whose name matches the name part of the bound element without the arguments. If the name does not match a template element or if the number of arguments in the bound element does not match the number of parameters in the template, then the model is ill formed. Each argument in the bound element maps into a ModelElement.\nStatic Structure Diagrams\n\nbearing a templateArgument association to the Namespace of the bound element. The Binding relationship bears the list of actual argument values.\n\n5.13 Utility\n\nA utility is a grouping of global variables and procedures in the form of a class declaration. This is not a fundamental construct but a programming convenience. The attributes and operations of the utility become global variables and procedures. A utility is modeled as a stereotype of a class.\n\n5.13.1 Semantics\n\nThe instance-scope attributes and operations of a utility are interpreted as global attributes and operations. It is inappropriate for a utility to declare class-scope attributes and operations because the instance-scope members are already interpreted as being at class scope.\n\n5.13.2 Notation\n\nShown as the stereotype «utility» of Class. It may have both attributes and operations, all of which are treated as global attributes and operations.\n\n5.13.3 Example\n\nFigure 15. Notation for utility\n\n```\n<utility>\n MathPak\n sin (Angle): Real\n cos (Angle): Real\n sqrt (Real): Real\n random(): Real\n```\n\n5.13.4 Mapping\n\nThis is not a special symbol. It simply maps into a Class element with the «utility» stereotype.\n5.14 **METACLASS**\n\n5.14.1 Semantics\n\nA metaclass is a class whose instances are classes.\n\n5.14.2 Notation\n\nShown as the stereotype «metaclass» of Class.\n\n5.14.3 Mapping\n\nThis is not a special symbol. It simply maps into a Class element with the «metaclass» stereotype.\n\n5.15 **CLASS PATHNAMES**\n\n5.15.1 Notation\n\nClass symbols (rectangles) serve to define a class and its properties, such as relationships to other classes. A reference to a class in a different package is notated by using a pathname for the class, in the form:\n\n```\npackage-name :: class-name\n```\n\nReferences to classes also appear in text expressions, most notably in type specifications for attributes and variables. In these places a reference to a class is indicated by simply including the name of the class itself, including a possible package name, subject to the syntax rules of the expression.\n5.15.2 Example\n\nFigure 16. Pathnames for classes in other packages\n\n```\n<table>\n<thead>\n<tr>\n<th>Banking::CheckingAccount</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Deposit</td>\n</tr>\n<tr>\n<td>time: DateTime::Time</td>\n</tr>\n<tr>\n<td>amount: Currency::Cash</td>\n</tr>\n</tbody>\n</table>\n```\n\n5.15.3 Mapping\n\nA class symbol whose name string is a pathname represents a reference to the Class with the given name inside the package with the given name. The name is assumed to be defined in the target package, otherwise the model is ill formed. A Relationship from a symbol in the current package (i.e., the package containing the diagram and its mapped elements) to a symbol in another package is part of the current package.\n\n5.16 IMPORTING A PACKAGE\n\n5.16.1 Semantics\n\nA class in another package may be referenced. On the package level, the «imports» dependency indicates that the contents of the target packages may be referenced by the client package or packages recursively embedded within it. The target references must have visibility sufficient for the referents. Visibilities may be specified on model elements and on packages. If a model element is nested inside one or more packages, the visibilities of the element and all of its containers combine according to the rule that the most restrictive visibility in the set is obtained. It is not possible to selectively export certain elements from within a nested package; the visibility of the outer package is applied to each element exported by an inner package. Imports are recursive within nested levels of packages. A descendents of a class requires at least “protected” visibility; any other class requires “public” visibility. (See the semantics document for full details.)\n\nNote that an imports dependency does not modify the namespace of the client or in any other way automatically create references; it merely grants permission to establish references. Note also that\na tool could automatically create imports dependencies for users if desired when references are created.\n\n5.16.2 Notation\n\nThe imports dependency is displayed as a dependency arrow from the referencing (client) package to the target (supplier) package containing the target of the references. The arrow has the stereotype «import». This dependency indicates that elements within the client package may legally reference elements within the supplier. The references must also satisfy visibility constraints specified by the supplier. Note that the dependency does not automatically create any references; it merely grants permission for them to be established.\n\n5.16.3 Example\n\nFigure 17. Imports dependency among packages\n\n5.16.4 Mapping\n\nThis is not a special symbol. It maps into a Dependency with the stereotype «import» between the two packages.\n5.17 **OBJECT**\n\n5.17.1 **Semantics**\n\nAn object represents a particular instance of a class. It has identity and attribute values. The same notation also represents a role within a collaboration because roles have instance-like characteristics.\n\n5.17.2 **Notation**\n\nThe object notation is derived from the class notation by underlining instance-level elements, as explained in the general comments in Section 2.11.\n\nAn object shown as a rectangle with two compartments.\n\nThe top compartment shows the name of the object and its class, all underlined, using the syntax:\n\n```\nobjectname : classname\n```\n\nThe classname can include a full pathname of enclosing package, if necessary. The package names precede the classname and are separated by double colons. For example:\n\n```\ndisplay_window: WindowingSystem::GraphicWindows::Window\n```\n\nA stereotype for the class may be shown textually (in guillemets above the name string) or as an icon in the upper right corner. The stereotype for an object must match the stereotype for its class.\n\nTo show multiple classes that the object is an instance of, use a comma-separated list of classnames. These classnames must be legal for multiple classification (i.e., only one implementation class permitted but multiple roles permitted).\n\nTo show the presence of an object in a particular state of a class, use the syntax:\n\n```\nobjectname : classname [' state-name-list ']\n```\n\nThe list must be a comma-separated list of names of states that can legally occur concurrently.\n\nThe second compartment shows the attributes for the object and their values as a list. Each value line has the syntax:\n\n```\nattributename : type = value\n```\n\nThe type is redundant with the attribute declaration in the class and may be omitted.\n\nThe value is specified as a literal value. UML does not specify the syntax for literal value expressions but it is expected that a tool will specify such a syntax using some programming language.\n5.17.3 Presentation options\n\nThe name of the object may be omitted. In this case the colon should be kept with the class name. This represents an anonymous object of the given class given identity by its relationships.\n\nThe class of the object may be suppressed (together with the colon).\n\nThe attribute value compartment as a whole may be suppressed.\n\nAttributes whose values are not of interest may be suppressed.\n\nAttributes whose values change during a computation may show their values as a list of values held over time. This is a good opportunity for the use of animation by a tool (the values would change dynamically). An alternate notation is to show the same object more than once with a «becomes» relationship between them.\n\n5.17.4 Style guidelines\n\nObjects may be shown on class diagrams. The elements on collaboration diagrams are not objects, because they describe many possible objects; they are instead roles that may be held by objects. Objects in class diagrams serve mainly to show examples of data structures.\n\n5.17.5 Variations\n\nFor a language such as Self in which operations can be attached to individual objects at run time, a third compartment containing operations would be appropriate as a language-specific extension.\n5.17.6 Example\n\nFigure 18. Objects\n\n5.17.7 Mapping\n\nThe mapping of an object symbol depends on the diagram:\n\nWithin a collaboration, it maps into a ClassifierRole of the corresponding Collaboration. The role has the name specified by the objectname portion of the symbol name string. The ClassifierRole has a type association to the Class whose name appears in the classname part of the symbol name string.\n\nIn an object diagram or within an ordinary class diagram, it maps into an Object of the Class given by the classname part of the name string. The values of the attributes are given by the value expressions in the attribute list in the symbol.\n\n5.18 COMPOSITE OBJECT\n\n5.18.1 Semantics\n\nA composite object represents a high-level object made of tightly-bound parts. This is an instance of a composite class, which implies the composition aggregation between the class and its parts. A composite object is similar to (but simpler and more restricted than) a collaboration, but it is defined completely by composition in a static model.\n5.18.2 Notation\n\nA composite object is shown as an object symbol. The name string of the composite object is placed in a compartment near the top of the rectangle (as with any object). The lower compartment holds the parts of the composite object instead of a list of attribute values. (However, even a list of attributes values may be regarded as the parts of a composite object, so there is not such a difference.) It is possible for some of the part to themselves be composite objects with further nesting.\n\n5.18.3 Example\n\nFigure 19. Composite object\n\n5.18.4 Mapping\n\nA composite object symbol maps into an Object of the given Class with composition links to each of the Objects and Links corresponding to the class box symbols and association path symbols directly contained within the boundary of the composite object symbol (and not contained within another deeper boundary).\n5.19 ASSOCIATION\n\nBinary associations are shown as lines connecting two class symbols. The lines may have a variety of adornments to show their properties. Ternary and higher-order associations are shown as diamonds connected to class symbols by lines.\n\n5.20 BINARY ASSOCIATION\n\n5.20.1 Semantics\n\nA binary association is an association among exactly two classes (including the possibility of a reflexive association from a class to itself).\n\n5.20.2 Notation\n\nA binary association is drawn as a solid path connecting two class symbols (both ends may be connected to the same class, but the two ends are distinct). The path may consist of one or more connected segments. The individual segments have no semantic significance but may be graphically meaningful to a tool in dragging or resizing an association symbol. A connected sequence of segments is called a path.\n\nIn a binary association both ends may attach to the same class. The links of such an association may connect two different objects from the same class or one object to itself. The latter case is a reflexive association; it may be forbidden by a constraint if necessary.\n\nThe end of an association where it connects to a class is called an association role. Most of the interesting information about an association is attached to its roles. See the section on Association Role for details.\n\nThe path may also have graphical adornments attached to the main part of the path itself. These adornments indicate properties of the entire association. They may be dragged along a segment or across segments but must remain attached to the path. It is a tool responsibility to determine how close association adornments may approach a role so that confusion does not occur. The following kinds of adornments may be attached to a path:\n\nassociation name\n\nDesignates the (optional) name of the association.\n\nShown as a name string near the path (but not near enough to an end to be confused with a rolename). The name string may have an optional small black solid triangle in it; the point of the triangle indicates the direction in which to read the name. The name-direction arrow has no semantics significance; it is purely descriptive. The classes in the association are ordered as indicated by the name-direction arrow.\n(Note that there is no need for a *name direction* property on the association model; the ordering of the classes within the association is the name direction. This convention works even with n-ary associations.) A stereotype keyword within guillemets may be placed above or in front of the association name. A property string may be placed after or below the association name.\n\n**association class symbol**\n\nDesignates an association that has class-like properties, such as attributes, operations, and other associations. This is present if and only if the association is an association class.\n\nShown as a class symbol attached to the association path by a dashed line.\n\nThe association path and the association class symbol represent the same underlying model element which has a single name. The name may be placed on the path, in the class symbol, or on both (but they must be the same name).\n\nLogically the association class and the association are the same semantic entity, but they are graphically distinct. The association class symbol can be dragged away from the line but the dotted line must remain attached to both the path and the class symbol.\n\n### 5.20.3 Presentation options\n\nWhen two paths cross, the crossing may optionally be shown with a small semicircular jog to indicate that the paths do not intersect (as in electrical circuit diagrams). Alternately crossing can be unmarked but connections might be shown by small dots.\n\n### 5.20.4 Style guidelines\n\nLines may be drawn using various styles, including orthogonal segments, oblique segments, and curved segments. The choice of a particular set of line styles is a user choice.\n\n### 5.20.5 Options\n\nOr-association. An or-constraint indicates a situation in which only one of several potential associations may be instantiated at one time for any single object. This is shown as a dashed line connecting two or more associations, all of which must have a class in common, with the constraint string “{or}” labeling the dashed line. Any instance of the class may only participate in at most one of the associations at one time. Each rolename must be different. (This is simply a predefined use of the constraint notation.)\n5.20.6 Example\n\nFigure 20. Association notation\n\nAn association path connecting two class symbols maps to an Association between the corresponding Classes. If there is an arrow on the association name, then the Class corresponding to the tail of the arrow is the first class and the Class corresponding to the head of the arrow is the second Class in the ordering of roles of the Association; otherwise the ordering of roles in the association is undetermined. The adornments on the path map into properties of the Association as described above. The Association is owned by the package containing the diagram.\n\n5.20.7 Mapping\n\n5.21 ASSOCIATION END\n\n5.21.1 Semantics\n\nAn association end is simply an end of an association where it connects to a class. It is part of the association, not part of the class. Each association has two or more ends. Most of the interesting\ndetails about an association are attached to its ends. An association end is not a separable element; it is just a mechanical part of an association.\n\n### 5.21.2 Notation\n\nThe path may have graphical adornments at each end where the path connects to the class symbol. These adornments indicate properties of the association related to the class. The adornments are part of the association symbol, not part of the class symbol. The end adornments are either attached to the end of the line or near the end of the line and must drag with it. The following kinds of adornments may be attached to an association end:\n\n- **multiplicity** – specified by a text syntax, see detail section. Multiplicity may be suppressed on a particular association or for an entire diagram. In an incomplete model the multiplicity may be unspecified in the model itself, in which case it must be suppressed in the notation.\n\nordering – if the multiplicity is greater than one, then the set of related elements can be ordered or unordered. If no indication is given, then it is unordered (the elements form a set). Various kinds of ordering can be specified as a constraint on the association end. The declaration does not specify how the ordering is established or maintained; operations that insert new elements must make provision for specifying their position either implicitly (such as at the end) or explicitly. Possible values include:\n - unordered — the elements form an unordered set. This is the default and need not be shown explicitly.\n - ordered — the elements of the set are ordered into a list. It is still a set and duplicates are prohibited. This generic specification includes all kinds of ordering. This may be specified by the keyword syntax: “{ordered}”.\n\nAn ordered relationship may be implemented in various ways but this is normally specified as a language-specified code generation property to select a particular implementation. An implementation extension might substitute the data structure to hold the elements for the generic specification “ordered”.\n\nAt implementation level, sorting may also be specified. It does not add new semantic information but it expresses a design decision:\n\n- sorted — the elements are sorted based on their internal values. The actual sorting rule is best specified as a separate constraint.\n\n- **qualifier** – see detail section. Qualifier is optional but not suppressible.\n\n- **navigability**\n\n An arrow may be attached to the end of the path to indicate that navigation is supported toward the class attached to the arrow. Arrows may be attached to zero, one, or two ends of the path. To be totally explicit arrows may be shown whenever navigation is supported in a given direction. In practice it is often convenient to sup-\npress some of the arrows and just show exceptional situations. See the presentation options for details.\n\naggregation indicator\n\nA hollow diamond is attached to the end of the path to indicate aggregation. The diamond may not be attached to both ends of a line, but it need not be present at all. The diamond is attached to the class that is the aggregate. The aggregation is optional but not suppressible.\n\nIf the diamond is filled, then it signifies the strong form of aggregation known as composition.\n\nrolename\n\nA name string near the end of the path. It indicates the role played by the class attached to end of the path near the rolename. The rolename is optional but not suppressible.\n\ninterface specifier\n\nThe name of a Classifier with the syntax\n\n```\n '::' classifiername\n```\n\nIt indicates the behavior expected of an associated object by the related object. In other words, the interface specifier specifies the behavior required to enable the association. In this case, the actual class usually provides more functionality than required for the particular association (since it may have other responsibilities).\n\nThe use of a rolename and interface specifier are equivalent to creating a small collaboration that includes just an association and two roles, whose structure is defined by the rolename and role classifier on the original association. The original association and classes are therefore a use of the collaboration. The original class must be compatible with the interface specifier (which can be an interface or a type).\n\nIf a interface specifier is omitted, then the association may be used to obtain full access to the associated class.\n\nchangeability\n\nIf the links are changeable (can be added, deleted, and moved) then no indicator is needed. The property {frozen} indicates that no links may be added, deleted, or moved from an object (toward the end with the adornment) after the object is created and initialized. The property {addOnly} indicates that additional links may be added (presumably the multiplicity is variable) but that links may not be modified or deleted.\n\nvisibility\n\nSpecified by a visibility indicator (‘+’, ‘#’, ‘-’ or explicit keyword such as {public}) in front of the rolename. Specifies the visibility of the association tra-\nversing in the direction toward the given rolename. See Section 5.7 for details of visibility specification.\n\nOther properties can be specified for association roles but there is no graphical syntax for them. To specify such properties use the constraint syntax near the end of the association path (a text string in braces). Examples of such other properties include mutability.\n\n5.21.3 Presentation options\n\nIf there are two or more aggregations to the same aggregate, they may be drawn as a tree by merging the aggregation end into a single segment. This requires that all of the adornments on the aggregation ends be consistent. This is purely a presentation option; there are no additional semantics to it.\n\nVarious options are possible for showing the navigation arrows on a diagram. These can vary from time to time by user request or from diagram to diagram:\n\nPresentation option 1: Show all arrows. The absence of an arrow indicates navigation is not supported.\n\nPresentation option 2: Suppress all arrows. No inference can be drawn about navigation. This is similar to any situation in which information is suppressed from a view.\n\nPresentation options 3: Suppress arrows for associations with navigability in both directions; show arrows only for associations with one-way navigability. In this case the two-way navigability cannot be distinguished from no-way navigation, but the latter case is normally rare or nonexistent in practice. This is yet another example of a situation in which some information is suppressed from a view.\n\n5.21.4 Style guidelines\n\nIf there are multiple adornments on a single role, they are presented in the following order, reading from the end of the path attached to the class toward the bulk of the path:\n\nqualifier\n\naggregation symbol\n\nnavigation arrow\n\nRolenames and multiplicity should be placed near the end of the path so that they are not confused with a different association. They may be placed on either side of the line. It is tempting to specify that they will always be placed on a given side of the line (clockwise or counterclockwise) but this is sometimes overridden by the need for clarity in a crowded layout. A rolename and a multiplicity may be placed on opposite sides of the same role, or they may be placed together (for example, \"* employee\").\n5.21.5 Example\n\nFigure 21. Various adornments on association roles\n\n5.21.6 Mapping\n\nThe adornments on the end of an association path map into properties of the corresponding role of the Association. In general, implications cannot be drawn from the absence of an adornment (it may simply be suppressed) but see the preceding descriptions for details.\n\n5.22 Multiplicity\n\n5.22.1 Semantics\n\nA multiplicity item specifies the range of allowable cardinalities that a set may assume. Multiplicity specifications may be given for roles within associations, parts within composites, repetitions, and other purposes. Essentially a multiplicity specification is a subset of the open set of nonnegative integers.\n\n5.22.2 Notation\n\nA multiplicity specification is shown as a text string comprising a comma-separated sequence of integer intervals, where an interval represents a (possibly infinite) range of integers, in the format:\n\nlower-bound .. upper-bound\n\nwhere lower-bound and upper-bound are literal integer values, specifying the closed (inclusive) range of integers from the lower bound to the upper bound. In addition, the star character (*) may be used for the upper bound, denoting an unlimited upper bound. In a param-\neterized context (such as a template) the bounds could be expressions but they must evaluate to literal integer values for any actual use. Unbound expressions that do not evaluate to literal integer values are not permitted.\n\nIf a single integer value is specified, then the integer range contains the single integer value.\n\nIf the multiplicity specification comprises a single star (*), then it denotes the unlimited nonnegative integer range, that is, it is equivalent to *:* = 0..* (zero or more).\n\nA multiplicity of 0..0 is meaningless as it would indicate that no instances can occur.\n\nExpressions in some specification language can be used for multiplicities, but they must resolve to fixed integer ranges within the model (i.e., no dynamic evaluation of expressions, essentially the same rule on literal values as most programming language).\n\n5.22.3 Style guidelines\n\nIntervals should preferably be monotonically increasing. For example, “1..3,7,10” is preferable to “7,10,1..3”.\n\nTwo contiguous intervals should be combined into a single interval. For example, “0..1” is preferable to “0,1”.\n\n5.22.4 Example\n\n0..1\n1\n0.*\n*\n1..\n1..6\n1..3,7..10,15,19..*\n\n5.22.5 Mapping\n\nA multiplicity string maps into a Multiplicity value. Duplications or other nonstandard presentation of the string itself have no effect on the mapping. Note that Multiplicity is a value and not an object; it cannot stand on its own but is the value of some element property.\n5.23 QUALIFIER\n\n5.23.1 Semantics\n\nA qualifier is an attribute or list of attributes whose values serve to partition the set of objects associated with an object across an association. The qualifiers are attributes of the association.\n\n5.23.2 Notation\n\nA qualifier is shown as a small rectangle attached to the end of an association path between the final path segment and the symbol of the class that it connects to. The qualifier rectangle is part of the association path, not part of the class. The qualifier rectangle drags with the path segments. The qualifier is attached to the source end of the association; that is, an object of the source class together with a value of the qualifier uniquely select a partition in the set of target class objects on the other end of the association (i.e., every target falls into exactly one partition).\n\nThe multiplicity attached to the target role denotes the possible cardinalities of the set of target objects selected by the pairing of a source object and a qualifier value. Common values include “0..1” (a unique value may be selected, but every possible qualifier value does not necessarily select a value), “1” (every possible qualifier value selects a unique target object, therefore the domain of qualifier values must be finite), and “*” (the qualifier value is an index that partitions the target objects into subsets).\n\nThe qualifier attributes are drawn within the qualifier box. There may be one or more attributes shown one to a line. Qualifier attributes have the same notation as class attributes, except that initial value expressions are not meaningful.\n\nIt is permissible (although somewhat rare) to have a qualifier on each end of a single association.\n\n5.23.3 Presentation options\n\nA qualifier may not be suppressed (it provides essential detail whose omission would modify the inherent character of the relationship).\n\nA tool may use a lighter line for qualifier rectangles than for class rectangles to distinguish them clearly.\n\n5.23.4 Style guidelines\n\nThe qualifier rectangle should be smaller than the attached class rectangle, although this is not always practical.\n5.23.5 Example\n\nFigure 22. Qualified associations\n\n```\nBank\n account #\n *\n 0..1\n Person\n\nChessboard\n rank:Rank\n file:File\n 1\n 1\n Square\n```\n\n5.23.6 Mapping\n\nThe presence of a qualifier box on an end of an association path maps into a Qualifier on the corresponding Association Role. Each attribute entry string inside the qualifier box maps into an Attribute of the Qualifier.\n\n5.24 ASSOCIATION CLASS\n\n5.24.1 Semantics\n\nAn association class is an association that also has class properties (or a class that has association properties). Even though it is drawn as an association and a class, it is really just a single model element.\n\n5.24.2 Notation\n\nAn association class is shown as a class symbol (rectangle) attached by a dashed line to an association path. The name in the class symbol and the name string attached to the association path are redundant and should be the same. The association path may have the usual adornments on either end. The class symbol may have the usual contents. There are no adornments on the dashed line.\n\n5.24.3 Presentation options\n\nThe class symbol may be suppressed (it provides subordinate detail whose omission does not change the overall relationship. The association path may not be suppressed.\n5.24.4 Style guidelines\n\nThe attachment point should not be near enough to either end of the path that it appears to be attached to the end of the path or to any of the role adornments.\n\nNote that the association path and the association class are a single model element and therefore have a single name. The name can be shown on the path or the class symbol or both. If an association class has only attributes but no operations or other associations, then the name may be displayed on the association path and omitted from the association class symbol to emphasize its “association nature.” If it has operations and other associations, then the name may be omitted from the path and placed in the class rectangle to emphasize its “class nature.” In neither case are the actual semantics different.\n\n5.24.5 Example\n\nFigure 23. Association class\n\n5.24.6 Mapping\n\nAn association path connecting two class boxes connected by a dashed line to another class box maps into a single Association Class element. The name of the Association Class element is taken from the association path or the attached class box or both (they must be consistent if both are present). The Association properties map from the association path as specified previously. The Class properties map from the class box as specified previously. Any constraints or properties places on either the association path or attached class box apply to the Association Class itself; they must not conflict.\n5.25 N-ARY ASSOCIATION\n\n5.25.1 Semantics\n\nAn n-ary association is an association among 3 or more classes (a single class may appear more than once). Each instance of the association is an n-tuple of values from the respective classes. A binary association is a special case with its own notation.\n\nMultiplicity for n-ary associations may be specified but is less obvious than binary multiplicity. The multiplicity on a role represents the potential number of instance tuples in the association when the other N-1 values are fixed.\n\nAn n-ary association may not contain the aggregation marker on any role.\n\n5.25.2 Notation\n\nAn n-ary association is shown as a large diamond (that is, large compared to a terminator on a path) with a path from the diamond to each participant class. The name of the association (if any) is shown near the diamond. Role adornments may appear on each path as with a binary association. Multiplicity may be indicated, however, qualifiers and aggregation are not permitted.\n\nAn association class symbol may be attached to the diamond by a dashed line. This indicates an n-ary association that has attributes, operations, and/or associations.\n\n5.25.3 Style guidelines\n\nUsually the lines are drawn from the points on the diamond or the midpoint of a side.\n\n5.25.4 Example\n\nThis example shows the record of a team in each season with a particular goalkeeper. It is assumed that the goalkeeper might be traded during the season and can therefore appear with different teams.\n5.25.5 Mapping\n\nA diamond attached to some number of class boxes by solid lines maps into an N-ary Association whose roles are corresponding Classes. The ordering of the Classes in the Association is indeterminate from the diagram. If a class box is attached to the diamond by a dashed line, then the corresponding Class supplies the class properties for an N-ary Association Class.\n\n5.26 COMPOSITION\n\n5.26.1 Semantics\n\nComposition is a form of aggregation with strong ownership and coincident lifetime of part with the whole. The multiplicity of the aggregate end may not exceed one (it is unshared). See the semantics document for further details.\n\nThe parts of a composition may include classes and associations. The meaning of an association in a composition is that any tuple of objects connected by a single link must all belong to the same container object.\n5.26.2 Notation\n\nComposition may be shown by a solid filled diamond as an association role adornment. Alternately UML provides a graphically-nested form that is more convenient for showing composition in many cases.\n\nInstead of using binary association paths using the composition aggregation adornment, composition may be shown by graphical nesting of the symbols of the elements for the parts within the symbol of the element for the whole. A nested class-like element may have a multiplicity within its composite element. The multiplicity is shown in the upper right corner of the symbol for the part; if the multiplicity mark is omitted then the default multiplicity is many. This represents its multiplicity as a part within the composite class. A nested element may have a rolename within the composition; the name is shown in front of its type in the syntax:\n\n```\nrolename ': ' classname\n```\n\nThis represents its rolename within its composition association to the composite.\n\nAlternately, composition is shown by a solid-filled diamond adornment on the end of an association path attached to the element for the whole. The multiplicity may be shown in the normal way.\n\nNote that attributes are, in effect, composition relationships between a class and the classes of its attributes.\n\nAn association drawn entirely within a border of the composite is considered to be part of the composition; any objects on a single link of it must be from the same composite. An association drawn such that its path breaks the border of the composite is not considered to be part of the composition; any objects on a single link of it may be from the same or different composites.\n\nNote that the notation for composition resembles the notation for collaboration. A composition may be thought of as a collaboration in which all of the participants are parts of a single composite object.\n\n5.26.3 Design guidelines\n\nThis notation is applicable to “class-like” model elements: classes, types, nodes, processes, etc.\n\nNote that a class symbol is a composition of its attributes and operations. The class symbol may be thought of as an example of the composition nesting notation (with some special layout properties). However, attribute notation subordinates the attributes strongly within the class, so it should be used when the structure and identity of the attribute objects themselves is unimportant outside the class.\n5.26.4 Example\n\nFigure 25. Different ways to show composition\n5.26.5 Mapping\n\nA class box with an attribute compartment maps into a Class with Attributes. Although attributes may be semantically equivalent to composition on a deep level, the mapped model distinguishes the two forms.\n\nA solid diamond on an association path maps into the composition property on the corresponding Association Role.\n\nA class box with contained class boxes maps into a set of composition associations, that is, one composition association between the Class corresponding to the outer class box and each of the Classes corresponding to the enclosed class boxes. The multiplicity of the composite end of each association is 1. The multiplicity of each constituent end is 1 if not explicitly specified, otherwise it is the value specified in the corner of the class box or specified on an association path from the outer class box boundary to an inner class box.\n\n5.27 Links\n\n5.27.1 Semantics\n\nA link is a tuple (list) of object references. Most commonly, it is a pair of object references. It is an instance of an association.\n\n5.27.2 Notation\n\nA binary link is shown as a path between two objects. In the case of a reflexive association, it may involve a loop with a single object. See Association for details of paths.\n\nA rolename may be shown at each end of the link. An association name may be shown near the path; if present, it is underlined to indicate an instance. Links do not have instance names; they take their identity from the objects that they relate. Multiplicity is not shown for links because they are instances. Other association adornments (aggregation, composition, navigation) may be shown on the link roles.\n\nA qualifier may be shown on a link. The value of the qualifier may be shown in its box.\n\n**Implementation stereotypes.** A stereotype may be attached to the link role to indicate various kinds of implementation. The following stereotypes may be used:\n\n- «association» association (default, unnecessary to specify except for emphasis)\n- «parameter» procedure parameter\nStatic Structure Diagrams\n\n- «local»: local variable of a procedure\n- «global»: global variable\n- «self»: self link (the ability of an object to send a message to itself)\n\n**N-ary link.** An n-ary link is shown as a diamond with a path to each participating object. The other adornments on the association and the adornments on the roles have the same possibilities as the binary link.\n\n### 5.27.3 Example\n\n\n\n**5.27.4 Mapping**\n\nThe mapping depends on the kind of diagram:\n\nWithin a collaboration diagram, each link path maps to an AssociationRole between the Classifier-Roles corresponding to the connected class boxes. If a name is placed on the link path, then it is the name of the Association that is the type of the AssociationRole. Stereotypes on the path indicate the form of the relationship within the collaboration.\n\nWithin an object diagram, each link path maps to a Link between the Objects corresponding to the connected class boxes. If a name is placed on the link path, then it is an instance of the given Association (and the role names must match or the diagram is ill formed).\n5.28 GENERALIZATION\n\n5.28.1 Semantics\n\nGeneralization is the taxonomic relationship between a more general element and a more specific element that is fully consistent with the first element and that adds additional information. It is used for classes, packages, use cases, and other elements.\n\n5.28.2 Notation\n\nGeneralization is shown as a solid-line path from the more specific element (such as a subclass) to the more general element (such as a superclass), with a large hollow triangle at the end of the path where it meets the more general element.\n\nA generalization path may have a text label in the following format:\n\ndiscriminator\n\nwhere discriminator is the name of a partition of the subtypes of the superclass. The subclass is declared to be in the given partition. The absence of a discriminator label indicates the “empty string” discriminator which is a valid value (the “default” discriminator).\n\nGeneralization may be applied to associations as well as classes, although the notation may be messy because of the multiple lines. An association can be shown as an association class for the purpose of attaching generalization arrows.\n\n5.28.3 Presentation options\n\nA group of generalization paths for a given superclass may be shown as a tree with a shared segment (including triangle) to the superclass, branching into multiple paths to each subclass.\n\nIf a text label is placed on a generalization triangle shared by several generalization paths to subclasses, the label applies to all of the paths. In other words, all of the subclasses share the given properties.\n\n5.28.4 Details\n\nThe existence of additional subclasses in the model that are not shown on a particular diagram may be shown using an ellipsis (…) in place of a subclass. (Note: this does not indicate that additional classes may be added in the future. It indicates that additional classes exist right now but are not being seen. This is a notational convention that information has been suppressed, not a semantic statement)\nPredefined constraints may be used to indicate semantic constraints among the subclasses. A comma-separated list of keywords is placed in braces either near the shared triangle (if several paths share a single triangle) or else near a dotted line that crosses all of the generalization lines involved. The following keywords (among others) may be used:\n\nThe following constraints are predefined:\n\n- **overlapping**: A descendent may be descended from more than one of the subclasses.\n- **disjoint**: A descendent may not be descended from more than one of the subclasses.\n- **complete**: All subclasses have been specified (whether or not shown). No additional subclasses are expected.\n- **incomplete**: Some subclasses have been specified but the list is known to be incomplete. There are additional subclasses that are not yet in the model. The is a statement about the model itself. Note that this is not the same as the ellipsis, which states that additional subclasses exist in the model but are not shown on the current diagram.\n\nThe *discriminator* must be unique among the attributes and association roles of the given superclass. Multiple occurrences of the same discriminator name are permitted and indicate that the subclasses belong to the same partition.\nThe use of multiple classification dynamic classification affects the dynamic execution semantics of the language but is not unusually apparent from a static model.\n\n### 5.28.5 Example\n\nFigure 27. Styles of displaying generalization\n\nSeparate Target Style\n\nShared Target Style\n5.28.6 Mapping\n\nEach generalization path between two class boxes maps into a Generalization between the corresponding Classes. A generalization tree with one arrowhead and many tails maps into a set of Generalizations, one between each Class corresponding to a class box on a tail and the single Class corresponding to the class box on the head. That is, a tree is semantically indistinguishable from a set of distinct arrows; it is purely a notational convenience.\n\nAny property string attached to a generalization arrow applies to the Generalization. A property string attached to the head line segment on a generalization tree represents a (duplicated) property on each of the individual Generalizations.\nThe presence of an ellipsis (“...”) as a subclass node of a given class indicates that the semantic model contains at least one subclass of the given class that is not visible on the current diagram. Normally this indicator will be automatically maintained by an editing tool.\n\n5.29 DEPENDENCY\n\n5.29.1 Semantics\n\nA dependency indicates a semantic relationship between two (or more) model elements. It relates the model elements themselves and does not require a set of instances for its meaning. It indicates a situation in which a change to the target element may require a change to the source element in the dependency.\n\n5.29.2 Notation\n\nA dependency is shown as a dashed arrow between two model elements. The model element at the tail of the arrow depends on the model element at the arrowhead. The arrow may be labeled with an optional stereotype and an optional name.\n\nThe following kinds of Dependency are predefined and may be indicated with keywords:\n\n- trace – Trace: a historical connection between two elements that represent the same concept at different levels of meaning\n- refine – Refinement: a historical or derivation connection between two elements with a mapping (not necessarily complete) between them. A description of the mapping may be attached to the dependency in a note. Various kinds of refinement have been proposed and can be indicated by further stereotyping.\n- uses – Usage: a situation in which one element requires the presence of another element for its correct implementation or functioning. May be stereotyped further to indicate the exact nature of the dependency, such as calling an operation of another class, granting permission for access, instantiating an object of another class, etc.\n- bind – Binding: a binding of template parameters to actual values to create a nonparameterized element. See Section 5.12 for more details.\n\n5.29.3 Presentation options\n\nIf one of the elements is a note or constraint then the arrow may be suppressed because the direction is clear (the note or constraint is the source of the arrow).\n5.29.4 Example\n\nFigure 30. Various usage dependencies among classes\n\n![Diagram showing various usage dependencies among classes]\n\nFigure 31. Dependencies among packages\n\n![Diagram showing dependencies among packages]\n\n5.29.5 Mapping\n\nA dashed arrow maps into a Dependency between the Elements corresponding to the symbols attached to the ends of the arrow. The stereotype and the name (if any) attached to the arrow are the stereotype and name of the Dependency.\n5.30 DERIVED ELEMENT\n\n5.30.1 Semantics\n\nA derived element is one that can be computed from another one, but that is shown for clarity or that is included for design purposes even though it adds no semantic information.\n\n5.30.2 Notation\n\nA derived element is shown by placing a slash (/) in front of the name of the derived element, such as an attribute or a rolename.\n\n5.30.3 Style guidelines\n\nThe details of computing a derived element can be specified by a dependency with the stereotype «derived». Usually it is convenient in the notation to suppress the dependency arrow and simply place a constraint string near the derived element, although the arrow can be included when it is helpful.\n5.30.4 Example\n\nFigure 32. Derived attribute and derived association\n\nThe presence of a derived adornment (a leading “/” on the symbol name) on a symbol maps into the setting of the “derived” property of the corresponding Element.\n6. USE CASE DIAGRAMS\n\nA use case diagram shows the relationship among actors and use cases within a system.\n\n6.1 USE CASE DIAGRAM\n\n6.1.1 Semantics\n\nUse case diagrams show elements from the use case model. The use case model represents functionality of a system or a class as manifested to external interactors with the system.\n\n6.1.2 Notation\n\nA use case diagram is a graph of actors, a set of use cases enclosed by a system boundary, communication (participation) associations between the actors and the use cases, and generalizations among the use cases.\n6.1.3 Example\n\nFigure 33. Use case diagram\n\n6.1.4 Mapping\n\nA set of use case ellipses within a box with connections to actor symbols maps to a single UseCase-Model package containing a set of UseCases and Actors with relationships among them.\n6.2 USE CASE\n\n6.2.1 Semantics\n\nA use case is a coherent unit of functionality provided by a system or class as manifested by sequences of messages exchanged among the system and one or more outside interactors (called actors) together with actions performed by the system.\n\n6.2.2 Notation\n\nA use case is shown as an ellipse containing the name of the use case.\n\nAn extension point is a location within a use case at which action sequences from other use cases may be inserted. Each extension point must have a unique name within a use case. Extension points may be listed in a compartment of the use case with the heading extension points.\n\n6.2.3 Presentation options\n\nThe name of the use case may be placed below the ellipse.\n\n6.2.4 Style guidelines\n\nUse case names should follow capitalization and punctuation guidelines used for behavioral items in the same model.\n\n6.2.5 Mapping\n\nA use case symbol maps to a UseCase with the given name (if any).\n\nAn extension point maps into an ExtensionPoint within the UseCase.\n\n6.3 ACTOR\n\n6.3.1 Semantics\n\nAn actor is a role of object or objects outside of a system that interacts directly with it as part of a coherent work unit (a use case). An Actor element characterizes the role played by an outside object; one physical object may play several roles and therefore be modeled by several actors.\nUse Case Diagrams\n\n6.3.2 Notation\n\nAn actor may be shown as a class rectangle with the stereotype “actor”. The standard stereotype icon for an actor is the “stick man” figure with the name of the actor below the figure.\n\n6.3.3 Style guidelines\n\nActor names should follow capitalization and punctuation guidelines used for types and classes in the same model.\n\n6.3.4 Mapping\n\nAn actor symbol maps to an Actor with the given name.\n\n6.4 USE CASE RELATIONSHIPS\n\n6.4.1 Semantics\n\nThere are several standard relationships among use cases or between actors and use cases.\n\nCommunicates – The participation of an actor in a use case. This is the only relationship between actors and use cases.\n\nExtends – An extends relationships from use case A to use case B indicates that an instance of use case B may include (subject to specific conditions specified in the extension) the behavior specified by A. Behavior specified by several extenders of a single target use case may occur within a single use case instance.\n\nUses – A uses relationship from use case A to use case B indicates that an instance of the use case A will also include the behavior as specified by B.\n\n6.4.2 Notation\n\nThe communication relationship between an actor and a use case is shown as a solid line between the actor and the use case.\n\nAn “extends” relationship between use cases is shown by a generalization arrow from the use case providing the extension to the base use case. The arrow is labeled with the stereotype «extends».\n\nA “uses” relationship between use cases is shown by a generalization arrow from the use case doing the use to the use case being used. The arrow is labeled with the stereotype «uses».\nThe relationship between a use case and its external interaction sequences are usually shown by an invisible hyperlink to sequence diagrams. The relationship between a use case and its implementation may be shown as a refinement relationship to a collaboration but may also be shown as an invisible hyperlink. The expectation is that a tool will support the ability to “zoom into” a use case to see its scenarios and/or implementation as an interaction.\n\n### 6.4.3 Example\n\nFigure 34. Use case relationships\n\n![Use case relationships diagram]\n\n### 6.4.4 Mapping\n\nA path between use case and/or actor symbols maps into the corresponding relationship between the corresponding Elements, as described above.\n7. SEQUENCE DIAGRAMS\n\n7.1 KINDS OF INTERACTION DIAGRAMS\n\nA pattern of interaction among objects is shown on an interaction diagram. Interaction diagrams come in two forms based on the same underlying information but each emphasizing a particular aspect of it: sequence diagrams and collaboration diagrams.\n\nA sequence diagram shows an interaction arranged in time sequence. In particular, it shows the objects participating in the interaction by their “lifelines” and the messages that they exchange arranged in time sequence. It does not show the associations among the objects.\n\nSequence diagrams come in several slightly different formats intended for different purposes.\n\nA sequence diagram can exist in a generic form (describes all the possible sequences) and in an instance form (describes one actual sequence consistent with the generic form). In cases without loops or branches, the two forms are isomorphic.\n\nSequence diagrams and collaboration diagrams express similar information but show it in different ways. Sequence diagrams show the explicit sequence of messages and are better for real-time specifications and for complex scenarios. Collaboration diagrams show the relationships among objects and are better for understanding all of the effects on a given object and for procedural design.\n\n7.2 SEQUENCE DIAGRAM\n\n7.2.1 Semantics\n\nA sequence diagram represents an Interaction, which is a set of messages exchanged among objects within a collaboration to effect a desired operation or result.\n\n7.2.2 Notation\n\nA sequence diagram has two dimensions: the vertical dimension represents time, the horizontal dimension represents different objects. Normally time proceeds down the page. (The dimensions may be reversed if desired.) Usually only time sequences are important but in real-time applications the time axis could be an actual metric. There is no significance to the horizontal ordering of the objects. Objects can be grouped into “swimlanes” on a diagram.\n\nSee subsequent sections for details of the contents of a sequence diagram.\n\n(Note that much of this notation is drawn directly from the Object Message Sequence Chart notation of Buschmann, Meunier, Rohnert, Sommerlad, and Stal, which is itself derived with modifications from the Message Sequence Chart notation.)\n7.2.3 Presentation options\n\nNote that the horizontal ordering of the lifelines is arbitrary. Often call arrows are arranged to proceed in one direction across the page, but this is not always possible and the ordering does not convey information.\n\nThe axes can be interchanged, so that time proceeds horizontally to the right and different objects are shown as horizontal lines.\n\nVarious labels (such as timing marks, descriptions of actions during an activation, and so one) can be shown either in the margin or near the transitions or activations that they label.\n\n7.2.4 Example\n\nFigure 35. Simple sequence diagram with concurrent objects\n\nThe call is routed through the network.\n\nAt this point the parties can talk.\n7.2.5 Mapping\n\n(This section summarizes the mapping for the sequence diagram and the elements within it, some of which are described in subsequent sections.)\nA sequence diagram maps into an Interaction and an underlying Collaboration. Each object box with its lifeline maps into a ClassifierRole; the name field maps into the ClassifierRole name and the type field maps into the type association from the role to the Classifier with the given name. The associations among roles are not shown on the sequence diagram; they must be obtained in the model from a complementary collaboration diagram or other means. A message arrow maps into a Message between the ClassifierRoles corresponding to the two lifelines that the arrow connects; unless the correct AssociationRole can be determined from a complementary collaboration diagram or other means, the Message must be attached to a dummy AssociationRole implied between the two ClassifierRoles for lack of complete information. A timing label placed on the level of an arrow endpoint maps into the name of the corresponding Message. A constraint placed on the diagram maps into a Constraint on the entire Interaction.\n\nAn object symbol placed within the frame of the diagram maps into a CreateAction attached to the Message corresponding to the incoming arrow. If an object termination symbol (\"X\") is the target of an arrow, it maps into a DestroyAction attached to the Message corresponding to the arrow; otherwise it maps into a TerminateAction.\n\nOn a diagram with concurrent objects, a predecessor association is established between Messages corresponding to successive arrows in the vertical sequence. In case of concurrent arrows, the mapping to a predecessor sequence may be ambiguous and may require additional information.\n\nOn a procedural sequence diagram (one with focus of control and calls) subsequent arrows on the same lifeline map into Messages obeying the predecessor association. An arrow to the head of a focus of control region establishes a nested activation; it maps into a Message (synchronous, activation) with associated CallAction (holding the arguments and referencing the target Operation) between the ClassifierRoles corresponding to the lifelines. All arrows departing the nested activation map into Messages with an activation Association to the Message corresponding to the arrow at the head of the activation. A return arrow departing the end of the activation maps into a Message (synchronous, reply) with an activation Association to the Message corresponding to the arrow at the head of the activation and a predecessor association to the previous message within the same activation. A return must be the final message within a predecessor chain; it is not the predecessor of any message. Any guard conditions or iteration conditions attached to a message arrow become recurrence values of the Message. The operation name is used to select the target Operation with the given name. The operation arguments become argument Expressions on the Action.\n\n### 7.3 OBJECT LIFELINE\n\n#### 7.3.1 Semantics\n\nA Role is a slot for an object within a collaboration that describes the type of object that may play the role and describes its relationships to other Roles. Within a sequence diagram the existence and duration of the object in a role is shown, but the relationships among the roles is not shown. There are ClassifierRoles and AssociationRoles.\n7.3.2 Notation\n\nAn object role is shown as a vertical dashed line called the “lifeline”. The lifeline represents the existence of the object at a particular time. If the object is created or destroyed during the period of time shown on the diagram, then its lifeline starts or stops at the appropriate point; otherwise it goes from the top to the bottom of the diagram. An object symbol is drawn at the head of the lifeline; if the object is created during the diagram, then the message that creates it is drawn with its arrowhead on the object symbol. If the object is destroyed during the diagram, then its destruction is marked by a large “X”, either at the message that causes the destruction or (in the case of self-destruction) at the final return message from the destroyed object. An object that exists when the transaction starts is shown at the top of the diagram (above the first arrow). An object that exists when the transaction finishes has its lifeline continue beyond the final arrow.\n\nThe lifeline may split into two or more concurrent lifelines to show conditionality. Each separate track corresponds to a conditional branch in the message flow. The lifelines may merge together at some subsequent point.\n\n7.3.3 Example\n\nSee Figure 36.\n\n7.3.4 Mapping\n\nSee Section 7.2.5.\n\n7.4 Activation\n\n7.4.1 Semantics\n\nAn activation (focus of control) shows the period during which an object is performing an action either directly or through a subordinate procedure. It represents both the duration of the action in time and the control relationship between the activation and its callers (stack frame).\n\n7.4.2 Notation\n\nAn activation is shown as a tall thin rectangle whose top is aligned with its initiation time and whose bottom is aligned with its completion time. The action being performed may be labeled in text next to the activation symbol or in the left margin, depending on style; alternately the incoming message may indicate the action, in which case it may be omitted on the activation itself. In procedural flow of control, the top of the activation symbol is at the tip of an incoming message (the one that initiates the action) and the base of the symbol is at the tail of a return message.\nIn the case of concurrent objects each with their own threads of control, an activation shows the duration when each object is performing an operation; operations by other objects are not relevant. If the distinction between direct computation and indirect computation (by a nested procedure) is unimportant, the entire lifeline may be shown as an activation.\n\nIn the case of procedural code, an activation shows the duration during which a procedure is active in the object or a subordinate procedure is active, possibly in some other object. In other words, all of the active nested procedure activations may be seen at a given time. In the case of a recursive call to an object with an existing activation, the second activation symbol is drawn slightly to the right of the first one, so that they appear to “stack up” visually. (Recursive calls may be nested to an arbitrary depth.)\n\n7.4.3 Example\n\nSee Figure 36.\n\n7.4.4 Mapping\n\nSee Section 7.2.5.\n\n7.5 MESSAGE\n\n7.5.1 Semantics\n\nA message is a communication between objects that conveys information with the expectation that action will ensue. The receipt of a message is one kind of event.\n\n7.5.2 Notation\n\nA message is shown as a horizontal solid arrow from the lifeline of one object to the lifeline of another object. In case of a message from an object to itself, the arrow may start and finish on the same object symbol. The arrow is labeled with the name of the message (operation or signal) and its argument values. The arrow may also be labeled with a sequence number to show the sequence of the message in the overall interaction. Sequence numbers are often omitted in sequence diagrams, in which the physical location of the arrow shows the relative sequences, but they are necessary in collaboration diagrams. Sequence numbers are useful on both kinds of diagrams for identifying concurrent threads of control. A message may also be labeled with a guard condition.\n7.5.3 Presentation options\n\nVariation: Asynchronous. An asynchronous message is drawn with a half-arrowhead (one with only one wing instead of two).\n\nVariation: Call. A procedure call is drawn as a full arrowhead. A return is shown as a dashed arrow.\n\nVariation: In a procedural flow of control, the return arrow may be omitted (it is implicit at the end of an activation). It is assumed that every call has a paired return after any subordinate messages; the return value can be shown on the initial message line. For nonprocedural flow of control (including parallel processing and asynchronous messages) returns should be shown explicitly.\n\nVariation: In a concurrent system, a full arrowhead shows the yielding of a thread of control (wait semantics) and a half arrowhead shows the sending of a message without yielding control (no-wait semantics).\n\nVariation: Normally message arrows are drawn horizontally. This indicates the duration required to send the message is “atomic”, that is, it is brief compared to the granularity of the interaction and that nothing else can “happen” during the message transmission. This is the correct assumption within many computers. If the message requires some time to arrive, during which something else can occur (such as a message in the opposite direction) then the message arrow may be slanted downward so that the arrowhead is below the arrow tail.\n\nVariation: Branching. A branch is shown by multiple arrows leaving a single point, each labeled by a guard condition. Depending on whether the guard conditions are mutually exclusive, the construct may represent conditionality or concurrency.\n\nVariation: Iteration. A connected set of messages may be enclosed and marked as an iteration. For a scenario, the iteration indicates that the set of messages can occur multiple times. For a procedure, the continuation condition for the iteration may be specified at the bottom of the iteration. If there is concurrency, then some messages in the diagram may be part of the iteration and others may be single execution. It is desirable to arrange a diagram so that the messages in the iteration can be enclosed together easily.\n\nVariation: A lifeline may subsume an entire set of objects on a diagram representing a high-level view.\n\nVariation: A distinction may be made between a period during which an object has a live activation and a period in which the activation is actually computing. The former (during which it has control information on a stack but during which control resides in something that it called) is shown with the ordinary double line; the latter (during which it is the top item on the stack) may be distinguished by shading the region.\n\n7.5.4 Mapping\n\nSee Section 7.2.5.\n7.6 TRANSITION TIMES\n\n7.6.1 Semantics\n\nA message may have a sending time and a receiving time. These are formal names that may be used within constraint expressions. The two may be the same (if the message is considered atomic) or different (if its delivery is nonatomic).\n\n7.6.2 Notation\n\nA transition instance (such as a message in a sequence diagram or a collaboration diagram or a transition in a state machine) may be given a name. The name represents the time at which a message is sent (example: A). In cases where the delivery of the message is not instantaneous, the time at which the message is received is indicated by the transition name with a prime sign appended (example: A'). The name may be shown in the left margin aligned with the arrow (on a sequence diagram) or near the tail of the message flow arrow (on a collaboration diagram). This name may be used in constraint expressions to designate the time the message was sent. If the message line is slanted, then the primed-name indicates the time at which the message is received.\n\nConstraints may be specified by placing Boolean expressions in braces on the sequence diagram.\n\n7.6.3 Example\n\nSee Figure 35.\n\n7.6.4 Mapping\n\nSee Section 7.2.5.\n8. COLLABORATION DIAGRAMS\n\nA collaboration diagram shows an interaction organized around the objects in the interaction and their links to each other. Unlike a sequence diagram, a collaboration diagram shows the relationships among the object roles. On the other hand, a collaboration diagram does not show time as a separate dimension, so the sequence of messages and the concurrent threads must be determined using sequence numbers.\n\n8.1 COLLABORATION\n\n8.1.1 Semantics\n\nBehavior is implemented by sets of objects that exchange messages within an overall interaction to accomplish a purpose. To understand the mechanisms used in a design, it is important to see only the objects and the messages involved in accomplishing a purpose or a related set of purposes, projected from the larger system of which they are part for other purposes. Such a static construct is called a collaboration.\n\nA collaboration is a set of participants and relationships that are meaningful for a given set of purposes. The identification of participants and their relationships does not have global meaning.\n\nA collaboration may be attached to an operation or a use case to describe the context in which their behavior occurs. The actual behavior may be specified in interactions, such as sequence diagrams or collaboration diagrams. A collaboration may also be attached to a class to define the class’s static structure.\n\nA parameterized collaboration represents a design construct that can be used repeatedly in different designs. The participants in the collaboration, including the classes and relationships, can be parameters of the generic collaboration. The parameters are bound to particular model elements in each instantiation of generic collaboration. Such a parameterized collaboration can capture the structure of a design pattern (note that a design pattern involves more than structural aspects). Whereas most collaborations can be anonymous because they are attached to a named entity, patterns are free standing design constructs that must have names.\n\nA collaboration may be expressed at different levels of granularity. A coarse-grained collaboration may be refined to produce another collaboration that has a finer granularity.\n\n8.1.2 Notation\n\nThe description of behavior involves two aspects: the structural description of its participants and the behavioral description of its execution. The two aspects are often described together on a single diagram but at times it is useful to describe the structural and behavioral aspects separately. The structure of objects playing roles in a behavior and their relationships is called a collaboration. A collaboration shows the context in which interaction occurs. The dynamic behavior of the message\nCollaboration Diagrams\n\nsequences exchanged among objects to accomplish a specific purpose is called an interaction. A collaboration is shown by a collaboration diagram without messages. By adding messages, an interaction is shown. Different sets of messages may be applied to the same collaboration to yield different interactions.\n\n8.2 COLLABORATION DIAGRAM\n\n8.2.1 Semantics\n\nA collaboration diagram represents a Collaboration, which is a set of objects related in a particular context, and an Interaction, which is a set of messages exchanged among the objects within a collaboration to effect a desired operation or result.\n\n8.2.2 Notation\n\nA collaboration diagram is a graph of references to objects and links with message flows attached to its links. The diagram shows the objects relevant to the performance of an operation, including objects indirectly affected or accessed during the operation. The collaboration used to describe an operation includes its arguments and local variables created during its execution as well as ordinary associations. Objects created during the execution may be designated as {new}; objects destroyed during the execution may be designated as {destroyed}; objects created during the execution and then destroyed may be designated as {transient}. These changes in life state are derivable from the detailed messages sent among the objects; they are provided as notational conveniences.\n\nThe diagram also shows the links among the objects, including transient links representing procedure arguments, local variables, and self links. Because collaboration diagrams are often used to help design procedures, they typically show navigability using arrowheads on links. (An arrowhead on a line between object boxes indicates a link with one-way navigability. An arrow next to a line indicates a message flowing in the given direction over the link. Obviously a message arrow cannot flow backwards over a one-way link.)\n\nIndividual attribute values are usually not shown explicitly. If messages must be sent to attribute values, the attributes should be modeled using associations instead.\n\nThe internal messages that implement a method are numbered starting with number 1. For a procedural flow of control the subsequent message numbers are nested in accordance with call nesting. For a nonprocedural sequence of messages exchanged among concurrent objects all the sequence numbers are at the same level (that is, they are not nested).\n\nA collaboration diagram without messages shows the context in which interactions can occur, without showing any specific interactions. It might be used to show the context for a single operation or even for all of the operations of a class or group of classes.\n8.2.3 Example\n\nFigure 8.2.3. Collaboration diagram\n\n8.2.4 Mapping\n\nA collaboration diagram maps to a Collaboration with a superimposed Interaction.\n\n8.3 Pattern Structure\n\n8.3.1 Semantics\n\nA collaboration can be used to specify the implementation of design constructs. For this purpose it is necessary to specify its context and interactions. It is also possible to view a collaboration as a single entity from the “outside.” For example, this could be used to identify the presence of design patterns within a system design. A pattern is a parameterized collaboration; in each use of the pattern, actual classes are substituted for the parameters in the pattern definition.\n\nNote that patterns as defined in Design Patterns by Gamma, Helm, Johnson, and Vlissides include much more than structural descriptions. UML describes the structural aspects and some behavioral\naspects of design patterns, but UML notation does not include other important aspects of patterns, such as usage trade-offs or examples. These must be expressed in text or tables.\n\n8.3.2 Notation\n\nA use of a collaboration is shown as a dashed ellipse containing the name of the collaboration. A dashed line is drawn from the collaboration symbol to each of the objects or classes (depending on whether it appears within an object diagram or a class diagram) that participate in the collaboration. Each line is labeled by the role of the participant. The roles correspond to the names of elements within the context for the collaboration; such names in the collaboration are treated as parameters that are bound to specify elements on each occurrence of the pattern within a model. Therefore a collaboration symbol can shown the use of a design pattern together with the actual classes that occur in that particular use of the pattern.\n\nFigure 38. Use of a collaboration\n\n8.3.3 Mapping\n\nA collaboration usage symbol maps into a Collaboration. For each class symbol attached by an arrow to the pattern occurrence symbol, the corresponding Class is bound to the template parameter that is the type association target of the ClassifierRole in the Pattern with the name equal to the name on the arrow.\n8.4 Collaboration Contents\n\nThe contents of a collaboration are modeling elements that interact within a given context for a particular purpose, such as performing an operation or a use case; it is a \"society of objects\". A collaboration is a fragment of a larger complete model that is intended for a particular purpose.\n\n8.4.1 Semantics\n\nA collaboration shows one or more roles together with their contents, associations, and neighbor roles, plus additional relationships and classes as needed. To use a collaboration, each role must be bound to an actual class that can support the operations required of the role.\n\n8.4.2 Notation\n\nA collaboration is shown as a graph of class references and association references. Each reference is a role of the collaboration; that is, each entity is playing a role within the context of the collaboration, a role that is only part of its full description. The names of the objects represent their roles within the collaboration. A collaboration is a prototype; in each use of the collaboration the roles are bound to actual objects. There are several ways to show the diagram:\n\nMethods. If the collaboration shows the implementation of an operation (a method), then it is usually drawn as a separate collaboration diagram including context to which message flow is added to obtain an interaction. The collaboration for the operation includes the target object of the operation and any other objects that it calls on, directly or indirectly, to implement the operation. The collaboration includes the objects present before the operation, the objects present after the operation (these may be the same or mostly the same as the ones before), and objects that exist only during the operation; these may be marked as \"new\", \"destroyed\", and \"transient\". Only objects involved in the operation implementation need be shown. To show the implementation of an operation, message flows are superimposed on the links between objects in the collaboration; each flow shows a step within the method for the operation (see Section 8.9).\n\nClasses. A collaboration is normally defined for a single operation. By taking the union of all of the collaborations for all of the operations of a class, an overall collaboration for the entire class can be shown. This collaboration shows all of the context for the implementation of the class.\n\nIn both cases the usual assumption is that objects and classes not shown on the collaboration are not affected by the operation. (It is not always safe to assume that all of the objects on a collaboration diagram are used by the operation, however.)\n\nDifferent collaborations may be devised for the same class for different purposes. Each collaboration may show a somewhat different subset of attributes, operators, and related objects that are relevant to each purpose. Inasmuch as actual operations often fall into related groups, each collaboration might specify a consistent view shared by several operations that is somewhat different from the view needed by other operations on the same type. Similarly, the model of types in a business\norganization can often be divided into several collaborations, each from the point of view of a particular stakeholder.\n\n8.5 **INTERACTIONS**\n\nA collaboration of objects interacts to accomplish a purpose (such as performing an operation) by exchanging messages. The messages may include both signals and calls, as well as more implicit interaction through conditions and time events. A specific pattern of message exchanges to accomplish a specific purpose is called an *interaction*.\n\n8.5.1 **Semantics**\n\nAn *interaction* is a behavioral specification that comprises a sequence of message exchanges among a set of objects within a collaboration to accomplish a specific purpose, such as the implementation of an operation. To specify an interaction, it is first necessary to specify a collaboration, that is, the establish the objects that interact and their relationships. Then the possible interaction sequences are specified. These can be specified in a single description containing conditionals (branches or conditional signals), or they can be specified by supplying multiple descriptions, each describing a particular path through the possible execution paths.\n\n8.5.2 **Notation**\n\nInteractions are shown as sequence diagrams or as collaboration diagrams. Both diagram formats show the execution of collaborations. However, sequence diagrams only show the participating objects and do not show their relationships to other objects or their attributes, therefore they do not fully show the context aspect of a collaboration. Sequence diagrams do show the behavioral aspect of collaborations explicitly, including the time sequence of message and explicit representation of method activations. Sequence diagrams are described in Chapter 7. Collaboration diagrams show the full context of an interaction, including the objects and their relationships relevant to a particular interaction, so they are often better for design purposes. Collaboration diagrams are described in the following sections.\n\n8.5.3 **Example**\n\nSee Collaboration Diagram section for a collaboration underlying an interaction.\n8.6 **COLLABORATION ROLES**\n\n8.6.1 **Semantics**\n\nA Role is a slot for an object within a collaboration that describes the type of object that may play the role and describes its relationships to other Roles. There are ClassifierRoles and Association-Roles.\n\n8.6.2 **Notation**\n\nA collaboration role is shown using the notation for an object or a link. Keep in mind, however, that in the context of a collaboration these represent roles that bind to actual objects or links when the collaboration is used, not actual objects and links.\n\nA class role is shown as a class rectangle symbol. Normally only the name compartment is shown. The name compartment contains the string:\n\n```\nclassRoleName : Classname\n```\n\nThe classname can include a full pathname of enclosing packages, if necessary (a tool will normally permit shortened pathnames to be used when they are unambiguous). The package names precede the classname and are separated by double colons. For example:\n\n```\ndisplay_window: WindowingSystem::GraphicWindows::Window\n```\n\nA stereotype for the class may be shown textually (in guillemets above the name string) or as an icon in the upper right corner. The stereotype for an object must match the stereotype for its class.\n\nA class role representing a set of objects includes a multiplicity indicator (such as “*”) in the upper right corner of the class box.\n\nAn association role is shown as a path between two class role symbols. If the name of the corresponding association is included it is underlined. Rolenames are not underlined. Even in absence of underlining a line connecting class roles is an association role.\n\nIf one end of the association role path is connected to a multiple class role, then a multiplicity indicator may be placed on that end to emphasize the multiplicity.\n\n8.6.3 **Presentation options**\n\nThe name of the object may be omitted. In this case the colon should be kept with the class name. This represents an anonymous object of the given class given identity by its relationships.\n\nThe class of the object may be suppressed (together with the colon).\n8.6.4 Example\n\nSee Figure 37.\n\n8.6.5 Mapping\n\nThe object symbol in a collaboration diagram maps to a ClassifierRole whose name matches the object part of the name string; the role has a type Association to a Classifier whose name matches the type part of the name string.\n\n8.7 MULTIOBJECT\n\n8.7.1 Semantics\n\nA multiobject represents a set of objects on the “many” end of an association. This is used to show operations that address the entire set, rather than a single object in it. The underlying static model is unaffected by this grouping. This corresponds to an association with multiplicity “many” used to access a set of associated objects.\n\n8.7.2 Notation\n\nA multiobject is shown as two rectangles in which the top rectangle is shifted slightly vertically and horizontally to suggest a stack of rectangles. A message arrow to the multiobject symbol indicates a message to the set of objects, for example, a selection operation to find an individual object.\n\nTo perform an operation on each object in a set of associated objects requires two messages: an iteration to the multiobject to extract links to the individual objects, then a message sent to each individual object using the (temporary) link. This may be elided on a diagram by combining the messages into a single message that includes an iteration and an application to each individual object; the target rolename takes a “many” indicator (*) to show that many individual links are implied. Although this may be written as a single message, in the underlying model (and in any actual code) it requires the two layers of structure (iteration to find links, message using each link) mentioned previously.\n\nAn object from the set is shown as a normal object symbol, but it may be attached to the multiobject symbol using a composition link to indicate that it is part of the set. A message arrow to the simple object symbol indicates a message to an individual object.\n\nTypically a selection message to a multiobject returns a reference to an individual object, to which the original sender then sends a message.\n8.7.3 Example\n\nFigure 39. Multiobject\n\n8.7.4 Mapping\n\nA multiobject symbol maps to a ClassifierRole with multiplicity “many” (or whatever is explicitly specified). In other respects it maps the same as an object symbol.\n\n8.8 ACTIVE OBJECT\n\nAn active object is one that owns a thread of control and may initiate control activity. A passive object is one that holds data but that does not initiate control. However, a passive object may send messages in the process of processing a request that it has received. In a collaboration diagram, a ClassifierRole that is an active class represents the active objects that occur during execution.\n\n8.8.1 Semantics\n\nAn active object is an object that owns a thread of control. Processes and tasks are traditional kinds of active objects.\n\n8.8.2 Notation\n\nA role for an active object is shown as an object symbol with a heavy border. Frequently active object roles are shown as composites with embedded parts.\n\nThe property keyword \\textit{active} may also be used to indicate an active object.\n8.8.3 Example\n\nFigure 40. Composite active object\n\n8.8.4 Mapping\n\nAn active object symbol maps as an object symbol does, with the addition that the *active* property is set.\n\nA nested object symbol (active or not) maps into a Classifier role that has a composition association to the roles corresponding to its contents, as described under Composition.\n8.9 MESSAGE FLOWS\n\n8.9.1 Semantics\n\nA message flow is the sending of a message from one object to another. The implementation of a message may take various forms, such as a procedure call, the sending of a signal between active threads, the explicit raising of events, and so on.\n\n8.9.2 Notation\n\nA message flow is shown as a labeled arrow placed near a link. The meaning is 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).\n\nControl flow type. The following arrowhead variations may be used to show different kinds of messages:\n\n- filled solid arrowhead →\n procedure call or other nested flow of control. The entire nested sequence is completed before the outer level sequence resumes. May be used with ordinary procedure calls. May also be used with concurrently active objects when one of them sends a signal and waits for a nested sequence of behavior to complete.\n\n- stick arrowhead →\n Flat flow of control. Each arrow shows the progression to the next step in sequence. Normally all of the messages are asynchronous.\n\n- half stick arrowhead →\n asynchronous flow of control. Used instead of the stick arrowhead to explicitly show an asynchronous message between two objects in a procedural sequence.\n\n- other variations\n other kinds of control may be shown, such as “balking” or “time-out”, but these are treated as extensions to the UML core\n\nMessage label. The label has the following syntax:\n\npredecessor guard-condition sequence-expression return-value := message-name argument-list\n\nThe label indicates the message sent, its arguments and return values, and the sequencing of the message within the larger interaction, including call nesting, iteration, branching, concurrency, and synchronization.\nPredecessor. The predecessor is a comma-separated list of sequence numbers followed by a slash (’/’):\n\n\\[\n\\text{sequence-number } \\text{’}, \\ldots \\text{’}/\n\\]\n\nThe clause is omitted if the list is empty.\n\nEach sequence-number is a sequence-expression without any recurrence terms. It must match the sequence number of another message.\n\nThe meaning is that the message flow is not enabled until all of the message flows whose sequence numbers are listed have occurred (a thread can go beyond the required message flow and the guard remains satisfied). Therefore the guard condition represents a synchronization of threads.\n\nNote that the message corresponding to the numerically preceding sequence number is an implicit predecessor and need not be explicitly listed. All of the sequence numbers with the same prefix form a sequence; the numerical predecessor is the one in which the final term is one less. That is, number 3.1.4.5 is the predecessor of 3.1.4.6.\n\nSequence expression. The sequence-expression is a dot-separated list of sequence-terms followed by a colon (’::’). Each term represents a level of procedural nesting within the overall interaction. If all the control is concurrent, then nesting does not occur. Each sequence-term has the following syntax:\n\n\\[\n[ \\text{integer} | \\text{name} ] [ \\text{recurrence} ]\n\\]\n\nThe integer represents the sequential order of the message within the next higher level of procedural calling. Messages that differ in one integer term are sequentially related at that level of nesting. Example: Message 3.1.4 follows message 3.1.3 within activation 3.1.\n\nThe name represents a concurrent thread of control. Messages that differ in the final name are concurrent at that level of nesting. Example: message 3.1a and message 3.1b are concurrent within activation 3.1. All threads of control are equal within the nesting depth.\n\nThe recurrence represents conditional or iterative execution. This represents zero or more messages that are executed depending on the conditions involved. The choices are:\n\n\\[\n\\text{’*’} \\text{’[ iteration-clause ’]’} \\quad \\text{An iteration}\n\\]\n\n\\[\n\\text{’[ condition-clause ’]’} \\quad \\text{A branch}\n\\]\n\nAn iteration represents a sequence of messages at the given nesting depth. The iteration clause may be omitted (in which case the iteration conditions are unspecified). The iteration-clause is meant to be expressed in pseudocode or an actual programming language; UML does not prescribe its format. An example would be: *\\{i := 1..n\\}.\n\nA condition represents a message that whose execution is contingent on the truth of the condition clause. The condition-clause is meant to be expressed in pseudocode or an actual programming language; UML does not prescribe its format. An example would be: \\{x > y\\}.\nCollaboration Diagrams\n\nNote that a branch is notated the same as an iteration without a star; one might think of it as an iteration restricted to a single occurrence.\n\nThe iteration notation assumes that the messages in the iteration will be executed sequentially. There is also the possibility of executing them concurrently. The notation for this is to follow the star by a double vertical line (for parallelism): *||.\n\nNote that in a nested control structure, the recurrence is not repeated at inner levels. Each level of structure specifies its own iteration within the enclosing context.\n\nSignature. A signature is a string that indicates the name, the arguments, and the return value of an operation, message, or signal. These have the following properties:\n\nReturn-value. This is a list of names that designates the values returned by the message within the subsequent execution of the overall interaction. These identifiers can be used as arguments to subsequent messages. If the message does not return a value, then the return value and the assignment operator are omitted.\n\nMessage-name. This is the name of the event raised in the target object (which is often the event of requesting an operation to be performed). It may be implemented in various ways, one of which is an operation call. If it is implemented as a procedure call, then this is the name of the operation and the operation must be defined on the class of the receiver or inherited by it. In other cases it may be the name of an event that is raised on the receiving object. In normal practice with procedural overloading, both the message name and the argument list types are required to identify a particular operation.\n\nArgument list. This is a comma-separated list of arguments (actual parameters) enclosed in parentheses. The parentheses can be used even if the list is empty. Each argument is an expression in pseudocode or an appropriate programming language (UML does not prescribe). The expressions may use return values of previous messages (in the same scope) and navigation expressions starting from the source object (that is, attributes of it and links from it and paths reachable from them).\n\n8.9.3 Presentation options\n\nInstead of text expressions for arguments and return values, data tokens may be shown near a message. A token is a small circle labeled with the argument expression or return value name; it has a small arrow on it that points along the message (for an argument) or opposite the message (for a return value). Tokens represent arguments and return values. The choice of text syntax or tokens is a presentation option.\n\nThe syntax of messages may instead be expressed in the syntax of a programming language, such as C++ or Smalltalk. All of the expressions on a single diagram should use the same syntax, however.\n8.9.4 Example\n\nSee Figure 37 for examples within a diagram.\n\nSamples of control message label syntax:\n\n2: display (x, y) simple message\n1.3.1: p:= find(specs) nested call with return value\n[x < 0] 4: invert (x, color) conditional message\nA3,B4/ C3.1*: update () synchronization with other threads, iteration\n\n8.9.5 Mapping\n\nA message flow symbol maps into a Message between the ClassifierRoles corresponding to the boxes connected by the association path bearing the message flow symbol. The control flow type sets the corresponding Message properties.\n\nThe predecessor expression together with the sequence expression determine the predecessor and activation (caller) associations between the Message and other messages. The predecessors of the Message are the messages corresponding to the sequence numbers in the predecessor list as well as the message corresponding to the immediate preceding sequence number as the Message (i.e., 1.2.2 is the one preceding 1.2.3). The caller of the Message is the Message whose sequence number is truncated by one position (i.e., 1.2 is the caller of 1.2.3).\n\nThe return value maps into a message from the called object to the caller with direction return. Its predecessor is the final message within the procedure. Its activation is the message that called the procedure.\n\nThe recurrence expression, the iteration clause, and the condition clause determine the recurrence value in the Message.\n\nThe operation name and the form of the signature determine the Operation attached to the CallAction associated with the Message.\n\nThe arguments of the signature determine the arguments associated with the CallAction.\n\nIn a procedural interaction, each message flow symbol also maps into a second Message with the properties (synchronous, reply) representing the return flow. This Message has an activation Association to the original call Message. Its associated Action is a ReturnAction bearing the return values as arguments (if any).\n8.10 CREATION/DESTRUCTION MARKERS\n\n8.10.1 Semantics\n\nDuring the execution of an interaction some objects and links are created and some are destroyed. The creation and destruction of elements can be marked.\n\n8.10.2 Notation\n\nAn object or link that is created during an interaction has the keyword new as a constraint. An object or link that is destroyed during an interaction has the keyword destroyed as a constraint. The keyword may be used even if the element has no name. Both keywords may be used together, but the keyword transient may be used in place of new destroyed.\n\n8.10.3 Presentation options\n\nTools may use other graphic markers in addition to or in place of the keywords. For example, each kind of lifetime might be shown in a different color. A tool may also use animation to show the creation and destruction of elements and the state of the system at various times.\n\n8.10.4 Example\n\nSee Figure 37.\n\n8.10.5 Mapping\n\nCreation or destruction indicators map into CreateActions or DestroyActions actions on the target ClassifierRoles or into TerminateActions. The actions correspond to messages that cause the changes. These status indicators are merely summaries of the total actions.\n9. STATECHART DIAGRAMS\n\nA statechart diagram shows the sequences of states that an object or an interaction goes through during its life in response to received stimuli, together with its responses and actions.\n\nThe semantics and notation described in this chapter are substantially those of David Harel’s state-charts with modifications to make them object-oriented. His work was a major advance on the traditional flat state machines. Statechart notation also implements aspects of both Moore machines and Mealy machines, traditional state machine models.\n\n9.1 STATECHART DIAGRAM\n\n9.1.1 Semantics\n\nA state machine is a graph of states and transitions that describes the response of an object of a given class to the receipt of outside stimuli. A state machine is attached to a class or a method.\n\n9.1.2 Notation\n\nA statechart diagram represents a state machine. The states are represented by state symbols and the transitions are represented by arrows connecting the state symbols. States may also contain subdiagrams by physical containment and tiling.\n9.1.3 Mapping\n\nA statechart diagram maps into a StateMachine. That StateMachine may be attached to a Class or a Method but there is no explicit notation for this.\n\n9.2 STATES\n\n9.2.1 Semantics\n\nA state is a condition during the life of an object or an interaction during which it satisfies some condition, performs some action, or waits for some event. An object remains in a state for a finite (non-instantaneous) time.\n\nActions are atomic and non-interruptible. A state may correspond to ongoing activity. Such activity is expressed as a nested state machine. Alternately, ongoing activity may be represented by a pair of actions, one that starts the activity on entry to the state and one that terminates the activity on exit from the state.\nStatechart Diagrams\n\nEach subregion of a state may have initial states and final states. A transition to the enclosing state represents a transition to the initial state. A transition to a final state represents the completion of activity in the enclosing region; completion of activity in all concurrent regions represents completion of activity by the enclosing state and triggers a “completion of activity” event” on the enclosing state. Completion of the outermost state of an object corresponds to its death.\n\n9.2.2 Notation\n\nA state is shown as a rectangle with rounded corners. It may have one or more compartments. The compartments are all optional. They are as follows:\n\nName compartment. Holds the (optional) name of the state as a string. States without names are “anonymous” and are all distinct. It is undesirable to show the same named state twice in the same diagram, however, as confusion may ensue.\n\nInternal transition compartment. Holds a list of internal actions or activities performed in response to events received while the object is in the state, without changing state. These have the format:\n\n\\[ \\text{event-name argument-list} ']' \\text{ guard-condition} ']' '}' action-expression \\]\n\nEach event name or pseudo-event name may appear at most once in a single state.\n\nThe following special actions have the same form but represent reserved words that cannot be used for event names:\n\n‘entry’ '}' action-expression An atomic action performed on entry to the state\n\n‘exit’ '}' action-expression An atomic action performed on exit from the state\n\nEntry and exit actions may not have arguments or guard conditions (because they are invoked implicitly, not explicitly). However, the entry action at the top level of the state machine for a class may have parameters that represent the arguments that it receives when it is created.\n\nAction expressions may use attributes and links of the owning object and parameters of incoming transitions (if they appear on all incoming transitions).\n\nThe following keyword represents the invocation of a nested state machine:\n\n‘do’ '}' machine-name (argument-list)\n\nThe machine-name must be the name of a state machine that has an initial and final state. If the nested machine has parameters, then the argument list must match correctly. When this state is entered, after any entry action then execution of the nested state machine begins with its initial state. When the nested state machine reaches its final state, then any exit action in the current state is performed and the current state is considered completed and may take a transition based on implicit completion of activity.\n9.2.3 Example\n\nFigure 42. State\n\n<table>\n<thead>\n<tr>\n<th>Typing Password</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>entry / set echo invisible</td>\n</tr>\n<tr>\n<td>exit / set echo normal</td>\n</tr>\n<tr>\n<td>character / handle character</td>\n</tr>\n<tr>\n<td>help / display help</td>\n</tr>\n</tbody>\n</table>\n\n9.2.4 Mapping\n\nA state symbol maps into a State. See the next section for further details on which kind of state.\n\nThe name string in the symbol maps to the name of the state. Two symbols with the same name map into the same state. However, each state symbol with no name (or an empty name string) maps into a distinct anonymous State.\n\nAn internal action string with the name “entry” or “exit” maps into an association: the source is the State corresponding to the enclosing state symbol; the target is an ActionSequence that maps the action expression; the association is the Entry action or the Exit action association.\n\nAn internal action string with the name “do” maps into the invocation of a nested state machine.\n\nAny other internal action maps into an internal Association from the corresponding State to a Transition. The action expression maps into the ActionSequence and Guard for the Transition. The event name and arguments map into an Event corresponding to the event name and arguments; the Transition has a trigger Association to the Event.\n\n9.3 Composite States\n\n9.3.1 Semantics\n\nA state can be decomposed using and-relationships into concurrent substates or using or-relationships into mutually exclusive disjoint substates. A given state may only be refined in one of these two ways. Its substates can may be refined in the same way or the other way.\n\nA newly-created object starts in its initial state. The event that creates the object may be used to trigger a transition from the initial state symbol.\nAn object that transitions to its outermost final state ceases to exist.\n\n### 9.3.2 Notation\n\nAn expansion of a state shows its fine structure. In addition to the (optional) name and internal transition compartments, the state may have an additional compartment that contains a region holding a nested diagram. For convenience and appearance, the text compartments may be shrunk horizontally within the graphic region.\n\nAn expansion of a state into concurrent substates is shown by tiling the graphic region of the state using dashed lines to divide it into subregions. Each subregion is a concurrent substate. Each subregion may have an optional name and must contain a nested state diagram with disjoint states. The text compartments of the entire state are separated from the concurrent substates by a solid line.\n\nAn expansion of a state into disjoint substates is shown by showing a nested state diagram within the graphic region.\n\nAn initial (pseudo)state is shown as a small solid filled circle. In a top-level state machine, the transition from an initial state may be labeled with the event that creates the object; otherwise it must be unlabeled. If it is unlabeled, it represents any transition to the enclosing state. The initial transition may have an action. The initial state is a notational device; an object may not be in such a state but must transition to an actual state.\n\nA final (pseudo)state is shown as a circle surrounding a small solid filled circle (a bull’s eye). It represents the completion of activity in the enclosing state and it triggers a transition on the enclosing state labeled by the implicit activity completion event (usually displayed as an unlabeled transition).\n\n### 9.3.3 Example\n\nFigure 43. Sequential substates\n9.3.4 Mapping\n\nA state symbol maps into a State. If the symbol has no subdiagrams in it, it maps into a SimpleState; if it is tiled by dashed lines into subregions then it maps into a CompositeState with the `isConcurrent` value true, otherwise it maps into a CompositeState with the `isConcurrent` value false.\n\nAn initial state symbol or a final state symbol map into a Pseudostate of kind `initial` or `final`.\n\n9.4 EVENTS\n\n9.4.1 Semantics\n\nAn event is a noteworthy occurrence. For practical purposes in state diagrams, it is an occurrence that may trigger a state transition. Events may be of several kinds (not necessarily mutually exclusive):\n\n- a designated condition becoming true (usually described as a boolean expression). This is a ChangeEvent. These are notated with the keyword `when` followed by a boolean expression in parentheses. The event occurs whenever the value of the expression changes from false to true. Note that this is different from a guard condition: A guard condition is evalu-\nated *once* whenever its event fires; if it is false then the transition does not occur and the event is lost. Example: \\texttt{when (balance < 0)}.\n\nreceipt of an explicit signal from one object to another. This is a SignalEvent. One of these is notated by the signature of the event as a trigger on a transition.\n\nreceipt of a call for an operation by an object. This is a CallEvent. These are notated by the signature of the operation as a trigger on a transition. There is no visual difference from a signal event; it is assumed that the names with distinguish them.\n\npassage of a designated period of time after a designated event (often the entry of the current state) or the occurrence of a given date/time. This is a TimeEvent. These are notated as time expressions as triggers on transitions. One common time expression is the passage of time since the entry to the current state; this is notated with the keyword \\texttt{after} followed by an amount of time in parentheses. Example: \\texttt{after (10 seconds)}.\n\nThe event declaration has scope within the package it appears in and may be used in state diagrams for classes that have visibility inside the package. An event is \\textit{not} local to a single class.\n\n### 9.4.2 Notation\n\nA signal or call event can be defined using the following format:\n\n```\n\\texttt{event-name \\{ (comma-separated-parameter-list \\})}\n```\n\nA parameter has the format:\n\n```\n\\texttt{parameter-name \\: \\texttt{:} \\: type-expression}\n```\n\nA signal can be declared using the «signal» keyword on a class symbol in a class diagram. The parameters are specified as attributes. A signal can be specified as a subclass of another signal. This indicates that an occurrence of the subevent triggers any transition that depends on the event or any of its ancestors.\n\nAn elapsed-time event can be specified with the keyword \\texttt{after} followed by an expression that evaluates (at modeling time) to an amount of time, such as “\\texttt{after (5 seconds)}” or \\texttt{after (10 seconds since exit from state A)}”. If no starting point is indicated, then it is the time since the entry to the current state. Other time events can be specified as conditions, such as \\texttt{when (date = Jan. 1, 2000)}.\n\nA condition becoming true is shown with the keyword \\texttt{when} followed by a boolean expression. This may be regarded as a continuous test for the condition until it is true, although in practice it would only be checked on a change of values (and there are ways to determine when it must be checked). This is mapped into a ChangeEvent in the model.\n\nSignals can be declared on a class diagram with the keyword «signal» on a rectangle symbol. These define signal names that may be used to trigger transitions. Their parameters are shown in the attribute compartment. They have no operations. They may appear in a generalization hierarchy. Note that they are \\textit{not} real classes and may not appear in relationships to real classes.\n9.4.3 Example\n\nFigure 45. Signal declaration\n\n```\n<signal>\n InputEvent\n time\n\n<signal>\n UserInput\n device\n\n<signal>\n Mouse\n Button\n location\n\n<signal>\n Keyboard\n Character\n character\n\n<signal>\n Mouse\n Button\n Down\n\n<signal>\n Mouse\n Button\n Up\n\n<signal>\n Control\n Character\n\n<signal>\n Graphic\n Character\n\n<signal>\n Space\n\n<signal>\n Alphanumeric\n\n<signal>\n Punctuation\n```\n\n9.4.4 Mapping\n\nA class box with stereotype «signal» maps into a Signal; the name and parameters are given by the name string and the attribute list of the box. Generalization arrows between signal class boxes map into Generalization relationships between the Signal.\n\nThe usage of an event string expression in a context requiring an event maps into an implicit reference of the Event with the given name. It is an error if various uses of the same name (including any explicit declarations) do not match.\n9.5 **SIMPLE TRANSITIONS**\n\n9.5.1 Semantics\n\nA simple transition is a relationship between two states indicating that an object in the first state will enter the second state and perform certain specified actions when a specified event occurs if specified conditions are satisfied. On such a change of state the transition is said to “fire”. The trigger for a transition is the occurrence of the event labeling the transition. The event may have parameters, which are available within actions specified on the transition or within actions initiated in the subsequent state. Events are processed one at a time. If an event does not trigger any transition, it is simply ignored. If it triggers more than one transition within the same sequential region (i.e., not in different concurrent regions), only one will fire; the choice may be nondeterministic if a firing priority is not specified.\n\n9.5.2 Notation\n\nA transition is shown as a solid arrow from one state (the source state) to another state (the target state) labeled by a transition string. The string has the following format:\n\n```\nevent-signature ‘[’ guard-condition ‘]’ ‘/’ action-expression ‘^’ send-clause\n```\n\nThe *event-signature* describes an event with its arguments:\n\n```\nevent-name ‘(’ parameter ‘,’ . . . ‘)’\n```\n\nThe *guard-condition* is a Boolean expression written in terms of parameters of the triggering event and attributes and links of the object that owns the state machine. The guard condition may also involve tests of concurrent states of the current machine (or explicitly designated states of some reachable object); for example, “in State1” or “not in State2”. State names may be fully qualified by the nested states that contain them, yielding path names of the form “State1::State2::State3”; this may be used in case same state name occurs in different composite state regions of the overall machine.\n\nThe *action-expression* is a procedural expression that is executed if and when the transition fires. It may be written in terms of operations, attributes, and links of the owning object and the parameters of the triggering event. The action-clause must be an atomic operation, that is, it may not be interruptible; it must be executed entirely before any other actions are considered. The transition may contain more than one action clause (with delimiter).\n\n‘The *send-clause* is a special case of an action, with the format:\n\n```\ndestination-expression ‘.’ destination-message-name ‘(’ argument ‘,’ . . . ‘)’\n```\n\nThe transition may contain more than one send clause (with delimiter). The relative order of action clauses and send clauses is significant and determines their execution order.\nThe *destination-expression* is an expression that evaluates to an object or a set of objects.\n\nThe *destination-message-name* is the name of a message (operation or signal) meaningful to the destination object(s).\n\nThe *destination-expression* and the *arguments* may be written in terms of the parameters of the triggering event and the attributes and links of the owning object.\n\n**Branches.** A simple transition may be extended to include a tree of decision symbols (see Section 10.3). This is equivalent to a set of individual transitions, one for each path through the tree, whose guard condition is the “and” of all of the conditions along the path.\n\n**Transition times.** Names may be placed on transitions to designate the times at which they fire. See the section on transition times within Section 7.6.\n\n### 9.5.3 Example\n\n```\nright-mouse-down (location) [location in window] / object := pick-object (location)\n^ object.highlight ()\n```\n\nThe event may be of any of the types; selecting the type depends on the syntax of the name (for time events, for example) but SignalEvents and CallEvents are not distinguishable by syntax and must be discriminated by their declaration elsewhere.\n\n### 9.5.4 Mapping\n\nA transition string and the transition arrow that it labels together map into a Transition and its attachments. The arrow connects two state symbols; the Transition has the corresponding States as its source (the state at the tail) and destination (the state at the head) States in associations to the Transition.\n\nThe event name and parameters map into an Event element, which may be a SignalEvent, a CallEvent, or a TimeExpression (if it has the proper syntax). The event is attached as a trigger Association to the Transition.\n\nThe guard condition maps into a Guard element attached to the Transition.\n\nAn action expression maps into an ActionSequence attached as an effect Association to the Transition; the target object expression (if any) in the expression maps into a target ObjectSetExpression. Each term in the action expression maps into an Action that is a part of the ActionSequence. A send clause maps into a RaiseAction with an ObjectSetExpression for the destination.\n\nA transition time label on a transition maps into a TimingMark attached to the Transition.\n9.6 **COMPLEX TRANSITIONS**\n\nA complex transition may have multiple source states and target states. It represents a synchronization and/or a splitting of control into concurrent threads without concurrent substates.\n\n9.6.1 **Semantics**\n\nA complex transition is enabled when all of the source states are occupied. After a complex transition fires all of its destination states are occupied.\n\n9.6.2 **Notation**\n\nA complex transition is shown as a short heavy bar (a *synchronization* bar, which can represent synchronization, forking, or both). The bar may have one or more solid arrows from states to the bar (these are the *source states*); the bar may have one or more solid arrows from the bar to states (these are the *destination states*). A transition string may be shown near the bar. Individual arrows do not have their own transition strings.\n\n9.6.3 **Example**\n\n\n\n9.6.4 **Mapping**\n\nA bar with multiple transition arrows leaving it maps into a fork Pseudostate; a bar with multiple transition arrows entering it maps into a join Pseudostate. The Transitions corresponding to the incoming and outgoing arrows attach to the pseudostate as if it were a regular state. If a bar has multiple incoming and multiple outgoing arrows, then it maps into a Join connected to a Fork pseudostate by a single Transition with no attachments.\n9.7 TRANSITIONS TO NESTED STATES\n\n9.7.1 Semantics\n\nA transition drawn to the boundary of a complex state is equivalent to a transition to its initial state (or to a complex transition to the initial states of each of its concurrent subregions if it is concurrent). The entry action is always performed when a state is entered from outside.\n\nA transition from a complex state indicates a transition that applies to each of the states within the state region (at any depth); it is “inherited” by the nested states. Inherited transitions can be masked by the presence of nested transitions with the same trigger.\n\n9.7.2 Notation\n\nA transition drawn to a complex state boundary indicates a transition to the complex state. This is equivalent to a transition to the initial state within the complex state region; the initial state must be present. If the state is a concurrent complex state, then the transition indicates a transition to the initial state of each of its concurrent substates.\n\nTransitions may be drawn directly to states within a complex state region at any nesting depth. All entry actions are performed for any states that are entered on any transition. On a transition within a concurrent complex state, transition arrows from the synchronization bar may be drawn to one or more concurrent states; any other concurrent subregions start with their default initial states.\n\nA transition drawn from a complex state boundary indicates a transition of the complex state. If such a transition fires, any nested states are forcibly terminated and perform their exit actions, then the transition actions occur and the new state is established.\n\nTransitions may be drawn directly from states within a complex state region at any nesting depth to outside states. All exit actions are performed for any states that are exited on any transition. On a transition from within a concurrent complex state, transition arrows may be specified from one or more concurrent states to a synchronization bar; specific states in the other regions are therefore irrelevant to triggering the transition.\n\nA state region may contain a history state indicator shown as a small circle containing an ‘H’. The history indicator applies to the state region that directly contains it. A history indicator may have any number of incoming transitions from outside states. It may have at most one outgoing unlabeled transition; this identifies the default “previous state” if the region has never been entered. If a transition to the history indicator fires it indicates that the object resumes the state it last had within the complex region; any necessary entry actions are performed. The history indicator may also be ‘H*’ for deep history. This indicates that the object resumes the state it last had at any depth within the complex region, rather than being restricted to the state at the same level as the history indicator. A region may have both shallow and deep history indicators.\n9.7.3 Presentation options\n\n**Stubbed transitions.** Nested states may be suppressed. Transitions to nested states are subsumed to the most specific visible enclosing state of the suppressed state. Subsumed transitions that do not come from an unlabeled final state or go to an unlabeled initial state may (but need not) be shown as coming from or going to *stubs*. A *stub* is shown as a small vertical line drawn inside the boundary of the enclosing state. It indicates a transition connected to a suppressed internal state. Stubs are not used for transitions to initial or from final states.\n\nNote that events should be shown on transitions leading into a state, either to the state contour or to an internal substate, including a transition to a stubbed state. Events should not normally be shown on transitions leading from a stubbed state to an external state, however. Think of a transition as belonging to its source state; if the source state is suppressed then so are the details of the transition. Note also that a transition from a final state is summarized by an unlabeled transition from the complex state contour (denoting the implicit event “action complete” for the corresponding state).\n\n9.7.4 Example\n\nSee Figure 44 and Figure 46 for examples of complex transitions. Following are examples of stubbed transitions and the history indicator.\n\n\n\n**may be abstracted as**\n\n\n9.7.5 Mapping\n\nAn arrow to any state boundary, nested or not, maps into a Transition between the corresponding States. Similarly for transitions directly to history states.\n\nA history indicator maps into a Pseudostate of kind shallowHistory or deepHistory.\n\nA stubbed transition does not map into anything in the model. It is a notational elision that indicates the presence of transitions to additional states in the model that are not visible in the diagram.\n\n9.8 SENDING MESSAGES\n\n9.8.1 Semantics\n\nMessages are sent by an action in an object to a target set of objects; the target set can be a single object, the entire system, or some other set. The sender can be subsumed to an object, a composite object, or a class.\n\n9.8.2 Notation\n\nSee Section 9.5 for the text syntax of sending messages that cause events for other objects.\n\nSending such a message can also be shown visually. See Section 7.5 and Section 8.9 for details of showing messages in sequence diagrams and collaboration diagrams.\n\nSending a message between state diagrams may be shown by drawing a dashed arrow from the sender to the receiver. Messages must be sent between objects, so this means that the diagram must\nbe some form of object diagram containing objects (not classes). The arrow is labeled with the event name and arguments of the event that is caused by the reception of the event. Each state diagram must be contained within an object symbol representing a collaborating object; graphically the state diagrams may be nested physically within an object symbol, or the object enclosing one state diagram may be implicit (being the object owning the main state diagram at issue). The state diagrams represent the states of the collaborating objects.\n\nNote that this notation may also be used on other kinds of diagrams to show sending of events between classes or objects.\n\nThe sender symbol may be one of:\n\n- A transition. The message is sent as part of the action of firing the transition. This is an alternate presentation to the text syntax for sending messages.\n\n- An object. The message is sent by an object of the class at some point in its life, but the details are unspecified.\n\nThe receiver may be one of:\n\n- An object, including a class reference symbol containing a state diagram. The message is received by the object and may trigger a transition on the corresponding event. There may be many transitions involving the event. This notation may not be used when the target object is computed dynamically; in that case a text expression must be used.\n\n- A transition. The transition must be the only transition in the object involving the given event, or at least the only transition that could possibly be triggered by the particular sending of the message. This notation may not be used when the transition triggered depends on the state of the receiving object and not just on the sender.\n\n- A class designation. This notation would be used to model the invocation of class-scope operations, such as the creation of a new instance. The receipt of such a message causes the instantiation of a new object in its default initial state. The event seen by the receiver may be used to trigger a transition from its default initial state and therefore represents a way to pass information from the creator to the new object.\n9.8.3 Example\n\nFigure 49. Sending messages\n\nStatechart Diagrams\n\nVCR\n\nOff\n\nOn\n\ntoggle Power\n\ntoggle Power\n\nRemote Control\n\nControlling TV\n\nControlling VCR\n\n\"VCR\"\n\n\"power\" button\n\\(^VCR\\).togglePower\n\n\"TV\"\n\n\"power\" button\n\\(^television\\).togglePower\n\ntogglePower\n\nTelevision\n\nOff\n\nOn\n\ntoggle Power\n\ntoggle Power\n9.8.4 Mapping\n\nA send arrow to an object maps into a SendAction whose message is a Signal that corresponds to the name on the arrow and whose target ObjectSetExpression corresponds to the target object.\n\nIf the arrow goes directly to a transition in the target object statechart, then the target ObjectSetExpression corresponds to the object owning the statechart containing the transition. In addition, the transition in the target statechart implicitly triggers on the event being sent (i.e., the name of the sent event is effectively written on the target transition).\n\nIf the sender symbol is an object, then the diagram is suggestive of the sender but has no actual semantic mapping.\n9.9 INTERNAL TRANSITIONS\n\n9.9.1 Semantics\n\nAn internal transition is a transition that remains within a single state rather than a transition that involves two states. It represents the occurrence of an event that does not cause a change of state. Entering the state (from any other state not nested in the particular state) and exiting the state (to any other state not nested in the particular state) are treated notationally as internal transitions with the reserved words “entry” and “exit”, but they are not really internal transitions in the internal model.\n\nNote that an internal transition is not equivalent to a self-transition from a state back to the same state. The self-transition causes the exit and entry actions on the state to be executed and the initial state to be entered, whereas the internal transition does not invoke the exit and entry actions and does not cause a change of state (including a nested state).\n\n9.9.2 Notation\n\nAn internal transition is attached to the state rather than a transition. Graphically it is shown as a text string within the internal transition compartment on a state symbol. The syntax of an internal transition string is the same as for an external transition. See Section 9.5 for details.\n\nFigure 51. State with internal transitions\n\nTyping Password\n\n| help / display help |\n| entry / set echo invisible |\n| exit / set echo normal |\n\n9.9.3 Mapping\n\nThe mapping for internal transitions has been given in Section 9.2.4.\n10. ACTIVITY DIAGRAM\n\n10.1 ACTIVITY DIAGRAM\n\n10.1.1 Semantics\n\nAn activity model is a variation of a state machine in which the states are Activities representing the performance of operations and the transitions are triggered by the completion of the operations. It represents a state machine of a procedure itself; the procedure is the implementation of an operation on the owning class.\n\n10.1.2 Notation\n\nAn activity diagram is a special case of a state diagram in which all (or at least most) of the states are action states and in which all (or at least most) of the transitions are triggered by completion of the actions in the source states. The entire activity diagram is attached (through the model) to a class or to the implementation of an operation or a use case. The purpose of this diagram is to focus on flows driven by internal processing (as opposed to external events). Use activity diagrams in situations where all or most of the events represent the completion of internally-generated actions (that is, procedural flow of control). Use ordinary state diagrams in situations where asynchronous events occur.\n10.1.3 Example\n\nPerson::Prepare Beverage\n\nFigure 52. Activity diagram\n10.1.4 Mapping\n\nAn activity diagram maps into an ActivityModel.\n\n10.2 ACTION STATE\n\n10.2.1 Semantics\n\nAn action state is a shorthand for a state with an internal action and at least one outgoing transition involving the implicit event of completing the internal action (there may be several such transitions if they have guard conditions). Action states should not have internal transitions or outgoing transitions based on explicit events; use normal states for this situation. The normal use of an action state is to model a step in the execution of an algorithm (a procedure).\n\n10.2.2 Notation\n\nAn action state is shown as a shape with straight top and bottom and with convex arcs on the two sides. The action-expression is placed in the symbol. The action expression need not be unique within the diagram.\n\nTransitions leaving an action state should not include an event signature; such transitions are implicitly triggered by the completion of the action in the state. The transitions may include guard conditions and actions.\n\n10.2.3 Presentation options\n\nThe action may be described by natural language, pseudocode, or programming language code. It may use only attributes and links of the owning object.\n\nNote that action state notation may be used within ordinary state diagrams but they are more commonly used with activity diagrams, which are special cases of state diagrams.\n\n10.2.4 Example\n\nFigure 53. Activities\n10.2.5 Mapping\n\nAn action state symbol maps into an ActionState invoking a CallAction. This is equivalent to an entry action on a regular state. There is no exit nor any internal transitions. The State is normally anonymous.\n\n10.3 DECISIONS\n\n10.3.1 Semantics\n\nA state diagram (and by derivation an activity diagram) expresses a decision when guard conditions are used to indicate different possible transitions that depend on Boolean conditions of the owning object. UML provides shorthand for showing decisions.\n\n10.3.2 Notation\n\nA decision may be shown by labeling multiple output transitions of an action with different guard conditions.\n\nThe icon provided for a decision is the traditional diamond shape, with one or more incoming arrows and with two or more outgoing arrows, each labeled by a distinct guard condition with no event trigger. All possible outcomes should appear on one of the outgoing transitions.\n\nNote that a chain of decisions may be part of a complex transition, but only the first segment in such a chain may contain an event trigger label. All segments may have guard expressions.\n\n10.3.3 Example\n\nFigure 54. Decision\n\n```plaintext\nCalculate total cost\n\n[cost < $50] Charge customer’s account\n[cost ≥ $50] Get authorization\n```\n10.3.4 Mapping\n\nA decision symbol maps into a Pseudostate of kind *branch*. Each label on an outgoing arrow maps into a Guard on the corresponding Transition leaving the Pseudostate.\n\n10.4 SWIMLANES\n\n10.4.1 Semantics\n\nActions may be organized into *swimlanes*. Swimlanes are a kind of package for organizing responsibility for activities within a class. They often correspond to organizational units in a business model.\n\n10.4.2 Notation\n\nAn activity diagram may be divided visually into “swimlanes” each separated from neighboring swimlanes by vertical solid lines on both sides. Each swimlane represents responsibility for part of the overall activity, and may eventually be implemented by one or more objects. The relative ordering of the swimlanes has no semantic significance but might indicate some affinity. Each action is assigned to one swimlane. Transitions may cross lanes; there is no significance to the routing of a transition path.\n10.4.3 Example\n\nFigure 55. Swimlanes in activity diagram\n\n10.4.4 Mapping\n\nA swimlane maps into a Partition of the States in the ActivityModel. A state symbol in a swimlane causes the corresponding State to belong to the corresponding Partition.\n10.5 ACTION-OBJECT FLOW RELATIONSHIPS\n\n10.5.1 Semantics\n\nActivities operate by and on objects. Two kinds of relationships can be shown: The kinds of objects that have primary responsibility for performing an action and the other objects whose values are used or determined by the action. These are modeled as messages sent between the object owning the activity model and the objects that are input or output by the actions in the model.\n\n10.5.2 Notation\n\n**Object responsible for an action.** The object responsible for performing an action can be shown by drawing a lifeline and placing actions on lifelines. Each lifeline represents a distinct object. There may be multiple lifelines for different objects of the same or different kinds. If this approach is chosen, usually a sequence diagram should be used. See Section 7.2. If an object lifeline is not shown, then some object within the swimlane package is responsible for the action but the object is not shown. Multiple actions within a single swimlane can be handled by the same or different objects.\n\n**Object flow.** Objects that are input to or output by an action may be shown as object symbols. A dashed arrow is drawn from an action outgoing transition to an output object, and a dashed arrow is drawn from an input object to an incoming arrow of an action. The same object may be (and usually is) the output of one action and the input of one or more subsequent actions.\n\nThe control flow (solid) arrows may be omitted when the object flow (dashed) arrows supply a redundant constraint. In other words, when an action produces an output that is input by a subsequent action, that object flow relationship implies a control constraint.\n\n**Object in state.** Frequently the same object is manipulated by a number of successive activities. It is possible to show the arrows to and from all of the relevant activities. For greater clarity, however, the object may be displayed multiple times on a diagram, each appearance denoting a different point during its life. To distinguish the various appearances of the same object, the state of the object at each point may be placed in brackets and appended to the name of the object, for example, PurchaseOrder[approved]. This notation may also be used in collaboration diagrams.\n10.5.3 Example\n\nFigure 56. Actions and object flow\n\n10.5.4 Mapping\n\nAn object flow symbol maps into an ObjectFlowState whose incoming and outgoing Transitions correspond to the incoming and outgoing arrows. The Transitions have no attachments. The class name and (optional) state name of the object flow symbol map into a Class or a ClassifierInState with the given name(s).\n10.6 Control Icons\n\nThe following icons provide explicit symbols for certain kinds of information that can be specified on transitions. These icons are not necessary for constructing activity diagrams but many users prefer the added impact that they provide.\n\n10.6.1 Stereotypes\n\nSignal receipt. The receipt of a signal may be shown as a concave pentagon that looks like a rectangle with a triangular notch in its side (either side). The signature of the signal is shown inside the symbol. A unlabeled transition arrow is drawn from the previous action state to the pentagon and another unlabeled transition arrow is drawn from the pentagon to the next action state. This symbol replaces the event label on the transition. A dashed arrow may be drawn from an object symbol to the notch on the pentagon to show the sender of the signal; this is optional.\n\nSignal sending. The sending of a signal may be shown as a convex pentagon that looks like a rectangle with a triangular point on one side (either side). The signature of the signal is shown inside the symbol. A unlabeled transition arrow is drawn from the previous action state to the pentagon and another unlabeled transition arrow is drawn from the pentagon to the next action state. This symbol replaces the send-signal label on the transition. A dashed arrow may be drawn from the point on the pentagon to an object symbol to show the receiver of the signal; this is optional.\n\nFigure 57. Symbols for signal receipt and sending\n\n```\n+-----------------+ +-----------------+\n| Turn on | → | coffeePot |\n| Machine | | |\n| | | |\n| turnOn | | |\n| Brew coffee | | |\n| light goes out | ← | |\n| Pour Coffee | | |\n```\n\nDeferred events. A frequent situation is when an event that occurs must be “deferred” for later use while some other activity is underway. (Normally an event that is not handled immediately is lost.) This may be thought of as having an internal transition that handles the event and places it on an internal queue until it is needed or until it is discarded. Each state or activity specifies a set of events that are deferred if they occur during the state or activity. If an event is not included in the set of deferred events for a state, then it is discarded from the queue even if it has already occurred. If a transition depends on an event, the transition fires immediately if the event is already on the internal queue. If several transitions are possible, the leading event in the queue takes precedence.\n\nA deferred event is shown by listing it within the state followed by a slash and the special operation defer. If the event occurs, it is saved and it recurs when the object transitions to another state, where it may be deferred again. When the object reaches a state in which the event is not deferred, it must be accepted or lost. The indication may be placed on a composite state, in which case it remains deferred throughout the composite state.\n\nWhen used in conjunction with an action state, a deferred event that occurs during the action state is deferred until the action is completed, when it may trigger a transition. This means that the transition will occur correctly regardless of the relative order of the event and the action completion.\n\nFigure 58. Deferred event\n10.6.2 Mapping\n\nAn input event symbol maps into an event trigger on the Transition between the States corresponding to the connected state symbols.\n\nAn output event symbol maps into a RaiseAction on the Transition between the States corresponding to the connected state symbols.\n\nAn input event symbol whose successor is a join symbol maps into an event trigger on a Transition to an implicit dummy State; the outgoing Transition from the dummy State enters the join Pseudostate.\n\nA deferred event attached to a state maps into a `deferredEvent` association from the State to the Event.\n11. IMPLEMENTATION DIAGRAMS\n\nImplementation diagrams show aspects of implementation, including source code structure and runtime implementation structure. They come in two forms: component diagrams show the structure of the code itself and deployment diagrams show the structure of the run-time system.\n\n11.1 COMPONENT DIAGRAMS\n\n11.1.1 Semantics\n\nA component diagram shows the dependencies among software components, including source code components, binary code components, and executable components. A software module may be represented as a component type. Some components exist at compile time, some exist at link time, and some exist at run time; some exist at more than one time. A compile-only component is one that is only meaningful at compile time; the run-time component in this case would be an executable program.\n\nA component diagram has only a type form, not an instance form. To show component instances, use a deployment diagram (possibly a degenerate one without nodes).\n\n11.1.2 Notation\n\nA component diagram is a graph of components connected by dependency relationships. Components may also be connected to components by physical containment representing composition relationships.\n\nA diagram containing component types and node types may be used to show compiler dependencies, which are shown as dashed arrows (dependencies) from a client component to a supplier component that it depends on in some way. The kinds of dependencies are language-specific and may be shown as stereotypes of the dependencies.\n\nThe diagram may also be used to show interfaces and calling dependencies among components, using dashed arrows from components to interfaces on other components.\n11.1.3 Example\n\nFigure 59. Component diagram\n\n11.1.4 Mapping\n\nA component diagram maps to a static model whose elements include Components.\n\n11.2 DEPLOYMENT DIAGRAMS\n\n11.2.1 Semantics\n\nDeployment diagrams show the configuration of run-time processing elements and the software components, processes, and objects that live on them. Software component instances represent run-time manifestations of code units. Components that do not exist as run-time entities (because they have been compiled away) do not appear on these diagrams; they should be shown on component diagrams.\n11.2.2 Notation\n\nA deployment diagram is a graph of nodes connected by communication associations. Nodes may contain component instances; this indicates that the component lives or runs on the node. Components may contain objects; this indicates that the object is part of the component. Components are connected to other components by dashed-arrow dependencies (possibly through interfaces). This indicates that one component uses the services of another component; a stereotype may be used to indicate the precise dependency if needed.\n\nThe deployment type diagram may also be used to show which components may run on which nodes, by using dashed arrows with the stereotype «supports».\n\nMigration of components from node to node or objects from component to component may be shown using the «becomes» stereotype of the dependency relationship. In this case the component or object is resident on its node or component only part of the entire time.\n\nNote that a process is just a special kind of object (see Active Object).\n\n11.2.3 Example\n\nFigure 60. Nodes\n11.2.4 Mapping\n\nA deployment diagram maps to a static model whose elements include Nodes. It is not particularly distinguished in the model.\n\n11.3 NODES\n\n11.3.1 Semantics\n\nA node is a run-time physical object that represents a processing resource, generally having at least a memory and often processing capability as well. Nodes include computing devices but also human resources or mechanical processing resources. Nodes may be represented as type and as instances. Run time computational instances, both objects and component instances, may reside on node instances.\n\n11.3.2 Notation\n\nA node is shown as a figure that looks like a 3-dimensional view of a cube.\n\nA node type has a type name:\n\n\\[ \\text{node-type} \\]\n\nA node instance has a name and a type name. The node may have an underlined name string in it or below it. The name string has the syntax:\n\n\\[ \\text{name } \\text{'' node-type} \\]\n\nThe name is the name of the individual node (if any). The node-type says what kind of a node it is. Either or both elements are optional.\n\nDashed-arrow dependency arrows show the capability of a node type to support a component type. A stereotype may be used to state the precise kind of dependency.\n\nComponent instances and objects may be contained within node instance symbols. This indicates that the items reside on the node instances. Containment may also be shown by aggregation or composition association paths.\n\nNodes may be connected by associations to other nodes. An association between nodes indicates a communication path between the nodes. The association may have a stereotype to indicate the nature of the communication path (for example, the kind of channel or network).\n11.3.3 Example\n\nThis example shows two nodes containing an object (cluster) that migrates from one node to another and also an object that remains in place.\n\nFigure 61. Use of nodes to hold objects\n\n11.3.4 Mapping\n\nA node maps to a «node» stereotype of a Class or Object. The nesting of symbols within the node symbol maps into a composition association between a node class and constituent classes or a composition link between a node object and constituent objects.\n\n11.4 COMPONENTS\n\n11.4.1 Semantics\n\nA component type represents a distributable piece of implementation of a system, including software code (source, binary, or executable) but also including business documents, etc., in a human system. Components may be used to show dependencies, such as compiler and run-time dependencies or information dependencies in a human organization. A component instance represents a run-\ntime implementation unit and may be used to show implementation units that have identity at run\ntime, including their location on nodes.\n\n### 11.4.2 Notation\n\nA component is shown as a rectangle with two small rectangles protruding from its side.\n\nA component type has a type name:\n\n\\[ component-type \\]\n\nA component instance has a name and a type. The name of the component and its type may be\nshown as an underlined string either within the component symbol or above or below it, with the\nsyntax:\n\n\\[ component-name \\::\\:: component-type \\]\n\nA property may be used to indicate the life-cycle stage that the component describes (source, binary,\nexecutable, or more than one of those). Components (including programs, DLLs, run-time linkable\nimages, etc.) may be located on nodes.\n\n### 11.4.3 Example\n\nThe example shows a component with interfaces and also a component that contains objects at run\ntime.\n\nFigure 62. Component\n\n[Diagram of components and interfaces]\n\n- **Dictionary**\n - spell-check\n - synonyms\n\n- **mymailer**: **Mailer**\n - Mailbox\n - RoutingList\nImplementation Diagrams\n\n11.4.4 Mapping\n\nA component symbol maps into a «component» stereotype of a Class or an Object. Graphical nesting of other symbols maps into composition association of the Component to Classes or Objects in it.\n\nInterface circles attached to the component symbol by solid lines map into supports Dependencies to Interfaces.\n\n11.5 LOCATION OF COMPONENTS AND OBJECTS WITHIN OBJECTS\n\n11.5.1 Semantics\n\nInstances may be located within other instances. For example, objects may live in processes that live in components that live on nodes. In more complicated situations processes may migrate from node to node, so a process may live in many nodes and deal with many components over time.\n\n11.5.2 Notation\n\nThe location of an instance (including objects, component instances, and node instances) within another instance may be shown by physical nesting. Containment may also be shown by aggregation or composition association paths. Alternately, an instance may have a property tag “location” whose value is the name of the containing instance.\n\nIf an object moves during an interaction, then it may be as two or more occurrences with a “becomes” dependency between the occurrences. The dependency may have a time property attached to it to show the time when the object moves. Each occurrence represents the object during a period of time. Messages should be directed to the correct occurrence of the object.\n\n11.5.3 Example\n\nSee the other diagrams in this section for examples of objects and components located on nodes as well as migration.\n\n11.5.4 Mapping\n\nPhysical nesting of symbols maps into composition association from the Element corresponding to the outer symbol to the Elements corresponding to the contents.\nIndex\n\nA\naction state 123\naction, special 105\naction-clause 111\nactivation 84\nactive object 96\nactivity diagram 121\nactor 77\naggregation 54\nassociation 50\nassociation class 51, 59\nassociation name 50\nassociation role 52\nattribute 29\n\nB\nbackground information 4\nbinary association 50\nbind 71\nbound template 40\n\nC\ncall event 109\nclass 23\nclass diagram 22\nclass pathname 43\nclassifier 23\ncollaboration 88, 92\ncollaboration diagram 88, 89\ncomment 16\ncommunicates 78\ncomplex transition 113\ncomponent 136\ncomponent diagram 132\ncomposite object 48\ncomposite state 104\ncomposition 62\nconcurrent substate 107\nconstraint 16\ncontext 89\ncreation (of an object) 102\n\ndefinition 124\ndeferred event 130\ndependency 71\ndeployment diagram 133\nderived element 73\ndesign pattern 90\ndestination state 113\ndestruction (of an object) 102\ndiscriminator 67\ndisjoint substate 107\ndo 105\n\nevent 108\nexit action 105\nexpression 8\nextends (a use case) 78\nextensibility mechanism 18, 20\nextension point 77\n\nF\nfinal state 107\n\nG\ngeneralization 67\ngeneralization constraints 68\ngraphic symbols 3\nIndex\n\ngraphs 3\nguard-condition 111\n\nH\n\nhistory state 114\nhyperlinks 4\n\nI\n\nimporting packages 44\ninitial state 107\ninteraction 93\ninteraction diagram 80\ninterface 36\ninternal activity 105\ninternal transition 120\ninvisible links 4\n\nK\n\nkeyword 8\n\nL\n\nlabel 7\nlink 65\nlist compartment 26\nlocation of object 138\n\nM\n\nmessage (in a sequence diagram) 85\nmessage flow 98\nmetaclass 43\nmultiobject 95\nMultiplicity 56\n\nN\n\nname 6\nname compartment 25\nn-ary association 61\nnavigability 53\nnavigation expression 9\nnested state machine 105\nnode 135\nnote 10\n\nO\n\nobject 46, 94\nobject diagram 23\nobject flow 127\nobject lifeline 83\nobject state 127\noperation 32\nor-association 51\noverview 1\n\nP\n\npackage 13\nparameterized class 38\nparticipates (in a use case) 78\npathname 43\npaths 4\npattern 90\nprogramming-language type 8\nproperty string 18\n\nQ\n\nqualifier 58\n\nR\n\nrefinement 71\nrole (association) 52\nrolename 54\n\nS\n\nsend-clause 111\nsending message\nwithin state diagram 116\nsequence diagram 80\nsignal event 109\nsource state 113\nstate\ncomposite 104\nstatechart diagram 103\nstereotypes 20\nstring 5\nstubbed transition 115\nsubstate 106\nswimlane 125\nsynchronization bar 113\n\nT\ntagged value 18\ntemplate 38\ntime event 109\ntiming mark 87\ntiming mark (in state diagram) 112\ntrace 71\ntransition 111\ntransition time 112\ntransition to nested state 114\ntype 35\n\nU\nusage dependency 71\nuse case 77\nuse case diagram 75\nuse case relationships 78\nuses (a use case) 78\nutility 42\n\nV\nvisibility 29"}}},{"rowIdx":172,"cells":{"id":{"kind":"string","value":"5c0c78f5d586c714c10563097ce84c24bc17a810"},"text":{"kind":"string","value":"Whole Team Thinking and Success Factors in Large Scale Agile Development\nAn Exploratory Case Study\n\nTina Christin Syversen\n\nMaster of Science in Computer Science\nSubmission date: May 2016\nSupervisor: Torgeir Dingsøyr, IDI\n\nNorwegian University of Science and Technology\nDepartment of Computer and Information Science\nAbstract\n\nAgile software development has been the preferred method since it was introduced as a software development method in 2001. It was originally intended for small co-located teams but in later years it has experienced widespread acknowledgement also in large scale development projects. One thing that is not known is how to best achieve success in these kinds of projects.\n\nIn this thesis we have explored two different cases of large scale projects. Because of the complexity which arise in large scale projects it is difficult to know how they can be conducted in the best possible way. The number of people involved, the need for coordination, and locating the different teams are some of what complicates a large scale agile development project and it is therefore hard to know how to best achieve success when considering these new complexities. From the literature research we therefore found several possible success factors, and the factor whole team thinking became the focus. The reason for this is that there is a difference when working in a project with one team and a project with several teams which depend on each other. Whole team thinking is about all teams thinking in the same direction and having the same goals throughout the projects, e.g. having shared mental models across all teams involved. These factors were investigated in the two cases and it was discovered how they affected the different cases; Omega and Tellus.\n\nFrom the results we could see that whole team thinking was one of the factors holding the two projects together. This was noticeable when the teams in the project considered the fact that they were working together and not competing against each other. When the teams noticed how important it was to collaborate they were more helpful toward the other teams and they understood the whole project more than when they just thought about their own team and their own part of the project. When they did not consider the project they were more quick to blame the other teams and hinder the project’s progress.\n\n**Keywords:** Agile, large scale, multiteam system, shared mental models, success, whole team thinking.\nSammendrag\n\nSmidig utvikling har vært den foretrukne metoden siden den ble introdusert som en metode i programvareutvikling i 2001. Opprinnelig så var den tenkt for små samlokaliserte team, men i de senere år har det blitt mer og mer utbrett også i større prosjekter med flere team. Noe som har vært uvisst er å finne ut hvordan man kan oppnå like stor suksess i de store prosjektene som i de små.\n\nI denne studien har vi sett på to ulike stor-skala prosjekter. På grunn av kompleksiteten som oppstår i stor-skala prosjekter er det vanskelig å vite hvordan disse kan lykkes på best mulig måte. Antall personer involvert, behovet for koordinering og det å lokalisere alle teamene er noe av det som kompliserer stor-skala smidige prosjekter og som gjør det vanskelig å vite hvordan en kan oppnå suksess når en vurderer disse aspektene. Fra litteraturen har vi derfor funnet flere mulige suksessfaktorer, og vi har valgt å fokusere på ”whole team thinking”. Denne faktoren går ut på at alle team skal tenke i samme retning og ha de samme målene gjennom hele prosjektet, for eksempel ved å ha felles mentale modeller på tvers av alle teamene. Disse faktorene har blitt sett sammen med de to casene; Omega og Tellus, og hvordan de påvirket prosjektene.\n\nFra resultatene kan vi se at ”whole team thinking” var en av faktorene som holdt prosjektene samlet. Dette var spesielt merkbart når teamene ikke konkurrerte mot hverandre, men jobbet sammen. Når teamene så hvor viktig det var å samarbeide var de mer hjelpsomme med tanke på andre team og de forsto helheten i prosjektet og tenkte ikke bare på sin egen del av prosjektet. Når de ikke tenkte på helheten så var de raskere til å skyldse på hverandre når ting ikke fungerte og hindret fremgangen til prosjektet.\n\nNøkkelord: Smidig, stor-skala, multiteam systemer, felles mentale modeller, suksess, helhetlig tenkning\nPreface\n\nThis paper was written as the master thesis in my final year on the Master Program in Computer Science at the Norwegian University of Science and Technology, NTNU. My specialization has been on software systems, where I have learned much from the different courses taken over the years. Agile development has been interesting through these years and I have been able to use this knowledge in some of the project courses, and in my summer job for Avanade in 2015.\n\nThe reason for choosing the subject of success factors in large scale agile was because I felt there was possible to contribute something. This area is still relatively new and therefore it is exciting to research something not many else have had the possibility of discovering yet.\n\nThis author would like to thank the supervisor of this paper, Torgeir Dingsøyr. With his help I was able to investigate actual cases, and without his support and knowledge on this subject this thesis would not be possible. There is also necessary to thank some other students who have also contributed. The thesis of Espen Andreassen was helpful throughout this project because of the knowledge of the subject and Omega case, and the observations of Aravindhan Yogarajah was helpful in the investigation of the Tellus case. The work with this thesis is related to the Agile 2.0 project funded by the Research council of Norway through grant 236759, and supported by the companies Kantega, Kongsberg Defence & Aerospace, Sopra Steria, and Sticos.\n\nTrondheim, May 31, 2016\n\nTina Christin Syversen\n# Table of Contents\n\nAbstract i \nSammendrag iii \nPreface v \nTable of Contents ix \nList of Tables xii \nList of Figures xiii \nAbbreviations xiv\n\n## 1 Introduction\n1.1 Motivation .................................................. 1 \n1.2 Problem Description and Background ............................... 2 \n1.3 Scope and Limitations ........................................ 3 \n1.4 Contribution .................................................. 4 \n1.5 Target Audience .............................................. 4 \n1.6 Report Outline ............................................... 5\n\n## 2 Theory\n2.1 Agile Software Development ..................................... 7 \n2.1.1 Agile Methods ............................................ 7 \n2.1.2 Team Performance ......................................... 12 \n2.1.3 Research on Agile ......................................... 14 \n2.2 Large Scale Projects .......................................... 15 \n2.2.1 Large Scale Agile ......................................... 15 \n2.2.2 Example: Spotify .......................................... 17 \n2.2.3 Multiple Teams ............................................ 18 \n2.2.4 Co-Located vs Distributed ................................ 19\n### 2.2.5 Frameworks and Scaling Methods\n\n---\n\n### 2.3 Success Factors\n\n- **2.3.1 Introduction**\n- **2.3.2 Customer Collaboration**\n- **2.3.3 Agile Software Engineering Techniques and Agile Evangelist**\n- **2.3.4 Responding to Change**\n- **2.3.5 The Team**\n- **2.3.6 Leadership**\n- **2.3.7 Bridgehead**\n- **2.3.8 Co-Location**\n- **2.3.9 Product Owner**\n- **2.3.10 Whole Team Thinking**\n\n---\n\n### 2.4 Whole Team Thinking and Shared Mental Models\n\n- **2.4.1 Shared Mental Models Theory**\n- **2.4.2 Agile Practices and Shared Mental Models Theory**\n- **2.4.3 Why is Whole Team Thinking Important?**\n\n---\n\n### 3 Method\n\n- **3.1 Literature Review**\n - **3.1.1 Parts and Objectives of a Literature Review**\n - **3.1.2 Selection Strategy and Research Question**\n- **3.2 Case Study**\n - **3.2.1 Data Collection**\n - **3.2.2 Data Analysis**\n\n---\n\n### 4 Results\n\n- **4.1 The Cases**\n - **4.1.1 Omega**\n - **4.1.2 Tellus**\n- **4.2 Success Factors**\n - **4.2.1 Agile Software Engineering Techniques and Agile Evangelist**\n - **4.2.2 Responding to Change**\n - **4.2.3 The Team**\n - **4.2.4 Leadership**\n - **4.2.5 Bridgehead**\n - **4.2.6 Co-Location**\n - **4.2.7 Product Owner**\n - **4.2.8 Whole Team Thinking**\n\n---\n\n### 5 Discussion\n\n- **5.1 Research Question and Success Factors**\n - **5.1.1 Research Question**\n - **5.1.2 Responding to Change**\n - **5.1.3 The Team**\n - **5.1.4 Leadership**\n - **5.1.5 Bridgehead**\n<table>\n<thead>\n<tr>\n<th>Page</th>\n<th>Section</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>5.1.6</td>\n<td>Co-Location</td>\n</tr>\n<tr>\n<td>5.1.7</td>\n<td>Product Owner</td>\n</tr>\n<tr>\n<td>5.1.8</td>\n<td>Whole Team Thinking</td>\n</tr>\n<tr>\n<td>5.1.9</td>\n<td>Summary</td>\n</tr>\n<tr>\n<td>5.2</td>\n<td>Evaluation of the Study</td>\n</tr>\n<tr>\n<td>5.2.1</td>\n<td>Research Process</td>\n</tr>\n<tr>\n<td>5.2.2</td>\n<td>Generalisation</td>\n</tr>\n<tr>\n<td>5.2.3</td>\n<td>Are the Cases Agile?</td>\n</tr>\n<tr>\n<td>6</td>\n<td>Conclusion</td>\n</tr>\n<tr>\n<td>6.1</td>\n<td>Research Question</td>\n</tr>\n<tr>\n<td>6.2</td>\n<td>Implications for Practice</td>\n</tr>\n<tr>\n<td>7</td>\n<td>Future Work</td>\n</tr>\n<tr>\n<td>7.1</td>\n<td>Suggestions for Future Research</td>\n</tr>\n<tr>\n<td>A</td>\n<td>Reasoning for Success Factors</td>\n</tr>\n<tr>\n<td>A.1</td>\n<td>Overview of Articles for each Success Factor</td>\n</tr>\n<tr>\n<td>B</td>\n<td>Observation Template</td>\n</tr>\n<tr>\n<td>B.1</td>\n<td>The Template</td>\n</tr>\n<tr>\n<td>C</td>\n<td>Supporting Information</td>\n</tr>\n<tr>\n<td>C.1</td>\n<td>Agile Software Development</td>\n</tr>\n<tr>\n<td>C.1.1</td>\n<td>XP</td>\n</tr>\n<tr>\n<td>C.1.2</td>\n<td>Enterprise Agile</td>\n</tr>\n<tr>\n<td>D</td>\n<td>Success Factors not Discussed in the Thesis</td>\n</tr>\n<tr>\n<td>D.1</td>\n<td>Success Factors</td>\n</tr>\n<tr>\n<td>D.1.1</td>\n<td>Planning</td>\n</tr>\n<tr>\n<td>D.1.2</td>\n<td>Testing</td>\n</tr>\n<tr>\n<td>D.1.3</td>\n<td>Governance</td>\n</tr>\n<tr>\n<td>D.1.4</td>\n<td>Divide after You Conquer</td>\n</tr>\n<tr>\n<td>D.1.5</td>\n<td>Continuous Integration</td>\n</tr>\n</tbody>\n</table>\nList of Tables\n\n<table>\n<thead>\n<tr>\n<th>Table</th>\n<th>Title</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2.1</td>\n<td>The Different Scrum Processes</td>\n<td>11</td>\n</tr>\n<tr>\n<td>2.2</td>\n<td>The Different Scrum Roles</td>\n<td>11</td>\n</tr>\n<tr>\n<td>2.3</td>\n<td>Summary of Distribution Between the Teamwork Components</td>\n<td>13</td>\n</tr>\n<tr>\n<td>2.4</td>\n<td>The Five Scaling Cases by Scheerer and Bick</td>\n<td>23</td>\n</tr>\n<tr>\n<td>2.5</td>\n<td>Success Factors in Small and Large Scale Agile</td>\n<td>25</td>\n</tr>\n<tr>\n<td>2.6</td>\n<td>Strode’s Implicit Coordination Factors</td>\n<td>37</td>\n</tr>\n<tr>\n<td>3.1</td>\n<td>Objectives of a Literature Review</td>\n<td>40</td>\n</tr>\n<tr>\n<td>3.2</td>\n<td>Search Words Used for this Thesis</td>\n<td>41</td>\n</tr>\n<tr>\n<td>3.3</td>\n<td>Databases Used for this Thesis</td>\n<td>41</td>\n</tr>\n<tr>\n<td>3.4</td>\n<td>Taxonomy of Scale by Dingsøyr et al.</td>\n<td>43</td>\n</tr>\n<tr>\n<td>3.5</td>\n<td>The Researchers Interpretation of the Principles of Klein and Myers</td>\n<td>45</td>\n</tr>\n<tr>\n<td>4.1</td>\n<td>An Overview of the Cases</td>\n<td>49</td>\n</tr>\n<tr>\n<td>4.2</td>\n<td>The Different Arenas in Tellus</td>\n<td>55</td>\n</tr>\n<tr>\n<td>4.3</td>\n<td>The Different Arenas in Omega</td>\n<td>56</td>\n</tr>\n<tr>\n<td>5.1</td>\n<td>Success Factors Applicable Found in the Cases: Y= found, S= found in</td>\n<td>69</td>\n</tr>\n<tr>\n<td></td>\n<td>some degree, NF = not found</td>\n<td></td>\n</tr>\n<tr>\n<td>5.2</td>\n<td>Strode’s Implicit Coordination Factors for Omega</td>\n<td>70</td>\n</tr>\n<tr>\n<td>5.3</td>\n<td>Strode’s Implicit Coordination Factors for Tellus</td>\n<td>70</td>\n</tr>\n<tr>\n<td>5.4</td>\n<td>The Researcher’s Use of the Principles of Klein and Myers</td>\n<td>72</td>\n</tr>\n<tr>\n<td>5.5</td>\n<td>Criterias to be Agile</td>\n<td>74</td>\n</tr>\n<tr>\n<td>6.1</td>\n<td>Success Factors Applicable in all Large Scale Agile Projects: A = always applicable, M = maybe always applicable, NF = not found in the cases</td>\n<td>76</td>\n</tr>\n<tr>\n<td>6.2</td>\n<td>Success Factors Whole Team Thinking have been seen in Conjunction</td>\n<td>76</td>\n</tr>\n<tr>\n<td></td>\n<td>with: Y= yes, N= no, NK = not known</td>\n<td></td>\n</tr>\n<tr>\n<td>7.1</td>\n<td>Revised Research Agenda for Large Scale Agile by Dingsøyr and Moe</td>\n<td>80</td>\n</tr>\n</tbody>\n</table>\nA.1 Customer Collaboration Articles ................................................. b\nA.2 Agile Software Engineering and Agile Evangelist Articles .............. c\nA.3 Responding to Change Articles .................................................. c\nA.4 The Team Articles ...................................................................... d\nA.5 Leadership Articles ...................................................................... e\nA.6 Planning Articles .......................................................................... e\nA.7 Testing Articles ........................................................................... f\nA.8 Governance Articles ...................................................................... g\nA.9 Divide after You Conquer Articles ................................................ g\nA.10 Continuous Integration Articles ................................................... h\nA.11 Bridgehead Articles ...................................................................... i\nA.12 Co-Location Articles ................................................................... j\nA.13 Product Owner Articles .............................................................. k\nA.14 Whole Team Thinking Articles ................................................... l\n## List of Figures\n\n2.1 The Waterfall Model .................................................. 9\n2.2 The Scrum Cycle .......................................................... 10\n2.3 Salas Big Five ............................................................. 13\n2.4 From Small to Large Scale ............................................. 16\n2.5 An Overview of Scaling at Spotify .................................... 18\n2.6 LeSS Framework up to Ten Teams .................................... 21\n2.7 DAD Scaling Factors .................................................... 22\n2.8 Components of Coordination Effectiveness from Strode et al. ... 37\n\n4.1 An Overview of the Open Work Area at Omega ..................... 50\n4.2 An Overview of Tellus .................................................... 51\n\nC.1 Extreme Programming Overview ...................................... r\nAbbreviations\n\nNTNU = Norwegian university of science and technology\nIT = information technology\nQA = quality assurance\nUI = user interface\nUX = user experience\nXP = extreme programming\nIS = information systems\nPO = product owner\nCPO = chief product owner\nAPO = area product owner\nPPO = proxy product owner\nEPO = epic product owner\nFPO = feature product owner\nSM = scrum master\nTDD = test driven development\nCOP = communities of practice\nMTS = multiteam system\nLeSS = large scale agile (framework)\nSAFe = scaled agile framework\nDAD = disciplined agile delivery\nChapter 1\n\nIntroduction\n\nThe first chapter is a short introduction of the motivation behind this thesis together with the problem description and background. The scope with its limitations, contribution and the target audience will also be presented. In the end there will be a brief report outline which explains what to expect in the forthcoming chapters.\n\n1.1 Motivation\n\nAgile software development methodologies have been widely accepted since the introduction of the agile manifesto in 2001 [1]. This transformation witnessed the introduction of several software methods, tools and techniques. Agile methods were said to:\n\n\"best suit co-located teams of about 50 people or fewer who have easy access to user and business experts and are developing projects that are not life critical\" [2]\n\nEven so companies have started applying agile practices to large scale projects.\n\nWhen applying agile in large scale projects it is necessary to sort out requirements with potential dependencies across the different teams. This creates new forms of coordination mechanisms that do not exist in small scale [3]. At XP2013 and XP2014 Dingsøyr and Moe conducted a workshop about the principles of large scale agile development which resulted in a research agenda in 2013, and a revised research agenda in 2014. One of the topics with the highest priority included variability factors in scaling. This involved identifying what factors are important in large projects that influence the development process [2].\n\nToday there are several projects which are working agile in large scale. One example of this is Spotify [4]. At Spotify they have implemented a matrix structure and they change their way of working constantly to find the best solutions for their business. SAP is another example of a company working in large scale [5]. What we do not know exactly is how\nthese companies can work agile in large scale and achieve success with their methodology.\n\nThe challenges which arise in large IT-projects are many. The number of people, dependencies and locations are just some of what needs to be considered. With so many new varying conditions it is difficult to discover how and why they can inhibit a project’s success. The teams should also communicate and coordinate with each other, which can be difficult because agile teams are supposed to be self-organizing [6]. This indicates that there is a difference when applying agile to large projects. This is an area where there is little information for those applying agile to large projects.\n\nThis master thesis has therefore examined the different factors improving the project success in large scale agile development. The focus has been on the factors and in which way these assist the project to success. Because of this we have studied some of the large organisations and projects which have implemented agile techniques, together with two cases that the researcher have been lucky enough to follow during the duration of this thesis.\n\nThe reason for choosing this subject is because little is known about it today. It is exciting exploring a field where much is still undiscovered and to hopefully contribute something to the cause. This thesis might not change much today, but it might bring a new outlook on large scale agile in the future.\n\n1.2 Problem Description and Background\n\nThere are today several different organizations and projects that benefits from agile practices, some of these are Spotify [4] and SAP AG [5]. Because of the benefits agile methodologies have proven to offer SAP AG, the world’s leading producer of enterprise software have transitioned from a waterfall-like process model to an agile development model [5].\n\nThe revised research agenda for large scale agile software development by Dingsøyr and Moe [2] had high priority on the topic of factors in scaling. After studying several lessons learned-articles it was clear that there were many different success factors that were applicable in both large and small scale agile. Misra et al. [7] and, Chow and Cao [8] have researched the potential success factors in small scale agile. These have therefore been compared with both the lessons learned-articles, and the cases involved in this thesis.\n\nThere is not much information on this topic in existing papers, which is probably why it was a high priority topic on the revised research agenda by Dingsøyr and Moe [2]. This is why the topic is highlighted in this thesis which focus on different success factors in large scale agile development projects.\n\nA project is usually a planned set of interrelated tasks to be executed over a fixed period and within certain costs and other limitations\\(^1\\), but in this thesis the project can also last\n\n\\(^1\\)http://www.businessdictionary.com/definition/project.html\nfor an unknown amount of time, e.g.: Spotify which is always improving to better fit the customers requirements. The purpose of this master thesis is:\n\n- To add to the body of knowledge on large scale agile project\n- To solve a problem by improving a large scale agile project\n- To find out what happens when regarding the factors in a large scale agile project\n- To find evidence to inform practice of how to best conduct a large scale agile project\n- To develop a greater understanding of people and their world in a large scale agile project\n- To contribute to other people’s well-being in a large scale agile project\n\nThe end product will therefore be a combination of these purposes [9].\n\nThis thesis will be an “in-depth study of a particular situation” [9] where we will focus on two different cases. In addition it will be ”an exploration of a topic, area, or field” with focus on the different factors in large scale agile, together with a more thorough investigation into large scale agile projects.\n\n### 1.3 Scope and Limitations\n\nThis thesis is about possible success factors and whole team thinking as a success factor in large scale agile development projects. The time limit on this master thesis has been twenty weeks. All of the work for this thesis has been completed during those weeks, in addition to some of the material being found and researched during the preliminary paper [10], which also focused on success factors and whole team thinking. The preliminary paper consisted in finding the research question and material for that, and is where the success factors were found. The preliminary paper were therefore more of a research study while this thesis only uses the information gathered there together with new information, and it is compared with the two cases; Omega and Tellus.\n\nBecause of the time constraints it was not possible to get more material from the two cases. With more time it might have been possible to conduct interviews in one or both of the cases, which could have shed more light on the research question and success factors. With more time it would have been possible to delve deeper into the cases, and maybe even follow other relevant cases. It could have been possible to ask more about how they are affected by the different factors, if they think about them at all. This was difficult because of the necessity for an ongoing or newly concluded project, preferably close by.\n\nSince this research field, large scale agile, was fairly new, there was not that much information on the subject, which is another reason of why it was chosen. The field had not been investigated thoroughly according to Dingsøyr and Moe [2] in a conference paper from XP2014, where variability factors in large scale agile development was proposed as\nChapter 1. Introduction\n\na future research field. This thesis therefore gives an overview over what has been found in other papers, both about agile development, large scale agile, and the different factors found in the different papers. This thesis is not about how to best scale an agile development project, but it is about the factors that can help large scale projects heavily influenced by the whole team thinking factor which will be explained later in this thesis.\n\nThe problems with large scale agile projects is the fact that an agile team is supposed to be self-organized [11]. In a project with several self-organized teams this would complicate the project, which implies that they can only be self-organized to a certain degree. The number of people involved increases the chances for dependencies and it is difficult for everyone involved in one project to not communicate and coordinate with each other. Spotify has over 30 teams across three cities [4]. The fact that they are too many to be placed in one location suggests the complexity of working in a large scale agile project.\n\nThe focus on this thesis is therefore on the possible success factors. These are found in other journals and lessons learned-articles, and compared with the two cases. We will discuss these factors individually and together with the factor whole team thinking which is the main focus. We will see how they affect the two cases both positively and negatively, and how they can help the projects to achieve success. We can therefore see the difference in how necessary they are, and how they affect the different projects. The scope for this thesis is therefore about what factors that need to be considered to achieve success in a large scale agile project, and how they can be used for the best results.\n\n1.4 Contribution\n\nThe contribution this thesis will provide is to the topic of success factors in large scale agile. After suggesting possible success factors we will try to display them in the two case studies and how they have affected these projects. We will compare the two different cases and see how each of them have solved the factors in their project. We will see which factors are applicable to both projects, and therefore factors which might be applicable to most projects and which factors depend on the case. In the end we will focus on the factor whole team thinking and see how this affects both the cases and the other factors found.\n\n1.5 Target Audience\n\nThe target audience for this thesis is primarily people interested in large scale agile projects. It is for those conducting large scale agile projects that are interested to know how they can best achieve success. This is relevant especially for the two cases followed and also for the supervisor and the Agile 2.0 project. This paper will be available through NTNU which indicates that other students can use it for inspiration either they write about agile or large scale agile development. For those who practice agile in large scale projects this thesis can help in understanding how to best conduct these types of projects by reading about the success factors and how they are implemented in the cases. For scientists in large scale agile\nhow the success factors influence the projects in both positive and negative is something that could be interesting regarding other research fields in the future.\n\n1.6 Report Outline\n\nChapter 1 Introduction:\nThis chapter is to give a brief overview of the thesis, this includes the motivation, background, scope, contribution and target audience.\n\nChapter 2 Theory:\nThe theory chapter brings a listing of agile software development and what lies in whole team thinking and shared mental models. Large scale is given an explanation and there is an overview over the different success factors found in different articles.\n\nChapter 3 Method:\nHere the literature review is carried out, with the selection strategy and research question. In addition this chapter contains how the data collection and analysis were performed and how thesis was completed.\n\nChapter 4 Results:\nThe results chapter holds the findings from the two cases. These are seen in context with the success factors from the theory chapter.\n\nChapter 5 Discussion:\nThe results are discussed further and the two cases are compared. The focus here will be on whole team thinking alone and together with the other factors. An evaluation of the study is also conducted.\n\nChapter 6 Conclusion:\nThis chapter includes the conclusion of this thesis in conjunction with the research question. This chapter also collects the loose threads.\n\nChapter 7 Future Work:\nIn this chapter suggestions for future work in large scale agile development is given.\nChapter 2\n\nTheory\n\nThe theory chapter will present the relevant literature for this thesis. First we will briefly explain agile software development together with one of its methods. After this we will give an introduction to large scale agile before presenting the different success factors found, together with an explanation. In the end we will delve deeper into one of the factors and shared mental models.\n\n2.1 Agile Software Development\n\nIn this section we will introduce agile software development and discuss how it is different from the waterfall-model. We will introduce one of the methodologies scrum, before considering team performance in an agile project. In the end we will focus on earlier research on agile software development.\n\n2.1.1 Agile Methods\n\nIn the late 1990’s there were several methodologies that had started gaining increased public attention, each with a different combination of new and old ideas. What these had in common was the close collaboration of the development team and the business stakeholders. When seventeen software development practitioners gathered in 2001 they tried to find a common ground. From this the Agile Software Development Manifesto emerged, which was based on four values:\n\n- **Individuals and interactions** over processes and tools\n- **Working software** over comprehensive documentation\n- **Customer collaboration** over contract negotiation\n- **Responding to change** over following a plan\n\n---\n\n1 [https://www.agilealliance.org/agile101/what-is-agile/](https://www.agilealliance.org/agile101/what-is-agile/)\n2 [http://agilemanifesto.org/history.html](http://agilemanifesto.org/history.html)\n3 [http://agilemanifesto.org/](http://agilemanifesto.org/)\nWhile there is value in the items on the right, the left ones are valued more.\n\nAgile software development offers a professional approach to software development that encompasses human, organizational, and technical aspects of software development processes [12]. Agile software development is an umbrella term for a set of methods and practices based on the values and principles from the agile manifesto. The word \"agile\" by itself indicates that something is flexible and responsive, so agile methods implies its \"ability to survive in an atmosphere of constant change and emerge with success\" [8]. Agile methods are people-centric, recognizing the value of competent people and what their relationships bring to software development [13]. It focuses on providing high customer satisfaction and extensive documentation are of little value to the developers. The key point is that agile approaches plan features, not tasks, as the first priority because that is what the customers understand. Agile approaches recommend short iterations in the two-to-six weeks range. By having dynamic prioritization the customer can always reprioritize their features at the end of an iteration [14]. At the core of agile practices is the idea of self-organizing teams where the members work at a pace that sustain their creativity and productivity [1]. This implies that the team is responsible for the whole product or service, that they control the members’ task behaviour and have the authority to make decisions about task assignment and work methods [15].\n\nAgile methods are, according to Cohen, Lindvall and Costa [9], a reaction to the traditional ways of developing software, and acknowledge the \"need for an alternative to documentation driven, heavyweight software development processes\". It is the focus and values behind the agile methods that differentiate them from the traditional methods. The waterfall model, see figure 2.14, was a way of assessing and building for the users’ needs. The model starts with a complete analysis of user requirements, then engineers establishes a definitive and exhaustive set of features etc. which are all well-documented. Next phase is the design phase before the programmers implement the well-documented design and the system is tested and shipped. Problems with this model was the fact that users changed their minds and that requirements changed. The waterfall model therefore worked best when change rates were low. Other incremental and iterative techniques took the process behind waterfall and repeated it through the development lifecycle [9].\n\nAgility, ultimately, is about creating and responding to change. It is not the practices that they use that are new, but their recognition of people as the primary drivers of project success, coupled with an intense focus on effectiveness and maneuverability [14]. Agile approaches is often used in the development of web-based applications [16]. As an iterative and incremental method to software development, the agile method is implemented in a very interactive manner to make good quality software that answers the alternating needs of its users.\n\nAccording to Scott Ambler [6] there are five criterias that determine whether a team is agile or not. It is important to note that these are just suggestions and that different projects might require different methods. For example; some agile teams produces working soft-\n\n---\n\n4http://www.sharonencyclo.com/waterfall-model-sharon-encyclopaedia/\n2.1 Agile Software Development\n\nAgile software development has followed the general trend in product development organizations towards a team-based structure with the idea of self-organizing teams [17]. Teamwork has been found to be a key driver to successful software development and it provides a better solution to organizational problems. Agile team behaviour might affect the \"ability to make the necessary modifications in order to meet new challenges\" [17].\n\nIt is said that members of effective teams are aware of team functioning and of changes in the team environment. This team-based structure can be seen in several of the agile methodologies. According to a world-wide survey [18] with professional software developers completed by VersionOne in 2012 the two most widely used agile methods among professional software developers today are scrum and extreme programming (XP).\n\nFigure 2.1: The Waterfall Model\n\nware every two weeks, while others might not do this as often because of a more complex situation. The first criteria is that the agile team provides a value to their stakeholders at a regular basis. The second is the validation criteria. This implies that for agile teams it is necessary to do continuous developer regression testing and that the disciplined agile teams take a test driven development approach to validate their work. Active stakeholder participation is the third one. Here the importance of working closely with the stakeholders, ideally on a daily basis, is recommended. The fourth one is self-organization and that is the criteria that is the most challenging to fulfill. Agile teams are self-organizing, and disciplined agile teams work within an appropriate governance framework. The last and fifth criterion is improvement. The agile teams have to regularly reflect on, and disciplined teams should measure, how they work together, and then act to improve on their findings in a timely manner.\nChapter 2. Theory\n\nScrum\n\nIn 1996 scrum was defined as a process that \"accepts that the development process is unpredictable,\" and formalizing the \"do what it takes\" mentality [19]. A scrum is a team of eight individuals in rugby. Everyone in the pack acts together with everyone else to move the ball down the field. The entire team have one single focus, work closely together and has clear priorities [20]. The focus of scrum in software development is project leadership and requirements management [6].\n\nScrum projects are divided into iterations, also called sprints, which lasts for two-to-four weeks, see figure 2.2 for an overview of the scrum cycle. Each sprint consists of a sprint planning session, daily stand-up meetings, sprint demo and a sprint retrospective. In the sprint planning the product backlog, a list of prioritized items from the product owner, is discussed and items are taken from this and into the sprint backlog.\n\n\n\nThe daily stand-up meetings are held everyday, involves the whole team and is facilitated by the scrum master. There is usually three questions that is answered during these meetings [20]:\n\n- What have you done since last time?\n- Are there any obstacles in your way?\n- What will you do next?\n\nThese meetings usually last about 15-30 minutes and are not used to brainstorm ideas or solving the problems they have [20]. In the end of a sprint a demo will be held. Here the\n\n---\n\n\n6 [https://www.scrumalliance.org/why-scrum](https://www.scrumalliance.org/why-scrum)\nTable 2.1: The Different Scrum Processes\n\n<table>\n<thead>\n<tr>\n<th>Process</th>\n<th>What</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Product backlog</td>\n<td>An overview of the requirements requested by the customer/PO which is prioritized after each sprint</td>\n</tr>\n<tr>\n<td>Sprint</td>\n<td>An iteration which lasts between two-to-four weeks where there hopefully will be produced working software</td>\n</tr>\n<tr>\n<td>Sprint backlog</td>\n<td>Requirements at the top of the product backlog which are to be completed during the sprint</td>\n</tr>\n<tr>\n<td>Sprint planning</td>\n<td>Planning of the sprint where requirements are taken from the backlog, divided into tasks and is given a duration</td>\n</tr>\n<tr>\n<td>Daily stand-up</td>\n<td>A meeting every day at approximately the same time where everyone explains what they are doing</td>\n</tr>\n<tr>\n<td>Demo</td>\n<td>A presentation at the end of the sprint of the product to the customer/PO</td>\n</tr>\n<tr>\n<td>Retrospective</td>\n<td>A discussion of how the sprint was conducted with positive and negative items which focus on how to conduct the next sprint better</td>\n</tr>\n</tbody>\n</table>\n\ndifferent stakeholders usually meet and they are shown what the team have managed to produce during the sprint. After this there might be reprioritizing of the product backlog. In the end the team has a retrospective where they discuss how the sprint went, and how the next sprint can be conducted even better than the last. For an overview of the different artifacts in scrum see table 2.1.\n\nTable 2.2: The Different Scrum Roles\n\n<table>\n<thead>\n<tr>\n<th>Scrum roles</th>\n<th>Who</th>\n<th>What</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Product owner</td>\n<td>A person from the customer with an interest and knowledge in the product</td>\n<td>Manages customer requirements and communicates these to the team</td>\n</tr>\n<tr>\n<td>Scrum master</td>\n<td>One team member with leader responsibilities</td>\n<td>Facilitator between PO and team, and a team member</td>\n</tr>\n<tr>\n<td>Team</td>\n<td>Software engineers, architects, programmers, analysts, QA experts, testers, UI designers</td>\n<td>Responsible for developing the product</td>\n</tr>\n</tbody>\n</table>\n\nA scrum team consists mainly of three different roles. These are the: product owner, scrum master and team\\(^7\\). The product owner is responsible for managing customer requirements and communicating these to the team. The scrum master is the facilitator between the product owner and the team, and works to remove any impediments that are obstructing the team from achieving its sprint goals. The team is a small development team.\n\n\\(^7\\)http://scrummethodology.com/\nChapter 2. Theory\n\nresponsible for self-organizing to complete work, with a mix of software engineers, architects, programmers, analysts, QA experts, testers and UI designers. The team is normally not more than ten people. For an overview of the different roles see table 2.2.\n\n2.1.2 Team Performance\n\nA common definition of a team is:\n\n\"a small number of people with complementary skills who are committed to a common purpose, set of performance goals, and approach for which they hold themselves mutually accountable” [21]\n\nCollaborative work in teams can promise the potential of greater adaptability, productivity and creativeness as compared to individual work [17]. Teamwork is at the core of agile development [22]. In agile development it is necessary for a team to be adaptable because of the everchanging needs of the customer, and it has been found that a team’s adaptability is a key determinant of team effectiveness [23].\n\nTeams have the potential to provide complex, innovative, and comprehensive solutions to organizational problems [24]. There are several models available but it is important to distinguish between team performance and team effectiveness. Team performance accounts for the outcomes of the team’s actions regardless of how the team may have accomplished the task. Team effectiveness takes a more holistic perspective in considering both how the team completed their task and how the team interacted to achieve the team outcome. The important factors of teamwork found by Salas et al. [24] is the ones called the \"Big Five\", see figure 2.3. These core components of teamwork include team leadership, mutual performance monitoring, backup behaviour, adaptability and team orientation. These components have three coordinating mechanisms which are: shared mental models, closed loop communication and mutual trust.\n\nIn 2013 Dingsøyr and Lindsjørn [21] conducted eighteen focus group sessions to investigate what factors agile software practitioners perceive to influence effective teamwork. They chose to use the research-based Salas et al. model of the \"Big five\" as a basis for this research. The questions asked during the focus groups was: \"What fosters effective teamwork?\" and \"What hinders effective teamwork?”. In total there were 1183 items that were placed in the eight teamwork component groups, see table 2.3. As we can see from the table shared mental models was one of the components that received the most items on fostering team performance, together with closed-loop communication and mutual trust, all of which are the coordinating mechanisms of the model.\n\nThe components were clustered into three main groups after they were reviewed:\n\n1. Team leadership and closed loop communication\n2. Shared mental models, team orientation and mutual trust\n3. Mutual performance monitoring, backup behaviour and adaptability\n2.1 Agile Software Development\n\n\n\n**Figure 2.3**: Salas Big Five\n\n### Table 2.3: Summary of Distribution Between the Teamwork Components\n\n<table>\n<thead>\n<tr>\n<th>Team Component</th>\n<th>Foster</th>\n<th>Hinder</th>\n<th>Total</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Team leadership</td>\n<td>90</td>\n<td>139</td>\n<td>229</td>\n</tr>\n<tr>\n<td>Mutual performance monitoring</td>\n<td>49</td>\n<td>22</td>\n<td>71</td>\n</tr>\n<tr>\n<td>Backup behaviour</td>\n<td>44</td>\n<td>57</td>\n<td>101</td>\n</tr>\n<tr>\n<td>Adaptability</td>\n<td>46</td>\n<td>50</td>\n<td>96</td>\n</tr>\n<tr>\n<td>Team orientation</td>\n<td>91</td>\n<td>65</td>\n<td>156</td>\n</tr>\n<tr>\n<td>Shared mental models</td>\n<td>104</td>\n<td>59</td>\n<td>163</td>\n</tr>\n<tr>\n<td>Closed-loop communication</td>\n<td>97</td>\n<td>58</td>\n<td>155</td>\n</tr>\n<tr>\n<td>Mutual trust</td>\n<td>122</td>\n<td>90</td>\n<td>212</td>\n</tr>\n<tr>\n<td><strong>Sum</strong></td>\n<td><strong>643</strong></td>\n<td><strong>540</strong></td>\n<td><strong>1183</strong></td>\n</tr>\n</tbody>\n</table>\nChapter 2. Theory\n\nThe research confirms the fact that teamwork is of high relevance to agile software development teams. Agile teams are said to be self-managing, while the \"Big Five\" model is not particularly tailored for self-managing teams. Even though we can see that the model is applicable for the self-organizing teams in agile software development.\n\nIf we focus on shared mental models team leadership is influenced by this in how the team leader has a role in the creation, maintenance and accuracy of the team’s shared mental model. For mutual performance monitoring it is important with shared mental models because it provides teammates an understanding of what other team members are supposed to be doing. Shared mental models are necessary antecedents to effective backup behaviour because they form the foundation for decisions of when a team member must step in to provide backup, who should step in, and what assistance is necessary.\n\nAs we can see from figure 2.3 there are ten research propositions, where three of these come from shared mental models. These are:\n\n**P3:** Effective mutual performance monitoring will only occur in terms with adequate shared mental models and a climate of trust.\n\n**P6:** Effective backup behaviour requires the existence of adequate shared mental models and mutual performance monitoring.\n\n**P8:** Effective availability requires the existence of adequate shared mental models and effective engagement in mutual performance monitoring and backup behaviour.\n\nThese propositions between the variables represents the interrelationships of the \"Big Five\", and as we can see the \"Big Five\" cannot function without their coordinating mechanisms, which include shared mental models.\n\n### 2.1.3 Research on Agile\n\nIn 2008 Dybå and Dingsøyr [25] published a systematic review of empirical studies on agile software development. The objective of the study was:\n\n1. What is currently known about the benefits and limitations of agile software development?\n\n2. What is the strength in support of these findings?\n\n3. What are the implications of these studies for the software industry and research community?\n\nThey identified 36 empirical studies on agile software development where thirty-three were primary studies, and three secondary studies. Most of the studies reviewed that investigated agile projects dealt with employees that were new to agile development and they were also published in conferences. According to Dybå and Dingsøyr [25] the research published before 2005 revealed a lack of theoretical and methodological rigor.\nSome of the benefits reported by the studies from Dybå and Dingsøyr [25] was customer collaboration, work processes for handling defects, learning in pair programming, thinking ahead of management, focusing on current work for engineers and estimation. One of the recurring themes found was human and social factors and how these factors affect agile development methods. One problem with the studies was that the strength of evidence were low, which made it difficult to offer specific advice to the industry.\n\nIn 2012 Dingsøyr et al. [1] did a literature search on the ISI Web of Science where they identified 1551 research papers on agile software development published from 2001 to 2010. The majority of the articles originated in the US, Canada, and Western Europe, but there were 63 countries in total on all continents which had had agile development as a research theme. Most of the articles published came from conferences, most notably the International Conference on Agile Software Development.\n\nNerur and Balijepally [13] revealed in 2007 that the progression of ideas in agile software development were remarkably similar to conceptual pattern shifts in software design. They looked at agile software teams as holographic organizations. Everything which is in the whole hologram can be accessed through any of its parts since each one is a reflection of the whole. Agile philosophy facilitates their formation of holistic teams through a culture that encourages the changing of roles and jobs based on independence. The team’s skills enable it to function even when some members are unable to perform [13]. This can be explained by the fact that the agile teams are self-organized and therefore are less dependent on one single person.\n\n2.2 Large Scale Projects\n\nIn this section we will introduce the concept of large scale projects before delving deeper into Spotify, which is an example of a large scale agile project. After this we will discuss multiple teams working together and how to locate the teams in a large scale project. In the end we will discuss different frameworks and different ways to scale a large agile project.\n\n2.2.1 Large Scale Agile\n\nThe success and wide use of agile software development has inspired use in new domains and companies have been increasingly applying agile to large scale projects [26], see figure 2.4 [27]. The discussion on the ability of agile practices to scale to larger software development efforts has been widely debated in recent years [28]. It is still important to remember that agile is not a tool-based technique that can easily be rolled out across large organizations, it is value based and needs buy-in [29].\n\nWhen describing agile development in everything from large teams to large multiteam projects that make use of principles of agile development in a whole organization, the term \"large scale agile development\" has been used [26]. The definition given by Dingsøyr et al. [26] is the following: \"agile development efforts with more than two teams\". In addition they define very large scale as \"agile development efforts with more than ten teams\".\nFigure 2.4: From Small to Large Scale\n2.2 Large Scale Projects\n\nWith these definitions we exclude agile methods applied in large organizations, also called \"enterprise agile\". For more information about this see appendix C.1.2.\n\nWhen large teams are supposed to produce software functionality quickly, the agile methods must scale to meet the task [30]. There has been said to be eight scaling factors for agile [16; 6]. These are: team size, geographical distribution, regulatory compliance, organizational complexity, technical complexity, organizational distribution, domain complexity and enterprise discipline. These scaling factors are ranges and all will not be applicable to any given project [16; 6]. According to Saeeda et al. [16] there are two terms when discussing scalability of agile. These are \"scaling out\" and \"scaling up\". Scaling up is concerned with the use of agile methods for developing large software systems that cannot be developed by smaller teams. Scaling out is more concerned with how agile methods can be introduced across a large size project with many years of software experience [16].\n\nWhen deciding how to divide the teams in large scale agile it is common to divide into feature teams or component teams [31]. When using feature teams the teams are grouped into areas that are customer- and not architecture-centric. Component teams divide their work based upon the system architecture. When choosing which way to divide the teams the customer should be in focus. The reason for this is the fact that when choosing component teams the requirements and backlogs are more technical of nature, this indicates that the product owner should be technically savvy or the team will have to translate technical requirements into needs for the product owner [31]. The mix of feature and component teams is one of the reasons for occurring inter-team dependencies [32].\n\n2.2.2 Example: Spotify\n\nSpotify is a good example of scaling agile, see figure 2.5 [4]. In an article from 2012 the scaling at Spotify is explained by Kniberg and Ivarsson [4]. It is important to note that Spotify is a company which is evolving fast and this article by Kniberg and Ivarsson is just a snapshot of how Spotify worked at the time of the article, and there have most likely been several changes since then.\n\nAt Spotify a squad is the same as a scrum team and it is designed to feel like a mini-startup. The squad has a long-term mission which can be e.g.: building and improving the android client. Because they are on a long-term mission they become experts in that area. The squads have a workspace which includes a desk area, lounge area and a personal \"huddle\" room. Most of the walls are whiteboards. Each squad is encouraged to spend about ten percent of their time on \"hack days\" where they can do whatever they want. They have a product owner which is responsible for prioritizing the work conducted by the team, and the product owners of different squads collaborate with each other.\n\nA tribe is a collection of squads that work in related areas, like the music player. The tribes have a tribe lead and they are physically in the same office. They are based on the concept of the \"Dunbar number\" which implies that people cannot maintain a social relationship with more than about one hundred people. This is because of the increase in restrictive rules, bureaucracy and other things that could get in the way. The tribes hold\nregular gatherings which is an informal get-together.\n\nDependencies is helped by the squads regularly being asked which squads they depend on and if these dependencies are blocking or slowing them down. Scrum of scrums happen only on demand because the squads are fairly independent. Chapters and guilds are used to glue the company together. A chapter is a family of people which have similar skills and are working in the same general competency area within the same tribe. They meet regularly but are not necessarily evenly distributed across the squads. The guild is referred to as more of a “community of interest” where those who want can share knowledge, tools, code and practices. Guilds cut across the whole organization.\n\nAnyone is allowed to edit the system, but to make sure that someone focuses on the integrity of the whole system they have the role ”system owner”. All systems have one or two system owners, when there are two; one has a developer perspective and the other an operations perspective. This person is not responsible for doing the job, but for making sure it is implemented. Normally this person is a squad member or chapter lead with other day-to-day responsibilities.\n\n2.2.3 Multiple Teams\n\nWhen there are multiple teams working together it is often called a multiteam system. A multiteam system (MTS) is:\n\n\"two or more teams that interface directly and interdependently in response to\nenvironmental contingencies toward the accomplishment of collective goals” [33; 34; 35].\n\nThis is when there are several independent teams that work together in a team of teams, or multiteam, setup [34; 35]. Typically this structure has been based on the modularised component of the software architecture. In such a setting each team owns the development and maintenance responsibility for one component [35]. The collective goal of this system can be broken down into a goal hierarchy and constitutes a key characteristic of any multiteam system [34]. All teams within a multiteam system share at least a distal goal\\(^8\\), while the individual teams pursue their more proximal goals\\(^9\\) [34; 36]. This goal structure leads to teams displaying input, process and outcome interdependence with at least one other team [35; 36].\n\nMTS have received growing attention in organizational psychology over the last decade, but the aspect of coordination is underdeveloped according to Scheerer et al. in different articles [33; 34]. This indicates that only the different areas and linkages have been explored. Cross-team processes have later been proved to have the most value in MTSs with a high independent goal hierarchy. This implies that well-managed MTS processes was influenced positively, but it did not support the team-level action processes.\n\nCoordination is the management of dependencies. Inter-team coordination is the coordination of activities between two or more teams within an MTS [15]. There are two coordination types. The first is explicit coordination which consists of mechanistic elements like plans and rules. The other is implicit coordination which consists of cognitive elements like shared mental models and team expertise [37]. In a study of leadership in MTSs the leader teams were trained in two ways by either facilitating strategy development or coordination [33]. The strategy training was positively related to explicit coordination while coordination training affected the implicit coordination much stronger. This indicates that an unidentified mechanism like shared mental models seemed to influence inter-team coordination [33].\n\n2.2.4 Co-Located vs Distributed\n\nOne of the scaling factors presented by Ambler [11] is geographical distribution. When working in a large scale project it is difficult to co-locate everyone in the same place, and some projects even go across several countries. Vlietland and van Vliet [38] present three main issues arising with distribution of software practices:\n\n- Spatial separation\n- Time zone differences\n- Cultural differences\n\n---\n\n\\(^8\\)A long-term goal, in this case the end product\n\\(^9\\)A short-term goal, here the sprint goals\nSpatial separation leads to exacerbation of communication and coordination. Time zone differences can make it difficult for teams to meet, and it can therefore make it harder to receive answers to questions and dependencies. Schnitter and Mackert [39] propose that time zone differences of more than three hours makes it difficult to agree on common time for daily scrum meeting, and this implies scheduling meetings in general. Cultural differences is about the culture in the teams. Teams in different countries might have another way of working than others do. In the lessons learned-article from Schnitter and Mackert [39] they mentioned that multicultural teams typically broke up within two months mainly because the role of the scrum master is interpreted very differently among European, Asian, and American people. A scrum master from one culture found it hard to meet the expectations of team members from another culture.\n\nLarman and Vodde [40] recommends co-located teams, but open up for the possibility that the teams can be in different sites. It is more important to avoid a single dispersed team with scattered members. Martini, Pareto and Bosch [41] found ten root factors and recommendations for them. One of the root factors was ”No co-location”. With large scale it is almost impossible not to distribute teams because of the lack of space, and even the distance of one floor can make the teams distributed. They therefore recommended that especially teams that interact more intensely should be located closer.\n\n2.2.5 Frameworks and Scaling Methods\n\nIn a response to the rapid adoption of agile software development in large scale settings, several frameworks have been proposed by practitioners and agile evangelists. The most known are: Large Scale Scrum (LeSS), the Scaled Agile Framework (SAFe), the Nexus Framework and Disciplined Agile Delivery (DAD). Out of these frameworks Nexus is the closest to scrum with a lot of the same practices and processes on an inter-team level with a group of scrum teams, called a nexus. Nexus is said to be the exoskeleton of scaled scrum.\\textsuperscript{10}\n\nLeSS, see figure 2.6\\textsuperscript{11}, provides two different large scale frameworks; LeSS and LeSS Huge which can have up to a few thousand people on the project. Most of the scaling elements are focused on directing the attention on all teams over to one product instead of ”my part”.\\textsuperscript{12} LeSS introduces the concept of requirement areas as a means to group teams by areas of strongly related customer requirements headed by area product owners. All teams are in a common sprint to deliver a shippable product every sprint. Some of what distinguishes LeSS from normal scrum is the fact that there are two sprint plannings; one for everyone and one for each team, and the overall retrospective. The overall retrospective’s purpose is to explore improving the overall system rather than focusing on one team.\n\n\\textsuperscript{10}https://www.scrum.org/Resources/The-Nexus-Guide\n\\textsuperscript{11}http://agileatlas.org/articles/item/large-scale-scrum-more-with-less\n\\textsuperscript{12}http://less.works/less/framework/index.html\nSAFe is based on a number of immutable, underlying lean and agile principles. It upholds four core values: alignment, built-in-quality, transparency and program execution. SAFe is a scaled agile application in the enterprise and targets seven areas to achieve parallel scrum development [16]. These seven targets are:\n\n- Cross-functional teams\n- Standardized planning and tracking\n- Standardized iterations\n- Smaller, frequent releases\n\n\\[13\\] http://www.scaledagileframework.com/safe-lean-agile-principles/\n\\[14\\] http://www.scaledagileframework.com/safe-core-values/\nChapter 2. Theory\n\n- Concurrent testing\n- Continuous integration\n- Regular reflection and adaption\n\nSAFe is based on a number of newer paradigms in modern system and software engineering. This includes lean and system thinking, product development flow and agile development\\(^\\text{15}\\).\n\nDAD is a hybrid framework that builds upon the solid foundation of other methods and software process framework\\(^\\text{16}\\). The approach combines scrum with the best practices from multiple methodologies like XP, Rational Unified Process, Kanban, etc. The focus of DAD is on the delivery and a full product lifecycle goes from the initial idea, through delivery, to operations and support. See figure 2.7\\(^\\text{17}\\) for an overview of the scaling factors in DAD.\n\n\n\nThe frameworks concentrate on the practices, but they do not say much about the delivery mode, planning and coordination. In November 2015 Scheerer and Bick had a presentation in Trondheim about \"Five Ways to Scaling Agile Coordination in Large-Scale Agile Software Development\" [27]. Scheerer and Bick both work in SAP and have written several articles based on the scaling there [23; 33; 34; 35; 36]. In the presentation they\n\n\\(^\\text{15}\\)http://www.scaledagileframework.com/lean-agile-mindset/\n\n\\(^\\text{16}\\)http://www.disciplinedagiledelivery.com/introduction-to-dad/\n\nexplained five different scaling methods, see table 2.4, and how they can be coordinated.\n\nThe first case is the traditional case with scaling through central team directives. Here there are about thirteen teams with one hundred and forty people at four locations. They are component-based, which indicates that they are business process-oriented. In this case there is a central team which assigns epics via top-down directives but there are little bottom-up feedback from the development teams. Cloud is the second case with ten teams and about one hundred and five people at two locations. The scaling here is via iterative proxy collaboration. The organizational structure is feature-based and the solution to problems are often merely reported to CPOs (chief product owners).\n\nThe third case is distributed which involves seven teams with about seventy people over six locations. This is scaling via central planning based on team inputs. This case is component-based and software module-oriented. They have a central architecture team and the planning is based on feedback from team architects and POs. Co-located is the fourth case and is scaling through full collaboration. Here there are six teams with approximately 85 people in one location. This case is another one which is component-based and business process-oriented. They have regular information-sessions between selected teams and maintenance of a detailed wiki. The fifth and last case is the modular case which is scaling via ad-hoc communication. There are four teams with around forty people over three locations and they are feature-based. Here there is a high involvement of, and guidance by, the CPO.\n\nAs we can see there are several ways of scaling a large scale agile projects. In addition to finding a framework it is necessary to find out how to coordinate the teams: bottom-up or top-down. Number of people and locations therefore have to be considered together\nwith the influence from the management. When scaling agile methods it is important to scale them without sacrificing the underlying principles of the agile manifesto [30].\n\n2.3 Success Factors\n\nIn this section we will introduce the different possible success factors for this thesis, but first we will introduce the background for these factors.\n\n2.3.1 Introduction\n\nIn 2014 Dingsøyr and Moe held a workshop during XP2014 [2]. Here they found a revised research agenda for large scale software development. From here the original research question for this thesis appeared:\n\n\"What are the possible success factors in large scale agile development?\"\n\nThis could appear to be a broad topic since there might be a number of factors that can make a project successful. After researching and reading through several papers, see appendix A, there were a lot of possible ideas as to what could be a success factor. A factor was categorized as a success factor if it was:\n\n- Important for the project’s success\n- Mentioned as a missing piece\n- Mentioned as a recommendation\n- Mentioned as a problem or challenge\n\nThe factors found can be seen in table 2.5.\n\nAll factors come from at least one article, most come from either a conference article or journal article, while some are lessons learned. The factors in lessons learned might only have been applicable in that case, but since they are mentioned they are important in some degree. Most of these factors are cited in multiple articles which gives support to both conference and lessons learned-articles. Some of the factors are only applicable in large scale while most are applicable in both large scale and small scale. The way they affect the project, and in what degree, can be somewhat different for some of the factors. The factors with the least data according to the research question, those marked with * in the table, can be found in appendix D.\n### 2.3 Success Factors\n\n#### Table 2.5: Success Factors in Small and Large Scale Agile\n\n<table>\n<thead>\n<tr>\n<th>Success factor</th>\n<th>Small scale</th>\n<th>Large scale</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Customer collaboration</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Agile software engineering techniques and agile</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>evangelist</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Responding to change</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Team</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Leadership</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Planning*</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Testing*</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Governance*</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Divide after you conquer*</td>\n<td></td>\n<td>X</td>\n</tr>\n<tr>\n<td>Continuous integration*</td>\n<td>X</td>\n<td></td>\n</tr>\n<tr>\n<td>Bridgehead</td>\n<td></td>\n<td>X</td>\n</tr>\n<tr>\n<td>Co-location</td>\n<td></td>\n<td>X</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td></td>\n<td>X</td>\n</tr>\n<tr>\n<td>Whole team thinking</td>\n<td></td>\n<td>X</td>\n</tr>\n</tbody>\n</table>\n\n#### 2.3.2 Customer Collaboration\n\nThe customer is an important part of agile methodologies since the customer is involved the whole way opposed to just the beginning and the end. In Chow and Cao’s [8] survey study they had a list of twelve possible critical success factors. One of these were customer involvement and in the end of the article they state the importance of strong customer involvement. In agile it is important for the customer to understand agile principles, if not the road can be a bit bumpy as experienced in the article from Koski and Mikkonen [42]. The effort that the customers have to put in an agile project is much more essential than in other projects, and several customers do not understand this before undertaking an agile project. The product owner is a good example of customer collaboration. The product owner is one of the most critical roles in scrum, and difficult to implement successfully [31]. The product owner is therefore the main contributor, but can in addition be the main bottleneck because of this [42]. When beginning an agile project it is therefore necessary to explain to the customer what is expected from them.\n\nAnother important thing when it comes to customers is involving the right people, or the key stakeholders [43]. It is essential to identify the correct stakeholders, if not the whole project can fail. It is not necessarily the leaders that are the correct stakeholders, but the people who are going to benefit from the system. For understanding the system goals and features it is important to know which stakeholders that are target for the system’s features and functions. The customer should be able to prioritize scenarios or requirements if they are to be satisfied with the product, if not they might not get all the necessary requirements they need to do their job. Factors like customer satisfaction, customer collaboration and customer commitment is significant to the project success [16]. This applies to both small and large scale, and we will describe the importance of scaling the PO-role more in\nChapter 2. Theory\n\n2.3.9.\n\n2.3.3 Agile Software Engineering Techniques and Agile Evangelist\n\nOne of the three critical success factors for agile software development projects presented by Chow and Cao [8] is agile software engineering techniques. The team has to practice rigorous agile software engineering techniques. Not all projects that are supposed to practice agile have practiced it before, and it is therefore necessary to have top-notch agile consulting [44]. This can be accomplished by an agile evangelist who coordinates training and rollout. Early coaching is important and especially when no one have practiced agile earlier.\n\nBenefield [45] explains how they introduced agile development to Yahoo. There the pilot teams received some early coaching from leading agile thinkers like Ken Schwaber, Paul Hodgetts, Mike Cohn and Esther Derby. As the program expanded they established an internal coaching team at Yahoo to evangelize the benefits of scrum throughout the company, and to train coaches and support the teams that wished to use it. Since they did not have enough capacity at a time they experienced that teams that went ahead without the training failed and performed mini-waterfalls instead of being agile. The coaches, or agile evangelists, should be people with strong skills in collaboration and building consensus. Yahoo is an example of enterprise agile and therefore it is stated that finding good people who really understand the agile principles, and training them to help their own teams, are keys to scaling effectively in a large organisation. Even though scaled agile is highlighted it is still important for any agile team to be familiar with agile techniques and practices.\n\n2.3.4 Responding to Change\n\nIn essence, agility means responding to changes quickly and efficiently [46]. Daneva et al. [47] accentuates the necessity to embrace change, especially when (re)prioritizing requirements. This necessity have an impact on how agile requirements prioritization happens in both large and small projects together with project constraints. Responding to change is one of the four values which constitutes the essence of agile development methods [36]. Agile development beautifully handles changes in regard of the client’s market advantage [16]. Being respondent to change is one of the things that makes agile so customer friendly, and displays how it can adopt to changing business situations [46]. There are two types of changes different events can lead to. First-order changes are caused by events leading to incremental adoption, while second-order changes lead to brief periods of upheaval, which change the systems deep structure [34].\n\n2.3.5 The Team\n\nChow and Cao [8] identified three critical success factors in agile software projects, where one of them were team capability. In agile development it is the self-organizing scenario-based team which is important for the project’s success [11; 48]. The reason for the self-organizing teams being a success might have something to do about the fact that the best people for planning are the ones who are going to implement it [11]. Scrum gives teams\nmore power to make decisions concerning development speed and quality, which have lead to wide acceptance among teams [39]. Self-organization is therefore one of five criterias that Ambler [6] proposes to determine whether a team is agile or not, and in addition it is where most teams fail.\n\nFor successfully adopting the principals and practices of agile software development the team members should posses the ability to think and act like ”Global Citizens” or ”Tribe Members” [49]. This is especially important in large scale where the primary challenge is finding the right people to form this ”tribe”. This is recommended by Dr. Dobb, one of the pseudonyms of Scott Ambler, that the easiest way to scale agile techniques is to hire good people [50]. As mentioned by Moore and Spens [49] their number one rule is to not base your decision on agile experience when finding people to a large scale agile project. Even though people are good at agile, it does not imply they are good when there are suddenly multiple teams opposed to just one team.\n\nAnother important aspect is that it is important to avoid the ”super team” [43]. The super team is not necessarily healthy to the success of a project. This is because they tend to create thick silos within which they do great work, but can totally ignore anything outside this silo. Instead of focusing on delivering business value to their customer, they focus on the success of their part of the system. Other problems with the super team is the fact that they might have to much work because there is no other team with their abilities and they can end up slowing down the whole process. The scenario-based teams help mitigate the formation of a super team since in order to make a scenario work, team members collaborate on interfaces across multiple components and technologies [43].\n\nOptimizing the collaborative teamwork is more important than optimizing individual productivity in agile development [51]. Schmidt et al. [18] found, in a case study at SAP, that there is a higher motivation in the team and a better common understanding among the team members when they do pair programming. Moore and Spens [49] mention that especially in large scale projects it is necessary for team members to participate in cross-team activities and many teams then struggle with balancing their identity as a team member against their membership in the larger project.\n\nAccording to Schmidt et al. [17] in their paper about team adaptability they propose that agile team behaviour might affect the ”ability to make the necessary modifications in order to meet new challenges”. There are differences in how the team is a factor in accomplishing success in small and large scale agile development, but it is still one of the most important aspects in both. Even though there are several teams in large scale they are still self-organizing, and it is still important to hire good people. The difference in people might be the fact that in small scale it is an advantage to know agile practices, while in large scale this could be a disadvantage because they forget to look outside their own team.\n\n2.3.6 Leadership\n\nA leader is the person who drives the project. The leader in an agile development team is often the scrum master, if scrum is the chosen methodology. A product owner can also\nbe seen as a sort of leader. This is because the product owner is the person who has the most influence on the project since he or she usually comes from the customer and has a customer-view. We will discuss the product owner more in 2.3.9. According to Erik Moore [52] the key to successfully scaling agile was finding leaders who understood as Grace Murray Hopper said:\n\n\"You manage things; you lead people\"\\(^{18}\\)\n\nThe organization structure may influence certain leadership behaviours, but not all.\n\nThe overall project manager is responsible for planning the whole project and making sure that eventual sub-projects are going in parallel in a timely manner [53]. In small scale it is usually only called the project manager, while in large scale it might be necessary to have one overall project manager and several sub-project managers. This is depending on the size of the project where there could be multiple levels in the hierarchy. According to Moore [52] it was important that leaders exhibited the following behaviours:\n\n- Leading instead of managing\n- Flexing team boundaries\n- Driving both team and project success\n- Balancing team and individual needs\n\nThis implies that it is necessary for a leader to set direction for their teams, recognize the necessity to maximize team velocity, understand that one team’s success does not drive the project, and recognize that a team consists of individuals.\n\nBecause of the increase in size there are some new factors that appear in large scale agile projects. This could be project management teams which have the overview of the entire project. These are necessary to hold the project together and to make sure that the teams are aware of steps taken by the other teams.\n\n### 2.3.7 Bridgehead\n\nHaving a bridgehead between the teams is extremely important in large scale because it helps with the coordination among them. Coordination is long recognized as one of the fundamental problems of software engineering [54]. This is one of the root factors proposed by Martini et al. [41] where they recommend that a bridgehead can help coordination and that face-to-face communication is beneficial. This is especially important when locating dependencies among the teams. As Moore and Spens [49] mention it is important in large scale that team members participate in cross-team activities and allocate time to project-wide activities. They explain that the team technical leads are required to dedicate significant portions of their time outside the team room. This can be compared with Spotify [4] where the system owner takes a \"system owner day\" to do housekeeping work on\n\n\\(^{18}\\)She was a computer programmer that helped develop a compiler that was a precursor to the widely used COBOL language - http://www.biography.com/people/grace-hopper-21406809\n2.3 Success Factors\n\nOne of the different coordinating mechanisms that has been proposed are the scrum of scrums, also called metascrum, which have been presented by several papers [5; 26; 34; 36; 38; 55]. Whether the scrum of scrums actually work have been researched by Paasivara et al. [56]. Their findings concluded with the fact that scrum of scrums worked poorly. Contrary to these findings Dingsøyr et al. [26] found scrum of scrums to be a well-functioning coordination mechanism in the Omega case. In scrum of scrums the scrum masters of the different teams brief the other teams what they are working on. It has the same function as the stand-up meeting, but instead it is about the teams and not individuals in a team. In some cases people from other team attend the stand-up to ensure information exchange between teams everyday [53].\n\nAnother coordination mechanism is the communities of practice (COP). A community of practice is a \"group of people who share a concern, a set of problems, or a passion about a topic, and who deepen their knowledge and expertise in this area by interacting on ongoing basis\" [57]. They have three important characteristics which are domain, community and practice. Communities of practice can provide a long range of both long-term and short-term benefits to both the organization and to the members of the community. At Spotify they have \"chapters” and \"guilds”, these are explained in 2.2.2. They meet regularly to discuss their area of expertise and their specific challenges. A guild resembles more a community of practice where people who want can share knowledge, tools, code and practices which cuts across the whole organization.\n\nDingsøyr et al. [26] saw in their research of the Omega case that coordination with a large number of arenas made coordination efficient. Some of these arenas were:\n\n- Board discussions\n- Experience forum\n- Instant messaging\n- Lunch seminars\n- Rotation of team members\n- Technical corner\n\nThe rotation of team members is also recommended by Elshamy and Elssamadisy [53] as a practice to help with problems of consistency and duplication. This can be compared with dependencies. There are normally dependencies between teams that work on the same project and a bridgehead, or cross-team activities, is therefore an important aspect in large scale to discover and fix these dependencies.\n\n2.3.8 Co-Location\n\nIt is said that agile methods “best suit co-located teams of about 50 people or fewer who have easy access to user and business experts and are developing projects that are not life-\ncritical” [26]. In large scale there might be multiple people and it becomes increasingly difficult to place everyone at the same location. Geographical distribution is presented as one of the scaling factors by Ambler [11]. Even being in different cubicles within the same building can erect barriers to communication, let alone being in different cities or even on different continents. The distance can lead to delays and lack of communication and commitment [41]. In Schnitter and Mackert’s papers on SAP [5; 39] they mention co-locating all product team members as one of the prerequisites for a product team to function properly. In addition they considered it essential to bring all team members together in one location during project kick-off meetings. Even though it is necessary with co-located teams it is more important to avoid a single dispersed team with scattered members [40]. One of the recommendations by Martini et al. [41] is that teams that have to interact more intensely should be located closer.\n\nWhen Giblin et al. [29] interviewed the development teams at the beginning of the agile introduction the open plan area provoked negative responses. After working with agile methods for a period of time, the necessity for co-location was strongly recognized by the developers. A good example of locating teams that need to work more intensely together is Spotify [4]. They have scaled to over thirty teams across three cities. As mentioned in section 2.2.2 the squads working in related areas are all physically in the same office, most often next to each other. The lounge areas they have are there to promote collaboration between squads.\n\n### 2.3.9 Product Owner\n\nThe product owner (PO) is the person who prioritizes the requirements and provides detailed information about the business to developers [6]. In scrum it is the product owner that makes the decisions [58]. The product owner is the key contributor, but can also be the main bottleneck [42]. The PO owns all the requirements and communicates all the functional and non-functional specifications to the developers. The PO role is pivotal in providing a bridge between the development and project management team. It is therefore necessary to have the right person in this task [48]. This is the same for both small scale and large scale. But the difference when it comes to large scale is the necessity of scaling the PO role. One of the recommendations from Koski and Mikkonen [42] was to split the responsibilities of the PO for a number of persons. This was to be able to communicate with both the customer and teams effectively.\n\nA single PO is not able to work with all the teams [31]. The number of teams one PO can be responsible for varies in the different papers. Paasivara et al. [31] have found that Pichler recommends that a PO works with no more than two teams simultaneously, while Larman and Vodde [40] thinks a single PO can have up to ten teams. Several articles suggest the use of area product owners (APO) [5; 31; 39; 40]. APO concentrate on specific areas of the product. The areas can be compared to the tribes at Spotify [4], see 2.2.2. There is normally one overall PO and several APOs that form the PO team [40]. Other PO roles that have been presented are the feature product owner (FPO) and epic product owner (EPO) [59]. A FPO owns the functionality of a set of features, while EPO is accountable for the unique priority of each feature on the feature backlog.\n2.3 Success Factors\n\nFrom the papers about SAP by Schnitter and Mackert [5; 39] they present product teams as a second organizational layer above the scrum teams. A product team is responsible for the work of up to seven development teams and consists of the product owners from those teams. This allows for full engineering coverage of all problem areas expected, well-organized communication among the teams, and direct communication with the development teams to detect and mitigate risks. In the product team they have these roles:\n\n- Chief product owner\n- Product team\n- Scrum master\n- Software architect\n- Delivery manager\n- Knowledge management and product documentation expert\n- User interface designer\n- Stakeholder representative\n\nThese roles are taken by dedicated people or by development team members. Also at SAP they have an additional, intermediate, layer between product team and scrum teams. These are called area product teams.\n\nThe division of responsibility between the PO team members depend on how the work is divided between the scrum teams. The two main lines of thought are requirement areas with feature teams or component teams [31], as mentioned in section 2.2. In one of the cases presented by Paasivara et al. [31] they divided the APO role between two persons; one system architect and one solution architect. The system architect was a technical person who worked closely with the development teams and communicated with the solution architect. The solution architect was a product management representative with either a business or technical background and did not communicate with the teams, which implies that they only had one PO to interact with. In the other case they had a product ownership team with one PO and ten proxy product owners (PPO). A large feature could have up to three PPOs, while a single PPO might be responsible for a couple of small features. The shared responsibility proved hard and the PPOs eventually had their own features since they all had specific product areas they were most familiar with.\n\nThere are many different ways of scaling the PO role, and it is usually accomplished with a hierarchy of POs [58]. The most important criteria to make the PO a success factor is to enable face-to-face communication with the development teams and having a clear prioritization which is efficiently communicated to all POs. It is positive if the PO has a technical background, but it is not necessary. A PO should be good at collaborating, this was mentioned in 2.3.2.\nChapter 2. Theory\n\n2.3.10 Whole Team Thinking\n\nAmbler proposed that for agility in the large to succeed the team members should share the same philosophical mindset [50]. Whole team thinking can have many names like shared mental models, understanding overall situation, full lifetime cycle or sharing the same philosophical mindset. In section 2.4 we will discuss shared mental models and how they work in both normal and agile teams. Now we will explain why whole team thinking is believed to be an important success factor in large scale agile. In small scale there is only one team and they all work toward the same goals already, which is why it is not that big of a problem. Most of the scaling elements are focusing the attention of all the teams to the whole product instead of \"my part\" [40], but this does not imply that this is how it works in real life. Improving the shared understanding of requirements is a key enabler for increased productivity in software projects [60]. One of the reasons for having to look at the bigger picture has to do with dependencies. In a large scale project it is hard not to encounter dependencies to other teams. One of the root factors presented by Martini et al. [41] is that when people discover that interaction is necessary they consider it a low priority and they delay tasks and communication, thus hindering the other team(s) involved. It is therefore necessary for tools creating awareness to help them understand the overall situation of the involved teams. As proposed by Brown et al. [51] it is more important to optimize collaborative teamwork than to optimize individual productivity.\n\nMoore and Spens [49] present several challenges when it comes to whole team thinking. When establishing a consistent culture of working builds there were only a few individuals that were passionate about this, for more information see appendix D.1.5. They hoped that team ownership of code would drive people to solve integration challenges, but sadly it did not. They also pointed out one other problem in large scale, which is that team members must participate in cross-team activities and allocate time to project-wide activities. This could be by the scrum masters having to participate in scrum of scrums, the architects having to gather to discuss architecture etc. In a large scale project it is necessary to do these things to ensure that everything is working according to plan. All the teams therefore struggled with balancing their identity as a team member against their membership in a larger project. This had to do with the demand to participate in these other meetings. The lessons learned by Lindvall et al. [61] is that a part of the project cannot truly be independent, but must interact with and follow the rules of the project overall.\n\nA problem found at SAP [5] was that there had been competition among the team members. Team members felt expected to work harder than was sustainable and they chose more from the backlog than they could implement. This was because the teams saw it more as a competition than a collaboration. They did not think about dependencies or the project as a whole, but only that their team should be the best team. This is one of the reasons that it is important to think about the whole project and not only \"my part\" as proposed by Larman and Vodde [40]. It does not help that one team has finished all their work, if there are still tasks left at other teams. The project is not finished until everything is completed. In large scale projects there is a need to sort out the dependencies across the different teams [3]. If this is saved until the end it will only cause more problems. The main cause of communication breakdowns is a \"weak vision of overall goal\" [3]. If\nthe dependencies are not communicated the team(s) or team members have a weak vision of the overall goal. Without a shared vision redundant work might be conducted and the system might not fully satisfy the user’s requirements [62].\n\n2.4 Whole Team Thinking and Shared Mental Models\n\nThis section will introduce the shared mental models theory. Following this is examples of how shared mental models can be applied together with agile practices. In the end we will discuss why whole team thinking is important.\n\n2.4.1 Shared Mental Models Theory\n\nShared mental models theory is a concept among team members where they are offered a means to explain coordinated performance in teams, especially in conditions where there are a high workload [63]. The theory investigates the role of shared understanding on team performance and has prescribed methods for fostering shared mental models [64]. Shared mental models are thought to provide team members with a common understanding of who is responsible for what task and what the information requirements are. This can allow them to anticipate one another’s needs so that they can work in synchronization [63]. Shared mental models is an organizing knowledge structure of the relationships among the task the team is engaged in and how the team members will interact [24].\n\nThe term mental model has been used as an explanatory mechanism in a variety of disciplines over the years. Mental models are organized knowledge structures that allow individuals to interact with their environment. They also allow people to predict and explain the behaviour of the world around them. Mental models serve three crucial purposes and that is that they help people to describe, explain, and predict events in their environment [65].\n\nThere are two types of mental models: team-related and task-related. The team-related mental models is about how the team is functioning and the expected behaviours of the team [24]. It is the shared understanding related to the other team’s interaction and coordination, such as communication patterns, roles and responsibilities of team members, role interdependencies, and background knowledge of each team member [64]. An example of team-related mental models is when a group of students discuss which grade they would like to achieve in a project and how to work together to reach this grade. The task-related mental models contain information regarding the materials necessary for the task or the manner in which equipment is used [24]. It focuses on performing the tasks as a team, such as understanding goals, complexities, challenges, interdependencies, and procedures of accomplishing tasks as a group [64]. An example of task-related mental models is when the students decide between the different equipments and frameworks to use in the project and discuss how this will affect them.\n\nShared mental models have been used to explain team functioning for years [65]. It facilitates the team’s progression toward goal attainment by creating a framework that\npromotes a common understanding and action [24]. Shared mental models can be used to explain how teams are able to cope with difficult and changing task condition [65]. Teams that share similar mental models communicate more effectively, perform more teamwork behaviours and they generally perform better [24]. Shared mental models theory focuses on the thought processes or activities that occur at a team level and it proposes that effective teams should maintain a shared understanding within a team. Accomplishing team goals without commonality between team members would be nearly impossible [64]. This does not indicate that cooperative or happy teams will always be successful [65]. This only implies that individual members may be headed toward different goals without a shared understanding, which may lead to ineffective feedback or assistance, or the inability to anticipate each other’s actions or needs [24]. This implies that having the same goals and being in a cooperative and happy team is not necessarily the same.\n\nThere are four specific stages for developing a shared mental model within a team according to Yu and Petter [64]. These four are knowing, learning, understanding and executing. Knowing refers to the stage in shared mental models where team members are exposed to information that is relevant for accomplishing team tasks or projects. When a team is established they will engage in various kinds of information exchange activities, ranging from casual team chat to team building exercise to a formal team meeting. All of these are knowing activities that expose the team members to information that is relevant for accomplishing the team’s goals. The team members are in this stage encouraged to share information previously possessed individually by each team member to others in the team [64].\n\nIn the learning stage the team members begin to integrate the information they obtained in the knowing stage. The outcome of the learning stage is essential for knowledge construction at the team level. The understanding stage is when the team members develop shared understanding about tasks and the team by solidifying the views and perspectives that each team member holds individually [64]. The goal of this stage is for the team members to reach a consensus and build a common ground so they are ready for the next stage. The executing stage happens when teams develop a shared understanding and start executing their team goals [64].\n\nShared mental models theory was originally used to account for the performance of military teams, such as whether or not a group accomplished a mission successfully [64]. Stout et al. [63] have explored the relationship between team planning, shared mental models and coordinated team decision making, and performance. The results indicated that effective planning increased the shared mental models among team members. The team members shared an understanding of each other’s needs and informational requirements [63]. These studies completed identified that teams that possessed shared mental models were better at predicting other team members’ behaviours and needs [64]. It is said that shared mental models have a tendency to shrink with the increasing specialization of team members [22].\n2.4 Whole Team Thinking and Shared Mental Models\n\n2.4.2 Agile Practices and Shared Mental Models Theory\n\nThe members in a software team are jointly responsible for the end product and they must develop shared mental models by negotiating shared understandings about both the team-work and the task [66]. According to Vlietland et al. [59] shared mental models are implemented by grouping people together and stimulate communication and feedback, such as with the scrum of scrums practice. There have been several studies on shared mental models in information systems development performance [64]. Shared mental models among information systems development teams facilitate information sharing between developers, reconciles conflicts between client representatives and software development project leaders. In addition it can improve the overall quality of the software according to some of these studies [64]. By having customer representatives on site they can be part of the development team, which leads to a shared sense of trust, norms and values which could improve the project success. There are different primary goals for the developers and testers in a team, if these can develop shared mental models there could be a greater understanding of the dissimilarities and they can work together to address other issues that could negatively impact the outcome of a software development process [64]. Yu and Peter [64] explained how three agile practices can be seen related to shared mental models.\n\nThe system metaphor in agile software development is employed at the beginning of the project to develop a story that makes people understand key concepts of the system and allow them to raise questions. It is used in the extreme programming method, see appendix C.1.1 for more information. This practice encourages the agile team to create an open environment and use metaphors or stories to develop shared understandings regarding system goals, key concepts, major system functionalities, and roles and expertise of the agile team members. The system metaphor is used for the same role as the shared mental model planning practice for the development team’s shared mental models. This practice helps the agile team developers to be more effective in the knowing and learning stages, and it allows agile teams to identify unshared information, and quickly communicate with customers in a common language. It improves the team’s taskwork mental models in terms of similarity and accuracy in that developers and customers will create a shared and correct understanding of one another’s roles, responsibilities, and technical backgrounds. There are two benefits of the system metaphor integrated with shared mental models. The first is that it provides a systematic approach for agile teams to generate system metaphors by ensuring the important aspects relevant to the task and the team are discussed among the users and developers. The second benefit is that the system metaphors enhances the communication effectiveness within the development team by enabling more correct anticipations of one another’s informational requirements [64].\n\nStand-up meetings are used in scrum and are conducted daily. These meetings are short and involve the entire team. Some of the benefits are: daily monitoring and control of the project’s progress. The shared mental models in stand-up meetings provide an opportunity to increase team’s shared understanding about taskwork through these benefits. It incorporates the shared mental models practices of leader briefings, which is leader communication within teams, and reflexivity. Reflexivity is “the extent to which group members overtly reflect upon the group’s objectives, strategies, and processes and adapt\nthem to current or anticipated endogenous or environmental circumstances”. The stand-up meeting improves similarity and accuracy of the taskwork and teamwork mental models. The meetings help to identify cognitive differences and goals between scrum master and the team. Through all of the interactions in stand-up meetings team members develop shared understandings of the consequences of the current approach and future steps [64].\n\nThe on-site customer in agile practice states that the customer should be present with the development team on a full time basis participating in planning game sessions, acceptance testing, and retrospective sessions. When the on-site customer is looked at from a shared mental models perspective, we can see that it helps the agile teams develop greater taskwork mental models by implicitly implementing the shared mental models practice: cross-training. Cross-training is an instructional strategy in which the team members is trained in the duties of his or her teammates to increase the accuracy and similarity of the team’s shared mental models. The team members develop greater taskwork mental models and are able to compensate for teammtes’ limitations through cross-training. The on-site customer enhances the agile teams’ understanding and executing stages, and it builds similar and accurate taskwork mental models for the team. There are two benefits of integrating shared mental models with on-site customer. The first is that it offers a guideline for agile team developers when communicating with the on-site customer. The other is that it offers alternative approaches to learn about the customers’ needs [64].\n\n2.4.3 Why is Whole Team Thinking Important?\n\nIn a presentation by Moe and Dingsøyr from the Norwegian agile conference \"Smidig 2015” they explained why shared understanding is so important [67]. In distributed teams a shared understanding is important for trust. All teams should understand:\n\n- Which agile workprocess do we want?\n- What do we wish to accomplish?\n- Who knows what?\n\nIf the teams do not use the same methods this can be an issue of trust, because they do not trust that the methods of one team works. Having the same goal is also important. If the teams work towards different goals there will be a problem when the different parts are assembled in the end.\n\nCoordination effectiveness is the outcome of a coordination strategy [37], see figure 2.8. The explicit components encompasses the objects involved in the project, while the implicit is concerned with coordination that occurs within work groups without explicit speech or message passing. A definition for coordination effectiveness is:\n\n\"Coordination effectiveness is a state of coordination wherein the entire agile software development team has a comprehensive understanding of the project goal, the project priorities, what is going on and when, what they as individuals need to do and when, who is doing what, and how each individuals work fits in with other team members work. In addition, every object (thing\n2.4 Whole Team Thinking and Shared Mental Models\n\nFigure 2.8: Components of Coordination Effectiveness from Strode et al.\n\nTable 2.6: Strode’s Implicit Coordination Factors\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Know why</td>\n<td>This implies that each individual working on the project understands the overall project goal and understands how a task contributes to the overall goal</td>\n</tr>\n<tr>\n<td>Know what is going on and when</td>\n<td>Each individual has an overall idea about the project status, which is tasks currently underway and tasks that need to be performed in the future</td>\n</tr>\n<tr>\n<td>Know what do to and when</td>\n<td>Each individual who works on the project knows which task they should be working on and when they should be working on that task relative to all of the other tasks that must be completed</td>\n</tr>\n<tr>\n<td>Know who is doing what</td>\n<td>Each individual knows what tasks others are currently working on</td>\n</tr>\n<tr>\n<td>Know who knows what</td>\n<td>This addresses expertise location</td>\n</tr>\n</tbody>\n</table>\nor resource) needed to meet a project goal in the correct time and in a state of readiness for use from the perspective of each individual involved in the project.” [37]\n\nAccording to Strode et al. [37] there are five factors for implicit efficient coordination which can be seen in the figure and further explained in table 2.6. The five factors are necessary in whole team thinking. Without whole team thinking you risk having several puzzle pieces that do not fit together in the end.\nChapter 3\n\nMethod\n\nThe method chapter will first give an overview of the literature review before explaining the data collection and data analysis of the case study. This includes explanation of case choice, observations and how the study was completed.\n\n3.1 Literature Review\n\nIn this section we will discuss the different parts of a literature review together with its objectives. The selection strategy and research question for this thesis will also be introduced.\n\n3.1.1 Parts and Objectives of a Literature Review\n\nThere are two parts of literature review according to Oates [9]. One of them is when a research student explores the literature to look for a suitable research idea and discover relevant material about any possible research topics. This will help the students to get a feel for the area and define a research problem. The other part begins after the topic is chosen and continues until the research is ended or published. Here the aim is to gather and present evidence to support ones claim. Since this also is a case study there are certain elements that a plan should have [68]:\n\n- Objective - what to achieve?\n- The case - what is studied?\n- Theory - frame of reference\n- Research questions - what to know?\n- Selection strategy - where to seek data?\nTo have a successful literature review most of the objectives in table 3.1 must be met. The main objective in this thesis is to see if what we have hypothesized can be accompanied by a result that can confirm it. This does not imply that it is necessary that it is correct in all cases, but at least in some cases.\n\n**Table 3.1: Objectives of a Literature Review**\n\n<table>\n<thead>\n<tr>\n<th>Objectives of a Literature Review [9]:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>- Show that the researcher is aware of existing work in the chosen topic area</td>\n</tr>\n<tr>\n<td>- Place the researcher’s work in the context of what has already been published</td>\n</tr>\n<tr>\n<td>- Point to strengths, weaknesses, omissions or bias in the previous work</td>\n</tr>\n<tr>\n<td>- Identify key issues or crucial questions that are troubling the research community</td>\n</tr>\n<tr>\n<td>- Point to gaps that have not previously been identified or addressed by researchers</td>\n</tr>\n<tr>\n<td>- Identify theories that the researcher will test or explore by gathering data from the field</td>\n</tr>\n<tr>\n<td>- Suggest theories that might explain data the researcher has gathered from the field</td>\n</tr>\n<tr>\n<td>- Identify theories, genres, methods or algorithms that will be incorporated in the development of a computer application</td>\n</tr>\n<tr>\n<td>- Identify research methods or strategies that the researcher will use in the research</td>\n</tr>\n<tr>\n<td>- Enable subsequent researchers to understand the field and the researcher’s work within that field</td>\n</tr>\n</tbody>\n</table>\n\n### 3.1.2 Selection Strategy and Research Question\n\nFor this thesis a supervisor together with a topic was chosen first. After this the supervisor provided several articles on the theme so that it was possible to find a research question. The topic chosen was:\n\n**Large scale agile development**\n\nAfter reading through several of the papers provided by the supervisor it was possible to narrow down the topic even more to:\n\n**What are the possible success factors in large scale agile development?**\n\nSince this was still a broad research question it was necessary to reduce it even more, but this was not possible until the success factors had been researched. After finding the possible success factors and analyzed them, the ultimate research question was produced:\n\n**Is whole team thinking a possible success factor in large scale agile development?**\n\nAfter choosing the success factor to focus on, it was necessary to research these more. This then lead to all the search words used for this thesis, see table 3.2. When finding relevant research papers several online databases relevant to IS and computing were searched through, those can be seen in table 3.3. These databases were proposed by the supervisor and by Oates in the book \"Researching Information Systems and Computing” [9].\n3.1 Literature Review\n\nTable 3.2: Search Words Used for this Thesis\n\n<table>\n<thead>\n<tr>\n<th>Concept</th>\n<th>Keywords</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Agile</td>\n<td>agile</td>\n</tr>\n<tr>\n<td>Large scale</td>\n<td>large scale, large-scale, multiteam system</td>\n</tr>\n<tr>\n<td>Success factors</td>\n<td>success, factors, tips, recommendation</td>\n</tr>\n<tr>\n<td>Whole team thinking</td>\n<td>whole team thinking, goal, shared mental models</td>\n</tr>\n</tbody>\n</table>\n\nTable 3.3: Databases Used for this Thesis\n\n<table>\n<thead>\n<tr>\n<th>Database</th>\n<th>Website</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ISI web of science</td>\n<td><a href=\"http://apps.webofknowledge.com/\">http://apps.webofknowledge.com/</a></td>\n</tr>\n<tr>\n<td>IEEE Xplore Digital Library</td>\n<td><a href=\"http://ieeexplore.ieee.org/Xplore/home.jsp\">http://ieeexplore.ieee.org/Xplore/home.jsp</a></td>\n</tr>\n<tr>\n<td>Scopus</td>\n<td><a href=\"http://www.scopus.com/\">http://www.scopus.com/</a></td>\n</tr>\n<tr>\n<td>ACM Digital Library</td>\n<td><a href=\"http://dl.acm.org/\">http://dl.acm.org/</a></td>\n</tr>\n</tbody>\n</table>\n\nArticle Selection\n\nAt the beginning the supervisor and other students provided articles based on agile development and large scale agile. After reading through these and proposing a research question the individual study began. The article selection was based on several items:\n\n- Does the article seem relevant from the abstract?\n- Does the article have many references?\n- Is the article referenced by other papers?\n\nSince there are few articles on large scale agile today, a lot of the papers found were printed out and read through, even though they did not meet all criteria. This was to make sure nothing was missed. Some of the articles that proved irrelevant to the research question could still include theory about the theme and they were therefore looked through briefly. It was necessary to see through the abstract if the article was about an agile development project, preferably large scale, if not the article was probably not relevant for the thesis.\n\nIf the abstract was approved the number of references would be checked. The number of references is important especially for a scientific article, because it makes it apparent that there has been research on the theme(s) presented. If there were few references it could imply that it was a lessons learned-article, or based on experiences discovered in the field, which is important since they can say firsthand what worked. These articles were not excluded, but were looked at with a more critical eye. Even though an article did not have many references it did not imply that it was irrelevant, just that it was important to check the facts in other papers. It was therefore checked if the article was referenced by other papers, this was to prove the validity of the article. An article referenced by other papers is often well researched. Checking these two last items was especially important when choosing the final research question after finding the success factors. The success factor chosen could not be mentioned by only one article with few references and no citations.\nChapter 3. Method\n\nThe reason for this is that it might not actually be a success factor if it is not mentioned by any other articles, and it might not have been researched sufficiently.\n\nIn addition to searching for articles, the references in all found articles were checked to see if there were other relevant papers that should be included in this research. From these papers it was again possible to check the references and so forth. This is called snowball sampling [9], when you use the gathered data to find more data. This is useful when it comes to finding persons with similar interests. From this, additional relevant papers were found that contributed to the research question.\n\nSeveral of the articles found was conference articles and there were few journal articles that mentioned different success factors and lessons learned from large scale agile. This indicates that in some cases there might be the personal opinions of the author(s) or the opinions of some of the people that worked on the projects. Most of the articles were based on one case.\n\n3.2 Case Study\n\nIn this section we will discuss the data collection for this thesis, together with choice of case, observations and qualitative data. After this we will discuss the data analysis for this thesis which includes information about the cases and how this study was conducted.\n\n3.2.1 Data Collection\n\nThis thesis is a case study where the main goal is to see if there is any truths to the research question. A case study is an empirical method which is purely observational. It can contain different research methods, but interviews and observations are mostly used for data collection in case studies [68]. The idea behind this case study is to find out what is happening, seek new insights and generating ideas and hypothesis for new research, which makes this thesis exploratory. The research process can be characterized as either fixed or flexible. Fixed indicates that it is defined at the launch of the study, while in flexible the key parameters may be changed during the course. Case studies are typically flexible, and that is also the case for this thesis. The primary data source for this thesis is qualitative, see more in 3.2.1.\n\nOne of the reasons for choosing an exploratory study is the fact that there have been few studies on the field. This is both when it comes to large scale agile and whole team thinking in large scale agile.\n\nChoice of Case\n\nWhen conducting a case study the case and the units of analysis should be selected intentionally. The reason that the choice of case study is important could be when someone wants to replicate the study. It can be literally replicated, which indicates that the case is selected to predict similar results, or theoretically replicated where the case is selected\n3.2 Case Study\n\nTable 3.4: Taxonomy of Scale by Dingsøyr et al.\n\n<table>\n<thead>\n<tr>\n<th>Level</th>\n<th>Number of teams</th>\n<th>Coordination Approaches</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Small scale</td>\n<td>1</td>\n<td>Coordinating the team can be accomplished using agile practices such as daily meetings, common planning, review and retrospective meetings</td>\n</tr>\n<tr>\n<td>Large scale</td>\n<td>2-9</td>\n<td>Coordination of teams can be achieved in a new forum such as scrum of scrums</td>\n</tr>\n<tr>\n<td>Very large scale</td>\n<td>10+</td>\n<td>Several forums are necessary for coordination, such as multiple scrum of scrums</td>\n</tr>\n</tbody>\n</table>\n\nto predict contrasting results for predictable reasons. When choosing cases for this thesis there were several selection criterias that needed to be fulfilled. These were:\n\n- Agile development project\n- Large scale\n- Available\n\nWhen deciding if a project were large scale or not we used the definition given by Dingsøyr et al. [69] which can be seen in table 3.4. From this it is necessary with a case which have from two to more than ten teams. When it comes to the availability criteria this is natural because in practice many cases are based on availability [68]. With the limited time and resources that is this thesis it might not always be possible to find good cases, but it is normally better to have one case than none. The researcher has been lucky enough to have two cases for this study. One of them finished a couple of years ago which have lead to information that others have collected. The other case is an ongoing project where it has been possible to observe several meetings.\n\nData collection techniques can be divided into three levels [68].\n\n- First degree\n- Second degree\n- Third degree\n\nFirst degree implies that the researcher is in direct contact with the subjects and collects data in real time. Second degree is when the researcher collects raw data without actually interacting with the subjects during the data collection. Third degree is independent analysis of work artifacts where already available and sometimes compiled data is used. For the Omega case only the third degree was possible, while for Tellus it was possible with second and third. Second is implemented through observations, and third through observations from other students also observing. It was not possible for this thesis to collect data from first degree.\nObservations\n\n\"Fieldnotes are gnomic, shorthand, reconstructions of events, observations, and conversations that took place in the field. They are composed well after the fact as inexact notes to oneself and represent simply one of many levels of textualization set off by experience.”\n\n-Van Maanen (1988) [70]\n\nAccording to Wolfinger [70] there are two methods for writing fieldnotes. The first is the salience hierarchy where whatever observations struck most noteworthy is described first. What makes an observation salient is highly subjective and depends upon the particular research context. The second strategy is comprehensive note-taking. Here one does the note-taking from the beginning to the end. One of the advantages with this last strategy is that the researcher often describes events that might otherwise seem to mundane to annotate, but later the data can prove to be valuable.\n\nObservations can be conducted in order to investigate how a certain task is implemented by software engineers. There are two main types of observation: systematic, also called direct, and participant. In the direct observations you decide in advance the particular type of events you want to observe, and use a pre-designed schedule to note their frequency in duration. This can be called a pre-defined system of observations and direct observations is a fairly structured form of data collection. The participant observations is where the researcher takes part in the situation under study and experiences it from the point of view of the others in that setting. This can be completed either by people knowing that you are observing them or not. Here there are several things that are noted and not only pre-defined observations [9].\n\nFor this study direct observation is chosen, since it is not possible with participant observation. Participant observation in this case would require training and it is not necessary for the case. Direct observation is primarily a quantitative technique in which the observer is explicitly counting the frequency and/or the intensity of specific behaviours or events or mapping the social composition and action of a particular scene. Since data captured can be observed, and do not require any interaction between observer and those studied, an audio or video recording setup could be enough [71]. For this case the observer is present and without any audio or video recording setup. Some of the reasons for this is the fact that it is not necessarily what is said that is of importance. The observation template is available in appendix B.\n\nQualitative Data\n\nQualitative data is all non-numeric data like words, images and sounds. This is the primary type of data generated by case studies. It is possible to do a quantitative analysis on qualitative data, for example by counting number of times a word or phrase occurs [9] Since a case study is a flexible research method qualitative data analysis methods are widely used [68]. The advantage with qualitative data analysis is that it can be rich and detailed and the fact that it is possible with alternative explanations. This indicates that there is possible\n3.2 Case Study\n\nfor different researchers to reach different, but equally valid conclusions.\n\nIn this thesis the researcher have gathered data from observations and focus group interviews. In the observations there have been possible with words, images and sounds, while in the focus groups there were only words because they had been conducted by others. There have not been conducted a quantitative analysis by counting words, but words and sentences, and interpretations by researcher in conjunction with these, have been gathered under the different factors.\n\n**Principles for Interpretive Field Research**\n\nWhen it comes to the nature of the study it was chosen to do an interpretive view. Interpretivism is:\n\n> \"associated with the philosophical position of idealism, and is used to group together diverse approaches, including social constructionism, phenomenology and hermeneutics; approaches that reject the objectivist view that meaning resides within the world independently of consciousness\"\n\nCollins 2010\n\nThe studies usually focus on meaning, while in positivism they believe there is a connection. The principles for interpretive field research by Klein and Myers [72] are a set of principles used for interpretive research in information systems research community. See table 3.5 for the seven principles.\n\n**Table 3.5: The Researchers Interpretation of the Principles of Klein and Myers**\n\n<table>\n<thead>\n<tr>\n<th>Principle</th>\n<th>Summary</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>The fundamental principle of the hermeneutic circle</td>\n<td>All understanding is achieved by the equal importance between parts and the whole that they form</td>\n</tr>\n<tr>\n<td>The principle of contextualization</td>\n<td>The subject of investigation must be understood in both its social and historical context</td>\n</tr>\n<tr>\n<td>The principle of interaction between the researcher and subjects</td>\n<td>Meaning is produced through the different interactions between the researcher and the participants</td>\n</tr>\n<tr>\n<td>The principle of abstraction and generalization</td>\n<td>Specific instances of phenomena should be articulated in terms of abstract categories or broader ideas and concepts</td>\n</tr>\n<tr>\n<td>The principle of dialogical reasoning</td>\n<td>The researcher should make own prejudices and philosophical assumptions explicit</td>\n</tr>\n<tr>\n<td>The principle of multiple interpretations</td>\n<td>The researcher should explore the varying viewpoints of stakeholders</td>\n</tr>\n<tr>\n<td>The principle of suspicion</td>\n<td>Sensitivity to possible "biases" and systematic "distortions" in the narratives collected from the participants</td>\n</tr>\n</tbody>\n</table>\n\n1 http://research-methodology.net/research-philosophy/interpretivism/\n3.2.2 Data Analysis\n\nThe data analysis phase is where the research is collected and worked through. This is where we begin to compare the findings with the research question. Here we will further explain how we have conducted the data analysis. First we will shortly describe the cases before we explain how this study was conducted. In the end we will display the views of the subject after the researcher presented the results of this thesis in member checking.\n\nThe Cases\n\nFor this thesis the researcher has been able to follow two cases. The first one is Omega. Omega is a finished project that the supervisor has followed earlier. Therefore I have been granted access to three focus group interviews for this thesis. The codenames is the same as the ones used in other articles. There is one focus group for each of the suppliers and several of the interviewees have been in project management at one point during the project. The background material for the case comes from a Master Thesis from 2015 [73] and an article which is still a work in progress which is about the case [26].\n\nThe other case is Tellus, which is a codename given by the researcher since it is a relatively new ongoing project where few others have been included. This case consists of six observations, four conducted by the researcher and two conducted by another student. These consist of: two backlog groomings, two sprint plannings and two retrospectives. Because there has been no interviews the case is based solely on the researcher’s interpretations of these observations.\n\nBoth of the case studies were conducted in Norwegian since that is the native language of the people involved. This indicates that all quotations used are translated from Norwegian to English. Since the material have been obtained by various methods and in different terms it might not be ideal to compare the different cases. Another fact is that while the Omega-case is finished, the Tellus-case is still ongoing. It is therefore important to state that many of the findings are from the interpretations of the researcher. Others might interpret things differently and might reach other conclusions than the researcher. This is especially important at Tellus where there are only observations and no interaction with the people involved. They might experience the meetings observed in a completely different way from the researcher of this thesis.\n\nConducting the Study\n\nWhen exploring the qualitative data the researcher decided to see it with regards of the success factors found in the theory. After reading through the material for each of the two cases the different aspects were put into the different factors that best suited the statements and interpretations of the text.\n\nFrom the Omega case there was focus group interviews conducted by other researchers. These interviews were first read through and then all the important keywords and statements were collected in its own document. The keywords and statements which were\ninterrelated were put together from this point to simplify the next processes, but each interview were segregated so it was easy to find which keywords and statements which came from what interview.\n\nThe observations from Tellus already had keywords and interpretations because they were completed by the researcher and this step was therefore not necessary for that case. After the first step the keywords, statements and interpretations found were put in each factor. This can be called coding of data where parts of the text is given a code representing a certain theme, area or construct [68] which here is the different factors. This was conducted separately for each case and can be compared to tabulation where the coded data is arranged in tables to get an overview of the data [68]. Some items were harder to place and was therefore put in an undecided factor. After all text was undergone by the researcher these were once again attempted to place in one of the existing factors.\n\nThis thesis have benefited from several approaches. The immersion approach has a low level of structure and is reliant on intuition and interpretive skills of the researcher [68]. This approach have been used to some degree because the researcher has not had the ability to interview and has relied on observations and interviews conducted by other researchers. The editing approach include codes based on findings of the researcher, which is the different factors found earlier. These have been used when reviewing the two cases and compared them to each other. The last approach used is the template approach where the research is based on research questions [68]. The quasi-statistical approach, where there can be a calculation of frequencies of words and phrases, did not seem appropriate in this thesis and has therefore not been utilized.\n\nMember Checking\n\nAfter the observations and analysis of these were concluded the researcher presented their findings to the Tellus-project. The people at Tellus did not know the purpose of the project and therefore they first needed an overview of the study. After this the researcher presented the findings from the case and compared it to the Omega case. In the end further actions for the project were presented.\n\nThe people involved agreed with what the researcher highlighted and they had already made several changes since the researcher had observed them. They seemed to appreciate the feedback given and were interested in how to begin new projects to try to eliminate some of the problems earlier in the process.\n\nMember checking can bee seen together with the third principle of Klein and Myers [72]. This principle is about the interaction between researcher and subject. The researcher did not communicate with the subjects during the observations, but later there were interaction where it was possible to find unity between researcher and subjects.\nResults\n\nThe results chapter contains the results from the two case studies conducted. First we will give an overview of the two cases. After this we will present the results from each case in conjunction with the different success factors.\n\n4.1 The Cases\n\nFor this thesis the researcher was able to follow two different cases; Omega and Tellus. Both of them have been anonymized. For more information about the data analysis see 3.2.2. Here the cases are explained with a basis of the project and an overview of the work areas. For an overview of both projects see table 4.1.\n\nTable 4.1: An Overview of the Cases\n\n<table>\n<thead>\n<tr>\n<th>Project</th>\n<th>Omega</th>\n<th>Tellus</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Budget</td>\n<td>140 million euro</td>\n<td>30 million NOK, exclusive VAT</td>\n</tr>\n<tr>\n<td>Duration</td>\n<td>January 2008 to March 2012</td>\n<td>Fall 2015 to early 2017</td>\n</tr>\n<tr>\n<td>Number of people</td>\n<td>175</td>\n<td>15</td>\n</tr>\n<tr>\n<td>Number of teams</td>\n<td>13 at most</td>\n<td>2 squads in one team</td>\n</tr>\n<tr>\n<td>Location</td>\n<td>Co-located</td>\n<td>Distributed</td>\n</tr>\n<tr>\n<td>Time of sprints</td>\n<td>3 weeks</td>\n<td>4 weeks</td>\n</tr>\n<tr>\n<td>Different companies</td>\n<td>5</td>\n<td>1</td>\n</tr>\n<tr>\n<td>Releases</td>\n<td>12</td>\n<td>About 10</td>\n</tr>\n<tr>\n<td>Tools</td>\n<td>Jira</td>\n<td>Jira</td>\n</tr>\n<tr>\n<td>Information gathering</td>\n<td>Focus groups</td>\n<td>Meeting observations</td>\n</tr>\n<tr>\n<td>Conducted by</td>\n<td>Others</td>\n<td>The researcher and other</td>\n</tr>\n<tr>\n<td>Status</td>\n<td>Finished</td>\n<td>Ongoing</td>\n</tr>\n</tbody>\n</table>\n4.1.1 Omega\n\nThis section is based on the information from Andreassen [73] and Dingsøyr et al. [26]. Omega was a project both initiated and completed by Gamma, a public sector department in Norway. In Gamma it was necessary with a new office automation system and the main arguments for initiating the programme were public reform, and because the current platform was outdated. The reason for choosing the agile development methodology was because little was known about the public reform at the beginning of the project. This indicates that there were high levels of uncertainties.\n\n\n\nA little way into the project everyone was placed in the same open work area, see figure 4.1. The projects were performed across the three organizations: Alpha, Beta and Gamma. At most they were up to thirteen teams placed on different tables in the open work area, together with tables from project managements, business, architecture and test. The scrum teams mainly consisted of about eight to ten members with different roles. In\naddition to given roles, the members were cross-functional so that they could be e.g.: sixty percent tester, thirty percent developer and ten percent designer.\n\nIt is important to note that the application was recreated from an earlier version only with improvements. The outcome and the complexity would have been entirely different with a completely new application. Omega is one of the largest IT development projects in Norway to date and is considered a success.\n\n4.1.2 Tellus\n\n\n\n*Figure 4.2: An Overview of Tellus*\n\nThe Tellus project is a control- and supervision system with an iPad-application and web-based request tracking-system in the Jupiter department. The competition for the project was big and in the end the company Mars won the contract. Mars is a small company based in at least two cities in Norway, and among previous clients we can find banking in addition to several public departments. The Tellus project is the biggest individual project\nin the history of the company. The project is still ongoing and is supposed to last for about one and a half year with parts of the solution operational later in 2016, and fully operational in late 2017.\n\nThe solution will gather information from underlying registry so that workers in the Jupiter department do not have to search many systems before supervision. During supervision the iPad-application will be used to document findings. It is a requirement that this solution should be able to synchronize offline. One of the reasons Mars won was because of their choice in reusing code. This involves Mars reusing code from other deliveries from earlier and it opens up for other departments possibilities to take use of the system at a later time.\n\nMars chose to use agile development methodology for this project because of the requirement of having short time to market since the department should be friendly to changeovers. The Tellus project is conducted over one team which is divided into two squads located in different cities. The customers and product owners is again located in another city, see figure 4.2. This is some of what makes this project distributed\\footnote{Sources: official pages of the Jupiter department, regjeringen.no, digi.no, kystogfjord.no}.\n\n4.2 Success Factors\n\nIn this section we will present the findings from the two cases; Tellus and Omega. We will see both in conjunction with the factors and compared to each other.\n\n4.2.1 Agile Software Engineering Techniques and Agile Evangelist\n\nBoth the projects needed to follow agile engineering techniques because of the changing requirements of customer. For Omega they knew little of the public reform, while for Tellus it was necessary to have short time to market, and parts of the delivery operational during project duration.\n\nBoth projects used the scrum methodology with sprints. Omega had three-week sprints, while Tellus had four-week sprints. Tellus noticed the problems with these long sprints because they did not manage to plan that far ahead.\n\n\"It is hard to plan a whole month ahead since it does not get correctly synchronized with Jira.\"\n\nDeveloper at Tellus\n\nThey eventually decided to divide the sprint into two parts; a and b. Another change they made was instead of detailing the tasks together, each developer got to detail their own tasks. This was to make sure they did not have to work on several tasks that belonged together, but only one task at a time. At the Omega-project they did some scrumban/kanban which meant that they needed to finish one task before starting another.\nAt Omega they had agile evangelists and people were willing to do an effort to be agile. They took courses to learn the techniques and everyone was eager to soak up more knowledge. This was because there were few who had had agile experience before entering the project. For the Tellus-project it is not known whether they were coursed during the project, but they saw that they did not do the backlog grooming according to the book during one of the observations. This did not only apply to the team, but to the product owners who were not good at prioritizing.\n\nOmega were big users of pair programming in their project. Beta introduced it, and soon all teams were doing it. The goal was for everyone to have programmed with everyone so that it was possible to create a line between everyone in a team. This was a hit which ensured everyone on the team acquired knowledge from everyone, and that the coding resembled. They therefore tried pair programming across teams, but that was not a success. The pair programming was good when bringing new people into the project, but later in the project several people started programming alone.\n\n### 4.2.2 Responding to Change\n\nWhen it came to responding to change this was easier for the researcher to notice in the Tellus-project since that was still ongoing, while Omega was finished. From what the researcher observed they were good at taking action when necessary. The case that all meetings observed were completed in different ways each time display that they were able to see the need for change. They also decided on a new way of dividing up the tasks in a sprint. This was eventually up to the developer working on it. This was a way of making sure that there were not several subtasks that needed to be implemented simultaneously which could lead to a developer having several unfinished tasks. In addition they decided to divide the sprint into two parts when they saw difficulties with planning for four weeks.\n\nWhole team thinking can also be found in this factor. After dividing the sprint into two parts because of the planning difficulties at Tellus they decided to have a common burndown chart for both squads in each sprint. At Omega they made sure to change the arenas when they saw that some arenas did not work, more on that can be seen in section 4.2.5.\n\n### 4.2.3 The Team\n\nThe team members at the Omega-project did not necessarily have much agile experience. Because of this they might not have been so determined when it came to self-organizing in the team, because they from the start knew that the project involved several teams working together. They did have people who were interested in learning about agile, which implied that they should learn while doing, and then customize to their project, and not agile projects in general. It is not known how much agile experience there is in the Tellus-project, but with the increase in agile methodology it is likely that some have experience. At Tellus they prefer to look at themselves as one team with two squads rather than two teams. This helps with the whole team thinking as well.\nAt Omega they mentioned the disadvantage with big projects which is that there are always people coming and going. Instead of creating new teams with the new people they made sure to separate those experienced so that everyone could be on a team with someone experienced with the project. The teams were more specialized in the beginning of the project. At Tellus it was the locations that decided where people were put. In addition they saw a problem with people coming and going, even though their project was smaller than the Omega case.\n\nAt Tellus they had a problem with not having a good feeling in the project and low achievement in sprints. This lead to lack of ownership in the project.\n\n\"I really feel like we all want it so bad, but we are more or less frustrated by the fact that things are moving slow, and we feel like we are still at the beginning after five months.\"\nDeveloper at Tellus\n\nThey all saw that they had potential, but they were struggling with acknowledging the results for themselves. At Omega their biggest problem were the fact that not everyone was happy when it was necessary to rotate the teams. The teams were very self-organizing and the people felt more like they were working at Gamma because of the time spent there compared to where they originally came from.\n\nOmega had many different arenas for people with certain roles. This is because of the size of the project. This can be compared to whole team thinking because people needed to spend time outside of their team to ensure that the different pieces of the project could fit together. For Tellus, a much smaller project, this was not observed, but probably it did not take much time from other duties.\n\n4.2.4 Leadership\n\nThe leadership in the two projects were very different. At Omega there was more of a hierarchy because of the size of the project, while it was not that visible from only meeting observations at Tellus. In the meetings at Tellus there were someone that usually took control, but this control was sometimes divided between several persons. They normally did not have a structured plan of what they should go through and they did not have a secretary, or someone to write down important aspects that came up during the meetings. This was however implemented in one of the last meetings observed, by someone making a list of what everyone should do until next time.\n\nAt Omega they had project management teams and different kinds of leaders like scrum master and others. Even though project management was not in the teams they were visible and showed interest.\n\n\"Just management by walking around, talking around.\"\nProject management at Alpha\nThey visited the teams at least once a day and had the opportunity of watching the boards, which made it easy to see if there were tasks that they struggled with.\n\nThe leaders at Omega were also responsible for making sure that the teams did not only care for themselves. This was illustrated by the leaders trying to encourage everyone to help each other before being asked to help. They often knew if someone was working on something they had knowledge about. This was one of the methods the leaders used to ensure whole team thinking in the project. It was much easier for the leaders to see the whole project which is why they were responsible for providing the way of thinking down to the teams.\n\n4.2.5 Bridgehead\n\nA bridgehead is a way of coordinating what happens at different teams in a project. For the Tellus-project a lot of the meetings are conducted together with both squads and sometimes together with the product owner group, all known arenas can be seen in table 4.2. At the Omega-project they had several different types of arenas to communicate the project to the others, all can be seen in table 4.3 [26]. These arenas helped coordinate the project and ensure that the project in the end was one product and not several different pieces. The arenas were a way of securing the whole team thinking through the whole project.\n\n<table>\n<thead>\n<tr>\n<th>Arena</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Demo</td>\n<td>Demonstration of developed user stories where everyone could participate</td>\n</tr>\n<tr>\n<td>Backlog grooming</td>\n<td>Completed together with product owner and important people from both Saturn and Venus</td>\n</tr>\n<tr>\n<td>Sprint planning</td>\n<td>These have been conducted both in the squads, with both squads and with both squads together with the product owner</td>\n</tr>\n<tr>\n<td>Retrospectives</td>\n<td>Have been completed together with both squads</td>\n</tr>\n<tr>\n<td>Tech talks</td>\n<td>Weekly between the teams</td>\n</tr>\n<tr>\n<td>Wiki</td>\n<td>Different documentations like architectural guidelines, team routines and retrospective reports were documented in the project wiki</td>\n</tr>\n<tr>\n<td>Jira</td>\n<td>Tool for managing the backlog and setting tasks and see burn-downcharts</td>\n</tr>\n<tr>\n<td>Live-feed</td>\n<td>Both squads have live-feed of the other to feel closer to each other</td>\n</tr>\n</tbody>\n</table>\n\nAt Omega the arenas changed over time after what worked best. They were user-controlled, which implies that when they did not find an arena necessary they ended it, which opened up for other arenas. Since Tellus is still an ongoing project it is not easy to know how things will develop later. From what was seen in the observations they changed.\n### Table 4.3: The Different Arenas in Omega\n\n<table>\n<thead>\n<tr>\n<th>Arena</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Demo</td>\n<td>Demonstration of developed user stories where everyone could participate</td>\n</tr>\n<tr>\n<td>Experience forum</td>\n<td>A forum at subcontractor Alpha for scrum masters, development manager and agile coach focusing on development method</td>\n</tr>\n<tr>\n<td>Instant messaging</td>\n<td>Used for open technical questions and social activities like wine lottery</td>\n</tr>\n<tr>\n<td>Lunch seminar</td>\n<td>Seminar with two or three short presentations during lunch on topics like architectural components, project management or on how to follow up a team</td>\n</tr>\n<tr>\n<td>Metascrum</td>\n<td>Two meetings per week with project managers from development, architecture, test and business projects, as well as sub-project managers from the development projects</td>\n</tr>\n<tr>\n<td>Open space technology</td>\n<td>Process where all participants suggested topics for discussion where participants were free to join discussion groups of interest</td>\n</tr>\n<tr>\n<td>Retrospectives</td>\n<td>Used mainly on team level, but also on subproject level at times. All were documented in wiki so everyone could see</td>\n</tr>\n<tr>\n<td>Scrum of scrums</td>\n<td>All three subprojects had scrum of scrums with their teams two or three times a week. Scrum masters and project managers attended, and sometimes others like product owners and test managers</td>\n</tr>\n<tr>\n<td>Technical corner</td>\n<td>Architectural briefings in the subprojects at Beta, where team architects briefed the team</td>\n</tr>\n<tr>\n<td>Wiki</td>\n<td>Different documentations like architectural guidelines, team routines and retrospective reports were documented in the project wiki</td>\n</tr>\n<tr>\n<td>Rotation of team members</td>\n<td>Members were sometimes rotated between teams</td>\n</tr>\n<tr>\n<td>Open Work area</td>\n<td>The project with all teams was situated in an open-plan office space on one floor</td>\n</tr>\n<tr>\n<td>Masterplan</td>\n<td>The programme established a common product backlog as a master plan, with 2,500 user stories organized in 300 epics</td>\n</tr>\n<tr>\n<td>Stand-up</td>\n<td>The time of stand-up was set so it was possible to visit others teams’ stand-up</td>\n</tr>\n</tbody>\n</table>\ntheir arenas continuously. The first sprint planning was just in the squad, while the other were divided into three parts with one part with product owner, one within each squad and one with the whole team, in other words with both squads present.\n\nAt Omega they saw a shift from formal arenas into informal arenas:\n\n\"I imagine that those arenas are more important at the beginning, but it becomes less important when you get to know each other and get used to going over to talk to the person you know can help you.\"\n\nPerson from Beta\n\nThese informal or unofficial forums like joint coffee-breaks etc. appeared to become automatic after a while. At Tellus on the other hand, it is not easy having informal arenas since they are situated in different locations.\n\nThere were some problems at both projects when it came to some types of arenas. At Tellus they discussed the fact that the retrospectives should be conducted face to face, rather than over video. This was to be able to be closer to each other. At Omega they noticed that it was hard to get everyone on the same level in the metascrum. Some people used more time than the ten minutes which were intended for each, and detailed more than necessary. This resulted in some waisted time since it was not all detailed information which was necessary for everyone.\n\n4.2.6 Co-Location\n\nBoth of these two projects chose entirely different when it came to where the teams were placed. At Omega they chose to co-locate everyone in an open work space area. This included project management and product owner, or functional experts, which were placed in the same room. In Tellus they chose a completely different practice and worked distributed within the teams, or squads as they called them. They were not only in different locations but also in different cities. This included the product owners which did not sit with any of the squads, but in another city. From the time they were all put at the same location at Omega, everyone was one hundred percent with their team, while at Tellus they had one team member that did not sit with everyone else.\n\nBecause of the distance between the teams in Tellus they have put up a video live-feed over the offices so that they can see each other all day long. At one point during the project one squad, Saturn, lost the others feed. While they were interested in getting it back, the other squad, Venus, did not really see the point because they did not feel like they were dependent on the other squad.\n\n\"I think that Saturn is more concerned about it than Venus is.\"\n\nDeveloper at Venus\n\n\"That is because the arrow of dependencies goes that way [Saturn dependent on Venus].\"\n\nDeveloper at Venus\nIn the end they agreed to fix the TV.\n\nAt Omega the fact that they were all located in the same room was important. This was because it opened up for more informal communication arenas, and it made the work easier for management. When they saw a team struggling they could just go up and help right away, instead of not knowing about the struggle.\n\n\"That with being in the same open space I think was an important factor here. This is something I notice now at Zeta, where we do not have this one space.\"\n\nProject management at Alpha\n\nIn the Tellus case they saw the necessity to work together at the same location, especially when working on tasks with dependencies to the other squad.\n\n\"I feel that all I have done these last two weeks are coordinating [...]. I feel that I got a lot more from the ten to fifteen minutes where we booked a meeting room than I have gotten [from other platforms].\"\n\nDeveloper at Saturn\n\nThey discussed the fact that it might be necessary for more traveling between locations. The only problem is that it requires money from the budget so it is important to decide what to prioritize.\n\nBoth projects saw the fact that it was much easier when having somebody to help. To acquire good answers to questions, when possible it should be conducted face to face, rather than sending mails or using other tools.\n\n\"What is important in agile, is that you are to deliver something in three weeks. Then you do not have the time to wait for someone to read all their mail before getting to the one you sent two weeks ago, because that is at the bottom of the list. You have to go there and ask for attention. You might not get the answer in ten seconds, but for him to open the mail, read it and answer, that takes time.\"\n\nProject management at Alpha\n\nIt takes a lot less time when getting hold of the person and asking the question, than waiting for an answer which may never come.\n\nWhen it comes to whole team thinking in this factor the fact that Tellus had a live-feed ensured that it was easier to collaborate because they were able to see if the person they needed to be in contact with were available. For Omega this could be accomplished by checking the open work space. This was less time-consuming than having to wait for answers on chat or mail which ensures that everyone is more effective in the project.\n\n4.2.7 Product Owner\n\nThere is a big difference in the product owner at both Tellus and Omega. At Omega the product owner was active and used its best people.\n4.2 Success Factors\n\n\"It is really a success criteria - take the best people and give them authority and responsibility.\"\n\nProject management at Alpha\n\nThe customer used their best business architects in the project and they were put in the same open work space ninety-five percent of their time. In eight out of ten situations they were able to take a decision then and there. In Tellus at the other hand the customer is situated in another city than the team. This complicates things when there are questions that require answers.\n\nAt Tellus they are struggling with the product owner not knowing what it entails when being a part of an agile project. They do not have the information ready, they have to be constantly reminded of what they should do and they do not prioritize. Since Gamma is a part of the development in Omega, and have been involved in choosing the agile development methodology they seem to have had an understanding of what is required by the customer.\n\nThere were three levels of product owners in Omega. There were one at the top, one for each of the suppliers, and functional experts.\n\n\"My experience of our product owner was that he was more of an administrator, that was formally the product owner role, but the functional experts were essential since they had a strong connection to the project, and that I think was crucial for the project going that well.\"\n\nDeveloper at Gamma\n\nIt was important in a project that big to have several product owners and they were good to come up with defined tasks. At Tellus they had a product owner group with people responsible for the different parts of the project.\n\nAccording to the observations at Tellus they were happy with their product owner and felt that they appeared to be open and trusting. They were also good at answering when it came to technical issues. The problem was that it did not seem like they had the authority to make snap decisions, or that they talk to each other. In some meetings they disagreed with each other, and these are things they should have dealt with before, and not during the meeting. It was apparent that the product owner could be somewhat unclear and was missing presence.\n\n\"Overall they are reactive and not proactive. We need to give them concrete tasks constantly and then we need to remind them a couple of times before it goes quiet.\"\n\nDeveloper at Tellus\n\nThe team struggled with having to wait for the requirements specification before conducting some of the development tasks.\n\nBoth of the projects have several POs, which can make it difficult when they do not think about whole team thinking. At Tellus they did not seem to talk together which implies that they did not display a united front to the teams. Since they did not have a united\nfront they also struggled with prioritizing, which made it harder for the team to know what to produce when. The hierarchy at Omega ensured that there were always someone with the knowledge and authority which indicates that it was less time-consuming because they were all aware of the whole project in the end.\n\n### 4.2.8 Whole Team Thinking\n\nBoth of the projects had several teams or squads. In both the observations and in the focus groups they spoke as though the teams were separated in “us” versus “them”. In Omega the teams experienced great team spirit with team names, effects, cheers etc. It was obvious that everyone was more committed to their team and not the project itself. The priorities was to do things for the team first, and if there was more time, that could be used to help other teams.\n\nWhen it came to the burndowncharts Tellus eventually decided to have a joint burn-downchart per mini-sprint. It then appears that they had had separate charts earlier. At Omega they had burndowns per team which might have had a connection to the competition between the teams. When they noticed this they removed the visible burndowns.\n\n> \"We tried to run the focus to the fact that we are one provider, and what we deliver we deliver together.\"\n\nProject management at Beta\n\nThey saw that how much each team delivered did not matter as long as the cooperation of the total delivery was good. This was probably one of the reasons for Tellus to choose a joint burndownchart.\n\nWhen there was a problem in Omega because of dependencies between the teams people were quick to judge the other teams. This was resolved with someone from each team being put together to solve the problem together. This helped with the fact that people could no longer blame each other. Omega was also proactive when it came to dependencies and had regular dependency-meetings. At Tellus they were not that proactive when it came to dependencies. They lacked structure in both planning and meetings, which led to them not always being able to go through all tasks and see if there are any dependencies. It was simply not prioritized enough to find the dependencies so they could discuss with the other squad. When both squads were together in the meeting they did not spend much time on discussing the dependencies they had found, if they had found any at all. In addition it was apparent that Venus believed that it was only Saturn who had use of the video live-feed between the offices.\n\nAnother thing at Omega was that the teams that did not depend on other teams, did not bother to deal with anyone else. There were only the teams with common dependencies, or working on the same things, which communicated with each other.\n\n> \"The way everything is build and stitched together makes it painful when working together so they simply did not have any other choice than to talk\n4.2 Success Factors\n\nTogether to find a solution.”\nTeam architect at Gamma\n\nAt Tellus they saw the same problems and the need to talk together when working on the same problems. There they also saw the necessity of working closer together, in other words being in the same location when working on the same objects.\n\nOne of the biggest problems with being able to do whole team thinking was the contracts. For everyone it was more important to deliver what was in the contract, than thinking of the project as a whole. They did however see that there is no winner, either everyone do well, or everyone do poorly.\n\n\"Seeing yourself in a bigger picture. We struggled there...”\nProject management at Beta\n\nFor Tellus which have only one contract together this is different. They had selected to do the project distributed, but they still remained one team. Here they just had to be better at not only saying that they are one team, but also think it. The different squads usually use the words “us” and ”them” which inhibits their actual meaning.\n\nAt Omega there was said that if a team saw that they were able to finish their tasks, they should speak up and take some tasks from those not so lucky. This was to better help each other out. Another item which was brought up was for everyone to be more proactive when it came to helping each other. This applied particularly when they knew that someone would require their help. In most cases it appeared that everyone was more reactive and only helped after being asked. The management did do their best to get everyone to think more for the whole project than only their own part. For Tellus it was obvious that later in the sprints the Saturn office did not have as much tasks as Venus. This was discovered early and Venus were more than happy to provide Saturn with more tasks. The division of tasks or main components divided earlier could have been somewhat premature and it might be something that should be implemented more frequently.\nDiscussion\n\nIn the discussion chapter the findings from the results chapter will be discussed. We will discuss these results according to the research question and together with Strode’s implicit coordination factors. In the end we will evaluate this study both according to Klein and Myers and if the cases were agile.\n\n5.1 Research Question and Success Factors\n\nIn this section we will first present the research question before discussing the results from the success factors in regards to the research question. In the end we will give a brief summary of the findings.\n\n5.1.1 Research Question\n\nNow that we have seen some of the results from the two cases it is important to see it in regards to the research question and the theory. The original research question was this:\n\nWhat are the possible success factors in large scale agile development?\n\nSince this subject would be to broad for a master thesis it has been narrowed down to this:\n\nIs whole team thinking a possible success factor in large scale agile development?\n\nThe discussion here will primarily revolve around the research question and the results from the observations and interviews for the two different cases; Omega and Tellus.\n\nIf we were to explore the other possible success factors we found in the two cases, mentioned in chapter 4 there would be necessary to explore these fields further. This is why we will see them together with the whole team thinking factor. Several of the factors can be seen in regards to whole team thinking.\n5.1.2 Responding to Change\n\nWhen it comes to responding to change we can see from both cases that they at times saw that it was necessary to focus on the whole team and not just the teams separately. At Tellus they decided to have a common burndownchart instead of one per squad, this can be seen as a first-order change [34]. They are after all working toward the same goal. This was not the only thing they decided to have common for the teams:\n\n\"Then we agreed to make one overall picture. At least to describe the most important components and how they interrelate.\"\nMeeting leader at Tellus\n\nAt Omega they tried to encourage everyone to help each other and they found new arenas where they could collaborate. When they saw that the need for one arena disappeared, they let it go instead of insisting on using people’s time when they not did believe it was the right way to go, this can be seen as a second-order change [34]. They saw what the requirements was for the teams to collaborate and used it to improve at all times for the project to go as smoothly as possible.\n\n5.1.3 The Team\n\nIn section 2.3.5 we read that Moore and Spens [49] concluded with that it is not necessary to base the hiring of people on agile experience when working in large scale projects. This is because people who are used to agile might not thrive in a large scale environment. At Omega there were several people who were not acquainted with agile methodology. This probably had something to do with the fact that the project was started in 2008, but still it showed that it is not necessary with agile experience. Everyone at Omega were eager to learn about agile and they spent time to improve themselves. The reason that it might not be necessary with agile experience in large scale projects is because it is more important that people remember they are only one of several teams working on the same project.\n\nWith a growing number of teams and people it is necessary to spend more time outside the teams, also proposed by Moore and Spens [49]. This is to make sure that everything in the project is going according to plan. Without these extra meetings there are several questions that never will be answered. When observing at Tellus it was obvious that several of the members needed to spend much more time in meetings than with their squad. This was something mentioned at Omega where there was even more necessary to spend time outside the teams. This could be seen by this quote from Alpha:\n\n\"As an employee at Alpha I had in longer periods no feeling of being an Alpha-employee. This was where I was. And in periods - both here and in other projects - where there is so much overtime that you cannot attend Alpha-arrangements you do feel more like a Gamma-employee.\"\nTeam architect at Alpha\n\nIt was necessary to spend time outside the team to get a better overview of the project. It was why people felt more at home at Gamma since they spent all their time there. This is something that probably made everyone feel more comfortable with each other and not\nthinking so much about the fact that they were from several suppliers since they all worked at the same place.\n\n5.1.4 Leadership\n\nLeadership was important when recognizing the importance of the teams to think as one unit and not as separate parts in the project. This can be seen by one of the behaviours presented by Moore: driving both team and project success [52]. Without good leaders who acknowledge the problems and make it their mission to handle the problems, it is not possible for the teams to understand they are only one part of the project. The leaders are the ones who are able to see the project as a whole, which makes it necessary for them to communicate this to their teams.\n\n“You want people to be able to handle it at the lowest level possible. But maybe it is necessary to communicate more with regards to project management that this is one project, and the important items are this and that, and get rid of the mental blockage that we first need to think about ourselves and then maybe help or support others, or ask others for help.”\n\nProject management at Beta\n\nAt Omega they tried to remind everyone that it was necessary to help each other. They also made sure to prioritize and explain when other teams’ tasks was important to prioritize over others. If they had not done that the people in less prioritized teams would have been displeased. At Tellus they did not seem to have very clear leadership in meetings, but they were good at involving everyone which caused them to more conveniently see the bigger picture.\n\n5.1.5 Bridgehead\n\nThe bridgehead is necessary so the teams know where they all are at, also called coordinating [41]. They are all supposed to deliver something together, and if they are not coordinated, this would be extremely hard. At Omega they had several arenas for discussing parts of the project and updating each other where they all were at. An example are the scrum of scrums which Paasivara et al. [56] concluded with worked poorly, but in this project worked pretty good [26]. They had meetings where they mapped the dependencies so everyone knew which teams they were required to have contact with.\n\n”It has been controlled by what people wanted to discuss, in the end there were no more themes requested and it was dropped. The project management did not invent several themes just to keep it. They were kind of user-controlled.”\n\nTeam architect at Alpha\n\nAt Tellus they had joint meetings for the same reasons as at Omega. This made it possible to see early if they were dependent on each other in cases and who should cooperate more. Without all these arenas the projects could face issues with a failed final product with parts that could not communicate. It is necessary for communication and collaboration between all teams, whole team thinking, when there are several teams and people involved.\n5.1.6 Co-Location\n\nWithout co-location, people always have to consider that they are not the only ones working on the project and understand the need for cooperating. This is necessary even when you do not see the ones you have to cooperate with. At Tellus this is an important aspect and it is why they put up a video live-feed. This simplifies the fact that you can check if the one you require is actually available or not. At Omega they saw that when everyone were acquainted they did not have a problem with going to the person and ask when necessary instead of sending a mail and waiting for an answer. It was easier to go outside their own teams. This is one of the aspects when you see that people understand the fact that they are not alone on the project.\n\n5.1.7 Product Owner\n\nIn large scale it is necessary to scale up the product owner because it is difficult for one person to be responsible for several teams [31]. It is difficult to find one product owner who is familiar with every aspect of the project. At Tellus they had a main (chief) product owner and a product owner group, just like at SAP [5]. This was necessary to ensure that all necessary parts of the project were preserved. At Omega they had a hierarchy of product owners which achieved the fact that every team had access to persons with authority and responsibility. This ensured that everyone was able to make a satisfactory product in the end.\n\n\"It is really a success criteria - take the best people and give them authority and responsibility.\"\n\nProject management at Alpha\n\nIf the product owners did not prioritize they would have made it more difficult for the teams to choose which tasks is important. This again could result in a failed solution. If the product owner does not think about the bigger picture, it is hard for the supplier to think of the bigger picture and the fact that they are all one team. This can be noticed if one in the product owner group believes that their part of the product is the most important one.\n\n5.1.8 Whole Team Thinking\n\nAs we have seen from the two cases whole team thinking is a subject which is often brought up. This does not indicate that it is presented in those words but we can read it between the lines.\n\n\"If one can help someone else deliver something more important, that would be better. Maybe even if we could help someone at Alpha or Gamma to deliver something which is more important, that would actually be better. Seeing yourself in a bigger picture. We struggled there... We did not do anything about it and understood that for the teams it was more important to deliver what was written in the contract.\"\n\nProject management at Beta\nThis can also be viewed by how they talk about the different teams. There is much mentioning of \"us\" versus \"them\", and the way the teams distinguish themselves from each other. Because the teams are measured individually instead of together it is necessary for each team to think of themselves, or their own part as proposed by Larman and Vodde [40]. When the burndown charts and other measuring components were removed at Omega, and were no longer visible, it was easier for the teams to not think of the others as competition. This is probably why Tellus chose to have a joint burndown chart. They are after all working toward the same goal and if one team delivers and the other does not it is still the project in whole that suffers.\n\nWhole team thinking, or shared mental models, is when someone work together with the same goals or philosophical mindsets [50]. In one team this is easier to accomplish than with several teams working on the same project. The different teams all have their own goals and work toward them. The problem is not that they have their own goals, the problem is when they forget that they are not the only ones in the project. It is therefore necessary to remember that what they are working on probably would have to compile with what the other teams do.\n\nThe dependency problem is a big one when it comes to several teams on the same project. As we have read from the theory, sometimes people just downgrade the problems and put them on hold, just like in the paper by Martini et al. [41]. The problem then is that the problems increase. From Omega we could see that people started blaming each other for the problems. This is why they put the people from the different teams together to try to resolve the problems together. When they did work together they did not have anyone other than themselves to blame.\n\n\"There is one thing I remember where we had the most problems finishing something, there was a lot of things going on and in the end we just needed to take one developer from each team and put them together [...]. In other words finding the entirety together.”\n\nHead of development at Alpha\n\nAt Tellus they did not appear to be that proactive when it came to the dependencies, which is why they might have some problems delivering in the sprints. There is a big difference in how Omega and Tellus handled the dependencies, and it shows that with a bigger project they are better at being proactive, because it is that much harder when they are not aware at the beginning. At Tellus on the other hand they are only two squads, which may be the reason why they do not spend more time. This is probably because they believe that when the dependencies arise, they will not be that big of a problem.\n\nThe division of tasks in large scale is difficult, not only because there is no way of knowing exactly how much job every task will require, but also because of the level of competence in the different teams. At Omega they tried to solve this by having the teams that knew they were able to finish their tasks to take some from those who did not think they would finish. Since Tellus is of much smaller scale they can divide the tasks more when they see the need for it because it is easier for them to have a complete overview of project and tasks.\n\"Saturn struggles in 7b with few tasks and needs more work, but if you only generate four days there is not much point if it leads to more work for you.\"\nSaturn developer\n\nBecause of the better overview at Tellus it is therefore easier to discuss further work together.\n\nAs presented earlier we can see from the way everyone talks that there is a division between the teams. At Omega this also applies to the different suppliers in the project, while at Tellus it applies to the different locations. In both the observation notes at Tellus and in the focus group interviews at Omega there is much \"us\" versus \"them\". At Omega where the teams had their own names, cheers and people were resistant to switch teams this was easy to see. This kind of talk might be something of what separates the teams in the project from each other. This is especially a problem since it comes from project management, which is the case for several of the people in the focus groups from Omega. At Tellus we could see that they do their best to be one team with two squads, while at Omega they saw themselves that it was necessary to explain that they are all working on the same project. This was to ensure the fostering of shared mental models [64]. These are ideas that help the shared mental model overall, or as it is called here, the whole team thinking.\n\n5.1.9 Summary\n\nWhat can be seen from all this is that there are definitely some things that could be defined as success factors when it comes to large scale agile development. In addition we can see from the two different cases that there are several differences in how they approached these possible success factors. When it comes to location Omega is co-located while Tellus is distributed, which is the most prominent difference between the two in addition to the size. Other differences are the teams; where Omega had several teams, while Tellus had one team which consisted of two squads, and the product owners where Omega had a hierarchy with functional experts with authority, and Tellus had a product owner group where they did not appear to always have the authority. We can see clearly that some of the possible success factors are specifically mentioned both in observations and focus groups without asking for it in particular. All found success factors for the cases are listed in table 5.1. NF implies that the factor is not found while S implies that it is found in some degree, but not so much that it is presented here.\n\nWe have discovered that several of the possible success factors can be seen as a remedy for whole team thinking and shared mental models. We can link the different success factors together by seeing what they have in common. As we can see from table 5.1 not all factors are found in both or any of the cases. Since there was observations at Tellus, it was not possible to ask about the different factors. At Omega the researcher was not involved, which is why it was not possible to ask for more information about them.\n\nIt would be hard trying to replicate these two cases for research. This has to do with the fact that no project is the same and that there always will be a difference in the knowledge\n5.1 Research Question and Success Factors\n\nTable 5.1: Success Factors Applicable Found in the Cases: Y= found, S= found in some degree, NF = not found\n\n<table>\n<thead>\n<tr>\n<th>Success factor</th>\n<th>Omega</th>\n<th>Tellus</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Customer collaboration</td>\n<td>S</td>\n<td>NF</td>\n</tr>\n<tr>\n<td>Agile software engineering techniques and agile evangelist</td>\n<td>Y</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Responding to change</td>\n<td>Y</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Team</td>\n<td>Y</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Leadership</td>\n<td>Y</td>\n<td>S</td>\n</tr>\n<tr>\n<td>Planning</td>\n<td>Y</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Testing</td>\n<td>Y</td>\n<td>S</td>\n</tr>\n<tr>\n<td>Governance</td>\n<td>NF</td>\n<td>NF</td>\n</tr>\n<tr>\n<td>Divide after you conquer</td>\n<td>NF</td>\n<td>NF</td>\n</tr>\n<tr>\n<td>Continuous integration</td>\n<td>NF</td>\n<td>NF</td>\n</tr>\n<tr>\n<td>Bridgehead</td>\n<td>Y</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Co-location</td>\n<td>Y</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>Y</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Whole team thinking</td>\n<td>Y</td>\n<td>Y</td>\n</tr>\n</tbody>\n</table>\n\nand capacity of team members. Another is the fact that there were certain limitations like the time limit, restriction of resources for the two cases, and the fact that this is mostly based on the interpretations of the researcher. When it comes to Omega this was also one of the first large scale agile projects, and not everyone were that familiar with agile as they might be now.\n\n\"We have recreated a lot of the same later. But there is a discussion of how successful it has been. There is also a matter of the governing conditions and settings where you try to recreate it. We have discussed the ability that people can take decisions on the spot, this is not possible everywhere.\"\n\nHead of development at Alpha\n\nStrode and Whole Team Thinking\n\nIn the theory chapter, chapter 2, we explained why whole team thinking is important and we looked more closely on Strode’s components for implicit coordination effectiveness, see 2.4.3. In table 5.2 and 5.3 we have the findings from Omega and Tellus in conjunction with the components of Strode.\n\nAs we can see from the tables it was easier for Tellus to have an overview over these five components. This is probably because of the fact that they were so few people in relation to Omega. At Omega the components were easier fulfilled for each supplier than the overall project. This might have had something to do with the fact that they were focused on following the contracts. The last component, know who knows what, was difficult to answer for both projects. At Tellus there were only meetings observed, and\nTable 5.2: Strode’s Implicit Coordination Factors for Omega\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Omega</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Know why</td>\n<td>The project management was aware of the overall goal and how tasks contributed to the overall goal. The team members became aware eventually, first aware of the supplier and their goal, and eventually the whole project and the overall goal</td>\n</tr>\n<tr>\n<td>Know what is going on and when</td>\n<td>Each individual had the opportunity to see the burn-downchart of other teams, and were aware of what was in their contracts, but it did not seem like they knew about all tasks in the project overall</td>\n</tr>\n<tr>\n<td>Know what do to and when</td>\n<td>They were to be aware of which tasks that should be prioritized, and they helped other teams when they had little to do, but they seemed to prioritize their team and supplier before the overall project</td>\n</tr>\n<tr>\n<td>Know who is doing what</td>\n<td>The team members were mostly aware of tasks the other team members or their supplier worked on. After a while they also knew if someone worked on something they had worked on previously</td>\n</tr>\n<tr>\n<td>Know who knows what</td>\n<td>This is not easy to see from the interviews, but they were aware of which supplier which had the responsibility of the different components</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.3: Strode’s Implicit Coordination Factors for Tellus\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Tellus</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Know why</td>\n<td>At Tellus it seemed like everyone was aware of the overall project goal and how tasks contributed to this through several discussions on dependencies</td>\n</tr>\n<tr>\n<td>Know what is going on and when</td>\n<td>Everyone were aware of all tasks in the backlog and were able to see the burn-downchart and which squad were responsible for what</td>\n</tr>\n<tr>\n<td>Know what do to and when</td>\n<td>At one point Saturn did not have many tasks for the next sprint that were important to the project and therefore decided to help with Venus’s tasks</td>\n</tr>\n<tr>\n<td>Know who is doing what</td>\n<td>Because there were few people it was easy for everyone to know who did what</td>\n</tr>\n<tr>\n<td>Know who knows what</td>\n<td>This was not possible to observe, but it seemed like they knew where to find the knowledge required</td>\n</tr>\n</tbody>\n</table>\nsince this was not mentioned it is difficult to conclude something. At Omega there were so many people involved which makes it difficult, but they probably had an idea of who to ask because of the components they were responsible for.\n\n### 5.2 Evaluation of the Study\n\nBefore concluding this study it is important to evaluate it. This is conducted by the researcher. The reason for doing this is to give an understanding about the research, especially the cases chosen. It is therefore important to build confidence and credibility in the study and the researcher. The research process will be discussed together with the principles of Klein and Myers before discussing if the cases are agile.\n\n#### 5.2.1 Research Process\n\nThis is a master thesis with a timeframe of 20 weeks. Because of these time constraints the researcher had to use material from the Omega case that had been conducted previously by other researchers. The researcher had to sign a non disclosure agreement, and was only given three focus group interviews in addition to background information in two other papers. When it came to Tellus, the researcher was able to observe four meetings, while another student had observed two additional meetings the researcher gained access to. The researcher could probably have observed additional meetings, but then there would have been less time to review the cases and comparing them. It would have been beneficial if there had been the possibility of interviews which could have given the researcher more information about the subject at hand.\n\n#### Klein and Myers Principles\n\nIf we see this study together with Klein and Myers principles of interpretive field we can look more closely on the study conducted. The results can be seen in table 5.4.\n\n#### 5.2.2 Generalisation\n\nThe development at Omega was based on producing a new system with all functionalities of the old system with improvements because the old system was being phased out. It was therefore unique since everyone was located in not only the same building but the same room. There were several different suppliers in this project which had to work together. The fact that many were new to agile methodology is also an important aspect because of the rise in agile practitioners. At Tellus they were mostly creating a new system, with the reuse of code from other projects. The team is divided into two squads and they work distributed. There is only one supplier involved. For the sake of generalising the projects, the researcher believe that Tellus is the project which most easily can be generalised, but in both projects there should be possible to discover somewhat the same factors in other large scale agile projects.\nTable 5.4: The Researcher’s Use of the Principles of Klein and Myers\n\n<table>\n<thead>\n<tr>\n<th>Principle</th>\n<th>How the principles were used</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>The fundamental principle of the hermeneutic circle</td>\n<td>The different cases were first seen together with the theory and then compared with each other. For each of the different success factors the cases and situations in them were described.</td>\n</tr>\n<tr>\n<td>The principle of contextualization</td>\n<td>Information on both cases and the reason for these projects is given by the researcher.</td>\n</tr>\n<tr>\n<td>The principle of interaction between the researcher and subjects</td>\n<td>The researchers understanding of the cases was developed through observations; Tellus, and interviews conducted by other researchers; Omega. A presentation was also held for Tellus where the subject agreed on the findings from the researcher.</td>\n</tr>\n<tr>\n<td>The principle of abstraction and generalization</td>\n<td>The findings are explained together with previous success factors presented in theory.</td>\n</tr>\n<tr>\n<td>The principle of dialogical reasoning</td>\n<td>The researcher have investigated whether or not the aforementioned success factors can be seen in the cases and how they have affected the cases, both in positive and negative.</td>\n</tr>\n<tr>\n<td>The principle of multiple interpretations</td>\n<td>At Tellus all research comes from observations and is therefore from the assumptions of the researcher. At Omega the interviews have been completed after the project finished and with people from different teams that have had different roles during the project duration. The interviews were conducted by other researchers that have had other research than this in mind.</td>\n</tr>\n<tr>\n<td>The principle of suspicion</td>\n<td>At Tellus all views come from the researchers point of view, and other people could see things in a different manner. At Omega the interviews were with people on different teams and with different roles, but because of the size of the project it is not clear if the meanings expressed here are the meanings of the majority.</td>\n</tr>\n</tbody>\n</table>\n5.2 Evaluation of the Study\n\n5.2.3 Are the Cases Agile?\n\nAccording to Ambler [6] there are five criterias that decide if you are really agile. The first criteria considers whether the agile teams provide value to their customers on a regular basis. At Omega they were located together with regular meetings like demos. At Tellus they had regular backlog grooming meetings in addition to demos. Both projects therefore fulfill the value criteria.\n\nThe second criteria is that agile teams should do continuous developer regression testing and that they should take a test driven development approach. This approach is not mentioned in either of the two cases, but we do know that at Omega they either have specialized testers or developers who also conducted the testing. The conclusion is therefore that Omega fulfills the validation criteria. At Tellus testing is not much mentioned and therefore it is unknown whether this criteria is fulfilled.\n\nThe third criteria involves the agile teams to work closely with their stakeholders, ideally on a daily basis. At Omega there were stakeholders present at all times and there was no problem to obtain them. At Tellus we know they had regular meetings, and from the observation we can read that they sometimes had contact with stakeholders through other means. Since we do not have the complete understanding for Tellus we are not one hundred percent sure if this is correct, but we know it is correct in some degree. For Omega we know that the criteria is fulfilled.\n\nSelf-organization is the fourth criteria. At Omega there was said that all teams were self-organizing and even though it was encouraged to pair program, each team was able to decide for themselves. At Tellus the team is divided into two squads. From the observations it would appear like the squads are self-organized with e.g. own sprint planning for squad. Therefore it seems as though this criteria is fulfilled for both, but since we are not certain when it comes to Tellus they are set to maybe.\n\nThe fifth and last criteria is that agile teams regularly reflect on, and measure how they work together and act to improve on their findings in a timely manner. At both projects they have retrospectives. At Omega we could see that not only those in the team ensured that the concerns were handled, this was also accomplished by others who read the retrospectives. At Tellus they divided the sprint into two parts when people had a problem with planning for four weeks at a time. Therefore we can say that both projects fulfill this criteria.\nChapter 5. Discussion\n\nTable 5.5: Criteria to be Agile\n\n<table>\n<thead>\n<tr>\n<th>Criteria</th>\n<th>Omega</th>\n<th>Tellus</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Value</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Validation</td>\n<td>Yes</td>\n<td>Unknown</td>\n</tr>\n<tr>\n<td>Active stakeholder participation</td>\n<td>Yes</td>\n<td>Maybe</td>\n</tr>\n<tr>\n<td>Self-organization</td>\n<td>Yes</td>\n<td>Maybe</td>\n</tr>\n<tr>\n<td>Improvement</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\nAs we can see from table 5.5 we can confirm that Omega was definitely agile. We do not have all the facts about Tellus, but from what we have observed four out of the five criteria were fulfilled. Since these are only suggestions for a project being agile we can therefore conclude with the fact that both of the projects are agile.\nConclusion\n\nIn this chapter we will try to conclude the findings from this thesis. We will do so in conjunction with the research question given earlier. In the end we will give an overview of implications for practice.\n\n6.1 Research Question\n\n*Is whole team thinking a possible success factor in large scale agile development?*\n\nAs we have witnessed there are several important success factors in large scale agile development. All of these do not have to be a success factor in every project, and some can be hindering even though the project is said to be a success. No two projects will ever be the same because of different people, motivations, experience etc. One thing it appears as they have in common is the necessity for whole team thinking.\n\nFrom what we have discovered in the theory we have fourteen different possible success factors. When investigating these two cases we found eleven of these applicable in one or both of the cases. The reason for not finding the last three could have something with the focus, which were on whole team thinking. Out of the eleven factors there were nine more or less applicable in both cases, some of these were only mentioned once or twice in one of the cases and is therefore not presented in the results chapter. From what we have seen in these two cases and from the theory there are at least five of the factors that are factors in all projects, the rest are unsure, see table 6.1.\n\nWhole team thinking does not only affect the factor itself but it can also be seen in conjunction with several of the other factors, see table 6.2. Whole team thinking is not visible, but seen between the lines. It is about everyone coming together and doing what is best for the project and not only the team. Without it there would be difficult not only to have a workable product, but to finish the project.\nTable 6.1: Success Factors Applicable in all Large Scale Agile Projects: A = always applicable, M = maybe always applicable, NF = not found in the cases\n\n<table>\n<thead>\n<tr>\n<th>Success factor</th>\n<th>Applicable</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Customer collaboration</td>\n<td>M</td>\n</tr>\n<tr>\n<td>Agile software engineering techniques and agile evangelist</td>\n<td>A</td>\n</tr>\n<tr>\n<td>Responding to change</td>\n<td>M</td>\n</tr>\n<tr>\n<td>Team</td>\n<td>A</td>\n</tr>\n<tr>\n<td>Leadership</td>\n<td>M</td>\n</tr>\n<tr>\n<td>Planning</td>\n<td>M</td>\n</tr>\n<tr>\n<td>Testing</td>\n<td>M</td>\n</tr>\n<tr>\n<td>Governance</td>\n<td>NF</td>\n</tr>\n<tr>\n<td>Divide after you conquer</td>\n<td>NF</td>\n</tr>\n<tr>\n<td>Continuous integration</td>\n<td>NF</td>\n</tr>\n<tr>\n<td>Bridgehead</td>\n<td>A</td>\n</tr>\n<tr>\n<td>Co-location</td>\n<td>M</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>A</td>\n</tr>\n<tr>\n<td>Whole team thinking</td>\n<td>A</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.2: Success Factors Whole Team Thinking have been seen in Conjunction with: Y= yes, N= no, NK = not known\n\n<table>\n<thead>\n<tr>\n<th>Success factor</th>\n<th>WTT</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Customer collaboration</td>\n<td>N</td>\n</tr>\n<tr>\n<td>Agile software engineering techniques and agile evangelist</td>\n<td>N</td>\n</tr>\n<tr>\n<td>Responding to change</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Team</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Leadership</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Planning</td>\n<td>N</td>\n</tr>\n<tr>\n<td>Testing</td>\n<td>N</td>\n</tr>\n<tr>\n<td>Governance</td>\n<td>NK</td>\n</tr>\n<tr>\n<td>Divide after you conquer</td>\n<td>NK</td>\n</tr>\n<tr>\n<td>Continuous integration</td>\n<td>NK</td>\n</tr>\n<tr>\n<td>Bridgehead</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Co-location</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>Y</td>\n</tr>\n</tbody>\n</table>\n6.2 Implications for Practice\n\nFrom what we have seen in both cases whole team thinking is a factor that affects the projects in one way or another. At Omega they saw the division between the teams and worked toward removing these, while they at Tellus have tried to see themselves as one team from the beginning. Whole team thinking has definitely been a factor in both of these projects. This can be seen by the results from Strode’s implicit coordination factors in table 5.2 and 5.3.\n\nTellus is not yet concluded and there is no way of knowing if it will be a success or not. This is not hindering when we conclude with whole team thinking as a success factor. As already determined there might not be necessary for all success factors in every project because of the different resources, duration, and technologies. There will still be necessary for whole team thinking even if it is seen in conjunction with the other factors. Whole team thinking is one of the factors that will remain in every project, and without considering it the project will probably fail because of different thoughts of direction between the teams.\n\nFrom what we have seen both in the theory and in the cases is that it is hard to not have whole team thinking in mind when doing a large scale agile development project. Not all lessons learned-papers mention it, but it can usually be seen between the lines, and in conjunction with other factors for success. Therefore it is safe to say that whole team thinking is an important success factor in large scale agile development projects.\n\n6.2 Implications for Practice\n\nNow that we can see that whole team thinking is a possible success factor it is important to know how it can be accomplished. At the beginning of the project it is important to think about the shared mental models in the whole project and for each team. This should be conducted for both management, and for everyone involved in the project. This can ensure that all team members have an understanding of the project as a whole from the beginning.\n\nIt is important to find different arenas for the project to provide knowledge from every part of the team. This can be accomplished by for example scrum of scrums. The bigger the project, the more arenas are necessary for the whole project. The arenas work as a bridgehead between the teams and ensures coordination between them. The architects should talk together, and the same applies for testers, designers and others. It is very important that the arenas are not forced on the teams, and can change over time to best suit the project. There is no point in continuing with scrum of scrums if nobody has the need for it, it is therefore important to be able to respond to changes.\n\nIt is not necessary to only hire people with agile experience, as long as they are passionate about learning agile practices. When hiring people with agile experience it is important that they know that a large scale project is different from a project with only one team. The leaders should be able to unite the teams and ensure that they understand that they are all working on the same project, and how important everyone’s contribution is.\nThe customer should dedicate their time to the project, because if they do not, the project will most likely fail. It is necessary that they use their best people with the right knowledge and authority to make decisions. The PO or POs all have to have an understanding that they are there for the whole project and not only for their expertise in the different areas of the project. They have to be able to collaborate and agree on which areas of the project to use the most resources.\n\nEveryone should know what the other teams are working on and how this affects their work. In addition the team members should be encouraged to help if they have the capacity and knowledge. This can easily be seen through the shared mental models already from the beginning. The shared mental models provide the team members and teams with a common understanding of the task and the people and teams involved. Everything will be easier the more co-located everyone is, but as long as they have good replacements, like a video live-feed, it can work either way. Locating teams working on the same areas of the project together will help and can bring the teams closer together.\n\nIf we add up we can see that the most important practices for whole team thinking is:\n\n- Shared mental models for the whole project\n- Different arenas\n- Listening to the teams and responding to changes\n- Hire people with an understanding of the requirements necessary for a large project\n- A customer who understands the needs in a large agile project\n\nHere the shared mental models is one of the most important practices and is something that are not only necessary from the beginning, but throughout the whole project.\nChapter 7\n\nFuture Work\n\nThe future work chapter will propose further research areas and how to continue the research of whole team thinking in large scale agile development. First we will consider the revised research agenda from XP2014 before considering this thesis and its findings.\n\n7.1 Suggestions for Future Research\n\nBefore proposing new suggestions we should look at the revised research agenda from Dingsøyr and Moe [2], see table 7.1. In this thesis we have researched the variability factors. Inter-team coordination have already been a topic widely researched, although there are different conclusions, for example if the scrum of scrums work [26; 56]. Knowledge sharing and improvement is something that can be seen together with the shared mental models and whole team thinking.\n\nIt is still difficult to find how to best scale agile practices, and comparing similar projects with different practices could be a way of studying this more closely. One of the topics actually mentioned by the Omega case is the contracts. People were concerned with delivering what was in the contracts which made it difficult to consider the project as a whole, and it made it difficult to rotate team members between suppliers.\n\nFrom this thesis we can see that there are several of the success factors which are present in the two cases, and in the research agenda, and some that have not been found or discovered, see table 6.1 and 6.2. For future research it might be necessary to explore these both in a narrow and wide perspective.\n\nWhen it comes to whole team thinking and shared mental models there are several interesting ways of discovering the necessity of these. One is to follow a project which is aware of the importance and which allocates time to nurture the idea. The outcome might be different when everyone involved is aware of the possible problem or factor from the beginning. If this is something that helps the project to more success would be an interest-\n### Table 7.1: Revised Research Agenda for Large Scale Agile by Dingsøyr and Moe\n\n<table>\n<thead>\n<tr>\n<th>Priority</th>\n<th>Topic</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>High</td>\n<td>Organisation of large development efforts</td>\n<td>Organizational models, portfolio management, governance, project management, agile productline engineering</td>\n</tr>\n<tr>\n<td>High</td>\n<td>Variability factors in scaling</td>\n<td>Factors important in large projects which influence development process</td>\n</tr>\n<tr>\n<td>High</td>\n<td>Inter-team coordination</td>\n<td>Coordination between teams</td>\n</tr>\n<tr>\n<td>High</td>\n<td>Key performance indicators</td>\n<td>Identify metrics to monitor progress and support transparency</td>\n</tr>\n<tr>\n<td>High</td>\n<td>Knowledge sharing and improvement</td>\n<td>How to ensure feedback for learning, use of knowledge networks and learning practices</td>\n</tr>\n<tr>\n<td>High</td>\n<td>Release planning and architecture</td>\n<td>Coordinating and prioritizing functional and non-functional requirements, continuous delivery, minimizing technical debt</td>\n</tr>\n<tr>\n<td>Medium</td>\n<td>Customer collaboration</td>\n<td>Practices and techniques for product owners and customers to collaborate with developers</td>\n</tr>\n<tr>\n<td>Medium</td>\n<td>Scaling agile practices</td>\n<td>Which agile practices can scale and understand why and when they do</td>\n</tr>\n<tr>\n<td>Medium</td>\n<td>Agile contracts</td>\n<td>Understand if contracts can change the mind-set of customers from upfront planning to agile principles and uncover legal limitations that reduce agility</td>\n</tr>\n<tr>\n<td>Medium</td>\n<td>Agile transformations</td>\n<td>Efficient adoption of agile practices</td>\n</tr>\n<tr>\n<td>Medium</td>\n<td>UX design</td>\n<td>Integration of user experience design</td>\n</tr>\n</tbody>\n</table>\nThis thesis followed two different cases. There were no interviews being conducted by the researcher. If the researcher had been able to do interviews that focused on the theme of this thesis, which are success factors and whole team thinking, the answers could have been something else. It might have been possible to see more of what they did to enable whole team thinking and it could have been less assumptions taken by the researcher. Since the one case was already concluded they could have contributed with suggestions to what could be conducted in future cases. With more focus on whole team thinking they might have more to contribute in later agile large scale projects.\n\nIt would also be interesting to see if the other factors not found in these cases are applicable in other projects. There might be different cases which have different factors important, and discovering what factors cause the different projects in their success. Some of the factors are so natural that they are not much considered during the project because they are obvious. With more focus on them it can help people in their next projects. In one project the fact that the product owner is involved may be taken for granted, which is why it is difficult to discover the lack of involvement in other projects.\n\nAs we can see there are still endless possibilities for further research in large scale agile development projects. Conducting the same research in more cases, explore the different factors and continuing to watch the agile development in large scale are just some possibilities. Every project will be different, not only because no one creates the same product, but because there are different people with different skills, and there is always new technologies. This is why there are so many possibilities for further research in the large scale agile development.\nBibliography\n\n\nIn this appendix we will present the different articles where we found the success factors and the words or phrases which supports them. This chapter is to help the reader to know the reasons for the success factors presented in this thesis.\n\nA.1 Overview of Articles for each Success Factor\n\nHere we will summarize the different factors in different tables. We will present the words found in the paper that supports the factor, and which article it is from. We will also give an overview of the number of referenced articles for each article and number of times the article have been cited by others. Several of the articles have a question mark where the number of times cited were to be mentioned. This is because no information has been found for them.\nTable A.1: Customer Collaboration Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Customer collaboration</td>\n<td>A survey study of critical success factors in agile software projects [8]</td>\n<td>Journal</td>\n<td>27 + 84</td>\n</tr>\n<tr>\n<td>Customer collaboration</td>\n<td>Agile Scalability for larger scale Projects: Lessons Learned [16]</td>\n<td>Journal</td>\n<td>64 + 2</td>\n</tr>\n<tr>\n<td>Customer collaboration</td>\n<td>Experiences Applying Agile Practices to Large Systems [43]</td>\n<td>Conference</td>\n<td>3 + 2</td>\n</tr>\n<tr>\n<td>Customer collaboration</td>\n<td>The Effects of Team Backlog Dependencies on Agile Multiteam Systems: A Graph Theoretical Approach [36]</td>\n<td>Conference</td>\n<td>46 + 0</td>\n</tr>\n<tr>\n<td>Customer collaboration</td>\n<td>Experiences in Scaling the Product Owner Role in Large-Scale Globally Distributed Scrum [31]</td>\n<td>Conference</td>\n<td>10 + 2</td>\n</tr>\n<tr>\n<td>Customer collaboration</td>\n<td>Rolling out a mission critical system in an agilish way [42]</td>\n<td>Conference</td>\n<td>4 + 2</td>\n</tr>\n<tr>\n<td>Part-time experts</td>\n<td>Improving Business Success by Managing Interactions among Agile Teams in Large Organizations [41]</td>\n<td>Conference</td>\n<td>26 + 1</td>\n</tr>\n</tbody>\n</table>\n### Table A.2: Agile Software Engineering and Agile Evangelist Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Agile software engineering</td>\n<td>A survey study of critical success factors in agile software projects [8]</td>\n<td>Journal</td>\n<td>27 + 84</td>\n</tr>\n<tr>\n<td>Agile software engineering</td>\n<td>Agility at Scale: Economic Governance, Measure Improvement, and Disciplined Deliveryt [51]</td>\n<td>Conference</td>\n<td>32 + 2</td>\n</tr>\n<tr>\n<td>Agile evangelist</td>\n<td>How BMC is Scaling Agile Development [44]</td>\n<td>Conference</td>\n<td>0 + 2</td>\n</tr>\n<tr>\n<td>Agile coaching</td>\n<td>Rolling out Agile in a Large Enterprise [45]</td>\n<td>Conference</td>\n<td>5 + ?</td>\n</tr>\n</tbody>\n</table>\n\n### Table A.3: Responding to Change Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Embrace change</td>\n<td>Agile requirements prioritization in large-scale outsourced system projects: An empirical study [47]</td>\n<td>Journal</td>\n<td>30 + 13</td>\n</tr>\n<tr>\n<td>Responding to change</td>\n<td>Agile software development methodology for medium and large projects [46]</td>\n<td>Journal</td>\n<td>30 + 1</td>\n</tr>\n<tr>\n<td>Responding to change</td>\n<td>Agile Scalability for larger scale Projects: Lessons Learned [16]</td>\n<td>Journal</td>\n<td>64 + ?</td>\n</tr>\n<tr>\n<td>Responding to change</td>\n<td>The Effects of Team Backlog Dependencies on Agile Multiteam Systems: A Graph Theoretical Approach [36]</td>\n<td>Conference</td>\n<td>46 + 0</td>\n</tr>\n<tr>\n<td>Changes</td>\n<td>Exploring Coordination in Large-Scale Agile Software Development: A Multiteam Systems Perspective [34]</td>\n<td>Conference</td>\n<td>67 + ?</td>\n</tr>\n<tr>\n<td>Word/phrase</td>\n<td>Article</td>\n<td>Type of article</td>\n<td>References + # of times referenced</td>\n</tr>\n<tr>\n<td>-------------------------------------</td>\n<td>------------------------------------------------------------------------</td>\n<td>-----------------</td>\n<td>-----------------------------------</td>\n</tr>\n<tr>\n<td>Team capability</td>\n<td>A survey study of critical success factors in agile software projects [8]</td>\n<td>Journal</td>\n<td>27 + 84</td>\n</tr>\n<tr>\n<td>Self-organizing scenario-based teams</td>\n<td>Aligning codependent Scrum teams to enable fast business value delivery: a governance framework and set of intervention actions [59]</td>\n<td>Journal</td>\n<td>71 + ?</td>\n</tr>\n<tr>\n<td>Self-organizing scenario-based teams</td>\n<td>Agile Scalability for larger scale Projects: Lessons Learned [16]</td>\n<td>Journal</td>\n<td>64 + ?</td>\n</tr>\n<tr>\n<td>Self-organizing scenario-based teams</td>\n<td>A Case Study in Agile-at-Scale Delivery [48]</td>\n<td>Conference</td>\n<td>8 + 3</td>\n</tr>\n<tr>\n<td>Self-organizing scenario-based teams</td>\n<td>Agility at Scale: Economic Governance, Measure Improvement, and Disciplined Delivery [51]</td>\n<td>Conference</td>\n<td>32 + 2</td>\n</tr>\n<tr>\n<td>Self-organizing scenario-based teams</td>\n<td>Experiences Applying Agile Practices to Large Systems [43]</td>\n<td>Conference</td>\n<td>3 + 2</td>\n</tr>\n<tr>\n<td>Self-organizing scenario-based teams</td>\n<td>IBM agility@scale: Become as Agile as You Can Be [6]</td>\n<td>Lessons learned</td>\n<td>10 + ?</td>\n</tr>\n<tr>\n<td>Right people</td>\n<td>Scaling Agile: Finding your agile tribe [49]</td>\n<td>Conference</td>\n<td>3 + 4</td>\n</tr>\n<tr>\n<td>Avoid "super team"</td>\n<td>Experiences Applying Agile Practices to Large Systems [43]</td>\n<td>Conference</td>\n<td>3 + 2</td>\n</tr>\n<tr>\n<td>Good people</td>\n<td>Supersize Me [50]</td>\n<td>Web</td>\n<td>6 + ?</td>\n</tr>\n</tbody>\n</table>\nTable A.5: Leadership Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Good leader</td>\n<td>Influence of Large-Scale Organization Structures on Leadership Behaviors [52]</td>\n<td>Conference</td>\n<td>10 + 1</td>\n</tr>\n</tbody>\n</table>\n\nTable A.6: Planning Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Project planning</td>\n<td>Agile software development methodology for medium and large projects [46]</td>\n<td>Journal</td>\n<td>30 + 1</td>\n</tr>\n<tr>\n<td>Planning</td>\n<td>Perspective on Productivity and Delays in Large-Scale Agile Projects [74]</td>\n<td>Conference</td>\n<td>34 + 1</td>\n</tr>\n<tr>\n<td>Two-level planning</td>\n<td>Agility at Scale: Economic Governance, Measure Improvement, and Disciplined Delivery [51]</td>\n<td>Conference</td>\n<td>32 + 2</td>\n</tr>\n<tr>\n<td>Adaptive planning</td>\n<td>Experiences Applying Agile Practices to Large Systems [43]</td>\n<td>Conference</td>\n<td>3 + 2</td>\n</tr>\n<tr>\n<td>Word/phrase</td>\n<td>Article</td>\n<td>Type of article</td>\n<td>References + # of times referenced</td>\n</tr>\n<tr>\n<td>---------------------</td>\n<td>-------------------------------------------------------------------------</td>\n<td>-----------------</td>\n<td>------------------------------------</td>\n</tr>\n<tr>\n<td>Continous testing</td>\n<td>Agile Scalability for larger scale Projects: Lessons Learned [16]</td>\n<td>Journal</td>\n<td>64 + ?</td>\n</tr>\n<tr>\n<td>Test driven</td>\n<td>Agility at Scale: Economic Governance, Measure Improvement, and Disciplined Delivery [51]</td>\n<td>Conference</td>\n<td>32 + 2</td>\n</tr>\n<tr>\n<td>development</td>\n<td>Experiences Applying Agile Practices to Large Systems [43]</td>\n<td>Conference</td>\n<td>3 + 2</td>\n</tr>\n<tr>\n<td>Test driven</td>\n<td>IBM agility@scale: Become as Agile as You Can Be [6]</td>\n<td>Lessons learned</td>\n<td>10 + ?</td>\n</tr>\n</tbody>\n</table>\n### Table A.8: Governance Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Governance framework</td>\n<td>Towards a governance framework for chain of Scrum teams [38]</td>\n<td>Journal</td>\n<td>99 + 2</td>\n</tr>\n<tr>\n<td>Governance</td>\n<td>Aligning codependent Scrum teams to enable fast business value delivery: a governance framework and set of intervention actions [59]</td>\n<td>Journal</td>\n<td>71 + ?</td>\n</tr>\n<tr>\n<td>Economic governance</td>\n<td>Agility at Scale: Economic Governance, Measure Improvement, and Disciplined Delivery [51]</td>\n<td>Conference</td>\n<td>32 + 2</td>\n</tr>\n<tr>\n<td>Effective governance</td>\n<td>IBM agility@scale: Become as Agile as You Can Be [6]</td>\n<td>Lessons learned</td>\n<td>10 + ?</td>\n</tr>\n</tbody>\n</table>\n\n### Table A.9: Divide after You Conquer Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Divide and conquer</td>\n<td>Supersize Me [50]</td>\n<td>Web</td>\n<td>6 + ?</td>\n</tr>\n</tbody>\n</table>\nTable A.10: Continuous Integration Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Continuous</td>\n<td>Towards a governance framework for chain of Scrum teams [38]</td>\n<td>Journal</td>\n<td>99 + 2</td>\n</tr>\n<tr>\n<td>integration</td>\n<td>Agile Scalability for larger scale Projects: Lessons Learned [16]</td>\n<td>Journal</td>\n<td>64 + ?</td>\n</tr>\n<tr>\n<td>Continuous</td>\n<td>Scaling Agile: Finding your agile tribe [49]</td>\n<td>Conference</td>\n<td>3 + 4</td>\n</tr>\n<tr>\n<td>Continuous</td>\n<td>Agility at Scale: Economic Governance, Measure Improvement, and Disciplined Delivery [51]</td>\n<td>Conference</td>\n<td>32 + 2</td>\n</tr>\n<tr>\n<td>integration</td>\n<td>Experiences Applying Agile Practices to Large Systems [43]</td>\n<td>Conference</td>\n<td>3 + 2</td>\n</tr>\n<tr>\n<td>Continuous</td>\n<td>Large Scale Agile: Scaling Agile Development: Large and Multisite Product Development with Large-Scale Scrum [40]</td>\n<td>Lessons learned</td>\n<td>6 + ?</td>\n</tr>\n<tr>\n<td>Word/phrase</td>\n<td>Article</td>\n<td>Type of article</td>\n<td>References + # of times referenced</td>\n</tr>\n<tr>\n<td>-------------------------</td>\n<td>-------------------------------------------------------------------------</td>\n<td>-----------------</td>\n<td>-----------------------------------</td>\n</tr>\n<tr>\n<td>Communities of practice</td>\n<td>Communities of practice in a large distributed agile software development organization - Case Ericsson [57]</td>\n<td>Journal</td>\n<td>33 + 1</td>\n</tr>\n<tr>\n<td>Scrum of scrums</td>\n<td>Towards a governance framework for chain of Scrum teams [38]</td>\n<td>Journal</td>\n<td>99 + 2</td>\n</tr>\n<tr>\n<td>Scrum of scrums</td>\n<td>Exploring Software development at the Very Large Scale: A Revelatory Case Study and Research Agenda for Agile Method Adoption [26]</td>\n<td>Journal</td>\n<td>56 + ?</td>\n</tr>\n<tr>\n<td>Scrum of scrums</td>\n<td>Inter-team Coordination in Large-Scale Globally Distributed Scrum: Do Scrum-of-Scrums Really Work? [56]</td>\n<td>Conference</td>\n<td>14 + 4</td>\n</tr>\n<tr>\n<td>Scrum of scrums</td>\n<td>Large-Scale Agile Software Development at SAP AG [5]</td>\n<td>Conference</td>\n<td>20 + 3</td>\n</tr>\n<tr>\n<td>Scrum of scrums</td>\n<td>Exploring Coordination in Large-Scale Agile Software Development: A Multiteam Systems Perspective[34]</td>\n<td>Conference</td>\n<td>67 + ?</td>\n</tr>\n<tr>\n<td>Scrum of scrums</td>\n<td>The Effects of Team Backlog Dependencies on Agile Multiteam Systems: A Graph Theoretical Approach [36]</td>\n<td>Conference</td>\n<td>46 + ?</td>\n</tr>\n<tr>\n<td>Bridgehead</td>\n<td>Improving Business Success by Managing Interactions among Agile Teams in Large Organizations [41]</td>\n<td>Conference</td>\n<td>26 + 1</td>\n</tr>\n<tr>\n<td>Cross-team activities</td>\n<td>Scaling Agile: Finding your agile tribe [49]</td>\n<td>Conference</td>\n<td>3 + 4</td>\n</tr>\n<tr>\n<td>Guilds, chapters</td>\n<td>Scaling Agile @ Spotify [4]</td>\n<td>Lessons learned</td>\n<td>0 + 2</td>\n</tr>\n</tbody>\n</table>\n### Table A.12: Co-Location Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Co-locating</td>\n<td>Large-Scale Agile Software Development at SAP AG [5]</td>\n<td>Conference</td>\n<td>20 + 3</td>\n</tr>\n<tr>\n<td>Co-location</td>\n<td>Improving Business Success by Managing Interactions among Agile Teams in Large Organizations [41]</td>\n<td>Conference</td>\n<td>26 + 1</td>\n</tr>\n<tr>\n<td>Locating teams together</td>\n<td>Scaling Agile @ Spotify [4]</td>\n<td>Lessons learned</td>\n<td>0 + 2</td>\n</tr>\n<tr>\n<td>Scattered members</td>\n<td>Scaling Agile Development: Large and Multisite Product Development with Large-Scale Scrum [40]</td>\n<td>Lessons learned</td>\n<td>6 + ?</td>\n</tr>\n</tbody>\n</table>\nTable A.13: Product Owner Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n<th>Type of article</th>\n<th>References + # of times referenced</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Product owner</td>\n<td>Aligning codependent Scrum teams to enable fast business value delivery: a governance framework and set of intervention actions [59]</td>\n<td>Journal</td>\n<td>71 + ?</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>Large-Scale Agile Software Development at SAP AG [5]</td>\n<td>Conference</td>\n<td>20 + 3</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>A Case Study in Agile-at-Scale Delivery [48]</td>\n<td>Conference</td>\n<td>8 + 1</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>Implementing Program Model with Agile Principles in a Large Software Development Organizations [58]</td>\n<td>Conference</td>\n<td>19 + ?</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>Experiences in Scaling the Product Owner Role in Large-Scale Globally Distributed Scrum [31]</td>\n<td>Conference</td>\n<td>10 + ?</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>Rolling out a mission critical system in an agilish way [42]</td>\n<td>Conference</td>\n<td>4 + ?</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>Scaling Agile @ Spotify [4]</td>\n<td>Lessons Learned</td>\n<td>0 + 2</td>\n</tr>\n<tr>\n<td>Product owner</td>\n<td>Large Scale Agile: Scaling Agile Development: Large and Multisite Product Development with Large-Scale Scrum [40]</td>\n<td>Lessons learned</td>\n<td>6 + ?</td>\n</tr>\n</tbody>\n</table>\n### Table A.14: Whole Team Thinking Articles\n\n<table>\n<thead>\n<tr>\n<th>Word/phrase</th>\n<th>Article</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Project overall</strong></td>\n<td>Agile Software development in Large Organizations [61]</td>\n</tr>\n<tr>\n<td><strong>Shared mental models</strong></td>\n<td>Aligning codependent Scrum teams to enable fast business value delivery: a governance framework and set of intervention actions [59]</td>\n</tr>\n<tr>\n<td><strong>Whole team thinking</strong></td>\n<td>Scaling Agile: Finding your agile tribe [49]</td>\n</tr>\n<tr>\n<td><strong>Project as a whole</strong></td>\n<td>Large-Scale Agile Software Development at SAP AG [5]</td>\n</tr>\n<tr>\n<td><strong>Full lifetime cycle</strong></td>\n<td>Agile Software Development at Scale [11]</td>\n</tr>\n<tr>\n<td><strong>Collaborative teamwork</strong></td>\n<td>Agility at Scale: Economic Governance, Measure Improvement, and Disciplined Delivery [51]</td>\n</tr>\n<tr>\n<td><strong>Overall situation</strong></td>\n<td>Improving Business Success by Managing Interactions among Agile Teams in Large Organizations [41]</td>\n</tr>\n<tr>\n<td><strong>Whole product</strong></td>\n<td>Large Scale Agile: Scaling Agile Development: Large and Multisite Product Development with Large-Scale Scrum [40]</td>\n</tr>\n<tr>\n<td><strong>Share philosophical mindset</strong></td>\n<td>Supersize Me [50]</td>\n</tr>\n</tbody>\n</table>\nObservation Template\n\nIn this chapter the reader can see the observation template used during the observations at Tellus. The observations were conducted in Norwegian, the native language of the observer and the subjects. The first page consists of various information which can be important for the observer at a later time. The next page is the observations conducted. Here we have an overview of what was said and done during what time. When observing there were several copies of the second page included.\n\nB.1 The Template\nObservasjon av:\n\nDato og tid:\n\nSted (antall):\n\nBedrift:\nCase:\nPersoner:\n\nSitteplasser:\n\nVindu:\nVær:\nBakgrunnsstøy:\nHumør/form:\nRomtemp:\nTeknisk utstyr:\n\nDiv:\n| Kl: | Observasjon: |\nSupporting Information\n\nThis chapter includes some theory which were originally in the thesis. The reasons for removing this from the thesis was because it was not important for the research question. The reasons for having it in the appendix is because it supports some of the items that are presented in the thesis.\n\nC.1 Agile Software Development\n\nHere we will present both XP and enterprise agile. XP will be presented because it is mentioned in section 2.4.2. For those readers that do not know about XP when reading this thesis an explanation of it is given here. Enterprise agile is briefly mentioned in the thesis in section 2.2. This is therefore explained here so that it is easy to understand the difference between enterprise agile and large scale agile.\n\nC.1.1 XP\n\nExtreme programming is often referred to as XP, see figure C.1\\(^1\\) for an overview. XP consists of practices that focus on software development team activities [64]. It is close to being a full-fledged disciplined agile delivery method, but is missing explicit project initiation and release practices [6]. XP has the shortest recommended iteration length of the agile methods with only two weeks [19]. The original XP recipe is based on four simple values and twelve supporting practices\\(^2\\):\n\n- The planning game\n- Small releases\n- System metaphor\n\n\\(^1\\)https://blogs.msdn.microsoft.com/jmeier/2014/06/06/extreme-programming-xp-at-a-glance-visual/\n\\(^2\\)https://www.versionone.com/agile-101/agile-methodologies/\nThe four values are; simplicity, communication, feedback and courage.\n\nThe basic advantage of XP is that the whole process is visible and accountable. In XP there are two planning steps. Release planning is where the customer presents the desired features to the programmers. Here the programmers estimate the difficulty of these features. It is important to know that the release plan is revised regularly. The second step is iteration planning where the customer presents the features desired for the next iteration. In XP a feature story is never ninety percent complete, it is either finished or not.\n\nXP is noted for pair programming and it advocates pair programming for feedback. Instead of using a product backlog, XP uses story cards, but the size of the team is\n\n---\n\n3 http://c2.com/cgi/wiki?ExtremeProgramming\n4 http://ronjeffries.com/xprog/what-is-extreme-programming/\nabout the same as in scrum with maximum ten people. XP has a focus on communication and co-location. This indicates that XP does not support distributed teams [19].\n\nC.1.2 Enterprise Agile\n\nSince agile software development has become widely popular several organizations have wanted to take part in the agile revolution. Dingsøyr et al. [26] refer to enterprise agile as agile methods applied in large organizations. How this can be accomplished is explained with Yahoo as an example [45]. The enterprise usually consists of several small projects which all use agile development methods. This means that the enterprise can have several independent projects which all use agile methods, but they are not connected. If the organization had had only one big project this would have been large scale and not enterprise agile. Large scale is explained in section 2.2.\n\nA number of organizations have taken an interest in agile methods because of the necessity to seek alternatives to the traditional software development methodologies [61]. The traditional ones are often too cumbersome, bureaucratic and inflexible, and the organizations feel pressure to produce more at lower cost. This can be seen by this quote from a team at Motorola:\n\n\"Software development teams face a continuous battle to increase productivity while maintaining or improving quality\"\n\nThe problems in organizations is that a project cannot truly be independent, but it must interact and follow the rules of the organization overall [61].\n\nAgile practices have been implemented not only at Yahoo, but also in other organizations, or parts of organizations. Lindvall et al. [61] followed ABB, Daimler-Chrysler, Motorola and Nokia in their pilot projects. BMC [44] and IBM [48] are among the other companies that have implemented agile practices and are satisfied with the results.\nAppendix D\n\nSuccess Factors not Discussed in the Thesis\n\nIn this appendix we will give an overview of the success factors that had little or no data found in the two cases by the researcher. This does not imply that they are not success factors, or that there is not possible to find them in the cases.\n\nD.1 Success Factors\n\nFirst we will give an overview of the two factors with results from the cases, these are planning and testing. Both of this are applicable for both small and large scale and is followed by governance which is also applicable by both. The two last factors are most applicable for large scale and they are: divide after you conquer, and continuous integration.\n\nD.1.1 Planning\n\nFor this factor there are some results from the two cases. Since the results were not relevant for whole team thinking it was removed from the thesis and put in the appendix.\n\nTheory\n\nLike with many of the other factors planning is important, and it is particularly important in large projects since there are so many factors to consider. Project planning plays an important role for the success or failure of a project [46]. The objective in this phase is to concentrate on the major milestones of the project. If the project planning is not properly made and documented, a software project might deteriorate. Large systems requires a planning process that accommodates changes and adapts to those [43]. All key stakeholders should be involved in the planning [74]. In large projects the planning will take place on different levels in the hierarchy. Top-down planning is an example of this since it is conceptualized as a mechanistic, centralized approach, e.g. between a team and a superior\nperson or team [34]. Brown et al. [51] found five core practices that constitute the key prerequisites for efficient adoption of agile approaches, and two-level planning was one of these.\n\nResults\n\nThe planning at Omega was implemented differently at the three suppliers. At Beta they only used a couple of hours planning the sprint, while at Alpha they used about a day. Alpha used a lot of the time to detail and ensure that everyone had the same understanding of the tasks. This made it possible for everyone to work on all tasks since they all had decided how to do them. Alpha felt better prepared, while Beta did not find it necessary to use that much time on planning. They believed more in doing the work and plan if problems emerged.\n\nThe meeting agenda and meeting structure seemed to be lacking at Tellus. The meetings were completed differently each time and there were often silent breaks when people did not know what to do next. They were not tough enough when it came to how much time they should use on the different items, which sometimes led them to not finish in time. This was especially a problem when they were to have another meeting next. In addition it was hard for people getting the answers to their questions, it sometimes appeared that no one cared about answering the question or knew how to answer. Other problems at Tellus included the fact that it was hard to plan a whole month ahead in a sprint, which eventually led to the sprint being divided into two parts.\n\nD.1.2 Testing\n\nFor this factor there are some results from the two cases. Since the results were not relevant for whole team thinking it was removed from the thesis and put in the appendix.\n\nTheory\n\nOne of the nine challenges found by Saeeda et al. [16] is challenges in regard to continous testing. In Ambler’s [6] five criterias for being agile, validation is one of them and focuses on continous developer regression testing and that the agile teams should take a test driven development (TDD) approach. Brown et al. [51] also propose test driven development as one of the five core practices that constitute the key prerequisites for efficient adoption of agile approaches. Giblin et al. [29] interviewed developers after they had had a training course on test driven development. They felt that it could improve quality, but what concerned them was the lack of test harnesses for the legacy code.\n\nTest driven development can help validate requirements/ scenarios early in the development process [43]. It is a technique where you write a single test and just enough production code to fulfill that test [11]. Test cases help developers mitigate errors and consequently minimize rework [18]. Test driven development helps agile teams capture detailed specifications in the form of executable tests instead of static documents or models [11]. In addition Brown et al. [51] present the importance of doing integration testing\nbefore unit testing. The scope of a unit is not necessarily a class. On large systems, units are typically a system component with significant behaviours or an interface to other parts of the system [43].\n\nIn a case study from SAP [18] they saw that high test coverage helped the team to deliver better software quality. It therefore helped to reduce the work stress during development sprints and before the end of the releases. This is just one of the cases that displays how important it is to test from day one since we are continuously integrating [43]. This is a fact that is important no matter the size of the project.\n\nResults\n\nWhen it came to testing there were different practices at Omega. At Alpha they had specialized testers, while at Beta they rotated the role.\n\n\"To become a specialist you first have to be a generalist\"\n\nProject management at Alpha\n\nIt was important that the tester understands some code and have somewhat of a technical background like running SQL and deploy. It was important at Alpha that even though they had specialized testers that it was still up to the team to deliver, not any individual. The tester cannot do all tests in a few days. It was important that the tester was able to start as soon as a task was finished, if not they would not have had anything to do for the first half of the sprint.\n\nD.1.3 Governance\n\nIf you have one or more IT projects then you have an IT governance in place [11]. Governance is critical to the success of any IT departments, and especially important at scale. Agile approaches to governance are based on collaborative approaches which enable teams to do the right thing. Governance can be classified as:\n\n\"Systematically determining who makes each type of decision (a decision right), who has input to a decision (an input right) and how these people (or groups) are held accountable for their role\" [59].\n\nAmbler proposes [6] that to succeed at scaling agile you will require tools that integrate easily, and are sufficiently instrumented to provide the metrics required for effective governance.\n\nAccording to Brown et al. [51] it is important to steer using economic governance, measure incremental improvements honestly, and empower teams with disciplined agile delivery. The reason for steering with economic governance is that it is an objective economic foundation for planning, decision making, and progress reporting that resolves uncertainties earlier and unifies constituencies on a shared set of expected target outcomes. From past measurement approaches they suggest three genres to software governance:\n\n- Engineering governance\n• Hybrid governance\n• Economic governance\n\nEffective governance is not about command and control, but it focuses on enabling the right behaviours and practices through collaborative and supportive techniques [11] which is why it is important both in small and large scale.\n\nD.1.4 Divide after You Conquer\n\nThere is no such thing as a 200-person project team, one big project results in many sub-projects. This indicates that when you scale it is important to divide and conquer [50]. Elshamy and Elssamadisy [53] recommend to start with a core team that builds out a valid simple business case in a test driven manner. This also involves building out most of the architecture. This first phase ends when there is a stable code base with a significant portion of the architecture built out. After this first phase is finished the problem is said to be conquered and it is time to divide by growing the development team and splitting up into smaller subteams. Each subteam follows an agile process and interface with the other teams. There is challenges with having a master build and sustaining it, but this is one way of starting a large scale project which might prove successfull.\n\nD.1.5 Continous Integration\n\nOne of the two key project challenges Moore and Spens [49] met in a large scale global development effort was continous integration. One of the seven areas SAFe targets is continous integration [16; 38]. Continous integration is presented as one of the five core practices that constitute the key prerequisites for efficient adoption of agile approaches by Brown et al. [51]. Continous integration is a development practice where developers integrate their work frequently, at least daily, where the integration is verified by an automated build [11]. In small scale this is not a problem since there are so few teams, but in large scale this is complicated since all code from the different teams are supposed to work together. Continous integration is important for the coordination of the teams and is often verified with automated tests, with a \"stop and fix\" culture of rapidly fixing a broken build [40].\n\nLarge systems have complex integration challenges such as the shear volume of code and the variety of code sources. Because integration problems are exacerbated the longer integration is delayed, most large systems must perform some form of continous and early integration to reveal integration problems [43]. Moore and Spens [49] describe in their paper that the teams failed to monitor the build beyond their own module-level build. After a while there was a passionate core of individuals that were made into an integration team. They were responsible for ensuring the integrated builds were successfull. They were hesitant in creating this group because they hoped that team ownership of code would drive people to solve integration challenges. Sadly it was difficult to expand that passion and sense of responsibilty across the entire project team of over 300 people.\nKoehnemann and Coats [43] proposed the following ideas between the developers and development teams to help facilitate continuous and early integration:\n\n- Organize teams around building scenarios, not components\n- Solicit stakeholder feedback as often as possible\n- Do not call everything a release\n- Simplify the process of making changes\n- Get all team members on board with continuous integration\n\nThe reasons for building scenarios and not components is the fact that component teams can become self-focused and more concerned about their part of the system than the system’s overall success [43]. Stakeholder feedback early in the integration process can help prevent future increments from building incorrect or undesirable implementations. When it comes to the last item we can see this together with the experiences from Moore and Spens [49]. Some individuals naturally resist, perhaps unintentionally, the change towards continuous integration [43]. As we can see continuous integration is essential to large scale since the time of integrating increases heavily with the time since the last integration."}}},{"rowIdx":173,"cells":{"id":{"kind":"string","value":"e5717a5e3c7e216d2b4fcbe357a35ca13cfdc9d2"},"text":{"kind":"string","value":"# Introduction\n\n1.1 Security Considerations ........................................... 8\n\n1.2 Starting the xrootd Daemon .................................... 9\n\n1.2.1 Multiple Instances and Automatic Fencing .................. 15\n\n1.2.2 Passing Plug-In Command Line Arguments ................ 16\n\n1.2.3 Log File Plug-Ins ............................................ 17\n\n1.2.4 Files created by xrootd .................................... 18\n\n1.2.4.1 Environmental Information File .......................... 18\n\n1.2.5 Exported Environment Variables ........................... 19\n\n# Framework Directives by Category ............................ 21\n\n2.1 Debugging ...................................................... 21\n\n2.2 Monitoring ...................................................... 21\n\n2.3 Networking ...................................................... 21\n\n2.4 Operational Environment ...................................... 21\n\n2.5 Protocol support ............................................... 21\n\n2.6 Security and TLS ............................................. 22\n\n2.7 Tuning .......................................................... 22\n\n# Common Framework Configuration Directives .............. 23\n\n3.1 adminpath ...................................................... 23\n\n3.1.1 Administrative Interface .................................... 25\n\n3.2 allow ........................................................... 26\n\n3.3 homepath ...................................................... 27\n\n3.4 tls (required for TLS) ........................................ 29\n\n3.5 tlsca (required for TLS) .................................... 31\n\n# Esoteric Framework Configuration Directives ............. 35\n\n4.1 buffers ........................................................ 35\n\n4.2 network ......................................................... 37\n\n4.2.1 Dual Public/Private Network Guidelines .................. 41\n\n4.2.2 Resolving Private IP Addresses .......................... 42\n\n4.2.3 Dynamic DNS ............................................. 42\n\n4.3 pidpath ......................................................... 43\n\n4.4 port ........................................................... 45\n\n4.5 protocol ......................................................... 47\n\n4.6 report .......................................................... 49\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>4.7</td>\n<td>sched</td>\n<td>51</td>\n</tr>\n<tr>\n<td>4.8</td>\n<td>sitename</td>\n<td>53</td>\n</tr>\n<tr>\n<td>4.9</td>\n<td>tcpmonlib</td>\n<td>55</td>\n</tr>\n<tr>\n<td>4.10</td>\n<td>timeout</td>\n<td>57</td>\n</tr>\n<tr>\n<td>4.11</td>\n<td>tlsciphers</td>\n<td>59</td>\n</tr>\n<tr>\n<td>4.12</td>\n<td>trace</td>\n<td>60</td>\n</tr>\n<tr>\n<td>5</td>\n<td>xrootd Directives by Category</td>\n<td>63</td>\n</tr>\n<tr>\n<td>5.1</td>\n<td>Data Access</td>\n<td>63</td>\n</tr>\n<tr>\n<td>5.2</td>\n<td>Data Integrity</td>\n<td>63</td>\n</tr>\n<tr>\n<td>5.3</td>\n<td>Debugging</td>\n<td>63</td>\n</tr>\n<tr>\n<td>5.4</td>\n<td>Monitoring</td>\n<td>63</td>\n</tr>\n<tr>\n<td>5.5</td>\n<td>Prepare Processing</td>\n<td>63</td>\n</tr>\n<tr>\n<td>5.6</td>\n<td>Security</td>\n<td>63</td>\n</tr>\n<tr>\n<td>5.7</td>\n<td>Tuning</td>\n<td>63</td>\n</tr>\n<tr>\n<td>6</td>\n<td>Common xrootd Configuration Directives</td>\n<td>65</td>\n</tr>\n<tr>\n<td>6.1</td>\n<td>export</td>\n<td>65</td>\n</tr>\n<tr>\n<td>6.2</td>\n<td>seclib</td>\n<td>67</td>\n</tr>\n<tr>\n<td>7</td>\n<td>Esoteric xrootd Configuration Directives</td>\n<td>69</td>\n</tr>\n<tr>\n<td>7.1</td>\n<td>async</td>\n<td>69</td>\n</tr>\n<tr>\n<td>7.2</td>\n<td>bindif</td>\n<td>72</td>\n</tr>\n<tr>\n<td>7.3</td>\n<td>chksum</td>\n<td>73</td>\n</tr>\n<tr>\n<td>7.4</td>\n<td>diglib</td>\n<td>76</td>\n</tr>\n<tr>\n<td>7.4.1</td>\n<td>Authorizing digFS Access</td>\n<td>77</td>\n</tr>\n<tr>\n<td>7.4.2</td>\n<td>Optional digFS Directives</td>\n<td>80</td>\n</tr>\n<tr>\n<td>7.4.2.1</td>\n<td>addconf</td>\n<td>80</td>\n</tr>\n<tr>\n<td>7.4.2.2</td>\n<td>log</td>\n<td>81</td>\n</tr>\n<tr>\n<td>7.4.3</td>\n<td>Using digFS</td>\n<td>82</td>\n</tr>\n<tr>\n<td>7.5</td>\n<td>fslib</td>\n<td>83</td>\n</tr>\n<tr>\n<td>7.6</td>\n<td>fsoverload</td>\n<td>85</td>\n</tr>\n<tr>\n<td>7.7</td>\n<td>log</td>\n<td>87</td>\n</tr>\n<tr>\n<td>7.8</td>\n<td>mongstream</td>\n<td>89</td>\n</tr>\n<tr>\n<td>7.9</td>\n<td>monitor</td>\n<td>93</td>\n</tr>\n<tr>\n<td>7.10</td>\n<td>pmark</td>\n<td>99</td>\n</tr>\n<tr>\n<td>7.11</td>\n<td>prep</td>\n<td>105</td>\n</tr>\n</tbody>\n</table>\n## 7.12 redirect\n\n7.13 tls\n\n7.14 trace\n\n### 8 Enabling HTTP Access\n\n- **8.1 Enabling HTTPS**\n - 8.1.1 Backward Compatibility and Overrides\n\n- **8.2 Directives to Enhance HTTPS Access**\n\n- **8.3 Common Directives**\n\n### 9 Document Change History\n1 Introduction\n\nThis document describes the eXtended Request Daemon (xrd) configuration directives protocols that can be used with xrd: cmsd, HTTP, and xrootd. It also includes the directives for the xrootd daemon that can run xroot and HTTP protocols. The cmsd-specific directives are described in a separate reference manual.\n\nThe xrd is a framework that can dynamically support multiple TCP/IP application service layer protocols. It is designed to provide a high performance environment for application services. The xrd is a generalized framework and it makes its primary decision on which protocol to support based on the name given to the executable. Currently, the following executable names are fully supported:\n\n- cmsd daemon for the cms server clustering protocol, and\n- xrootd daemon for xroot and other related protocols.\n\nConfiguration directives come from a configuration file. Directives are prefixed by the component acronym they apply to, as shown in the following table. This makes creating a single configuration file for all services possible.\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>acc</td>\n<td>Access control (i.e., authorization)</td>\n</tr>\n<tr>\n<td>cms</td>\n<td>Cluster Management Services</td>\n</tr>\n<tr>\n<td>frm</td>\n<td>File Residency Manager</td>\n</tr>\n<tr>\n<td>ofs</td>\n<td>Open File System</td>\n</tr>\n<tr>\n<td>oss</td>\n<td>Open Storage System (i.e., file system implementation)</td>\n</tr>\n<tr>\n<td>pfc</td>\n<td>Proxy File Cache</td>\n</tr>\n<tr>\n<td>pss</td>\n<td>Proxy Storage Service</td>\n</tr>\n<tr>\n<td>sec</td>\n<td>Security authentication</td>\n</tr>\n<tr>\n<td>xrd</td>\n<td>Extended Request Daemon</td>\n</tr>\n<tr>\n<td>xrootd</td>\n<td>The xroot protocol implementation.</td>\n</tr>\n<tr>\n<td>http</td>\n<td>The HTTP protocol implementation.</td>\n</tr>\n<tr>\n<td>all</td>\n<td>Applies the directive to all of the above components.</td>\n</tr>\n</tbody>\n</table>\n\nRecords that do not start with a recognized identifier are ignored. This includes blank record and comment lines (i.e., lines starting with a pound sign, #). This guide documents the all, http, xrd, and xrootd configuration directives (i.e., the un-shaded rows). Other directives are documented in supplemental references specific to the component they deal with.\nThe location of the configuration file is specified on the \\texttt{xrootd} command line. Refer to the reference manuals for other components on how they locate their respective configuration files.\n\nRefer to the manual \\textit{“Configuration File Syntax”} on how to specify and use conditional directives and set variables. These features are indispensable for complex configuration files usually encountered in large installations.\n\n\\subsection*{1.1 Security Considerations}\n\nThe \\texttt{xrd} framework relies on the loaded protocol(s) for strong authentication (e.g., Kerberos, GSI, etc.). Therefore, security is a protocol issue. The \\texttt{xroot} protocol provide strong authentication should you choose to use it. Refer to each protocol on how to configure strong authentication.\n\nThe \\texttt{xrd} framework does provide host-based authentication. While this type of authentication can be subverted in a number of ways, it still is a practical mechanism for installations that do not need strong authentication. The \\texttt{allow} directive can be used to restrict the range of hosts that can connect to the daemon. This security can be used together with any protocol-provided security.\n\nBecause the \\texttt{xrd} framework does not intrinsically provide strong authentication; you \\textit{should not run} \\texttt{xrootd} as super-user (i.e., \\texttt{Unix} root). Any attempt to do so without indicating that you \\textit{really} want to run super-user (see the \\texttt{-R} command line option) will cause the program to exit.\n1.2 Starting the xrootd Daemon\n\nUse the following command to start the xrd-based xrootd daemon:\n\n```\nxrootd [ options ] [ path [ path [ ... ] ] ] [piargs]\n```\n\n**options:**\n\n[-c cfn] [-l largs]\n\n[-k {num | sz{k|m|g} | sig}] [esoteric]\n\n**esoteric:**\n\n[{-a | -A} apath] [-b] [-d] [-h] [-I {v4 | v6}]\n\n[-n name] [-R user] [-s pfn] [-S site]\n\n[{-w | -W} hpath] [-z] [devopts]\n\n**devopts:**\n\n[-L protlib] [-p {port | any}] [-P protocol]\n\n---\n\n**largs:**\n\n[=]fn | - |\n\n@lib[,bsz=sz][,cse={0 | 1 | 2}][,logfn=[=]fn]\n\n**sig:**\n\nfifo|hup|rtmin|rtmin+1|rtmin+2|ttou|winch|xfsz\n\n**piargs:**\n\n-+[tag] [args] [piargs]\n\n**Parameters**\n\n**path** An absolute file system path prefix. All requests will be restricted to files with this prefix. You may specify any number of path prefixes. If no path is specified, operations will be restricted to paths starting with /tmp.\n\n**Options**\n\n**-c fn** The name of the configuration file. If one is not specified, no configuration file is processed.\nStarting the Daemon\n\nConfiguration\n\n-1 \\[=\\] fn\n\nSpecified how messages are to be handled. Options are:\n\n- \\( fn \\) Directs messages and any trace output to the indicated file, \\( fn \\), possibly qualified by the instance name (see the fencing section). If \\( fn \\) is a dash (\\(-\\)), output is sent to standard error; the default.\n\n- \\( =fn \\) Same as \\( fn \\) but the \\( fn \\) is not qualified by the instance name, if any. This allows log files to be handled in an arbitrary manual way. For more information see the section on fencing.\n\n- \\@lib \\) Directs messages to a plug-in that is defined in the shared library specified by \\( lib \\) (see the section on log file plug-ins). Additional comma-separated parameters may follow \\( lib \\), as follows:\n\n- \\( bsz=sz \\) Specifies the size of the speed matching buffer. The default is 64K. Messages are placed in the buffer and then forwarded to the plug-in as time permits. A value of 0 disables speed matching and messages are handed off to the plug-in as they occur. See the section on log file plug-ins for more information. A positive value less than 8K is forced to be 8K. The maximum allowed in one megabyte. The \\( sz \\) may be suffixed by \\( k \\) or \\( m \\) to indicate kilobytes or megabyte, respectively.\n\n- \\( cse={0\\mid1\\mid2} \\) Specifies how standard error output should be handled:\n - \\( 0 \\) Does not capture standard error output. All such output is sent to the \\( logfn \\) destination, if specified, or is otherwise lost. This is the default.\n - \\( 1 \\) Captures standard error but only forwards it to the logging plug-in if it starts with a standard time stamp. This option may cause an infinite loop. Refer to the logging plug-in section for more information.\n - \\( 2 \\) Captures standard error output and forwards it to the logging plug-in without inspection. Refer to the logging plug-in section for more information.\n\n- \\( logfn= [=] fn \\) Specifies that messages are also to be routed to a local log file. The parameter is identical to that described above. To use standard error, specify a dash (\\(-\\)) for \\( fn \\).\n-k num | sz[k|m|g] | sig\nKeep no more than num old log files. If sz is specified, the number of log files kept (excluding the current log file) is trimmed to not exceed sz bytes. The sz must be suffixed by k, m, or g to indicate kilobytes, megabyte, or gigabytes, respectively. If a sig value is specified (i.e. hup etc), then an external program is expected to handle log file rotation (e.g. logrotate). Except for fifo, the argument specifies signal that causes the daemon to close and re-open the log file to allow rotation to occur. When fifo is specified, the daemon waits for data to appear on a fifo whose path is identical to the log file path but whose name is prefixed by a dot. Refer to the notes for manual rotation caveats.\n\n**Esoteric Options**\n\n{-a | -A} apath\nSpecifies the default administrative path and can be overridden by the adminpath directive in the configuration file. When -A is specified group write access is allowed (see the adminpath directive option for details).\n\n-b Runs the program in the background. You should also specify -l.\n\n-d Turns on debugging. **Warning!** This severely impacts performance.\n\n-h Displays help information.\n\n-I {v4 | v6}\nRestricts the server’s internet address protocol. When v4 is specified, only hosts with IPV4 addresses can connect or be connected to. When v6 is specified, the default, hosts using IPV6 or IPV4 addresses can connect or be connected to. This option is only useful for systems that have misbehaving IPV6 network stacks. The default is established by the network interface configuration on the machine at the time the program starts.\n\n-n name\nAssigns name to the xrootd instance. By default, the xrootd instance is unnamed. See the notes on how to use this option.\n\n-R user\nThe user name or numeric uid of the user whose effective identity is to be assumed. See the usage notes for more information. The specified user may not have super-user privileges. This option may *not* be specified unless the program is running as super-user.\n-s pfn Specifies the name of the file that is to hold the process id upon start-up.\n\n-S site Specifies a 1- to 15-character site name that is to be included in monitoring records. The name may only contain letters, digits and the symbols “-_:.”; any other characters are converted to a period.\n\n[-w | -W] hpath\nSpecifies the default home path; i.e. the current working directory during execution. If it is not specified on the command line, it can be specified by the homepath directive in the configuration file. When -W is specified group read access is allowed (see the homepath directive group option for details). The hpath is extended by any specified instance name (i.e. -n option). The path is created should it not exist.\n\n-z provides microsecond resolution for log file message timestamps.\n\n-+ provides a mechanism to pass command line arguments to plug-ins. See the section “Passing Plug-In Command Line Arguments” for more information.\n\nDeveloper Options\n-L protlib\nSpecifies the shared library that holds the implementation of the default protocol specified by the -P option.\n\n-p port\nThe TCP port, or service name associated with a port, that xrootd is use for new connections. The default is “xrootd” or port 1094, if the TCP service xrootd cannot be found /etc/services.\n\n-p any\nUses any available port.\n\n-P protocol\nThe name of the default protocol. Use this option when the name of the executable differs from the name of the default protocol. You may need to specify the -L option as well. See the notes for more information.\nDefaults Arguments\n\n-1 -I v6 -p xrootd -P executable_name /tmp\n\nGeneral Notes\n1) For security purposes, only files in /tmp are allowed to be accessed unless you specify otherwise. You may specify other paths either on the command line or using the xrootd export configuration directive.\n2) Do not prefix any export path with the oss localroot directive path, if any.\n3) If a log file is specified without a signal -k option, the file is closed at midnight, renamed to have a date suffix (i.e., fn.yyyyymmdd) and possible sequence number (i.e. fn.yyyyymmdd.n), and a new log file is opened. When a signal value is specified, log files are not automatically renamed at midnight. Instead an external program must be used to properly rotate log files. Make sure to choose a signal that is not in use by any plug-in. If unsure, choose one of the obscure signal names and monitor for any odd behavior. Otherwise, use the fifo option. Be aware that on some non-Linux platforms the fifo file descriptor may leak.\n4) When fifo is specified the fifo file name must not exists or exist as a fifo file. A simple “echo x >> /path/lfn” causes the logfile to close and reopen.\n5) The sig names should not be prefixed by “sig” or “SIG”.\n\nNotes on Esoteric Options\n1) The default port service name, default protocol, and pidfile name is normally determined by the prefix-name of the executable. The prefix-name is defined to be all of the characters in the base filename (i.e. the directory path removed) up to but not including the first dot in the name, if any. If the name starts with a dot, the prefix-name is the complete base filename.\n2) The way the prefix-name is derived allows you to maintain several versions of a particular xrd executable (e.g., xrootd and xrootd.debug) without changing the intrinsic way default names (e.g. protocol) are determined.\n3) The built-in protocol name for cmsd is cms and for xrootd is xroot.\n4) The –n option allows you to run multiple instances of the xrootd on the same machine. See the next section on instances and fencing.\n5) The –b option forces the program into the background. If –I is not specified; all output messages are discarded.\n6) When –b is specified, the program fails if it cannot write the pid file.\n7) The -R option allows the program to run under the super user’s account. This is allowed because the effective user is set to specified user and the effective group to user’s primary group. Thus, the program is not effectively running as super-user. However, the real and saved user ids may still be “root”, depending on how the program was started.\n\n8) The -R option provides a minimal increase in security since it is possible for a loaded protocol to switch back to super user mode. You should not use the -R option unless absolutely necessary.\n\n9) **Warning:** Command line options, except for –a and -s, over-ride corresponding configuration file directives. For -s the `pid` file is written to the desired location in addition to the location specified by the `pidpath` directive.\n\n### Notes on Developer Options\n\n1) You must use the –P option to set the default protocol name as well as other related naming aspects (e.g., port service name) when the name of the executable does not correspond to the name of the default protocol.\n\n2) Use `-p any` for protocols that manage their own port numbers. This is the case for redirection target `xrootd/cmsd` combinations. Only the initial point of contact needs a well-known port number. All other connections between clients and servers are routed using whatever port numbers are currently in effect. This allows you to keep a simple configuration file for servers and to run more than one server on the same machine without worrying about conflicting port numbers.\n\n### Example\n\n```bash\nxrootd -c /opt/xrootd/xrootd.cf\n```\n1.2.1 Multiple Instances and Automatic Fencing\n\nYou can run multiple instances of `xrootd` on the same physical machine. This is useful when you want to overlay more than one cluster on top of a file system (e.g. production and test). In order to prevent instances from interfering with each other, you must provide each `xrootd` that is running on the same hardware a unique instance name. One of the daemons need not have an instance name as it assumes the name “anon” (i.e. anonymous).\n\nOnce an instance name is assigned to a daemon using the `–n` option, the system automatically fences in the daemon so that it does not interfere with any other `xrootd` processes running with it. Automatic fencing consists of these actions:\n\n- The instance name is suffixed to the `adminpath` to create a unique location for temporary server files. For instance, if `–n` is not specified, `xrootd` creates `/tmp/.xrootd/admin` as the path for the administrative interface. If “-n test” is specified, `xrootd` creates `/tmp/test/.xrootd/admin` instead. Even the path specified with the `adminpath` configuration directive is modified.\n- The instance name is used to create a new directory in the current working directory. The current working directory is changed to this newly created path. So, if “/home/xrootd” is the current working directory and “-n test” is specified; the current working directory becomes “/home/xrootd/test”. This allows core files to be segregated by instance name.\n- The instance name is automatically inserted into the log file path specified via the `-l` command line directive to create a unique location for server log files. For instance, if “-l /var/adm/xrootd/xrd.log” is specified along with “-n test”, `xrootd` modifies the `-l` argument to be `/var/adm/xrootd/test/xrd.log`.\n\nAutomatic fencing of log files may, for some installations, run counter to the way log files are commonly handled. You can disable fencing of log files by prefixing the log file path by an equals sign. However, you are then responsible to make sure that each instance uses a different log file path or name.\n\nMuch of this functionality has been subsumed into containerized frameworks. However, the functionality described here is still supported in the cases where containerization either does not provide the desired performance or is inconvenient thus making host-based applications becomes an imperative.\n1.2.2 Passing Plug-In Command Line Arguments\n\nYou can pass command line arguments to various plug-ins that support the feature using the `+` option. The option must be specified after all XRootD options and parameters as plug-in arguments are stripped from the command line. For example,\n\n```\nxrootd [ options ] [ path [ path [ . . . ] ] +mypi arg1 arg2 +urpi arg3\n```\n\nplaces a pointer to the vector containing “argv[0] arg1 arg2 0” into the internal environment passed to the plug-in using the variable “mypi.argv**” and the count in “mypi.argc” (i.e. 3). Similarly, “argv[0] arg3 0” are pointed to by “urpi.argv**” with the count in “urpi.argc” (i.e. 2). If no tag is specified, the leading prefix is missing (i.e. the variables are “.argv**” and “.argc”). Note that argv[0] is the actual value of argv[0] (i.e. the executable name) passed to XRootD.\n\nIt is up to the plug-in to extract the appropriate arguments using a documented tag. Tag values that start with “xrd” should not be used as these are reserved for plug-ins normally distributed with the XRootD package.\n1.2.3 Log File Plug-Ins\n\nXRootD allows you to specify a plug-in to handle messages that would otherwise be sent to a regular file or standard error. You do this using the ‘@’ qualifier with the –l option. Logging messages is a critical function in the server and any delay will severely impact server performance. The default logging path is very efficient and any plug-in placed in the path should be just as efficient. To help, a speed matching buffer is used to minimize plug-in vagaries. However, if you choose to not use a speed matching buffer (i.e. a bsz of zero for synchronous operation) then the plug-in becomes the choke point in server performance.\n\nYou may also choose to capture standard error output using the cse parameter. However, this option will result in an infinite loop if your logging plug-in writes to standard error for any reason. This may be mitigated by specifying cse=1 which only sends standard error output to the plug-in if it starts with a timestamp of the form “ymmd hh:mm:ss”. All debugging output starts with such a timestamp.\n\nThe details on how you write a log file plug-in is detailed in the XrdSysLogPI.hh header file. It is important to realize that if you use the XrdSysLogger object to route a message from your plug-in, an infinite loop will result. Additionally, one log file plug-in is used for all XrdSysLogger instances.\n1.2.4 Files created by xrootd\n\nThe following directories and files are created by xrootd:\n\n<table>\n<thead>\n<tr>\n<th>Default File</th>\n<th>Changed by</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>stderr</td>\n<td>-l and -n command line options</td>\n<td>Informational and error messages</td>\n</tr>\n<tr>\n<td>/tmp/[name].xrootd/</td>\n<td>-n command line option and the adminpath directive</td>\n<td>Directory for various server-related files.</td>\n</tr>\n<tr>\n<td><cwd>/[name]/core[.pid]</td>\n<td>-n command line options</td>\n<td>Core file</td>\n</tr>\n<tr>\n<td>/tmp/[name]/exec.pid</td>\n<td>pidpath and -n option</td>\n<td>Holds the process id</td>\n</tr>\n<tr>\n<td>/tmp/exec.name.env</td>\n<td>adminpath and -n option</td>\n<td>Holds environmental information (see next section).</td>\n</tr>\n</tbody>\n</table>\n\n1.2.4.1 Environmental Information File\n\nThe daemon writes environmental information in the directory specified by adminpath directive, or its default. This information can be used to automatically collect all relevant information about a daemon to facilitate automatic problem resolution.\n\nThe environmental file is named “exec.name.env” where exec is the executable’s name and name is the instance name (i.e. -n option) and anon if no instance name was specified. The format of the information is shown below. When parsing this information, you should not depend on the order shown below.\n\n```\n pid=pid&host=host&inst=inst &ver=ver&home=home&cfgfn=cfgfn&cwd=cwd&logfn=logfn\n```\n\n**Parameters**\n\n- `cfgfn`: The configuration file used.\n- `cwd`: The current working directory.\n- `host`: The host name.\n- `home`: The current working directory.\n- `inst`: The instance name.\n- `logfn`: The log file being used.\n- `pid`: The process id.\n- `ver`: The version string\n\nThese are the minimal elements. Additional elements may be added by specific protocols.\n### 1.2.5 Exported Environment Variables\n\nThe following table shows the environment variable exported by `xrootd`. These may be used by external programs and plug-ins, as needed. They should never be modified.\n\n<table>\n<thead>\n<tr>\n<th>XRD Variable</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>XRDADMINPATH</td>\n<td>Is the directory for administrative files (i.e. <code>all.adminpath</code>)</td>\n</tr>\n<tr>\n<td>XRDCONFIGFN</td>\n<td>The effective administrative path used for server management files.</td>\n</tr>\n<tr>\n<td>XRDEBUG</td>\n<td>Set to one when the <code>-d</code> command line option is specified.</td>\n</tr>\n<tr>\n<td>XRDHOST</td>\n<td>The current host’s DNS name.</td>\n</tr>\n<tr>\n<td>XRDINSTANCED</td>\n<td>Is the string of the form “execname instance@hostname”. Where execname is the executable’s name, instance is the name specified via <code>-n</code> or <code>anon</code> if no instance name was specified, and hostname is the current host’s DNS name.</td>\n</tr>\n<tr>\n<td>XRDLOGDIR</td>\n<td>Is the directory where log files are written.</td>\n</tr>\n<tr>\n<td>XRDNAME</td>\n<td>The name specified via <code>-n</code> or <code>anon</code> if no instance name was specified.</td>\n</tr>\n<tr>\n<td>XRDPROG</td>\n<td>The executable’s name.</td>\n</tr>\n<tr>\n<td>XRDSITE</td>\n<td>The site name specified either via the <code>-s</code> command line option or the <code>all.sitename</code> directive.</td>\n</tr>\n</tbody>\n</table>\n\nIf the standard **cms** client plug-in is being used, the following additional environment variables are exported.\n\n<table>\n<thead>\n<tr>\n<th>CMS Variable</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>XRDCMSMAN</td>\n<td>The space separated list of managers for this host each in the form of “host:port”.</td>\n</tr>\n<tr>\n<td>XRDCMSCLUSTERID</td>\n<td>The globally unique cluster identification for this host.</td>\n</tr>\n</tbody>\n</table>\n\nIf the standard **ofs** plug-in is being used, the following additional environment variables are exported.\n\n<table>\n<thead>\n<tr>\n<th>OFS Variable</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>XRDROLE</td>\n<td>The effective value specified on the <code>all.role</code> directive.</td>\n</tr>\n<tr>\n<td>XRDTPC</td>\n<td>Is set when TPC (Third Party Copy) has been configured and represents the version number of the protocol. If the first character is a plus sign, authentication is required.</td>\n</tr>\n</tbody>\n</table>\nIf the standard **oss** plug-in is being used, the following additional environment variables are exported.\n\n<table>\n<thead>\n<tr>\n<th>OSS Variable</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>XRDN2NLIB</td>\n<td>The path and name of the name-to plug-in, if specified via the <strong>oss.namelib</strong> directive.</td>\n</tr>\n<tr>\n<td>XRDRMROOT</td>\n<td>The local root path specified by the <strong>oss.remoteroot</strong> directive.</td>\n</tr>\n<tr>\n<td>XRDLCLROOT</td>\n<td>The local root path specified by the <strong>oss.localroot</strong> directive.</td>\n</tr>\n<tr>\n<td>XRDOSSQUOTAFILE</td>\n<td>The name and location of the file handling disk space quotas.</td>\n</tr>\n<tr>\n<td>XRDOSSUSAGEFILE</td>\n<td>The name and location of the file handling disk space usage.</td>\n</tr>\n</tbody>\n</table>\n\nIf the standard **xrootd** protocol plug-in is being used, the following additional environment variables are exported.\n\n<table>\n<thead>\n<tr>\n<th>XROOTD Variable</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>XRDOFSLIB</td>\n<td>The path and name of the OFS plug-in specified by the <strong>xrootd.fslib</strong> directive.</td>\n</tr>\n<tr>\n<td>XRDMONRDR</td>\n<td>If monitoring is enabled, how often server identification records are sent.</td>\n</tr>\n</tbody>\n</table>\n2 Framework Directives by Category\n\nThis section provides a guide to xrd directives by category that is helpful when you need to address a specific requirement.\n\n2.1 Debugging\n\nxrd.trace Specify which framework activities are to be traced.\n\n2.2 Monitoring\n\nxrd.report Specify which execution summary statistics are to be gathered and where they are to be sent.\n\nall.sitename Specify the name of the site to be used for monitoring purposes.\n\nxrd.tcpmonlib Specify the plug-in to be used to collect and report specialized TCP connection statistics.\n\n2.3 Networking\n\nxrd.network Specify network parameters such as DNS usage, interfaces, keep-alive characteristics, and routing.\n\n2.4 Operational Environment\n\nall.adminpath Specifies the location of runtime files used for administrative purposes.\n\nxrd.homepath Specifies the location of the working directory during execution.\n\nall.pidpath Specifies where the file containing the server’s process id should be created.\n\n2.5 Protocol support\n\nxrd.port Specifies the default port number for incoming requests.\n\nxrd.protocol Load additional protocols such as HTTP.\n2.6 Security and TLS\n\n- **xrd.allow**: Restricts hosts that can connect to the server.\n- **xrd.tls**: Specify the location of the server’s host certificate.\n- **xrd.tlsca**: Specify the location of CA certificates and CRLs.\n- **xrd.tlsciphers**: Specify allowable TLS ciphers.\n\n2.7 Tuning\n\n- **xrd.buffers**: Limit the amount of memory used for data buffers.\n- **xrd.sched**: Specify execution parameters such as core file creation, default stack size, and threading.\n- **xrd.timeout**: Specify various connection handling timeout parameters.\n3 Common Framework Configuration Directives\n\n3.1 adminpath\n\n```\nall.adminpath path [ group ]\n```\n\n**Function**\n\nSpecify the location of protocol-specific files for administrative purposes.\n\n**Parameters**\n\n- **path** The absolute path to a directory that is to hold protocol-specific files. The path should be no longer than 76 characters. See the notes for details.\n\n- **group** Allows read/write group access to any named sockets created in the `path`. By default, only the owner can use such sockets.\n\n**Default (see warning in the notes)**\n\n```\n/ tmp\n```\n\n**Notes**\n\n1) The `adminpath` directive allows you to specify the location of the local TCP sockets used for the command-line administrative functions along with special directories that are needed to handle protocol specific features.\n\n2) Use the `-a` or `-A` command line option to set the defaults for the `adminpath` directive.\n\n3) If `-n` is specified on the command line, a subdirectory corresponding to the instance name (i.e., `-n` argument) is created in `path`, if one does not exist. This becomes the new `path`. This allows fencing multiple daemons running on the same node.\n\n4) **Warning:** if idle `/tmp` directories and socket files are automatically deleted by the system, you should specify a path other than `/tmp`. Be aware if neither `-a` command line option nor the `adminpath` directive is specified, the default becomes `/tmp`. External removal of files stored in the `adminpath` may lead to server failure.\n5) When specifying an **adminpath**; be cognizant that the program may be containerized and the path may not be suitable for that environment. Confer with your system administrators on what the suitable path should be if the program will run in a container.\n\n6) Local **TCP** socket names are limited to 108 characters. Up to 32 characters are needed to define actual socket files; leaving 76 characters that may be specified for the **path**.\n\n7) The following steps are taken when creating a **Unix** named socket in path:\n - The subdirectory `.xrd` is created in **path** and\n - the **cmsd** daemon creates subdirectory `.olb` while\n - the **xrootd** daemon creates subdirectory `.xrootd` in **path**.\n - Mode bits for these directories are set to 0700 (rwx for owner). If the directories already exist, the mode settings are reset to correspond to the **adminpath** directive.\n - If **group** was specified, the mode setting is extended to 0770 (rwx for owner and group).\n - If the directories already exist, the mode settings are reset to correspond the to the **adminpath** directive specification.\n - Server, manager, and supervisor **cmsd**’s create stream sockets named “olbd.admin”, “olbd.nimda”, and “olbd.super” in the `.olb` subdirectory, respectively. These sockets are used for administrative communication.\n - Server and manager **cmsd**’s respectively create datagram socket named “olbd.notes” and “olbd.seton” in the `.olb` subdirectory. These sockets are used for external notifications.\n - The **xrootd** daemon creates a **Unix** named socket with the name “admin” in the `.xrootd` subdirectory.\n\n8) The **adminpath** value is passed to all protocols so that they can create their respective administrative files in **path**. However, for the **cmsd** only, you may specify an exception by using the **cms.adminpath** directive to create a completely different path for its files.\n\n9) Refer to the section “Administrative Interface” for details on how to use the **Unix** named socket created by various protocols and daemons.\n\n1) **Example**\n\n ```\n all.adminpath /var/adm/xrd group\n ```\n3.1.1 Administrative Interface\n\nThe adminpath directive is used to construct the path where local TCP sockets, called named sockets, are created. These sockets are used to communicate requests and receive responses via the administrative interface. Unix domain sockets function identically as INET domain sockets. The only differences are in how the socket is created and the domain in which it operates. Care should also be given as to who creates the socket. Following the next steps will allow the successful use of the administrative interface.\n\n1. Wait until the server creates that the socket file (e.g., “/tmp/.xrootd/admin” or “/tmp/.olb/notes”). This can be done by polling for the socket using stat().\n2. Create a stream socket using socket(PF_UNIX, SOCK_STREAM, 0)\n3. Properly fill out the sockaddr_un structure with the path name of the socket (e.g., “/tmp/.xrootd/admin”). This structure is normally defined in the <sys/un.h> include file.\n4. Issue a connect() call to connect the newly created socket to the path.\n5. Use write() to issue requests to the server and read() to read responses.\n\nThe administrative protocol used for the socket interface is defined elsewhere.\n3.2 allow\n\n```\nxrd.allow { host | netgroup } name\n```\n\n**Function**\nRestrict the hosts that can connect to \\texttt{xrootd}.\n\n**Parameters**\n\n- **host** \\texttt{name}\n \nThe DNS host name allowed to connect to \\texttt{xrootd}. Substitute for \\texttt{name} a host name or IP address. A host name may contain a single asterisk anywhere in the name. This lets you allow a range of hosts should the names follow a regular pattern. IP addresses may be specified in IPV4 format (i.e. “a.b.c.d”) or in IPV6 format (i.e. “[x:x:x:x:x]”).\n\n- **netgroup** \\texttt{name}\n \nThe NIS netgroup allowed to connect to \\texttt{xrootd}. Substitute for \\texttt{name} a valid NIS netgroup. Only hosts that are members of the specified netgroup are allowed to connect to \\texttt{xrootd}.\n\n**Defaults**\nNone. If \\texttt{allow} is not specified, any host is allowed to connect.\n\n**Notes**\n\n1) You may specify any number of hosts and netgroups. Any host matching a specified name or is a member of a specified netgroup is allowed to connect to \\texttt{xrootd}.\n\n2) \\textbf{Warning!} Using hostname based security relies on the security of the DNS server and the inability of other hosts spoofing and successfully using the “allowed” IP addresses. The two security assumptions have severe limitations.\n\n**Example**\n```\nxrd.allow host objyana*.slac.stanford.edu\n```\n3.3 homepath\n\n```\nxrd.homepath path [ group ]\n```\n\n**Function**\nSpecify the location of the current working directory.\n\n**Parameters**\n- `path` The absolute path to a directory that is to be used as the working directory.\n- `group` Allows read group access to `path`. B\n\n**Default**\nWhatever is the directory on start-up.\n\n**Notes**\n1) Use the `-w` or `-W` command line option to set the home path. When the home path is set on the command line, it cannot be overridden with the `homepath` directive.\n2) If `-n` is specified on the command line, a subdirectory corresponding to the instance name (i.e., `-n` argument) is created in `path`, if one does not exist. This becomes the new `path`. This allows fencing multiple daemons running on the same node.\n3) When specifying a `homepath`; be cognizant that the program may be containerized and the path may not be suitable for that environment. Confer with your system administrators on what the suitable path should be if the program will run in a container.\n\n**Example**\n```\nall.homepath /var/run/xrd group\n```\n3.4 **tls** *(required for TLS)*\n\n```plaintext\nxrd.tls cpath [ kpath ] [ options ]\n\noptions: [[no]detail] [hsto to{h|m|s}]\n```\n\n**Function**\n\nConfigure transport layer security (TLS).\n\n**Parameters**\n\n- **cpath** Specifies the absolute path to the x509 certificate file to use for TLS. The certificate must be in PEM format. The file may only be written by the owner of the file.\n\n- **kpath** Specifies the absolute path to the certificate's x509 private key file to use for TLS. The key must be in PEM format. The file may only be read and written by the owner of the file. If **kpath** is not specified then the certificate file must contain the key.\n\n- **[no]detail** When **detail** is specified, detailed TLS trace back messages are printed along with explanatory messages. The **nodetail** option suppresses the TLS trace back messages. The default is **nodetail**. See the notes why this is so.\n\n- **to** Specifies the maximum amount of time a TLS handshake is allowed to take before the connection is closed. The **to** value may be suffixed by **h** for hours, **m** for minutes, or **s** for seconds, respectively; otherwise, the **to** value defaults to seconds. There is no default time limit for the TLS handshake.\n\n**Defaults**\n\nTLS is not configured and cannot be used. See individual options for the defaults should you configure TLS.\n\n**Notes**\n\n1) Normally, a host certificate should be used because the client can use it to validate that it connected to the intended host.\n2) If you specify the `tls` directive then you must specify the `tlsca` directive as well.\n\n3) Most TLS trace back messages do not provide any more information than the companion explanatory messages and, as such, is only useful for debugging purposes. This is why `nodetail` is the default. However, if you enable TLS tracing using the `xrd.trace` directive, `detail` is enabled regardless of what is specified.\n\nExample\n\n```\nxrd.tls /etc/security/xrootd/hostcert.pem\n```\n3.5 **tlsca** *(required for TLS)*\n\n```bash\nxrd.tlsca noverify | {certdir | certfile} path [options]\n```\n\n```bash\noptions: [crlcheck {all | external | last}]\n\n[log {failure | off}] [[no]proxies]\n\n[refresh rint[h|m|s]] [verdepth vdn]\n```\n\n**Function** \nConfigure client certificate verification for transport layer security (TLS).\n\n**Parameters** \n\n**noverify** \nDisables client certificate verification. All subsequent parameters, if any, are ignored.\n\n**certdir** *path* \nSpecifies the absolute path of the directory containing trusted Certificate Authority certificates that can be used to verify client certificates. Each file in the directory may only contain a single certificate in PEM format. Naming conventions are those required by the version of OpenSSL being used. The directory may only be written to by the owner of the directory.\n\n**certfile** *path* \nSpecifies the absolute path to the file containing one or more trusted Certificate Authority certificates that can be used to verify client certificates. The certificates in the specified file are used first before an attempt is made to find an appropriate certificate in `certdir`, if specified. The file must be in PEM format. The file may only be written to by the owner of the file.\ncrlcheck\nSpecifies the certificate revocation list (crl) is to be handled. Choose one of the following:\nall - apply crl checking to the complete certificate chain.\nexternal - crl application is handled by an external plug-in (the default).\nlast - apply crl checking only to the last certificate in the chain.\n\nlog\nSpecifies logging requirements. Logging messages are written to the log file. Choose one of the following:\nfailure - log failed verifications (the default).\noff - verification failures are not to be logged.\n\nvdn\nSpecifies the verification depth. Should the client present a certificate chain, up to the last vdn certificates are verified. Specify a value between 1 and 256, inclusive. The default is 9.\n\nrint\nSpecifies the refresh interval. Suffix the value with h for hours, m for minutes, or s for seconds (the default). The default is 8h (eight hours).\n\nDefaults\nxrd.tlsca crlcheck external log failure proxies refresh 8h verdepth 9\n\nNotes\n1) You may specify both a directory and a file. The certificates in the certfile will be searched before any certificates in certdir.\n2) If all the loaded protocols use strong authentication (e.g. Kerberos, GSI, or SSS) client certificate verification is not necessary as the client will be verified using a strong authentication mechanism and the client’s certificate will only be used to establish a TLS connection.\n3) Certain protocols require certificate verification (e.g. HTTPS). If you enable one of these protocols you should enable verification overall to avoid specifying protocol specific directives that duplicate ones that could be specified using the tlsca directive.\n4) In the absence of strong authentication, you should always verify client certificates. Generally, you should always verify client certificates. This is why the directive requires that you make an explicit choice.\n5) All of the certificates in the directory, as well as the file, must in a format that is recognized by the version of OpenSSL being used.\n6) If you use a `certdir` be aware that `OpenSSL` requires that the `c_rehash` utility be run after the certificates in the directory are updated. This introduces a race condition between refreshes and updates to the directory and may produce verification failures should a refresh occur while the directory is being updated. You can avoid this problem by making sure that changes to the directory are visibly done in an atomic fashion.\n\nExample\n\n```\nxrd.tlsca certfile /etc/security/xrootd/cacerts.pem\n```\n4 Esoteric Framework Configuration Directives\n\n4.1 buffers\n\n```\nxrd.buffers memsz[k | m | g] [rint[m | s | h]]\n```\n\nFunction\nLimits the amount of memory to be used to data buffers.\n\nParameters\n\n```memsz```\nThe maximum number of bytes to be used for data buffers. The `memsz` can be suffixed by `k`, `m`, or `g` to indicate kilo-, mega-, or giga-bytes; respectively. The default is to use up to 12.5% (one-eighth) of the configured memory of the machine.\n\n```rint```\nThe interval between buffer pool readjustments. Specify a number, optionally suffixed by `m` for minutes, `s` for seconds (the default), or `h` for hours. The default is every 20 minutes.\n\nDefaults\n```\nxrd.buffers memsz 20m\n```\n\nNotes\n1) The allotted memory for buffers is independent of any other memory allotment to the daemon.\n2) Data buffers in the pool are periodically readjusted to reflect the actual working needs of the daemon. The `rint` interval controls how frequently this adjustment occurs. The default value is usually the best value.\n\nExample\n```\nxrd.buffers 512M\n```\n4.2 network\n\n```\nxrd.network [buffsz blen[k | m | g]] [cache sec]\n [[no]dnr] [[no]dyndns]\n [kaparms idle[,itvl[,cnt]]] [[no]keepalive]\n [routes {split|common|local} [use if1[,if2]]]\n [[no]rpipa] [tls]\n```\n\n**Function**\nSpecify network parameters.\n\n**Parameters**\n\n**buffsz** *blen*\nThe buffer size to be set for each connected socket. The *blen* can be suffixed by *k*, *m*, or *g* to indicate kilo-, mega-, or giga-bytes; respectively. The default is determined by the operating system.\n\n**cache** *sec*\nThe maximum number of seconds that an address to hostname translation can be locally cached for future use. See the notes on its interaction with *dyndns*. The *sec* can be suffixed by *s*, *m*, *h* or *d* to indicate seconds, minutes, or hours, or days; respectively. The default is 3 hours.\n\n**dnr**\nUses Domain Name Resolution to convert IP addresses to host name for connecting clients. Host names are displayed in various messages.\n\n**nodnr**\nAvoids using Domain Name Resolution to convert IP addresses to host name for connecting clients. Client IP addresses are displayed in various messages.\ndyndns\nThe network uses a Dynamic DNS for name resolution. See the section on Dynamic DNS for information on when you should specify this option. See the notes on its interaction with cache.\n\nnodyndns\nThe network uses a standard DNS whose name entries are stable. This is the default.\n\nkaparms idle[,itvl[,cnt]]\nSpecifies TCP keepalive parameters. The kaparms option is only effective for Linux. Up to three parameters may be specified. Omitted parameters, as well as parameter values of zero, use the system default. The parameters are:\n\nidle The time the connection needs to remain idle before TCP starts sending keepalive probes. The idle value may be optionally suffixed by m for minutes, s for seconds (the default), or h for hours.\n\nitvl The time between individual keepalive probes. The itvl value may be optionally suffixed by m for minutes, s for seconds (the default), or h for hours.\n\ncnt The maximum number of keepalive probes TCP should send before dropping the connection.\n\nkeepalive\nUses the operating system’s keep-alive mechanism to determine whether or not a client is still connected to the daemon. This is the default. See the usage notes for other ways of simulating keepalive.\n\nnokeepalive\nDoes not use the operating system’s keep-alive mechanism to determine whether or not a client is still connected to the daemon.\n\nroutes\nSpecifies that a dual network exists and how public and private addresses are routed within a site. Select one of the below optionally followed by the use keyword and up to two interface names (i.e. if1 and optionally if2 immediately preceded by a comma; use ifconfig to display interfaces and their names):\n\nsplit Two separate networks exist. Clients connecting with a private address can only be redirected to a server’s private address. Clients\nconnecting with a public address can only be redirected to a server’s public address. If clients can use both types of addresses, all servers must be dual homed with a public and private address. Typically, you must specify the interfaces you are using.\n\n**Common**\n\nTwo common networks exist. Clients connecting with a private address are preferentially redirected to a server’s private address but may be redirected to a server’s public address if need be. However, clients connecting with a public address can only be redirected to a server’s public address. All servers must have at least a public address. If the machine is dual-homed you must specify the interfaces you are using.\n\n**Local**\n\nTwo cross-routable networks exist. Clients connecting with a private address are preferentially redirected to a server’s private address but may be redirected to a server’s public address if need be. Clients connecting with a public address are preferentially redirected to a server’s public address but may be redirected to a server’s private address if need be. This is the default mode of operation in order to be compatible with previous releases. If the machine is dual-homed it is advisable to specify the interfaces you are using for predictable access. *Warning,* such a network configuration is not suitable for external access and a proxy server must be used for out of domain clients.\n\n**rpipa**\n\nTries to resolve private IP addresses to host names. See the section on resolving private IP address for more information.\n\n**norpipa**\n\nDoes not resolve private IP addresses to host names. This is the default.\n\n**tls**\n\nIndicates that the specifications apply to the Transport Layer Security port.\n\n**Defaults**\n\n```\nxrd.network cache 3h dnr norpipa\n```\n\n**Notes**\n\n1) For systems that support TCP buffer auto-tuning as a manual option, specify a `buffsz blen` of 0 to turn on auto-tuning.\n2) Setting the buffer size to a large value may cause the operating system’s default value to be used. You should determine the maximum valid value for your system before specifying values greater that 64k.\n\n3) Normally, the best performance is obtained by using TCP buffer auto-tuning.\n\n4) Even if you specify nodnr, domain Resolution may be forced on if you specify an allow directive using a host name or host name fragment or authorize file access via host names, netgroups, or domain names. Resolution is still optimized by caching the results for future use.\n\n5) The daemon’s internal timeout mechanism can be used to discover unconnected clients instead of TCP keepalive and may be more responsive. See the timeout directive. You should avoid using both mechanisms at the same time.\n\n6) For aggressive keepalive processing you can use “kaparms 300,10,6”.\n\n7) By default, public-private networking support is disabled. You must specify the routes option to enable it. If you do specify for one server you must specify for all nodes in your cluster (i.e. servers and redirectors). Failure to do so may result in unreachable nodes.\n\n8) If the supplied information is inconsistent with the server network settings, warning messages are printed and the public-private network support may be turned off for that server. You should verify that your specification is consistent with the server’s networking configuration.\n\n9) Interface names are arbitrary but usually are of the form enx, ethx, etc. One interface must be assigned a public address and the other the private address. This mechanism works best when all of the servers in a cluster use the same interface naming conventions; though the address assignments may differ. If this is not the case, you will need to use the if-else-fi configuration syntax to special case particular nodes.\n\n10) Dual public/private network are fully supported in Linux, MacOS, and in Solaris 11.\n\n11) IP address caching is generally incompatible with a dynamic DNS. When dyndns is specified but no cache option has been specified, the cache timeout is set to zero. This effectively turns off IP address caching.\n\nExample\n\n xrd.network nokeepalive nodnr\n xrd.network tls buffsz 512k\n4.2.1 Dual Public/Private Network Guidelines\n\nBefore you configure a dual public/private network, determine if such a network is actually necessary. Administering dual networks is difficult and problem resolution rather onerous. Typical reasons and alternatives to running a dual network are:\n\n- Conserving IPV4 addressees: consider using IPV6, which does not suffer from this problem.\n- Performance: if private addresses are routed along with public addresses over the same networking hardware then the switch becomes the bottleneck and performance improvements are moot.\n- Security: if you desire to restrict certain kinds of access you may be able to achieve the same result using router and switch settings (e.g. file walls, routing restrictions, etc) thus avoiding a dual network.\n\nIf you still wish to run a dual network, you should use the following guidelines to avoid access surprises and mysterious performance issues.\n\n- Never register private addresses in a publicly accessible DNS server. This exposes your private network configuration and is considered bad practice. Private addresses should only be registered in a private DNS or zone registered to prevent external leakage.\n- Never register a server’s private and public address under a single host name unless both addresses have equal connectivity. While this practice works for simple applications, complex applications like XRootD and Proof attempt to use all addresses assigned to a particular host name. If connectivity is unequal, performance issues and connection failures are likely to occur.\n- Never cluster servers with only a public address with servers that only have a private address if their name spaces overlap. While this may work for certain network routing topologies, it invariably introduces inconsistencies.\n- Carefully review the routes option on the xrd.network directive to make sure your network routing topology and interfaces are correctly stated.\n4.2.2 Resolving Private IP Addresses\n\nBy default, private IP addresses are not resolved to host names. This is commonly accepted practice to avoid DNS timeouts as private addresses are usually not registered in DNS. However, some installations may opt to register such addresses in either a private DNS or in a zoned public DNS. This actually may be necessary in cloud deployments where nodes within the cloud receive private addresses and a NAT box is installed to provide outside access. In such cases, there is usually a 1-to-1 mapping between a public address (e.g. IPv6) to a corresponding private address (e.g. IPv4). The public address is registered in a public DNS while the private address is registered in a private DNS within the cloud. Both addresses are registered with the same host name. However, to avoid leaking private addresses you must specify the `xrd.network rpipa` option so that only host names are returned and not actual addresses. This allows clients on the public network to access nodes in the private network using the NAT box. Nodes in the private network also receive host names but since these names are registered within the private network, proper address resolution occurs.\n\n4.2.3 Dynamic DNS\n\nThe `dyndns` option specifies that a Dynamic DNS is being used for the network. This is typically the case for containerized cloud deployments (private or public) managed by an orchestration scheme (e.g. Kubernetes). In such schemes, when a container starts with an arbitrary local IP address, its host name and address are entered into a local DNS. When the container stops, the entry is removed. Even on a container restart, the entry may be removed between the time the container stops and the time it restarts with a new IP address. This becomes a problem for servers expecting to contact specific services when those services have not yet been started or are being restarted. In the XRootD framework, cluster management services that supervisor and data servers rely on expect those services to be permanently registered in DNS; albeit with arbitrary non-permanent IP addresses.\n\nThe `dyndns` option notifies all nodes in an XRootD cluster using the network that DNS entries may come and go and resolution of IP addresses needs to be done at the time of contact not during initialization. Failure to specify the `dyndns` option when a Dynamic DNS is actually being used inevitably leads to random failures.\n\nOf course, you may be able to avoid using a Dynamic DNS if you opt for host networking, at least for management services. However, many times that is not an option and when allowed severely limits orchestration choices.\n4.3 pidpath\n\n```\nall.pidpath path\n```\n\nFunction\nSpecify the location where the process id file (i.e. pid file) is to be written.\n\nParameters\n\n- `path` The path to be used to create the file where the daemon’s process id is stored.\n\nDefaults\nThe process id file is written into `/tmp`.\n\nNotes\n1) If `-n` is specified on the command line, a subdirectory corresponding to the instance name (i.e., `-n` argument) is created in `path`, if one does not exist. This becomes the new `path`. This allows fencing multiple daemons running on the same node.\n2) The `-s` command line option may be used to specify the path and filename to be used for the `pid` file.\n3) The name of the `pid` file corresponds to the executable name suffixed by “.pid”.\n\nExample\n```\nall.pidpath /var/run/scalla\n```\n4.4 port\n\nFunction\nDesignate the port number to use for incoming requests.\n\nParameters\ntls Sets the preferred TLS-only (Transport Layer Security) port number. Otherwise, the default port number is set. See the usage notes on how the default is determined and the caveats when using the tls option.\n\npnum The TCP port number or the TCP service name associated with a port in /etc/services file that the daemon should use for incoming requests. See the usage notes on how the default is determined.\n\nany Specifies that any available TCP port number may be used for incoming requests. See the usage notes on how the default is determined.\n\nconds The conditions that must exist for this directive to apply. Refer to the description of the “if” directive on how to specify conds.\n\nDefaults\nSee the usage notes.\n\nNotes\n1) The default port number is determined using the following rules:\n • The protocol specified port when the protocol is loaded.\n • The port specified on the protocol directive entry.\n • The port specified on the command line using –p.\n • Any available port number if -p any was specified on the command line.\n • The port associated with the service name that corresponds to the name of the program used to start the daemon (e.g., xrootd).\n • The port value of 1094.\n2) The `tls` port number need only be specified if you wish to have a port that can only communicate using TLS at the outset. A client may discover this port using the `kXR_query` request with the `tlsport` as an argument. If not specified or used by a protocol, no TLS-only port is created.\n\n3) Not all protocols support a TLS-only port. For instance, the `xroot` and `xroots` protocols negotiate TLS with the client and must first communicate without using TLS. So, TLS-only port cannot be used. The `http` protocol can use such a port but only for `https` connections. However, TLS-only port prevents it redirecting a TLS connection to a non-TLS connection.\n\n4) When running clustered systems, you can keep a single configuration file that is applicable to all types of servers, as follows:\n - always specify “`xrd.port any`” in the configuration file, and\n - use the `if` modifier to identify the top-most servers (i.e., the initial point of contact also known as redirectors) and assign them fixed port numbers immediately following the “`xrd.port any`” directive.\n\n4) Using the steps outlined above, the initial point of contact will have a well-known port number. While all other servers will choose random port numbers, the ports are communicated to the cluster manager which then automatically manages the port numbers while redirecting clients.\n\nExample\n\n```plaintext\nxrd.port xrdnew\n```\n4.5 protocol\n\n```\nxrd.protocol [tls] name[:port] (+port | {lib | *}) [parms]\n```\n\n**Function**\nConfigure a protocol that xrd is to use for incoming requests.\n\n**Parameters**\n\n- **tls** Indicates that any connection to the port must communicate using TLS at the outset. Not all protocols support this option. See the notes for caveats.\n\n- **name** The name of the protocol you wish to configure.\n\n- **port** The port number the protocol is to use for incoming requests. Specify a number, the name of a TCP service, or the word any. If port is not specified, the preferred port is used (see the xrd.port directive).\n\n- **+port** Adds the specified port to the list of port number that the protocol may receive connections. The protocol name must have been previously defined. You may not omit the port specification when using this parameter. If the port already is associated with the protocol, only the tls designation is updated.\n\n- **lib** The path to the shared library that contains the code the implements the protocol. If lib is an asterisk, the protocol refers to the built-in or the command line assigned protocol. Any pre-existing protocol definition with the same name is completely replaced by this definition.\n\n- **parms** Parameters to be passed to the protocol at load time.\n\n**Defaults**\nNot applicable.\n\n**Notes**\n1) The daemon expects that only one protocol is built-in. The name of this protocol must correspond to the name of the program implementing the daemon (e.g., xrootd implies xroot protocol). The built-in protocol may be overridden by the -P and -L command line options.\n2) The built-in or assigned protocol is always loaded first followed by any additional protocols in the order they appear in the configuration file.\n\n3) The **tls** option is meant to be used for protocols that require **TLS** but cannot configure it themselves. The **xroot** protocol is incompatible with this option as it negotiates the use of **TLS** using a non-**TLS** connection. The **http** protocol can work but only for **https** connections. However, enforcing **TLS** at the outset disables its ability to redirect a **TLS** connection to a non-**TLS** connection.\n\n4) Most protocols can share the same port number because the framework picks the protocol that is compatible with the incoming data. For instance, the **xroot** and **http** protocols can both use the same port number. The framework automatically enables the **xroot** base port for **http** use. This makes it convenient in a clustered environment when an **http** connection is redirected to an **xroot** port number.\n\n5) When the specified protocol name matches a previously declared protocol the **port**, **lib**, and **parms** specifications replace those in the previously specified directive. If the **port** is missing, the protocol uses its default port number. If the **parms** are missing then any existing **parms** are removed from the previous specification.\n\n6) Additional protocols are dynamically loaded from the indicated **lib**.\n\n7) A port of **any** assigns an arbitrary port number to the protocol.\n\n8) Be aware that a protocol may choose its own port irrespective of what is actually specified. While current protocols respect the configured specification, future ones may not.\n\n9) Only those protocols bound to a specific port are matched against incoming connections on that port. The daemon attempts to match each such protocol with an incoming connection on the associated port in the order that the protocols are specified. The built-in protocol is always tried first, if applicable.\n\n10) Load-time parameters are specific to each protocol. Refer to the protocol requirements for details.\n\n11) The **cms** and **xroot** protocols do not have any load-time parameters.\n\n12) Up to eight different protocols may be specified. Each protocol may be assigned up to 8 different ports.\n\n**Example**\n\n```\nxrd.protocol http:8000 libXrdHttp.so\nxrd.protocol http:8080 +port\n```\n4.6 report\n\n**xrd.report dest1[,dest2] [every rsec] [-]option**\n\n*option*: all | buff | info | link | poll | process | prot[ocols] | sched | sgen | sync | syncwp\n\n[[-]option]\n\n**Function**\nSpecify execution tracing options.\n\n**Parameters**\n\n*dest1* is a *host:*port or a UDP named local socket where reports are to be sent. Reports are always sent as a single UDP message.\n\n*dest2* is a secondary destination and must differ from *dest1*. The same report is delivered to *dest2* and *dest1*.\n\n*r sec* determines how often reports are sent. Specify a number, optionally suffixed by *m* for minutes, *s* for seconds (the default), or *h* for hours. The default is every 10 minutes.\n\n*option* Specifies the reporting level. One or more options may be specified. The specifications are cumulative and processed left to right. Each option may be optionally prefixed by a minus sign to turn off the setting. The following options produce reports on:\n\n- **all** selects all possible reports\n- **buff** I/O buffer activity\n- **link** connection and socket I/O activity\n- **poll** socket activity other than I/O\n- **process** process resources\n- **protocols** protocol specific information\n- **sched** scheduling and thread activity\n- **sgen** statistics generation\n- **sync** synchronizes data for completeness (see the notes)\n- **syncwp** synchronizes data only when practically possible\nDefaults\nReporting is disabled.\n\nNotes\n1) Report messages are encoded in XML format. Refer to the xrootd protocol specification on the actual format and embedded information; as described under the response format for the kXR_QStats option of the kXR_query request.\n2) By default, statistical values are obtained without data access synchronization. This may occasionally produce incomplete or inaccurate values. However, because information is collected asynchronously this has little impact on the server.\n3) If absolute accuracy is required, you should specify the sync option. Be aware that reporting may require a significant amount of elapsed time while the server synchronizes its activities in order to produce accurate and consistent data.\n4) If absolute accuracy is desired but not required, you should specify the syncwp option. The server synchronizes its activities only when possible. If the server is too active, an asynchronous report is done. The sgen report segment provides information on whether the report was synchronous or not and how much time it took to generate.\n5) For scalability reasons, you should feed all UDP messages to one or more collectors whose sole function is to multiplex the UDP message streams into a single buffered serial stream. Generally, attempting to do more in a UDP message receiver substantially increases the chance for lost UDP messages.\n6) A UDP message multiplexor and XML parser, mpxstats, is available as part of the reference XRootD distribution. Refer to the “Monitoring” reference for details.\n\nExample\nxrd.report myhost:1234 every 15m all -poll\n### 4.7 sched\n\n<table>\n<thead>\n<tr>\n<th><strong>xrd.sched parms</strong></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>parms:</strong> [avlt avlt] [core {asis</td>\n</tr>\n<tr>\n<td>[idle idle] [maxt maxt] [mint mint] [stksz size]</td>\n</tr>\n</tbody>\n</table>\n\n**Function**\n\nSpecify when threads are created, how many can be created, and when they should be destroyed.\n\n**Parameters**\n\n**avlt**\n\nThe number of threads that must always be available to service a request. These threads are never bound to any connection. Excess threads above this quantity will be allowed to bind with a socket until either the socket becomes idle or the number of available threads falls under `avlt`. The default is one half of the `mint` value.\n\n**core** {asis | max | off}\n\nSets the limit for core file production. Choices are:\n- **asis** - leave the current setting alone.\n- **max** - allow core files up the hard limit maximum (the default).\n- **off** - turn off core file production.\n\n**idle**\n\nThe interval between checks for underused threads. Underused threads in excess of the `mint` value are terminated. Specify a number, optionally suffixed by m for minutes, s for seconds (the default), or h for hours. The default is every 13 minutes (i.e., 13m). Specifying a value of zero prevents threads from being terminated even if they are idle.\n\n**maxt**\n\nThe maximum number of threads that may be created to service requests. The number of threads will dynamically vary between `mint` and `maxt`. \n**mint** *mint*\n\nThe minimum number of threads that must exist to handle requests. Once this number has been created, it is never reduced.\n\n**stksz** *size*\n\nThe default thread stack size. Specify the number of bytes, optionally suffixed by *k* for kilobytes or *m* for megabytes. The default is controlled by the target operating system.\n\n**Defaults**\n\n```\nxrd.sched mint 8 maxt 2048 avlt 512 idle 780\n```\n\n**Notes**\n\n1) The *mint*-number of threads are eventually created.\n2) The stack size is controlled by the target operating system used to create *xrootd*. For instance, in Solaris when `sizeof(long)` is 4 (indicating a 32-bit architecture), a 1M stack size is used. When `sizeof(long)` is 8 (indicating a 64-bit architecture or an LP64 data model) a 2M stack size is used. In Linux, the stack grows, as needed, to a maximum of 2M.\n3) You should periodically review whether or not you have sufficient number of threads. The daemon prints a warning message the first time the *maxt* value is reached and more threads are needed.\n4) If the daemon indicates that the thread limit was reached but less than *maxt* threads were created; then the target operating system maximum has been reached. This now becomes the new *maxt* value.\n5) **Warning**, you should not change the thread parameters unless there is an overpowering reason to do so. The system is optimized for having many thread readily available. Constraining the number of threads may yield random failures that are hard to explain.\n\n**Example**\n\n```\nxrd.sched mint 10 maxt 100 avlt 20\n```\n4.8 sitename\n\nall.sitename sname\n\nFunction\nSpecify the site name to be included in monitoring records.\n\nParameters\nsname\nThe 1- to 63-character name of the site. The name may include letters, digits, and the symbols \"-_:.\". Other symbols are converted to a period. If the name is longer than 63 characters it is truncated to 63 characters.\n\nDefaults\nNone.\n\nNotes\n1) The -S command line option overrides the sitename directive.\n2) The first sitename directive takes precedence over any subsequent sitename directives.\n\nExample\nall.sitename slac\n4.9 tcpmonlib\n\nxrd.tcpmonlib [++] path [parms]\n\nFunction\nSpecify the location of the TCP connection statistics monitoring plug-in.\n\nParameters\n++ The specified plug-in should stack on top of the existing plug-in or default. A stacked plug-in cannot be overridden by a subsequent directive.\n\npath The absolute path to the shared library that contains an implementation of the TCP connection statistics monitor.\n\nparms Optional parameters to be passed to the plug-in object creation function.\n\nDefaults\nNone.\n\nNotes\n1) The TCP connection monitor plug-in interface is defined in the XrdTcpMonPin.hh include file. Refer to this file on how to create a custom monitoring plug-in.\n2) You must specify the tcpmon option in the xrootd.monitor directive in order to enable the TCP connection monitoring.\n3) The plug-in is called just before the TCP socket to a client is closed.\n\nExample\nofs.authlib /opt/xrootd/lib/libAuth.so\n4.10 timeout\n\n**xrd.timeout** *parms*\n\n```plaintext\nparms: [hail hlto[h | m | s]] [idle idto[h | m | s]]\n[kill klto[h | m | s]] [read rdto[h | m | s]]\n```\n\n**Function**\nSpecify timeout parameters.\n\n**Parameters**\n\n**hail hlto**\nThe maximum number of seconds to wait for data to arrive after a connection is accepted. Specify a number optionally suffixed by **h** for hours, **m** for minutes, or **s** for seconds, the default.\n\n**idle idto**\nThe number of seconds a connection may remain idle before it is closed. Specify a number optionally suffixed by **h** for hours, **m** for minutes, or **s** for seconds, the default. A value of 0 disables idle timeout processing.\n\n**kill klto**\nThe number of seconds to wait for an “end session” request to complete. Specify a number optionally suffixed by **h** for hours, **m** for minutes, or **s** for seconds, the default.\n\n**read rdto**\nThe number of seconds a read may wait for data before it is either terminated or rescheduled. Specify a number optionally suffixed by **h** for hours, **m** for minutes, or **s** for seconds, the default.\n\n**Defaults**\n\n```\nxrd.timeout hail 30 idle 0 kill 3 read 5\n```\nNotes\n\n1) The idle timeout prevents accumulation of dead connections which may happen when a client host machine crashes.\n2) Currently, idle timeouts are disabled. You may enable them by specifying an $idto$ value greater than zero.\n3) Forced closure of connections is safe if the protocol supports dynamic reconnection, as the xroot protocol does.\n4) The read timeout forces a link to be closed should the initial protocol identification data not arrive within the timeout interval. After which, connections that do not send all of their data in the indicated period are simply rescheduled to the background.\n5) Avoid setting short idle timeouts (e.g. less than 2 minutes). The framework oversamples timeout conditions so that it can accurately meet the specified value. Shorter timeouts require a higher sampling rate which increases overhead.\n\nExample\n\n```\nxrd.timeout idle 120m read 10\n```\n4.11 tlsciphers\n\n```\nxrd.tlsciphers cipher\n```\n\n**Function**\nSpecify the allowed ciphers for transport layer security (TLS).\n\n**Parameters**\nciphers\nA list of colon separated ciphers that are allowed to be used.\n\n**Defaults**\nFor OpenSSL versions greater than 1.0.2 the ciphers recommended by mozilla.org version 5.4 guidelines are used. These are strict ciphers. For older OpenSSL versions, generic ciphers are used for compatibility reasons.\n\n**Notes**\n1) The tls.ciphers directive is provided in cases where a default cipher has been shown to be insecure and should be removed. In this case, you need to specify all of the ciphers less the one you wish to eliminate.\n\n**Example**\n```\nxrd.tlsciphers ALL:!LOW:!EXP:!MD5:!MD2\n```\n4.12 trace\n\n```\nxrd.trace [ -]option\n```\n\n**option:** {all | conn | debug | mem | net | none | off | poll | protocol | sched | tls | tlsctx | tlsio | tlssok} [ [-]option]\n\n**Function**\nSpecify execution tracing options.\n\n**Parameters**\n\n*option* Specifies the tracing level. One or more options may be specified. The specifications are cumulative and processed left to right. Each option may be optionally prefixed by a minus sign to turn off the setting. Valid options are:\n\n- **all**: Selects all possible trace levels\n- **conn**: Traces connection activity\n- **debug**: Traces internal activities for debugging purposes\n- **mem**: Traces memory management functions\n- **net**: Traces network management functions\n- **none**: Traces nothing\n- **off**: A synonym for NONE\n- **poll**: Traces I/O interrupt polling activities\n- **protocol**: Traces protocol activity (see the notes)\n- **sched**: Traces scheduling functions\n- **tls**: A synonym for the combination tlsctx and tlssok\n- **tlsctx**: Traces TLS context activities\n- **tlsio**: Traces TLS I/O activities\n- **tlssok**: Traces TLS socket activities\n\n**Defaults**\nTracing is disabled.\nNotes\n\n1) All tracing is forcibly enabled when the daemon is invoked with the \\texttt{-d} option.\n2) All previous trace settings are discarded when \\texttt{none} or \\texttt{off} is encountered.\n3) The \\texttt{protocol} trace option is passed along to the all loaded protocols that may or may not respect the option or may have their own options.\n\nExample\n\\begin{verbatim}\nxrd.trace all -debug\n\\end{verbatim}\n5 xrootd Directives by Category\n\n5.1 Data Access\n\nall.export Specify the file system paths that may be accessed.\nxrootd.fslib Specify the file system plug-in to be used for data access.\nxrootd.redirect Specify client redirection by type of request, access path, and possible errors during access.\n\n5.2 Data Integrity\n\nxrootd.chksum Enable file checksum calculation.\n\n5.3 Debugging\n\nxrootd.diglib Enable interactive remote debugging.\nxrootd.trace Specify execution tracing options.\n\n5.4 Monitoring\n\nxrootd.mongstream Specify custom g-stream parameters.\nxrootd.monitor Specify which statistics are to be collected and where they are to be sent.\nxrootd.pmark Specify packet marking firefly parameters.\n\n5.5 Prepare Processing\n\nxrootd.prep Specify how prepare requests tracking should be handled.\n\n5.6 Security\n\nxrootd.seclib Specify the location of the security interface layer.\nxrootd.log Specify which events are to be logged.\nxrootd.tls Specify TLS requirements by request category.\n\n5.7 Tuning\n\nxrootd.async Specify asynchronous data processing features and limits.\nxrootd.bindif Specify alternate interfaces that should be used for data.\nxrootd.fsoverload Specify how file system overloads are to be handled.\n**xrootd.tlsreuse** Specify TLS session cache characteristics.\n6 Common xrootd Configuration Directives\n\n6.1 export\n\n```\nall.export {path | *[?]} [[no]lock] [oss_options]\n```\n\n**Function**\n\nSpecify a valid path prefix for file requests.\n\n**Parameters**\n\n- **path**\n \n An absolute path prefix for valid file requests. Only files starting with this prefix are allowed in requests.\n\n- ***\\[\\]**\n \n Allow arbitrary object identifiers (i.e. names that do not start with a slash). The names are not inspected in any way and passed as is to the file system plug-in.\n\n- ***?[\\]**\n \n Allow arbitrary object identifiers (i.e. names that do not start with a slash). Inspected the names for CGI information and, if present, separate it from the object identifier (i.e. characters before the question mark) before passing the object name and CGI information to the file system plug-in.\n\n- **lock**\n \n Uses standard xroot protection against multiple writers. This is the default.\n\n- **nolock**\n \n Does not protect against multiple writers.\n\n- **oss_options**\n \n Optional oss options that affect how the path is processed by the storage system and cluster service. Refer to the “Open File System & Open Storage System Configuration Reference” and the “Clustering Configuration Reference”.\n\n**Defaults**\n\n```\nxrootd.export /tmp lock\n```\nNotes\n\n1) For security purposes, only files in /tmp are allowed to be accessed unless you specify otherwise. You may specify valid paths either on the command line or using the export configuration directive.\n\n2) Do not prefix path with the oss localroot directive path, if any.\n\n3) By default, a file may be opened by a single writer with no readers or multiple readers without any writer. If an external locking mechanism is used or no locking mechanism is needed; specify the nolock option to disable the default.\n\n4) The [no]lock option must appear before any oss options.\n\n5) The underlying file system plug-in as well as the storage system plug-in must support object identifiers in order to use the * or *? export. The default file system plug-in will pass the object identifier to the storage system plug-in for the common set of file operations. However, the default storage system plug-in will not load if object identifiers are being exported.\n\n6) Object identifiers exportation is meant to support object store plug-ins such as the Ceph block storage plug-in.\n\nExample\n\nxrootd.export /store\n6.2 seclib\n\n\\[\nxrootd.seclib \\{ \\text{default} | path \\}\n\\]\n\n**Function**\nSpecify the location of the security interface layer.\n\n**Parameters**\n\n- **default**\n Uses the default security plug-in in the security interface.\n\n- **path**\nThe absolute path to the shared library that contains an implementation of the Security (sec) interface that *xrootd* is to use for strong authentication (e.g., Kerberos, GSI, etc).\n\n**Defaults**\nStrong authentication is disabled unless *seclib* is specified.\n\n**Notes**\n1) The *sec* interface allows you to provide an arbitrary authentication implementation (e.g., Kerberos, GSI, etc).\n2) A *sec* implementation requires that compatible interface libraries be used on the server and client sides of the connection.\n3) Refer to *XrdSecEntity.hh* and *XrdSecInterface.hh* for guideline on how to write a *sec* interface.\n4) It is up to the *sfs* implementation to use authentication information to restrict access to files.\n5) The provided *ofs* implementation can use authentication information for access control purposes.\n6) The default *sfs* implementation does not provide any access control.\n\n**Example**\n\\[\nxrootd.seclib /opt/xrootd/lib/libosec.so\n\\]\n7 Esoteric xrootd Configuration Directives\n\n7.1 async\n\n```\nxrootd.async parms\n\nparms: [force] [limit aiorpc] [maxsegs smax]\n\n[maxstalls mstall] [maxtot slim]\n\n[minsize reqsz[k | m | g]] [minsfsz sfsz[k | m | g]]\n\n[nocache] [nosf] [off] [segsize segsz[k | m | g]]\n\n[syncw] [timeout tmo]\n```\n\nFunction\nSpecify how asynchronous I/O is to be handled.\n\nParameters\n\nforce Uses asynchronous I/O for all requests, even if the client did not ask for asynchronous handling.\n\nlimit clim\nThe maximum allowed number of outstanding asynchronous requests per client connection. Any additional requests past clim are synchronously handled. The default is eight (8).\n\nmaxsegs smax\nThe maximum number of simultaneous asynchronous operations that may any one request may have in progress. The default is eight (8).\n\nmaxstalls mstall\nThe maximum number of times a client may fail to deliver data at a sufficient rate to keep up with asynchronous I/O needs before future requests from the client are synchronously handled. Asynchronous handling is tried again after mstall number of synchronously handled requests. The default is four (4).\nmaxtot \\textit{slim}\n\nThe maximum number of simultaneous asynchronous operations the server may have in progress. The default is 4,096.\n\n\\texttt{minsz reqsz}\n\nThe minimum number of bytes required in a single client request for it to be eligible for async handling. I/O requests smaller than \\texttt{reqsz} are always synchronously handled. The \\texttt{reqsz} can be suffixed by \\texttt{k}, \\texttt{m}, or \\texttt{g} to indicate kilo-, mega-, or giga-bytes; respectively. The default is 1.5 of the default \\texttt{segsz}.\n\n\\texttt{minfsz sfsz}\n\nThe minimum number of bytes that must be read in a single client request for that request to be handled using sendfile(). I/O requests smaller than \\texttt{sfsz} are always handled in the standard way. The \\texttt{sfsz} can be suffixed by \\texttt{k}, \\texttt{m}, or \\texttt{g} to indicate kilo-, mega-, or giga-bytes; respectively. The default is 8k for Linux, 1 otherwise.\n\n\\texttt{nocache}.\n\nDisables using asynchronous I/O for caching servers (e.g. Xcache).\n\n\\texttt{nosf} Disables using sendfile(), where available, for all read requests.\n\n\\texttt{off} Disables asynchronous I/O for all requests. This is the default for the built-in oss plug-in and cannot be changed.\n\n\\texttt{segsz} \\texttt{segsz}\n\nThe segment size to use for quantizing I/O requests (i.e. requests are broken into \\texttt{segsz} pieces). The \\texttt{segsz} can be suffixed by \\texttt{k}, \\texttt{m}, or \\texttt{g} to indicate kilo-, mega-, or giga-bytes; respectively. The default is 64k.\n\n\\texttt{syncw}\n\nUses synchronous I/O for all \\texttt{fsync} requests. Otherwise, asynchronous I/O is used for \\texttt{fsync} requests if the client requested asynchronous I/O or if the \\texttt{force} has been specified.\n\n\\texttt{timeout tmo}\n\nThe maximum number of seconds an asynchronous operation may take before the request fails. Specify a value between 1 and 360. The default is 45.\nDefaults\n\n```\nxrootd.async limit 8 maxsegs 8 maxstalls 4 maxtot 4096\n minsize 98304 minsfsz 8k segsz 64k timeout 45\n```\n\nNotes\n\n1) Asynchronous requests allow the client to start a number of read operations at one time and wait for the request to complete in optimal order. When properly employed, asynchronous requests may substantially improve overall client processing speed.\n2) Asynchronous processing represents a substantial resource commitment on part of the daemon. Each operation requires the dispatching of a separate thread. Rampant asynchronous processing may exhaust resource limits or allow a single client to more easily monopolize the server.\n3) Asynchronous processing is effective when the disk transfer rate approaches the network transfer rate. Thus, asynchronous processing is enabled only when a sufficiently large amount of data is requested by the client at one time. Use the `minsize` parameter to control the point where asynchronous operation is effective.\n4) The `segsz` parameter specifies the ideal I/O size for asynchronous operations in order to maintain continuous incoming/outgoing transfer overlap. Requests are broken into `segsz` units.\n5) Conversion of asynchronous requests to synchronous requests is transparent to the client.\n6) The `sendfile()` interface allows data to be transferred directly from the kernel’s file system memory cache to a client. Generally, this significantly reduces system overhead.\n7) Use the `nosf` option in cases where you suspect that the `sendfile()` interface is causing data transfer problems.\n8) Asynchronous I/O may cause incorrect cache hit/miss calculations because the I/O size is not the true request size.\n9) The `pgread` and `pgwrite` requests use a fixed 64k `segsz` as this is optimal.\n10) The default values allow for the best overall performance in most cases. Whenever changing these values you should measure the difference in performance as changes may actually produce worse performance.\n\nExample\n\n```\nxrootd.async minsz 1M\n```\n7.2 bindif\n\nbindif\n\n\\begin{center}\n\\begin{tabular}{l}\n\\textbf{xrootd.bindif} \\space target \\\\\n\\textbf{target:} \\space host[:port][%host[:port]] [target] \\\\\n\\textbf{host:} \\space dnsname | [ipv6addr] | ipv4addr\n\\end{tabular}\n\\end{center}\n\n**Function**\nSpecify the endpoints for future bound data paths.\n\n**Parameters**\n- \\textbf{target} The name or address of the host and optional port number where clients are to use when creating an additional data path. When the port is omitted the default of first assigned port number is used (see the notes for additional caveats when specifying a port). Any number of targets may be specified. The target consists of one or two host[:port] specifications with the second separated by a percent sign (%). When a second host[:port] is specified, then clients connecting using a private IP address are told to use the second host[:port] while clients connecting with a public IP address are told to use to the first host[:port]. If only one host[:port] is specified, no distinction is made.\n\n**Defaults**\nBy default, the session endpoint is used to create additional data paths.\n\n**Notes**\n1) When there is more than one target, the client round-robins the use of the end-points as additional data paths are created.\n2) When specifying a non-default port make sure that the port is added to the list of ports the daemon should enable via the \\texttt{xrd.protocol} directive using the \\texttt{+port} option.\n3) When as actual host name is specified as a target, the host name must be registered in DNS unless dynamic DNS is enabled. See the \\texttt{xrd.network} directive for more information and, specifically, the discussion on when dynamic DNS should be enabled.\n\n**Example**\n\\texttt{xrootd.bindif foo.proxy.edu:1094}\n7.3 chksum\n\n\\texttt{xrootd.chksum [chkcgi] [max num] digest [path [args]]}\n\ndigest: algorithm [digest]\n\nFunction\nSpecify how file check sums are computed.\n\nParameters\n\\texttt{chkcgi}\nAlways checks the \\texttt{cgi} information, if any, for the \\texttt{cks.type} element that can be used to select a checksum algorithm. The \\texttt{cgi} information is not checked if only one digest is specified for backward compatibility. It is always checked if more than one digest is specified, making \\texttt{chkcgi} unnecessary. See the usage notes for more information.\n\n\\texttt{num}\nMaximum number of checksum calculations that may run at the same time. Specifying 0 prevents real-time check summing. See the notes for more information.\n\n\\texttt{algorithm}\nThe name of the checksum digest (e.g., md5) used for the check summing. Specify one or more supported digests, each separated by a space. The first algorithm becomes the default algorithm. See the usage notes on how multiple digests are supported.\n\n\\texttt{path}\nThe absolute path of the program that computes the check sum. If \\texttt{path} is not specified, checksums are internally performed.\n\n\\texttt{args}\nInitial arguments to be passed to the program identified by \\texttt{path}, if any.\n\nDefaults\nThe default \\texttt{max} is 4; otherwise. If \\texttt{path} is not specified, checksums are internally performed. File check summing is not supported unless the directive is specified.\nNotes\n\n1) When a client issues an `xrootd` query checksum request, the following steps are performed:\n a. A checksum digest is selected as follows:\n i. If a single algorithm is specified and `chkcgi` was not specified, the digest in the configuration file is used.\n ii. If a single algorithm is specified and `chkgi` is specified, a `cgi` scan is made for `cks.type` and, if specified, its argument must match the single algorithm in the configuration file or an error results. In any case, the digest in the configuration file is used.\n iii. If more than one algorithm has been specified, a `cgi` scan is made for `cks.type` and, if specified, its argument must match one of the specified algorithms in the configuration file or an error results. If there is a match, the `cks.type` argument is used as the desired digest. If `cks.type` is not found, then the first algorithm specified in the configuration file is used.\n b. A check is made that the client has lookup privileges for the file and that a valid checksum has been recorded for the file. If both are true, that checksum is sent back to the client. If the client lacks lookup privileges, an access error is sent back to the client.\n c. Since a checksum needs to be computed the `max` value applies. If it is zero, the client is told that the checksum is not available.\n d. If the checksum is natively supported and no program path has been specified, a new checksum is locally computed and recorded for future queries. Otherwise, the program named in path is executed to compute a new checksum and it is not recorded for future queries. Of course, the program may record the checksum in some way for future queries.\n e. Either the previously recorded checksum or the computed checksum is provided to the client.\n\n2) Native checksums are `adler32`, `crc32`, `crc32c`, and `md5`.\n\n3) XRootD uses hardware assist features for `crc32c` should the platform support them (e.g. AMD and Intel).\n\n4) Use the `ofs.ckslib` directive to add new digests or improve the performance of the native digests.\n\n5) Since computation of multiple checksums is CPU and memory intensive choose the `max` with circumspection. You can control memory usage via the `ofs.cksrdsz` directive.\n\n6) The `ofs` directives are documented on the OFS/OSS reference manual.\n7) When the program identified by *path* is invoked, it is passed the path to the file that is to be processed. The actual argument list varies depending on whether or not a single algorithm has been specified, as follows:\n a. When a single algorithm has been specified, the program is passed the file path as the last argument and is the only argument if no *args* have been specified.\n b. When multiple algorithms have been specified, the program is passed the file path as the last argument and the checksum algorithm name as the second to the last argument. If no *args* have been specified, these are the only two arguments that are passed.\n\n8) The program must output on standard out a single checksum value; normally ending with a new-line (‘\\n’) character and terminate with a status code of zero. If the program terminates with a non-zero status code or returns no output, the client’s request fails.\n\n9) Upon success, the returned checksum value is passed back to the client, prefixed by the digest token, *digest*.\n\n10) **Warning:** If an external checksum program is specified (i.e. *path* is specified), then neither the *oss.localroot* nor *oss.namelib* directives are applied to the logical file name before passing the file name to the specified program that computes the checksum. Hence, the program is responsible for converting a logical file name to a physical file name.\n\n11) When checksums are natively computed (i.e., *path* is not specified), then the *oss.localroot* and *oss.namelib* directives are applied to the logical file name. The checksum is computed against the resulting physical file name.\n\n12) The *chkcgi* option is provided for backward compatibility. In previous releases only one algorithm could be specified and *cgi* information was immaterial. This processing mode remains the default when only a single algorithm is specified. You may wish to verify that a client is not requesting an unsupported digest in the case where some servers support multiple checksums and others do not.\n\n13) The administrator’s interface allows you to list and cancel checksum jobs. This applies to external as well as internal computation of the checksum.\n\n14) When max is zero, checksums on demand are prohibited. This requires that checksums to be pre-computed. This can be done using the *frm_admin chksum* command. See the File Residency Manager reference.\n\n15) Using an external checksum calculation via the path option disables the server’s ability to return checksums in a directory listing.\n\n**Example**\n\n```\nxrootd.chksum max 2 crc32c\n```\n7.4 diglib\n\n```\nxrootd.diglib * authpath\n```\n\n**Function**\nEnable remote debugging via the **digFS** read-only file system.\n\n**Parameters**\n\n- \n * Loads the built-in version of **digFS**; the only the version currently supported.\n\n **authpath** \n The path to the authorization file that describes who is allowed to access **digFS** and what kind of information they may view.\n\n**Defaults**\nBy default, **digFS** is disabled.\n\n**Notes**\n\n1) The **digFS** provides a virtual read-only file system view of key information about **xrootd** and **cmsd** that is valuable to remotely debug system problems.\n\n2) Since **digFS** exposes system information an authorization file describing access permissions is required. See the next section.\n\n3) When **diglib** is specified, the */=*/ directory is automatically exported and available to authorized users. You must not list */=*/ in the `all.export` list.\n\n4) The */=*/ path always refers to local storage regardless of server role and is never subject to redirection.\n\n5) Only `close`, `dirlist`, `locate`, `open`, `read`, and `stat` requests can be vectored to **digFS**. Other requests referring to */=*/ are disallowed.\n\n6) The **digFS** accepts configuration directives starting with *dig*. Refer to subsequent sections for a description of these directives.\n\n**Example**\n```\nxrootd.diglib * /etc/xrootd/digauth.cf\n```\n7.4.1 Authorizing digFS Access\n\nThe file describing digFS access permissions is composed of newline delimited records. Each record describes a single entity that is authorized to access certain information. The format of each record is\n\n```\ninfo allow aprot ident\n```\n\n```\naprot: gsi | host | krb5 | pwd | sss | unix\nident: g=group | h=host | n=name | o=org | r=role | [ ident ]\n```\n\n**Parameters**\n\n**info** Authorizes the entity described in the record to access certain information. Use the word *all* to allow access to all information. If you specify *all*, you can remove specific information by specifying subsequent information keywords prefixed by a minus sign. Alternatively, list the *info* keywords to enable access to the associated information described below.\n\n<table>\n<thead>\n<tr>\n<th>Keyword</th>\n<th>Information</th>\n<th>Keyword</th>\n<th>Information</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>conf</td>\n<td>configuration file</td>\n<td>logs</td>\n<td>log files</td>\n</tr>\n<tr>\n<td>core</td>\n<td>core files</td>\n<td>proc</td>\n<td>process information</td>\n</tr>\n</tbody>\n</table>\n\n(Linux only)\n\n**aprot** Specifies the authentication protocol that must be used in order to use digFS. Only one protocol per entity description may be specified. Since the information provided by digFS is sensitive in nature you should use the strongest authentication protocol consistent with site policies. The following table lists the default protocols\\(^1\\) from strongest to weakest. Additionally, the rightmost column lists the *ident* tags that can be successfully specified relative to that protocol since not every protocol identifies clients in the same way. See the XRootD security reference for more detailed information.\n\n\\(^1\\) Authentication is plug-in based and any implemented authentication protocol may be specified as *aprot*.\n**Ident** Authorizes the `aprot` authenticated entity possessing the specified identity values access to info `digFS` information. Identity values are specified as key value pairs. The entity must match all the specified pairs in order to be granted access. An imbedded space in a value must be designated as a `\\` (i.e. two character sequence). Specifying an inappropriate key relative to an authentication protocol prohibits access. The following table describes the possible key value pairs.\n\n<table>\n<thead>\n<tr>\n<th>Key</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>g</td>\n<td>Group name</td>\n</tr>\n<tr>\n<td>h</td>\n<td>Fully qualified hostname</td>\n</tr>\n<tr>\n<td>n</td>\n<td>Authentication-specific protocol client identity string (see notes)</td>\n</tr>\n<tr>\n<td>o</td>\n<td>Organization name</td>\n</tr>\n<tr>\n<td>r</td>\n<td>Role name</td>\n</tr>\n</tbody>\n</table>\n\n**Notes**\n\n1) Valid entries in the `authfile` are used and syntactically incorrect entries are discarded. At least one valid entry must exist for `digFS` to be enabled.\n\n2) If the modification time of the `authfile` changes outside of a 5 second window it is reprocessed. This allows you to modify the `authfile` on a running system. However, you must atomically update the file as follows:\n a. Create a copy of the file.\n b. Modify the copy as needed.\n c. Rename the copy to be the original name (i.e. use `mv`).\n Distributing a modified copy of the file to other hosts should also use rename to install the new `authfile`.\n\n**Protocol** | **Description** | **Meaningful ident Codes**\n-------------|-----------------|-------------------\nkrb5 | Kerberos Version 5 | h n \ngsi | Grid Security Infrastructure (i.e. x.509) | g h n o r \nsss | Simple Shared Secret | g h n \npwd | Password | g h n o r \nhost | DNS resolved hostname | h \nunix | NFS V2-Style authentication | g h n \n3) Each authentication protocol has a specific way of identifying a client. For instance, x.509 (i.e. gsi) uses distinguished name (i.e. dn). Depending on the security configuration the protocol-specific name may be mapped to a Unix name. If so, you must use the mapped name not the original name.\n\n4) If an entity is associated with more than one group name then the specified group (i.e. g=) must match one of the associated group names.\n\n5) Starting in version 4.2 you are able to enable digFS but prevent its use by simply not creating an authorization file or commenting out all authorization entries. This allows you to enable its use in real-time without restarting XRootD by either creating an authorization file or adding authorization lines to an existing file.\n\n6) Prior to 4.2 you must have a valid authorization file with at least one authorization entry. However, that entry may be unsatisfiable. This also allows you to selective enable or disable digFS without an XRootD restart.\n\nExample\n\n```\nall -core allow krb5 h=test.org n=xtestor\nconf logs allow gsi g=atlas n=theuser\n```\n7.4.2 Optional digFS Directives\nThe digFS accepts the following directives in the configuration file.\n\n7.4.2.1 addconf\n\n```\ndig.addconf path [ fname ]\n```\n\n**Function**\nAdd a configuration file reference to the digFS namespace.\n\n**Parameters**\n\n*path* \nThe absolute path to a regular file that is to be added to “/=/conf/etc”. The name of the file will be the same as the last component of path unless *fname* is specified.\n\n*fname* \nThe name that is to appear in “/=/conf/etc” but refers to path.\n\n**Defaults**\nNone.\n\n**Notes**\n1) The *path* is only added if it is readable by the xrootd server.\n2) This directive allows you to make other server related configuration files available via digFS.\n\n**Example**\n```\ndig.addconf /etc/sysconfig/xrootd\n```\n7.4.2.2 log\n\ndig.log parm [ parm ]\n\nparm: deny | grant | none\n\nFunction\nControl the level of logging.\n\nParameters\nparm The level of logging; specify one or more of:\n deny - log file access denials\n grant - log file access approvals\n none - turn off logging\n\nDefaults\ndig.log deny grant\n\nNotes\n1) To enable logging of denials and approvals you must specify both deny and grant parameters.\n\nExample\ndig.log deny\n7.4.3 Using digFS\n\nThe **digFS** file system can be accessed using standard file system applications. All information is rooted in the `/=` directory and follows a standard layout. The following table describes directory tree.\n\n<table>\n<thead>\n<tr>\n<th>Directory</th>\n<th>Subdirectory</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>/=conf</code></td>\n<td></td>\n<td>Configuration files <strong>cmsd.cf</strong> and <strong>xrootd.cf</strong></td>\n</tr>\n<tr>\n<td><code>/etc</code></td>\n<td></td>\n<td>Other site selected configuration files.</td>\n</tr>\n<tr>\n<td><code>/core</code></td>\n<td></td>\n<td>Core files</td>\n</tr>\n<tr>\n<td><code>/core/cmsd</code></td>\n<td></td>\n<td>Directory holding <strong>cmsd</strong> core files.</td>\n</tr>\n<tr>\n<td><code>/core/xrootd</code></td>\n<td></td>\n<td>Directory holding <strong>xrootd</strong> core files.</td>\n</tr>\n<tr>\n<td><code>/logs</code></td>\n<td></td>\n<td>Log files</td>\n</tr>\n<tr>\n<td><code>/logs/cmsd</code></td>\n<td></td>\n<td>Directory holding <strong>cmsd</strong> log files.</td>\n</tr>\n<tr>\n<td><code>/logs/xrootd</code></td>\n<td></td>\n<td>Directory holding <strong>xrootd</strong> log files.</td>\n</tr>\n<tr>\n<td><code>/proc</code></td>\n<td></td>\n<td>proc files (Linux only)</td>\n</tr>\n<tr>\n<td><code>/proc/cmsd</code></td>\n<td></td>\n<td>Directory holding the <strong>cmsd</strong> proc files.</td>\n</tr>\n<tr>\n<td><code>/proc/xrootd</code></td>\n<td></td>\n<td>Directory holding the <strong>xrootd</strong> proc files.</td>\n</tr>\n</tbody>\n</table>\n\nIf the **cmsd** and the **xrootd** share the same configuration file the `/=conf/cmsd.cf` and `/=conf/xrootd.cf` will be identical. If they share the core file directory or the log file directory; the same files may appear in the **cmsd** and **xrootd** subdirectories. As other components are added to **digFS**, additional executable names may appear in each root subdirectory.\n\nTo find out your access rights, simply list the entries in the `/=` directory. Only the subdirectories for which you are authorized are displayed.\n7.5 fslib\n\n```\nxrootd.fslib [++] [throttle | path]\n```\n\nDeprecated (see notes):\n```\nxrootd.fslib [throttle | path2] {default | path1}\n```\n\n**Function**\nSpecify the location of the file system interface layer.\n\n**Parameters**\n++ The specified plug-in should stack on top of the existing plug-in or default. Once specified, it cannot be replaced by a subsequent directive.\n\n*throttle*\nLoads *libXrdThrottle.so* to wrap the subsequent library specification.\n\n*path* The path to the shared library that contains the file system plug-in.\n\n*path2* The path to the shared library that is to be used as the wrapper for the subsequent library specification.\n\n*default*\nLoads a built-in version of the file system implementation.\n\n*path1* The path to the shared library that contains an implementation of the Open File System (ofs) interface that *xrootd* is to use for file system specific operations (e.g., open, close, read, write, rename, etc).\n\n**Defaults**\n```\nxrootd.fslib default\n```\n\n**Notes**\n1) When you only specify the shared library filename, the library is located using the standard platform-dependent loader rules (e.g. well known places followed by the *LD_LIBRARY_PATH* envvar setting).\n2) The `sfs` interface allows you to provide an arbitrary file system implementation. It is documented in `XrdSfsInterface.hh`. Refer to this include file for differences between version 1 and 2 instantiation.\n\n3) The deprecated version of his directive should be avoided. The general version is a superset of the deprecated version. In the common case:\n\n `ofs.fslib throttle default`\n\n can be simply replaced by:\n\n `ofs.fslib ++ throttle`\n\n Should you mix both styles, the deprecated version is handled before the general version of the directive which may be confusing.\n\nExample\n\n `xrootd.fslib /opt/xrootd/lib/libofs.so`\n7.6 fsoverload\n\n```\nxrootd.fsoverload [[no]bypass] [redirect target]\n [stall sec]\n\ntarget: host:port[host:port]\nhost: dnsname | ipv6addr | ipv4addr\n```\n\n**Function**\nSpecify how to handle file system overload.\n\n**Parameters**\n- **[no]bypass**\n Specifies whether or not clients should be redirected to the client-specified forwarding destination when the file system indicates it is overloaded. This option is only meaningful for servers configured as forwarding proxies and is ignored if that is not the case. It is only applicable when the client specifies a forwarding destination.\n\n- **redirect target**\n The name or address of the host and port number where clients are to be redirected when the file system indicates that it is overloaded. The target consists of one or two host:port specifications with the second separated by a percent sign (%). When a second host:port is specified, then clients connecting using a private IP address are redirected to the second host:port while clients connecting with a public IP address are redirected to the first host:port. If only one host:port is specified, all clients are redirected to that host.\n\n- **stall sec**\n Specifies how long the client should be stalled when a redirect target is not available and the file system indicates that it is overloaded. After the stall, clients will re-issue the request. A value of zero passes back an overload error to the client when the file system indicates an overload.\n\n**Defaults**\n```\nxrootd.fsoverload nobypass stall 33\n```\nNotes\n\n4) The fsoverload directive is most effective for disk caching proxy servers. Refer to the “Proxy Storage Services Configuration Reference” for additional information on how to effectively use this directive.\n\n5) Currently, the fsoverload directive only applies to file open requests. All other requests encountering a file system overload event fail with an overload error.\n\n6) The bypass directive only applies to release 4.0 or higher clients. Older clients that specify a forwarding path are subject to the stall option should a file system overload event occur.\n\nExample\n\nxrootd.fspreload bypass redirect foo.proxy.edu:1094\n7.7 log\n\n**Function**\nSpecify event logging options.\n\n**Parameters**\n- `levent` Specifies the events to be logged level. One or more events may be specified. The specifications are cumulative and processed left to right. Each event may be optionally prefixed by a minus sign to turn off the setting. Valid events are:\n - `all` logs all possible events, the default\n - `disc` disconnect events\n - `login` login events\n\n**Defaults**\n- `xrootd.log all`\n\n**Notes**\n1) Events messages are routed to the `xrootd` log file.\n\n**Example**\n- `xrootd.log all -login`\n7.8 mongstream\n\n```\nxrootd.mongstream events use parms\n```\n\n**Functions**\nSpecify g-stream monitoring parameters and, optionally, enable selected events.\n\n**Parameters**\n- **events** The events to which this directive applies. The permissible events are:\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>all</td>\n<td>Selection applies to all of the events below.</td>\n</tr>\n<tr>\n<td>ccm</td>\n<td>cache context management information.</td>\n</tr>\n<tr>\n<td>pfc</td>\n<td>proxy file cache information (i.e. proxy disk caching).</td>\n</tr>\n<tr>\n<td>tcpmon</td>\n<td>TCP connection statistics at time of socket close.</td>\n</tr>\n</tbody>\n</table>\n\n- **flush intvl**\nThe maximum time event data may be internally buffered before it is sent to the monitoring destination. Specify a number optionally suffixed by h for hours, m for minutes, or s for seconds, the default. The default comes from the `xrootd.monitor` directive.\n\n- **maxlen size**\nThe maximum size of the datagram. Specify no less than 1024 and no more than 64k. The size can be suffixed by k to indicate kilo-bytes. The default comes from the `xrootd.monitor` directive.\nsend fmt [noident] host:port\n\nspecifies header formatting and the destination for the selected g-stream events. This overrides whatever is specified in the xrootd.monitor directive dest option. The fmt parameter specifies the header format, if any:\n\ncgi formats the header as a CGI query string\njson formats the header as a JSON object\nnohdr do not include any header for any message. See the notes for caveats.\n\nWhen an actual format (i.e. not nohdr) is specified, you may specify the kind of header to be used:\ndflthdr uses a minimal header to identify the message and timing.\nsitehdr uses dflthdr but adds the site name, if any.\nhosthdr uses sitehdr but adds the host name.\ninsthdr uses hosthdr but adds the port and instance name.\nfullhdr uses insthdr but adds the program name and version.\n\nWhen the previous specification is followed by noident, the server does not send periodic identification messages. The noident option is the default when nohdr is specified since an identification record requires a header.\n\nThe final element is the endpoint specification. Specify the host and port where the selected g-stream messages are to be sent using UDP.\n\nDefaults\n\nDefaults come from the xrootd.monitor directive. If a header format is specified, the default is dflthdr.\n\nNotes\n\n1) The mongstream directive is meant to customize specific g-stream events. It also allows enabling these events without enabling common monitoring using the xrootd.monitor directive.\n\n2) If you do not specify the send parameter, then g-stream monitoring is controlled by the xrootd.monitor dest parameter. Otherwise, the send specification overrides the xrootd.monitor specification.\n\n3) You may still use common monitoring for g-streams via the xrootd.monitor directive yet select specific flush intervals and message sizes using the mongstream directive by simply not specifying the send parameter.\n4) Specifying `nohdr` automatically disables identification messages as well as any map messages. The latter makes dictionary mapping inoperative. If a g-stream plug-in uses dictionary mapping, that mapping is never recorded.\n\n5) Unless the monitoring collectors are able to handle multiple header formats, it is unwise to send different header formats to the same collector. This is not enforced.\n\n6) The `mongstream` directive is cumulative with each subsequent directive replacing previously set values.\n\nExample\n\n```\nxrootd.mongstream all use send json datacoll:1234\n```\n7.9 monitor\n\n```\nxrootd.monitor [...] [options] [dest dest [dest dest]]\n```\n\n**options:**\n```\n[all] [auth] [flush [io] intvl[m|s|h]]\n```\n\n```\n[fstat intvl[m|s|h] [lfn] [ops] [ssq] [xfr cnt]]\n```\n\n```\n[ident {intvl[m|s|h] | off}] [fbuff size[k]]\n```\n\n```\n[gbuff size[k]] [mbuff size[k]] [rbuff size[k]]\n```\n\n```\n[rnums cnt] [window intvl[m|s|h]]\n```\n\n**dest:**\n```\n[events] host:port\n```\n\n**events:**\n```\n{ccm | files | fstat | io | info | pfc | redir | tcpmon | user} [events]\n```\n\n**Function**\nSpecify monitoring parameters and, optionally, enable it.\n\n**Parameters**\n\n... uses previously set values to allow a continuation. If the directive does not start with a triple dot, all previous values are reset to initial defaults.\n\nall Automatically enables monitoring for all connections. If all is not specified, monitoring is only enabled upon client request for that specific client.\n\nauth Includes authentication information along with user information, when user is specified and authentication has been configured.\n\nflush [io] intvl\nThe maximum time event data may be internally buffered before it is sent to the monitoring destination. Specify a number optionally suffixed by h for hours, m for minutes, or s for seconds, the default. When io is specified, io event data is also subject to flushing. Otherwise, only non-io events are flushed. The default only applies to non-io events and is 10 minutes.\n**fstat intvl [lfn] [ops] [ssq] [xfr cnt]**\n\nEnables file activity monitoring using a special \"f\" stream. The intvl is the maximum time event data may be internally buffered before it is sent to the monitoring destination. Specify a number optionally suffixed by h for hours, m for minutes, or s for seconds. A value of zero disables the \"f\" stream. The intvl is also used as the basis for xfr event data. By default, only file open and close events are inserted into the stream. Additional information may be requested as follows:\n\n- **lfn** includes the user’s dictionary identifier along with the logical file name being opened in the open event record.\n- **ops** includes detailed operation count information along with minimum and maximum values in the close event record.\n- **ssq** includes the sum of squares count for read and write sizes in the close event record. Specifying ssq automatically includes ops. This option impacts server performance. See the notes for more information.\n- **xfr cnt** inserts the number of bytes read and written from each open file every intvl*cnt elapsed time. The cnt must be 1 or more.\n\n**ident sec**\n\nThe number of seconds between each server identity transmissions (i.e., the '=' map record). Specify a number optionally suffixed by h for hours, m for minutes, or s for seconds, the default. A value of zero transmits the identity only once at start-up time. Specifying off prevents identify records from being sent. The default is 1 hour (i.e. 3600 seconds).\n\n**fbuff size**\n\nthe maximum size of the datagram for file and I/O events (i.e. the f-stream). Specify no less than 1024 and no more than 64k. The size can be suffixed by k to indicate kilo-bytes. The default size is 64k.\n\n**gbuff size**\n\nthe maximum size of the datagram for plug-in generated events (i.e. the g-stream). Specify no less than 1024 and no more than 64k. The size can be suffixed by k to indicate kilo-bytes. The default size is 32k.\n\n**mbuff size**\n\nthe maximum size of the datagram for all other events not covered by a specific xbuff parameter. Specify no less than 1024 and no more than 64k. The size can be suffixed by k to indicate kilo-bytes. The default size is 16k.\n**rbuff size**\nthe maximum size of the datagram for redirection events (i.e. the r-stream). Specify no less than 2048 and no more than 64k. The size can be suffixed by k to indicate kilo-bytes. The default size is 32k.\n\n**rnums cnt**\nthe number of redirection monitoring streams to start. Specify no less than 1 and no more than 8. The default size is 3.\n\n**window intvl**\nThe monitoring window size. Data collected within the window is not differentiated by time. Thus, the window represents the undifferentiated sampling interval. Specify a number optionally suffixed by h for hours, m for minutes, or s for seconds, the default. The default is 60 seconds.\n\n**dest events host:port**\nThe events that are to be sent to the endpoint identified by host:port. All monitoring messages are sent as datagrams (i.e., UDP protocol). The dest parameter, if specified, must be specified as the last parameter. Up two destinations are allowed. By default, only file event information is sent. The permissible events are:\n\n<table>\n<thead>\n<tr>\n<th>Event</th>\n<th>Stream</th>\n<th>Explanation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ccm</td>\n<td>g</td>\n<td>cache context management information.</td>\n</tr>\n<tr>\n<td>files</td>\n<td>t</td>\n<td>file-related request monitoring (i.e., open and close requests).</td>\n</tr>\n<tr>\n<td>fstat</td>\n<td>f</td>\n<td>specified "f" stream information (i.e., open and close requests).</td>\n</tr>\n<tr>\n<td>io</td>\n<td>t</td>\n<td>I/O request monitoring (read and write requests plus files).</td>\n</tr>\n<tr>\n<td>iov</td>\n<td>t</td>\n<td>same as io above plus details on readv vector elements.</td>\n</tr>\n<tr>\n<td>info</td>\n<td>m</td>\n<td>client specified monitoring data submitted using xrootd protocol and other miscellaneous information.</td>\n</tr>\n<tr>\n<td>pfc</td>\n<td>g</td>\n<td>proxy file cache information (i.e. proxy disk caching).</td>\n</tr>\n<tr>\n<td>redir</td>\n<td>r</td>\n<td>redirection events.</td>\n</tr>\n<tr>\n<td>tcpmon</td>\n<td>g</td>\n<td>TCP connection statistics at time of socket close.</td>\n</tr>\n<tr>\n<td>user</td>\n<td>f</td>\n<td>client login and disconnect events.</td>\n</tr>\n</tbody>\n</table>\nDefaults\n\n```\nflush 10m ident 1h fbuff 64k gbuff 32k mbuff 16k rbuff 32k \\\n rnums 3 window 60\n```\n\nNotes\n\n1) Use the `monitor` directive to enable statistical gathering and reporting of events, file information, and I/O requests.\n2) The `monitor` directive not only sets general parameters but is also used to enable monitoring streams whose events are sent with a common XRootD binary header. The header facilitates the use of a central collection, reformatting, and redistribution service.\n3) Specifying the `dest` parameter enables the selected events to be sent to the specified endpoint. If `dest` is not specified, common header event monitoring is not enabled. You may, however, selectively enable alternative g-stream event monitoring using the `mongstream` directive even when other event monitoring is disabled.\n4) The `fstat ssq` option impacts performance since floating point operations must be carried out for each read and write request in order to accurately compute the sum of squares. The counts can be used to compute the standard deviation for read and write sizes. Do not specify this option unless there is a clear need for such information.\n5) The `fstat ssq` counts are available on platforms that use IEEE 754 floating point format. The `fstat ssq` option is ignored on non-conforming platforms.\n6) The `io` option reports individual seeks for each read and write request. While this data may be used to determine access patterns or used in I/O trace simulation studies, it reduces server performance by about 7% and generates a large amount of monitoring data. Normally, `fstat` provides sufficient information about client I/O efficiency at a much lower cost.\n7) The `flush` parameter does not apply to monitor streams that include `io` event data unless `io` is specified. By default, monitor streams that include `io` event data are flushed only when the internal monitor buffer becomes full or when the user owning the stream being monitored disconnects.\n8) You may specify two monitoring destinations. This allows you to isolate data high volume streams (i.e., `io` monitoring) and provide real-time display for low-volume streams (i.e., `info`, `files`, `fstat`, and `user`). Also refer to the `mongstream` directive that provides for additional routing options.\n9) The **all** option forces monitor data to be collected for all connections. If **all** is not specified, each client must enable monitoring manually using the **xrootd set** request code (see the **xrootd** protocol specification). This allows selective monitoring and gives each client the opportunity to tag **io** monitor data with the relevant application name.\n\n10) The **iov** option inserts a read entry for every element in a **readv** vector. This may explode the amount of monitoring information that is generated. By default, when only **io** is specified, a summary **readv** entry is placed in the monitoring stream.\n\n11) Clients cannot enable monitoring that has not been enabled by the **monitor** directive.\n\n12) Specifying a small datagram buffer size (e.g. less than 8k) increases the number of datagrams that need to be sent and, consequently, adds to server overhead. Large datagram buffer sizes reduce the number of datagrams as well as server overhead but increase memory utilization as each connection allocates a buffer.\n\n13) Approximately 61 requests can fit into a 1K **mbuff**.\n\n14) On average, 64 to 128 redirection events can fit into a 32K **rbuff**.\n\n15) Increasing the number of redirection monitoring streams (**rnums**) reduces the bottlenecks in the monitoring path.\n\n16) Specifying a small window increases the timing accuracy of any individual request entry at the expense of additional datagrams and significantly increased server overhead. Conversely, large window sizes reduce timing accuracy but also reduce server overhead.\n\n17) The g-stream events: **ccm**, **pfc**, and **tcpmon** are for events generated by specific plug-ins. The plug-ins are loaded by various directives. Specifying a g-stream whose associated plug-in has not been loaded is ignored. The g-stream events are:\n\n<table>\n<thead>\n<tr>\n<th>Event</th>\n<th>Plug-in Directive</th>\n<th>Type of information reported</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>ccm</strong></td>\n<td><strong>pss.ccmlib</strong></td>\n<td>Cache context management events.</td>\n</tr>\n<tr>\n<td><strong>pfc</strong></td>\n<td><strong>pss.cachelib</strong></td>\n<td>Data caching events.</td>\n</tr>\n<tr>\n<td><strong>tcpmon</strong></td>\n<td><strong>xrd.tcpmonlib</strong></td>\n<td>TCP connection statistics at disconnect.</td>\n</tr>\n</tbody>\n</table>\n\n18) Refer to the “XRooT Monitoring” reference for a detailed explanation on the datagram format used by the monitoring subsystem. It is especially important to understand the different between **files**, **fstat**, and **io** monitoring as the information overlaps and there is rarely a need to specify all three.\nExample\n\n```bash\nxrootd.monitor all fstat 5m dest fstat datacoll:5050\n```\n7.10 pmrk\n\nxrootd.pmark parms\n\nparms: [[no] debug] [defsfie [[no] fail] dpars]\n\n[domain {any | local | remote}] [[no] duprex]\n\n[ffdest host:port] [ffecho intvl[m|s|h]]\n\n[map2act exp {default | {role|user} name} act]\n\n[map2exp {default | {path path | vo vo}} exp]\n\n[[no] trace] [use {[[no] firefly] [[no] scntag]]]\n\ndpams: fpath | {curl | wget} [tmo[m|s|h]] url\n\nFunction\n\nSpecify packet marking parameters and, optionally, enable it. Caution: this directive is experimental and subject to change.\n\nParameters\n\n[no]debug\n\ncontrols detailed debugging messages and should normally not be specified. The nodebug option disables detailed log messages and is the default.\n\ndefsfie [[no] fail] dpars\n\nspecifies the location of the json definition file. This file maps experiment names to experiment IDs and activity names within each experiment to their respective activity IDs. It is required when either the map2act or map2exp parameters are specified. The nofail option ignores processing errors of the defsfie to prevent 3rd party suppliers from preventing a server from starting and is the default. When a processing error occurs, mapping is disabled which may also disable packet marking. The nofail option does not cover blatant configuration errors. The defsfie may be local or may exist at a remote location, as described below.\n**defsfile** [[no]fail] *fpath*\n\nthe **defsfile** is local and *fpath* specifies its file system location as an absolute path (i.e. starts with a slash).\n\n**defsfile** [[no]fail] **{curl | wget}** [tmo[m|h]] *url*\n\nthe **defsfile** is remote and *url* specifies its remote location. The file is downloaded using curl or wget (specify the program you wish to use). Since the remote server may be inaccessible when the file needs to be accessed, specify for *tmo* the maximum amount of time in which the download must complete. The *tmo* value may be optionally suffixed by *h* for hours, *m* for minutes, or *s* for seconds, the default. If unspecified, a 30 second limit applies.\n\n**domain** {any | local | remote}\n\nspecifies which type of connections the **pmark** directives applies to, as follows:\n\nany include local and remote connections.\nlocal include local connections only, remote connections are ignored.\nremote include remote connections only, local connections are ignored; this is the default.\n\n[no]duplex\n\nspecifies whether or not firefly UDP packets are to indicate a symmetric flow. See the notes for more information. The default is **noduplex**.\n\n**ffdest** *host:*port\n\nspecifies the destination (i.e. the hostname or IP address for *host* and the port number for *port*) for firefly UDP packets. The **ffdest** parameter is required if the “use firefly” parameter is specified.\n\n**ffecho** *intvl*\n\nspecifies how often firefly UDP packets are to be sent as long as the connection is open. Specify for *intvl* a number optionally suffixed by *h* for hours, *m* for minutes, or *s* for seconds, the default. Any value less than 30s is interpreted as zero. The default is 0 and a firefly UDP packet, if enabled, is sent only at the start of a connection and when the connection ends. Be aware that this parameter is not yet implemented.\n**map2act** \\( exp \\{ \\text{default} \\mid \\{ \\text{role} \\mid \\text{user} \\} \\text{name} \\} \\text{act} \\)\n\nspecifies how activities are to be determined for an experiment. There may be as many such parameters as needed. For each parameter specify the name of the experiment for \\( exp \\) and the name of the activity for \\( act \\). The names must be defined in the **defsfile**. The two major variations are described below:\n\n**map2act** \\( exp \\text{default} \\text{act} \\)\n\ndefines the default activity for experiment \\( exp \\) when the actual activity cannot be determined. When the activity cannot be determined and no default exists, the activity is reported as undetermined.\n\n**map2act** \\( exp \\{ \\text{role} \\mid \\text{user} \\} \\text{name} \\) \\( act \\)\n\nspecifies that the experiment’s, \\( exp \\), activity is based on either the client’s role or the actual username. Specify for \\( name \\) either to role name or the user’s name, as appropriate. See the notes for a description of how this mapping actually occurs.\n\n**map2exp** \\{default \\mid \\{ \\text{path} \\text{path} \\mid \\text{vo} \\text{vo} \\} \\} \\text{exp} \\)\n\nspecifies how experiments are to be determined. There may be as many such parameters as needed. For each parameter specify the name of the experiment for \\( exp \\). The names must be defined in the **defsfile**. The two major variations are described below:\n\n**map2exp** default \\( exp \\)\n\ndefines the default experiment when the actual experiment cannot be determined. When the experiment cannot be determined and no default exists, the connection is not reported.\n\n**map2exp** \\{ \\text{path} \\text{path} \\mid \\text{vo} \\text{vo} \\} \\text{exp} \\)\n\nspecifies that the experiment is based on either the path of the client’s first successful file open or the client’s virtual organization. For **path**, specify the logical path prefix, \\( path \\), that maps to the experiment, \\( exp \\). For **vo**, specify the virtual organization name, \\( vo \\). See the notes for a description of how this mapping actually occurs.\n\n**[no]trace**\n\nControls execution tracing information and should normally not be specified. The **notrace** option disables execution tracing and is the default.\nuse {[[no]firefly] [[no]scitag]}\nspecifies additional processing options, as follows:\n\n[no]firefly\nSpecifying nofirefly disables sending firefly UDP packets and\nessentially disables packet marking. Specifying firefly enables it and\nrequires that ffdest be specified. When neither is specified, firefly\nbecomes the default if ffdest is specified and nofirefly otherwise.\n\n[no]scitag\nSpecifying noscitag disables checking the cgi string for the token\nscitag.flow that normally identifies the experiment and activity.\nSpecifying or defaulting to scitag enables cgi checking. If the token is\nfound and the information is valid, it is used in the firefly UDP\npacket; thus avoiding any other mapping rules.\n\nDefaults\nnodebug nofail domain remote ffecho 0 notrace use scitag\n\nNotes\n1) The pmark directive is primarily meant for controlling firefly UDP\npackets to monitor data flows at the internet network level.\n2) The pmark directives are cumulative with duplicate parameters replacing\npreviously specified values.\n3) When a client connects and issues the first successful open request and the\nexperiment can be determined, a firefly UDP pack is sent to indicate the\nstart of a data flow. No additional packets are sent and all subsequent\ntraffic is assigned to the initial flow marker. When the client disconnects a\nfirefly UDP packet is sent to indicate the end of the flow.\n4) If the experiment cannot be determined on the first successful open, no\nfirefly UDP packets are sent and the flow is not recorded.\n5) In general, flows are symmetric but the firefly protocol expects the client\nto send a firefly UDP packet identifying data flow to the server while the\nserver is expected to send a firefly packet identifying data flow to the\nclient. Since most clients are incapable of sending firefly UDP packets the\nduplex parameter allows you to request that the server send a packet on\nbehalf of the client. While this is logically correct it may bypass one or\nmore routers that the client would have used when sending data to server.\nIn this case, the flow information may become imprecise.\n6) The following steps are taken to identify the experiment and activity:\n a. If `scitag` usage is allowed and a valid `scitag` is found, it is used to identify the experiment and activity.\n b. If path mapping is enabled, the logical file name in the open request is matched against the specified path prefixes in decreasing length order. When a match is found its target is used to identify the experiment.\n c. If `vo` mappings are enabled, the first `vo` present in the client’s `vo` list is matched against the specified `vo` mappings. When a match is found, its target is used to identify the experiment.\n d. If a default experiment has been defined, it is used. Otherwise, firefly flow identification for the connection is disabled.\n e. When user name activity mapping exist for the identified experiment, the client’s name is matched against the specified user mappings. When a match is found, its target is used to identify the experimental activity.\n f. If `role` mappings exist for the identified experiment, the first `role` present in the client’s `role` list is matched against the specified `role` mappings. When a match is found, its target is used to identify the experimental activity.\n g. If a default activity is defined for the identified experiment, it is used. Otherwise, the activity is reported as undetermined.\n\n7) The following features have not yet been implemented:\n a. Automatic `defsfile` refresh. The server needs to be restarted to pick up any `defsfile` changes.\n b. A `defsfile` fallback to using the previously downloaded version if the current download fails.\n c. Periodic retransmission of the `firefly UDP` packet. When the `ffecho` parameter, when specified, must be valid but otherwise ignored.\n d. Integration with `gstream` monitoring.\n\nExample\n\n```\nxrootd.pmark defsfile curl https://api.scitags.org/api.json\nxrootd.pmark ffdest firefly.esnet.net:1234\nxrootd.pmark map2exp path /data/atlas atlas\nxrootd.pmark map2exp path /data/cms cms\nxrootd.pmark map2exp default atlas\nxrootd.pmark map2act atlas role prod production\nxrootd.pmark map2act cms user fts rebalancing\nxrootd.pmark map2act cms default dc\n```\n7.11 prep\n\n```\nxrootd.prep parms\n parms: [ keep ksec ] [ scrub time ] [ logdir ldir ]\n```\n\nFunction\nSpecify how prepare request tracking is done.\n\nParameters\n\n**keep ksec**\nThe time that prepare request tracking record are to be held. The time may be suffixed by s (the default), m, or h to indicate seconds, minutes, and hours, respectively. The default is 24 hours.\n\n**scrub time**\nThe time between scrubs of the tracking log directory. The time may be suffixed by s (the default), m, or h to indicate seconds, minutes, and hours, respectively. The default is 1 hour.\n\n**logdir ldir**\nThe absolute path of the directory that is to hold the preparation tracking records. A directory must be specified, otherwise preparation request tracking is disabled.\n\nDefaults\nNone. Preparation request tracking is normally disabled. When a logdir directory is specified, the keep and scrub defaults of 24H and 1H apply, respectively.\n\nNotes\n8) This directive allows server to track prepare requests. When request tracking is enabled, each prepare is logged in the logdir directory. It then becomes possible to list the requests and cancel them, if need be.\n9) Since there can be more than one redirecting xrootd server, prepare requests may be scattered across several servers. It is the client’s responsibility to collect information from each server in order to create a composite preparation request history.\n\n10) Each server uniquely names the files in the logdir directory. When multiple xrootd redirecting servers exist, it is possible to collect full preparation history from any server, if the logdir directory is located in a shared file system (e.g., NFS).\n\n11) When running multiple xrootd servers on the same machine, the instance name (-n command line option) is used to differentiate logdir directories among all instances by appending the instance name to the path.\n\nExample\n\nxrootd.prep keep 12H logdir /nfs/xrootd/preplog\n7.12 redirect\n\n```\nxrootd.redirect target {client domlist | byfunc}\n\n domlist: {local | private | .domain} [domlist]\n\n byfunc: {[-]foper | [?] path [path [...]]}\n\n foper: {all | chmod | chksum | dirlist | locate | mkdir\n | mv | prepare | prepstage | rm | rmdir | stat\n | trunc} {[-]foper}\n\n target: host:port[%host:port]\n\n host: dnsname | [ipv6addr] | ipv4addr\n```\n\nFunction\n\nSpecify request forwarding.\n\nParameters\n\n**target** The name or address of the *host* and *port* number where clients are to be redirected based on the subsequent parameters. The target consists of one or two *host:*port specifications with the second separated by a percent sign (%). When a second *host:*port is specified, then clients connecting using a private IP address are redirected to the second *host:*port while clients connecting with a public IP address are redirected to the first *host:*port. If only one *host:*port is specified, all clients are redirected to that host.\n\n**domlist**\n\nSpecifies which clients, by domain, should be redirected. The redirection occurs after login but before any significant client activity. Only one *client* redirection may be defined. Specify one or more of the following:\n\n- **local** clients whose IP address is in the server’s DNS domain.\n- **private** clients using a private IP address.\n- **.domain** clients whose IP address is in the DNS domain (e.g. “.oscer.ou.edu” note the leading period).\n\\textit{foper} Specifies which metadata operations are to be \\textit{immediately} redirected. One or more operations may be specified. The specifications are cumulative and processed left to right. Each operation may be optionally prefixed by a minus sign to turn off the setting. Valid operations are:\n\n- \\texttt{all} redirect all possible operations\n- \\texttt{chmod} redirect change mode requests\n- \\texttt{chksum} redirect checksum requests\n- \\texttt{dirlist} redirect directory content listing requests\n- \\texttt{locate} redirect path location requests\n- \\texttt{mkdir} redirect create directory requests\n- \\texttt{mv} redirect rename requests\n- \\texttt{prepare} redirect prepare requests that \\textit{do not need} file staging\n- \\texttt{prepstage} redirect prepare requests that \\textit{may need} file staging\n- \\texttt{rm} redirect file removal requests\n- \\texttt{rmdir} redirect directory removal requests\n- \\texttt{stat} redirect file attribute requests\n- \\texttt{trunc} redirect file truncate requests using a path\n\n\\textit{path} Specifies that when a file open request occurs on the specified path prefix, the client should be redirected to the specified host and port. One or more paths may be specified. However, no more than four different host-port combinations may be specified.\n\n\\textit{? path} Specifies that any client operation on the specified path prefix that ends with a “not found” error (i.e., \\texttt{EONOENT}) and has not been specifically covered by another redirect directive, the client should be redirected to the specified host and port. All subsequently specified paths, if any, on the line fall under the “not found” provision.\n\n**Defaults**\n\n- \\texttt{xrootd.redirect -all}\n\n**Notes**\n\n1) Request redirection is typically applicable to the cluster manager. Refer to the \\texttt{role} directive in the “Clustering Configuration Reference” for additional information, especially on inter-related directives.\n\n2) Client IP address based redirection is primarily meant to protect proxy servers from clients within a domain who mistakenly use the proxy server when they could have directly connected to services fronted by the proxy server.\n3) Normally, meta-data requests are performed on the local host. However, certain clustered environments may be controlled by a central manager that records the exact state of every file. In such environments, the central manager may perform meta-data requests. When the `redirect` directive is not specified, the client is directed to perform the operation on a single host, normally the one that has the file. When the request is redirected, the target host is responsible for performing the operation.\n\n4) The redirect path prefixes are always matched from most- to least-specific prefix (i.e., longest to shortest).\n\nExample\n\n```\nxrootd.redirect all -prepare\n```\n7.13 tls\n\n```\nxrootd.tls [capable] req\nreq: [-]all | [-]data | [-]login | none | off |\n [-]session | [-]tpc | req\n```\n\nFunction\n\nSpecify transport layer security (TLS) requirement.\n\nParameters\n\ncapable\n\napplies requirements only to TLS capable clients. The default is to apply TLS requirements to all clients irrespective of their ability to use TLS.\n\nreq\n\nspecifies the general requests for which TLS must be used. Clients who attempt these requests without using a TLS connection are rejected with a \"TLS Required\" error message. Valid req are:\n\n- **all**: requires TLS for all requests\n- **data**: requires that all file data or metadata be transmitted using TLS\n- **login**: requires TLS for login requests and all subsequent requests\n- **none**: turns off all requirements (off is a synonym)\n- **session**: requires TLS for all requests after the login and authentication\n- **tpc**: requires TLS for third party copy requests\n\nDefaults\n\n```\nxrd.tls none\n```\n\nNotes\n\n1) The **capable** parameter is meant to provide a migration path for pre-Release 5 clients (i.e. those that do not support TLS). Requiring TLS for all clients essentially disallows older clients from using XRootD.\n\n2) The **tls** directive is cumulative and allows different settings for TLS-capable clients and those that do not support TLS. See the examples on how to accomplish this.\n\n3) Specifying a minus sign in front of any indicated requirement removes that requirement from the current set of requirements.\n4) The **session** requirement is a subset of the **login** requirement. If both are specified, **login** prevails.\n\n5) The **data** requirement applies to the session connection as well as any additional connections bound to the session. If **data** is specified without specifying **login** or **session**, **session** is automatically added to the requirements.\n\n6) At least one requirement must be specified, even if it’s **none** or **off**.\n\n7) When **none** or **off** is encountered, all applicable requirements are discarded.\n\n8) The requirements only apply to the **XRootD** protocol. They do not apply to any other protocols running in parallel with **XRootD**.\n\n9) The **tls** directive fails if **TLS** has not been configured using the **xrd.tls** directive.\n\n**Example**\n\n```text\nxrrootd.tls tpc\n```\n\nThe above requires that any third party copy request use a **TLS** connection. This also prohibits older client (i.e. those incapable of **TLS**) from requesting a third party copy. Adding the following directive\n\n```text\nxrrootd.tls capable session\n```\n\nalso requires that **TLS** capable clients must use a **TLS** connection after the login and authentication phases. Note that while **session** also covers third party copy requests, the preceding directive requires that all **TPC** requests use **TLS**. Hence, non-capable clients can do anything they are allowed to do but cannot request a third-party copy.\n7.14 trace\n\n```\nxrootd.trace [-]option [ [-]option ] [• • •]\n```\n\n**option:**\n- **all** selects all possible trace levels\n- **auth** traces the result of client authentication\n- **debug** traces internal activities for debugging purposes\n- **emsg** traces errors sent back to the client\n- **fs** traces file system requests other than I/O requests\n- **fsaio** traces file system asynchronous I/O requests\n- **fsio** traces file system synchronous I/O requests\n- **login** traces login and authentication steps\n- **mem** traces memory management functions\n- **off** traces nothing\n- **pgcserr** traces checksum errors encountered by pgwrite\n- **redirect** traces client redirections to other servers\n- **request** traces client request information\n- **response** traces request response information\n- **stall** traces client deferrals due to resource limitations\n\n**Defaults**\n\n```\nxrootd.trace off\n```\n\n**Function**\nSpecify execution tracing options.\n\n**Parameters**\n\n`option` The tracing level. One or more options may be specified. The specifications are cumulative and processed left to right. Each option, other than **off**, may be optionally prefixed by a minus sign to turn off the setting. Valid options are:\n\n- **all** selects all possible trace levels\n- **auth** traces the result of client authentication\n- **debug** traces internal activities for debugging purposes\n- **emsg** traces errors sent back to the client\n- **fs** traces file system requests other than I/O requests\n- **fsaio** traces file system asynchronous I/O requests\n- **fsio** traces file system synchronous I/O requests\n- **login** traces login and authentication steps\n- **mem** traces memory management functions\n- **off** traces nothing\n- **pgcserr** traces checksum errors encountered by pgwrite\n- **redirect** traces client redirections to other servers\n- **request** traces client request information\n- **response** traces request response information\n- **stall** traces client deferrals due to resource limitations\n\n*these selections severely reduce server performance*\nNotes\n\n1) **Warning**: enabling tracing may reduce server performance by 50%!\n2) All tracing is enabled when the daemon is invoked with the `–d` option.\n3) All previous trace settings are discarded when `off` is encountered.\n\nExample\n\n```bash\nxrootd.trace all -debug\n```\n8 Enabling HTTP Access\n\n**XRootD** supports HTTP access via a protocol plug-in. The HTTP protocol can run alongside of standard **XRootD** protocol without any interference; providing an additional access mode. To Enable HTTP access, add the following configuration parameter to the configuration file.\n\n```\nif exec xrootd\n xrd.protocol http[:port] path/libXrdHttp.so [cfgfile]\nfi\n```\n\n**Parameters**\n\n- **port** The port number http is to use for incoming requests. Specify a number, the name of a TCP service, or the word any. If you do not specify port number, port 1094 is used. This is also the default port for **XRootD** protocol.\n\n- **path** The path to the shared library **libXrdHttp.so** that contains the code the implements the HTTP protocol.\n\n- **cfgfile** is the path to an external configuration file specific to HTTP. If not specified, the configuration file at daemon start-up is used.\n\n**Defaults**\n\nNot applicable.\n\n**Notes**\n\n1) You should surround the **xrd.protocol** directive with the shown if-fi if you are using a common configuration file for **xrootd** and **cmsd** daemons. Failure to do so will prevent the **cmsd** from starting.\n\n2) All HTTP requests are bound by any “xrd.” and “xrootd.” Directives that exist in the start-up configuration file. Hence, HTTP access cannot exceed any restriction imposed by those directives.\n\n3) Monitoring of HTTP requests is handled as if they are **XRootD** requests. Consequently, the monitoring stream includes all HTTP requests as well. However, monitoring information is tagged with the fact that the information was generated by the HTTP protocol.\n4) While the default port number is the same as for XRootD; the framework directs each request to appropriate protocol and these requests are never intermixed. To avoid any confusion you may wish to use a more standard HTTP port number such as 8080. This is especially true if connection are made using HTTPS.\n\n5) Additional configuration file directives specific to HTTP are always prefixed with “http.” and the following sections describe these directives.\n\n6) HTTP support also includes WebDav support enabling a wider range of access abilities beyond simple get and post capabilities.\n\n7) When HTTP is used in a clustered XRootD deployment, all servers in that deployment must have HTTP enabled. Failure to do so typically results in access failure when a client is redirected to a server that holds the desired file but for which HTTP was not enabled.\n\n8) Not all HTTP clients support all HTTP features. While the plug-in does not violate the HTTP or WebDav standards, it does implement a wide range of allowable features (e.g. redirection on POST requests) that may not be supported by the HTTP client being used.\n8.1 Enabling HTTPS\n\nWhen a server is configured to use HTTPS, each server processes the client’s credentials from the connection. This allows the client to be authenticated and makes authorization possible. On the other hand, HTTPS is very resource demanding because it encrypts and decrypts all of the TCP traffic. Additionally, the process of establishing an encrypted connection requires several network interchanges that increase connection latency which can be substantial on a wide area network.\n\nWhile HTTP is much faster it is impossible to authenticate the client using HTTP. However, the HTTP plug-in allows a client to initially connect with HTTPS, extract the authentication information, encode that information in a low-overhead encrypted security token and redirect the connection to use HTTP. This is known as HTTPS to HTTP conversion and is much less resource intensive. When a server is configured to do HTTPS to HTTP conversion, it always expects a security token to be present when a client connects via HTTP. If the token is missing or cannot be decrypted the connection is rejected. This mechanism provides a relatively secure authentication but at the expense of privacy as no traffic is encrypted past the authentication stage.\n\nHTTPS to HTTP conversion is especially attractive in clustered environments where a client typically makes contact with a particular node (i.e. redirector) that then redirects the client to a particular server that holds the requested file. Using HTTPS everywhere incurs identical overhead at each contact point. This can be eliminated by using HTTPS at the initial contact point and converting HTTPS to HTTP for subsequent connections. This incurs the overhead just once.\n\nWhen enabling HTTPS you should consider the following points:\n\n- If only HTTPS is configured, then the server only accepts HTTPS connections (see the xrd.tls and xrd.tlsca directives).\n- If HTTPS to HTTP conversion is configured a server accepts an HTTPS connection or an HTTP connection that provides a valid security token (see the secretkey directive)\n- If self-conversion of HTTPS to HTTP is configured, the server unconditionally redirects any HTTPS incoming connections to itself; using HTTP and a security token (see the selfhttps2http directive). This allows greater performance for subsequent requests.\nWhen using **HTTP** in an **XRootD** cluster, additional considerations apply on how the cluster redirector interacts with data servers in that cluster. The following table provides reasonable possibilities, depending on the degree of security that is desired.\n\n<table>\n<thead>\n<tr>\n<th>Redirector Accepts</th>\n<th>Server Accepts</th>\n<th>Configuration</th>\n<th>Remarks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>HTTP</td>\n<td>HTTP</td>\n<td>The <strong>is</strong> the default</td>\n<td>No security.</td>\n</tr>\n<tr>\n<td>HTTPS</td>\n<td>HTTP with security token</td>\n<td>Specify <code>xrd.tls</code>, <code>xrd.tlsca</code> and <code>http.secretkey</code> directives.</td>\n<td>Central authentication, fast unencrypted data access but higher CPU load in the redirector</td>\n</tr>\n<tr>\n<td>HTTP</td>\n<td>HTTPS</td>\n<td>Specify <code>xrd.tls</code> and <code>xrd.tlsca</code> directives <em>only</em> in data servers. Specify <code>http.desthttps</code> in redirectors.</td>\n<td>Fast redirection, distributed authentication, slow encrypted data access</td>\n</tr>\n<tr>\n<td>HTTP</td>\n<td>HTTPS with self redirection using HTTP with security token</td>\n<td>Specify <code>xrd.tls</code>, <code>xrd.tlsca</code>, <code>http.selfhttps2http</code> and <code>http.secretkey</code> directives <em>only</em> in data servers. Specify <code>http.desthttps</code> in redirectors.</td>\n<td>Fast redirection, distributed authentication, fast unencrypted data access</td>\n</tr>\n<tr>\n<td>HTTPS</td>\n<td>HTTPS</td>\n<td>Specify <code>xrd.tls</code> and <code>xrd.tlsca</code> directives in servers and redirectors.</td>\n<td>Fully authenticated but authentication occurs twice, slow encrypted data access, resource consumption can be high</td>\n</tr>\n</tbody>\n</table>\n8.1.1 Backward Compatibility and Overrides\n\nExceptions are handled by the `http.httpsmode` directive. See this directive on how to control backward compatibility warning messages.\n\n8.2 Directives to Enhance HTTPS Access\n\nBy default, HTTPS access is not enabled. You must specify certain critical `xrd` information in order for HTTPS to be enabled (i.e. `xrd.tls` and `xrd.tlsca`).\n\nThe `xrd` framework provides TLS services to all protocols and HTTPS relies on these services. The `xrd.tls` and `xrd.tlsca` directives should be used to configure TLS for HTTPS. Previous releases relied on `http` specific directives to do this (i.e. `http.cadir`, `http.cafile`, `http.cert` and `http.key`). These are still accepted and still allow HTTPS to be configured. However, when specified a warning message is issued to remind you to use the `xrd` framework directives instead. It is best to configure TLS for all protocols using a common set of directives to avoid inconsistency. Therefore, the `http`-specific TLS directives have been deprecated.\n\nHowever, there are other directives that are specifically oriented to improving the handling of HTTPS. These are described in the following sections.\n8.2.1 desthttps\n\n```\nhttp.desthttps {no | yes}\n```\n\n**Function**\nSpecify whether or not HTTPS is to be used for redirections.\n\n**Parameters**\n\n- **no** \n A redirector will always redirect a client using http. The word `false` and the number `0` are synonyms.\n\n- **yes** \n A redirector will always redirect a client using https. The word `true` and the number `1` are synonyms.\n\n**Defaults**\n```\nhttp.desthttps no\n```\n\n**Notes**\n1) While this directive applies normally applies to redirectors it is used by any node, redirector or data server that redirects a client.\n\n**Example**\n```\nhttp.desthttps yes\n```\n8.2.2 gridmap\n\n```bash\nhttp.gridmap path\n```\n\n**Function**\n\nSpecify the file containing the \"grid map file\" that the server must use.\n\n**Parameters**\n\n`path` The path to the file.\n\n**Defaults**\n\nNone.\n\n**Notes**\n\n1) This file is loaded at startup and used to translate the requestor’s x509 DN into a short user name for internal authorization usage.\n2) This directive requires that HTTPS be enabled with certificate verification.\n\n**Example**\n\n```\nhttp.gridmap /etc/grid-security/mapfile\n```\n8.2.3 httpsmode\n\n```\nhttp.httpsmode {auto | disable | manual}\n```\n\nFunction\nSpecify how to handle enabling HTTPS protocol.\n\nParameters\n- **auto**: automatically enables the use of HTTPS if the underlying xrd framework was configured to allow TLS (i.e. the xrd.tls and xrd.tlsca directives). This is the default.\n- **disable**: disables the use of HTTPS regardless of any other directives.\n- **manual**: enables the use of HTTPS but requires that the appropriate http directives are used to specify required HTTPS parameters (i.e. http.cadir, http.cafile, http.cert and http.key).\n\nDefaults\n```\nhttp.httpsmode auto\n```\n\nNotes\n1) When auto is in effect, you may still override xrd directives that are used for HTTPS. However, each override produces a warning message. To suppress the warnings specify manual and provide all the required http directives to configure HTTPS.\n\nExample\n```\nhttp.httpsmode manual\n```\n8.2.4 secretkey\n\n**http.secretkey {path | token}**\n\n**Function**\nSpecify the key to be used to encrypt and decrypt redirection tokens.\n\n**Parameters**\n- **path** The absolute path to the file containing a random string of alpha-numeric characters and symbols that are to be used to encrypt and decrypt redirection tokens.\n- **token** A random string of alpha-numeric characters and symbols that are to be used to encrypt and decrypt redirection tokens. The token may not start with a slash. **Warning!** Specifying the key in the configuration file exposes the key to theft whenever the configuration file is displayed!\n\n**Defaults**\nNone.\n\n**Notes**\n1) The same key must be used by all nodes within a cluster.\n2) Specifying a secret key automatically enables HTTPS to HTTP conversion.\n\n**Example**\n```\nhttp.secretkey /admin/thekey\n```\n8.2.5 selfhttps2http\n\n```\nhttp.selfhttps2http {no | yes}\n```\n\n**Function**\nSpecify whether or not a server may redirect an HTTPS connection to itself using HTTP plus a security token.\n\n**Parameters**\n- **no** \n A server should continue to use HTTPS for all communications. The word false and the number 0 are synonyms.\n- **yes** \n A server should convert an HTTPS session to an HTTP session by redirecting the client to itself using HTTP plus a security token. The word true and the number 1 are synonyms. You must also specify the secretkey directive.\n\n**Defaults**\n```\nhttp.selfhttps2http no\n```\n\n**Notes**\n1) This option is meant to control the level of data privacy that is desired. Normally, HTTPS connections are converted to HTTP connections after authentication information is extracted from the HTTP stream. This greatly reduces overhead as no data past the authentication stage has to be encrypted.\n2) When an HTTPS connection is converted to an HTTP connection, the redirection includes a security token encrypted with the key specified by with the secretkey directive. The HTTP connection is only accepted if the token can be decrypted using the same key.\n\n**Example**\n```\nhttp.selfhttps2http yes\n```\n8.2.6 secxtractor\n\n```\nhttp.secxtractor path [parms]\n```\n\n**Function**\nSpecify the location of the specialized authentication information extractor plug-in.\n\n**Parameters**\n\n- `path` The path to the shared library containing the plug-in.\n\n- `parms` The parameters to the shared library containing the plug-in.\n\n**Defaults**\nNone.\n\n**Notes**\n\n1) A Security eXtractor plug-in is a component that can be loaded at initialization time in order to provide specialized processing to the certificate passed by the client. Normally, all authentication information comes from the standard part of the client certificate and any extensions are ignored. A Security eXtractor can be used to extract other information from the certificate or any of its extensions. This information is then passed along and may be used for other authorization functions within XRootD.\n\n2) The typical case for which a security extractor library is needed is to extract the extended VO information from a Grid client’s certificate.\n\n3) A general purpose VO Security eXtractor plug-in is available with the gsi package that can be used with HTTPS. See the explanation of the VOMS plug-in in the security reference.\n\n4) The secxtractor plug-in requires that HTTPS be enabled with certificate verification (i.e. xrd.tlsca or http.cadir or http.cafile be specified).\n\n**Example**\n```\nhttp.secxtractor /usr/lib64/libXrdSecgsiVOMS.so\n```\n8.2.7 tlsreuse\n\n```\nhttp.tlsreuse off | on\n```\n\n**Function**\nSpecify transport layer security (TLS) session reuse characteristics.\n\n**Parameters**\n\n- **off** \n disables the TLS session cache and may substantially increase latency for reconnecting clients. This is the default.\n\n- **on** \n enables the TLS session cache.\n\n**Defaults**\n\n```\nhttp.tlsreuse off\n```\n\n**Notes**\n\n1) The **https** protocol cannot successfully use the **TLS** session cache when it needs to handle **TLS** peer certificates. This is why the default is off.\n\n2) The cache is flushed every 255 connection which is not ideal but the mechanism **OpenSSL** uses.\n8.2.8 Deprecated HTTPS Directives\n\n8.2.8.1 cadir\n\n```\nhttp.cadir path\n```\n\n**Function**\nSpecify the directory containing the CA certificates (see the `cafile` directive as an alternative).\n\n**Parameters**\n\n- `path` The path to the directory.\n\n**Defaults**\nNone.\n\n**Notes**\n\n1) Replace this directive with `xrd.tlsca` to configure all protocols to use the same certificate directory.\n2) All of the certificates in the directory must be in a format that is recognized by the version of OpenSSL being used.\n3) If the certificate information is contained in a single file, you should either use the `xrd.tlsca certfile` (preferable) or the `http.cafile` directive.\n\n**Example**\n\n```\nhttp.cadir /etc/grid-security/certificates\n```\n8.2.8.2 cafile\n\n```\nhttp.cafile path\n```\n\n**Function**\n\nSpecify the file containing the CA certificates.\n\n**Parameters**\n\n- **path** The path to the file.\n\n**Defaults**\n\nNone.\n\n**Notes**\n\n1) Replace this directive with `xrd.tlsca certfile` to configure all protocols to use the same certificate file.\n2) All of the certificates in the file must in a format that is recognized by the version of OpenSSL is being used.\n3) If certificates are contained in multiple files you should use the `xrd.tlsca certdir (preferable)` or the `http.cadir` directive.\n\n**Example**\n\n```\nhttp.cafile /etc/myCA.pem\n```\n8.2.8.3 cert\n\n```plaintext\nhttp.cert path\n```\n\n**Function**\nSpecify the file containing the x.509 certificate that the server must use.\n\n**Parameters**\n- `path` The path to the file.\n\n**Defaults**\nNone.\n\n**Notes**\n1) Replace this directive with `xrd.tls` to configure all protocols to use the same certificate.\n2) The certificate must be in **PEM** format.\n3) See the related `http.key` directive to specify the location of the private key.\n\n**Example**\n```\nhttp.cert /etc/grid-security/hostcert.pem\n```\n8.2.8.4 cipherfilter\n\n**http.cipherfilter ciphers**\n\n**Function**\nSpecify the allowed ciphers for transport layer security (TLS).\n\n**Parameters**\nciphers\n\nA list of colon separated ciphers that are allowed to be used.\n\n**Defaults**\nFor OpenSSL versions greater than 1.0.2 the ciphers recommended by mozilla.org version 5.4 guidelines are used. These are strict ciphers. For older OpenSSL versions, generic ciphers are used for compatibility reasons.\n\n**Notes**\n1) Replace this directive with **xrd.tlsCipher** to configure all protocols to use the same ciphers.\n2) The **http.cipherfilter** directive is provided in cases where a default cipher has been shown to be insecure and should be removed. In this case, you need to specify all of the ciphers less the one you wish to eliminate.\n\n**Example**\n\n```\nhttp.cipherfilter ALL:!LOW:!EXP:!MD5:!MD2\n```\n8.2.8.5 key\n\nhttp.key path\n\n**Function**\n\nSpecify the file containing the x.509 private key that the server must use.\n\n**Parameters**\n\n*path* The path to the file.\n\n**Defaults**\n\nNone.\n\n**Notes**\n\n1) Replace this directive with `xrd.tls` to configure all protocols to use the same certificate key.\n2) The key must be in **PEM** format.\n3) See the related `http.cert` directive to specify the location of the server’s certificate.\n4) Specifying a key without specifying a certificate location is inconsistent and causes the key specification to be ignored along with a warning message.\n\n**Example**\n\nhttp.key /etc/grid-security/hostkey.pem\n8.3 Common Directives\n\n8.3.1 embeddedstatic\n\n```\nhttp.embeddedstatic {no | yes}\n```\n\n**Function**\nSpecify where CSS template and logo is to come from for formatted listings.\n\n**Parameters**\n- **no** The CSS template and logo information must be over-ridden by another file containing such information. The word `false` and the number `0` are synonyms.\n- **yes** An internal memory-based CSS template and logo should be used. The word `true` and the number `1` are synonyms.\n\n**Defaults**\n```\nhttp.embeddedstatic yes\n```\n\n**Notes**\n1) Using the default memory-based CSS template and logo provide much better performance and makes the setup much simpler.\n2) If you need to use a custom style sheet, significant performance gains can be achieved by preloading the style sheet file using the `staticpreload` directive.\n\n**Example**\n```\nhttp.embeddedstatic yes\n```\n8.3.2 exthandler\n\n```\nhttp.exthandler name path [token]\n```\n\n**Function**\nSpecify the location of the TCP connection statistics monitoring plug-in.\n\n**Parameters**\n- **name** \na 1- to-16 character unique name identifying the handler.\n- **path** \nThe absolute path to the shared library that contains an implementation of the handler.\n- **token** \nAn optional parameter to be passed to the plug-in object creation function. Typically, this is the name of a configuration file.\n\n**Defaults**\nNone.\n\n**Notes**\n1) Each exthandler is invoked for every HTTP request to allow special handling for certain requests.\n2) No more than 4 handlers may be loaded.\n\n**Example**\n```\nhttp.exthandler mhandler17 /opt/http/lib/libExtHndlr.so\n```\n8.3.3 header2cgi\n\n```\nhttp.header2cgi hdrkey cgikey\n```\n\n**Function**\n\nSpecify which headers are to be promoted to cgi information and appended to the incoming url.\n\n**Parameters**\n\n`hdrkey` the header key that is to be promoted to cgi information.\n\n`cgirkey` the cgi key name that the promoted header should have.\n\n**Defaults**\n\nNone.\n\n**Notes**\n\n1) Normally, header information is internally processed and not made available to other plug-ins. The `header2cgi` directive allows you to pass on header information to external plug-ins via the incoming *url* by promoting the header payload to a *cgi* element.\n\n2) Assuming *xyzzy* is the payload of header with a key of *auth*, the example shown below would promote the header by appending \"authz=xyzzy\" to the incoming *url* as *cgi* information before it is passed to other system components. This essentially makes the header visible outside of the *http* plug-in.\n\n3) The `header2cgi` directive is meant to be used for non-*http* plug-ins that wish to consider specific information sent via the *http* protocol.\n\n**Example**\n\n```\nhttp.header2cgi auth authz\n```\n8.3.4 listingdeny\n\n**http.listingdeny {no | yes}**\n\n**Function**\nSpecify whether or not directory listings are allowed.\n\n**Parameters**\n\n**no** Directory listings are not allowed. The word **false** and the number **0** are synonyms.\n\n**yes** Directory listings are allowed. The word **true** and the number **1** are synonyms.\n\n**Defaults**\n\n**http.listingdeny no**\n\n**Notes**\n\n1) In a clustered environment a listing of a directory via **HTTP** only lists the directory of some arbitrary server in the cluster. Since files are scattered across all of the servers in the cluster; this likely produces an incomplete listing. You may wish to deny directory listings to avoid confusion.\n\n2) Alternatively, you can redirect directory listings to a special node that can produce a composite listing using all nodes in the cluster via the **listingredir** directive.\n\n3) Note that the **XRootD** based **xrdfs** command automatically produces a composite listing.\n\n**Example**\n\n**http.listingdeny yes**\n8.3.5 listingredir\n\n```\nhttp.listingredir desturl\n```\n\n**Function**\nSpecify the node to which to redirect clients requesting a directory listing.\n\n**Parameters**\n*desturl* The redirection URL to use when a directory listing is requested.\n\n**Defaults**\nNone.\n\n**Notes**\nNone.\n\n**Example**\n```\nhttp.listingredir http://hostwhichprovideslistings:80/\n```\n8.3.6 staticpreload\n\n```\nhttp.staticpreload url path\n```\n\n**Function**\nPreload a static resource file into memory.\n\n**Parameters**\n\n- `url` The URL naming a static resource (e.g. style sheet or icon).\n- `path` The path to the local file containing the resource.\n\n**Defaults**\nNone.\n\n**Notes**\n\n1) Static resources named in a URL must start with “/static” in order to be recognized.\n2) The contents of the static resource contained in path may not exceed 64K. If it does, it is truncated to 64K.\n3) Typical static resources are URL resources ending with “.css” and “.ico”.\n4) This directive is ineffective if the `staticredir` directive is specified.\n\n**Example**\n```\nhttp.staticpreload http://static/mcss.css /etc/mcss\n```\n8.3.7 staticredir\n\n```\nhttp.staticredir newurl\n```\n\n**Function**\nPreload a static resource file into memory.\n\n**Parameters**\n\n*newurl* The URL the client is to be redirected to when requesting a non-local or unsupported static resource.\n\n**Defaults**\nNone.\n\n**Notes**\n\n1) The `staticredir` directive is only effective when a) `embeddedstatic` processing is disabled, or b) the resource is neither a content style sheet nor an icon.\n\n**Example**\n\n```\nhttp.staticredir http://althost/\n```\n8.3.8 trace\n\n```\nhttp.trace [-]option [ [-]option ] [- -]\n```\n\n`option:` all | debug | none | off | request | response\n\nFunction\nSpecify execution tracing options.\n\nParameters\n`option` The tracing level. One or more options may be specified. The specifications are cumulative and processed left to right. Each option may be optionally prefixed by a minus sign to turn off the setting. Valid options are:\n- `all` selects all possible trace levels\n- `debug` traces internal activities for debugging purposes\n- `none` traces nothing\n- `off` a synonym for `none`\n- `request` traces client request information\n- `response` traces request response information\n\nDefaults\nTracing is disabled.\n\nNotes\n1) All tracing is enabled when the daemon is invoked with the `-d` option.\n2) All previous trace settings are discarded when `none` or `off` is encountered.\n3) Tracing seriously degrades server performance. Use this directive only for debugging purposes.\n\nExample\n```\nhttp.trace all -debug\n```\n9 Document Change History\n\n14 March 2005\n- Remove documentation on local redirection mode.\n- Remove documentation of –s command line option.\n- Add ‘-t’ option to the StartXRD documentation.\n- Significantly change the port directive, adding “port any” and “if”. \n- Discuss using “port any” mode.\n\n26 April 2005\n- Further clarified the xrootd monitor flush parameter.\n\n1 June 2005\n- Added description of conditional directives (if-fi).\n- Added description of the –n command line option.\n- Fully explain which run-time files are created.\n- Deprecate –r, –t, and –y command line options.\n- Deprecate the XRDMODE variable and remove the description of the XRDTYPE variable in the StartXRD.cf script.\n- Remove extraneous options from the StartXRD script.\n\n1 Aug 2005\n- Document administrative interface portal socket.\n- Add file size to open monitor record.\n\n16 Aug 2005\n- Add authentication mapping (a-record) to monitoring data.\n\n6 Jan 2006\n- Document the -b and -R command line options.\n- Document how to independently bind different port numbers to available protocols.\n\n25 Jan 2006\n- Add max option to chksum directive.\n\n22 March 2006\n- Add exec condition to if/else/fi.\n28 February 2007\n- Cleaned up documentation relative to `role` directive and `all` prefix modifier.\n- Documented the `xrootd.redirect` directive.\n- Removed the `xrd.connections` directive.\n- Placed most `xrd` directives in esoteric status.\n\n28 March 2007\n- Move conditional directives to a separate manual.\n- Indicate the `adminpath` now is configured via the `all` prefix.\n- Documented the `xrd wan network` and `protocol` directive option.\n- Indicate that the `xrootd export` directive is configured via the `all` prefix and accepts `oss` options.\n\n01 October 2007\n- Document the `locate` option of the `redirect` directive.\n\n01 January 2008\n- Remove references to olbd.\n\n01 February 2008\n- General clean-up.\n\n11 April 2008\n- Document staging (‘s’) monitor record.\n\n29 May 2008\n- Document the `xrootd async nosf` option.\n\n21 July 2008\n- Document the `xrd network [no]dnr` option.\n- Document the `xrd async minsfsz` option.\n\n6 March 2009\n- Document the `xrootd monitor stage` option.\n\n22 June 2009\n- Document the `xrd.report` directive.\n7 July 2009\n • Document the `mpxstats` command for monitoring.\n • Document the summary variables.\n\n17 March 2010\n • Document the `timeout hail` and `kill` options.\n • Document the pid file creation and the `pidpath` directive.\n\n8 March 2011\n • Document the `–s` command line option.\n • Minor editorial changes.\n\n24 May 2011\n • Document the `auth` option in the `xrootd.monitor` directive.\n\n31 May 2011\n • Change the `xrootd.chksum` directive to support native checksums.\n Additional wording added explaining native checksums.\n\n29 June 2011\n • Document the `rbuff` and `redir` options on the `xrootd.monitor` directive\n to support redirection monitoring.\n\n27 September 2011\n • Document the `io flush` option on the `xrootd.monitor` directive.\n\n------------ Release 3.1.0\n\n10 October 2011\n • Document the `iov`, `migr`, and `purge` options on the `xrootd.monitor`\n directive.\n\n2 November 2011\n • Update documentation on the `xrootd.redirect` directive. It now accepts\n additional file operations (`chksum` and `trunc`), `open` targets (previously\n undocumented feature), and `ENOENT` targets.\n3 December 2011\n- Remove the `migr`, `purge` and `stage` options from the `xrootd.monitor` directive. These have been moved to the `frm.all.monitor` directive.\n- Document the new `ident` option on the `xrootd.monitor` directive.\n\n12 December 2011\n- Document the `rnums` option for the `xrootd.monitor` directive.\n\n------------\nRelease 3.2.0\n------------\nRelease 3.2.1\n------------\nRelease 3.2.2\n------------\nRelease 3.2.3\n------------\nRelease 3.2.4\n\n21 September 2012\n- Document the `fstat` option for the `xrootd.monitor` directive.\n- Remove the `rootd` configuration section.\n\n------------\nRelease 3.2.5\n------------\n\n22 October 2012\n- Document the `-S` command line option and the `all.sitename` directive for specifying a monitoring site name.\n\n------------\nRelease 3.2.6\n------------\nRelease 3.2.7\n\n15 December 2012\n- Change the `fstat sdv` option to `fstat ssq` in the `xrootd.monitor` directive.\n\n------------\nRelease 3.3.0\n------------\nRelease 3.3.1\n------------\nRelease 3.3.2\n------------\nRelease 3.3.3\n------------\nRelease 3.3.4\n------------\nRelease 3.3.5\n------------\nRelease 3.3.6\n11 February 2013\n- Enhance the fslib directive to allow one to easily wrap one library with another.\n\n23 February 2013 (IPV6 Introduction)\n- Document the –I command line option.\n- Document the cache option in the xrd.network directive.\n\n12 August 2013\n- Document the extended –k, –l and –z command line options.\n- Document exported environment variables.\n- Document the environment information file contents.\n- General clean-up and better explanations.\n\n2 December 2013\n- Document the xrootd.diglib directive.\n\n8 January 2014\n- Document the routes option on the xrd.network directive.\n- Document enhanced xrootd.redirect directive that can distinguish between public and private IP addresses.\n\n18 February 2014\n- Restrict the routes option on the xrd.network directive to prohibit auto-discovery of interface addresses as this may lead to choosing the wrong addresses.\n\n27 March 2014\n- Document how to enable HTTP and HTTPS protocols.\n- Redesign the routes option on the xrd.network directive to cover the most common case.\n\n6 August 2014\n- Document the core option in the xrd.sched directive.\n- Document how to export object identifier names via the all.export directive.\n8 September 2014\n- Document that **TCP keepalive** is now the default setting.\n- Add a **nokeepalive** option and a **kaparms** option to the **xrd.network** directive.\n- Indicate the **use** option in **xrd.network** accepts one or two interface names.\n- Minor corrections to HTTP section.\n\n27 September 2014\n- Document multiple checksum support via the **xrootd.chksum** directive.\n- Document the **default** option on the **xrootd.seclib** directive.\n- Document the **–L** command line option.\n\n26 November 2014\n- Document the version option in the **xrootd.fslib** directive.\n\n10 February 2015\n- Document how to pass command line arguments to plug-ins.\n- Document how to enable **digFS** but prevent its use until needed.\n\n25 November 2015\n- Explain the side-effects of the **–s** command line option on the placement of the environmental file.\n\n15 April 2016\n- Document log file plug-ins.\n\n20 June 2016\n- Document the **cse** parameter for logging plug-ins.\n- Document the **xrd.network [no]pипа** option.\n\n10 March 2017\n- Correct **http.mapfile** directive (it’s really **gridmap**).\n\n20 May 2017\n- Document the **xrootd.fsoverload** directive.\n27 October 2017\n • Document the `http.header2cgi` directive.\n\n19 December 2018\n • Document the `xrd.tls` and the `xrootd.tls` directives.\n\n31 May 2019\n • Document the `xrd.tlsca` directive.\n\n21 June 2019\n • Document the `dyndns` option in the `xrd.network` directive.\n • Remove all references to the `wan` option. It is no longer supported.\n • Documented the `xrd tls network`, `port`, and `protocol` directive option.\n • Correct spelling of `xrootd.async segsize` option (was `segsz`).\n\n18 October 2019\n • Document the preferred version of the `xrootd.fslib` directive.\n\n21 December 2019\n • Document the interaction between the `dyndns` and `cache` option of the `xrd.network` directive.\n\n31 March 2020\n • Document the `xrd.tlsciphers` directive.\n\n11 April 2020\n • General cleanup with better descriptions.\n • Document the `ccm`, `pfc`, and `tcpmon` options of the `xrootd.monitor` directive.\n • Document the `xrd.tcpmonlib` directive.\n • Document the `http.cipherfilter` and `http.exthandler` directives.\n\n14 April 2020\n • Document the `-a` and `-A` command line options.\n • Document the `xrd.homepath` and `xrd.tcpmonlib` directives.\n24 April 2020\n- Document the `xrd.trace` directive’s `tls`, `tlsctx`, `tlsio`, and `tlssok` options.\n - Document the `xrd.tlsca refresh` option.\n - Document the `tls` options of the `xrd.tls` directive.\n - Document the `http.httpsmode` directive.\n\n28 April 2020\n- Remove the `xrd.tls` directive’s `cache` option.\n - Document the `xrd.tlsca` directive’s `crlcheck` and `[no]proxies` options.\n - Document changes in the `http.httpsmode` directive where `enable` has changed to `manual`.\n - Re-factor the `http` protocol section and describe the deprecated directives.\n - Document how the TLS session cache has, by default, turned off.\n - Document the `xrootd.tlsreuse` directive.\n\n5 May 2020\n- Add directives by category for `xrd` and `xrootd` section.\n - Cleanup `HTTP` section.\n\n23 July 2020\n- Remove documentation of the `xrootd.tlsreuse` directive.\n- Add documentation for the `http.tlsreuse` directive.\n\n20 August 2020\n- Document the `xrootd.monitor` directive triple dot, `fbuff` and `gbuff` parameters.\n - Document that the `xrootd.monitor` directive `dest` parameter is now optional.\n - Add documentation for the `xrootd.mongstream` directive.\n\n29 December 2020\n- Document the `+port` option of the `xrd.protocol` directive.\n\n6 January 2021\n- Add admonition that using an external checksum agent via the `xrootd.chksum` directive disables returning checksums in a directory listing.\n16 March 2021\n- Document the \\texttt{pgcserrs}, \\texttt{pgread}, and \\texttt{pgwrite} options of the \\texttt{xrootd.trace} directive.\n\n13 June 2021\n- Document the \\texttt{auth}, \\texttt{fsaio} and \\texttt{fsio} options of the \\texttt{xrootd.trace} directive.\n- Remove the \\texttt{pgread}, and \\texttt{pgwrite} options of the \\texttt{xrootd.trace} directive.\n- Correct \\texttt{minsz} (should be \\texttt{minsize}) option of the \\texttt{xrootd.trace} directive.\n\n30 July 2021\n- Document that \\texttt{crc32c}, is a natively supported checksum.\n\n2 August 2021\n- Document the \\texttt{xrootd.bindif} directive.\n\n22 November 2021\n- Document the \\texttt{xrootd.pmark} directive.\n- Document the \\texttt{xrootd.redirect} directive’s \\texttt{client} option.\n\n9 December 2021\n- Document the \\texttt{nocache} option of the \\texttt{xrootd.async} directive."}}},{"rowIdx":174,"cells":{"id":{"kind":"string","value":"ea49b90a449f5a8b30c3b0ae51670a355f09e92e"},"text":{"kind":"string","value":"Master Thesis\n\nDistributed Optimization for Non-Strongly Convex Regularizers\n\nAuthor(s):\nForte, Simone\n\nPublication Date:\n2015\n\nPermanent Link:\nhttps://doi.org/10.3929/ethz-a-010585230\n\nRights / License:\nIn Copyright - Non-Commercial Use Permitted\nDistributed Optimization for Non-Strongly Convex Regularizers\n\nMaster Thesis\nSimone Forte\nWednesday 16th September, 2015\n\nSupervising Professor: Prof. Dr. Thomas Hofmann\nAdvisors: Dr. Martin Jaggi, Dr. Matthias Seeger, Virginia Smith\n\n1 Department of Computer Science, ETH Zürich\n2 Amazon Development Center Germany GmbH\n3 Department of Computer Science, UC Berkley\nI would like to thank Prof. Thomas Hofmann for the opportunity to work in his research group.\nI would also like to express my deep gratitude to my advisors Dr. Martin Jaggi, Dr. Matthias Seeger and Virginia Smith for their indispensable guidance and advice and to Celestine Dünner for her useful suggestions.\nAbstract\n\nWe develop primal-dual algorithms for distributed training of linear models in the Spark framework.\n\nWe present the ProxCoCoA+ method which represents a generalization of the CoCoA+ algorithm and extends it to the case of general strongly convex regularizers. A primal-dual convergence rate analysis is provided along with an experimental evaluation of the algorithm on the problem of elastic net regularized logistic regression.\n\nWe also develop the PrimalCoCoA+ method, a method that allows certain non-strongly convex regularizers to be trained in the ProxCoCoA+ theoretical framework; the algorithm works under the assumption that this regularizers are linearly separable and box constrained. This allows for primal-dual convergence rates for $L_1$ regularized models, which are, to the best of our knowledge, the first of their kind; we also evaluate the practical efficiency of this method in the case of $L_1$ regularized logistic on two real world datasets.\n\nFinally, we experimentally explore and prove the validity of ProxCoCoA+ Wild and PrimalCoCoA+ Wild, two new optimization methods that combine distributed and parallel optimization techniques and achieve significant speed-ups with respect to their non-wild variants.\n## Contents\n\n1 Introduction \n1.1 Regularized Loss Minimization .................................................. 1 \n1.1.1 Losses ................................................................. 1 \n1.1.2 Regularization ......................................................... 2 \n1.1.3 Gradient Descent ..................................................... 3 \n1.2 Distributed Optimization ....................................................... 4 \n1.2.1 The MapReduce Model .................................................. 4 \n1.2.2 Apache Spark .......................................................... 5 \n1.2.3 Distributed Gradient Descent ........................................ 5 \n1.3 Primal-Dual Methods ............................................................ 6 \n1.3.1 Convex Conjugates ..................................................... 6 \n1.3.2 The Dual Problem ..................................................... 7 \n1.3.3 Stochastic Dual Coordinate Ascent for L2 Regularization .... 8 \n\n2 ProxCoCoA+ \n2.1 Setting .............................................................................. 11 \n2.2 Distributed Algorithmic Framework ....................................... 11 \n2.2.1 Solving the Local Subproblems .................................... 15 \n2.3 Convergence Analysis for Lipschitz Losses ............................ 17 \n2.4 Convergence Analysis for Smooth Losses ............................... 18 \n2.5 Elastic Net ....................................................................... 20 \n\n3 Primal ProxCoCoA+ \n3.1 Encoding Primal Problems in Dual Form ............................... 22 \n3.1.1 The Corresponding Primal Form .................................... 23 \n3.2 Convergence Analysis for $L$-Bounded Regularizers ............. 24 \n3.3 Convergence Analysis for Strongly Convex Regularizers ...... 25 \n3.4 Applications ..................................................................... 27\nChapter 1\n\nIntroduction\n\nThe last several years have seen an enormous increase in the size and complexity of datasets across numerous domains. Social networks, search engines and electronic commerce websites, among many others, produce huge amounts of valuable data at an ever increasing rate, enabling machine learning applications hard to imagine only a few years ago. This has driven the creation and development of distributed computing infrastructures and frameworks, which are necessary in order to store and consume such a wealth of information in the most efficient way possible and requires us to adapt and rethink many common machine learning algorithms, whose often inherently sequential structure makes unfit to this new setting.\n\n1.1 Regularized Loss Minimization\n\nMany common methods in machine learning can be posed as a convex optimization problem having the following structure\n\n$$\\min_{w \\in \\mathbb{R}^d} \\left[ \\mathcal{P}(w) := g(w) + \\sum_{i=1}^{n} \\ell_i(x_i^T w) \\right].$$\n\n(1.1)\n\nIn this formulation, data are represented by \\( x_i \\) vectors in \\( \\mathbb{R}^d \\) and we wish to learn a vector \\( w \\) that minimizes the sum of convex loss functions \\( \\ell_i \\) and a regularization term \\( g \\). Throughout this work we will refer to this formulation as a regularized loss minimization (RLM) problem.\n\n1.1.1 Losses\n\nRegression\n\nA common application of this theoretical framework is linear regression. In this, given a data matrix \\( A := [x_1; \\ldots; x_n] \\in \\mathbb{R}^{d \\times n} \\) with data examples as its\n1.1. Regularized Loss Minimization\n\ncolumns, and a label vector \\( y \\in \\mathbb{R}^n \\), we seek a linear function that interpolates this labels as \"good as possible\". The definition of \"good\" can be captured through several different convex loss functions with common choices being the squared error\n\\[\n\\ell_i(x_i^T w) = \\frac{1}{2n} (x_i^T w - y_i)^2\n\\]\nand the absolute error\n\\[\n\\ell_i(x_i^T w) = \\frac{1}{2n} |x_i^T w - y_i|.\n\\]\n\nSupport Vector Machines\n\nAnother widespread application of this is binary classification. The input data in this class of problems are represented by a data matrix\n\\[\nA := [x_1; \\ldots; x_n] \\in \\mathbb{R}^{d \\times n}\n\\]\nand a label vector \\( y \\in \\{-1, +1\\}^n \\) with loss functions \\( \\ell_i \\) parameterized by the \\( y_i \\) entry. Among the most successful models in this field, we find the Support Vector Machines model [2]; this model is based on the simple idea of finding a hyperplane with the highest possible margin, that is, maximizing the distance between the plane and the closest data points. This can be achieved by using the hinge loss function:\n\\[\n\\ell_i(x_i^T w) = \\frac{1}{2n} \\max (0, 1 - y_i x_i^T w).\n\\]\n\nLogistic Regression\n\nAnother common classification model is logistic regression; in this, although, instead of just trying to predict the most likely label, we seek to interpolate the probability of the labels, assuming that this probability can be expressed using the sigmoid function as\n\\[\np(y_i = +1) = \\frac{1}{1 + \\exp (-x_i^T w)}.\n\\]\nGiven a matrix \\( A \\) and a set of observed labels \\( y_i \\), it can be shown that the maximum likelihood solution for this problem is given by using\n\\[\n\\ell_i(x_i^T w) = \\frac{1}{2n} \\log (1 + \\exp (-y_i x_i^T w))\n\\]\nas a loss function.\n\n1.1.2 Regularization\n\nWidespread and critical in machine learning is the concept of model regularization; this refers to imposing constraints on the solution vector \\( w \\) in order to penalize too high coefficient values with the aim of controlling its complexity.\nand avoid the *overfitting* problem. In our framework we can achieve regularization by choosing an appropriate $g$ function with the most predominant choice being\n\n$$g(w) = \\frac{\\lambda}{2} \\|w\\|_2^2.$$ \n\nAnother common choice is $L_1$ regularization, which uses a\n\n$$g(w) = \\lambda \\|w\\|_1$$\n\nregularizer. This has the property of giving very sparse models and thus easily interpretable $w$ weight vectors and it’s often used in combination with the squared error loss, with the resulting model going by the name of Lasso and having important applications in feature selection tasks [14]. Very relevant and with similar applications in feature selection is also the Elastic Net [19] regularizer, which is based on a convex combinations of the $L_1$ and $L_2$ norms.\n\n### 1.1.3 Gradient Descent\n\nIn the case of differentiable loss and regularization terms - as for example in the logistic regression - a simple but often very effective strategy for RLM is using a gradient descent based approach on function (1.3). This class of algorithms work by constructing a sequence of vectors, $w_t$, which represent approximations of the optimal value of the function we wish to minimize, where the $w_{t+1}$ vector is obtained subtracting from it an approximation of the gradient of the previous iterate $w_t$ scaled by the step size $\\eta_t$.\n\nSeveral possible incarnations of gradient descent are possible; two commons ones are:\n\n- **batch** gradient descent which, at every step, computes the exact gradient at the point $w_t$;\n- **stochastic** gradient descent which approximates the gradient by using only one randomly chosen data point $x_t$.\n\nThe first algorithm will generally converge in a much smaller number of iterations than the stochastic gradient descent, but the much higher cost of every iteration makes it generally much slower to use in practice, making SGD the algorithm of choice for many RLM problems. Note here, that this is particularly true in the \"big data\" setting that is of interest in this work.\n\n### Choosing the Step Size\n\nThe sequence $\\eta_t$ is generally chosen to be a decreasing function of $t$ with common choices being $\\eta_t = 1/t$ or $\\eta_t = 1/\\sqrt{t}$ or even $\\eta_t = \\eta$ for some constant $\\eta$ and needs to be tuned to achieve good performance. A $\\eta_t$ that decreases too\nfast e.g. $1/t$ can in fact severely slow down convergence while a bigger step can completely prevent the algorithm from converging. An alternative to defining a fixed $\\eta_t$ sequence, is to select a good step size at each step, using a line search algorithm; this approach is however limited to batch gradient descent algorithms, as a line search algorithm would need to compute the value of the whole objective function, making the complexity of every iteration at least linear in the size of the dataset.\n\n**Algorithm 1** Batch Gradient Descent\n\n1: **Input:** Loss function $\\ell_i$, regularizer $g$ and data matrix $A$.\n2: **Output:** $\\text{argmin}_w P(w)$\n3: $w_0 := 0$\n4: for $t = 1, 2, 3, \\ldots$ do\n5: $w_t = w_{t-1} - \\eta_t \\nabla P(w)$\n6: end for\n\n**Algorithm 2** Stochastic Gradient Descent\n\n1: **Input:** Loss function $\\ell_i$, regularizer $g$ and data matrix $A$.\n2: **Output:** $\\text{argmin}_w P(w)$\n3: $w_0 := 0$\n4: for $t = 1, 2, 3, \\ldots$ do\n5: Pick a random data point $x_i$\n6: $w_t = w_{t-1} - \\eta_t \\nabla \\left[ n \\ell_i(x_i^T w) + g(w) \\right]$\n7: end for\n\n1.2 Distributed Optimization\n\nIn this section we will look at some simple distributed optimization algorithms to better understand the power and limitations of this model of computation. When speaking about computation, especially distributed computation, it is important to specify the exact model we will be employing, as different models exist with different specifications and capabilities. In particular, in this work, we are interested in distributed computation according to the general MapReduce [4] programming paradigm, and will utilize Apache Spark [18], which is a popular instantiation of this.\n\n1.2.1 The MapReduce Model\n\nPresented in [4], MapReduce has been one of the first and most influential programming models for distributed computation. The model assumes that the data input to the computation are partitioned into several *splits* and spread\n1.2. Distributed Optimization\n\nacross a set of machines; the data is also assumed to be a collection of key-value pairs. Computation is based on two simple operations inspired by the functional programming paradigm:\n\n- **Map:** \\((k_1, v_1) \\rightarrow \\text{list}(k_2, v_2)\\): This operation, applied independently to all the input pairs, takes a key-value pair and maps it to a list of key-value pairs.\n\n- **Reduce:** \\((k_1, \\text{list}(v_1)) \\rightarrow \\text{list}(v_2))\\): Pairs from the map stage having the same key are then grouped together producing a set of lists with an associated key. Each of these lists are then independently fed to a reduce function which will finally output a list of values.\n\nDespite its apparent simplicity the model is very powerful and many common algorithms can be formalized in it.\n\n1.2.2 Apache Spark\n\nApache Spark is a framework for large-scale in-memory data processing [18] based on the MapReduce model. The model is based on the concept of Resilient Distributed Dataset (RDD) which can be thought of as collections of elements distributed over \\(K\\) partitions on \\(M\\) worker machines. In many scenarios the number of partitions in an RDD will correspond to the total number of cores collectively available on the machines. The Spark computational model supports several classes of operations on RDDs; these operations are orchestrated and always initiated by a driver machine. In this work we will mostly be concerned with the following three kinds of operations:\n\n- **mapPartition:** This operation, takes the content of a partition and creates a new RDD obtained my mapping the content of each partition using some mapping function; we will assume that the resulting RDD keeps the original partitioning. A mapPartition, though still orchestrated by the driver, will only involve the worker machines in the actual computations and no data transfer will happen across machines.\n\n- **reduce:** This aggregates the elements of an RDD by means of a commutative and associative operation (e.g. sum), returning the result of this aggregation back to the driver node.\n\n- **broadcast:** This will be used to broadcast data from the master to all the machines; it is worth noticing that only one copy of the broadcast data is created per machine and it is thus shared across partitions present on the same machine.\n\n1.2.3 Distributed Gradient Descent\n\nWe can now present a simple strategy to distribute a gradient descent algorithm for RLM that perfectly fits in the Spark computing system. We will thus\n1.3. Primal-Dual Methods\n\nAssume that we are given a data matrix\n\n\\[ A = [x_1, \\ldots, x_n] \\]\n\npartitioned column-wise over \\( K \\) worker nodes. We will refer to the set of indices assigned to each partition \\( k \\in [K] \\) as \\( \\mathcal{P}_k \\); in other words each partition \\( k \\) will store data points \\( x_i \\) for \\( \\forall i \\in \\mathcal{P}_k \\). The simplest strategy to distribute Gradient Descent thus is to distribute over the computation of the gradient\n\n\\[\n\\nabla P(w) = \\nabla g(w) + \\sum_{i=1}^{n} \\nabla \\ell_i(x_i^T w) = \\nabla g(w) + \\sum_{k=1}^{K} \\sum_{i \\in \\mathcal{P}_k} \\nabla \\ell_i(x_i^T w).\n\\]\n\nIn order to compute this we will first of all broadcast the \\( w \\) vector to all worker nodes. At this point, we can map every partition \\( \\mathcal{P}_k \\) to the \\( \\sum_{i \\in \\mathcal{P}_k} \\nabla \\ell_i(x_i^T w) \\) summation value; this only requires accessing data already available on the partition and the broadcast \\( w \\) vector. We then sum the values returned by the partitions through a reduce operation and the master can now finally compute the gradient of the function by finally adding \\( \\nabla g(w) \\) to it. We can see all of this put together in Algorithm 3.\n\n**Algorithm 3 Distributed Gradient Computation**\n\n1: **Input**: \\( x_i \\) vectors distributed over \\( K \\) partitions, \\( w \\) vector\n2: **Output**: \\( \\nabla P(w) \\)\n3: Broadcast \\( w \\) to all workers\n4: **for** \\( k \\in \\{1, 2, \\ldots, K\\} \\) **in** parallel **over** workers **do**\n5: \\( \\text{Compute } \\nabla P_k(w) := \\sum_{i \\in \\mathcal{P}_k} \\nabla \\ell_i(x_i^T w) \\)\n6: **end for**\n7: **Reduce** \\( \\nabla P'(w) = \\sum_{k=1}^{K} P_k(w) \\)\n8: **return** \\( \\nabla P'(w) + \\nabla g(w) \\)\n\n1.3 Primal-Dual Methods\n\nIn this section we will now turn to primal-dual based methods applied to RLM problems. This will serve as a foundation for the rest of this work, as the main concepts related to primal-dual methods will be here introduced and explained.\n\n1.3.1 Convex Conjugates\n\nA fundamental concept that will appear all throughout this work is the convex conjugate.\n\n**Definition 1.** The convex conjugate of a function \\( f : \\mathbb{R}^d \\to \\mathbb{R} \\) is defined as\n\n\\[\nf^*(v) := \\max_{u \\in \\mathbb{R}^d} v^T u - f(u)\n\\]\n1.3.2 The Dual Problem\n\nAs in the previous section, we will be looking at RLM problems, defined as\n\n\\[\n\\min_{w \\in \\mathbb{R}^d} \\quad P(w) := g(w) + \\sum_{i=1}^{n} \\ell_i(x_i^T w). \\tag{1.3}\n\\]\n\nThe main idea behind primal-dual based methods though is to maximize a quadratic lowerbound of (1.3) instead, which can be defined as\n\n\\[\n\\max_{\\alpha \\in \\mathbb{R}^n} \\quad D(\\alpha) := -g^* \\left( A\\alpha \\right) - \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i) \\tag{1.4}\n\\]\n\nHere we will now show as this problem arises naturally from (1.3). Beginning with the primal formulation, we introduce variables \\( z_i = w^T x_i \\) for \\( i = 1, \\ldots, n \\).\n\nThe optimization problem (1.3) thus becomes:\n\n\\[\n\\min_{w \\in \\mathbb{R}^d} \\quad g(w) + \\sum_{i=1}^{n} \\ell_i(z_i) \\quad \\text{such that} \\quad z_i = x_i^T w. \\tag{1.5}\n\\]\n\nIntroducing dual variables \\( \\alpha = [\\alpha_1, \\ldots, \\alpha_n] \\), the Lagrangian is given by:\n\n\\[\nL(w, z; \\alpha) := g(w) + \\sum_{i=1}^{n} \\ell_i(z_i) + \\sum_{i=1}^{n} \\alpha_i \\left( z_i - x_i^T w \\right).\n\\]\n\nThe dual problem follows by taking the infimum with respect to \\( w \\) and \\( z \\):\n\n\\[\n\\inf_{w,z} L(w, z; \\alpha) = \\inf_w \\left\\{ g(w) - (A\\alpha)^T w \\right\\} + \\sum_{i=1}^{n} \\inf_{z_i} \\left\\{ \\ell_i(z_i) + \\alpha_i z_i \\right\\}\n= - \\sup_w \\left\\{ (A\\alpha)^T w - g(w) \\right\\} - \\sum_{i=1}^{n} \\sup_{z_i} \\left\\{ -\\alpha_i z_i - \\ell_i(z_i) \\right\\}\n= -g^*(A\\alpha) - \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i)\n\\]\n\narriving at the dual formulation (1.4). From the above derivation it is also clear that, since\n\n\\[\n\\min_{w \\in \\mathbb{R}^d} P(w) = \\max_{\\alpha \\in \\mathbb{R}^n} D(\\alpha)\n\\]\n\nthen for every \\( w \\in \\mathbb{R}^d \\) and \\( \\alpha \\in \\mathbb{R}^n \\)\n\n\\[\nG(\\alpha) = P(w) - D(\\alpha)\n\\]\n\nwill always be positive and an upper bound to the suboptimality of a \\( w \\) solution for the primal problem \\( P \\). Given \\( \\alpha \\in \\mathbb{R}^n \\), a corresponding primal vector \\( w \\in \\mathbb{R}^d \\) can be obtained as:\n\n\\[\nw := w(\\alpha) := \\nabla g^*(v(\\alpha)).\n\\]\n1.3.3 Stochastic Dual Coordinate Ascent for L2 Regularization\n\nIn this section we will look at SDCA, a well known algorithm to maximize problem (1.4) in the simplest possible case of $g(w) = \\|w\\|_2^2$. We will only give a high level overview of the method, but an extensive analysis of it can be found in [12] and a very popular implementation in the open source LIBLINEAR [5] library. In order to get the dual problem for this case, we will first of all compute the convex conjugate of $g$; we thus need to solve\n\n$$g^*(v) := \\max_{u \\in \\mathbb{R}^d} v^T u - \\frac{\\|u\\|_2^2}{2}. \\hspace{1cm} (1.7)$$\n\nGiven the convexity of $v^T u - \\|u\\|_2^2$ we can compute its maximum by finding the root of its derivative $v - u = 0 \\iff v = u$ and replacing it in (1.7) getting $g^*(v) = \\|v\\|_2^2$.\n\nWe will now look at an actual SDCA based algorithm for solving this problem; the idea behind this class of methods is to iteratively choose a random index $i \\in [n]$ and maximize problem (1.4) with respect to $\\alpha_i$ keeping all the other coordinates fixed. In other words, for a fixed $i$, we want to solve\n\n$$\\max_{\\Delta \\alpha_i \\in \\mathbb{R}} D(\\alpha + \\Delta \\alpha_i e_i) = \\max_{\\Delta \\alpha_i \\in \\mathbb{R}} \\left[ - \\frac{1}{2} \\|A \\alpha + \\Delta \\alpha_i x_i\\|_2^2 - \\ell_i^* (-\\alpha_i - \\Delta \\alpha_i) \\right]$$\n\nand replacing $A \\alpha$ with $v(\\alpha)$ we get:\n\n$$\\max_{\\Delta \\alpha_i \\in \\mathbb{R}} \\left[ - \\frac{1}{2} \\|v(\\alpha) + \\Delta \\alpha_i x_i\\|_2^2 - \\ell_i^* (-\\alpha_i - \\Delta \\alpha_i) \\right]. \\hspace{1cm} (1.8)$$\n\nMore precisely, the resulting optimization algorithm will be Algorithm 4. One important thing to notice is that, for efficiency reasons, the $v(\\alpha_t)$ iterate will be computed incrementally at each iteration, given the iterate $v(\\alpha_{t-1})$, as\n\n$$v(\\alpha_t) = A \\alpha_t = A(\\alpha_{t-1} + \\Delta \\alpha_i x_i) = v(\\alpha_{t-1}) + \\Delta \\alpha_i x_i.$$ \n\nThe SDCA algorithm we just presented has several advantages over the similar SGD algorithm:\n\n- The algorithm has no parameter to be tuned; in particular there is no step size to be chosen.\n\n- It is possible to use the duality gap as a sound certificate of suboptimality and it can thus be used as a well defined stopping criterion for the algorithm.\n\n- Despite having similar theoretical convergence rates [12], it is reported that it can be superior to SGD in $L_2$ regularized SVM problems.\nAlgorithm 4 Stochastic Dual Coordinate Ascent\n\n1: **Input**: Loss functions \\( \\ell_i \\), data matrix \\( A \\).\n2: **Output**: \\( \\arg \\max_{\\alpha} P(\\alpha) \\) and \\( v = v(\\alpha) = \\arg \\min P(v) \\)\n3: \\( \\alpha^{(0)} := 0, w^{(0)} := 0 \\).\n4: for \\( t = 1, 2, 3, \\ldots \\) do\n5: Pick a random data point \\( x_i \\)\n6: Find \\( \\Delta \\alpha \\) maximizing (1.8)\n7: \\( \\alpha^{(t)} = \\alpha^{(t-1)} + \\Delta \\alpha e_i \\)\n8: \\( v^{(t)} = v^{(t-1)} + \\Delta \\alpha x_i \\)\n9: end for\nIn the previous chapter we looked at different sequential and distributed optimization algorithms. In particular, we saw how to apply gradient descent based algorithms to the general form of RLM problems in a distributed environment, but we only saw a sequential version of SDCA and on the specific setting of $L_2$ regularization. Achieving the same generality for the SDCA approach is in fact possible and will be the main focus of this chapter and a main contribution of this thesis.\n\nPrevious work on SDCA has already, in part, dealt with the problem of applying SDCA to more general settings, both in term of distribution and generalization to different regularizers; in particular two methods have been studied that tried to bridge the gap with gradient descent methods:\n\n- **ProxSDCA**: The proxSDCA method [11]: a generalization of the algorithm 4. The basic idea underlying the method is to optimize, during a coordinate step, a quadratic lowerbound of the actual dual function; convergence results are proven for general strongly convex regularizers.\n\n- **CoCoA+**: The CoCoA+ method [10]: a distributed and communication efficient primal-dual optimization method for $L_2$ regularization. The algorithm assumes that the data are partitioned across several machines and works by optimizing surrogate dual local subproblems for every partition and then combining the results by scaling the independent partition updates in a suitable way; the local optimizations can be performed using arbitrary local solvers. A special case of CoCoA+ is the CoCoA method [8] which, in its common instantiation using an SDCA based local solver, can be thought of as performing SDCA on the original problem independently for every partition and then averaging the results.\n\nIn this chapter we will combine ideas from both works in order to develop ProxCoCoA+, a general method for primal-dual distributed optimization of RLM problems with strongly convex regularizers.\n2.1 Setting\n\nIn this section we will formally present the setting for this work. Similarly as in the previous chapter we will be looking at models of the form\n\n\\[ \\min_{w \\in \\mathbb{R}^d} \\left[ P(w) := g(w) + \\sum_{i=1}^{n} \\ell_i(x_i^T w) \\right]. \\quad (2.1) \\]\n\nIn addition to this, in order to prove the convergence results, we will assume that the functions \\( \\ell_i, i \\in [n] \\) are convex, and the function \\( g(.) \\) is \\( \\tau \\)-strongly convex, with \\( \\tau > 0 \\).\n\nData Partitioning\n\nAs in section 1.2.3 we will assume that the data matrix \\( A = [x_1, \\ldots, x_n] \\) is partitioned column-wise in \\( P_k \\) partitions over \\( K \\) worker nodes; the size of each partition will be denoted as \\( n_k = |P_k| \\) and the data in each partition will be denoted as \\( A[k] \\). In addition we will also have one dual variable \\( \\alpha_i \\) per data point, and will represent them as \\( \\alpha = [\\alpha_1, \\ldots, \\alpha_n] \\) vectors; this vector will have the same partitioning of the \\( A \\) matrix, and we will indicate each partition \\( k \\) as \\( \\alpha[k] \\).\n\n2.2 Distributed Algorithmic Framework\n\nThe CoCoA Special Case\n\nWe will now look at what is perhaps the simplest strategy to apply an SDCA type of algorithm to a distributed setting. The approach we will use is based on and generalizes the CoCoA algorithm presented in [8]; this will serve us to build an intuition for when, later on, we will generalize the problem further. As with the previously seen SDCA method, we will work on the dual formulation\n\n\\[ \\max_{\\alpha \\in \\mathbb{R}^n} \\left[ D(\\alpha) := -g^*(v(\\alpha)) - \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i) \\right]. \\quad (2.2) \\]\n\ninstead than on the primal one. The algorithm will proceed iteratively looking at each round \\( t \\) for a better \\( \\alpha^{(t+1)} \\) solution for the dual optimization problem, starting from a previous solution \\( \\alpha^{(t)} \\). More precisely, each partition will only be responsible for the dual variable corresponding to the data points that reside on that partition; we will indicate the subset of dual variables for a partition as \\( \\alpha[k] \\). We will then start the algorithm with \\( \\alpha[0] = 0 \\) and thus a corresponding \\( v = v(\\alpha) = 0 \\). Independently for each partition we will then look for a \\( \\Delta\\alpha[k] \\) vector that optimizes the problem on partition \\( k \\) only with respect to the dual variables on that partition. Formally, if \\( \\alpha^{(t)} \\) is the current iterate, partition \\( k \\) would solve the following local subproblem\n2.2. Distributed Algorithmic Framework\n\n\\[\n\\max_{\\Delta \\alpha[k] \\in \\mathbb{R}^n} - \\sum_{i \\in P_k} \\ell_i^* \\left( - (\\alpha + \\Delta \\alpha[k])_i \\right) - g^* \\left( \\mathbf{v}(\\alpha^{(t)}) + \\Delta \\alpha[k] \\right).\n\\] \n\nSolving this problem might however not be easy for complex \\( g^* \\) functions [11]. Therefore, instead of solving this problem directly we will – inspired by the proxSDCA approach [11] – maximize a quadratic lower bound of it. In order to achieve this we will notice that – because of \\( \\tau \\)-strong convexity assumption on \\( g \\) and using Proposition 2 – \\( g^* \\) is \\((1/\\tau)\\)-smooth. This means that, by Definition 17, we have:\n\n\\[\ng^* \\left( \\mathbf{v}(\\alpha^{(t)} + \\Delta \\alpha[k]) \\right) \\leq g^* \\left( \\mathbf{v}(\\alpha^{(t)}) + \\nabla g^* \\left( \\mathbf{v}(\\Delta \\alpha[k]) \\right) \\right)^T \\mathbf{v}(\\alpha^{(t)}) + \\frac{1}{2\\tau} \\left\\| \\mathbf{v}(\\Delta \\alpha[k]) \\right\\|^2\n\\]\n\nand therefore we have that\n\n\\[\n- \\sum_{i \\in P_k} \\ell_i^* \\left( - (\\alpha + \\Delta \\alpha[k])_i \\right) - g^* \\left( \\mathbf{v}(\\alpha^{(t)}) - \\mathbf{w}(\\alpha^{(t)})^T \\mathbf{v}(\\alpha^{(t)}) - \\frac{1}{2\\tau} \\left\\| \\mathbf{v}(\\Delta \\alpha[k]) \\right\\|^2\n\\]\n\nwhere the left hand side of the equation is the lower-bound we will optimize on. By optimizing this problem for every partition we will thus get \\( k \\) solution vectors \\([\\Delta \\alpha[k], \\ldots, \\Delta \\alpha[k]] =: \\Delta \\alpha\\). We can now conclude an iteration by computing the new vector iterate summing \\( \\alpha^{(t)} \\) and the \\( \\Delta \\alpha \\) vector update rescaled by \\( \\frac{1}{K} \\).\n\n\\[\n\\alpha^{(t+1)} = \\alpha^{(t)} + \\frac{1}{K} \\Delta \\alpha.\n\\]\n\nIt is shown in [8] – and will again be shown in a more general setting in this work – that the \\( \\frac{1}{K} \\) scaling is a safe choice to ensure that the algorithm will convergence to the correct solution of the dual problem.\n\n**Generalizing the Local Subproblems**\n\nBased on the derivation from the previous section we will now define a slightly different and more general local problem, generalizing the one defined for CoCoA+ [10]. Similarly as before, this problem, defined for each partition \\( k \\), will only directly depend on data that reside on it and on a \\( \\mathbf{v} = \\mathbf{v}(\\alpha) \\) vector shared among all partitions. This vector will allow us to account, in a communication efficient way, for the *state* of other partitions. A new parameter \\( \\sigma' \\) that we’ll refer to as *complexity parameter* will also appear in the formula; its role will though only be explored in later sections and only after having presented the complete ProxCoCoA+ algorithm. We thus define the local subproblems as follows:\n\n\\[\n\\max_{\\Delta \\alpha[k] \\in \\mathbb{R}^n} G^*_k \\left( \\Delta \\alpha[k]; \\mathbf{v}, \\alpha[k] \\right)\n\\]\nwhere \\( G^\\sigma_k(\\Delta \\alpha_{[k]}; v, \\alpha_{[k]}) := \\)\n\\[-\\sum_{i \\in P_k} \\ell_i^*(-\\alpha + \\Delta \\alpha_{[k]}_i) - \\frac{1}{K} g^*(v) - w^T v(\\Delta \\alpha_{[k]}) - \\frac{\\sigma'}{2\\tau} \\|v(\\Delta \\alpha_{[k]})\\|^2 \\]\n\nand \\( w \\) is defined as \\( w := \\nabla g^*(v) \\). This subproblem is more general than the CoCoA+ subproblem \\([10]\\). In order to obtain a subproblem formulation analogous to the one presented in CoCoA+ we just have to define \\( g(w) = \\|w\\|_2^2 \\); we therefore have that the strong convexity parameter is 1 and is \\( \\tau \\)-strongly convex, and \\( w = v \\). The obtained formula would however not be identical as we have no scaling factor \\( \\frac{1}{n} \\) in front of the loss functions and no factor \\( \\lambda \\) that multiplies the regularizer. Later in this chapter, we will however see how to adapt ProxCoCoA+ to the case in which losses and regularizers are rescaled.\n\n### The Algorithm\n\nWe will now formally present Algorithm 5. The basic idea is similar to what we have seen for the CoCoA special case and it is based on decomposing the problem in partition local subproblems and solving them with respect to a subset of dual variables. These solutions are then summed up, after being scaled by a \\( \\gamma \\) parameter. A detailed analysis of the algorithm dependent on its parameters will be the main focus of the following sections.\n\n**Algorithm 5** ProxCoCoA+ Algorithm for Problem (2.1)\n\n1. **Input:** Regularizer \\( g(v) \\), loss functions \\( \\ell_i \\). Data matrix \\( A \\) distributed column-wise according to partitions \\( \\{P_k\\}_{k=1}^K \\). Aggregation parameter \\( \\gamma \\in (0, 1] \\), parameter \\( \\sigma' \\). Initialize \\( \\alpha^{(0)} := 0 \\in \\mathbb{R}^n \\), \\( v^{(0)} := 0 \\in \\mathbb{R}^d \\).\n2. for \\( t = 0, 1, 2, \\ldots \\) do\n3. for \\( k \\in \\{1, 2, \\ldots, K\\} \\) in parallel over partitions do\n4. find a \\( \\Theta \\)-approximate solution \\( \\Delta \\alpha_{[k]} \\) for the local subproblem (2.5) using an arbitrary local solver\n5. update \\( \\alpha_{[k]}^{(t+1)} := \\alpha_{[k]}^{(t)} + \\gamma \\Delta \\alpha_{[k]} \\)\n6. return \\( \\Delta v_k := A \\Delta \\alpha_{[k]} \\)\n7. end for\n8. reduce \\( v^{(t+1)} := v^{(t)} + \\gamma \\sum_{k=1}^K \\Delta v_k \\)\n9. end for\n\n### The Aggregation and Complexity Parameters\n\nAs we has seen in the previous sections, Algorithm 5 depends on two important parameters \\( \\gamma \\) and \\( \\sigma' \\). The *aggregation parameter* \\( \\gamma \\), in particular, allows\n2.2. Distributed Algorithmic Framework\n\nthe algorithm to interpolate between an averaging based and an adding based approach. The \\( \\sigma' \\) parameter instead serves as a measure of difficulty of partitioning and has to be chosen in a way that is dependent on the correlation between the partitions and on the aggregation strategy of the algorithm as determined by \\( \\gamma \\).\n\nIn order to clarify the role of this parameter we will now look at two \\( \\sigma' \\) choices for the \\( L_2 \\) regularized case (in this case we can assume \\( \\tau = 1 \\)):\n\n- \\( \\sigma' = 1 \\): in this case the local problem becomes\n\n\\[\n\\max_{\\Delta\\alpha_{[k]} \\in \\mathbb{R}^n} - \\sum_{i \\in P_k} \\ell_i^* \\left( - (\\alpha + \\Delta\\alpha_{[k]})_i \\right) - \\frac{1}{2K} \\|v\\|^2 - w^T v(\\Delta\\alpha_{[k]}) - \\frac{1}{2} \\|v(\\Delta\\alpha_{[k]})\\|^2\n\\]\n\nBeing the maximization problem independent of \\( v \\) and \\( w = v \\) we can get rid of the \\( 1/K \\) factor, obtaining the following equivalent maximization problem\n\n\\[\n\\max_{\\Delta\\alpha_{[k]} \\in \\mathbb{R}^n} - \\sum_{i \\in P_k} \\ell_i^* \\left( - (\\alpha + \\Delta\\alpha_{[k]})_i \\right) - \\frac{1}{2} \\|v + v(\\Delta\\alpha_{[k]})\\|^2.\n\\]\n\nWe can easily notice that this maximization problem is equivalent to maximizing the original problem for the \\( \\alpha_{[k]} \\) subset of dual variables. As we will prove in the following section, and as previously seen, a safe choice to combine the subproblem solutions in this case is to use a parameter \\( \\gamma = \\frac{1}{K} \\) that is equivalent to a simple averaging of the primal solutions.\n\n- \\( \\sigma' = K \\): in this case the local problem becomes\n\n\\[\n\\max_{\\Delta\\alpha_{[k]} \\in \\mathbb{R}^n} - \\sum_{i \\in P_k} \\ell_i^* \\left( - (\\alpha + \\Delta\\alpha_{[k]})_i \\right) - \\frac{1}{2} \\|v + K v(\\Delta\\alpha_{[k]})\\|^2 - K v^T v(\\Delta\\alpha_{[k]}) - \\frac{1}{2} \\|v(\\Delta\\alpha_{[k]})\\|^2\n\\]\n\nMultiplying everything by \\( K \\) we get that the previous is equivalent to the following\n\n\\[\n\\max_{\\Delta\\alpha_{[k]} \\in \\mathbb{R}^n} - \\sum_{i \\in P_k} \\ell_i^* \\left( - (\\alpha + \\Delta\\alpha_{[k]})_i \\right) - \\frac{1}{2} \\|v + K v(\\Delta\\alpha_{[k]})\\|^2 - K v^T v(\\Delta\\alpha_{[k]}) - \\frac{1}{2} \\|v(\\Delta\\alpha_{[k]})\\|^2 = \\max_{\\Delta\\alpha_{[k]} \\in \\mathbb{R}^n} - \\sum_{i \\in P_k} \\ell_i^* \\left( - (\\alpha + \\Delta\\alpha_{[k]})_i \\right) - \\frac{1}{2} \\|v + K v(\\Delta\\alpha_{[k]})\\|^2.\n\\]\n\nDifferently from the \\( \\sigma' = 1 \\) case, we are in this case explicitly accounting for the contributions of the other machines by scaling the \\( v(\\Delta\\alpha_{[k]}) \\) vector by the number of partitions \\( K \\). In other words we are looking for a solution to the optimization problem on the local partition by assuming that the other partitions will find a similar \\( v(\\Delta\\alpha_{[k]}) \\) parameter vector.\nMore generally and similarly as for the original CoCoA+ method, we will make the following assumption on the $\\gamma$ and $\\sigma'$ parameters.\n\n**Assumption 1.** The $\\gamma$ and $\\sigma'$ parameters must be such that $\\gamma \\in [0, 1]$ and\n\n$$\n\\sigma' \\geq \\sigma'_{\\text{min}} := \\gamma \\max_{\\alpha \\in \\mathbb{R}^n} \\frac{\\|A\\alpha\\|^2}{\\sum_{k=1}^K \\|A\\alpha[k]\\|^2}.\n$$\n\n(2.6)\n\nGiven this assumption we can in fact present and prove Lemma 2 – which is the direct equivalent of [10, Lemma 4] – which illustrates how different choices of aggregation and complexity parameters affects the gain that we get when combining different subproblems.\n\n**Lemma 2.** Given For any $\\alpha, \\Delta \\alpha \\in \\mathbb{R}^n$, $v = v(\\alpha)$ and real values $\\gamma, \\sigma'$ as in Assumption 1, it holds that\n\n$$\n\\mathcal{D}\n(\\alpha + \\gamma \\sum_{k=1}^K \\Delta \\alpha[k]) \\geq (1 - \\gamma)\\mathcal{D}(\\alpha) + \\gamma \\sum_{k=1}^K \\mathcal{G}_k'(\\Delta \\alpha[k]; v, \\alpha[k]),\n$$\n\n(2.7)\n\nChoosing the complexity parameter $\\sigma'$ to be exactly $\\sigma'_{\\text{min}}$ as in (2.6) is though in general not always possible; however as shown in [10] it always holds that\n\n$$\n\\sigma'_{\\text{min}} \\leq \\gamma K.\n$$\n\n(2.8)\n\nThe value $\\gamma K$ can thus be used as a safe value for $\\sigma'$ in the algorithm.\n\nFor later use we will also define the following quantity:\n\n**Definition 3 ([10, defined in Lemma 6]).**\n\n$$\n\\sigma_k := \\max_{\\alpha[k] \\in \\mathbb{R}^n} \\frac{\\|A\\alpha[k]\\|^2}{\\|\\alpha[k]\\|^2}.\n$$\n\n(2.9)\n\n### 2.2.1 Solving the Local Subproblems\n\nAs seen, Algorithm 5 presented in the previous section does not specify or impose any specific method to optimize the local subproblems $\\mathcal{G}_k'^*$. In fact, as in [10] we will make relatively weak assumptions about such solvers:\n\n**Assumption 2 (Θ-approximate solution).** We will require that a local solver always returns a $\\Theta \\in [0, 1)$ approximate solution; that is, whenever called and for $\\forall k \\in [K], \\sigma', w, \\alpha[k]$ it produces a (possibly) randomized approximate solution $\\Delta \\alpha[k]$, which satisfies\n\n$$\n\\mathbb{E}[\\mathcal{G}_k'^* (\\Delta \\alpha[k]^*; w, \\alpha[k]) - \\mathcal{G}_k' (\\Delta \\alpha[k]; w, \\alpha[k])] \\\\\n\\leq \\Theta \\left( \\mathcal{G}_k' (\\Delta \\alpha[k]^*; w, \\alpha[k]) - \\mathcal{G}_k' (0; w, \\alpha[k]) \\right),\n$$\n\n(2.10)\n2.2. Distributed Algorithmic Framework\n\nwhere\n\n\\[\n\\Delta \\alpha_{[k]}^* \\in \\arg \\max_{\\Delta \\alpha \\in \\mathbb{R}^n} G_k'((\\Delta \\alpha_{[k]}; w, \\alpha_{[k]})) \\quad \\forall k \\in [K] \\tag{2.11}\n\\]\n\nBy looking at the structure of the local subproblems (2.5), we can see that a very natural choice for a local solver, would be a Stochastic Dual Coordinate Ascent based algorithm, similar to Algorithm 4 – this is however just a possible choice we’ll present for ease of understanding, since any local solver conforming to Assumption 2 would be suitable. In order to solve this we immediately notice that we can leave out the \\( g^*(v) \\) term as it is independent of the \\( \\Delta \\alpha_{[k]} \\) variables. We therefore get that\n\n\\[\n\\max_{\\Delta \\alpha \\in \\mathbb{R}^n} G_k'((\\Delta \\alpha_{[k]}; v, \\alpha_{[k]})) =\n\\]\n\n\\[\n\\max_{\\Delta \\alpha \\in \\mathbb{R}^n} \\left[ -\\sum_{i \\in P_k} \\ell_i'(-\\alpha - \\Delta \\alpha) - w^T v(\\Delta \\alpha_{[k]}) - \\frac{\\sigma'}{2\\tau} \\| v(\\Delta \\alpha_{[k]}) \\|^2 \\right].\n\\]\n\nSimilarly as in Algorithm 4, an SDCA algorithm for this problem will work by iteratively choosing a random index \\( i \\in P_k \\) and maximize the problem with respect to the \\( i \\)-th coordinate. That is, for a fixed \\( i \\) we get:\n\n\\[\n\\max_{\\Delta \\alpha \\in \\mathbb{R}^n} \\left[ -\\ell_i'(-\\alpha - \\Delta \\alpha) - w^T v(\\Delta \\alpha_{[k]}) - \\frac{\\sigma'}{2\\tau} \\| v(\\Delta \\alpha_{[k]}) \\|^2 \\right]\n\\]\n\nthat we obtained by leaving out the \\( \\ell_i \\) that do not depend on \\( \\Delta \\alpha \\). By expanding \\( v(\\Delta \\alpha_{[k]}) \\) we now get\n\n\\[\n- \\max_{\\Delta \\alpha \\in \\mathbb{R}} \\left[ -\\ell_i'(-\\alpha - \\Delta \\alpha) - w^T (v(\\Delta \\alpha_{[k]}) + \\Delta \\alpha x_i) - \\frac{\\sigma'}{2\\tau} \\| v(\\Delta \\alpha_{[k]}) + \\Delta \\alpha x_i \\|^2 \\right],\n\\]\n\nand by again leaving out terms independent of \\( \\Delta \\alpha \\) we arrive at\n\n\\[\n- \\max_{\\Delta \\alpha \\in \\mathbb{R}} \\left[ -\\ell_i'(-\\alpha - \\Delta \\alpha) - \\Delta \\alpha w^T x_i - \\frac{\\sigma'}{2\\tau} \\| \\Delta \\alpha x_i \\|^2 - \\frac{\\sigma'}{2\\tau} \\Delta \\alpha^2 \\| x_i \\|^2 \\right] =\n\\]\n\n\\[\n\\max_{\\Delta \\alpha \\in \\mathbb{R}} \\left[ -\\ell_i'(-\\alpha - \\Delta \\alpha) - \\Delta \\alpha x_i^T (w + \\frac{\\sigma'}{\\tau} v(\\Delta \\alpha_{[k]})) - \\frac{\\sigma'}{2\\tau} \\Delta \\alpha^2 \\| x_i \\|^2 \\right]. \\tag{2.12}\n\\]\n\nJust as in Algorithm 4, the \\( \\Delta v_{[k]} := v(\\Delta \\alpha_{[k]}) \\) term will be updated at every local iteration in a similar way (as shown in Algorithm 6).\n2.3 Convergence Analysis for Lipschitz Losses\n\nFinally, we can give the following theorem for the general case of Lipschitz continuous losses.\n\n**Theorem 4** (Generalization of [10, Theorem 8] for general \\( g(\\cdot) \\) functions). Let \\( L \\)-Lipschitz continuous \\( \\ell_i(\\cdot) \\) functions, a \\( \\tau \\)-strongly convex \\( g \\) function and an arbitrary local solver satisfying Assumption 2 be given. Let \\( \\gamma, \\sigma' \\) be defined as in Assumption 1. Then, if \\( \\epsilon_G > 0 \\) is the desired duality gap, after \\( T \\) iterations of Algorithm 5 with\n\n\\[\nT \\geq T_0 + \\max\\left\\{ \\frac{1}{\\gamma(1-\\Theta)}, \\frac{4L^2\\sigma\\sigma'}{\\tau\\epsilon_G\\gamma(1-\\Theta)} \\right\\},\n\\]\n\n\\[\nT_0 \\geq t_0 + \\left( \\frac{2}{\\gamma(1-\\Theta)} \\left( \\frac{8L^2\\sigma\\sigma'}{\\tau\\epsilon_G} - 1 \\right) \\right) + ,\n\\]\n\n\\[\nt_0 \\geq \\max(0, \\left[ \\frac{1}{\\gamma(1-\\Theta)} \\log\\left( \\frac{2(\\mathcal{D}(\\alpha^*) - \\mathcal{D}(\\alpha^{(0)}))}{4L^2\\sigma\\sigma'} \\right) \\right]),\n\\]\n\nthe expected duality gap will satisfy\n\n\\[\n\\mathbb{E}[\\mathcal{P}(\\bar{w}(\\bar{\\alpha})) - \\mathcal{D}(\\bar{\\alpha})] \\leq \\epsilon_G,\n\\]\n\nat the averaged iterate\n\n\\[\n\\bar{\\alpha} := \\frac{1}{T-T_0} \\sum_{t=T_0+1}^{T-1} \\alpha^{(t)}\n\\]\n\nIn order to compare this to previous work on distributed convex optimization we will now look at the more common RLM structure, that is:\n\n\\[\n\\max_{\\mathbf{w} \\in \\mathbb{R}^d} \\frac{1}{n} \\sum_{i=1}^{n} \\ell'_i(\\mathbf{w}^T \\mathbf{x}_i) + \\lambda g'(\\mathbf{w})\n\\]\n2.4. Convergence Analysis for Smooth Losses\n\nwith the assumption that the $\\ell'_i$ are $L'$-Lipschitz continuous and the function $g'(w)$ is 1-strongly convex. It is quite easy to see that by defining loss functions\n\n$$\\ell_i(w^T x_i) = \\frac{1}{n} \\ell'_i(w^T x_i)$$\n\nand regularizer\n\n$$g(w) = \\lambda g'(w)$$\n\nthe problem\n\n$$\\max_{w \\in \\mathbb{R}^d} \\sum_{i=1}^n \\ell_i(w^T x_i) + \\lambda g(w)$$\n\nnow fits in the required form. In particular we now have that the $\\ell_i$ functions are $(\\frac{L'}{n})$-Lipschitz and $g$ is $\\lambda$-strongly convex. This is sufficient to prove Corollary 5 which exactly matches the convergence rates for the CoCoA+ method.\n\n**Corollary 5.** Let $L'$-Lipschitz continuous $\\ell'_i(\\cdot)$ functions, a 1-strongly convex $g'$ function and an arbitrary local solver satisfying Assumption 2 be given. Let $\\gamma, \\sigma'$ be defined as in Assumption 1. Then, if $\\epsilon_G > 0$ is the desired duality gap, after $T$ iterations of Algorithm 5 with\n\n$$T \\geq T_0 + \\max\\left\\{ \\frac{1}{\\gamma(1-\\Theta)}, \\frac{4L'^2\\sigma'^{}}{\\lambda n^2 \\epsilon_G \\gamma(1-\\Theta)} \\right\\},$$\n\n$$T_0 \\geq t_0 + \\left( \\frac{2}{\\gamma(1-\\Theta)} \\left( \\frac{8L'^2\\sigma'^{}}{\\lambda n^2 \\epsilon_G} - 1 \\right) \\right),$$\n\n$$t_0 \\geq \\max(0, \\left\\lceil \\frac{1}{\\gamma(1-\\Theta)} \\log\\left( \\frac{2 \\lambda n^2 (D(\\alpha^*) - D(\\alpha(0)))}{4L'^2\\sigma'^{}} \\right) \\right\\rceil),$$\n\nthe expected duality gap will satisfy\n\n$$\\mathbb{E}[P(w(\\bar{\\alpha})) - D(\\bar{\\alpha})] \\leq \\epsilon_G,$$\n\nat the averaged iterate\n\n$$\\bar{\\alpha} := \\frac{1}{T-T_0} \\sum_{t=T_0+1}^{T-1} \\alpha^{(t)}.$$\n\n2.4 Convergence Analysis for Smooth Losses\n\nThe analysis in the previous chapter applies to general continuous Lipschitz continuous losses. If the function is smooth we can however show that we can achieve a better convergence rate.\n\n**Theorem 6** (Generalization of [10, Theorem 10] for general $g(\\cdot)$ functions). Let $(1/\\mu)$-smooth $\\ell_i(\\cdot)$ functions, a $\\tau$-strongly convex $g$ function and an arbitrary local solver satisfying Assumption 2 be given. Let $\\gamma, \\sigma'$ be defined as in\n2.4. Convergence Analysis for Smooth Losses\n\nAssumption 1 and define $\\sigma_{\\text{max}} = \\max_{k \\in [K]} \\sigma_k$. Then, if $\\epsilon_D > 0$ is the desired maximum dual suboptimality, after $T$ iterations of Algorithm 5 with\n\n$$T \\geq \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\mu' + \\sigma_{\\text{max}}\\sigma'}{\\mu n \\lambda} \\log \\frac{1}{\\epsilon_D},$$\n\nit holds that\n\n$$\\mathbb{E} [D(\\alpha^*) - D(\\alpha^{(T)})] \\leq \\epsilon_D.$$\n\nFurthermore, given the desired duality gap $\\epsilon_G$, after $T$ iterations with\n\n$$T \\geq \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\mu' + \\sigma_{\\text{max}}\\sigma'}{\\mu n \\lambda} \\log \\left( \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\mu' + \\sigma_{\\text{max}}\\sigma'}{\\mu n \\lambda} \\frac{1}{\\epsilon_G} \\right),$$\n\nthe expected duality gap is such that\n\n$$\\mathbb{E} [P(w(\\alpha^{(T)})) - D(\\alpha^{(T)})] \\leq \\epsilon_G.$$\n\nProof. The proof of this closely follows the one of [10, Theorem 10].\n\nSimilarly as what we have done for Lipschitz continuous losses, we can also present the following lemma that gives us a convergence rate for the more common case\n\n$$\\max_{w \\in \\mathbb{R}^d} \\sum_{i=1}^{n} \\frac{1}{n} \\ell'_i(w^T x_i) + \\lambda g'(w)$$\n\nwith the assumption that the $\\ell'_i$ are $(1/\\tau')$-smooth continuous and the function $g'(w)$ is $1$-strongly convex. We easily see that the losses $\\frac{1}{n} \\ell'_i(w^T x_i)$ are $(1/(\\mu' n))$ smooth and $\\lambda g$ regularizer is $\\lambda$-strongly convex. This is enough to prove Lemma 7 which matches the corresponding convergence rate from [10].\n\n**Corollary 7.** Let $(1/\\mu')$-smooth $\\ell'_i(\\cdot)$ functions, a $\\tau'$-strongly convex $g'$ function and an arbitrary local solver satisfying Assumption 2 be given. Let $\\gamma, \\sigma'$ be defined as in Assumption 1 and define $\\sigma_{\\text{max}} = \\max_{k \\in [K]} \\sigma_k$. Then, if $\\epsilon_D > 0$ is the desired maximum dual suboptimality, after $T$ iterations of Algorithm 5 with\n\n$$T \\geq \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\mu' n \\lambda + \\sigma_{\\text{max}}\\sigma'}{\\mu' n \\lambda} \\log \\frac{1}{\\epsilon_D},$$\n\nit holds that\n\n$$\\mathbb{E} [D(\\alpha^*) - D(\\alpha^{(T)})] \\leq \\epsilon_D.$$\n\nFurthermore, given the desired duality gap $\\epsilon_G$, after $T$ iterations with\n\n$$T \\geq \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\mu' n \\lambda + \\sigma_{\\text{max}}\\sigma'}{\\mu' n \\lambda} \\log \\left( \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\mu' n \\lambda + \\sigma_{\\text{max}}\\sigma'}{\\mu' n \\lambda} \\frac{1}{\\epsilon_G} \\right),$$\n\nthe expected duality gap is such that\n\n$$\\mathbb{E} [P(w(\\alpha^{(T)})) - D(\\alpha^{(T)})] \\leq \\epsilon_G.$$\n2.5 Elastic Net\n\nA very natural and immediate application of the framework we developed in this chapter is given by Elastic Net regularization; we will, however, only consider the case when it does not degenerate to $L_1$ regularization, as we have seen that a strong convex regularizer is a necessary requirement for primal-dual methods. Something similar to what we’ll see, was also done in the [11] paper, however for a non-distributed settings and applied to the problem of approximating $L_1$ regularization. Formally, we will therefore be looking at models with a regularization term having the following form:\n\n$$h(w) = \\frac{\\eta}{2} \\|w\\|_2^2 + \\eta \\|w\\|_1.$$ \n\nwith $\\eta > 0$.\n\nLemma 8. For $\\eta \\in (0, 1]$, the convex conjugate of the elastic net function\n\n$$f(\\alpha) := \\frac{\\eta}{2} \\alpha^2 + (1 - \\eta)|\\alpha|$$\n\nis\n\n$$f^*(x) := \\frac{1}{2\\eta}(\\left[|x| - (1 - \\eta)\\right])_+^2,$$\n\nwhere $[.]_+$ is the positive part operator, $[s]_+ = s$ for $s > 0$, and zero otherwise. Also, the conjugate $f^{**}$ of $f^*$ is equal to $f$.\n\nMore generally, just like we did for $L_2$ regularization, we can also allow a scaling factor $\\lambda$, thus giving us a regularizer\n\n$$g(w) = \\lambda h(w).$$\n\nGiven a convex loss function $\\ell_i$, and depending on its Lipschitz $L$-continuity or $(1/\\mu)$-smoothness we can now quite easily apply any of the convergence results proven in this chapter to an Elastic Net regularized model by simply noticing that the strong convexity parameter $\\tau$ of $g$ would in this case simply be $\\lambda \\eta$. \n\n20\nIn the previous chapter, we have developed a framework capable of handling problems of primal form\n\n\\[\n\\min_{\\mathbf{w} \\in \\mathbb{R}^d} \\left[ \\mathcal{P}(\\mathbf{w}) := g(\\mathbf{w}) + \\sum_{i=1}^{N} \\ell_i(\\mathbf{x}_i^T \\mathbf{w}) \\right]\n\\] \n\n(3.1)\n\nwith the assumption of \\( g \\) being \\( \\tau \\)-strongly convex with \\( \\tau > 0 \\). The main application of this framework that we have explored has been Elastic Net. However, we faced an important limitation: as the relative contribution of the \\( L_1 \\) term with respect to the \\( L_2 \\) term became bigger, the problem complexity increased asymptotically, allowing us to only approximate \\( L_1 \\) regularized problems. The main problem we were facing, was that as we approached \\( L_1 \\), the problem became less and less strongly-convex which is a necessary requirement for applying ProxCoCoA+. To overcome this, we will need a complete change of perspective: whereas traditional approaches were based on optimizing a problem that fit into the primal form and exploits the dual mapping as a mere algorithmic tool, here we will look at problems that fit directly into the dual form and optimize on it directly. We will call this method Primal ProxCoCoA+ or just PrimalCoCoA+ since the resulting algorithm will run on the primal of the original problem and the whole optimization problem will be distributed according to the primal coordinates, not the dual ones as in the previous sections. In summary, the roles of primal and dual problems will be completely swapped. The main idea behind the method will be to encode problems that are typically solved as primal problems in a dual formulation, suitable for the ProxCoCoA+ algorithm, and then use the ProxCoCoA+ algorithm to compute the actual solution.\n3.1 Encoding Primal Problems in Dual Form\n\nIn this section we will now look at how to encode typical primal problems in a form that is solvable directly in the dual. The models we are interested in solving are again problems in RLM-dual form and have therefore the following formulation:\n\n$$\\max_{\\alpha \\in \\mathbb{R}^n} \\left[ D(\\alpha) := -\\sum_{j=1}^{d} \\phi_j^*(y_j^T \\alpha) - r^*(\\alpha) \\right] \\quad (3.2)$$\n\nwhere the training examples $y_j$ are the rows of an $A := [y_1; \\ldots; y_d]^T = [x_1; \\ldots; x_n] \\in \\mathbb{R}^{d \\times n}$ data matrix - it is important to keep in mind here that training examples are put as rows of the data matrix, instead of being columns as it is more commonly the case. We will also assume that the $\\phi_i^*$ functions are $(1/\\tau)$-smooth. Clearly, doesn’t look exactly like the standard dual formulation (1.4); in order to achieve this we will have to make the additional assumption of $r^*$ being separable i.e. expressable as a sum of functions each depending on one coordinate. This is not a very restrictive assumption, as most regularizers - $L_2$, $L_1$ or elastic net - have in fact this form. We thus assume that $r^*$ has the following form\n\n$$r^*(\\alpha) = \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i).$$\n\nAs for the remaining part of the equation, we just need to adjust the notation. Using the now familiar primal-dual mapping notation\n\n$$v = v(\\alpha) = A\\alpha$$\n\nwe can define the following function\n\n$$g^*(v) := \\sum_{j=1}^{d} \\phi_j^*(v_j) = \\sum_{j=1}^{d} \\phi_j^*((A\\alpha)_j) = \\sum_{j=1}^{d} \\phi_j^*(y_j^T \\alpha)$$\n\nthus getting\n\n$$\\max_{\\alpha \\in \\mathbb{R}^n} \\left[ D(\\alpha) := -g^*(v) - \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i) \\right]. \\quad (3.3)$$\n\nWe will later see that, under the smoothness assumption of the $\\phi_i^*$ function, we can prove that the primal corresponding to this formulation has a strongly convex $g$ regularizer. We will also later see assumptions on the $\\ell_i^*$ that will give us either Lipschitz continuous or smooth $\\ell_i$ functions, thus fulfilling the conditions for applying ProxCoCoA+.\n3.1. Encoding Primal Problems in Dual Form\n\n3.1.1 The Corresponding Primal Form\n\nIn this section we will now work on deriving the primal form of (3.1). This formula is actually not entirely necessary to optimize on (3.1), as we are encoding and solving our models directly in a dual type of formulation and can be ignored in a purely implementative setting. However this form will come in handy to compute the duality gap, which allows us to have a certificate of how far we are from an optimal solution. This will also be useful as an analysis tool to as we will be able to reuse most of the results in the previous section to study the convergence rate of the duality gap which in turns gives us also a convergence rate for the dual problem only. In order to do this we need to be able to compute the conjugate of\n\n\\[ g^*(v) := \\sum_{j=1}^{d} \\phi^*_j(v_j). \\]\n\nTo get the primal form we need to find a \\( g \\), such that \\( g^* \\) is its convex conjugate. As it turns out this form is simply\n\n\\[ g(w) = \\sum_{j=1}^{d} \\phi_j(w_j). \\]\n\nWe can see this by applying the definition of convex conjugate for \\( g \\), exploiting the fact that the coordinate are, in this case, all independent from each other:\n\n\\[ g^*(v) = \\max_{w \\in \\mathbb{R}^d} [v^T w - g(w)] = \\max_{w \\in \\mathbb{R}^d} \\left( \\sum_{j=1}^{d} (v_jw_j - \\phi_j(w_j)) \\right) = \\]\n\n\\[ \\sum_{j=1}^{d} \\max_{w_j \\in \\mathbb{R}} (v_jw_j - \\phi_j(w_j)) = \\sum_{j=1}^{d} \\phi^*_j(v_j). \\]\n\nWe can now write the primal of \\( D(\\alpha) \\) as\n\n\\[ P(w) = g(w) + \\sum_{i=1}^{n} \\ell_i(w^T x_i). \\]\n\nFinally, we notice that, given the \\((1/\\tau)\\)-smoothness assumption on the \\( \\phi^*_j \\) functions, the \\( g \\) we have just derived is \\( \\tau \\)-strongly convex (from Proposition 2). Having derived its primal form, we can now trivially present an algorithm for optimizing equation (3.1) which simply works by reducing the problem to a ProxCoCoA+ solvable problem. Algorithm 7 precisely reflects what we have just seen in this section; the only additional point to notice is that Algorithm 7 takes as input an \\( A \\in \\mathbb{R}^{n \\times d} \\) matrix having the data examples as its columns – as it is generally more commonly the case in machine learning – and only then transpose it to get the actual matrix \\( A \\) that we have used when defining the problem.\n3.2 Convergence Analysis for $L$-Bounded Regularizers\n\n**Algorithm 7** PrimalCoCoA+ Algorithm for primal form (2.1)\n\n1. **Input:** Data matrix $\\hat{A} = [\\hat{y}_1, \\ldots, \\hat{y}_d] \\in \\mathbb{R}^{n \\times d}$; Regularizer $r^*(\\alpha) = \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i)$, loss functions $\\phi_i^*$. Aggregation parameter $\\gamma \\in (0, 1]$, subproblem parameter $\\sigma'$ for the local subproblems\n2. Compute matrix $A = \\hat{A}^T$\n3. Define function $g^*(v) := \\sum_{j=1}^{d} \\phi_j^*(v_j)$\n4. Run Algorithm 5 on matrix $A$, with $g := (g^*)^*$, $\\ell_i := (\\ell_i^*)^*$, aggregation parameter $\\gamma$ and subproblem parameter $\\sigma'$.\n5. **Output:** The $\\alpha$ vector as computed by Algorithm 5\n\n3.2 Convergence Analysis for $L$-Bounded Regularizers\n\nIn this section we will now analyze the convergence of Algorithm 7 on the previously defined problem\n\n$$\\max_{\\alpha \\in \\mathbb{R}^n} \\left[ D(\\alpha) := -\\sum_{j=1}^{d} \\phi_j^*(y_j^T \\alpha) - r^*(\\alpha) \\right]. \\quad (3.4)$$\n\nin the case of $r^*(\\alpha) := \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i)$ being such that the $\\ell_i^*$ functions are $L$-bounded.\n\n**Definition 9** ($L$-bounded function). A function $f : \\mathbb{R}^d \\to \\mathbb{R}$ is called $L$-bounded, if\n\n$$f(u) \\geq +\\infty \\quad \\forall u : \\|u\\|_2 \\geq L \\quad (3.5)$$\n\nAs previously mentioned, we will also work under the assumption that the the $\\phi_j^*$ functions are $(1/\\tau)$-smooth, so that $g$ is $\\tau$-strongly convex; also, by Proposition 3 we have that the convex conjugates the $\\ell_i$ functions are $L$-Lipschitz. This allows us to state Corollary 10.\n\n**Corollary 10.** Let $\\phi_j^*(\\cdot)$ be $(1/\\tau)$-smooth, $r^*(\\alpha) := \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i)$ with the $\\ell_i^*(\\cdot)$ functions being $L$-bounded. Let $\\gamma, \\sigma'$ be as in Assumption 1 and an arbitrary local solver satisfying Assumption 2 be given. Then, if $\\epsilon_G > 0$ is the desired duality gap, after $T$ iterations of Algorithm 7 with\n\n$$T \\geq T_0 + \\max\\left\\{ \\left[ \\frac{1}{\\gamma(1 - \\Theta)} \\right], \\frac{4L^2\\sigma'\\gamma}{\\tau\\epsilon_G \\gamma(1 - \\Theta)} \\right\\},$$\n\n$$T_0 \\geq t_0 + \\left( \\frac{2}{\\gamma(1 - \\Theta)} \\left( \\frac{8L^2\\sigma'}{\\tau\\epsilon_G} - 1 \\right) \\right),$$\n\n$$t_0 \\geq \\max\\left( 0, \\left[ \\frac{1}{\\gamma(1 - \\Theta)} \\log\\left( \\frac{2(\\mathcal{D}(\\alpha^*) - \\mathcal{D}(\\alpha(0)))}{4L^2\\sigma'} \\right) \\right] \\right),$$\n\nthe expected duality gap will satisfy\n\n$$\\mathbb{E}[\\mathcal{P}(w(\\bar{x})) - \\mathcal{D}(\\bar{x})] \\leq \\epsilon_G,$$\nat the averaged iterate\n\n\\[\n\\overline{\\alpha} := \\frac{1}{T-T_0} \\sum_{t=T_0+1}^{T-1} \\alpha(t).\n\\] \n\n(3.7)\n\nSimilarly to the previous chapter, and in order to compare this result to the result from other works \\([10, 11]\\) we are now also interested in looking at the convergence rate for the case in which the optimization problem takes the following more common form:\n\n\\[\n\\max_{\\alpha \\in \\mathbb{R}^n} \\left[ D(\\alpha) := -\\frac{1}{d} \\sum_{j=1}^{d} \\phi_j^*(y_j^T \\alpha) - \\lambda r^*(\\alpha) \\right].\n\\] \n\n(3.8)\n\nwith \\(\\lambda > 0\\), \\(\\phi_j^*(\\cdot)\\) being \\((1/\\tau')\\)-smooth and \\(r^*(\\alpha) := \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i)\\) being such that the \\(\\ell_i^*(-\\cdot)\\) functions are \\(L'\\)-bounded. Very easily we can now see that by defining \\(\\phi_j^* = \\frac{1}{d} \\phi_j'\\) and \\(\\ell_i^* = \\lambda \\ell_i'\\) (with \\(r^*(\\alpha) := \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i)\\)) we can reduce our problem to (3.4). This also gives us that \\(\\phi_j^*\\) are now \\((1/(d\\tau'))\\)-smooth while the \\(\\ell_i^*\\) clearly stay \\(L'\\)-bounded; we can therefore finally state Corollary 11.\n\n**Corollary 11.** Let \\(\\phi_j^*\\) be \\((1/\\tau')\\)-smooth, \\(r^*(\\alpha) := \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i)\\) with the \\(\\ell_i^*(-\\cdot)\\) functions being \\(L'\\)-bounded. Let \\(\\gamma, \\sigma'\\) be as in Assumption 1 and an arbitrary local solver satisfying Assumption 2 be given. Then, if \\(\\epsilon_G > 0\\) is the desired duality gap, after \\(T\\) iterations of Algorithm 7 with\n\n\\[\nT \\geq T_0 + \\max\\left\\{ \\frac{1}{\\gamma(1-\\Theta)}, \\frac{4L'^2 \\sigma' \\gamma(1-\\Theta)}{d \\epsilon_G} \\right\\},\n\\] \n\n(3.9)\n\n\\[\nT_0 \\geq t_0 + \\frac{2}{\\gamma(1-\\Theta)} \\left( \\frac{8L'^2 \\sigma' \\gamma(1-\\Theta)}{d \\epsilon_G} - 1 \\right),\n\\] \n\n\\[\nt_0 \\geq \\max(0, \\left[ \\frac{1}{\\gamma(1-\\Theta)} \\log \\left( \\frac{2d(\\epsilon_G - D(\\alpha^*))}{4L'^2 \\sigma'} \\right) \\right]),\n\\] \n\nthe expected duality gap will satisfy\n\n\\[\n\\mathbb{E} [P(w(\\overline{\\alpha})) - D(\\overline{\\alpha})] \\leq \\epsilon_G,\n\\]\n\nat the averaged iterate\n\n\\[\n\\overline{\\alpha} := \\frac{1}{T-T_0} \\sum_{t=T_0+1}^{T-1} \\alpha(t).\n\\] \n\n(3.10)\n\n### 3.3 Convergence Analysis for Strongly Convex Regularizers\n\nIn this section we will instead analyze the convergence of Algorithm 7 in the case of strongly convex regularizers; in order to do so, we will apply\n3.3. Convergence Analysis for Strongly Convex Regularizers\n\nthe convergence analysis for smooth losses developed in the previous chapter.\nMore formally we will assume a model such as (3.4) but with $\\mu$-strongly convex $\\ell_i^*$ functions. This gives us, from Proposition 2, that the $\\ell_i$ functions are $(1/\\mu)$ smooth. We can thus easily state Corollary 12.\n\n**Corollary 12.** Let $\\phi_j^*(\\cdot)$ be $(1/\\tau)$-smooth, $r^*(\\alpha) := \\sum_{i=1}^{n} \\ell_i^*(-\\alpha_i)$ with the $\\ell_i^*(\\cdot)$ functions being $\\mu$-strongly convex. Let $\\gamma, \\sigma$ be defined as in Assumption 1 and define $\\sigma_{\\text{max}} = \\max_{k \\in [K]} \\sigma_k$. Then, if $\\epsilon_D > 0$ is the desired maximum dual suboptimality, after $T$ iterations of Algorithm 7 with\n\n$$ T \\geq \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\mu \\tau + \\sigma_{\\text{max}}}{\\mu^2} \\log \\frac{1}{\\epsilon_D}, $$\n\nit holds that\n\n$$ \\mathbb{E}[D(\\alpha^*) - D(\\alpha^{(T)})] \\leq \\epsilon_D. $$\n\nFurthermore, given the desired duality gap $\\epsilon_G$, after $T$ iterations with\n\n$$ T \\geq \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\mu \\tau + \\sigma_{\\text{max}}}{\\mu^2} \\log \\left( \\frac{1}{\\gamma(1-\\Theta)} \\frac{1}{\\epsilon_D} \\right), $$\n\nthe expected duality gap is such that\n\n$$ \\mathbb{E}[P(w(\\alpha^{(T)}) - D(\\alpha^{(T)})] \\leq \\epsilon_G. $$\n\nAs done for the $L$-bounded case, we will also look at the averaged loss case as in equation (3.8) but under the $\\mu'$-strong convexity assumption of the $\\ell_i^*$ functions; as in the previous section we thus define $\\ell_i^* = \\lambda \\ell_i^*$ getting that the $\\ell_i^*$ are now $\\lambda \\mu'$-strongly convex.\n\n**Corollary 13.** Let $\\phi_j^*(\\cdot)$ be $(1/\\tau')$-smooth, $r''^*(\\alpha) := \\sum_{i=1}^{n} \\ell_i''^*(-\\alpha_i)$ with the $\\ell_i''^*(\\cdot)$ functions being $\\mu'$-strongly convex. Let $\\gamma, \\sigma'$ be defined as in Assumption 1 and define $\\sigma_{\\text{max}} = \\max_{k \\in [K]} \\sigma_k$. Then, if $\\epsilon_D > 0$ is the desired maximum dual suboptimality, after $T$ iterations of Algorithm 7 with\n\n$$ T \\geq \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\lambda \\mu' \\tau' + \\sigma_{\\text{max}}}{\\lambda \\mu'^2} \\log \\frac{1}{\\epsilon_D}, $$\n\nit holds that\n\n$$ \\mathbb{E}[D(\\alpha^*) - D(\\alpha^{(T)})] \\leq \\epsilon_D. $$\n\nFurthermore, given the desired duality gap $\\epsilon_G$, after $T$ iterations with\n\n$$ T \\geq \\frac{1}{\\gamma(1-\\Theta)} \\frac{\\lambda \\mu' \\tau' + \\sigma_{\\text{max}}}{\\lambda \\mu'^2} \\log \\left( \\frac{1}{\\gamma(1-\\Theta)} \\frac{1}{\\epsilon_D} \\right), $$\n\nthe expected duality gap is such that\n\n$$ \\mathbb{E}[P(w(\\alpha^{(T)}) - D(\\alpha^{(T)})] \\leq \\epsilon_G. $$\n\n3.4 Applications\n\n3.4.1 $L_1$ regularization\n\nIn order to achieve $L_1$ regularization, we’ll simply have to define the $\\ell_i^*$ functions as\n\n$$\\ell_i^*(\\alpha_i) = |\\alpha_i|$$\n\nwhere this gets us the dual problem\n\n$$\\max_{\\alpha \\in \\mathbb{R}^n} \\left[ D(\\alpha) := -\\frac{1}{d} \\sum_{j=1}^{d} \\phi_j(y_j^T \\alpha) - \\lambda \\|\\alpha\\|_1 \\right] \\quad (3.11)$$\n\nwhich should be easy to recognize as a typical $L_1$-RLM problem. The function $\\ell_i$ that has $|\\cdot|$ as its conjugate is the indicator of the unit interval\n\n$$\\ell_i(x) := \\begin{cases} 0 &: x \\in [-1, 1] \\\\ +\\infty &: \\text{otherwise} \\end{cases} \\quad (3.12)$$\n\nAs this $\\ell$ function (we will drop the $i$ index from now on) is neither Lipschitz continuous nor smooth, it won’t be possible to immediately apply the convergence results proved in the previous chapter. A possible solution to this problem is to add a small $L_2$ regularization term to the $L_1$ term as done in [11], thus using elastic net to approximate $L_1$ regularization; this approach has however the drawback of destroying the sparsity property of the norm.\n\nThe alternative approach that we take here is to replace the $L_1$ function with an $L$-bounded surrogate, which preserves an almost identical solution space as the original problem and preserves the sparsity property. More specifically, we will modify the function $|\\cdot|$ by imposing an additional constraint, which is only active outside the region of interest. Formally, we replace $\\ell^*(\\cdot) = |\\cdot|$ with\n\n$$\\bar{\\ell}^*(\\alpha) := \\begin{cases} |\\alpha| &: \\alpha \\in [-B, B] \\\\ +\\infty &: \\text{otherwise} \\end{cases}$$\n\nLemma 14. The convex conjugate of $\\bar{\\ell}_i^*$ as defined above is\n\n$$\\bar{\\ell}(x) = \\begin{cases} 0 &: x \\in [-1, 1] \\\\ B(|x| - 1) &: \\text{otherwise} \\end{cases}$$\n\nand is $B$-Lipschitz.\n\nWith this modified $L_1$-regularizer, the optimization problem becomes\n\n$$\\max_{\\alpha \\in \\mathbb{R}^n} \\frac{1}{d} \\sum_{i=1}^{n} \\bar{\\ell}^*(\\alpha_i) - \\lambda g^*(\\nu(\\alpha)) \\quad (3.13)$$\n\nIt is not hard to see that for a large enough choice of the value $B$, this problems yields the same solution as the original Lasso objective. An easy way to derive\n3.4. Applications\n\na big enough value for $B$ is as follows. We first of all notice that, since we start the algorithm with $\\alpha = 0$, if we use a monotonic optimization algorithm - e.g. SDCA, then all the $\\alpha$ iterates encountered during the execution of the algorithm will never have an objective value worse than $D(0)$. Formally, this means that for every $i$:\n\n$$\\frac{|\\alpha_i|}{d} \\leq D(0) = \\lambda g^*(0) \\implies |\\alpha_i| \\leq d\\lambda g^*(0)$$\n\nand this $d\\lambda g^*(0)$ can be used as a safe value for $B$; this value will be safe in the sense that the modified problem will be guaranteed to have the same optimal solution(s) as the original problem\n\nIt is worth noticing that this trick only affects the convergence theory, in that it allows us to present a strong primal-dual theory for Lasso and other $\\ell_1$-regularized problems. This modification of $\\ell_i$, however, does not affect the algorithms for the original problems whenever a monotone optimizer is used, as we will never encounter solutions that violate the $B$ constraint; we can therefore run the algorithm on the original unmodified problem.\n\nTo finally get a primal dual convergence rate for $\\ell_1$ regularized models we can simply apply Corollary 11 with $L'$ equal to $d\\lambda g^*(0)$.\n\n3.4.2 Elastic Net\n\nThe same approach used for $\\ell_1$ regularization can also be applied to Elastic Net regularized models. The approach is very similar and simply requires us to define $\\ell_i^\\ast$ functions\n\n$$\\ell_i^\\ast(\\alpha_i) = \\frac{\\eta}{2} \\alpha_i^2 + (1 - \\eta) |\\alpha_i|$$\n\nthat will act as per-coordinate regularizers.\n\n**Lemma’ 8.** For $\\eta \\in (0, 1]$, the convex conjugate of the elastic net function\n\n$$f(\\alpha) := \\frac{\\eta}{2} \\alpha^2 + (1 - \\eta) |\\alpha|$$\n\nis\n\n$$f^*(x) := \\frac{1}{2\\eta} \\left( \\left[ |x| - (1 - \\eta) \\right]_+ \\right)^2,$$\n\nwhere $[.]_+$ is the positive part operator, $[s]_+ = s$ for $s > 0$, and zero otherwise. Also, the conjugate $f^{**}$ of $f^*$ is equal to $f$.\n\nHere, in contrast to the $L_1$ case above, we have that since the Elastic Net function is $\\eta$-strongly convex we don’t need to go through defining an $L$-bounded surrogate; all we need to do is obtain a convergence rate result is applying Corollary 13 with the strong convexity parameter $\\mu'$ of the $\\ell_i^\\ast$ functions equal to $\\eta$.\n\n\\footnote{Uniqueness of solution does not necessarily hold.}\n3.5 Related Work\n\nIn this section we will briefly look at some of the existing work related to the PrimalCoCoA+ algorithm when applied to $L_1$ regularization as Section 3.4.1. The recent approach of [15] for sparse logistic regression is closely related to our method. Inspired by glmnet and [17], [15] they use a block-diagonal Hessian upper approximation. On the theory side, its analysis [15, 17] is not an explicit convergence rate but only asymptotic, as the quadratic upper bounds are not explicitly controlled for safety as with our $\\sigma'$. [15, 17] assume the quadratic subproblems to be solved exactly. In contrast, we do allow arbitrary weak accuracy $\\Theta$ of the local solver, allowing trade-off between communication and computation.\n\nShotgun (parallel stochastic coordinate descent, for the case of $L_1$-regularizers) was proposed in [3], and is among the state-of-the-art solvers in the parallel setting. Our framework reduces to shotgun as a special case when the internal solver is one single coordinate update on the subproblem (2.5), $\\gamma = 1$, and a suitable $\\sigma'$. However, shotgun is not covered by our convergence theory, since it uses a potentially unsafe upper bound $\\beta$ instead of $\\sigma'$, not necessarily satisfying condition (2.6).\n\nParallel coordinate descent on the $L_1$-primal objective directly has recently been analyzed in [6, 13], but not in the communication-efficient setting.\nIn this chapter we will now finally look at how the methods developed and analyzed in the previous chapters actually perform in practice. In particular we will be looking at the problem of Logistic Regression with Elastic Net regularization (included the case in which it degenerates to $L_1$ regularization) and compare several different approaches on different regularization parameters. Formally, given $n$ datapoints $x_i$ we will therefore be solving a logistic regression classification problem with target labels $y_i$, by means of optimizing the following function:\n\n$$\\min_{w \\in \\mathbb{R}^d} \\left[ P(w) := \\lambda g(w) + \\frac{1}{n} \\sum_{i=1}^{n} \\ell_i(x_i^T w) \\right].$$\n\n(4.1)\n\nwhere the loss functions are defined as\n\n$$\\ell_i(x_i^T w) = \\log (1 + y_ix_i^T w)$$\n\nand the regularizer $g$ is defined as\n\n$$g(w) = \\eta \\|w\\|_2^2 + (1 - \\eta)\\|w\\|_1.$$ \n\nWe will also assume that our data are distributed on $K$ partitions.\n\n### 4.1 Experimental Infrastructure\n\nThe experimental infrastructure will be based on the MapReduce computational model, with all implementations written in Spark. We will therefore assume that we have $M$ machines each having $C$ cores each, thus giving us a total of $K := M \\cdot C$ partitions. More precisely all experiments have been carried out in an Amazon EC2 cluster composed of 1 master and 8 worker machines of type $m3.2xlarge$, all of which having 8 cores and 30GB of main memory each.\n4.2 Datasets\n\nAll the experiments will be run on the following classification datasets:\n\n- **RCV1**[9]: The RCV1 classification dataset is a text classification datasets obtained by preprocessing the RCV1 category annotated collection of news articles. The number of datapoints is 677,399 with a total number of 47,236 features. The sparsity of this dataset is 0.16%.\n\n- **webspam**[16]: The webspam dataset is a binary classification dataset where every data point is constructed by taking trigrams of a document and it has a spam/non-spam label. It contains a total of 350,000 datapoints and 16,609,143 features, of which only 680,715 are nonzero. This dataset is much sparser than the previous one, with a sparsity of 0.02%.\n\n4.3 Compared Algorithms\n\nBefore showing any results, we will now list the methods we will be comparing, quickly reiterating on some of the methods we presented in previous sections and presenting some new ones.\n\n4.3.1 Proximal CoCoA+ (ProxCoCoA+)\n\nBy ProxCoCoA+ in experiments we will refer to Algorithm 5 with data \\( x_i \\) distributed column-wise over the \\( K \\) partitions. The number of partitions \\( K \\) will be \\( M \\cdot C \\), where \\( M \\) is the number of machines and \\( C \\) is the number of cores per machine; more precisely, in our case will therefore be equal to 64. It is important to notice here that this method will only be applicable to the Elastic Net regularized linear model with \\( \\eta > 0 \\), since strong convexity is required for the method to work. The additive version of the algorithm will be used by setting \\( \\gamma = 1 \\); the \\( \\sigma' \\) value will instead be set to the corresponding safe value \\( K \\) as it can be derived from (2.8). Depending on the actual \\( \\sigma'_{\\text{min}} \\) value, \\( \\sigma' \\) could be set to bigger values, thus yielding better performances; this is often especially true on very sparse datasets. More aggressive choice will however not be explored, as it goes beyond the scope of this work.\n\nAs a local solver we will use a variant of the SDCA local solver presented as Algorithm 6; the algorithm will differ in that the data points will be sampled without replacement i.e. the algorithm iterates on the data points following a random permutation of the data matrix columns \\( [x_1, \\ldots, x_n] \\) and does exactly one pass over the data.\n\n4.3.2 Primal Proximal CoCoA+ (PrimalCoCoA+)\n\nThis refers to Algorithm 7 with local solver and parameters \\( \\gamma \\) and \\( \\sigma' \\) as in Section 4.3.1. The partitioning scheme will also be the same as in Section 4.3.1.\n4.3. Compared Algorithms\n\nThe problem we will be looking at will therefore be \\(-D(\\alpha)\\) with \\(D\\) defined as\n\n\\[\n\\max_{\\alpha \\in \\mathbb{R}^n} \\left[ D(\\alpha) := -\\frac{1}{n} \\sum_{j=1}^{d} \\phi_j^*(y_j^T \\alpha) - \\lambda r^*(\\alpha) \\right] \\tag{4.2}\n\\]\n\nwith\n\n\\[\n\\phi_j^*(x_j^T \\alpha) = \\log (1 + y_j x_j^T \\alpha)\n\\]\n\nand\n\n\\[\nr^*(\\alpha) = \\eta \\|\\alpha\\|^2_2 + (1 - \\eta)\\|\\alpha\\|_1\n\\]\n\nwhich is clearly equivalent to the primal formulation (4.1). It is however crucial to understand how this precisely relates to Algorithm 7, by noticing that the \\(\\hat{A}\\) matrix will in this case be equal to \\(A\\) (as defined in this section) and thus in \\(\\mathbb{R}^{d \\times n}\\) (and not in \\(\\mathbb{R}^{n \\times d}\\)) hence also why there is a \\(\\frac{1}{n}\\) term (instead of \\(\\frac{1}{d}\\)). The time required by Algorithm 7 to transpose matrix \\(A\\) will not be accounted in the running time of the algorithm. It is worth noting that this transposition could be avoided by storing the data directly in a row-wise format.\n\n### 4.3.3 Orthant-Wise Limited-Memory Quasi-Newton Optimizer (OWLQN)\n\nThe Orthant-Wise Limited-memory Quasi-Newton Optimizer [1] is a Quasi-Newton method based on the L-BFGS method for training of L1-regularized models. As other descent based methods, when minimizing a function \\(f(w)\\), OWLQN will compute a sequence of solution vectors \\(w(t)\\) as\n\n\\[\nw^{(t+1)} = w^{(t)} - \\gamma [Hf(w^{(t)})]^{-1}\\nabla f(w^{(t)})\n\\]\n\nwhere \\(Hf(w^{(t)})\\) is an approximation of the true Hessian matrix of \\(f\\) at \\(w^{(t)}\\). As for other Quasi-Newton methods this approximation will be computed by only using first order information as given by the history of the last \\(m\\) gradient evaluations. Furthermore \\(Hf(w^{(t)})\\) won’t be computed explicitly - as its size is quadratic in the size of the \\(w\\) vector, but a search direction will rather be implicitly computed. The step size \\(\\gamma\\) will then be chosen though a line search method.\n\nThus, given a problem like (4.1) the distribution of the algorithm will happen by simply computing this gradient in a distributed fashion as in Algorithm 3 (both for the gradient computation and for the line search); the computation of the search direction using the gradient history will instead happen entirely on the master. The algorithm thus strongly resembles the Batch Gradient Descent algorithm except that the search direction will be found using a smarter strategy.\n\n### 4.3.4 Wild ProxCoCoA+ and PrimalCoCoA+\n\nIn section 4.3.1 we saw a set up for the ProxCoCoA+ method where we used \\(K = M \\cdot C\\), i.e. every machine has 1 partition per each core. However, as\n4.3. Compared Algorithms\n\nthe number of partitions increases the number of iterations required by the ProxCoCoA+ method tends to increase and it is thus sensible to try to keep the number of partitions to the smallest possible number, that is, the number of machines in the cluster $M$. A better approach could therefore be to only have one partition per machine, thus $K = M$, and then use a parallel local solver in order to solve the local subproblem defined on the partition, thus exploiting all the $C$ cores available on the machine. The main difference with what we did in section 4.3.1 is therefore that we now have that the $C$ threads on every machine are working together to solve the same subproblem more efficiently, instead of each of them solving a different subproblem independently. By using a parallel SDCA method, this results in a cost per iteration identical to the setup from section 4.3.1 but with $K = M$ as opposed to $K = M \\cdot C$ and thus possibly with a faster convergence.\n\nPASSCoDe\n\nThe PASSCoDe wild algorithm, presented in [7] is a simple SDCA parallel variant. The algorithm assumes a machine with $C$ cores, all having access to a shared main memory where the $A = [x_1, \\ldots, x_n]$ data matrix is stored and accessible to every thread in its entirety. In the case of a model such as (4.1) with $L_2$ regularization, every thread of execution will have access to all the $x_i$ data points and will simply execute a procedure identical to Algorithm 4 on them; the only difference will be that the $w$ vector will be unique and shared between the $C$ threads. Different synchronization rules for updating the shared $w$ are presented in [7], but we will only explore an adaptation of the Wild variant, in which no synchronization happens between threads. This means that dirty and lost updates are possible and that the $w = A\\alpha$ relation will hold only approximately.\n\nWild Local Solver\n\nIn this section we now present Algorithm 8, a parallel local solver based on the PASSCoDe algorithm. This algorithm, though very similar, has two main differences from the original PASSCoDe algorithm:\n\n- Each thread $c \\in \\{1, \\ldots, C\\}$ won’t have access to the entire partition data matrix $A_{[k]}$, but only to a subpartition $A_{[k][c]}$ of partition $A_{[k]}$; we will also refer with $P_{k,c} \\in P_k$ to the subpartition indices. This modification is necessary to better fit the Spark computational model and, though formally different from the original PASSCoDe we’ll see from the experiments that is still works quite well in practice. The algorithm still retains the original ”wild” nature since the weight vector $w$ is shared among the threads.\n\n- Although the PASSCoDe algorithm as presented in [7], only supported $L_2$ regularization, we will nonetheless apply to our more general strongly\n4.3. Compared Algorithms\n\nThe convex regularizer setting. Experiments seem to confirm that the algorithm should support this setting too.\n\nAs the number of partitions $K$ can now be assumed to be $M$, a safe choice when $\\gamma = 1$, will be $\\sigma' = M$ – as given by (2.8) – instead of $\\sigma' = C \\cdot M$.\n\nLater in the experiments, we will refer to the ProxCoCoA+ method using the wild local solver (and with $\\sigma' = M$ and $\\gamma = 1$) as the ProxCoCoA+Wild algorithm. Also, when the ProxCoCoA+Wild is used in Algorithm 7, we will refer to the resulting algorithm as PrimalCoCoA+Wild.\n\nAlgorithm 8 Wild SDCA Local Solver\n\n1: Input: Loss functions $\\ell_i$, data matrix $A[k]$, $\\sigma' > 0$, $v \\in \\mathbb{R}^d$, $\\alpha[k] \\in \\mathbb{R}^{nk}$\n2: $w^{(0)} = \\nabla g^*(v)$\n3: $\\alpha[k] := \\alpha[k]$\n4: for each thread $c \\in \\{1, \\ldots, C\\}$ in parallel do\n5: Pick a random permutation $R_{k,c}$ of the subpartition indices $P_{k,c}$.\n6: for $i \\in R_{k,c}$ do\n7: $\\Delta \\alpha = \\arg \\max \\Delta \\alpha - \\ell_i^*(\\alpha_i - \\Delta \\alpha) - \\Delta \\alpha x_i^T w^{(t-1)} - \\frac{\\sigma'}{\\tau} \\Delta \\alpha^2 \\|x_i\\|^2$\n8: $\\alpha^{(t)} = \\alpha^{(t-1)} + \\Delta \\alpha x_i$\n9: $w^{(t)} = w^{(t-1)} + \\sigma' \\Delta \\alpha x_i$\n10: end for\n11: end for\n12: return $\\Delta \\alpha[k] := \\alpha^{(n)}[k] - \\alpha[k]$\n\nImplementation Details\n\nAs seen in the previous section, we are assuming that our data are partitioned into $M$ partitions and each of this partitions has $C$ subpartitions each. The reason for this choice is due to some limitations of the Spark model. The algorithm was in fact implemented by partitioning the RDD containing the data points into $C \\cdot M$ partitions and each machine was assigned by Spark exactly $C$ of this partitions and one Spark task was run for each of this partitions; this $C$ partitions are what we called subpartitions in the previous section. In order for this partitions to share a common $w$ weight vector, we then used the broadcast construct to broadcast the weight vector to each machine; the semantics of this operation will therefore make sure that only one copy of the vector is present per machine. All tasks will then write on this same vector concurrently. It is important to mention that, although the Spark computational model is based on immutability and tasks are not supposed to modify the content of broadcasted data, this is however possible when mutable data e.g. a standard java array are broadcast. We warn that this is not the intended usage of the broadcast construct and could be considered a hack and\nthe Spark fault-tolerance guarantees might not hold as strongly anymore as a result. This however works very well in practice and will serve us well at least as a proof-of-concept implementation.\n\n4.4 Experiments\n\nWe can now finally look at the results we achieved in our experiments on logistic regression problems for elastic net and l1 regularization. All the results will be presented in graphs having time in seconds on the x-axis and primal suboptimality on the y-axis; this will be computed as the difference between the current objective value and an approximation of the optimal one. This approximation is obtained as the minimum objective value found by any of the methods.\n\n4.4.1 Elastic Net Regularization\n\nIn this section we will now look at a comparison of several methods on an Elastic Net regularized logistic regression problem with $\\eta = \\frac{1}{2}$. From experiments on both webspam and rcv1 and for both $\\lambda = 10^{-4}$ and $\\lambda = 10^{-6}$ (Figure 4.1, 4.2, 4.3 and 4.4) we can immediately see that the two clear winners are the proxCoCoA+ – along with its wild variant – and the OWLQN algorithm. The performances of primalCoCoA+ are instead sharply inferior to the other two methods. A superior performance of proxCoCoA+ method can also be observed when using bigger values of $\\lambda$ and it is expected behavior and consistent with the convergence rate formula.\n\nWorth noticing is also the contribution of the wild modification to the performance of the proxCoCoA+Wild and primalCoCoA+Wild algorithms. Especially in the latter case, we can see that the wild approach makes the algorithm substantially better for both values of $\\lambda$. In the case of proxCoCoA+, however, even though a speed-up is still provided by the algorithm during the initial rounds, the objective value experiences an oscillating behavior once it reaches a high enough accuracy; this behavior seems consistent with the convergence result from [7] for PASSCoDe-Wild, which states that the algorithm does not converge to the actual solution of the optimization problem but to a solution with a perturbed regularizer.\n\nComparing the experiments on the two different datasets, we can also notice that ProxCoCoA+ performs much better than OWLQN on webspam while being almost on par on the rcv1 dataset; we believe this can be attributed to the higher sparsity of the webspam dataset which would tend to favor an SDCA approach.\n4.4.2 $L_1$ Regularization\n\nIn this section we look instead at $L_1$ regularized logistic regression; as previously indicated, we will not use algorithm ProxCoCoA+ and its wild variant on this problem as the $L_1$ norm is not a strongly convex function.\n\nAs opposed to the previous section, in this case we observe a very sharp difference between the webspam and the rcv1 experiments. In fact, from the experiments in Figure 4.7 and 4.8 on rcv1, we see a much better performance of the OWLQN algorithm both against PrimalCoCoA+ and PrimalCoCoA+Wild; the picture looks however very different when the algorithm is run on the webspam datasets (Figure 4.5 and Figure 4.6) where can see that PrimalCoCoA+ Wild appears to be substantially faster than OWLQN in the initial phases though still being outperformed by OWLQN in the long run; this means that PrimalCoCoA+ Wild could therefore still be a better choice than OWLQN in scenarios where very high accuracy is not required and thus especially in machine learning, where it’s known that very high training accuracy is often not required for a good test accuracy.\n4.4. Experiments\n\nFigure 4.1: webspam - $\\lambda = 1.0E - 4, \\eta = 0.5$\n\nFigure 4.2: webspam - $\\lambda = 1.0E - 6, \\eta = 0.5$\n4.4. Experiments\n\nFigure 4.3: $\\text{rcv1} - \\lambda = 1.0E - 4, \\eta = 0.5$\n\nFigure 4.4: $\\text{rcv1} - \\lambda = 1.0E - 6, \\eta = 0.5$\n4.4. Experiments\n\nFigure 4.5: webspam - $\\lambda = 1.0 \\times 10^{-4}, \\eta = 0.0$\n\nFigure 4.6: webspam - $\\lambda = 1.0 \\times 10^{-6}, \\eta = 0.0$\n4.4. Experiments\n\nFigure 4.7: rcv1 - $\\lambda = 1.0 \\times 10^{-4}$, $\\eta = 0.0$\n\nFigure 4.8: rcv1 - $\\lambda = 1.0 \\times 10^{-6}$, $\\eta = 0.0$\nChapter 5\n\nConclusion\n\nIn this work we developed primal-dual algorithms for regularized loss minimization in a distributed setting. We started by presenting ProxCoCoA+, a generalization of the CoCoA+ [10] algorithm that is able to handle general strongly convex regularizers and we saw convergence results analogous to the one presented in [10], both for the case of smooth and Lipschitz continuous losses. This allowed us to apply the ProxCoCoA+ method to elastic net regularized problems; in particular we saw experiments for the logistic regression loss, on which the method proved to be very effective and competitive with the OWLQN algorithm. We then showed how the ProxCoCoA+ method is able to handle non-strongly convex regularizers, by means of reversing the role of primal and dual problems; this resulted in the PrimalCoCoA+ method, a method capable of solving RLM-problems directly using their primal formulation and represents a major contribution of this work. This method allows us to obtain primal-dual convergence rates for $L_1$ regularized problems and this result is, to the best of our knowledge, the first of its kind. Experiments on $L_1$ regularized logistic regression showed that this method is competitive, in certain settings, with the more complex OWLQN algorithm. We finally saw an experimental study for a new parallel SDCA local solver, based on PASSCoDe-Wild [7], which allows the ProxCoCoA+ and PrimalCoCoA+ method to exploit the benefits of parallel computation between threads running on the same machine and gave very promising results.\n\n5.1 Future Work\n\nThis work opens some possible lines of future research:\n\n- The PrimalCoCoA+ method we developed, because of its reduction-based nature, only handles separable regularizers. It would be worth investigating whether a more general method could be developed capable of handling non-separable regularizers.\n5.1. Future Work\n\n- The Wild SDCA local solver presented in the experiments’ section, though based on the PASSCoDe Wild algorithm, was applied to the more general strongly convex regularizer setting and it proved successful. However, in [7] we only see a proof of convergence of the algorithm on $L_2$ regularized problems; studying its behavior, from a theoretical standpoint, on this more general setting would thus be important to investigate.\nChapter 6\n\nInternship At Amazon\n\nAs part of my thesis, I also worked in the Amazon Development Center in Berlin from June 1, 2015 to August 15, 2015.\nThe work produced during my internship there is currently not included in this document.\nAppendix A\n\nAppendix\n\n**Definition 15** ($\\mu$-strong convexity). A function $g : \\mathbb{R}^d \\to \\mathbb{R}$ is called $\\mu$-strongly convex, for $\\mu \\geq 0$, if\n\n$$g(u) \\geq g(w) + \\langle \\nabla g(w), u - w \\rangle + \\frac{\\mu}{2} \\|u - w\\|^2 \\quad \\forall u, w \\in \\mathbb{R}^d.$$ \\hspace{1cm} (A.1)\n\n**Definition 16** ($L$-Lipschitz continuity). A function $f : \\mathbb{R}^d \\to \\mathbb{R}$ is called $L$-Lipschitz continuous, if\n\n$$|f(u) - f(v)| \\leq L \\|u - v\\|_2 \\quad \\forall u, v \\in \\mathbb{R}^d$$ \\hspace{1cm} (A.2)\n\n**Definition 17** ($(1/\\mu)$-smoothness). A function $f : \\mathbb{R}^d \\to \\mathbb{R}$ is called $(1/\\mu)$-smooth if its differentiable and its gradient is $(1/\\mu)$-Lipschitz continuous. An equivalent condition for smoothness (from [11]) is that:\n\n$$f(u) \\leq f(v) + \\nabla f(v)^T (u - v) + \\frac{1}{2\\mu} \\|u - v\\|^2_2 \\quad \\forall u, v \\in \\mathbb{R}^d$$\n\n**Proposition 1** (Fenchel–Young inequality). Given a function $f : \\mathbb{R}^d \\to \\mathbb{R}$ and its convex conjugate $f^* : \\mathbb{R}^d \\to \\mathbb{R}$ it holds that\n\n$$x^T y \\leq f(x) + f^*(y) \\quad \\forall x, y \\in \\mathbb{R}^d$$\n\n**Proposition 2.** The conjugate $f^*$ of a $(1/\\mu)$-smooth $f$ function for $\\mu > 0$ is $\\mu$-strongly convex, and vice versa, the conjugate $f^*$ of a $\\mu$-strongly convex $f$ function for $\\mu > 0$ is $(1/\\mu)$-smooth. [11]\n\n**Proposition 3.** The conjugate $f^* : \\mathbb{R} \\to \\mathbb{R}$ of an $L$-bounded function $f : \\mathbb{R} \\to \\mathbb{R}$ function is $L$-Lipschitz.\n\n**Proof.** In order to prove $L$-Lipschitzness we need to upper bound the following term; we start by applying the definition of convex conjugate and noticing that\nA.1. Convergence Analysis\n\n$x$ needs to be in $[-L, L]$ as it is $+\\infty$ outside of this interval:\n\n$$|f^*(u) - f^*(v)| = \\left| \\sup_{|x| \\leq L} [ux - f(x)] - f^*(v) \\right|$$\n\n$$= \\left| \\sup_{|x| \\leq L} [ux - f(x) - f^*(v)] \\right|$$\n\n(Fenchel–Young inequality)\n\n$$\\leq \\left| \\sup_{|x| \\leq L} [ux] \\right| = \\left| \\sup_{|x| \\leq L} (u - v) x \\right| \\leq L|u - v|.$$\n\n\\[\\square\\]\n\nA.1 Convergence Analysis\n\nA.1.1 Proof of Lemma 2\n\nLemma’ 2. Given $\\alpha, \\Delta \\alpha \\in \\mathbb{R}^n$, $v = v(\\alpha)$ and real values $\\gamma, \\sigma'$ as in Assumption 1, it holds that\n\n$$\\mathcal{D}(\\alpha + \\gamma \\sum_{k=1}^{K} \\Delta \\alpha_{[k]}) \\geq (1 - \\gamma)\\mathcal{D}(\\alpha) + \\gamma \\sum_{k=1}^{K} g_k^{\\sigma'}(\\Delta \\alpha_{[k]}; v, \\alpha_{[k]}), \\quad (A.3)$$\n\nIn this proof we follow the line of reasoning in [10, Lemma 4]. By the definition of $\\mathcal{D}$ we have:\n\n$$\\mathcal{D}(\\alpha + \\gamma \\sum_{k=1}^{K} \\Delta \\alpha_{[k]}) = \\begin{aligned} A \\quad A &= - \\sum_{i=1}^{n} \\ell^*_i(-\\alpha_i - \\gamma(\\sum_{k=1}^{K} \\Delta \\alpha_{[k]_i})) - g^*(v(\\alpha + \\gamma \\sum_{k=1}^{K} \\Delta \\alpha_{[k]}))) \\\\ & \\quad B \\quad B \\geq - \\sum_{k=1}^{K} \\left( \\sum_{i \\in \\mathcal{P}_k} \\ell^*_i(-\\alpha_i) + \\gamma \\ell^*_i(-(\\alpha + \\Delta \\alpha_{[k]})_i) \\right) \\end{aligned} \\quad (A.4)$$\n\nWe will now bound terms $A$ and $B$.\n\n$$A = - \\sum_{k=1}^{K} \\left( \\sum_{i \\in \\mathcal{P}_k} \\ell^*_i(-\\alpha_i - \\gamma(\\Delta \\alpha_{[k]_i})) \\right)$$\n\n$$= - \\sum_{k=1}^{K} \\left( \\sum_{i \\in \\mathcal{P}_k} \\ell^*_i(-(1 - \\gamma)\\alpha_i - \\gamma(\\alpha + \\Delta \\alpha_{[k]_i})) \\right)$$\n\n$$\\geq - \\sum_{k=1}^{K} \\left( \\sum_{i \\in \\mathcal{P}_k} (1 - \\gamma)\\ell^*_i(-\\alpha_i) + \\gamma \\ell^*_i(-(\\alpha + \\Delta \\alpha_{[k]})_i) \\right)$$\n\n45\nwhere the last inequality is obtained by applying Jensen’s inequality. We then proceed at bounding $B$ exploiting the $(1/\\tau)$-smoothness of $g^*$ and Assumption 2.6 on $\\sigma'$:\n\n$$B = g^*(v(\\alpha + \\gamma \\sum_{k=1}^{K} \\Delta \\alpha_{[k]})) = g^*(v(\\alpha) + \\gamma \\sum_{k=1}^{K} v(\\Delta \\alpha_{[k]}))$$\n\nwhere the last equality is by the definition of the dual objective $D$ for any local solver compliant to Assumption 1.\n\nBefore proving the main convergence result of Theorem 4 we will present the following lemma, that characterizes the effect of an iteration of Algorithm 5:\n\n$$\\Delta \\alpha_{[k]} = (1 - \\gamma)D(\\alpha) + \\frac{1}{n} \\sum_{i \\in P_k} \\ell_i^*(\\alpha) + \\gamma \\ell_i^*(\\alpha + \\Delta \\alpha_{[k]}),$$\n\nand\n\n$$\\Delta \\alpha_{[k]} = (1 - \\gamma)D(\\alpha) + \\frac{1}{n} \\sum_{i \\in P_k} \\ell_i^*(\\alpha) + \\gamma \\ell_i^*(\\alpha + \\Delta \\alpha_{[k]}).$$\n\nWe can now plug $A$ and $B$ back into (A.4) obtaining:\n\n$$D\\left(\\alpha + \\gamma \\sum_{k=1}^{K} \\Delta \\alpha_{[k]}\\right)$$\n\n$$\\geq - \\sum_{k=1}^{K} \\left( \\sum_{i \\in P_k} \\ell_i^*\\left(-\\alpha_i\\right) + \\gamma \\ell_i^*\\left(\\alpha + \\Delta \\alpha_{[k]}\\right) \\right)$$\n\n$$- \\left( g^*(v(\\alpha)) + \\sum_{k=1}^{K} \\gamma v(\\Delta \\alpha_{[k]})^T w(\\alpha) + \\frac{\\gamma}{2\\tau} \\sigma' \\sum_{k=1}^{K} \\|v(\\alpha_{[k]})\\|^2 \\right)$$\n\n$$= - \\sum_{k=1}^{K} \\left( \\sum_{i \\in P_k} \\ell_i^*\\left(-\\alpha_i\\right) \\right) - (1 - \\gamma)g^*(v(\\alpha))$$\n\n$$\\leq (1 - \\gamma)D(\\alpha) + \\frac{1}{n} \\sum_{i \\in P_k} \\ell_i^*(\\alpha) - \\frac{1}{K} g^*(v(\\alpha)) - v(\\Delta \\alpha_{[k]})^T w(\\alpha) - \\frac{\\sigma'}{2\\tau} \\|v(\\alpha_{[k]})\\|^2$$\n\nwhere the last equality is by the definition of the dual objective $D(\\cdot)$ and the subproblem objective $G_k^*(\\cdot)$ as in (2.5).\n\n**A.1.2 Preliminary Results**\n\nBefore proving the main convergence result of Theorem 4 we will present the following lemma, that characterizes the effect of an iteration of Algorithm 5 for any local solver compliant to Assumption 1.\nA.1. Convergence Analysis\n\nLemma 18. Let \\( f : \\mathbb{R}^d \\to \\mathbb{R} \\) be a continuous proper convex function and \\( f^* : \\mathbb{R}^d \\to \\mathbb{R} \\) its conjugate. Then:\n\n\\[\ny \\in \\partial f(x) \\implies f(x) + f^*(y) = x^T y \\quad \\text{(A.5)}\n\\]\n\nand\n\n\\[\nx \\in \\partial f^*(y) \\implies f(x) + f^*(y) = x^T y \\quad \\text{(A.6)}\n\\]\n\nProof. We will begin by proving A.5. We first of all notice that Fenchel’s inequality gives us that\n\n\\[\nf(x) + f^*(y) \\geq x^T y;\n\\]\n\nwe thus only need to prove the reverse. We begin by noting that for every subgradient \\( y \\in \\partial f(x) \\) it holds that\n\n\\[\nf(z) \\geq f(x) + (z - x)^T y \\quad \\forall z \\in \\mathbb{R}^d.\n\\]\n\nBy now applying the definition of convex conjugate we get:\n\n\\[\nf(x) + f^*(y) = f(x) + \\sup_z [z^T y - f(z)] \\\\\n\\leq f(x) + \\sup_z [z^T y - (f(x) + (z - x)^T y)] \\\\\n= \\sup_x x^T y = x^T y\n\\]\n\nEquation A.6 can be similarly proven by treating \\( f \\) as the biconjugate \\( f^{**} \\) of \\( f \\); this is possible since \\( f = f^{**} \\) which is given by the fact that \\( f \\) is a proper and continuous convex function.\n\nLemma 19. Let \\( \\ell^*_i \\) be a \\( \\mu \\)-strongly convex function with \\( \\mu \\geq 0 \\) and \\( g \\) be a \\( \\tau \\)-strongly convex function with \\( \\tau > 0 \\). Then for any iteration \\( t \\) of Algorithm 5 under Assumption 2 on \\( \\gamma, \\sigma' \\) and Assumption 1 on the local solver, for any \\( s \\in [0, 1] \\) it holds that\n\n\\[\n\\mathbb{E}[D(\\alpha^{(t+1)}) - D(\\alpha^{(t)})] \\geq \\gamma(1 - \\Theta) \\left( sG(\\alpha^{(t)}) - \\frac{\\sigma'}{2\\tau} s^2 R^{(t)} \\right), \\quad \\text{(A.7)}\n\\]\n\nwhere\n\n\\[\nR^{(t)} := -\\frac{\\tau(1-s)}{\\sigma s} \\|u^{(t)} - \\alpha^{(t)}\\|^2 + \\sum_{k=1}^K \\|A(u^{(t)} - \\alpha^{(t)})_k\\|^2,\n\\]\n\nfor \\( u^{(t)} \\in \\mathbb{R}^n \\) with\n\n\\[\nu_i^{(t)} \\in \\partial \\ell_i(x_i^T w(\\alpha^{(t)})).\n\\]\n\nProof. The line of thought follows the one of [10, Lemma 5]. The main difference will be the extension to our generalized subproblems \\( \\mathcal{G}_k^* (\\cdot; \\mathbf{v}, \\alpha_{[k]}) \\) along with the general mappings \\( w(\\alpha) := \\nabla g^*(\\mathbf{v}(\\alpha)) \\) with \\( \\mathbf{v}(\\alpha) := A\\alpha \\).\n\nFor sake of notation, we will fix an iteration index \\( t \\) and drop it from the notation, writing \\( \\alpha, \\mathbf{v}, \\mathbf{u} \\) instead of \\( \\alpha^{(t)}, \\mathbf{v}(\\alpha^{(t)}), \\mathbf{u}^{(t)} \\).\nA.1. Convergence Analysis\n\nWe now begin by applying the update formula\n\n\\[ \\alpha^{(t+1)} = \\alpha^{(t)} + \\gamma \\sum_k \\Delta \\alpha_k \\]\n\nfor the dual variables as used in Algorithm 5; we thus have:\n\n\\[\n\\mathbb{E}[D(\\alpha^{(t)}) - D(\\alpha^{(t+1)})] = \\mathbb{E}[D(\\alpha) - D(\\alpha + \\gamma \\sum_k \\Delta \\alpha_k)]\n\\]\n\n(by Lemma 2)\n\n\\[\n\\leq \\mathbb{E}[D(\\alpha) - (1 - \\gamma)D(\\alpha) - \\gamma \\sum_k G_k^\\sigma(\\Delta \\alpha_k^*; v, \\alpha_k)]\n\\]\n\n\\[\n= \\gamma \\mathbb{E}[D(\\alpha) - \\sum_k G_k^\\sigma(\\Delta \\alpha_k^*; v, \\alpha_k)] + \\sum_k G_k^\\sigma(\\Delta \\alpha_k^*; v, \\alpha_k) - \\sum_k G_k^\\sigma(\\Delta \\alpha_k^*; v, \\alpha_k)\n\\]\n\n(by Assumption 2 on the local solver \\( \\Theta \\)-approximation quality)\n\n\\[\n\\leq \\gamma \\left( D(\\alpha) - \\sum_k G_k^\\sigma(\\Delta \\alpha_k^*; v, \\alpha_k) + \\Theta \\left( \\sum_k G_k^\\sigma(\\Delta \\alpha_k^*; v, \\alpha_k) - \\sum_k G_k^\\sigma(0; v, \\alpha_k) \\right) \\right)\n\\]\n\n\\[\n= \\gamma (1 - \\Theta) \\left( D(\\alpha) - \\sum_k G_k^\\sigma(\\Delta \\alpha_k^*; v, \\alpha_k) \\right) + \\Theta \\left( \\sum_k G_k^\\sigma(\\Delta \\alpha_k^*; v, \\alpha_k) - \\sum_k G_k^\\sigma(0; v, \\alpha_k) \\right)\n\\]\n\n(A.10)\n\nwhere the last equality has been obtained by noticing that \\( \\sum_k G_k^\\sigma(0; v, \\alpha_k) = -g^*(v(\\alpha)) - \\sum_{i=1}^n \\ell_i^*(\\alpha_i) = D(\\alpha) \\).\n\nWe will now upper bound term \\( C \\). In the remaining of the proof we will be denoting \\( \\Delta \\alpha^* = \\sum_k \\Delta \\alpha_k^* \\). We start by applying the dual objective definition \\( D \\) and the definition of the local subproblems (2.5); we thus have\nthat\n\\[\nC = \\sum_{i=1}^{n} (\\ell_i^*(\\alpha_i) - \\Delta \\alpha_i^*) + v(\\Delta \\alpha^*)^T w(\\alpha) + \\sum_{k=1}^{K} \\frac{1}{2\\tau} \\sigma^\\prime \\|v(\\Delta \\alpha_{[k]}^*)\\|^2\n\\]\n(By the optimality of \\(\\Delta \\alpha^*)\n\\[\n\\leq \\sum_{i=1}^{n} (\\ell_i^*(\\alpha_i - s(u_i - \\alpha_i)) - \\Delta \\alpha_i^*) + v(s(u - \\alpha))^T w(\\alpha) + \\sum_{k=1}^{K} \\frac{1}{2\\tau} \\sigma^\\prime \\|v(s(u - \\alpha)_{[k]})\\|^2\n\\]\n(By the \\(\\mu\\)-strong convexity of \\(\\ell^*)\n\\[\n\\leq \\sum_{i=1}^{n} \\left( s\\ell_i^*(-u_i) + (1-s)\\ell_i^*(-\\alpha_i) - \\frac{\\mu}{2} (1-s)s(u_i - \\alpha_i)^2 - \\ell_i^*(-\\alpha_i) \\right)\n\\]\n\\[\n+ v(s(u - \\alpha))^T w(\\alpha) + \\sum_{k=1}^{K} \\frac{1}{2\\tau} \\sigma^\\prime \\|v(s(u - \\alpha)_{[k]})\\|^2\n\\]\n\\[\n= \\sum_{i=1}^{n} \\left( s\\ell_i^*(-u_i) - s\\ell_i^*(-\\alpha_i) - \\frac{\\mu}{2} (1-s)s(u_i - \\alpha_i)^2 \\right)\n\\]\n\\[\n+ v(s(u - \\alpha))^T w(\\alpha) + \\sum_{k=1}^{K} \\frac{1}{2\\tau} \\sigma^\\prime \\|v(s(u - \\alpha)_{[k]})\\|^2\n\\]\nBy now applying Lemma 18 we get\n\\[\n\\ell_i^*(-u_i) = -u_i x_i^T w(\\alpha) - \\ell_i(x_i^T w(\\alpha)). \\quad (A.11)\n\\]\n\nUsing the primal and dual problems definitions (1.3) and (1.4) we now write the duality gap as:\n\\[\nG(\\alpha) := P(w(\\alpha)) - D(\\alpha) \\overset{(1.3),(1.4)}{=} \\sum_{i=1}^{n} (\\ell_i(x_i^T w(\\alpha)) + \\ell_i^*(-\\alpha_i)) + (g(w(\\alpha)) + g^*(v(\\alpha)))\n\\]\n\\[\n= \\sum_{i=1}^{n} (\\ell_i(x_i^T w(\\alpha)) + \\ell_i^*(-\\alpha_i)) + (g(\\nabla g^*(v(\\alpha))) + g^*(v(\\alpha)))\n\\]\n(by Lemma 18)\n\\[\n= \\sum_{i=1}^{n} (\\ell_i(x_i^T w(\\alpha)) + \\ell_i^*(-\\alpha_i)) + v(\\alpha)^T w(\\alpha)\n\\]\n\\[\n= \\sum_{i=1}^{n} (\\ell_i(x_i^T w(\\alpha)) + \\ell_i^*(-\\alpha_i) + \\alpha_i x_i^T w(\\alpha)).\n\\]\n(A.12)\nA.1. Convergence Analysis\n\nHence,\n\n\\[ C (A.11) \\leq \\sum_{i=1}^{n} \\left( -su_i^T w(\\alpha) - s\\ell_i(x^T_i w(\\alpha)) - s\\ell_i^*(-\\alpha_i) \n- sa_i x_i^T w(\\alpha) + sa_i x_i^T w(\\alpha) - \\frac{\\mu}{2} (1-s)s(u_i - \\alpha_i)^2 \\right) \n+ v(s(u - \\alpha))^T w(\\alpha) + \\sum_{k=1}^{K} \\frac{1}{2\\tau} \\|v(s(u - \\alpha)|_k)\\|^2 \n= \\sum_{i=1}^{n} (-s\\ell_i(x^T_i w(\\alpha)) - s\\ell_i^*(-\\alpha_i) - s^T x_i w(\\alpha)\\alpha_i) \n+ \\sum_{i=1}^{n} \\left( sx_i^T w(\\alpha)(\\alpha_i - u_i) - \\frac{\\mu}{2} (1-s)s(u_i - \\alpha_i)^2 \\right) \n+ v(s(u - \\alpha))^T w(\\alpha) + \\sum_{k=1}^{K} \\frac{1}{2\\tau} \\|v(s(u - \\alpha)|_k)\\|^2 \n\\overset{(A.12)}{=} -sG(\\alpha) - \\frac{\\mu}{2} (1-s)s\\|u - \\alpha\\|^2 + \\frac{\\sigma'}{2\\tau} s^2 \\sum_{k=1}^{K} \\|A(u - \\alpha)|_k\\|^2. \\quad (A.13) \\]\n\nFinally, plugging this last equation (A.10) into (A.7) yields the improvement bound (A.7).\n\nThe following Lemma provides a uniform bound on \\( R(t) \\):\n\n**Lemma 20.** If \\( \\ell_i \\) are \\( L \\)-Lipschitz continuous for all \\( i \\in [n] \\), then\n\n\\[ \\forall t : R(t) \\leq 4L^2 \\sum_{k=1}^{K} \\sigma_k n_k, \\quad (A.14) \\]\n\nwith \\( \\sigma_k \\) as in (2.9).\n\n**Proof.** [10, Proof of Lemma 6] \\( \\square \\)\n\n**A.1.3 Proof of Convergence Rate for General Lipschitz Losses**\n\n**Theorem’ 4.** Let \\( L \\)-Lipschitz continuous \\( \\ell_i(\\cdot) \\) functions, a \\( \\tau \\)-strongly convex \\( g \\) function and an arbitrary local solver satisfying Assumption 2 be given. Let\n\\( \\gamma, \\sigma' \\) be defined as in Assumption 1. Then, if \\( \\epsilon_G > 0 \\) is the desired duality gap, after \\( T \\) iterations of Algorithm 5 with\n\\[\nT \\geq T_0 + \\max\\left\\{ \\frac{1}{\\gamma(1-\\Theta)}, \\frac{4L^2\\sigma'}{\\tau \\epsilon_G \\gamma(1-\\Theta)} \\right\\},\n\\]\n\\[\nT_0 \\geq t_0 + \\left( \\frac{2}{\\gamma(1-\\Theta)} \\left( \\frac{8L^2\\sigma'}{\\tau \\epsilon_G} - 1 \\right) \\right),\n\\]\n\\[\nt_0 \\geq \\max\\left\\{ 0, \\left[ \\frac{1}{\\gamma(1-\\Theta)} \\log(\\frac{2\\tau(d(\\alpha^*)-d(\\alpha^{(0)}))}{4L^2\\sigma'}) \\right] \\right\\},\n\\]\nthe expected duality gap will satisfy\n\\[\n\\mathbb{E}[d(w(\\bar{\\alpha})) - d(\\bar{\\alpha})] \\leq \\epsilon_G,\n\\]\nat the averaged iterate\n\\[\n\\bar{\\alpha} := \\frac{1}{T-T_0} \\sum_{t=T_0+1}^{T-1} \\alpha^{(t)}\n\\]\nProof. The proof of this theorem closely follows the proof of Theorem 8 from [10]. We start by estimating the expectation of the change in dual feasibility. Using Lemma 19 we get:\n\\[\n\\mathbb{E}[d(\\alpha^*) - d(\\alpha)] \\leq \\mathbb{E}[d(\\alpha^*) - d(\\alpha^{(t+1)}) + d(\\alpha^{(t)}) - d(\\alpha^{(t)})]\n\\]\n\\[\n\\leq d(\\alpha^*) - d(\\alpha^{(t)}) - \\gamma(1-\\Theta)sG(\\alpha^{(t)}) + \\gamma(1-\\Theta)\\frac{s^2 G'}{2\\tau}\n\\]\n\\[\n\\leq d(\\alpha^*) - d(\\alpha^{(t)}) - \\gamma(1-\\Theta)s(d(w(\\alpha^{(t)})) - d(\\alpha^{(t)})) + \\gamma(1-\\Theta)\\frac{s^2 G'}{2\\tau}\n\\]\n\\[\n\\leq (1 - \\gamma(1-\\Theta)s) (d(\\alpha^*) - d(\\alpha^{(t)})) + \\gamma(1-\\Theta)\\frac{s^2 G'}{2\\tau}\n\\]\nWe can now recursively apply (A.17) to get\n\\[\n\\mathbb{E}[d(\\alpha^*) - d(\\alpha^{(t)})] \\leq (1 - \\gamma(1-\\Theta)s) t_0 (d(\\alpha^*) - d(\\alpha^{(0)})) + \\gamma(1-\\Theta)\\frac{s^2 G'}{2\\tau} \\frac{1-(1-\\gamma(1-\\Theta)s)^t}{(1-\\gamma(1-\\Theta)s)}\n\\]\nBy choosing \\( s = 1 \\) and \\( t = t_0 := \\max\\left\\{ 0, \\left[ \\frac{1}{\\gamma(1-\\Theta)} \\log(\\frac{2\\tau(d(\\alpha^*)-d(\\alpha^{(0)}))}{4L^2\\sigma'}) \\right]\\right\\} \\)\nwe can see that\n\\[\n\\mathbb{E}[d(\\alpha^*) - d(\\alpha^{(t)})] \\leq (1 - \\gamma(1-\\Theta)s) t_0 (d(\\alpha^*) - d(\\alpha^{(0)})) + \\gamma(1-\\Theta)\\frac{s^2 G'}{2\\tau}\n\\]\n\\[\n\\leq \\frac{4L^2\\sigma'}{2\\tau} + \\frac{4L^2\\sigma'}{2\\tau} = \\frac{4L^2\\sigma'}{\\tau}\n\\]\nWe'll now proceed by induction in order to show\n\\[ \\forall t \\geq t_0 : \\mathbb{E}[D(\\mathbf{a}^*) - D(\\mathbf{a}^{(t)})] \\leq \\frac{4L^2 \\sigma s}{\\tau(1 + \\frac{1}{2} \\gamma (1 - \\Theta)(t - t_0))}. \\tag{A.21} \\]\n\nFirst of all we notice that the base case \\( t = t_0 \\) is readily implied by (A.19). We can show that, by assuming that (A.21) holds for a fixed \\( t \\geq t_0 \\), it also holds for step \\( t + 1 \\). We thus define \\( s \\) as a function of \\( t \\) as follows\n\\[ s = \\frac{1}{1 + \\frac{1}{2} \\gamma (1 - \\Theta)(t - t_0)} \\in [0, 1] \\tag{A.22} \\]\nand get\n\\[\n\\mathbb{E}[D(\\mathbf{a}^*) - D(\\mathbf{a}^{(t+1)})] \\overset{(A.17)}{\\leq} (1 - \\gamma (1 - \\Theta)s) (D(\\mathbf{a}^*) - D(\\mathbf{a}^{(t)})) + \\gamma (1 - \\Theta) \\frac{\\sigma s^2}{2r} 4L^2 \\sigma \\\\\n\\overset{(A.21)}{\\leq} (1 - \\gamma (1 - \\Theta)s) \\frac{4L^2 \\sigma s}{(1 + \\frac{1}{2} \\gamma (1 - \\Theta)(t - t_0))} + \\gamma (1 - \\Theta) \\frac{\\sigma s^2}{2r} 4L^2 \\sigma \\\\\n\\overset{(A.22)}{= \\frac{4L^2 \\sigma s}{\\tau}} \\left( 1 + \\frac{1}{2} \\gamma (1 - \\Theta)(t - t_0) \\right) \\left( \\gamma (1 - \\Theta) + \\gamma (1 - \\Theta) \\right) \\\\\n= \\frac{4L^2 \\sigma s}{\\tau} \\left( 1 + \\frac{1}{2} \\gamma (1 - \\Theta)(t - t_0) \\right) \\\\\n\\leq 1.\n\\]\n\nWe can now upperbound \\( D \\) using the fact that the geometric mean is less or equal than the arithmetic mean:\n\\[\nD = \\frac{1}{1 + \\frac{1}{2} \\gamma (1 - \\Theta)(t + 1 - t_0)} \\left( 1 + \\frac{1}{2} \\gamma (1 - \\Theta)(t + 1 - t_0) \\right) \\\\\n\\leq 1 + \\frac{1}{2} \\gamma (1 - \\Theta)(t + 1 - t_0).\n\\]\n\nWe now look at the expected duality gap for the averaged iterate \\( \\overline{\\mathbf{a}} \\) defined as in (A.16):\n\\[\n\\mathbb{E}[G(\\overline{\\mathbf{a}})] = \\mathbb{E} \\left[ G \\left( \\frac{1}{T-t_0} \\sum_{t=t_0}^{T-1} \\mathbf{a}^{(t)} \\right) \\right] \\leq \\frac{1}{T-t_0} \\mathbb{E} \\left[ \\sum_{t=t_0}^{T-1} G \\left( \\mathbf{a}^{(t)} \\right) \\right] \\\\\n\\overset{(A.7), (A.14)}{\\leq} \\frac{1}{T-t_0} \\mathbb{E} \\left[ \\sum_{t=t_0}^{T-1} \\left( \\frac{1}{\\gamma (1 - \\Theta)s} (D(\\mathbf{a}^{(t+1)}) - D(\\mathbf{a}^{(t)})) + \\frac{4L^2 \\sigma s}{2r} \\right) \\right] \\\\\n= \\frac{1}{\\gamma (1 - \\Theta)s} \\frac{1}{T-t_0} \\mathbb{E} \\left[ D(\\mathbf{a}^{(T)}) - D(\\mathbf{a}^{(T_0)}) \\right] + \\frac{4L^2 \\sigma s}{2r} \\\\\n\\leq \\frac{1}{\\gamma (1 - \\Theta)s} \\frac{1}{T-t_0} \\mathbb{E} \\left[ D(\\mathbf{a}^*) - D(\\mathbf{a}^{(T_0)}) \\right] + \\frac{4L^2 \\sigma s}{2r}. \\tag{A.23}\n\\]\nAssuming $T \\geq \\lceil \\frac{1}{\\gamma(1-\\Theta)} \\rceil + T_0$ with $T_0 \\geq t_0$ we get\n\\[\n\\mathbb{E}[G(\\mathbf{x})] \\leq \\frac{1}{\\gamma(1-\\Theta)s} \\frac{1}{T-T_0} \\left( \\frac{4L^2\\sigma s}{(1+\\frac{1}{2}\\gamma(1-\\Theta)(T_0-t_0))} \\right) + \\frac{4L^2\\sigma s}{2\\tau}.\n\\]\n(A.24)\n\nChoosing\n\\[\ns = \\frac{1}{(T-T_0)\\gamma(1-\\Theta)} \\in [0,1]\n\\]\n(A.25)\nwe then obtain\n\\[\n\\mathbb{E}[G(\\mathbf{x})] \\leq \\frac{4L^2\\sigma \\sigma'}{\\tau} \\left( \\frac{1}{1+\\frac{1}{2}\\gamma(1-\\Theta)(T_0-t_0)} + \\frac{1}{(T-T_0)\\gamma(1-\\Theta)2} \\right).\n\\]\n(A.26)\n\nWe conclude by choosing a $T$ and $T_0$ that make (A.26) smaller than the desired gap $\\epsilon_G$:\n\\[\n\\frac{4L^2\\sigma \\sigma'}{\\tau} \\left( \\frac{1}{1+\\frac{1}{2}\\gamma(1-\\Theta)(T_0-t_0)} \\right) \\leq \\frac{1}{2} \\epsilon_G, \\quad (A.27)\n\\]\n\\[\n4L^2\\sigma \\sigma' \\left( \\frac{1}{(T-T_0)\\gamma(1-\\Theta)2} \\right) \\leq \\frac{1}{2} \\epsilon_G. \\quad (A.28)\n\\]\n\nTherefore, using\n\\[\nt_0 + \\frac{2}{\\gamma(1-\\Theta)} \\left( \\frac{8L^2\\sigma \\sigma'}{\\tau \\epsilon_G} - 1 \\right) \\leq T_0,\n\\]\n\\[\nT_0 + \\frac{4L^2\\sigma \\sigma'}{\\tau \\epsilon_G \\gamma(1-\\Theta)} \\leq T,\n\\]\n(A.27) and (A.28) are both satisfied.\n\n\\section*{A.2 Specific Conjugates}\n\n\\textbf{Lemma' 14.} The convex conjugate of $\\bar{\\ell}_i^*$ as defined above is\n\\[\n\\bar{\\ell}(x) = \\begin{cases} \n0 & : x \\in [-1,1] \\\\\nB(|x| - 1) & : otherwise\n\\end{cases},\n\\]\nand is $B$-Lipschitz.\n**Proof.** We start by applying the definition of convex conjugate, that is:\n\n\\[ \\bar{\\ell}^*(\\alpha) = \\sup_{x \\in \\mathbb{R}} [\\alpha x - \\ell(x)] \\]\n\nWe begin by looking at the case in which \\( \\alpha \\geq B \\); in this case it's easy to see that when \\( x \\to +\\infty \\), we have that:\n\n\\[ \\alpha x - B(|x| - 1) = (\\alpha - B)x - B \\to +\\infty \\]\n\nas \\( \\alpha - B \\geq 0 \\). Similarly one can show the case \\( \\alpha \\leq -B \\). We'll now look at the case \\( \\alpha \\in [0,B] \\); in this case it is clear that an optimal \\( x^* \\) needs to be \\( \\geq 0 \\). Also it must hold that \\( x^* \\leq 1 \\) since\n\n\\[ \\alpha x - B(x - 1) < \\alpha x \\]\n\nfor every \\( x > 1 \\). Therefore the maximization becomes:\n\n\\[ \\bar{\\ell}^*(\\alpha) = \\sup_{x \\in [0,1]} \\alpha x \\]\n\nwhich has maximum \\( \\alpha \\) at \\( x = 1 \\). Analogously one can show the remaining \\( \\alpha \\in [-B,0] \\) case. \\( \\square \\)\n\n**Lemma’ 8.** For \\( \\eta \\in (0,1] \\), the convex conjugate of the elastic net function\n\n\\[ f(\\alpha) := \\frac{\\eta}{2} \\alpha^2 + (1 - \\eta)|\\alpha| \\]\n\nis\n\n\\[ f^*(x) := \\frac{1}{2\\eta} \\left( \\left[ |x| - (1 - \\eta) \\right]_+ \\right)^2, \\]\n\nwhere \\([.]_+ \\) is the positive part operator, \\([s]_+ = s \\) for \\( s > 0 \\), and zero otherwise. Also, the conjugate \\( f^{**} \\) of \\( f^* \\) is equal to \\( f \\).\n\n**Proof.** We start by applying the definition of convex conjugate, that is:\n\n\\[ f^*(x) = \\max_{\\alpha \\in \\mathbb{R}} [x\\alpha - f(\\alpha)] = \\max_{\\alpha \\in \\mathbb{R}} \\left[ x\\alpha - \\frac{\\eta}{2} \\alpha^2 - (1 - \\eta)|\\alpha| \\right] \\]\n\nWe’ll now distinguish the cases in which the optimal \\( \\alpha^* \\geq 0 \\), \\( \\alpha^* < 0 \\). For the first case we get that\n\n\\[ f^*(x) = \\max_{\\alpha \\in \\mathbb{R}} \\left[ x\\alpha - \\frac{\\eta}{2} \\alpha^2 - (1 - \\eta)\\alpha \\right] \\]\n\nand thus setting the derivative of it to 0 we get that \\( \\alpha^* = \\frac{x - (1 - \\eta)}{\\eta} \\) and thus, in order for \\( \\alpha^* \\) to be \\( \\geq 0 \\) this can only hold when \\( x \\geq 1 - \\eta \\). Replacing with \\( \\alpha^* \\) we thus get:\n\n\\[ f^*(x) = \\alpha^*(x - \\frac{1}{\\eta} \\alpha^* - (1 - \\eta)) = \\alpha^* \\left( x - \\frac{1}{\\eta} (x - (1 - \\eta)) - (1 - \\eta) \\right) = \\]\n\n54\nA.2. Specific Conjugates\n\n\\[ \\frac{1}{2} \\alpha^*(x - (1 - \\eta)) = \\frac{1}{2\\eta} (x - (1 - \\eta))^2 \\]\n\nSimilarly we can show that for \\( x \\leq -(1 - \\eta) \\)\n\n\\[ f^*(x) = \\frac{1}{2\\eta} (x + (1 - \\eta))^2. \\]\n\nFinally, by the fact that \\( f^*(\\cdot) \\) is convex, always positive and that \\( f^*(-(1 - \\eta)) = f^*(1 - \\eta) = 0 \\), it follows that \\( f^*(x) = 0 \\) for every \\( x \\in [-1(1 - \\eta), 1 - \\eta] \\).\n\nWe conclude by noticing that, being the \\( f \\) function convex and continuous we can apply the Fenchel–Moreau theorem to prove that \\( f^{**} = f \\).\n\n\\[ \\square \\]\n\n\nDeclaration of originality\n\nThe signed declaration of originality is a component of every semester paper, Bachelor’s thesis, Master’s thesis and any other degree paper undertaken during the course of studies, including the respective electronic versions.\n\nLecturers may also require a declaration of originality for other written papers compiled for their courses.\n\nI hereby confirm that I am the sole author of the written work here enclosed and that I have compiled it in my own words. Parts excepted are corrections of form and content by the supervisor.\n\nTitle of work (in block letters):\n\nDistributed Optimization for Non-Strongly Convex Regularizers\n\nAuthored by (in block letters):\nFor papers written by groups the names of all authors are required.\n\nName(s):\nForte\n\nFirst name(s):\nSimone\n\nWith my signature I confirm that\n- I have committed none of the forms of plagiarism described in the ‘Citation etiquette’ information sheet.\n- I have documented all methods, data and processes truthfully.\n- I have not manipulated any data.\n- I have mentioned all persons who were significant facilitators of the work.\n\nI am aware that the work may be screened electronically for plagiarism.\n\nPlace, date\nZürich, 16/09/2015\n\nSignature(s)\n\nFor papers written by groups the names of all authors are required. Their signatures collectively guarantee the entire content of the written paper."}}},{"rowIdx":175,"cells":{"id":{"kind":"string","value":"a55428ff03236e15e0ef2037c961f080b3404cbb"},"text":{"kind":"string","value":"Policy Merger System for P3P\nIn a\nCloud Aggregation Platform\n\nOlumuyiwa Olurin\n\nThesis submitted to the\nSchool of Electrical Engineering and Computer Science\nIn Partial Fulfillment of\nThe requirements for the degree of\n\nMaster of Applied Science,\nElectrical and Computer Engineering\n\nUnder the auspices of the\nInstitute for Electrical and Computer Engineering (OCIECE)\nFaculty of Engineering\n\nuOttawa\n\nUniversity of Ottawa\nOttawa, Ontario, Canada\n\nJanuary 2013\n\n© Olumuyiwa Olurin, Ottawa, Canada, 2013\nAbstract\n\nThe need for aggregating privacy policies is present in a variety of application areas today. In traditional client/server models, websites host services along with their policies in different private domains. However, in a cloud-computing platform where aggregators can merge multiple services, users often face complex decisions in terms of choosing the right services from service providers. In this computing paradigm, the ability to aggregate policies as well as services will be useful and more effective for users that are privacy conscious regarding their sensitive or personal information.\n\nThis thesis studies the problems associated with the Platform for Privacy Preference (P3P) language, and the present issues with communicating and understanding the P3P language. Furthermore, it discusses some efficient strategies and algorithms for the matching and the merging processes, and then elaborates on some privacy policy conflicts that may occur after merging policies. Lastly, the thesis presents a tool for matching and merging P3P policies. If successful, the merge produces an aggregate policy that is consistent with the policies of all participating service providers.\nAcknowledgements\n\nA very special and well-deserved thank you to God and to the following:\n\n1) I am indebted to my supervisors Dr. Carlisle Adams and Dr. Logrippo Luigi for their guidance, patience, insight, and encouragement during the last two years. They have always been very kind and friendly advisors. Their brilliance, steady perseverance and the pursuit of excellence in thinking and writing helped me to successfully coordinate my ideas and writing skills. These skills will continue to inspire me all the way.\n\n2) The Computer Security and Privacy group including Ali Noman, Ruj Sushmita. Our monthly meetings, our formal and informal discussions about security, privacy and cryptography were of great help.\n\n3) I would like to thank my dear friends Mary, Ivan, and Karen Beauchamp for providing their support and help all the way and for making my graduate life very fulfilling and enriching.\n\n4) Lastly, I would like to thank my family and most importantly my parents for their support throughout my graduate studies. Without their care, patience, and encouragement, I would not have been able to complete this important step of my life’s journey.\n# Table of Contents\n\nAbstract ................................................................................................................. ii\nAcknowledgements ............................................................................................... iii\nTable of Contents ................................................................................................. iv\nList of Figures ....................................................................................................... viii\nList of Tables ........................................................................................................ x\n\nChapter 1 Introduction ......................................................................................... 1\n 1.1 Thesis Motivation ........................................................................................... 4\n 1.2 Thesis Objective .............................................................................................. 7\n 1.3 Thesis Contributions ....................................................................................... 7\n 1.4 Thesis Outline ................................................................................................. 8\n\nChapter 2 Background ......................................................................................... 10\n 2.1 Basic Definitions ............................................................................................ 10\n 2.1.1 Privacy ..................................................................................................... 10\n 2.1.2 Privacy Policy .......................................................................................... 10\n 2.1.3 Policy Language ....................................................................................... 11\n 2.2 Platform for Privacy Preferences (P3P) ........................................................... 12\n 2.2.1 Introduction to P3P ................................................................................ 12\n 2.2.2 Retrieving P3P Policies ......................................................................... 13\n 2.2.3 P3P Policy Reference File ...................................................................... 14\n 2.2.4 P3P Syntax and Semantics ...................................................................... 15\n 2.3 Tree Model Structured Data .......................................................................... 25\n 2.4 P3P User Agents ............................................................................................ 26\n 2.5 A P3P Preference Exchange Language (APPEL) .......................................... 27\n 2.5.1 Introduction of APPEL .......................................................................... 27\n 2.6 Cloud Computing ......................................................................................... 28\n 2.6.1 Introduction to Cloud Computing .......................................................... 28\n 2.6.2 Cloud Service Models .......................................................................... 29\n 2.6.3 Cloud Deployment Models ..................................................................... 31\n 2.7 Service Aggregation Model .......................................................................... 32\n 2.7.1 Cloud Service Provider (CSP) ............................................................... 33\n 2.7.2 Cloud Users ........................................................................................... 33\n2.7.3 Service Provider (SP) ................................................................. 33\n2.7.4 Service Aggregator (SA) .......................................................... 33\n2.7.5 Aggregation Platform .............................................................. 34\n2.8 Conclusion ................................................................................. 36\n\nChapter 3 Related Work ................................................................. 37\n3.1 Privacy Policy Language .............................................................. 37\n 3.1.1 Platform for Privacy Preferences ............................................. 38\n 3.1.2 A P3P Preference Exchange Language (APPEL) ....................... 38\n 3.1.3 Formal Semantics for the P3P Language .................................. 39\n3.2 P3P Inconsistencies ................................................................ 40\n 3.2.1 Conflicts between multiple retention values and Datum ............. 40\n 3.2.2 Conflicts between purpose and retention element .................... 40\n 3.2.3 Conflict between purpose and data category element ............... 40\n 3.2.4 Conflict between purpose and recipient element ..................... 40\n 3.2.5 Conflict between retention and recipient element ................... 40\n 3.2.6 Conflict from optional attributes .......................................... 41\n3.3 Semantic Approach to P3P ......................................................... 41\n3.4 Related Research on P3P ............................................................ 43\n 3.4.1 Combining Privacy Policies ...................................................... 43\n 3.4.2 Related Approach to Merging Privacy Policies ......................... 46\n 3.4.3 Formal Modeling & Verification of P3P Policies ......................... 48\n 3.4.4 Automated Tool .................................................................... 49\n3.5 Conclusion ................................................................................ 50\n\nChapter 4 Merging Strategy ............................................................ 51\n4.1 Overview of Merging Strategy .................................................... 51\n4.2 Requirements for P3P Merge Process ........................................ 51\n 4.2.1 Text-Based Merge ................................................................. 52\n 4.2.2 Syntactic Merge ................................................................... 53\n 4.2.3 Semantic Merge ................................................................... 53\n4.3 Merging Strategy ....................................................................... 53\n 4.3.1 Policy Validation and Conflict Detection ............................... 55\n 4.3.2 P3P Match Detection ............................................................. 56\nList of Figures\n\nFigure 1: Cloud User is searching and managing multiple online accounts.................................1\nFigure 2: Aggregate service along with multiple P3P policies.........................................................5\nFigure 3: A User’s aggregate service dashboard on Primadesk..........................................................6\nFigure 4: Framework for P3P Privacy Policies [24]...........................................................................13\nFigure 5: Retrieving a P3P policy from the server............................................................................14\nFigure 6: An Example of P3P Policy Reference [24]........................................................................14\nFigure 7: Outline of P3P Privacy Policy Syntax and Semantics..........................................................15\nFigure 8: Policy Element......................................................................................................................17\nFigure 9: An Example of Entity Element............................................................................................17\nFigure 10: An Example of Access Element........................................................................................18\nFigure 11: Sample natural language policy ..........................................................................................23\nFigure 12: The corresponding P3P policy derived from the preceding natural language policy ......24\nFigure 13: Sample XML code..............................................................................................................25\nFigure 14: The Tree Corresponding to the XML code in Figure 13...................................................26\nFigure 15: How users can create APPEL Preferences [26]...............................................................27\nFigure 16: The NIST’s Model of Cloud Computing [12]....................................................................29\nFigure 17: Overview of Cloud Service Models ..................................................................................30\nFigure 18: Service aggregation in a cloud-computing environment [78]...........................................32\nFigure 19: Overview of HP AP4SaaS.................................................................................................36\nFigure 20: Example of data hierarchy..................................................................................................42\nFigure 21: Equation for Aggregate Policy............................................................................................47\nFigure 22: Multiple Statement Element Scenario in P3P policies...................................................52\nFigure 23: P3P Merge Process............................................................................................................54\nFigure 24: P3P Tree matching problems (P3P A and B).................................................................57\nFigure 25: Two-Way merge Principle [50] .........................................................................................59\nFigure 26: Two-Way merge operation on P3P policies ...................................................................59\nFigure 27: Three-Way merge Principle, [50].....................................................................................60\nFigure 28: Three-Way merge operation on P3P policies.................................................................61\nFigure 29: A sample P3P code............................................................................................................65\nFigure 30: Tree corresponding to the P3P Code in Figure 29............................................................65\nFigure 31: Example of Multiple Purposes and Data........................................................................66\nList of Tables\n\nTable 1: Classification of the Privacy Policy Language [46] .......................................................... 11\nTable 2: Table explaining XML document in Figure 13 .................................................................. 26\nTable 3: Khurat’s Details of relation table [43] ............................................................................. 45\nTable 4: Node tables to explain the P3P code in Figure 29 ......................................................... 65\nTable 5: Example of Aggregate ENTITY Element ........................................................................ 85\nTable 6: Example of aggregate Access Element ......................................................................... 86\nTable 7: Example of aggregate Disputes-group Element ............................................................. 88\nTable 8: Example of aggregate NON-IDENTIFIABLE Element .................................................. 89\nTable 9: Example of aggregate Consequence Element ............................................................... 90\nTable 10: Example of aggregate Retention element ................................................................. 91\nTable 11: Differences in P3P Merger Approach ........................................................................ 107\nTable 12: Privacy Policy for Service A ..................................................................................... 109\nTable 13: Privacy Policy B ......................................................................................................... 110\nTable 14: Aggregated Result for P3P A and B ....................................................................... 113\nChapter 1\n\nIntroduction\n\nThe need for aggregate privacy policies is present in a variety of application areas today. With the growing success and advantage of cloud computing\\(^1\\), many organizations are considering moving their data or applications into the cloud. Among many advantages of cloud computing, users have the opportunity to create, share, and manage their online data stored on the cloud. While creating exciting opportunities, cloud services bring new challenges. The user faces complex issues for choosing the right services, and the right service providers, or synchronizing and integrating service applications using the cloud infrastructure. As shown in Figure 1, managing and searching for data on the cloud is a major challenge to most cloud users; an average online user in countries such as the USA or Canada can have around 20 different online accounts. For example, some users can have accounts for storing and sharing documents (e.g. Dropbox, SugarSync), photos (e.g. Facebook, Picasa), and e-mails (e.g. Gmail, Yahoo, Hotmail).\n\n\\[\\text{Figure 1: Cloud User is searching and managing multiple online accounts}\\]\n\n\\(^1\\) The International Data Corporation (IDC) indicates that the market for cloud computing services was 16.2 billion dollars in 2008 and will rise to 42.3 billion dollars per year by 2012. http://www.idc.com.\nService providers need a way to reach their entire community of users to support them on integrating services and maintaining their services. The cloud aggregation platform is the right tool to solve these challenges. Cloud aggregation platform is a hub for service providers that come together to find solutions to users’ integrating and synchronizing problems. The platform can integrate services deployed in the cloud at the request of users. However, privacy policies from those merged services will remain in separate files, because the concept of merging privacy policies is not present in the aggregation platform for cloud computing. For example, when users receive an aggregate service along with separate multiple privacy policies, they may get confused regarding which privacy policy they should acknowledge. Moreover, a policy user agent that translates an encoded policy into a readable format also needs a single policy file to communicate a consistent summary of the policy.\n\nCloud computing describes both aggregation platforms and application services. As a platform it supplies, and configures servers. On the other hand, applications on the cloud are accessible via the Internet, and for this purpose large data centers and powerful servers host the services and applications [16]. Cloud computing combines the newest techniques to deliver services that have the following characteristics: rapid scalability, pay per use services, service delivery via broadband networks or the Internet, and sharing resources. However, information collected from people, organizations, agencies or service providers will be at the mercy of the cloud service providers [29]. Some organizations contemplating cloud computing adoption face a number of challenges on policy or security standards [12]. These concerns in return may discourage those organizations from adopting cloud-computing services.\n\nData privacy has become increasingly important for both users and service providers. Users that now benefit from cloud computing resources can easily release Personally Identifiable Information (PII) about themselves or their personal businesses to their service providers either consciously or subconsciously [5,7]. Some research analysts at reputable privacy and\nsecurity laboratories, such as Cylab Usable Privacy and Security Lab\\(^2\\), found that the trail of information left can rapidly grow, and the potential for the misuse of this information is well-recognized \\([47]\\).\n\nPrivacy issues are a major concern that prevents users from fully enjoying the flexibility, convenience, and variety offered by service providers in a cloud computing environment \\([47,25,61]\\). Users that are aware of possible consequences that may arise because of privacy violation on their PII are reluctant to adopt or use some cloud services. Furthermore, those users may quickly reject services that may request sensitive PII, such as credit card information, Social Insurance Number (SIN) or other sensitive personal data. Privacy violations can range from privacy accidents to illegal actions \\([25,5]\\). Those violations have generated fears and doubts in the mind of many experienced web users, prompting different questions such as\n\n- What will the service providers do with their PII information after it serves the primary purpose?\n- How long will the retention period affect their PII information?\n- With whom will they share the PII information collected?\n\nBournez et al. \\([17]\\) has defined some policy requirements and other aspects of privacy policies. In \\([17]\\), they refer to privacy policy as a “set of rules stating how the provider will treat a piece of sensitive data collected. The data handling policy specifies for what purposes the data is collected, with which third parties will they share the data, the obligation to make use of the data as specified in the policy, and for how long they can store the data.” Bournez et al. \\([17]\\) further states that the main legal requirement imposed by institutions (such as Governments, European Union, etc.) is that privacy languages should be used for privacy policies and protection.\n\n\\(^2\\) Carnegie Mellon University, The Cylab Usable Privacy and Security Laboratory (CUPS)\nhttp:www.cups.cs.cmu.edu\n1.1 Thesis Motivation\n\nThe concerns about the privacy of user data stored in the cloud have grown along with the cloud’s popularity [32, 68]. It is very important for a user to stay aware of the potential privacy hazards and have better control over disclosing private information. Privacy regulations in the USA, Canada, Europe, and elsewhere include a provision that regulates companies to give notice of their data practices through privacy policies. Privacy policies serve to increase transparency about data practices and support the “awareness” fair information practice principle [19].\n\nPrivacy policy languages were developed as one of the responses to the concerns about privacy issues. There are various open source privacy policy languages available on the Internet. A privacy policy language uses standardized syntax and semantics to create and compare user’s privacy preferences with service providers’ policies, and to make privacy policies more machine-readable and enforceable. However, as reviewed in the recent research [39, 43, 30], few researchers widely use or talk about standardized service privacy policy languages such as the Platform for Privacy Preferences (P3P) [24] and the Enterprise Privacy Authorization Language (EPAL) [71].\n\nThe World Wide Web Consortium (W3C) proposed the P3P framework for automating the privacy policy verification process [24]. “The P3P project enables service providers to express their privacy practices in a standard XML format, which are automatically retrieved and interpreted by user agents. P3P user agents allow users to understand the provider’s data handling practices (in both machine readable and human readable formats) and automate decision-making [24].” The P3P framework is useful and more effective for situations where a user is interacting with a single privacy policy, because the framework was not originally designed to accommodate multiple privacy policies for a single HTTP request. To the best of our knowledge, none of the privacy mechanisms available can merge privacy policies on an aggregation platform. Due to this absence, users cannot derive a fair aggregate policy from\n\n---\n\nmultiple privacy policies when the need arises. The problem gets more important as companies adopt cloud computing technologies, because they move their customers’ and company’s private data, privacy policies, and business applications into the cloud.\n\nFigure 2: Aggregate service along with multiple P3P policies.\n\nFigure 2 illustrates a sample aggregate platform that provides the user with an aggregate service from three different service providers. It should be noted, however, that this aggregate service will be formed at the request of the user. For example, Cloud aggregators such as Primadesk⁴, Rackspace⁵, Otixo⁶, and Kitedesk⁷ offer service integration tools that help aggregate and manage services from different providers (e.g. Gmail, Yahoo, Hotmail, Instagram, Facebook, Dropbox, Google Doc, My box, etc.).\n\n⁴ Primadesk https://www.primadesk.com\n⁵ Rackspace http://www.rackspace.com\n⁶ Otixo http://www.otixo.com\n⁷ Kitedesk http://www.kitedesk.com\nThe Primadesk dashboard shown in Figure 3 lets the user stay connected to the cloud by linking together the contents from all of the user’s online accounts. The user can integrate and navigate through the personalized stream of information. For the example shown in Figure 3, the user connects the Primadesk dashboard to email, document and photo accounts through a single stream view of the cloud.\n\nNormally providers present their services in separate domains with a well-defined privacy policy (e.g. P3P). The notifications of privacy policies will be entirely different in the cloud aggregation platform, where multiple service providers adopt different privacy policies for their services. Policy notifications in an aggregation platform will be easier to understand by users, if the aggregate service also has aggregate policy. However, the design of the P3P framework only accommodates one privacy policy file in a single HTTP request. Although it is possible for service providers to aggregate privacy policies offline, this method will only be appropriate if those service providers have appropriate machine readable policies such as P3P.\nHowever, the expiry element in a machine readable policy such as P3P language, states how long the policy reference file or policies remains valid. In order to keep track of the validity when merging the policies, we are considered a real-time merge to reduce human error.\n\n1.2 Thesis Objective\n\nThis thesis aims to apply a formal semantic approach and consistency constraints to build a real-time P3P aggregate system. The concept will aid service providers in an aggregation platform to merge and create a consistent P3P policy for service consumers. The first objective of this thesis is to find and resolve inconsistencies in the P3P language, and to properly summarize and categorize the privacy communication of P3P user agents. After identifying the inconsistencies, our next goal is to create merger rules or constraints for the P3P 1.1 specifications. The constraints will help create a new valid policy in an aggregation platform.\n\nOur next objective of this thesis is to explore the usage of our policy aggregate system. Specifically, we aim to bridge policy differences in composite services or aggregate services in the cloud. The concept will not only serve the purpose of applying machine enabled privacy policies (P3P) to service providers in the cloud, but also recognize the basic task of identifying inconsistencies in privacy policies.\n\nThe final goal of this thesis is to implement the concept in a way that supports the idea, and propose an account of the status of related research on P3P and directions for future research.\n\n1.3 Thesis Contributions\n\nIn this thesis, we propose a concept and framework to merge P3P policies of cloud service providers using an aggregation platform to serve the end users. The proposed concept will also detect inconsistencies in P3P policies and formally verify the merged P3P policies. The following are the major contributions of this thesis:\n\n- We use the P3P language to encode service providers’ privacy policies in a cloud-computing environment and we propose a concept and a framework that uses the three-way principle for aggregating P3P policies (chapter 6).\n• We extend the current P3P syntax using the concept of relative keys to set up a link between purpose, recipient and data items. We propose a relative data key concept to P3P in (chapter 5).\n\n• We propose P3PMatch, an algorithm for matching (mapping) elements in two or more privacy policies (chapter 5).\n\n• We carry out a formal relational modeling in (chapter 7), to find and solve inconsistencies in P3P using the Alloy model checker.\n\n• We implement the concept that performs a syntactic and semantic merge on different P3P policies in a cloud aggregation platform (chapter 6 and 7).\n\n1.4 Thesis Outline\n\nWe organized the rest of this thesis as follows:\n\nChapter 2 provides background information on policy languages including definitions and categories of related terms in the privacy policy topics. We also give some introductory information on P3P and user agents, including the syntax and semantics of the language, and discuss the P3P framework used in client/server architectures. Then, we present an overview of cloud computing, specifically the Software as a Service (SaaS) model. We also discuss an overview of the architectural design of the SaaS model and the aggregation platform for SaaS.\n\nChapter 3 discusses the related research on P3P privacy policies. In particular, it focuses on the status of the language, and the recent work on formal semantics and inconsistencies about the P3P language. We present an overview of some recent P3P user agents and techniques on composite policy in web services.\n\nChapter 4 describes the merging strategy and elaborates on the complete matching and merging process required for aggregating multiple P3P policies. This chapter states some desired merging strategy features, which we address in Chapters 5 and 6.\n\n8 Alloy is a relational model language for describing structures and a tool for exploring them as well. http://alloy.mit.edu/alloy/\nChapter 5 presents the proposed P3PMatch algorithm. In particular, this chapter focuses on introducing the relative data key notion, which consists of a pair (data-purpose and data-recipient) of data items. The notion semantically enhances the purpose and recipient information about a data item.\n\nChapter 6 discusses the concept proposed for merging P3P in a cloud aggregation platform. This chapter also presents the semantic merging constraints and an aggregation framework for P3P in the cloud.\n\nChapter 7 describes the software implementation of the P3P aggregation concept. This tool performs the validation test, matching processes, and performs a syntactic and semantic three-way merging operation of P3P policies.\n\nChapter 8 presents the conclusion, summarizes the contributions and implications, and proposes several future research directions.\nChapter 2\n\nBackground\n\nTo get a proper understanding of the P3P language and cloud computing services, this chapter provides basic definitions, and background information regarding the P3P policy language. In order to understand the P3P merger system, we give an overview of the predefined P3P vocabularies, the P3P user agents, and the cloud aggregation platform.\n\n2.1 Basic Definitions\n\nIn this section, we explain below, the common concepts and terms required to understand the research context of this thesis.\n\n2.1.1 Privacy\n\nA.F. Westin [80] described privacy as “the ability for an entity to control how, when, and to what extent personal information is communicated to other entities.” R. Agrawal et al. [4] described privacy as “the right of the users to decide for themselves when, how, and to what extent information about them will be communicated to other users.”\n\n2.1.2 Privacy Policy\n\nKumaraguru et al. [46] describes the privacy policy as “the formalization of an organization’s privacy promises in the form of a policy statement.” Nigusse et al. [58] later explained that the privacy policy has two different contextual meanings. They explained in the first context that, “the privacy policy can specify the user’s private information that providers collects and the rules that may apply to the information.” In the second context, “the privacy policy must specify the possible conflicts that may arise between users and service providers.” In this thesis, we categorize both defined policies to have the same meaning.\n2.1.3 Policy Language\n\nThe Policy language defines the standardized syntax and semantics needed to create and compare the user’s privacy preferences with the provider’s policies. These syntax and semantics make the privacy policies more machine-readable and enforceable [46].\n\n<table>\n<thead>\n<tr>\n<th>Privacy Areas</th>\n<th>Used By</th>\n<th>Privacy Languages</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Access Control Language (ACL)</td>\n<td>Service providers</td>\n<td>SAML, XACML, XACL</td>\n</tr>\n<tr>\n<td></td>\n<td>Clients</td>\n<td>XACML</td>\n</tr>\n<tr>\n<td>Web</td>\n<td>Service providers</td>\n<td>P3P</td>\n</tr>\n<tr>\n<td></td>\n<td>Clients</td>\n<td>APPEL, XPref</td>\n</tr>\n<tr>\n<td>Enterprise</td>\n<td></td>\n<td>CPExchange, PRML, E-P3P, EPAL, DPAL</td>\n</tr>\n</tbody>\n</table>\n\nTable 1: Classification of the Privacy Policy Language [46]\n\nKumaraguru et al. [46] describes various privacy policy languages and arranged those privacy languages in categories. They organized the privacy policy languages according to the area in which the languages are used. Table 1 illustrates a summary of how those privacy languages are classified.\n\n2.1.3.1 Policy Language Requirements\n\nPolicy languages are important tools in any privacy assured infrastructures. Machine-interpretable languages have a major advantage over natural languages. Bournez et al. [17] argues that the policy language tools are not designed properly, because they should allow automated negotiation, composition, and enforcement of different privacy policies. The following are the few requirements enumerated in [17] to develop standard privacy policy languages.\n\n- **Measurability** – To fulfill this property, the privacy language should allow one to confirm or verify the policy, and to test if the policy conforms to the instructions of the language.\n- **Unified Model** – The Data handling policies are closely related to the access control policies. Therefore, a unified model is a key success factor that should be present in the policy language.\n\n- **Semantic compatibility with P3P** – Other policy languages often should be compatible with the semantics of the P3P language.\n\n- **Revocability** – It must be possible for any policy maker to revoke the data handling policy, the same way it is possible to revoke a credential related to the access control policy.\n\n- **Transparency** – A service provider’s privacy policies must be able to express the data flow of collecting user data. Information should be provided on how they are transferred, and how they are kept.\n\n### 2.2 Platform for Privacy Preferences (P3P)\n\n#### 2.2.1 Introduction to P3P\n\nThe W3C (World Wide Web Consortium) has defined P3P in a pioneer web privacy project in 1995; the project is called the Platform for Internet Content Selection (PICS) [66]. The PICS privacy project started from a research laboratory at the Massachusetts Institute of Technology (MIT). The PICS project was the early standard name rating system for labeling web contents. The W3C later transformed the idea behind the project from rating and labeling the contents of web sites (PICS) into communicating websites’ data handling practices (P3P).\n\nThe P3P language is an XML specification defined by the W3C. The P3P platform is the protocol that allows policy file generated from a website’s privacy statement when encoded with the P3P language [43,54,62]. Some P3P editors (e.g. JRC Policy Workbench, IBM P3P Editor, P3Pwriter.com, or P3Pdeveloper.com) generate the P3P files that describe the privacy practices of a web site.\n\nWe refer to the privacy policy encoded with the P3P language as a P3P policy [24,25]. The W3C proposed the framework to automate the privacy policy verification processes. Figure 4 describes the workflow of the P3P framework. The following are the two requirements of the\nP3P framework. (1) The P3P specification requires that websites should publish their privacy policies using the P3P vocabulary [24]. (2) The P3P specification requires the users to specify their privacy preferences using a preference language called A P3P Preference Exchange Language (APPEL) [26].\n\n\n\n2.2.2 Retrieving P3P Policies\n\nThe standard Hypertext Transfer Protocol (HTTP) is the foundation of data communication for the P3P policies. The web browser uses the HTTP protocol to communicate with servers over the Internet, which enables the retrieval of P3P policies on the web browser. However, the web browsers or proxy servers parse and compare the retrieved P3P policies with the user’s privacy preferences. Figure 5 illustrates the complete HTTP transaction between the web browser and a P3P enabled website. In the next section, we will explain the P3P reference and the policy file.\n\n13\n2.2.3 P3P Policy Reference File\n\nFigure 6: An Example of P3P Policy Reference [24]\n\nThe P3P policy reference file is an XML file that points to a Uniform Resource Identifier (URI) where specific P3P policies on the web server are located. The policy reference file makes it easier for a user agent to find the privacy policies that applies to the specific web page. Figure 6 illustrates an example of the P3P policy reference file; Line 4 represents the Policy-Ref element that specifies the address for the P3P policy. To locate the site address (Figure 6; line 4) of the policy reference file, one can use the specified ways in the P3P specification [24]. The following are the three specified ways of retrieving the P3P policy from the web server.\n\na) A predefined address path helps to find the policy reference file (…/W3C/P3P.xml).\n\nb) Either through the website’s HTML link tag, or XHTML link tag.\n\nc) Through an HTTP header.\n2.2.4 P3P Syntax and Semantics\n\nP3P policy is a deployable subset of XML; the W3C as well as major corporations such as Microsoft, Yahoo and IBM supports the language [7,8,24]. A P3P policy consists of machine-readable assertions [24] about the website’s privacy practices written in a standard privacy vocabulary. There are two main classifications of P3P elements: the Body element and the Root element.\n\n\n\nIn the P3P language, each element (tag) may have lists of associated attributes with different values. The P3P elements and attributes are usually not variables but they have meaningful\npredefined names specified as P3P vocabularies [24]. Figure 7 presents an overview of the P3P syntax; the main elements contained in a P3P policy are all in the policy element. The policy element is the root element, which contains the combination of elements such as Extension, Entity, Access, Disputes-Group, and Statement elements.\n\n2.2.4.1 Policies Element\n\nThe POLICIES element is the root element of a P3P file, if the file contains one or more Policy elements. This provides performance optimization: a single HTTP request can collect many P3P policies in a single POLICIES, improving network traffic and caching. Policies can contain the following elements [24].\n\n- **Xml-Lang** - in the case of an HTTP request using “Accept-Language” property in the header tag.\n- **Expire** – optional expiration time length. Possible to define the absolute date of expiration or set relatively maximum age of policy in seconds.\n- **Dataschema** – defines embedded Dataschema.\n- **Policy** – Policies element encapsulates a set of policy elements.\n\n2.2.4.2 Policy Element\n\nThe POLICY element contains the complete privacy policy of an entity. The POLICY element must contain one ENTITY element to identify the legal entity responsible for the privacy practices. The element also contains one ACCESS element, one DISPUTES-GROUP and one or more STATEMENT elements. Figure 8 describes the POLICY element and its required child elements [24]:\n\n- **Name** (mandatory attribute): The Name attribute is the name tag given to the policy, used as a fragment identifier to be able to reference the policy.\n- **Discuri** (mandatory attribute): The Discuri attribute is the URI of the natural language privacy statement of the service provider.\n- **Opturi** (not mandatory): The **Opturi** attribute is the URI of instructions that users can follow to request or decline to have their data used for a particular purpose (opt-in or opt-out).\n\n```xml\n<POLICY name=\"\" discuri=\"\" opturi=\"\" [xml-Lang]>\n <ENTITY> ... </ENTITY>\n <ACCESS> ... </ACCESS>\n <DISPUTES-GROUP> ... </DISPUTES-GROUP>\n <STATEMENT> ... </STATEMENT>\n</POLICY>\n```\n\nFigure 8: Policy Element\n\n### 2.2.4.3 Entity Element\n\nThe **ENTITY** element provides the precise description of the provider responsible for the policy. It contains the provider’s name and some of the fields defined in the business dataset of the base data\\(^9\\) schema such as the contact address, and e-mail address\\([24,39]\\). As shown in Figure 9, a **DATA GROUP** element, which contains **DATA** element, extends the datatype reference mechanism.\n\n```xml\n<ENTITY>\n <DATA-GROUP>\n <DATA ref=\"#business.name\">XYX</DATA>\n <DATA ref=\"#business.online.email\">abc@ee.com</DATA>\n </DATA-GROUP>\n</ENTITY>\n```\n\nFigure 9: An Example of Entity Element\n\n### 2.2.4.4 Access Element\n\nThe **ACCESS** element indicates privilege given to an individual or any other user to access private information collected. The **ACCESS** element must contain only one of the following predefined values:\n\n- **Nonident**: The web site does not collect identifying data.\n- **All**: Access is given to all identified data.\n- **Contact-all-other**: Access is given to identified online and physical contact information as well as to certain other identified data.\n\n\\(^9\\) The P3P 1.1 specification; Business Data, http://www.w3.org/TR/P3P11/#business_data\n- **Ident-contact**: Access is given to certain identified online and physical contact information (e.g., Users can access things such as home address).\n- **Other-Ident**: Access is given to certain other identified data (e.g., users can access thing such as their online account charges).\n- **None**: No access is given to access identified data.\n\n```\n<ACCESS>\n <IDENT-CONTACT/>\n</ACCESS>\n```\n\nFigure 10: An Example of Access Element\n\n### 2.2.4.5 Disputes-Group\n\nA DISPUTES-GROUP element contains one or more DISPUTES elements in a policy. It describes dispute resolution procedures that the users may follow to resolve disputes about the service providers’ privacy practice. The DISPUTES element requires a resolution type (*Service, Independent, Court, or Law*), and the URI of the service to resolve the dispute page, the URL for verification, and should include the REMEDIES element, and the long and short description of the dispute.\n\n### 2.2.4.6 Statement-Group-Definition Element\n\nThe STATEMENT-GROUP-DEF element indicates the statement group tag that contains all the associated statement elements. It collects the statements elements together, based on a certain typical data representation.\n\n### 2.2.4.7 Statement Element\n\nThe STATEMENT element is a container that groups together a RETENTION element, a RECIPIENT element, a DATA-GROUP element, a PURPOSE element, and optionally a CONSEQUENCE element and one or more extensions. The STATEMENT element can contain a NON-IDENTIFIABLE element; which signifies that there is no data collected regarding the STATEMENT. However, the element will anonymize data which are collected. The websites that prefer to disclose separate purposes and other information for each category of data they collect can do so, by creating a separate STATEMENT for each DATA type.\n2.2.4.8 Non-Identifiable Element\n\nThe NON-IDENTIFIABLE element signifies that, either only anonymized data, or no data will be collected in the STATEMENT element.\n\n2.2.4.9 Purpose Element\n\nThe PURPOSE element describes the purpose or the main reasons for collecting private data. It must contain one or more inner purpose elements relevant to the collected data.\n\n- **Opt-out**: The tag requires explicit user rejection before removing the purpose or recipient options from their agreed policies.\n- **Opt-in**: The tag requires explicit user consent before adding the purpose or recipient options to their agreed policies.\n- **Always**: The tag does not require any rejection or consent from users; it means that users cannot opt-out or opt-in for data collection with this purpose.\n\nThere are 12 predefined purpose values used in the P3P Language, which are mostly self-explanatory:\n\n- **Current**: This purpose value represents data collected for the completion and the support of activities on websites, which data is required. The CURRENT element does not have a required option.\n\n For example, if a bus-scheduling website requires personal information such as home address and in return, the user gets the bus schedule, then the website has collected the address for current purposes.\n\n- **Admin**: The purpose value, admin, depicts the data collected for the purpose of technical support, or the website administration.\n\n For example, a website may collect data about users’ devices to improve the bandwidth optimization, and the communication systems. Thus, data collected for its purpose is tagged admin.\n\n- **Tailoring**: This purpose value allows private data to be collected for customizing a user’s need for a one-time visit to the website, which is not to be used for future purposes.\nFor example, if a website such as an online store collects information regarding the content of a user’s online cart, then the information will be used to tailor the website to other relevant information that the user may prefer.\n\n- **Develop**: Data is collected for research and development purposes alone, which does not include research on personal information of users.\n\n For example, a website may collect information regarding the sections of the website users’ visit often, or the browsing history of the user on the website.\n\n- **Pseudo-analysis**: Data collected is tied to a pseudonymous identifier to build reports for the purpose of research, analysis, and reporting on the website. The website collects only data that are not identifiable.\n\n For example, if the website wishes to understand the interest of users in different sections of the site, information tied to a pseudonymous identifier will be collected for the purpose of pseudo-analysis.\n\n- **Pseudo-decision**: Data collected is tied to a pseudonymous identifier to generate reports for determining the habits, interests or other characteristics of the individual to make decisions that directly affect users.\n\n- **Individual-analysis**: Data collected is used to determine the habits, interests or other characteristics of the user and to combine the private data with other identifiable data for the purpose of research, analysis and reports.\n\n For example, if an online store collects information to analyze how online shoppers make offline purchases in the physical store, data collected is used for the purposes of individual analysis.\n\n- **Individual-decision**: Data collected is used to determine the habits, interests or other characteristics of the individual and to combine the private data with other identifiable data to make a decision that directly affects the individual.\n\n For example, an online store suggests items a visitor may wish to purchase based on items he has purchased during previous visits to the website.\n• **Contact:** Data collected is used to contact users for the purpose of product or service promotion. This purpose value is only used for communication media other than voice telephone or web advertisements embedded in sites the user is visiting.\n• **Historical:** Data collected is archived or stored for the purpose of preserving social history as governed by an existing law or policy. This law or policy must be referenced in the **DISPUTES** element.\n• **Telemarketing:** Data collected is used to contact the users via a voice telephone call for promotion of a product or service. This does not include a direct reply to a question or comment, or customer service for a single transaction.\n\n### 2.2.4.10 Retention Element\n\nThe **RETENTION** element indicates how long the entity will keep collected information; it describes the category of retention value that applies to the data referenced in the **STATEMENT** element. The **RETENTION** element must contain one of the following pre-defined values: **no retention, stated-purpose, legal-requirement, or business-practices, indefinitely.**\n\n- **No-Retention** – Information collected from users are not retained for more than a brief period of time required for a single online interaction.\n- **Stated-Purpose** – Data collected is retained to meet the stated purpose for which the data were collected.\n- **Legal-Requirement** – Information collected is as required by law or liability under applicable law. The retention period is longer because of a legal requirement or liability.\n- **Business-Practices** – Information is retained under a service provider’s stated business practices.\n- **Indefinitely** – Information is retained for an indeterminate period of time. The recipient value when a retention value is indefinitely MUST be public fora.\n2.2.4.11 Recipient Element\n\nThe RECIPIENT Element indicates the entity that collects data and the agents that shares collected data. The entity must declare their recipients by using one or more of the following pre-defined values: Public, Other-party, Ours, Delivery, Same, and Unrelated.\n\n- **Public** – Public fora such as bulletin boards, public directories, marketplace, or commercial CD-ROM directories.\n- **Other-Party** – Legal entities following different practices: legal entities that are constrained by and accountable to the original service provider, but may use the data in a way not specified in the service provider’s practices.\n- **Ours** – Ourselves or entities acting as our agents, or entities for which we are acting as an agent. E.g. some specific department of our company.\n- **Delivery** – Delivery services possibly following different practices: legal entities performing delivery services that may use data for a purpose other than completion of the stated purpose. This should be used for delivery services whose data practices are unknown.\n- **Same** – Legal entities following our practices; legal entities who use the data on their own behalf under equitable practices e.g. business partner with equitable policies.\n- **Unrelated** – Unrelated third parties; legal entities whose data usage practices are not known by the original service provider.\n\n2.2.4.12 Data Group Element\n\nThe DATA-GROUP element encapsulates data types. Those data types specify which data is collected. The element must include one or more DATA elements.\n\n- **Data**: The element is used to specify the type of information collected; it has two attributes. The required attribute is ref (ref identifies the data collected by name), for example <DATA ref=\"#user.name.given\"/>`. The other attribute is optional; it indicates whether or not the data collection is optional, the required values are (Yes or No).\nIn the following figures, Figure 11 and Figure 12, there are examples of a natural language privacy policy translated into a full P3P privacy policy.\n\nAt Blue Yonder Airlines, we care about your privacy. When you browse through our site, we collect information on the efficiency and working of our Website. This information includes the number of times a web page is accessed, the browser used, and paths taken when moving through the Web site. We purge this information yearly.\n\nWe also collect your zip code but will prompt you to enter it. With your permission, this information is aggregated with information collected from all visitors to our Web site and used for market analysis. This information might be provided to third parties. Once prompted for your zip code, you will not be prompted again if your browser privacy preferences allow cookies.\n\nBlue Yonder Airlines use cookies (small files on your computer) to store whether you have entered your zip code or declined to do so. We access this information each time you visit our site so that you are only prompted the first time you visit our site.\n\nFigure 11: Sample natural language policy\\footnote{Microsoft Library: How to deploy P3P Privacy Policies on Your Web Site; http://msdn.microsoft.com/en-us/library/ms537341(v=vs.85).aspx}\nFigure 12: The corresponding P3P policy derived from the preceding natural language policy\\textsuperscript{11}\n\n\\textsuperscript{11}Microsoft Library: How to deploy P3P Privacy Policies on Your Web Site; http://msdn.microsoft.com/en-us/library/ms537341(v=vs.85).aspx\n2.3 Tree Model Structured Data\n\nThe organization of XML expresses the syntactical structure of documents, and the most important components of that structure are elements. Luuk Peters [50] stated that, “Considering XML documents a structured data tree, two trees can be compared together, equal nodes and equal sub-trees in both XML trees can be matched. The nodes and sub-trees that aren’t matched are the difference between the two XML trees.” In this thesis, we also consider P3P as a structured data tree.\n\nFigure 13 illustrates sample XML code; the root element is a node-indicating <student> and its closing tag </student>. The root node has one attribute associated with it: id with the value 7456. The content of the root element is the subject node, the score node, and the completed node. We will map XML documents to trees according to the following rules:\n\n1. The children of a node n are the elements and character data contained in the element corresponding to n.\n2. The content of a node corresponding to an element has a type value of the element, the student field is initialized to the name of the element (e.g. “Student” from the example above), and the list of attributes and values are initialized with the attributes and values of the element. The text field is empty.\n3. The content of a node corresponding to subject data has a type value of mathematics, and the text field is initialized with the character data.\n4. Content that is not character data or elements (such as comments) is not mapped to the tree.\nNodes, whose type field has the value element, are \\textit{element nodes}, and those whose type field is text are \\textit{text nodes}. Figure 14 shows the tree corresponding to the XML document in figure 11.\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Name</th>\n<th>Text</th>\n<th>Attribute and Values</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Element (root)</td>\n<td>Student</td>\n<td>Null</td>\n<td>Id = 7456</td>\n</tr>\n<tr>\n<td>Element (2)</td>\n<td>Subject</td>\n<td>Null</td>\n<td>Null</td>\n</tr>\n<tr>\n<td>Element (3)</td>\n<td>Score</td>\n<td>Null</td>\n<td>Null</td>\n</tr>\n<tr>\n<td>Element (1)</td>\n<td>Completed</td>\n<td>Null</td>\n<td>Null</td>\n</tr>\n<tr>\n<td>Text</td>\n<td>Null</td>\n<td>90</td>\n<td>Null</td>\n</tr>\n<tr>\n<td>Text</td>\n<td>Null</td>\n<td>Mathematics</td>\n<td>Null</td>\n</tr>\n</tbody>\n</table>\n\nTable 2: Table explaining XML document in Figure 13\n\n\\subsection*{2.4 P3P User Agents}\n\nA P3P User Agent is a tool or service that translates websites’ P3P policies into a complete human readable format. It also checks the website’s policies against the user’s preferences for privacy warnings \\([1,9,21,23,24]\\). The Microsoft Internet Explorer 6 (IE6) and the Netscape Navigator 7 were the first web browsers to adopt the P3P functionality. “A user agent’s action can range from showing a simple information message to blocking the requested web site \\([58]\\).” The P3P user agents assist users to specify their privacy preferences and can be classified into informative-only or automatic user agents; the former simply\ninform “whether website’s privacy policies match with user privacy preferences or not [58].”\n\nHowever, the P3P user agent can automatically take certain actions such as blocking cookies, or blocking access to certain web sites. The AT&T lab developed a P3P user-agent called the Privacy Bird [7,26,22,25]. Privacy Bird is a privacy extension for the Microsoft IE6; it allows users to specify privacy preferences. “A P3P compatible user agent might use the APPEL rule sets to express the user’s privacy preferences. However, a user agent can be compliant without implementing the APPEL rule sets [58,21,7].” A P3P user agent is a browser extension, a browser plug-in, a standalone user application, or any mobile platform that can run a browser.\n\n2.5 A P3P Preference Exchange Language (APPEL)\n\n2.5.1 Introduction of APPEL\n\nThe W3C specifically developed a language that complements the P3P1.0 language by encoding the users’ privacy preferences; this language is called APPEL [26]. An APPEL-based policy is the P3P counterpart on the client-side, used by the P3P user agents to automatically make privacy decisions on behalf of the user. The preference-rules (ruleset) group the privacy preferences specified by users. Figure 15 illustrates how a user can create the APPEL ruleset either manually or by interacting with an APPEL enabled user agent, which in turn automatically generates the APPEL ruleset [39].\n\n\n\nFigure 15: How users can create APPEL Preferences [26].\nThe APPEL policy consists of multiple \\texttt{RULE} elements, which specify user requirements for comparing P3P policies. \\textit{Behavior} attributes in the APPEL language specify the action taken upon successful matching of a \\texttt{RULE}; the three standard behaviors supported are \\textit{Request}, \\textit{Limited}, and \\textit{Block}. APPEL has a rule-based syntax encoded in an XML based language [26]. The following attributes describe the behavior output:\n\n- \\textit{Request} – The provided P3P policy that covers the URI is acceptable (the resource at the URI should be accessible).\n- \\textit{Limited} – The provided P3P policy is partially acceptable (the resource at the URI should be accessible with limitations).\n- \\textit{Block} – The provided P3P policy is not acceptable (access to the resource may be blocked).\n\n\\section*{2.6 Cloud Computing}\n\n\\subsection*{2.6.1 Introduction to Cloud Computing}\n\nCloud computing is the recent revolution in the Information Technology (IT) industry, following the personal computer revolution and the internet revolution. Chang et al. [20] pointed out that, “cloud computing not only matters for the IT industry, but also for technology consumers because its services are directly accessible to consumers over the internet.” Tim Grance and Peter Mell of the Information Technology Laboratory (ITL)\\footnote{ITL at the NIST promotes the U.S economy and public welfare by providing technical leadership for the nation’s measurement and standard infrastructure. ITL develops tests, test methods, reference data, proof of concept implementations, and technical analysis to advance the development and productive use of information technology [3, p.4].} at the NIST (the US National Institute of Standards and Technology) defined cloud computing in a NIST special publication 800-145 [55].\n\n“Cloud computing is a model for enabling convenient, on-demand network access to a shared pool of configurable and reliable computing resources (e.g., networks, server storage, applications and services) that can be rapidly provisioned and released with minimal management effort or service provider interaction.”[55]\nCloud computing resources are typically exploited by a pay-per-use model and the guarantees are offered by means of a Service Level Agreement (SLA) [81,12]. Cloud computing is not a “one-size-fits-all” technology. Rather it is a continuum of service delivery options, often referred to as Software as a Service, Platform as a Service, and Infrastructure as a Service. Figure 16 illustrates the platforms and models available in cloud computing.\n\n### 2.6.2 Cloud Service Models\n\nThe concept of cloud computing can be classified according to the resources or services offered by the CSP. “Cloud computing can be categorized into three basic service models; Software, Platform and Infrastructure as a Service. These service models describe the degree of control an enterprise will get from the CSP.” [20] Figure 17 illustrates a brief comparison of cloud computing models and traditional computing.\n2.6.2.1 Infrastructure as a Service (IaaS)\n\nIn the Cloud IaaS model, the CSP offers a platform virtualization environment as a service to the enterprise. “The CSP offers processing power, storage, networks, and other fundamental computing resources. The customer is able to deploy and run operating systems and applications but the control given to the customer is only for the operating systems, storage, deployed applications, and possibly limited control of the selected networking components like firewalls” [12,55]. Computing hardware resources described above provide services via the internet and users would typically obtain an instance of the computing or storage resource, and then connect to it remotely through the server available to them. Examples of IaaS are Amazon EC2, Flexiscale etc.\n\n2.6.2.2 Platform as a Service (PaaS)\n\nIn the Cloud PaaS model, “The customer is able to write their applications created using programming languages (e.g. Java, python) and tools supported by the provider of the cloud infrastructure. The consumer does not manage or control the underlying cloud infrastructure, but has control over the deployed applications and possibly application hosting environment configurations.” [12,55] Examples of PaaS are the Google App Engine, Force.com, etc.\n\n\n2.6.2.3 Software as a Service (SaaS)\n\nSaaS is a cloud-computing model for delivering software applications over the internet. “The consumer is provided with the ability to use the service provider’s applications hosted on a cloud infrastructure. The consumer is not usually concerned where the applications are running or where the data is stored” [55]. The applications in a SaaS model are accessible from various consumers’ devices through a thin generic client interface such as a web browser [49]. Some of the examples of SaaS are online webmail (Yahoo Mail, Gmail, etc.). “The customer does not manage or control the underlying cloud infrastructure, but may be able to set limited user-specific application configuration settings” [55,12].\n\n2.6.3 Cloud Deployment Models\n\nYang et al. [81] explained that cloud deployment models “can be delivered with four deployment models; public, private, community, and hybrid”. These deployment models describe who owns, manages, and is responsible for services. NIST [55] described the deployment models mentioned above, as follows:\n\n2.6.3.1 Public Cloud\n\nIn a public cloud, multiple service providers share delivered services or resources provided by a cloud service provider. “The cloud infrastructure is made available to the general public or a large industry group and is owned by a provider selling cloud services” [55]. The public can access resources remotely and quickly. Furthermore, they can only operate on the service they pay for.\n\n2.6.3.2 Private Cloud\n\nIn a private cloud, only one private enterprise can use the services and computing resources. “The cloud infrastructure is operated solely for an organization to manage on site or off premise. Resources in this model are dedicated only to the customer.”[55]\n\n2.6.3.3 Community Cloud\n\nIn a community cloud, several organizations can share the same cloud infrastructure. “The combination of several organizations jointly constructs and share the same cloud\ninfrastructure as well the same policies, requirements, values, and concerns.” An organization or a third party vendor can also manage the cloud infrastructure [55].\n\n2.6.3.4 Hybrid Cloud\n\nHybrid cloud combines multiple deployment models. “The cloud infrastructure is a composition of two or more clouds (Private, Community, or Public) that remain unique entities but are bound together by standardized or proprietary technology that enables data and application portability (e.g. Cloud burst for load-balancing between clouds)” [55].\n\n2.7 Service Aggregation Model\n\nIn this thesis, we consider the model of service aggregation presented in [78]. The diagram in Figure 18 illustrates the high-level architecture of service aggregation in a cloud-computing environment. For this thesis, we extend the types of parties presented in [78]. There are five types of parties in service aggregation in a cloud: users, service providers (SP), service aggregator (SA), aggregation platform, and cloud service provider (CSP).\n\n\n\n32\n2.7.1 Cloud Service Provider (CSP)\n\nA cloud service provider is a company, which offers some component of a cloud computing service model: Infrastructure as a service (IaaS), Platform as a Service (PaaS), or Software as a Service (SaaS). The following are examples of CSPs: The Amazon EC2, the Google App Engine, Open stack, GoGrid, and Microsoft Azure.\n\n2.7.2 Cloud Users\n\nDeepa et al. [28] expressed a cloud user, “as a person or entity that makes use of the cloud capabilities and services as opposed to the cloud service providers and cloud providers that supply those services.”\n\n2.7.3 Service Provider (SP)\n\nA service provider is an organization or an enterprise that purchases services (Software, Platform, or Infrastructure services) from the cloud provider. They enhance their own services and capabilities by exploiting cloud platforms from cloud service providers. The enhanced services can thus effectively become software as a service [16,28].\n\n2.7.4 Service Aggregator (SA)\n\nThe Service Aggregator\\(^\\text{13}\\) offers a web portal service or a platform that combines multiple cloud applications and SaaS offerings such as (e-mail, cloud storage, or hosted desktops) with similar characteristics (geographic area, target market, size, etc.) into a single point of access, format, and structure. Users derive the value of aggregate services from cost savings and greater efficiency found from the ability to leverage multiple service providers [68]. The service aggregator works as an agency for service providers to aggregate various services and policies offered by service providers, along with some of its own services and policies to serve users. The service aggregator is an entity that manages the service use, the\n\n\\[^{13}\\text{A cloud aggregator can also be referred to as a cloud broker; http://h30507.www3.hp.com/t5/Cloud-Source-Blog/Defining-cloud-service-intemediation-and-aggregation-IT-as-the/ba-p/122769.}\\]\nperformance, and service delivery to cloud consumers. Three types of aggregators are recognized.\\(^{14}\\)\n\n### 2.7.4.1 Service Intermediation\n\nThe service aggregator enhances a given service by improving some specific capacity and providing value-added services to the cloud consumer. The improvement can be managed access to cloud services, identity management, performance reporting, enhanced security, etc.\n\n### 2.7.4.2 Service Aggregation\n\nService aggregation combines and integrates multiple services offered by various service providers into one or more new services; the providers sometimes may be in a different domain from some of the organization's own services to form more complex and powerful services to serve users[72]. The service aggregator provides data integration and ensures the secure data movement between the cloud user and multiple cloud providers.\n\n### 2.7.4.3 Service Arbitrage\n\nService arbitrage is similar to service aggregation except that the aggregated services are not fixed. Service arbitrage means an aggregator has the flexibility to choose services from multiple agencies or providers. For example, the aggregator can use a credit-scoring service to measure and select a provider with the best score.\n\n### 2.7.5 Aggregation Platform\n\nThe cloud aggregation platform [78] “is a way to bring together different point solutions and services to address a single goal; it is much more beneficial to a single service provider or enterprise that has one service to offer.”\n\nOriginally, SaaS applications were mainly used by Small and Medium Business (SMB) for non-core business applications. Typical examples are Google Apps (an office suite, e-mail, calendar, etc.) and Salesforce (CRM). Recently however, large enterprises are increasingly\n\n\\(^{14}\\) Ibid.\nstarting to use SaaS for core business applications [51]. “SaaS is increasingly popular because it allows business to access specialist and complex services on demand, with no initial investment or ongoing maintenance required.” Service providers also benefit from SaaS by making their services available globally, dramatically increasing the potential customer base. An aggregation platform for SaaS is a single point of access that integrates and aggregates multiple SaaS and hosted service offerings. This platform enables service providers to accelerate revenue growth by providing SMBs and large enterprises with a “one-stop-shop” experience for multiple SaaS and hosted service offerings from a unified web portal access (Marketplace portal)16.\n\nAggregation platforms include: HP Aggregation Platform for SaaS (HP AP4SaaS)17, or Prevalent Cloud Services Aggregation Platform18, etc.\n\n- The Prevalent Cloud Services Aggregation Platform (Prevalent ONE) is a cloud-based solution that provides unified management of service providers’ compliance, applications, and security services19.\n\n- HP AP4SaaS eases the integration of IT/ Communication SaaS (CaaS) applications and other hosted services into the providers’ environment and expedites the delivery to individual customers20. Figure 19 illustrates an overview of HP AP4SaaS.\n\n---\n\n15 HP/INTEL project on Cloud computing (SaaS); HP Cloud Computing SaaS offering http://www.hpintelco.net/pdf/solutions/SB_HP_Cloud_Computing_SaaS_Offering.pdf\n16 A marketplace portal is a web based application where customers can discover, order, and manages services and products via a web browser.\n18 The Prevalent Cloud Services: http://www.prevalent.net\n19 The Prevalent Cloud Services: http://www.prevalent.net/index.php?option=com_content&task=view&id=110&Itemid=82\n2.8 Conclusion\n\nIn this chapter, we have discussed privacy policy techniques, the P3P language, cloud computing, and the cloud aggregation platform. We have overviewed P3P User agents and presented a summary of all the noticeable elements (vocabularies) in the policy language. We have also introduced the syntax and semantics of the P3P language. We have then discussed the P3P1.1 specification from the W3C.\n\nIn the following chapter, we will provide a review of previous research work in the areas of privacy languages, P3P consistency, and privacy policies in cloud computing.\n\n\\[21\\] Ibid.\nChapter 3\n\nRelated Work\n\nThis chapter presents the findings from the initial study that investigated current approaches for presenting privacy policies. It also summarizes and examines the related research work in P3P privacy policies by presenting analysis, existing semantic solutions, and a recent discussion on P3P user agents.\n\n3.1 Privacy Policy Language\n\nThe research area of privacy policies has made significant progress over the last ten years [46]. This includes remarkable research articles such as [24], which is an introduction to the P3P language. The research on P3P also helped facilitate the emergence of the Platform for Enterprise Practices (E-P3P) [11]. Ashley et al. [11] proposed the E-P3P language; E-P3P is designed for enterprises to create and enforce enterprise-related privacy policies. The other policy language includes the Enterprise Privacy Authorization Language (EPAL 1.2) [63]; EPAL is an interoperability language for exchanging privacy policies in a structured format between applications and enterprises. The EPAL architecture uses XACML as the structural language [2]. Agarwal et al. [3] proposed the Paranoid Platform for Privacy Preferences (P4P); this platform allows users to commit their data to an agent, and the agent then creates an alias of the data to be delivered to the service provider.\n\nIn addition to the research on privacy policy languages, the research also helped to develop policy user agents for web browsers. The user agent tool is used to produce a thorough analysis of machine-readable policies, compare privacy policies against user preferences and communicate a precise overview of the policy to the user. P3P user agents include products such as Privacy Bird [22,27,53], the user preference generator [45] etc. However, the majority of past research has focused on P3P inconsistencies [74], privacy enforcement and negotiations [2].\n3.1.1 Platform for Privacy Preferences\n\nIn 2002, the W3C released the P3P1.0 specification for website owners that collect sensitive data from users to express their data handling practices. At the initial stage of the P3P project, there were other attempts to express machine-readable policies such as EPAL. However, P3P is the most popular policy language [41,62] being used by large Internet companies like Yahoo™, Microsoft™, IBM™, etc. [7]. P3P 1.0 is a good research tool with multiple suggestions, solutions, and criticisms [38,7,61]. Cranor et al. [24] defined P3P1.1 as a working specification for P3P, after taking into consideration some of the suggestions in [74,71,19,38,42].\n\nIn addition to the fundamental problem of inconsistencies in P3P1.0, there have been research efforts to make P3P less prone to semantic errors. Yu et al. [82] addressed some of the semantic problems in P3P. As a solution, they proposed relational formal semantics and integrity constraints. For the purpose of this thesis, we will adopt some of the solutions provided in [82,43].\n\n3.1.2 A P3P Preference Exchange Language (APPEL)\n\nCranor et al. [26] published APPEL as the W3C recommendation for declaring user preferences; unfortunately, “there are subtle interactions between APPEL and P3P policy language that make APPEL extremely hard to use correctly.” Agrawal et al. [4] showed the limitations of APPEL with a series of plausible examples [5]. They proposed the X-Path Privacy Preference Language (XPref). XPref “retains the two outermost XML elements in APPEL: RULE-SET and RULE. However, rather than using the sub elements of RULE to specify an acceptable or unacceptable combination of P3P elements, XPref uses an X-Path expression for this purpose.”[4]\n\nBennicke et al [14] proposed an extension to the P3P framework and the user agent APPEL; the work aimed to provide better ways of communicating non ambiguous P3P policies via user agents, and the initiation of negotiation processes respectively. They also proposed concepts that enable service users and service providers to adapt their negotiation strategies.\n3.1.3 Formal Semantics for the P3P Language\n\nRecent research has shown that the P3P language has limited adoption by new websites and remains stagnant [59,25,10,27]. Some of the reasons why the global adoption of P3P seems slow are “there have been few incentives driving websites to embrace the policy format and there are no privacy regulations that require websites to express their privacy policies in the P3P format” [39]. Frequently, P3P policies may have syntactic or semantic errors, because they do not adhere to the P3P standard while constructing the policies [27]. Very few websites perform maintenance on their P3P policies because there is no law enforcing this process [7]. Another reason for the low adoption of P3P technology is that the tools do not accommodate other languages beside the English language. Lastly, P3P does not have precisely specified semantics and is not defined in such a way as to force specific policies to be attached to specific data items [82]. Papanikolaou et al. [62] described how formal modelling and verification can be applied to the analysis of privacy policies expressed in the P3P language; they discussed how to automatically generate a P3P policy using the Communicating Sequential Process (CSP) model.\n\nEven though a given P3P policy may be syntactically correct, Karjoth et al. [42] noted that the policy should also be semantically defined as well. They explained that the policy given should be able to answer the following questions: Can a given recipient use a given data element for a given purpose? What is the retention policy for some data?\n\nThey argue that if these questions cannot be answered on the basis of the given P3P policy, then the policy is meaningless. Cranor [21] recognized the semantic problem in P3P when using invalid combinations of P3P elements: purpose, retention, and recipient. An invalid combination thus makes the policy semantically inconsistent. Yu, et al. [82] identified many areas where potential conflicts may occur as a result of invalid combinations of P3P elements.\n3.2 P3P Inconsistencies\n\nIn the last few years, several papers have been published to show how semantic inconsistencies can arise in P3P policies due to a lack of correspondence between the values of P3P elements [82,21]. Yu et al. [82] argued that the following conflicts may occur as a result of the inconsistencies in P3P specification:\n\n3.2.1 Conflicts between multiple retention values and Datum\n\nThe P3P specification [24] allows a datum to be reusable or appear in multiple statement elements, which introduces semantic problems and allows one retention element for each statement element. For example, a datum cannot have two different retention values (e.g. no-retention, and indefinitely). However, this is possible when a datum appears in multiple statements that have multiple retention values.\n\n3.2.2 Conflicts between purpose and retention element\n\nA situation of conflict exists when a statement contains the purpose value (develop) and the retention value (no-retention). This introduces a conflict; no-retention allows data collected from users to be retained for a short period of time which is required for a single online interaction, but develop would require more retention time [82,44].\n\n3.2.3 Conflict between purpose and data category element\n\nAnother situation of conflict exists when a statement contains the purpose value (individual-analysis) but does not contain a data element from certain data categories: physical, online, financial, purchase or government. However, this does not correspond to the P3P specification since individual-analysis requires identifying data [82].\n\n3.2.4 Conflict between purpose and recipient element\n\nA situation of conflict also exists when a statement contains purpose values (admin, develop and/or tailoring) including recipient values (only, delivery, same, or public). However, this does not correspond to the P3P specification since specific purpose values and the recipient value, ours, must be present [82].\n3.2.5 Conflict between retention and recipient element\n\nThis conflict occurs when a statement has a defined recipient value that does not correspond to the retention value. For instance, a statement may contain the recipient value, *public*, and any retention value but *indefinitely* [82].\n\n3.2.6 Conflict from optional attributes\n\nWhere attributes expressing whether data, purpose and recipient elements are either *required* or *optional*, ambiguities may exist in the policy. For example, when data is *required*, and purpose and recipient are *optional*, it is unclear whether the entity will collect data. In cases where the STATEMENT-GROUP-DEF element is used, the value of these attributes must correspond to the value of the *consent* attribute [82].\n\nIn [73], the aim is to further classify the conflicts in P3P. Suntisrivarporn et al. [73] classified the policy conflicts into: (1) The syntax-based conflicts and (2) The pre-defined vocabulary conflicts.\n\n3.3 Semantic Approach to P3P\n\nKhurat et al. [43] introduces a semantic approach to solving inconsistencies in P3P policies. This research shows that one of the disadvantages of the P3P language is a lack of formal semantics. As a result, the error verifications only associate with the syntax check, which creates the possibility of ambiguities. Yu et al. [82] addresses the problem by identifying and formally describing semantic inconsistencies in P3P policies that have been addressed by researchers in this field of research. Ninghui Li et al. [59] proposed adding semantics to policies by translating them into a relational schema. If a P3P policy is translated into a semantic database the constraints would be violated, making the policy invalid. The semantic approach introduced in [82] focuses on handling semantic inconsistencies by using integrity constraints in the semantics. Such a set of integrity constraints can benefit both end users and websites. The concepts in [82,43] use semantic constraints to detect and fix inconsistencies in P3P policies. The following are integrity constraints to solve inconsistencies:\n\n41\n• Data-Centric Constraints - For example, three possible values for requirement are mutually exclusive (always, opt-out, opt-in). In data-purpose and data-recipient relations there can only be one requirement value. It is not semantically correct to have a data-type with a purpose that can be opt-out and at the same time is required always.\n\n```\n+ #user.home-info\n- #user.home-postal\n- #user.home-info.telecom\n- #user.home-info.online\n```\n\nFigure 20: Example of data hierarchy\n\n• Data Hierarchy Constraints – For example as illustrated in Figure 20, if the collection of #user.home-info is required, then it does not make sense for the collection of #user.home-info.online to be optional. However, it may be reasonable for the collection of #user.home-info to be optional, but the collection of #user.home-info.online to be required, which would mean that the collections of #user.home.info.postal and #user.home-info.telecom are optional.\n\n• Data-Purpose Constraints 1: For any two tuple data-purpose$_1$ (data$_1$, purpose$_1$, retention$_1$) and data-purpose$_2$ (data$_2$, purpose$_2$, retention$_2$), if data$_1$ is more specific than data$_2$ and purpose$_1$ = purpose$_2$, then retention$_1$ $\\geq$ retention$_2$. (Always $\\geq$ Opt-out $\\geq$ opt-in). They argued that similar constraints apply to the data-recipient relation and the data-collection relation.\n\n• Data-Retention Constraints 2: For any two tuple data-retention$_1$ (data$_1$, retention$_1$) and data-retention$_2$ (data$_2$, retention$_2$), if data$_1$ is more specific than data$_2$, then retention$_1$ $\\geq$ retention$_2$ (indefinitely $>$ business-practices, legal-requirement, stated-purpose $>$ no-retention).\n\nHowever, the integrity constraints explore only a subset of P3P policies; as shown above, listed constraints will not be able to discover any inconsistencies if P3P policies are merged.\n3.4 Related Research on P3P\n\nHalpern et al. [36] proposed reasoning about policies using first-order predicate logic. Choi et al. [79] later applied predicate logic to workflow security management; their security policy focuses on access control for a specific workflow, but the transformation from workflow into logic is not mentioned in their work. Glasgow et al. [33] proposed a formal framework for privacy policies called security logic, which applies modal logic to generic security policy considerations. He et al. [37] analyzed security policy integration between different application domains. They provided the requirements for policy integration and patterns. Satoh et al. [70] used security policies of the external services to solve inconsistencies. They showed how hard it is for policy developers to define composite policies by hand. The composition rules are not clear for maintaining consistency and the composite processes and policies are themselves complicated. They proposed a logic-based approach to composite security policies for an aggregate process. Khurat et al. [43] built on the early research work from [82,70] and they enhanced the P3P language to be able to support composite services by proposing a formal semantics for the P3P language to preserve semantic consistency and defined a method for combining privacy policies for composite services.\n\n3.4.1 Combining Privacy Policies\n\nKhurat et al. [43] defined formal semantic constraints for P3P policies in a composite environment. They assumed the P3P policies obtained from each service do not conflict with issues mentioned in section 3.1.4. They defined a combining mechanism and described some constraints to verify inconsistencies of privacy policies between service providers.\n\n3.4.1.1 Constraints for Integrity between services\n\nAdditional integrity constraints were introduced in [43] to solve the inconsistencies that may arise from combining multiple service policies. The following are brief explanations of the constraints.\n• **Multiple statement for a datum:** P3P specification [24] allows more than one STATEMENT element which declares the same data-purpose. Thus, multiple retention values may exist for the same data-purpose [43].\n\n**CONSTRAINT**\n\n\\[ \\forall p, q \\in DPRD, p.(data, purpose) = q.(data, purpose) \\]\n\n\\[ \\rightarrow p.\\text{retention} = q.\\text{retention} \\]\n\n• **Data Hierarchy:** With the P3P language, the data structure is hierarchical. It will not make sense if the upper level has more restrictions than its lower level.\n\n**CONSTRAINT**\n\n\\[ \\forall p, q \\in DPO, \\quad p.\\text{data is the upper level of q. data}, p.\\text{optional} = \\text{no} \\]\n\n\\[ \\rightarrow q.\\text{optional} = \\text{no} \\]\n\n• **Purpose and Data Optional Constraints:** If the purpose value of a data is CURRENT, the optional value of that data must be no since it is obvious that the website will collect data. Otherwise, the website will not provide the service [43].\n\n**CONSTRAINT**\n\n\\[ \\forall p \\in DPO, \\quad p.\\text{purpose} = \\text{current} \\rightarrow p.\\text{optional} = \\text{no} \\]\n\n• **Data Collection:** If data are needed to fulfill the service provisioning, then its collection must be required. Otherwise, this composite service cannot function.\n\n**CONSTRAINT**\n\n\\[ \\forall p \\in DPO, \\quad p.\\text{data} \\in \\text{shared.data} \\rightarrow p.\\text{optional} = \\text{no} \\]\n\n• **Purpose Element:** For the same reason, the PURPOSE values of these data must contain at least a current value with a required value such as always.\n\n**CONSTRAINT**\n\n\\[ \\forall p \\in DPR, \\quad p.\\text{data} \\in \\text{shared.data} \\rightarrow p.\\text{purpose} \\]\n\n\\[ = \\text{current} \\land p.\\text{required} = \\text{always} \\]\n3.4.1.2 Mechanism for Composite P3P Policies\n\nKhurat et al. [43,82] discusses the overview of data purpose-relation by using table 3; this table illustrates elements associated with different key relations.\n\n<table>\n<thead>\n<tr>\n<th>Relation Tables</th>\n<th>Fields</th>\n<th>Key of the relation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DPO</td>\n<td>Data Purpose Optional</td>\n<td>(Data, Purpose)</td>\n</tr>\n<tr>\n<td>DPR</td>\n<td>Data Purpose Required</td>\n<td>(Data, Purpose)</td>\n</tr>\n<tr>\n<td>DPC</td>\n<td>Data Purpose Category</td>\n<td>(Data, Purpose, Category)</td>\n</tr>\n<tr>\n<td>DPRD</td>\n<td>Data Purpose Retention Duration</td>\n<td>(Data, Purpose)</td>\n</tr>\n<tr>\n<td>DPRTR</td>\n<td>Data Purpose Recipient Third_Party_Service Required</td>\n<td>(Data, Purpose, Recipient, Third_Party_Service)</td>\n</tr>\n<tr>\n<td>Service-Entity</td>\n<td>Entity(#business.name) Access Dispute(resolution-type) Dispute( Remedies)</td>\n<td>Entity</td>\n</tr>\n</tbody>\n</table>\n\nTable 3: Khurat's Details of relation table [43]\n\n3.4.1.2.1 Data – Purpose – Optional (DPO)\n\nThe research [43] assumed that the P3P policy from each service is validated before combining the policies. The optional value of a data-purpose (dp) for a composite service must be only one value. n tuples from DPO (dp1, optional1), (dp2, optional2), ..., (dpn, optionaln) that have the same data-purpose (dp1=dp2= ... = dpn). They defined that optional values of the composite service are the most restrictive. This means that if at least one of the optional values is no, then the optional value of the composite service must be no. The following is a composite service rule for data-optional values:\n\n- No (means data is required) > Yes (means data is optional)\n\n3.4.1.2.2 Data – Purpose – Required (DPR)\n\nSimilar to the DPO explained above, the required value of a dp from each service must be only one value i.e. always, opt-out or opt-in. n (any real number) tuples from DPO (dp1, optional1), (dp2, optional2) ... (dpn, optionaln) that have the same data-purpose (dp1=dp2= ... = dp). The following is a composite service rule for the data – purpose required:\n\nAlways > Opt-out > Opt-in\n3.4.2 Related Approach to Merging Privacy Policies\n\nIn [30], Dong et al extended the proposed idea from [43] (section 3.2.1), they also adopted the two-way merging approach discussed in [56]. They used the approach to compare two different P3P policies. This merging process does not allow information from the semantic constraint discussed in [82] to be used when resolving conflicts. The merging algorithm introduced in [30] demonstrates how to put into practice composite privacy policies. However, the merging algorithm cannot determine whether the P3P policies used or the resulting P3P policy is semantically consistent. It also cannot match two or more P3P STATEMENT elements. For the purpose of this thesis, we adopted the following formal model of privacy policy and its elements.\n\n3.4.2.1 Formal Modeling of Privacy Policies\n\nAccording to the research presented in [57,30], Michael et al [57] presented a formal definition of privacy policy and its contents.\n\nDefinition 1 (Privacy Policy) “A Privacy Policy is a tuple of a vocabulary (Subject, Object, Operation, and Purpose), a set of authorization rules, and a default ruling.” Here Subject (S) is the set of end-users, Object (O) is the set of data, Operation (OP) is the set of operations performed and Purpose (P) is the set of data purpose. In [30], Dong et al. assumed that the components of a privacy policy (Pol) are called (Vocabulary (V), Rule sets (R), Authorizations (A)). For example, the following is a privacy policy that consists of a tuple of n rules, where ri is an instance of (V, R, A).\n\n\\[ Pol = (r_1, r_2 \\ldots r_n). \\]\n\nDefinition 2 (Vocabulary) “A vocabulary is a tuple \\( V \\in (S, O, OP, P) \\).” Authorization rules \\( A = \\{+, -, *\\} \\) denotes allow, do not allow, and do not care respectively; for entities and policy developers. \\( A = \\{+, -, *\\} \\) denotes require privacy information, do not require privacy information, and do not specify respectively, for policy users.\nDefinition 3 (Ruleset) “A ruleset \\((R)\\) for a vocabulary \\(V\\) is a subset of \\((I \\times S \\times O \\times OP \\times P \\times A)\\),” where \\(I\\) denotes an index set. In [30] an instance of a ruleset \\((rs)\\) is denoted by a complete \\(\\subseteq\\) of \\((i, s, o, op, a)\\).\n\n3.4.2.2 Semantics of Privacy Policies Aggregation\n\nDong et al. [30] presented a formal definition for policy aggregation and override rules. However, they assumed the policy statements relate to the data items.\n\nDefinition 4 (Policy Aggregation) “Assuming the \\(Pol_k = (r_{k, 1}, r_{k, 2}, r_{k, 3} \\ldots r_{k, n})\\) for \\(k = 1, 2\\ldots m\\; m\\) is a policy set. \\(r_{k, i}\\) denotes a ruleset for the policy.” Figure 21 denotes the aggregate privacy policy of \\(Pol_k\\).\n\n\\[\nPol(R_I) \\leftarrow \\bigoplus_{k=1}^{m} Pol_k(r_{k,i})\n\\]\n\nFigure 21: Equation for Aggregate Policy\n\nDong et al [30] denotes the generic aggregator operator as \\(\\bigoplus\\), which represents the union, intersection, differences, and conflicts depending on the properties of the policy rule. [30,43] used \\(\\leftarrow\\) to denote an assignment in a policy merging process.\n\nDefinition 5. (Policy Operations)\n\nTwo policies \\(A\\) and \\(B\\) are said to be related \\((A \\sim B)\\) if and only if they have associated policy properties, otherwise they are not related \\((A \\not\\sim B)\\).\n\nFor example, if both policies \\(A\\) and \\(B\\) are associated with gender, then the policies will be “related.” However, if \\(A\\) is about gender information and \\(B\\) is about driver’s license information, then they are “not-related.”\n\n\\[\nPol(A, B) \\leftarrow Pol_1(A) \\bigoplus Pol_2(B)\n\\]\n\n47\nThe rules in a privacy policy are subject to the following operations:\n\n- **Equivalent (\\(=\\)):** If two policy rules, \\(A\\) and \\(B\\), represent the same privacy policy, then they are equivalent; that is \\(A = B\\).\n- **Override (\\(>\\)):** If a policy rule \\(A\\) dominates another rule \\(B\\), \\(A\\) overrides \\(B\\) \\((A > B)\\).\n- **In Conflict (\\(< >\\)):** Given two related rules \\(A\\) and \\(B\\), if neither rule overrides the other, then they are in conflict or \\((A < > B)\\).\n\n### 3.4.3 Formal Modeling & Verification of P3P Policies\n\nIn the case of formal verification of privacy policies, the research is still ongoing to address the need to automatically discover or check for privacy violations [76]. A typical use of formal methods in privacy policies is to study the semantics of security policies, privacy policies, and access control policies. Using formal methods to model privacy policies has been an area of interest in the field of privacy policies for a substantial amount of time [31].\n\nGraham et al. [35] translates XACML policies into a simplified mathematical model. They interpreted mathematical models to logical expressions (*first order logic*). Logical expressions evaluate to be true if and only if the corresponding relation holds. Jackson [40] presents the logic with the type system, the syntax, and the formal semantics. He reported some case study applications of the analysis to check the consistency of a formula, and to check the validity of a theorem. The act of creating aggregate policy out of multiple policies may leave it vulnerable to unintended conflicts [35,52,34]. Graham et al. [35] used Alloy Analyzer to “automatically check the truth value of logical expressions.” They check whether a combination of privacy policies will faithfully reproduce the properties of its sub-policies, and thus discover unintended conflicts before the policies appear in the services.\n\n### 3.4.3.1 Formal Policy Languages\n\nThe privacy right of exclusion requires that the users know how service providers will use their sensitive information. Thus, providers must encode their practice into publicly available privacy policies [76]. Graham et al. [34] introduced “a formal model for XACML policies which partition the input domain to four classes: permit, deny, error, and not-applicable.”\nXACML is an XML-based language for expressing access rights to arbitrary objects that are identified in XML. XACML provides rules and policy combining mechanisms for constructing policies from rules and meta-policies from policies respectively.\n\nXiang [31] proposed Privacy Verification (PV), a framework built upon first order logic. He used the P3P policy language as a standard language because of its wide acceptance and its first order logic properties. “The policy language such as P3P, which has a formal notation, informs website visitors of the website’s privacy practices and enables automated methods for finding privacy-conscious sites. However, the P3P language lacks formal semantics”[24].\n\n### 3.4.4 Automated Tool\n\nOne of the advantages of formal methods is that formal specifications are amenable to machine manipulations and machine analysis (e.g., finding bugs or proving properties). Automation not only helps us catch human errors, but also enables us to scale up pencil-and-paper techniques [75].\n\n**3.4.4.1 Alloy Modeling System**\n\nAlloy [40] is a modeling language based on relational first order logic developed at MIT by Jackson and his team. Unlike a programming language, an Alloy model is declarative. This allows the construction and analysis of very brief and partial models. It is similar in structure to these formal specification languages: Z, B, etc. However, Alloy is amenable to a full automatic analysis in the style of a model checker.\n\nThe Alloy Analyzer is a tool that permits users to verify and analyze Alloy models. The alloy language is a structural and declarative language. Alloy models consist of sets of concrete objects, called *signatures*. The signatures contain *facts* and *relations* about the *sets*. \n\n\n3.5 Conclusion\n\nIn this chapter, we have discussed related research work in privacy policies and in formal semantic policy research areas. We have provided an overview of some existing solutions and the on the limitations of the P3P language. We talked about the existing constraints used to develop a formal semantics for the P3P language. We have described different conflicts that may arise due to inconsistencies in P3P specifications. In addition, we have mentioned the current solutions to combine privacy policies in composite services and improvements in the research area of the P3P Language. Finally, the Alloy Analyzer and other related work on formal modeling of privacy policies were discussed.\n\nIn the next chapter, we will begin our introduction to the merging strategy, which specifies the requirements and desired features for the P3P merger system. We will use the three-way merge principle to specify how the merger system should perform its task.\nChapter 4\nMerging Strategy\n\nThis chapter presents the merging processes required to aggregate P3P policies. It states some requirements and desired features that must be satisfied when merging privacy policies. Furthermore, we divided the merging strategy into four different logical processes. Lastly, this chapter defines the P3P merging problems that may occur while merging policies.\n\n4.1 Overview of Merging Strategy\n\nBased on the various ways [18,15,77] in which structured data have been previously analyzed for XML merging processes, we adopted some of the techniques and requirements used in [18,15,77] to form a complete merging strategy. However, to create a consistent aggregate P3P policy, there are some additional requirements that have to be satisfied. Those additional requirements should be in agreement with the P3P specification. First, we need to match the P3P policies to detect the conflicts that may occur during the merging process, and to establish a logical relationship between the STATEMENT elements in the policies. The most important requirement for the merging process is to avoid data duplication and data loss when creating the new policy.\n\n4.2 Requirements for P3P Merge Process\n\nThis section introduces the merging strategy for aggregating P3P policies. To create a P3P policy, one needs to revise the P3P schema\\(^\\text{22}\\) in a manner that agrees with the data handling practices of the provider and the P3P 1.1 specification. Because the P3P specification allows the usage of one or more STATEMENT elements in a P3P policy, a given P3P policy may have a structure that varies from other P3P policies. Figure 22 illustrates a scenario where P3P policies have different statement structures. Since services have different privacy practices, merging two or more P3P policies may lead to a conflict. Figure 23 illustrates the merge process involved in aggregating multiple P3P policies.\n\n\\(^{22}\\) http://www.w3.org/TR/p3p-rdfschema/\nLuuk et al. [50] discusses several merging algorithms which handle the structural merging process in a syntactic manner. Merge algorithms use different amounts of knowledge about the language to merge source code from the language. The following sections present an overview of the merging algorithms.\n\n4.2.1 Text-Based Merge\n\nTraditional merging algorithms are the foundation of the textual merge techniques. “This gives high flexibility to the merging process, since any structured data can be treated as a text file” [50]. The text-based techniques aggregate texts in parallel to their programming languages. For example, the text-based merging algorithm detects parallel modification such as insert actions, delete actions, and changes of a text line in a syntactical manner. The main disadvantage of a text-based merging algorithm is that it identifies only very basic conflicts which involve text errors. This drawback is due to the lack of structured syntactic and semantic knowledge. The text-based merging algorithms do not take into account the syntax and semantics of the language in which text streams exist. To build a policy-merging algorithm, the text-based merging techniques will not fully capture the consistency we wish to accomplish while merging P3P policies.\n4.2.2 Syntactic Merge\n\nThe syntactic merging algorithms use language-specific knowledge and can therefore evaluate and merge structured data better than the text-based algorithms. The techniques take into account the syntax of the language of the texts before merging. The underlying data structure for syntactic merges are usually trees, which requires the merge tool to parse the data in advance and generate the corresponding trees. However, Philipp [65] stated that the main problem with syntactic mergers for policy merging is that it lacks semantic interpretation of the structured trees.\n\n4.2.3 Semantic Merge\n\nThe semantic merging techniques address sets of conflicts that are not detectable by the syntactic merge algorithms. To detect and correct these kinds of conflicts, the merging algorithms must obtain more information about the semantics of the language. The P3P schema and specifications provide semantic information that the semantic merging algorithms need. In our work, we will use both the semantic and syntactic merging algorithms.\n\n4.3 Merging Strategy\n\nMerging pairs of privacy policies is usually an interactive task. However, the entire merging process in this thesis consists of different tasks, which trigger automatically. We utilized the three-way merge principle (section 4.3.3.2) while merging the P3P policies with the P3P schema defined by the W3C, in order to avoid some syntactic conflicts that may occur. In the cloud aggregation platform, the aggregator may have no chance to modify and merge all the P3P policies. The only way is to use normal editing operations and to make merging decisions automatically. Sometimes it is necessary to undo the decisions because the solutions of a merged policy may imply a different meaning from what the service policies intended. The aim is not just to merge P3P policies, but to merge the policies with additional merging instructions (semantic merging). Therefore, the merging process in Figure 23 consists of five main steps altogether: 1) retrieving the P3P policies from service providers;\n2) P3P policy validation and conflict detection; 3) P3P policy match detection; 4) merging P3P policies and solving conflicts, and finally 5) creating the merged P3P policy.\n4.3.1 Policy Validation and Conflict Detection\n\nAs shown in Figure 23, the P3P policy validation and conflict detection steps are required in the merging process after uploading the P3P policies. We use the validation process to check if the P3P policies agree with the P3P1.1 specification [24]. Instead of our own validation scripts for retrieving and validating P3P policies, we adopted the P3P Validator\\(^{23}\\) developed by W3C.\n\nThe P3P Validator checks policies for compliance with P3P1.1 using the following steps\\(^{24}\\):\n\n- **Access**: The Validator checks if the Internet can access the policy URI, using the HTTP GET method.\n\n- **Syntax**: Checks if the syntax of the policy is correct using the following sub steps: 1) checks if the policy is well formed as an XML document. 2) Checks if the policy has the correct namespace URI for P3P. 3) Checks the root element of the policy file if it is either POLICY or POLICIES. 4) Checks the policy if it conforms to the XML schema for P3P\\(^{25}\\).\n\n- **Vocabulary**: Checks if the P3P data item in the `<DATA ref= “…”>` directives are included in a P3P base data schema.\n\n- **Link**: checks if the URI references included in the policy are accessible. The Validator checks for the following:\n 1) Discuri and Opturi (attributes of `policy` element)\n 2) Service (attribute of `disputes` element)\n 3) SRC (attribute of `img` element).\n\nAfter detecting the validity of P3P policies, some valid P3P policies might remain inconsistent and semantically incompatible for merging. P3P Validator may fail to identify such policies because it lacks semantic information on of the P3P language. For example, the\n\n---\n\n\\(^{23}\\) The W3C P3P Validator is available as a free service at [http://www.w3.org/P3P/validator](http://www.w3.org/P3P/validator). It was implemented in Perl by Yuichi Kioke and Shojima Taiki.\n\n\\(^{24}\\) Ibid.\n\n\\(^{25}\\) [http://www.w3.org/TR/p3p-rdfschema/](http://www.w3.org/TR/p3p-rdfschema/)\nvalidator cannot detect if two service providers have different policies that collect separate data items, purpose values, and retention values with their relationship. However, the lack of semantic verification may cause inconsistencies to occur in an aggregate policy. Therefore, the result of an aggregate policy may be inconsistent, as discussed in section 3.1.4. Therefore, we adhere to the constraints discussed in section 3.2.1 on how to apply constraints to P3P policies, and to avoid or detect policy inconsistencies.\n\n4.3.2 P3P Match Detection\n\nIn order to merge multiple P3P policies, it is essential to compare them, so as to identify the differences and similarities. The match process is crucial to produce a quality aggregate policy. The problem of matching P3P trees is concerned with constructing a semantic match between two policy trees (for example A and B in Figure 24 below). The solution to the problem will be given in section 5.3.1.\nFigure 24: P3P Tree matching problems (P3P A and B)\n\nP3P match detection means that we have to recognize similar elements (for each elements e.g. STATEMENT, DATA, PURPOSE etc.) in all the policies to be merged. This process is the match operation. Every element in XML needs an identifier by which it can be recognized, and the P3P specification provides an element name for all tags [24]. In order to have a consistent merge, we will consider two ways to match the policies.\n\n- We will apply the syntactic match: if the *element name* of a given node is equal to the element in the same tree level. In other words, if the P3P policies have the same *name* and contents, so we have a match.\n\n- We will also apply the semantic match: if the *element names* are equal but the contents are not semantically and syntactically equal. In this case, we will need a matching algorithm which recognizes the similarities between the contents of the policies.\nBefore applying the match algorithm, the semantic and syntactic inequalities between elements that have equal names may indicate match problems. A match problem may arise if corresponding nodes in both tree tags have the same \\(<E\\) node> name; see Figure 24. Figure 24 illustrates that two different \\texttt{STATEMENT} elements may exist in P3P \\texttt{B}, and only one statement in P3P \\texttt{A}. The description may result in a semantic match problem; because the corresponding data nodes in the P3P tree for \\texttt{B} may not be identical to \\texttt{A}. Matching both trees will result in a policy conflict or change the meaning of the aggregate policy from what the providers intended. The existing match mechanisms and P3P specification will often recognize elements using their similarities. These match problems and the need for a semantic match leads us to the conclusion of modifying the \\textit{data element} in the P3P language. We introduced two attributes to the P3P specification to enhance the semantic match operation. This will be explained in chapter 5.\n\n\\textbf{4.3.3 P3P Merge Process}\n\nIn this sub-section, we will describe a possible way to perform a merge process based on the P3P specification, which satisfies the syntax and semantic specifications of P3P. As illustrated in Figure 23, the order is important because each step requires an output from the previous step. In [50] a few methods for merging unordered trees and identifying conflicts are outlined. For achieving a semantic and syntactic merge, we considered a three-way merge over two-way merge. The following sub-sections will provide a brief overview to both merge principles previously mentioned.\n\n\\textbf{4.3.3.1 Two-way Merge}\n\nThe Two-way merge Principle [48] performs an automated merge between two different versions of XML files by comparing the two XML files without the need of any other information from the language specification or semantics. Consequently, the differences between the two XML files may lead to policy conflicts when merged because the result was not semantically analyzed.\n\nFigure 25 shows how the two-way merge principle operates; the elements extracted from \\textit{File A} and \\textit{B} are directly merged together to generate a new file with some shared attributes.\nFor example, the P3P merged result from a two way merge may be error prone or may require additional verification to correct the policies prior to completing the merge operation.\n4.3.3.2 Three-Way Merge\n\nThe three-way method takes two replicas of an XML document into account and thus has more information about the syntax and semantics at hand to decide where a modification is required and whether the aggregate result can create a policy conflict or not. As Figure 27 illustrates, the three-way merge method needs three files: the original file (the P3P schema) and two different files $A$ & $B$. The two files were modified from the original file independently; this means they have the same pool of semantic and syntactic rules.\n\n\n\nFigure 27: Three-Way merge Principle, [50]\nThe original file compares separately itself with the modified files; the differences achieved from those files \\((A \\text{ and } B)\\) are gathered to create the change file. The change files describe the modifications to the original file to create files \\(A\\) and \\(B\\). The result of the \\textit{combine change} stage merges with the original file to produce a merged file which contains all modifications from \\((A \\text{ and } B)\\).\n\n\n\n**Figure 28:** Three-Way merge operation on P3P policies\n\n### 4.3.4 Creating New Policy\n\nIn producing a new policy from the merging process, we took into consideration that the merged policy should be symmetric and should avoid data loss. When generating the new aggregate file, we highlight and show a brief report of where changes and merges were done; this allows the aggregator to manually override any decision.\n\nThe merge process for aggregating P3P should be reputable. If we perform the merging process on different P3P policies several times, we should always obtain the same output.\nMoreover, it should be symmetric in the sense that the aggregate result should depend neither on the order of the elements in the policy nor on the order of match detection. For example, if we load policies $A$ and $B$ into a merge process, the result should be the same as if we had loaded policies $B$ and $A$.\n\n4.4 Conclusion\n\nIn this chapter, we have presented the steps required for our P3P merging strategy and the matching and merging processes required to aggregate multiple P3P policies. We have also presented an overview of the merging strategy, which describes the features and requirements that must be satisfied when aggregating privacy policies. We described the common merging methods that are used in aggregating structured data (e.g. the text based merge, the syntactic merges, and the semantic merge). We have discussed the differences amongst the merging methods by illustrating examples where they are most useful. This chapter also elaborates on the merge principles: the two-way and the three-way principles.\n\nWe have introduced the P3P merging strategy, the merge processes (the policy validation and conflict detection, the P3P match detection, the P3P merge process, and formulating a new P3P policy). Merge processes consist of different tasks, which trigger automatically. We have adopted the 3-way merging principle, which consists of both semantic and syntactic merge methods.\n\nIn the next chapter, we will introduce the P3P match algorithm; the algorithm that finds the similarities and relationships amongst P3P elements. We will present the tree structure of the P3P language using the Document Object Model (DOM) representation of W3C. We will define and use match types to classify the similarities amongst P3P elements.\nChapter 5\nThe P3P Matching Algorithm\n\nThis chapter introduces the P3PMatch algorithm. Prior to the merging phase, we first detect the differences and similarities amongst the P3P elements. The matching algorithm finds the relationships amongst the P3P STATEMENT elements. We introduce a notion called the P3P relative data key, which consists of two pairs (data-purpose and data-recipient) for the P3P DATA element. This notion will semantically enhance the matching algorithm to detect the PURPOSE and RECIPIENT elements that relate to a DATA element; this will improve the quality of matching for multiple P3P policies.\n\n5.1 P3P Match Prerequisites\n\nIn this section, we introduce the prerequisites for the P3P matching phase. To satisfy the objective of this thesis, we need a matching algorithm that can iterate through multiple P3P elements to identify matching P3P elements. The matching process is one of the four main stages of the merging strategy discussed in (Section 4.3). We introduce matching prerequisites that must be satisfied when matching policies. The following are the two prerequisites to be considered:\n\n- Structural prerequisite: Prior to matching policies, it is very important to understand the structure of the policy. The algorithm should be able to model the exact number of elements, attributes, and contents of the policies.\n\n- Semantics prerequisite: To improve the quality of our algorithm, we consider the P3P semantics when detecting the similarities and differences in P3P policies. To attain the accurate semantic matching property in the P3P matching algorithm, we introduce the notion of P3P relative data key (section 5.3).\n5.2 Tree Structure of the P3P Policy\n\nThe format of XML files is hierarchical and it can be represented as a tree structure [6,77]. Section 2.3 shows the tree model of a sample XML document. In order to design an efficient merge system for the P3P language, we need to detect the differences and similarities in the policy elements. Since the match detection is an important phase in merging P3P policies, it is also necessary to understand the hierarchical structure of the P3P policies. Considering the structure of XML, it is reasonable to use either trees or graphs as the underlying data structure of the P3P language. However, for the purpose of this thesis, we will represent the structure of P3P policies as trees.\n\n5.2.1 Document Object Model (DOM)\n\nThe W3C Document Object Model (DOM) is a “platform and language-neutral interface that allows programs and scripts to dynamically access and update the content, structure, and style of a document.”\n\nThe Document Object Model (DOM) [64,6] provides some insight into the semantics for XML documents. According to the survey on DOM, a document is a hierarchical structure of nodes. Nodes are of several types, but the following are the most important for P3P:\n\n- Element node: element node (E node), which has a label (name) only; the element node may have children.\n- Attribute node: attribute node (A node), which has a label and carries text.\n- Text node: text node (T node), which has no label but carries text; attribute and text nodes are terminal nodes.\n\nFor Example, we represent the element (E), attribute (A), and text (T) nodes as a tree in Figure 30. The sample P3P code presented in Figure 29 corresponds to the tree described in Figure 30.\n\n26 W3C Document Object Model (DOM) http://www.w3.org/DOM/\nFigure 29: A sample P3P code\n\n![Tree diagram]\n\nFigure 30: Tree corresponding to the P3P Code in Figure 29\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Name</th>\n<th>Text</th>\n<th>Attribute and Values</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Element</td>\n<td>Policy</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element</td>\n<td>Statement</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element</td>\n<td>Purpose</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element</td>\n<td>Recipient</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element</td>\n<td>Retention</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element</td>\n<td>Data-Group</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element</td>\n<td>Pseudo-Analysis</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element</td>\n<td>Other-Recipient</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element</td>\n<td>Indefinitely</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Element/Attribute</td>\n<td>Data</td>\n<td>-</td>\n<td>ref="#user.home-info.postal.postalcode"</td>\n</tr>\n</tbody>\n</table>\n\nTable 4: Node tables to explain the P3P code in Figure 29\n5.3 The P3P Relative Data Keys\n\nIn a database, constraints make it possible to enforce restrictions on attributes [64]. For instance, “a constraint can restrict a given integer attribute to values between 1 and 10”. The essential parts of a database are the keys (primary and foreign keys). The keys provide the means by which one tuple in a relational database may refer to another tuple; they are important for updates, for they enable us to guarantee that an update will affect precisely one tuple. Peter et al. [64] explained that with the id attribute in the Document Type Definition (DTD), one can uniquely identify properties of an element within an XML file.\n\nWith the same idea in [64], the PURPOSE, RECIPIENT elements and their attributes in the P3P language would only help identify the set of service purposes and recipients declared by the service provider. However, there is no connection that can help the P3P language identify the relationship between the PURPOSE and RECIPIENT elements.\n\nIn our solution, we consider the PURPOSE and RECIPIENT values in P3P as key relations to the data type collected. By doing so, we are not assuming that every data-type listed in a policy will have its own statement element.\n\n```xml\n<STATEMENT>\n <PURPOSE>\n <pseudo-analysis/>\n <current/>\n <contact required = 'always'>\n <telemarketing/>\n </PURPOSE>\n <DATA-GROUP>\n <DATA ref= \"#user.name.firstname\"/>\n <DATA ref= \"#user.address.postal\"/>\n <DATA ref= \"#home-info.telecom.mobile\"/>\n </DATA-GROUP>\n</STATEMENT>\n```\n\nFigure 31: Example of Multiple Purposes and Data\n\nFigure 31 shows an example of a STATEMENT element with three data items (#user.name.firstname, #user.address.postal, and #home-info.telecom.mobile) to be used for the following purposes (pseudo-analysis, current, contact, and telemarketing). According to the P3P specification [24], one cannot allow data items collected for the PURPOSE of\ntelemarketing to be used for contact. Moreover, the P3P user agent will not be able to identify how those purposes relate to the various data items. The P3P code in Figure 31, depicts that the statement element can collect the data item in the data-group element, and the data can be used for the purposes in the purpose element. The example described above does not clearly state how to connect the relationships that exists in a data item, and its recipients or purposes. Finally, in agreement with the P3P specification, one can specify purpose values in statement elements that have nothing to do with a data type collected. In this thesis, we modified the XML key notion defined in [64] to improve the relationship of data items to its purposes and recipients. For example, data element listed in Figure 31 can uniquely have a target purpose (datapurpose) and recipient (datarecipient) that will identify a set of purposes and recipients in the P3P language.\n\n5.3.1 Definition of Relative Data Key\n\nA path is an expression involving element names (tags and attribute names) that describe a set of paths in the structured document or file [64,69]. In defining a data key, we specify the attribute (a relational terminology for purpose and recipient values) that when used together can uniquely identify the purpose and recipient values of collecting a particular data item.\n\nTo describe hierarchical key structures, we introduce the notion of a relative key discussed in [64,77]. The notion consists of a pair (Q, K) where:\n\n- Q is a path and\n- K is a key\n\nQ consists of Data-Purpose (DP) and Data-Recipient (DR). We specified the target element and attributes to follow the syntax in [64].\n\nWe define the relative key as\n\n\\[(K: (DP, \\{P_1; \\ldots; P_n\\}, DR, \\{R_1; \\ldots; R_n\\}))\\]\n\nwhere \\(K\\) is the name of the key. The key is the data item collected, path expressions DP and DR are the sets of purpose values and recipient values respectively, and \\(P_1; \\ldots; P_n\\) and \\(R_1; \\ldots; R_n\\) are the key paths.\nThe idea is that the path expression DP (datapurpose) identifies a set of PURPOSE values and DR (datarecipient) identifies a set of RECIPIENT values. The Ref is an attribute name in the DATA element that identifies the data collected. The goal of relative data keys is to specify the purpose and recipient values in a DATA element.\n\nWe express a sample P3P DATA element that uses the relative data keys as follows. For example, from Figure 32 a data element with ref value \n\n```\n<Data ref=\"#user.home-info-postal\"\n\ndatapurpose = {current; contact = ‘always’}, datarecipient = {ours}>\n\n</Data>\n```\n\nThe P3P tree in Figure 33 illustrates an example of how we represent the relative data key syntax in Figure 32.\n5.4 P3P Match Algorithm\n\nIn this section, we present \\textit{P3PMatch}, an algorithm to match corresponding elements in two different versions of P3P trees. We base this algorithm on the P3P relative data key explained in the last section. The P3PMatch algorithm is designed to complete its operation before the merging operation. Figure 34 depicts the P3PMatch architecture.\nAccording to the general tree matching principle defined in [60], “Let $X$ be a tree and $X[i]$ be the $i^{th}$ node of $X$ in an ordered walk through the tree.” The match between the nodes of a tree is a set of elements, attributes, and text-nodes that connect the corresponding nodes in both trees. We measure the correspondence by comparing the contents (elements, attributes, and text-nodes) of both P3P nodes [64,67,48].\n\n**Definition P3PMatch:** A matching between two policy trees (A and B) is a set of nodes $(p, q)$, $p \\in A$, and $q \\in B$,\n\nWhere $p$ and $q$ are equal by leaf nodes (content, name, or attribute). We denote matches in this thesis with the letter $M$, with optional subscripts that connect the P3P trees involved in the match. For example, $M_{AB}$ represents the matching operation between the P3P trees: A and B.\n\n**5.4.1 P3PMatch**\n\nThe P3PMatch algorithm receives as input two P3P trees, A and B, where two sets of data keys $\\Sigma K$ exist in A and B. The algorithm outputs a set of node pairs $\\Sigma N$ after matching.\n\nFor example, $\\Sigma N$ contains nodes $p$ and $q$, where node $p \\in A$ and node $q \\in B$. To identify $\\Sigma N$ from the P3P elements POLICIES, POLICY, ACCESS, ENTITY, and DISPUTE-GROUPS, we compare the element names at every stage to find matching elements. However, when both policies have two or more STATEMENT elements, we use the relative data key set $\\Sigma K$ to find the closest STATEMENTS to match. The set $\\Sigma N$ will be the input of the merging algorithm, which aggregates the elements in the set $\\Sigma N$.\n\n**5.4.2 Matching Similar P3P Elements**\n\nMatching nodes: Given matches $M_{AB}$, the P3P elements $p \\in A$ and $q \\in B$ are matched if and only if the labels for elements $p$ and $q$ are equal and if $p$ and $q \\in M_{AB}$. For merging, we use the match function to detect the changes and the similarities in different P3P policies. By inspecting the P3P policy structure and its relative data keys, we identify the changes that\ntransform a P3P schema into a P3P policy and we can detect the similarities in similar policy STATEMENT elements.\n\nTo match the P3P policies effectively, we divide the matching procedures into three different parts.\n\n- **Text Match**: Two elements \\( p \\in A \\) and \\( q \\in B \\) match only by the text contents, if the nodes \\( (p, q) \\in M_{AB} \\) are of type text node, where \\( p \\) and \\( q \\) are related contents of P3P elements. For example\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n</table>\n| \\(<\\text{Statement}> //\\text{Statement}\\<\\text{Consequence}>\\> \\>\n| \\(<\\text{Retention}> //\\text{Retention}<\\text{ours}>\\>\\> \\>\n| \\(<\\text{End Retention}> //\\text{End Retention}\\>\\>\\> \\>\n| \\(<\\text{Statement}> //\\text{End Statement}\\>\\>\\> \\>\n| \\(<\\text{Statement}> //\\text{Statement}\\<\\text{Consequence}>\\>\\> \\>\n| \\(<\\text{Retention}> //\\text{Retention}<\\text{Indefinitely}>\\>\\> \\>\n| \\(<\\text{End Retention}> //\\text{End Retention}\\>\\>\\> \\>\n| \\(<\\text{Statement}> //\\text{End Statement}\\>\\>\\> \\>\n\n**Figure 35**: Example of Text Match\n\n- **Label Match**: Two nodes \\( p \\in A \\) and \\( q \\in B \\) match only by the structure of the elements, if the nodes \\( (p, q) \\in M_{AB} \\) are of the same structure type, where \\( p \\) and \\( q \\) are related elements syntactically. For example\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n</table>\n| \\(<\\text{Statement}> //\\text{Start Statement}\\<\\text{p}>\\>\\> \\>\n| \\(<\\text{Retention}> //\\text{Retention}<\\text{ours}>\\>\\> \\>\n| \\(<\\text{End Retention}> //\\text{End Retention}\\>\\>\\> \\>\n| \\(<\\text{Statement}> //\\text{End Statement}\\>\\>\\> \\>\n| \\(<\\text{Statement}> //\\text{Start Statement}\\<\\text{q}>\\>\\> \\>\n| \\(<\\text{Retention}> //\\text{Retention}<\\text{Indefinitely}>\\>\\> \\>\n| \\(<\\text{End Retention}> //\\text{End Retention}\\>\\>\\> \\>\n| \\(<\\text{Statement}> //\\text{End Statement}\\>\\>\\> \\>\n\n**Figure 36**: Example of Label Match\n\n71\n- **Relative Match**: Two elements ($p \\in A$) and ($q \\in B$) match ref values in DATA elements, if and only if the ref values in the set of $p$ have non-empty intersection with the ref values of the set of $q$. If more than one data-group elements exist in policies A and B, then the relative match algorithm will map the sets that have the larger intersection together for merging.\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code><Data-Group></code> //Start Data-group</td>\n<td><code><Data-Group></code> //Start Data-group</td>\n</tr>\n<tr>\n<td><code><p></code></td>\n<td><code><q></code></td>\n</tr>\n<tr>\n<td><code><data ref= "#user.name.family"></code></td>\n<td><code><data ref= "#user.name.family"></code></td>\n</tr>\n<tr>\n<td><code><data ref= "#thirdparty.name.given"></code></td>\n<td><code><data ref= "#business.cert.key"></code></td>\n</tr>\n<tr>\n<td><code><data ref= "#business.name"></code></td>\n<td><code><data ref= "#business.name"></code></td>\n</tr>\n<tr>\n<td><code><</p></code></td>\n<td><code><</q></code></td>\n</tr>\n<tr>\n<td><code><</Data-Group></code> //End Data-group</td>\n<td><code><</Data-Group></code> //End Data-group</td>\n</tr>\n</tbody>\n</table>\n\n**Relative Match**\n\nRelative match ($<p>$, $<q>$) = 2 items\n\n\\{<data ref= \"#user.name.family\"> , <data ref= \"#business.name\">}\\}\n\nFigure 37: Example of Relative Match\n\nThe following is a match method that combines all matches together.\n\n**Full match**: Two elements ($p \\in A$) and ($q \\in B$) match fully if and only if the content and structure of the elements matches.\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code><Data-Group></code> //Start Data-group</td>\n<td><code><Data-Group></code> //Start Data-group</td>\n</tr>\n<tr>\n<td><code><p></code></td>\n<td><code><q></code></td>\n</tr>\n<tr>\n<td><code><data ref= "#user.name.family"></code></td>\n<td><code><data ref= "#user.name.family"></code></td>\n</tr>\n<tr>\n<td><code><data ref= "#business.name"></code></td>\n<td><code><data ref= "#business.name"></code></td>\n</tr>\n<tr>\n<td><code><</p></code></td>\n<td><code><</q></code></td>\n</tr>\n<tr>\n<td><code><</Data-Group></code> //End Data-group</td>\n<td><code><</Data-Group></code> //End Data-group</td>\n</tr>\n</tbody>\n</table>\n\n**Related Match**\n\nFull match ($<p>$, $<q>$) = true\n\nFigure 38: Example of Full Match\n5.4.3 P3PMatch Algorithms\n\nSo far we have presented the overall process and flow of the P3PMatch algorithm. We will now give a more detailed description of the algorithm: the overall structure of the P3PMatch algorithm, validating the P3P policy using the P3P validator, matching P3P elements with P3P relative key.\n\nAlgorithm P3PMatch\n\nAlgorithm 1 presents the general P3PMatch algorithm for matching P3P elements. The algorithm accepts as input two P3P policies (A, and B), after comparing the P3P vocabularies or elements in both policies the P3PMatch returns as output an array of best matched element \\( M[i, j] \\). The algorithm sets Integer variables \\( i \\), and \\( j \\) to null and two Boolean variables (verifyPolicy1, and verifyPolicy2) to store the validation result of P3P A and B if the validation results are both true (meaning P3P A and B are valid P3P policies). The algorithm then loops through both policies to retrieve the content element in P3P A\\[i\\], and B\\[j\\]. If an element exists in both arrays, both instances will be retrieved and matched in pairs using the matchElement algorithm. The result of the match process will be stored in \\( M[i, j] \\).\n\n**Algorithm 1** P3PMatch\n\n1. **Input**: P3P policies P3P A, P3P B\n2. **Output**: Best matched elements after comparing the P3P elements\n3. int \\( i, j = \\) null\n4. boolean verifyPolicy1 ← validateP3P(A)\n5. boolean verifyPolicy2 ← validateP3P(B)\n6. if verifyPolicy1 && verifyPolicy2 == TRUE then\n7. \\( i ← \\) number of first-level subelements of P3P A\n8. \\( j ← \\) number of first-level subelements of P3P B\n9. \\( M[i][j] \\)\n10. do\n11. foreach \\( i \\) subelement ← A\n12. \\hspace{1em} foreach \\( j \\) subelement ← B\n13. \\hspace{2em} element collectElement1 ← A\\[i\\]\n14. \\hspace{2em} element collectElement2 ← B\\[j\\]\n15. \\hspace{2em} \\( M[i, j] ← \\) matchElement(A\\[i\\], B\\[j\\])\n16. end for\n17. end for\n18. end if\n19. return \\( M[i, j] \\)\nAlgorithm ValidateP3P\n\nAlgorithm 2 describes the validation of initial P3P policies (A and B), already discussed in subsection 4.3.1. The validateP3P method receives P3P policies or target URI to the policy as an input and returns a boolean value of either True or False after testing the validity of the P3P policy.\n\nFor example, we uploaded the P3P policy from an online business website (BennettGold LLP). The image in Figure 39 illustrates the result of the P3P policy after testing for validity.\n\n\n\n---\n\n27 http://www.bennettgold.ca/w3c/policy1.xml#Bennett_Gold_Privacy_Policy\nThe matchElement is presented in algorithm 3: this operation finds out the appropriate element in P3P policy A that corresponds to a given element in P3P policy B.\nMethod `elementName`\n\nMethod `elementName` (in Algorithm 3) returns the attribute value for the P3P element with a given name or returns null if there is no such attribute value assigned. The method may also return the empty string if the attribute value is empty.\n\nFor example, if `elementA = <STATEMENT>`, then `elementA.elementName = \"STATEMENT.\"`\n\nThe algorithm uses the `elementName` in one policy to find a similar element with equal names in the other policy. The algorithm later groups identical elements, which are later distributed to appropriate match classes (e.g. matchEntity, matchAccess, matchDispute, or matchStatement).\n\n---\n\n### Algorithm 4 matchEntity\n\n1. **Input**: element `elementA` and `elementB`\n2. **Output**: Matched result in `M[element, element]` with a match type to `mergeEntity`\n3. `int i = elementA.size`\n4. `int j = elementB.size`\n5. \n6. **foreach** `i` `subElementA ← elementA`\n7. **foreach** `j` `subElementB ← elementB`\n8. **if** `subElementA.elementName & subElementB.elementName == \"DATA-GROUP\"` **then**\n9. **// Repeat the loop process from line 3 to 7 for the element “DATA-GROUP”**\n10. **if** `subElement2A.elementName & subElement2B.elementName == \"DATA\"` **then**\n11. **if** `Label Match condition == TRUE` **then**\n12. `mergeEntity(subElement2A, subElement2B)`\n13. **end if**\n14. **end if**\n15. **end if**\n16. **end if**\nAlgorithm matchEntity\n\nThe matchEntity described in Algorithm 4, uses the matching type label match (explained in subsection 5.4.2) to find out the data group element in P3P policy A that corresponds to a given element in P3P policy B. The matchEntity collects matched pairs of data-group elements along with the match type, and then sends the collection to the mergeEntity method.\n\nMethod size\n\nMethod size (lines 3 – 4) is a public integer method that returns the number of elements in the list and uses the result to initialize the integer variables \\((i, j)\\) declared on lines 3 – 4. For example, the XML code below has a parent “purpose” and the size ( ) of this element equals four. E.g. purpose.size ( ) = 4.\n\n```xml\n<PURPOSE>\n <pseudo-analysis/>\n <current/>\n <contact required = 'always'>\n <telemarketing/>\n</PURPOSE>\n```\n\nAlgorithm matchAccess\n\nThe matchAccess described in Algorithm 5, explains the matchAccess for matching Access elements. The algorithm uses the matching type (Label match) to access element in P3P policy A and B, and passes along both elements with their match type to the mergeAccess class (if and only if the sub-elements are not empty or null).\n\n```\nAlgorithm 5 matchAccess\n1. Input: element elementA and elementB\n2. Output: Matched result in M[element, element] with a match type to mergeEntity\n3. subElementA = elementA.childElement\n4. subElementB = elementB.childElement\n5. \n6. if subElementA.elementName && subElementB.elementName != \"NULL OR EMPTY\"\n then\n 7. mergeAccess(elementA, elementB)\n 8. end if\n```\nAlgorithm matchDispute\n\nThe matchDispute in Algorithm 6 uses the matching type (Label and Text match) to group the resolution type elements in P3P policy A and B, then passes along the matched pair to the mergeEntity class.\n\nMethod remove\n\nThe remove method (lines 17 and 18) is a public integer method that returns and removes the element at the specified position in the list. Any subsequent elements are shifted to the left (one is subtracted from their indices). Parameters: Index – is the index of the element to be removed.\n\nMethod add\n\nThe add method inserts the specified elements at the specified position M[k, l] in the list. It shifts the element currently at the position (if any) and any subsequent elements to the right (it adds to the indices specified). Parameters: index – index at which the specified element is to be inserted and element – the Element to be inserted.\n\\begin{align*}\n20. & \\quad \\textbf{end if} \\\\\n21. & \\quad \\textbf{end for} \\\\\n22. & \\quad \\textbf{end for} \\\\\n23. & \\quad \\textbf{if} \\ \\text{subElementA.size ( )} \\neq 0 \\ \\textbf{then} \\\\\n24. & \\quad \\quad M[k + \\text{subElementASize( )},(l+1)].addColumn = \\text{subElementA.childElement} \\\\\n25. & \\quad \\textbf{end if} \\\\\n26. & \\quad \\textbf{end if} \\\\\n27. & \\quad \\textbf{if} \\ \\text{subElementB.size ( )} \\neq 0 \\ \\textbf{then} \\\\\n28. & \\quad \\quad M[k + \\text{subElementBSize( )},(l+1)].addColumn = \\text{subElementB.childElement} \\\\\n29. & \\quad \\textbf{end if} \\\\\n30. & \\quad \\textbf{end for} \\\\\n31. & \\quad \\textbf{end for} \\\\\n32. & \\quad \\textbf{mergeDispute}(M[k, l]) \\\\\n\\end{align*}\n\n\\textit{Method addAll}\n\nThe method \\textit{addAll ( )} inserts more than one element in a specified collection into the list, starting at the specified position. The method shifts the element currently at the position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in the list in the order returned by the specified collection’s iterator. Parameters: \\textit{index} – index at which to insert the first element from the specified collection. \\textit{collection} – collection containing elements.\n\n\\textit{Algorithm matchStatement}\n\nThe \\textit{matchStatement} algorithm described in Algorithm 7, uses the matching type (Label and Text match) to group the resolution type elements in P3P policies A and B. However, label and text match is not enough to match the statement element, as discussed in chapter 4; the use of a P3P relative data key must be checked. If the data element contains the relative data key, then the relative match will return the number of data-purpose and data-recipient occurrences for a data.\n**Algorithm 7** matchStatement\n\n1. **Input**: element elementA and elementB\n2. **Output**: Matched result in M[element, element] with a match type to mergeDispute\n3. int i = elementA.size\n4. int j = elementB.size\n5. int data[]\n6. int count = 0\n7. \n8. foreach i subElementA ← elementA\n9. foreach j subElementB ← elementB\n10. if subElementA.elementName && subElementB.elementName == \"DATA-GROUP\"\n11. then\n12. int i = subElementA.size\n13. int j = subElementB.size\n14. data[count] = countDataOccurance(subElementA, subElementB)\n15. increment count\n16. end if\n17. end for\n18. end for\n19. \n20. Sort(data[count], subElementA, subElementB) ← highest to lowest\n21. i Max(subElementA.length, subElementB.length)\n22. \n23. foreach i elements[ ] ← data[count]\n24. M[ ] ← pairElement(subElementA[i], subElementB[i])\n25. end for\n26. \n27. mergeStatement(M[ ])\n\n**Method countDataOccurance**\n\nThe countDataOccurance ( ) used on line 14, is a public integer method that returns the number of occurrences of an attribute (‘ref’ with a unique value) in Policies A and B. Parameters: element1, element2 – List of elements to compare.\n\n**Method sort**\n\nThe sort ( ) method on line 20, sorts the specified array of elements in descending order, according to the DATA occurrence of its DATA-GROUP element. This sort is to be stable: equal elements will not be reordered because of the sort. Parameters: data [index] - the array of data occurrences counted. element– List of elements and their properties to be sorted.\nMethod pairElement\n\nThe `pairElement()` method on line 24, is a public method that checks the collection statement elements in Policies A and B, and pairs them based on the sort results. The method returns a match array \\( M[\\text{element, element}] \\) that contains paired sorted statement elements, then `remove()` the paired group from the statement array.\n\n5.5 Conclusion\n\nIn this chapter, we have presented the P3P Match algorithm to match corresponding elements in two different P3P trees. We described how the processes required in matching multiple P3P policies relate to the P3P match process. We explained how the inner classes and methods in this algorithm interact. We then adopted the relative data key concept in Relational Database Management (RDBM) to extend the data element defined in the P3P specification; the P3P relative data key. Lastly, we defined the match types (Text, Label, Relative, and Full match) and the P3P relative data key (an extension to the P3P specification) required for matching privacy policies.\n\nIn the next chapter, we will present the P3P Merging algorithm for aggregating and integrating P3P privacy policies. We will begin by introducing the overview of our P3P aggregator framework, which describes the framework for merging policies of service providers on an aggregated platform.\nChapter 6\n\nThe P3P Merging Algorithm\n\nThis chapter explains our concept for merging P3P policies in a cloud aggregation platform. We propose an algorithm that implements the merging process described in section 4.2. Part of our methodology is to describe a framework for merging policies of service providers on an aggregation platform. To achieve this goal, we use the Three-Way Merge principle for aggregating structured data and constraints for the P3P language.\n\n6.1 Design Overview\n\nFollowing the introduction of our merging process in chapter 4, here we present the framework for using the P3P aggregator in the cloud-computing environment. This may require a formal semantic model, which should help avoid loss of data and correct semantic errors when creating a new policy. To perform the merger on an aggregation platform for SaaS, we illustrate the layout of our concept in Figure 40 and define merger constraints.\n\nFigure 40: Aggregation Platform for SaaS & P3P Merger System\n6.2 Defining P3P Merge Constraints\n\nThe purpose of defining P3P policy constraints is to include the semantic rules in the merging algorithms defined in [43,82] and discussed in section 3.2.1.\n\nNote that all the following example were actually executed and in this sense they constitute a fairly complete set of test cases for our merge algorithm.\n\n6.2.1 Policy Element\n\nThe POLICY element is the root element that starts the P3P policy; the element should have the following attributes: names, discuri, and opturi. To create a new merged P3P policy, the cloud aggregator must declare a new name, discuri, and opturi for the merged policy.\n\nFor example, if two services A and B in the cloud are merged to produce service C, the service aggregator is responsible to give a new name, discuri, and opturi for service C’s P3P policy.\n\n<table>\n<thead>\n<tr>\n<th>Policy A</th>\n<th>Policy B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code><Policy name = “service A”</code></td>\n<td><code><Policy name = “service B”</code></td>\n</tr>\n<tr>\n<td><code>></code></td>\n<td><code>></code></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Aggregate Policy Element</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code><Policy name = “Aggregate Policy”</code></td>\n</tr>\n<tr>\n<td>opturi = “new opturi address”</td>\n</tr>\n<tr>\n<td>discuri = “new discuri address”</td>\n</tr>\n<tr>\n<td><code>></code></td>\n</tr>\n</tbody>\n</table>\n\nFigure 41: Example of Aggregate POLICY Element\n\n6.2.2 Entity Element\n\nThe ENTITY element gives a precise description of the legal entity that owns the privacy policy. The P3P specification [24] permits service providers to declare their company information using the DATA-GROUP extension.\nFor example, if we merge services A and B, the new ENTITY element ($Entity_{new}$) will merge the company’s service information into a different DATA-GROUP element in the same new ENTITY element.\n\n**Rule 1:** If two or more ENTITY elements have the same data text values for #business.name (representing the company name), the aggregate result will only inherit one data-group for ENTITY because the P3P merger will assume that the providers are the same.\n\n**Algorithm 8** mergeEntity\n\n1. **Input:** element elementA and elementB\n2. **Output:** returns a merged result for Entity Element\n3. \n4. \n5. \n6. \n7. \n8. \n9. \n10. \n11. \n12. \n13. \n14. \n15. \n16. return Entity\n\nFor Example\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code><Entity></code></td>\n<td><code><Entity></code></td>\n</tr>\n<tr>\n<td><code><Data-Group></code></td>\n<td><code><Data-Group></code></td>\n</tr>\n<tr>\n<td><code><Data ref="#business.name"></code></td>\n<td><code><Data ref="#business.name"></code></td>\n</tr>\n<tr>\n<td>Service_A </Data></td>\n<td>Service_B </Data></td>\n</tr>\n<tr>\n<td><code><Data ref="#business.address"></code></td>\n<td><code><Data ref="#business.address"></code></td>\n</tr>\n<tr>\n<td>180 King Edward Drive</Data></td>\n<td>243 Hurmand Drive</Data></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Aggregate Entity Element</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code><Entity></code></td>\n</tr>\n<tr>\n<td><code><Data-Group></code></td>\n</tr>\n<tr>\n<td><code><Data ref="#business.name"></code> Service_A </Data></td>\n</tr>\n<tr>\n<td><code><Data ref="#business.address"></code> 180 King Edward Drive</Data></td>\n</tr>\n<tr>\n<td><code><Data-Group></code></td>\n</tr>\n<tr>\n<td><code><Data-Group></code></td>\n</tr>\n<tr>\n<td><code><Data ref="#business.name"></code> Service_B </Data></td>\n</tr>\n</tbody>\n</table>\nAccess Element\n\nThe ACCESS element indicates if the service provides access to various kinds of user information. The ACCESS element must contain one of the following child elements:\n\n- NONIDENT element (no identifying data is collected)\n- ALL element (the user can access all identifiable information)\n- IDENT-CONTACT element (the user can access only identifying and contact information)\n- CONTACT-AND-OTHER element (the user can access contact information and other identifiable)\n- OTHER-IDENT element (other identifiable data)\n- NONE element (the user cannot access any information)\n\n<table>\n<thead>\n<tr>\n<th>Algorithm 8: mergeAccess</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. <strong>Input:</strong> element elementA and elementB</td>\n</tr>\n<tr>\n<td>2. <strong>Output:</strong> returns a merged result for Access Element</td>\n</tr>\n<tr>\n<td>3. element Access ← null</td>\n</tr>\n<tr>\n<td>4. element subElement ← null</td>\n</tr>\n<tr>\n<td>5. if elementA.elementName && elementB.elementName != null then</td>\n</tr>\n<tr>\n<td>6. subElement ← <strong>accessRule</strong> (elementA, elementB)</td>\n</tr>\n<tr>\n<td>7. Access.add(subElement)</td>\n</tr>\n<tr>\n<td>8. end if</td>\n</tr>\n<tr>\n<td>9. return Access</td>\n</tr>\n</tbody>\n</table>\n\nFor example, if we merge the two P3P policies A and B, the new ACCESS element (Access Element) will be equal to the Access element of policy A or the Access element of policy B, if and only if Access element for both A and B are identical. Otherwise, the method accessRule () determines the access value between the two access elements.\nThe accessRule (*element, element*) method used on line 6, is a public element method that returns the element at the specified access element. The method accepts access values from P3P policy A and B as input and compare the values based on the access values on the privacy information.\n\n**Rule 2**: Access values can be prioritized according to the privacy information they possess:\n\n\\[\n\\text{All} \\prec \\text{Contact-and-other} \\prec \\text{Ident-contact} \\prec \\text{Other-ident} \\prec \\text{Nonident} \\prec \\text{None}\n\\]\n\nFor Example, Table 6 describes access values of two services A and B, if service A allows user access `<all/>` and service B allows access `<ident-contact/>`.\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code><Access></code></td>\n<td><code><Access></code></td>\n</tr>\n<tr>\n<td><code><all/></code></td>\n<td><code><ident-contact/></code></td>\n</tr>\n<tr>\n<td><code></Access></code></td>\n<td><code></Access></code></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>New Service</th>\n<th>RULE</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code><Access></code></td>\n<td><code><Access></code></td>\n</tr>\n<tr>\n<td><code><ident-contact/></code></td>\n<td><code><ident-contact/></code></td>\n</tr>\n<tr>\n<td><code></Access></code></td>\n<td><code></Access></code></td>\n</tr>\n<tr>\n<td><code><all/></code></td>\n<td><code><ident-contact/></code></td>\n</tr>\n</tbody>\n</table>\n\nTable 6: Example of aggregate Access Element\n\n### 6.2.4 Disputes-Group Element\n\nThe DISPUTES-GROUP element has one or more DISPUTES elements. The DISPUTES element describes the resolution rules that users will follow in case of a user-provider dispute. The DISPUTES element requires the resolution type (*Service* | *Independent* | *Court* | *Law*), the URI of the service to resolve the dispute, the URL for verification (which should include the REMEDIES element) and the long and short description of the DISPUTE element.\n\n**Rule 3**: The merge system should aggregate service values (*Service* | *Independent* | *Court* | *Law*) in the dispute element based on equality, and if the values are not equal then the apply method will pick a greater value in the following order: *Correct* < *Money* < *Law*.\nAlgorithm 8 mergeDisputes\n\n1. **Input**: element elementA and elementB\n2. **Output**: returns a merged result for Disputes-Group Element\n3. \\texttt{element} Disputes-Group = null\n4. \\texttt{element} Disputes = null\n5. \\texttt{int} \\texttt{i} = elementA.size ()\n6. \\texttt{int} \\texttt{j} = elementB.size ()\n7. \\texttt{foreach} \\texttt{i} subElementA ← elementA\n8. \\texttt{foreach} \\texttt{j} subElementB ← elementB\n9. \\texttt{if} subElementA.elementName.equal(subElementB.elementName) && != null\n10. Disputes.add( ) ← \\texttt{disputesRule} ( subElementA, subElementB)\n11. Disputes-Group.add( ) ← Disputes\n12. Disputes.clear( )\n13. elementA.remove(subElementA)\n14. elementB.remove(subElementB)\n15. \\texttt{end if}\n16. \\texttt{end for}\n17. \\texttt{end for}\n18. \\texttt{if}(elementA.size( ) <= 0) \\texttt{then}\n19. Disputes-Group.addAll(elementA)\n20. \\texttt{end if}\n21. \\texttt{if}(elementB.size( ) <= 0) \\texttt{then}\n22. Disputes-Group.addAll(elementB)\n23. \\texttt{end if}\n24. return Disputes-Group\n\nFor Example\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><Disputes-Group></td>\n<td><Disputes-Group></td>\n</tr>\n<tr>\n<td><Dispute></td>\n<td><Dispute></td>\n</tr>\n<tr>\n<td><Resolution ="Service"></td>\n<td><Resolution ="Service"></td>\n</tr>\n<tr>\n<td><Remedies> <Money/> </Remedies></td>\n<td><Remedies> <Law/> </Remedies></td>\n</tr>\n<tr>\n<td></Dispute></td>\n<td></Dispute></td>\n</tr>\n<tr>\n<td><Dispute></td>\n<td><Dispute></td>\n</tr>\n<tr>\n<td><Resolution ="Court"></td>\n<td><Resolution ="Court"></td>\n</tr>\n<tr>\n<td><Remedies> <Correct/> </Remedies></td>\n<td><Remedies> <Law/> </Remedies></td>\n</tr>\n<tr>\n<td></Dispute></td>\n<td></Dispute></td>\n</tr>\n<tr>\n<td></Disputes-Group></td>\n<td></Disputes-Group></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>New Service</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><Disputes-Group></td>\n</tr>\n<tr>\n<td><Dispute></td>\n</tr>\n<tr>\n<td><Resolution ="Service"></td>\n</tr>\n<tr>\n<td><Remedies> <Money/> </Remedies></td>\n</tr>\n<tr>\n<td></Dispute></td>\n</tr>\n<tr>\n<td>Service = Service</td>\n</tr>\n<tr>\n<td>Apply rule (Correct < Money < Law)</td>\n</tr>\n</tbody>\n</table>\n6.2.5 Statement Element\n\nAlgorithm 9 mergeStatement\n\n1. **Input**: element elementA and elementB\n2. **Output**: returns a merged result for Disputes-Group Element\n3. element Statement = null\n4. int i = elementA.size()\n5. int j = elementB.size()\n6. foreach i subElementA ← elementA\n7. foreach j subElementB ← elementB\n8. if subElementA.elementName.equal(subElementB.elementName) && != \"NON-IDENTIFIABLE\"\n9. if subElementA.elementName.equal(subElementB.elementName) &&\n10. subElementA.element.equal(\"CONSEQUENCE\") then\n11. statement.addUnique(subElementA, subElementB)\n12. end if\n13. if subElementA.elementName.equal(subElementB.elementName) &&\n14. subElementA.element.equal(\"PURPOSE\") then\n15. statement.addUnique (subElementA, subElementB)\n16. end if\n17. if subElementA.elementName.equal(subElementB.elementName) &&\n18. subElementA.element.equal(\"RECIPIENT\") then\n19. statement.addUnique (subElementA, subElementB)\n20. end if\n21. if subElementA.elementName.equal(subElementB.elementName) &&\n22. subElementA.element.equal(\"RETENTION\") then\n23. mergeRetention(subElementA, subElementB)\n24. end if\n25. if subElementA.elementName.equal(subElementB.elementName) &&\n26. subElementA.element.equal(\"DATA-GROUP\") then\n27. statement.add\n28. foreach l dataElementA ← subElementA\n29. foreach k dataElementB ← subElementB\n30. if dataElementA.elementName.equal(dataElementB.elementName) &&\n31. dataElementA.element.equal(\"DATA\") then\n32. statement(DATA-GROUP).addUnique(dataElementA, dataElementB)\n33. end if\n34. end if\n35. end for\nThe **STATEMENT** element is a container that groups together a **PURPOSE** element, a **RECIPIENT** element, a **RETENTION** element, a **DATA GROUP** element, a **NON-IDENTIFIABLE** element and a **CONSEQUENCE** element. When the **STATEMENT** element in P3P does not collect any data from the user, the childnode of that **STATEMENT** element will have a **NON-IDENTIFIABLE** element.\n\nFor example\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n</table>\n| `<Statement>` //Statement 1 \n `<non-identifiable/>` \n `/Statement>` | `<Statement>` //Statement 1 \n `<purpose/>` \n `<retention/>` \n `<recipient/>` \n `/Statement>` |\n| `<Statement>` //Statement 2 \n `<non-identifiable/>` \n `/Statement>` | `<Statement>` //Statement 1 \n `<non-identifiable/>` \n `<Statement>` |\n\n**New Service**\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n</table>\n| `<Statement>` //Statement 1 \n `<purpose/>` \n `<retention/>` \n `<recipient/>` \n `/Statement>` | `<Statement>` //Statement 1 \n `<purpose/>` \n `<retention/>` \n `<recipient/>` \n `/Statement>` |\n| `<Statement>` //Statement 2 \n `<non-identifiable/>` \n `/Statement>` | `<Statement>` //Statement 1 \n `<non-identifiable/>` \n `<Statement>` |\n\nTable 8: Example of aggregate **NON-IDENTIFIABLE** Element\n### 6.2.6 Retention Element\n\nThe RETENTION element indicates the time of retaining the collected information, and it describes the kind of retention policy that applies to the data referenced in that STATEMENT. The element must contain one of the following pre-defined retention values: *indefinitely, no retention, stated-purpose, legal-requirement, or business-practices*.\n\nFor example, when merging two services (A and B); the new RETENTION element of the aggregate statement depends on the greater retention value between the two matched values.\n\n**Rule 4**: The merge system should aggregate retention values based on their longevity.\n\nIndefinitely > business-practices > legal-requirement > stated-purpose > no-retention\n\nFor example\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n</table>\n| <Statement> //Statement 1 \n <Consequence> \n As a consequence of the use of the service, or by virtue of having sent an e-mail through the “contacts”... \n </Consequence> \n </Statement> | <Statement> //Statement 1 \n Null \n </Statement> |\n\n<table>\n<thead>\n<tr>\n<th>New Service</th>\n</tr>\n</thead>\n</table>\n| <Statement> //Statement 1 \n <Consequence> \n As a consequence of the use of the service, or by virtue of having sent an e-mail through the “contacts”... \n </Consequence> \n </Statement> \n <Statement> Null </Statement> |\n\nTable 9: Example of aggregate Consequence Element\n**Algorithm 8** mergeRetention\n\n1. **Input**: element subElementA and subElementB\n2. **Output**: returns the aggregate value of a retention element\n3. element retention ← null\n4. if subElementB.elementName && subElementA.elementName != null then\n5. retention ← accessRule(subElementA, subElementA)\n6. retention.add(subElement)\n7. end if\n8. return retention\n\nFor example\n\n<table>\n<thead>\n<tr>\n<th>Service A</th>\n<th>Service B</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><Statement> //Statement 1</td>\n<td><Statement> //Statement 1</td>\n</tr>\n<tr>\n<td><Retention>Stated-purpose<Retention/></td>\n<td><Retention>Legal-requirement</td>\n</tr>\n<tr>\n<td></Statement></td>\n<td><Retention/></td>\n</tr>\n<tr>\n<td></td>\n<td></Retention/></td>\n</tr>\n<tr>\n<td></td>\n<td></Statement></td>\n</tr>\n<tr>\n<td><strong>New Service</strong></td>\n<td></td>\n</tr>\n<tr>\n<td><Statement> //Statement 1</td>\n<td></td>\n</tr>\n<tr>\n<td><Retention>Legal-requirement <Retention/></td>\n<td></td>\n</tr>\n<tr>\n<td></Statement></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTable 10: Example of aggregate Retention element\n6.3 P3P Merge Framework\n\nIn this section, we extend the model of service aggregation in [78]. We apply the P3P policy aggregator module to the service aggregation model.\n\nFigure 42: Design Overview of Policy Merger in an Aggregation Platform\n6.3.1 P3P-Enabled Service Providers\n\nWhen service providers create and deploy P3P policies, they will have to configure the server to issue P3P response headers to the cloud upon request. Here is an overview of the file and HTTP responses involved in the process.\n\n- **Create P3P policy**: The policy statements of a service provider are the subset of the services offered; the data handling practices have always influenced the policy statements. A P3P policy\\(^{28}\\) is an XML document that describes those policy statements. The P3P policy can either be a standalone file, or be included in a policy reference file.\n\n- Create Policy Reference File: A P3P policy reference file is an XML file that tells user agents which P3P policy applies to which URLs and cookies on a web site [24]. The service providers’ policy reference files contain addresses to P3P policies. Every P3P-enabled service provider must have at least one policy reference file [24].\n\n6.3.2 Aggregate Service \\(K\\)\n\nWe defined a service user in section (2.7.2) as an individual or entity, which makes use of aggregate services on the aggregation platform.\n\nAccording to the framework in Figure 42, the user-request for aggregate service is denoted \\(K\\). Service \\(K\\) is the set of all services that are included in the requested service.\n\n\\[\nK \\in \\{\\text{service } 1, \\text{service } 2, \\ldots, \\text{service } j \\}\n\\]\n\nThe P3P specification includes a protocol for requesting and transmitting P3P policies, which we discussed in (Section 2.2.2). The protocol relies on the HTTP protocol that the web browsers use to communicate with the aggregator’s market place (web portal). As shown in Figure 42, the customer sends the list of services in \\(K\\) via the marketplace to the service aggregator.\n\n\\(^{28}\\) A service provider may have more than one privacy policy\n6.3.3 Retrieving P3P Reference and Policy files\n\nIn a typical client/server model, the web browser uses the HTTP protocol to communicate with the servers over the Internet. With this protocol, the web browser can retrieve P3P policies from the server. In this framework, the service aggregator uses a standard HTTP request to fetch P3P policy reference files for service K. Service K equals a list of services \\( \\{\\text{service 1, service 2, \\ldots, service } j\\} \\) from different service providers. On obtaining the appropriate policy reference files, the service aggregator can use those reference files to locate the P3P policy files corresponding to the services \\( \\{\\text{service 1, service 2, \\ldots, service } j\\} \\).\n\n6.3.4 Policy Merger System\n\nThe policy merger system is associated with a method that creates the aggregate P3P policy. The policy merger system merges the P3P policies retrieved from the service K with the aggregator’s P3P policy. We denote the aggregate P3P policy to be \\( Z \\), as shown in Figure 43.\n\nWe adopt the aggregate and operator notation used in [30] to represent the aggregate operation in our model. By definition, \\( \\Theta \\) denotes an aggregate operator, which represents the intersection of P3P elements, union of related elements, or conflicts. Our algorithm for this operator is presented in Section 6.2.\n\nWe denote the assignment operation as \\( \\leftarrow \\), where policies in \\( K \\) and the aggregator’s policy are aggregated to form a new policy \\( Z \\). Note that although we considered \\((K + 1)\\) P3P policies in Figure 43, they are merging two by two according to the three-way merging method discussed in chapter 4.\n\n\\[\n\\text{policy } Z = (\\text{policy 1 } \\Theta \\text{ policy 2 } \\Theta \\ldots \\Theta \\text{ policy } j) \\Theta \\text{ aggregator’s P3P policy}\n\\]\n6.3.5 Consistency Check for Policy Z\n\nTo formally verify and semantically check inconsistencies in the P3P policy Z, we implement the P3P constraints introduced in section 3.2.1.1 using a SAT solver called “Alloy Analyzer.” We rely on the Alloy Analyzer for model checking; it must be verified that the semantics and syntax of policy Z conform to the P3P1.1 specifications. The model in the Alloy analyzer will also check for any conflicts that may exist in the policy before it reaches the user.\n\n6.3.5.1 Alloy Concepts\n\nThe Alloy is a first order relational logic, and is intended to model complex structures through extensive set manipulation, and this manipulation permits an easy translation from mathematical models (usually in a set or object-oriented form) by using the Alloy Analyzer tool.\n\nAn Alloy model consists of sets of concrete objects, called signatures (sig), facts about these sets, and relations on these sets. In the alloy language, distinguished subsets of signatures can be created; these new signatures are said to extend the superset of an object. Unlike some other modeling languages, Alloy does not require that these relations are completely specified.\n\n- Signature: A signature (sig) declares one or more sets of atoms, and their relations to the other sets.\n\n- Function: A function (fun) defines relations (sets, or atoms). It can take parameters that are used in getting its results. It can define a relation (usually using the implication⇒) and make use of it in order to produce relationship results. Such functions are a FOL (First-Order Logic) function for the Alloy logic, in which expressions are relations.\n\n- Predicate: A Predicate (Pred) defines a formula that one assumes to be valid. The Alloy analyzer uses facts as axioms in constructing its examples and counterexamples.\nAssertion: An Assertion (assert) defines a formula that is claimed to always be true. It differs from a fact, because the Alloy analyzer will always check an assertion to make sure that it is true for all other modules. However, the analyzer assumes that each fact is used as a constraint, which is only true for the module it is declared in.\n\n6.3.5.2 Alloy Model of Aggregate P3P Policy Z\n\nIn this section, we show a logical model for the P3P policy Z. To obtain the alloy model we need to translate the logical notations into the Alloy notion. Alloy defines sets to be signatures. The signatures connect the events of elements in a function. We translate constraints in the P3P language defined in section 3.4.1.1 into Alloy’s facts, assertions, or functions.\n\nFor example, the P3P policy expressed as POLICY = {ACCESS, ENTITY, DISPUTES-GROUP, STATEMENT} can be translated in Alloy to the diagram shown in Figure 44.\n\n```alloy\nabstract one sig Policy{\n statement: some Statement,\n entity: one Entity,\n access: one Access,\n disgroup: one DisputesGroup\n}\n```\n\nFigure 44: Modeling a P3P policy element in Alloy\n\n```alloy\none sig Statement {\n purpose: one Purpose,\n retention: one Retention,\n recipient: one Recipient,\n data : some DataGroup\n}\n```\n\nFigure 45: Modeling a P3P statement element in Alloy\nFigure 46: Alloy Model of P3P Privacy Policy Z\n6.3.5.3 Checking Consistency in policy Z\n\nConsistency is a condition for aggregating P3P models, since there should not be conflicts in an aggregate policy. We will therefore check the P3P policy Z to determine if there were any inconsistencies. The constraints defined in sections 3.2.1 can be translated into facts that check for P3P conflicts. For example, Figure 48 illustrates a P3P constraint translated to Alloy.\n\nP3P Constraint\n\n\\[ \\forall p, q \\in DPRD, p.(data, purpose) = q.(data, purpose) \\rightarrow p.retention = q.retention \\]\nThe Alloy analyzer will take policy constraints such as the one given in Figure 48 to verify whether a P3P policy is satisfied. In other words, it checks constraints against a given P3P policy, and outputs true if the P3P policy comply with the constraints or false otherwise.\n\n6.3.6 P3P User Agent Checking Policy Z\n\nAfter verifying consistency in a policy Z, the P3P user agent on the user’s web browser retrieves the policy, which is then compared with the user’s privacy preferences in the browser. In the case where the policy matches with the user’s privacy preferences, the browser will request the aggregate service. However, if the policy does not match the user’s preferences, the browser will inform the user about the privacy warnings and attempt to abort the service request. User intervention is necessary to recover from this situation. Most probably, the user will either have to modify its preferences or renounce using the service.\n\n6.4 Conclusion\n\nIn this chapter, we have discussed the P3P Merge algorithm, an algorithm to aggregate corresponding elements that have been matched by the P3P match algorithm. We described how some semantic rules required in merging P3P policies are added through the apply method. We have explained our approach by showing how the methods in the merge algorithm interact with the P3P elements used in a policy. We have then presented our contribution to the aggregation platform by developing a model of an aggregation framework to merge the P3P policies of service providers on an aggregation platform. We adopted the\nAlloy Analyzer (a SAT solver) as an extension to determine if the aggregate policy is consistent or not. We call this the policy validation process or consistency check.\n\nIn the next chapter, we will present the implementation of our P3P policy aggregation tool, the tool is part of the goal of this thesis. We use the Java programming language and Dom4J as the main programming languages. We will also present some example scenarios of how the tool developed can be used.\nChapter 7\n\nThe Merger Implementation\n\nIn this chapter, we explain some core modules in the prototype implementation of the P3P merger system. The tool performs a syntactic and semantic three-way merge operation on two P3P policies. We also describe the technologies used in the implementation of the merger system.\n\n7.1 Implementation Technologies\n\nAs part of the goal of this thesis, we develop a P3P policy aggregation tool, which can interact with service providers in the cloud, and over the Internet. Our choice of implementation technologies was driven by cloud platform standards, the need for platform independence, and the language requirements from cloud Platform as a Service (PaaS) providers such as Google App Engine (GAE). The GAE supports apps written in several programming languages like Java™, Python, and the Go programming language.\n\nCloud aggregators run on the PaaS platform; this platform lets users run web applications on the cloud provider’s infrastructure. The aggregator can easily build, maintain, and scale applications in the language’s runtime environment (e.g. Java runtime environment JRE). For example, if an aggregator runs the JRE platform in the cloud, add-on or plug-in applications can be developed using the standard Java technologies, including the Java virtual machine, Java servlets, JavaScript, Ruby, and the Java programming language.\n\nIn this thesis work, we used Java™ as the main programming language, HTTP as the transport protocol, DOM4J as the DOM API and XML parser, and P3P1.1 as the format for all aggregate policies. We used Java™ Platform, Standard edition 7 APIs. We also relied on\n\n---\n\n29 What is Google App Engine? https://developers.google.com/appengine/docs/whatisgoogleappengine\n31 DOM4J, an open source library for working with XML. http://dom4j.sourceforge.net/\nthe Eclipse Integrated Development Environment IDE for Java developers\\textsuperscript{32} to edit and create our code.\n\n### 7.1.1 DOM4J XML Parser\n\nDom4J is an open source XML framework library for parsing XML, XPath and XSLT on the Java platform. It uses the Java-Collections framework and has full support for other XML parsers such as DOM, SAX and JAXP.\n\nThe main features of Dom4J are listed below:\n\n- Was designed for the Java platform with full support for the Java collection framework\n- Provides full support for JAXP, TrAX, SAX, DOM, and XSLT\n- Has fully integrated XPath support for easy navigation of XML documents\n- Is based on Java interfaces for flexible plug and play implementations\n- Provides support for XML schema Data Types\n\n### 7.2 Design\n\nTo merge two or more policy files, the aggregator tool has to parse the policy code, compare all the differences, constrain and validate the P3P trees, and finally assemble the aggregate policy in a pretty-print XML format. Being a prototype, the current implementation is not fully automated in terms of determining the policy URI from the P3P reference file. The tool is in its alpha stage.\n\nThe current parser API essentially allows us to model XML in a tree format or in a pretty print XML format. A side feature of the aggregator tool is the additional comment function that explains each merge step in the aggregate policy; this allows the entities to trace the merging steps and manually verify them if the need arises. We include comments where aggregate actions affect the policy. The comment element in this implementation appends a brief summary of how an aggregate element was obtained.\n\n\\textsuperscript{32} \\url{http://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/junor}\n7.3 Test Environment\n\nFor each match and merge scenario, three matches, and one merge operation are performed consecutively:\nThe text matches\n- The label matches\n- The relative matches\n- The full matches\n- The three-way merge principle\n\nThe framework for the evaluation is a Java program which already performs the basic three-way merge rules at the directory level with valid P3P policies as input arguments, as shown in section 4.3.3.2. This decision was made in order to allow a more direct and consistent aggregation between the policies. The framework program validates the P3P policy after completing the upload process, and analyzes the P3P elements before matching the P3P STATEMENT elements.\n\nAll tests were carried out on an Intel Core i5 Pentium with 4 cores at 3.4GHz with 6GB of RAM. The machine runs Ubuntu Linux 12.04 and uses an up-to-date version of the eclipse Juno 32-Bit, DOM4J version 1.16 and Java SE 7.02.\n\n7.4 Program Structure of the Merger Tool\n\nIn this section, we give a brief overview of the program structure. The main class is the mainEngine; the class contains the Java main method that controls the application’s execution. The frameMerger class contains the method that generates the interface and parses the P3P policies to build the P3P tree. The interface from this method contains buttons that execute the P3P matches and invoke the P3P validator and the P3P merge methods.\n\nThe P3PMatch algorithm is implemented in the matchPolicy class; this implementation performs the text, relative, label and full matches (matchEntity, matchAccess, matchDisputes, and matchStatement), see section 5.4.\n\nThe validatePolicy class invokes the P3P constraints and validations algorithms. The class encapsulates the the checkConstraint and the getValidate methods.\nFigure 50: Class Diagram showing composition relationships\n\nvalidatePolicy\n- getConstraints(String s)\n- validateElement(Element e)\n- validateDocument(Doc d)\n- validateLinks(String s)\n- validateSyntax(Document d)\n\nmainEngine\n- main(String[] args)\n\nCreatePolicy\n- collectElement()\n- createEntity(element e, element e)\n- createAccess(element e, element e)\n- createDisputes(element e, element e)\n- createStatement(element e, element e)\n- createDocument(element e, element e)\n- setPolicy(); return Document doc1\n\nmergePolicy\n- mergeDoc(Document d1, Document d2)\n- mergeEntity(element E1, Element E2)\n- mergeAccess(element E1, Element E2)\n- mergeDisputes(element E1, Element E2)\n- mergeStateM(element E1, Element E2)\n- Entity(); return E1, E2\n- Access(); return E1, E2\n- Disputes(); return E1, E2\n- Statement(); return E1, E2\n\nframeMerger\n- actionPerformed(ActionEvent e)\n- getPath(String path)\n- frameMerger()\n- getDocument()\nFigure 51: Example of an Aggregate P3P Policy\n7.5 Differences Between Our Approach and the Approach of Dong et al.\n\nCompared with Dong et al. [30], our merger concept has more advanced functions in the matching and merging algorithms, including validating P3P policies, checking for inconsistencies, using the three-way merging principle and matching P3P elements. The Validator function helps prevent syntactic errors and helps in producing a consistent P3P policy. We consider P3P policy consistency to be a more important factor in this work than other factors (e.g. Merging speed). The differences between the two aggregate policy approaches are outlined in the following subsection.\n\nDong et al.’s aggregate algorithm for merging P3P policies will not consistently aggregate policies in a composite environment or aggregation platform because the approach used is based only on the two-way merge principle. This merger principle only allows a syntactic merge. Therefore, this algorithm needs to completely compare P3P elements in both policies and the policy aggregator will have to resolve semantic inconsistencies manually each time a merge operation is performed. The aggregate policy approach we are considering in this thesis is in real-time, which reduces manual manipulations from the policy aggregator.\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Dong et al</th>\n<th>Our P3P Merger Approach</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Validating P3P Vocabulary</td>\n<td>No Syntax validation</td>\n<td>Adopted the W3C’s P3P validator</td>\n</tr>\n<tr>\n<td>Matching P3P Elements</td>\n<td>Label Match</td>\n<td>Text, Label, Relative, and Full Match</td>\n</tr>\n<tr>\n<td>Relating P3P Data, Purpose, and Recipient</td>\n<td>×</td>\n<td>The P3P Data Key</td>\n</tr>\n<tr>\n<td>Merge Principle</td>\n<td>Two-way Merge principle</td>\n<td>Three-way Merge</td>\n</tr>\n<tr>\n<td>Constraints Or Merge Rules</td>\n<td>×</td>\n<td>✓</td>\n</tr>\n</tbody>\n</table>\n\nTable 11: Differences in P3P Merger Approach\n7.6 Runtime\n\nOne of the main benefits of our merger approach is the consistency of the aggregate P3P policies. The other noticeable benefit is the speed in real time merges operation: because the P3P policy file has an average file size of 3 to 10 kilobyte (KB), a merge on two policy files can be executed in a very short time. When the merger program executes repeatedly, its efficiency becomes important. However, because of the huge processor power delivered in the cloud, our algorithm performs efficiently on typical P3P policy files. However our focus was on creating consistent aggregate policies rather than optimizing merge speed.\n\n7.7 Example Scenario\n\nWe illustrate our approach by aggregating privacy policies of sample service providers. We will be considering two different service providers’ privacy policies (Policy A and B), which are to be merged on an aggregation platform. Each privacy policy presented has different access granting rules for their users, where policies are specified using the P3P policy language.\n\nPrivacy Policy for Service A.\n\nWe present the privacy policy for service A first in natural language and then translated into a full P3P privacy policy.\n\nNatural Language Policy:\n\nAt Service A Inc, we care about the privacy policy of our customers. When browsing through our site, we will collect personal information on the family name, the phone number, and contact address. This information includes the number of times a web page is accessed, the browser used, the paths taken when moving through the web site. We will delete this information yearly.\n\nService A uses cookies to store some necessary information about you on your computer. You will be able to access information that concerns your contact and other related data alone. Information collected will only be shared with delivery agents that share our privacy practices.\nP3P Policy for A:\n\n```xml\n<POLICY name=\"Service_aggregateA\" xml:lang=\"en\">\n <ENTITY>\n <DATA-GROUP>\n <DATA ref=\"#business.name\">Service A, Inc</DATA>\n <DATA ref=\"#business.contact-info.online.email\">abcd@serviceA.ca</DATA>\n <DATA ref=\"#business.contact-info.online.uri\">http://www.serviceA.ca</DATA>\n <DATA ref=\"#business.contact-info.telecom.telephone.number\">123-456-8976</DATA>\n </DATA-GROUP>\n </ENTITY>\n <ACCESS><contact and other/></ACCESS>\n <STATEMENT>\n <PURPOSE>\n <admin/><contact/><current/><develop required=\"opt-out\"/><individual-analysis/>\n <individual-decision/><telemarketing/>\n </PURPOSE>\n <RECIPIENT><ours/><delivery/></RECIPIENT>\n <RETENTION><legal-requirement/></RETENTION>\n <DATA-GROUP>\n <DATA ref=\"#user.name.family\", DP = \"admin, contact, develop, Individual-analysis, individual decision\", DR = \"ours, delivery\"/>\n <DATA ref=\"#user.info.phonenumber\", DP = \"current, admin, contact, develop, Individual-analysis, individual decision, telemarketing\", DR = \"ours\"/>\n <DATA ref=\"#user.info.contact\", DP = \"current, admin, contact,\", DR = \"ours\"/>\n </DATA-GROUP>\n </STATEMENT>\n</POLICY>\n```\n\nTable 12: Privacy Policy for Service A\n\nPrivacy Policy for Service B.\n\nWe present the privacy policy for service B first in natural language and then translated into a full P3P privacy policy.\n\nNatural Language Policy:\n\nAt Service B Inc, we care about your privacy. When you browse through our site, we collect information on the efficiency and working of our website. This information includes the number of times a web page is accessed, the browser used, and paths taken when moving through the website. We purge this information from the public domain yearly.\n\nWe also collect postal codes but will always prompt you to enter it with your permission, this information is aggregated with information collected from all visitors to our website for market analysis. This information is provided to third parties. Once prompted for your postal code, you will not be prompted again if your browser privacy preferences allow cookies.\nService A uses cookies to store whether you have entered your zip code or declined to do so. We access this information each time you visit our site so that you are only prompted the first time you visit our web site.\n\nP3P Policy for B:\n\n```xml\n<POLICY name=\"Service_AggregateB\" xml:lang=\"en\">\n <ENTITY>\n <DATA-GROUP>\n <DATA ref=\"#business.name\">ServiceB</DATA>\n <DATA ref=\"#business.contact-info.online.email\">abcd@ServiceB.ca</DATA>\n <DATA ref=\"#business.contact-info.online.uri\">http://www.ServiceB.ca</DATA>\n <DATA ref=\"#business.contact-info.telecom.telephone.number\">123-456-0000</DATA>\n </DATA-GROUP>\n </ENTITY>\n <ACCESS><all/></ACCESS>\n <STATEMENT>\n <PURPOSE>\n <admin/><contact/><current/><develop required=\"opt-out\"/><tailoring/><telemarketing/>\n </PURPOSE>\n <RECIPIENT><ours/><delivery/></RECIPIENT>\n <RETENTION><legal-requirement/></RETENTION>\n <DATA-GROUP>\n <DATA ref=\"#user.name.family\", DP = \"admin, contact, develop, tailoring\", DR = \"ours, delivery\"/>\n <DATA ref=\"#user.info.phonenumber\", DP = \"admin, develop, telemarketing\", DR = \"ours, delivery\"/>\n <DATA ref=\"#user.info.contact\", DP = \"admin, contact, develop, tailoring\", DR = \"ours, delivery\"/>\n <DATA ref=\"#user.gender\", DP = \"current, DR = \"ours\"/>\n </DATA-GROUP>\n </STATEMENT>\n <STATEMENT>\n <PURPOSE>\n <admin/><contact/><current/><develop required=\"opt-out\"/><tailoring/><telemarketing/>\n </PURPOSE>\n <RECIPIENT><ours/></RECIPIENT>\n <RETENTION><legal-requirement/></RETENTION>\n <DATA-GROUP>\n <DATA ref=\"#user.postal_no\", DP = \"current, admin, contact, develop, tailoring\", DR = \"ours, delivery\"/>\n <DATA ref=\"#user.user_number\" DP = \"current, admin, develop, tailoring\", DR = \"ours\"/>\n <DATA ref=\"#user.browserinformation\" DP = \"current, admin, develop, tailoring\", DR = \"ours\"/>\n </DATA-GROUP>\n </STATEMENT>\n</POLICY>\n</POLICIES>\n```\n\nTable 13: Privacy Policy B\n7.7.1 Aggregate Result\n\nStage1 Policy Definition\nThe service aggregator is always responsible for creating a new Policy name, Dispute URI (discuri), and Opt-out or Opt-in URI information.\n\nStage2 Entity Element\nAfter the validation process, the tool gathers the service providers’ information and compares if they are the same elements with text, label or attributes. The match process detects similar elements to be merged.\n\n<!-- Description of merged entities making this policy statements -->\n<ENTITY>\n <DATA-GROUP>\n <DATA ref=\"#business.name\">Service A, Inc</DATA>\n <DATA ref=\"#business.contact-info.online.email\">abcd@ServiceA.ca</DATA>\n <DATA ref=\"#business.contact-info.online.uri\">http://www.ServiceA.ca</DATA>\n <DATA ref=\"#business.contact-info.telecom.telephone.number\">123-456-0000</DATA>\n </DATA-GROUP>\n\n <DATA-GROUP>\n <DATA ref=\"#business.name\">ServiceB</DATA>\n <DATA ref=\"#business.contact-info.online.email\">abcd@serviceB.ca</DATA>\n <DATA ref=\"#business.contact-info.online.uri\">http://www.serviceB.ca</DATA>\n <DATA ref=\"#business.contact-info.telecom.telephone.number\">123-456-8976</DATA>\n </DATA-GROUP>\n</ENTITY>\nStage3 Access Element\n\nAccess type for Service A = Contact-and-Other e.g. <ACCESS><contact-and-other/></ACCESS>\nAccess type for Service B = All e.g. <ACCESS><all/></ACCESS>\nConflict = Access Type. Apply AccessRule(), aggregate result = <All/>\n\n<ACCESS><all/></ACCESS>\n\nAggregate Result for A and B\n\n(Notes that the execution time for this example was negligible). <POLICY name=\"Service_AggregateB\" xml:lang=\"en\">\n<!-- Description of merged entities making this policy statements -->\n\n<!-- Merge Rule 'all' > 'content-and-other'-->\n<ACCESS><all/></ACCESS>\n\n<!-- Statement for group “New Statement 1” -->\n<STATEMENT>\n<PURPOSE>\n<admin/><contact/><current/><develop required=\"opt-out\"/><tailoring/><telemarketing/>\n</PURPOSE>\n\n<!-- Recipients -->\n<RECIPIENT><ours/><delivery/></RECIPIENT>\n\n<! -- Retention -->\n<RETENTION><legal-requirement/></RETENTION>\n\n<! -- Base datasync elements. -->\n<Data-Group>\n<Data ref=\"#user.name.family\" , DP = \"admin, contact, develop, tailoring\", DR = \"ours, delivery\"/>\n<Data ref=\"#user.info.phonenumber\" , DP = \"admin, develop, telemarketing\", DR = \"ours, delivery\"/>\n<Data ref=\"#user.info.contact\" , DP = \"admin, contact, develop, tailoring\", DR = \"ours, delivery\"/>\n<Data ref=\"#user.gender\", DP = \"current, DR = \"ours\" />\n</Data-Group>\n</STATEMENT>\n<STATEMENT>\n\n<! -- Statement for group \"library\" -->\n\n<STATEMENT>\n\n<PURPOSE>\n\n<admin/><contact/><current/><develop required=\"opt-out\"/><tailoring/><telemarketing/>\n\n</PURPOSE>\n\n<! -- Recipients -->\n\n<RECIPIENT><ours/></RECIPIENT>\n\n<RETENTION><legal-requirement/></RETENTION>\n\n<! -- Base dataschema elements. -->\n\n<DATAGROUP>\n\n<D ATA ref=\"#user.postal_no\", DP = \"current, admin, contact, develop, tailoring\", DR = \"ours, delivery \"/>\n\n<D ATA ref=\"#user.user_number\" DP = \"current, admin, develop, tailoring\", DR = \"ours \"/>\n\n<D ATA ref=\"#user.browserinformation\" DP = \"current, admin, develop, tailoring\", DR = \"ours\"/>\n\n</DATAGROUP>\n\n</STATEMENT>\n\n<! -- End of policy -->\n\n</POLICY>\n\nTable 14: Aggregated Result for P3P A and B\n\n7.8 Conclusion\n\nIn this chapter, we have presented the design choices for implementing the different parts and methods of our P3P policy aggregator tool. The overview of the prototype describes the features that are satisfied after the implementation. We presented an overview of the technologies used; Java Programming language, Dom4J, and XML. We discussed how the classes interact by presenting the UML of our implementation. We introduced the P3P merge tool, the graphical user interface, the program structure, and an example scenario of how the aggregate results are formed.\n\nIn the next chapter, we will conclude the thesis by reviewing the main contributions, the approach involved in our solution, the algorithms introduced, and the future work of the thesis.\nChapter 8\n\nConclusions and Future Work\n\n8.1 Conclusion\n\nIn current privacy practices, privacy statements are often informal and imprecise, making it necessary to resort to human intervention in order to detect and resolve issues. The P3P standard has been developed to promote the automation of privacy policies. After giving a summary of P3P’s main characteristics and solutions, we have given examples showing that the proper use of P3P and its enhancements can help the deployment and execution of privacy-sensitive services. The major objective of the thesis was to come up with a formal semantic approach and consistent rules to build a merger system on an aggregation platform, which is a potentially useful environment where the policy merger system can be used.\n\nIn this thesis, we have considered the use of the Platform for Privacy Preferences (P3P) language to encode privacy policies for services in a cloud-computing environment. This has led to several research contributions. We have implemented the concept of a three-way merge principle of two P3P policies. The several match cases considered in the thesis were identified in Chapter 6 and each of them was tested, to check the algorithm’s functionality. For enhancing the P3P semantics, we have extended the syntax rules of the P3P language to include a relational link that ties together the purpose, the recipient, and the data elements in the P3P policy. We have demonstrated that the relation between the purpose element and the data element in a statement will eliminate some known inconsistencies in the P3P language. Lastly, we have shown how to formally verify and validate the merged P3P policy, by modeling and checking policies using an Alloy model checker.\n8.2 Future Work\n\nThis section of the thesis provides a summary of the proposed directions suggested in [61]. In the future, we intend to consider some web privacy areas including a P3P policy solution for anti-phishing attacks, implementing P3P user agents for mobile applications, and locating service providers’ local P3P policies as suggested by [61]. These concepts are explained below.\n\n8.2.1 Policies and User agents for Mobile Apps\n\nSmart phones provide mobility and flexibility to users; however, privacy declaration methods do not exist for Smartphone applications. Usually we trust our smart phones more than our laptops because we carry them with us most of the time. As a smart phone becomes a part of our everyday life, many opportunities for privacy leaks may arise, like giving away important and personal information whenever users connect to the internet or download new applications. Smartphone applications or mobile website visits often can track user’s interactions or movements. Thus, some mobile users will want to know how the applications or mobile websites will use the information available to them, e.g., will they install tailoring cookies or tracking bugs on their smart phones? Will they allow third parties to install new applications? The third parties may not operate in the same way as the web site or application installed; they may have entirely different privacy policies, and the fact that they have users’ personal information may increase the chances of privacy compromises.\n\nFor example, users can use smart phones to assess or store their health information (web connection to the clinic) or financial information (mobile banking applications) for easy and fast connection in cases of emergency. The challenge here will be that users who are conscious of the information stored on or accessed via their phones may not want those applications or websites to take or misuse the information. This leads to the following research questions:\n\n- How to create a mobile-based privacy user agent that can communicate compact privacy policies of mobile web sites or applications to users.\n• How to delegate automatic access control privileges to mobile applications and websites based on user defined privacy preferences.\n\n8.2.2 Anti-Phishing Mechanism with the P3P Protocol\n\nFraudsters can create fake websites to lure users for collecting their data. This type of attack on users is called Phishing. Personal identity information such as username, passwords, and credit card details can be stolen by Phishing attacks from unsuspecting users by entities masquerading as trusted entities, such as PayPal sites. The main aim of phishers is to lead users to unsafe websites, and retrieve their personal data. Since the P3P policy on a legitimate website is freely available to the public, phishers can easily copy the P3P policies of the trusted websites and republish them on their fake websites. This can aid phishing attack schemes because P3P user agents that are trusted by the users will be misled by the P3P policy that appears to be associated with the fake site.\n\nThe P3P user agent will report a legitimate policy summary, perhaps with a (stolen) trust seal from a third party privacy seal organization. We suggest here a solution that is based on cryptographic techniques: the legitimate site should digitally sign its P3P policy using the private key that corresponds to the public key contained in a valid certificate for the site (possibly, but not necessarily, its SSL certificate). This signature can be done using the XML Signature format [13]. A P3P user agent, instead of simply downloading a P3P policy from a target site, would also engage in a challenge-response protocol with the site, submitting a one-time challenge (i.e., a random number that has not been used before) and receiving in return a digital signature on that challenge. If the user agent is able to verify this signature with the same public key that verifies the signature on the P3P policy, and if this public key is the one contained in the verified public key certificate issued to this site from a trusted Certification Authority, then the user can be certain that the downloaded P3P policy is actually associated with the website currently being accessed. A fake website would thus be unable to steal a P3P policy from a legitimate site to increase the probability of phishing success because the fake site does not know the real site’s private key and so would be unable to construct a proper response for the user agent’s one-time challenge.\n8.2.3 Geographically Locating P3P Policies\n\nMultinational companies are taking advantage of the web’s capabilities (file sharing, web applications, and fast communication); they now globally distribute their products on the web for customers in different countries. However, policy guidelines for multinational companies are usually determined by the governments of the countries where the regional websites are operating. These government guidelines may affect the posted websites’ privacy policies. More precisely, a branch of a multinational company in a particular country will only be bound by government guidelines or policies in that country. Thus, there is a need for Geolocating web users to know what policies should apply to their present location on the internet. The mechanism should allow multinational websites to accurately segment their global audiences and help the users to determine where (in which country) their data will be stored or if the government of the country where the website is located will have access to their personal data. For example, Amazon is a well-known multinational website located in countries like the USA (Amazon.com) and Canada (Amazon.ca). The two websites may have two different privacy policies adapted to each government’s laws and guidelines. In a scenario where a user wants to purchase a product on Amazon.ca, it may happen that because of product availability, the user gets redirected to Amazon.com. These policy differences can promote research topics and questions such as:\n\n- How will the user know the web location where his/her personal information will be stored? Will the other websites share their personal information?\n- What are the inconsistencies between the various policies involved, and what are the risks associated with them?\n- Most multinational companies do not bother to change their P3P policies, even if the privacy policies are modified according to the government guidelines. (E.g. Amazon.com/w3c/p3p.xml is available but Amazon.ca/w3c/p3p.xml is not). So redirected users may not get new summaries from their P3P user agents.\n\nIf a multinational company publishes P3P policies in a single domain, there should be a tool to determine the P3P file that will apply to the user based on its location.\nReferences\n\n\n2003, volume 1, issue 6, pp. 50-55.\n\n\n[31] X Fu, Conformance verification of privacy policies, in Proceedings of the 7th international\n\n\n[53] C Mar, *Privacy Bird for chrome*, in Privacy Policy , Law, and Technology Project. Pittsburgh,\n\n\n"}}},{"rowIdx":176,"cells":{"id":{"kind":"string","value":"2b6da381fa9002112aa8fbe8b9885e288c8607e0"},"text":{"kind":"string","value":"Network of Excellence\n\nDeliverable D2.4\n\nSecond Release of the Method and Tool Evaluation\n<table>\n<thead>\n<tr>\n<th>Deliverable Number</th>\n<th>D2.4</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Title of Deliverable</td>\n<td>Second Release of the Method and Tool Evaluation</td>\n</tr>\n<tr>\n<td>Nature of Deliverable</td>\n<td>R</td>\n</tr>\n<tr>\n<td>Dissemination Level</td>\n<td>Public</td>\n</tr>\n<tr>\n<td>Internal Version Number</td>\n<td>3.0</td>\n</tr>\n<tr>\n<td>Contractual Delivery Date</td>\n<td>September 30 2013</td>\n</tr>\n<tr>\n<td>Actual Delivery Date</td>\n<td>October 31 2013</td>\n</tr>\n<tr>\n<td>Contributing WPs</td>\n<td>WP2</td>\n</tr>\n<tr>\n<td>Editor(s)</td>\n<td>Marianne Busch (LMU) Nora Koch (LMU)</td>\n</tr>\n<tr>\n<td>Author(s)</td>\n<td>Alexander van den Berghe (KUL) Marianne Busch (LMU) Nora Koch (LMU) Riccardo Scandariato (KUL) Le Minh Sang Tran (UNITN)</td>\n</tr>\n<tr>\n<td>Reviewer(s)</td>\n<td>Benoit Baudry (INRIA) Manuel Clavel (IMDEA) Marina Egea (ATOS) Marinella Petrocchi (CNR)</td>\n</tr>\n</tbody>\n</table>\nAbstract\n\nThis report describes the approach of the NESSoS project related to the evaluation and comparison of security features, vulnerabilities, methods, notations and tools in the area of software engineering for secure software and systems. The approach has been further developed since it was introduced in deliverable D2.1. It is based on the CBK of WP5, which focuses on a knowledge base of existing methods, notations and tools. Additionally, our approach, named SECVAL, addresses the collection, analysis and finer-grained representation of security-specific knowledge.\n\nGetting an overview and collecting data of existing security engineering methods, notations and tools is of major importance for security and software engineers, as it helps them to take decisions about solutions for upcoming tasks. Security engineers usually rely on their experience and sometimes are limited in their decisions to the development context and architecture. Nevertheless, more often than not they would like to have access to compact information about security mechanisms in order to find a more effective method, an appropriate notation, useful CASE tools for developing prototypes and systems, and further tools needed in the Software Development Life Cycle (SDLC).\n\nThus, the objective is to further develop our strategy sketched in D2.1 for evaluating and comparing methods, notations and tools; this time mainly focusing on evaluation. Our approach SECVAL provides an ontology, which comprises: (1) a security context model describing security features, methods, notations and tools; (2) a data collection model, which records how data is collected when researchers or practitioners search for an answer to a question they have; (3) a data analysis model specifying how analysis, using previously collected data, is done.\n\nSECVAL was influenced by our prior works, an evaluation of approaches for secure software design and an empirical validation of risk-based methods.\n\nThereby, we provide an evaluation approach targeting security engineers who may also have research questions in mind which cannot be answered directly by the CBK and who want to use a sound, extensible model to specify their research actions as well as research results. Consequently, our approach is designed to ease the process of doing research in the area of security, no matter if the research question aims at scientific or engineering issues.\n\nKeyword List\n\n<table>\n<thead>\n<tr>\n<th>Version</th>\n<th>Type of Change</th>\n<th>Author(s)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0.1</td>\n<td>Table of Contents</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>0.2</td>\n<td>Questionnaire as appendix and first description of model</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>0.3</td>\n<td>SecEval description of security context</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>0.4</td>\n<td>SecEval description of data collection</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>0.5</td>\n<td>SecEval description of data analysis</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>0.6</td>\n<td>Chapters about guided interview</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>0.7</td>\n<td>Abstract and conclusion</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>0.8</td>\n<td>Introduction and spell-checking and improvements of the models</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>0.9</td>\n<td>Improvements of the models</td>\n<td>Marianne Busch, Nora Koch (LMU)</td>\n</tr>\n<tr>\n<td>1.0</td>\n<td>Proof reading, changes and comments</td>\n<td>Nora Koch (LMU)</td>\n</tr>\n<tr>\n<td>1.1</td>\n<td>Background chapter</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>1.2</td>\n<td>Chapter about Empirical Validation of Security Methods</td>\n<td>Le Minh Sang Tran (UNITN)</td>\n</tr>\n<tr>\n<td>1.3</td>\n<td>Literature review on secure software design</td>\n<td>Alexander van den Berghe, Riccardo Scandariato (KUL)</td>\n</tr>\n<tr>\n<td>1.4</td>\n<td>Chapter about case study</td>\n<td>Marianne Busch (LMU)</td>\n</tr>\n<tr>\n<td>2.0</td>\n<td>Improvements after internal reviews</td>\n<td>Marianne Busch and Nora Koch(LMU)</td>\n</tr>\n<tr>\n<td>3.0</td>\n<td>Final version</td>\n<td>Marianne Busch and Nora Koch(LMU)</td>\n</tr>\n</tbody>\n</table>\n# Table of Contents\n\n**LIST OF FIGURES** ........................................................................................................... 9\n\n1 **INTRODUCTION** ........................................................................................................... 13\n\n2 **BACKGROUND** ........................................................................................................... 15\n 2.1 General Evaluation Approaches .............................................................................. 15\n 2.2 Security-specific Evaluation Approaches ............................................................... 16\n\n3 **EVALUATION APPROACH IN THE SECURITY DOMAIN: SecEval** ................. 17\n 3.1 Requirements ............................................................................................................ 17\n 3.2 Ontology ................................................................................................................... 18\n 3.2.1 Security Context ................................................................................................. 20\n 3.2.2 Data Collection .................................................................................................. 26\n 3.2.3 Data Analysis ...................................................................................................... 27\n 3.3 Gathering Expert Knowledge .................................................................................... 30\n 3.3.1 Guided Interview ............................................................................................... 30\n 3.3.2 Results and Extensions ...................................................................................... 31\n\n4 **CASE STUDY ON SECURITY TESTING OF WEB APPLICATIONS USING SecEval** ........................................................................................................ 35\n 4.1 Data Collection ......................................................................................................... 35\n 4.2 Data Analysis ............................................................................................................ 36\n 4.3 Security Context Model ............................................................................................ 39\n\n5 **DOMAIN-SPECIFIC EVALUATION OF SECURITY MECHANISMS** ................. 41\n 5.1 Mapping Study on Secure Software Design ............................................................. 41\n 5.1.1 Review method ................................................................................................. 41\n 5.1.2 Discussion of the research questions ................................................................. 43\n 5.1.3 Identified Gaps .................................................................................................. 44\n 5.1.4 Limitations of this study .................................................................................... 46\n 5.2 Empirical Validation of Risk-based Methods ......................................................... 46\n 5.2.1 Research method ............................................................................................... 48\n 5.2.2 Reports’ Analysis .............................................................................................. 52\n 5.2.3 Questionnaire Analysis ..................................................................................... 56\n 5.2.4 Interviews’ Analysis ......................................................................................... 58\n 5.2.5 Discussion ......................................................................................................... 60\n 5.2.6 Threats to Validity ............................................................................................ 60\n\n6 **CONCLUSION** ............................................................................................................... 63\n\n7 **NESSoS THIRD-YEAR PUBLICATIONS** ................................................................. 65\n\n**BIBLIOGRAPHY** .............................................................................................................. 67\n\nA **APPENDIX: QUESTIONNAIRE** ..................................................................................... 73\n A.1 Security Engineering Method and Tool Evaluation ............................................... 73\n A.2 Questions and Suggestions ...................................................................................... 76\nList of Acronyms\n\nCASE Computer-Aided Software Engineering\nCBK Common Body of Knowledge\nCPU Central Processing Unit\nGUI Graphical User Interface\nKO Knowledge Object\nNESSoS Network of Excellence on Engineering Secure Future Internet Software Services and Systems\nOCL Object Constraint Language\nOWASP Open Web Application Security Project\nSDE Service Development Environment\nSDLC Software Development Life Cycle\nSLR Systematic Literature Review\nSWRL Semantic Web Rule Language\nUML Unified Modeling Language\nURL Uniform Resource Locator\nWP Work Package\nXSS Cross-site scripting\nList of Figures\n\nFigure 1.1: Overview of SecEval’s Evaluation Process .................................................. 14\n\nFigure 3.1: Stakeholders and Use Cases ................................................................. 17\nFigure 3.2: Model Overview ..................................................................................... 19\nFigure 3.3: Security Context ..................................................................................... 20\nFigure 3.4: Security Context: Connections between Tools, Notations and Methods .... 21\nFigure 3.5: Security Context: Details of Methods ..................................................... 23\nFigure 3.6: Security Context: Details of Tools .......................................................... 25\nFigure 3.7: Data Collection ....................................................................................... 27\nFigure 3.8: SecEval’s Evaluation Process ............................................................... 28\nFigure 3.9: Data Analysis ......................................................................................... 29\nFigure 3.10: Inclusion of basic risk evaluation approach ......................................... 32\nFigure 3.11: Method extension using Moody’s method evaluation approach ........... 32\n\nFigure 4.1: Case Study: Data Collection ................................................................. 36\nFigure 4.2: Case Study: Data Analysis – Results ...................................................... 37\nFigure 4.3: Case Study: Data Analysis – Ratings ..................................................... 38\nFigure 4.4: Case Study: Data Analysis – Values ....................................................... 38\nFigure 4.5: Case Study: Instances of Context Model (excerpt) ............................... 40\n\nFigure 5.1: The security dimension classifies each research work over what and how security properties are supported ................................................................. 43\nFigure 5.2: The evaluation dimension classifies each evaluation discussed in a research work over its type, level of description, domain and provider ................................................................. 44\nFigure 5.3: Access control is supported by considerably more approaches than other security properties ................................................................. 44\nFigure 5.4: A majority of 12 approaches support only one security property ........... 46\nFigure 5.5: Most approaches only support analysis for their security properties .......... 46\nFigure 5.6: There is no significant difference is amount of support between representation types ...... 47\nFigure 5.7: The large majority of evaluations found in literature are illustrative toy examples.\n\nFigure 5.8: Examples of Visual (CORAS) and Textual (SREP) Methods’ Artefacts.\n\nFigure 5.9: Expert assessment.\n\nFigure 5.10: Means of identified threats in all groups (left) and good groups (right).\n\nFigure 5.11: Means of identified security requirements in all groups (left) and good groups (right).\n\nFigure 5.12: Scatter plot of identified threats and security requirements for the two methods.\n\nFigure 5.13: The distribution of identified threats (left) and security requirements (right) within each facet.\n\nFigure A.1: Overview.\n\nFigure A.2: Security Context.\n\nFigure A.3: Security Context: Details of Tools.\n\nFigure A.4: Security Context: Details of Methods.\nExecutive Summary\n\nThis report describes the approach of the NESSoS project related to the evaluation and comparison of security features, vulnerabilities, methods, notations and tools in the area of software engineering for secure software and systems. The approach has been further developed since it was introduced in deliverable D2.1. It is based on the CBK of WP5, which focuses on a knowledge base of existing methods, notations and tools, which are summarized by the term Knowledge Object (KO). Additionally, our approach, named SecEval, addresses the collection, analysis and finer-grained representation of security-specific knowledge.\n\nGetting an overview and collecting data of existing security engineering methods, notations and tools is of major importance for security and software engineers, as it helps them to take decisions about solutions for upcoming tasks. Security engineers usually rely on their experience and sometimes are limited in their decisions to the development context and architecture. Nevertheless, more often than not they would like to have access to compact information about security mechanisms in order to find a more effective method, an appropriate notation, useful CASE tools for developing prototypes and systems, and further tools needed in the SDLC.\n\nThus, the objective is to further develop our strategy sketched in D2.1 for evaluating and comparing methods, notations and tools; this time mainly focusing on evaluation. Our approach SecEval provides an ontology, which comprises: (1) a security context model describing security features, methods, notations and tools; (2) a data collection model, which records how data is collected when researchers or practitioners do research to answer a question they have; (3) a data analysis model specifying how analysis, using previously collected data, is done.\n\nSecEval was influenced by our prior works, an evaluation of approaches for secure software design and an empirical validation of risk-based methods.\n\nThereby, we provide an evaluation approach targeting security engineers who also have research questions in mind which cannot be answered directly by the CBK and who want to use a sound, extensible model to specify their research actions as well as research results. Consequently, our approach is designed to ease the process of doing research in the area of security, no matter if the research question aims at scientific or engineering issues.\n\nWith our evaluation approach, called SecEval, we do not claim to provide a one-fits-all ontology for IT-security (which would horribly overload any model), but introduce an extensible basis. SecEval defines an ontology which is represented using graphical models. It comprises:\n\n- A security context model describing security properties, vulnerabilities and threats as well as methods, notations and tools.\n- A data collection model, which records how data is collected when a researchers or practitioners do research to answer a question.\n- A data analysis model specifying, how analysis using previously collected data, is done.\n\nTo verify our approach, we used SecEval for a case study in the area of security testing of web applications.\n\nPrior to our work on SecEval, we performed two domain-specific evaluations of KOs: an evaluation of approaches for secure software design and an empirical validation of risk-based methods. The former is a study which provides an overview of the current state of the art regarding secure software design. The latter study compares a textual method and a graphical method for identifying threats and possible mitigations. Both works, beyond others, influenced the construction of SecEval.\n\nAfter a short motivation, the deliverable starts describing the background of our evaluation approach, especially the connection to the CBK in chapter 2. Chapter 3 presents our evaluation approach called SecEval and a guided review with a questionnaire we used to improve it. Chapter 4 provides an example of instantiation of our model in form of a case study about methods and tools from the area of security testing. Chapter 5 introduces two examples of domain-specific KO evaluations. Finally, chapter 6 summarizes and sketches future steps and chapter 7 lists the NESSoS publications that are relevant for this work.\n\nNote that the Service Development Environment (SDE) and its 20 integrated tools are not discussed in this deliverable. For further information about the SDE, please refer to deliverables D1.4 [2] and D2.3 [11].\n1 Introduction\n\nSoftware and security engineers constantly make decisions about which technology should be used in the different phases of the Software Development Life Cycle (SDLC). Therefore, a cost-benefit analysis and a subsequent selection of appropriate Knowledge Objects (KOs) (i.e., methods, tools and notations) for a specific task, play an important role. More often than not, there is no time to investigate on alternatives to well-known ones used so far. Most of the questions which arise are not entirely new, but useful scraps of knowledge are distributed in papers, books or the web, or just exist in the head of colleagues working at another department. What makes it even worse is that engineers often have to start from the very beginning by defining the process of evaluating KOs as well as the structure of the results from scratch, i.e. without having a template for their domain.\n\nTo ease the tasks of recording own results and of getting an overview of existing KOs, we introduced an ontology in deliverable D2.1 that works hand in hand with the Common Body of Knowledge (CBK) [13] which was implemented as a semantic Wiki within the scope of WP5. In the conclusion of deliverable D2.1 we stated that “it became apparent that comparisons can be drawn best for enumeration types” and that we wanted to further develop the approach. As time passed, we gained further experience in working with the CBK which raised three questions:\n\n- How could our ontology be improved, so that security-related features become first-class citizens?\n- How can we use our ontology for finding answers to research questions beyond comparing methods, notations and tools?\n- How is the process of data collection and data analysis specified, to make sure that emerging research results are comprehensible and valid?\n\nEvaluation in the area of cybersecurity does mean for us, e.g., to find out which authentication-related threats can or cannot be mitigated by a method, for which tool-support is implemented. Furthermore, it is advantageous to know which tools work together and can be used in a row and which notations are supported as tool inputs. Up to now, these kinds of questions require researchers to document their approaches and results in a self-made way. Consequently, other researchers, who want to build on those results, have first to understand many different schemas documenting research processes and their results. This is not only annoying and time-consuming, but also error-prone, as misunderstandings easily occur.\n\nWith our evaluation approach, called SecEval, we do not claim to provide a one-fits-all ontology for IT-security (which would horribly overload any model), but introduce an extensible basis. SecEval defines an ontology which is represented using graphical models. It comprises:\n\n- A security context model describing security properties, vulnerabilities and threats as well as methods, notations and tools.\n- A data collection model, which records how data is collected when researchers or practitioners do research to answer a question.\n- A data analysis model specifying, how analysis using previously collected data, is done.\n\nA simplified example of the process of using SecEval for evaluation is depicted in Figure 1.1. Research questions initiate the process of data collection, where sources (as papers, websites, ...) are gathered. These sources are then analyzed, which means to extract information, possibly process it and record it using SecEval’s security context model.\n\nTo verify our approach, we used SecEval for a case study in the area of security testing of web applications.\n\nPrior to our work on SecEval, we performed two domain-specific evaluations of Knowledge Objects (KOs): an evaluation of approaches for secure software design and an empirical validation of risk-based methods. The former is a study which provides an overview of the current state of the art regarding secure software design. The latter study compares a textual method and a graphical method for identifying threats and possible mitigations. Both works, beyond others, influenced the construction of SecEval.\nBackground/Foreground. The background for this deliverable was described in deliverable D2.1 and D5.4. More about the background of this work can be found in chapter 2.\n\nRelations to other work packages. As written above, we introduced an ontology in deliverable D2.1 which works hand in hand with the CBK. The CBK was developed in WP5 and contains information about 163 security engineering methods, notations and tools, used and developed within the NESSoS project as well as from outside the project.\n\nStructure of the deliverable. Chapter 2 describes the background of our evaluation approach, especially the connection to the CBK. Chapter 3 presents our evaluation approach called SEC\\textsc{e}VAL and a guided review with a questionnaire we used to improve it. Chapter 4 provides an example of instantiation of our model in form of a case study about methods and tools from the area of security testing. Chapter 5 introduces two examples of domain-specific KO evaluations. Finally, chapter 6 summarizes and sketches future steps and chapter 7 lists the NESSoS publications that are relevant for this work.\n2 Background\n\nIn this chapter, we introduce related work in the area of evaluation of methods, notations, tools, vulnerabilities, threats or security features. Evaluation approaches are often tailored to the needs of a specific area. We start by introducing general approaches and continue with those which are security-specific.\n\n2.1 General Evaluation Approaches\n\nKitchenham et al. [39] specify so called “Systematic Literature Reviews” (SLRs) in software engineering. The aim is to answer research questions by systematically searching and extracting knowledge of existing literature. The systematic literature review is executed in three main steps: first, the review is planned, then it is conducted and finally results are reported (this process is depicted in deliverable D5.2 [5, Fig. 3.2]).\n\nOur approach, SECEVAL, is based on their work. We focus on the use of arbitrary resources, as source code or experiments which are carried out to answer a research question. Furthermore, we specify a basic graphical structure for results (context model) which is security-specific. However, SECEVAL can also be used for methods, notations and tools which are not especially related to security features or it can be extended to also cover other areas of interest. In contrast to Kitchenham’s approach, the process we define is generic and thus allows us to refine the way of searching while being in the phase of collecting data. Refining the search means to collect data during several phases, e.g., to perform a breadth-search before a concrete plan for a subsequent depth-search is made.\n\nSIQinU (Strategy for understanding and Improving Quality in Use) [4] is a framework for evaluating the quality of a product version which can then be improved. It uses the conceptual framework C-INCA M (Contextual-Information Need, Concept model, Attribute, Metric and Indicator), which specifies concepts and relationships for measurement and evaluation. SIQinU defines a strategy using UML activity diagrams whereas C-INCA M is specified by a UML class diagram. C-INCA M consists of six modules which are modeled as UML packages:\n\n- measurement and evaluation project definition\n- nonfunctional requirements specification\n- context specification\n- measurement design and implementation\n- evaluation design and implementation\n- analysis and recommendation specification\n\nFor example, in the package “evaluation...” they specify a decision criterion which defines thresholds which are used to determine the need for action (i.e., improvement of quality in order to fulfill requirements). Although C-INCA M is used for the domain of quality evaluation and not for the domain of security Knowledge Objects (KOs), we recognized several properties we wanted to take care of in our own approach. UML class diagrams seem to be a sound way to represent concepts and relationships between them. Separation of concerns can easily be implemented by using several packages; however the overall size of the model should not get too big. We wondered why we found no paper that is depicting all six C-INCA M modules. This reduces the advantage of graphical models, which usually is to quickly provide an overview. Besides, names for classes and their attributes have to be chosen with caution in order to avoid permanent lookups in the specification.\n\nMoody [51] proposes an evaluation approach which is based on experiments. Practitioners use methods and afterwards answer questions about perceived ease of use, perceived usefulness and intention to use. Further details and how Moody’s approach can be integrated in SECEVAL are discussed in subsection 3.3.2.\n\nThe CBK (Common Body of Knowledge) [6] defines an ontology for software engineers to describe Knowledge Objects (KOs), which are methods, techniques, notations, tools or standards. Techniques are methods which do not specify activities for applying the method. Note that those activities do not necessarily have to be supported by a tool. We use the CBK as a starting point for SECEVAL’s ontology,\nalthough in our context model we do not focus on standards and we aggregate the concepts of technique and method, as an instance model immediately shows whether actions (in our case called steps) are defined.\n\nThe CBK is implemented as a semantic Wiki [13] and serves as a knowledge base containing all relevant information about existing KOs. At the moment it is primarily used and improved by security- and software engineers who are related to NESSoS. Further information about the improvement process of the CBK can be found in D5.3 [7,6]. Unlike the CBK, SECEVAL is not implemented yet.\n\nIn deliverable D2.1 [10] we defined relations between KOs and exemplarily compared methods, notations and tools in a tabular way. SECEVAL is built on our experiences with the CBK and deliverable D2.1, which lead to the three questions we asked in the previous chapter.\n\n2.2 Security-specific Evaluation Approaches\n\nWe also have a look at existing evaluation approaches which are security-specific. To the best of our knowledge, no framework exists which is as comprehensive as SECEVAL.\n\nFrameworks which are more specific often consider concrete systems for their evaluation. An example is the OWASP Risk Rating Methodology [22], where the risk for a concrete application or system is estimated. As usual, estimation is based on factors for estimating likelihood and impact. Factors are made up by questions with predefined answers, which are rated from 0 to 9. The overall severity of the risk is then calculated by multiplying ratings of likelihood and impact.\n\nFor SECEVAL, we added vulnerability-dependent features of the OWASP model, as e.g., the difficulty of detecting or exploiting a vulnerability. Features that are related to a concrete system and the rating of a possible attack are introduced as an extension of SECEVAL in subsection 3.3.2.\n\nThe i* [66] metamodel is the basis of a vulnerability-centric requirements engineering framework introduced in [20]. The extended, vulnerability-centric i* metamodel aims at analyzing security attacks, countermeasures, and requirements based on vulnerabilities. The metamodel is represented using UML class models. Instances of this metamodel use different i* notations which are not based on UML. Main elements of the metamodel are: vulnerability, attack (which can exploit a vulnerability; executed by an actor), effect and security impact (e.g., on a resource).\n\nAnother approach which is focused on vulnerabilities is described by Wang et al. [70] They come up with a concept model which is less detailed than the i* metamodel. Their aim is not to describe reality by using graphical models, but to create a knowledge base which can then be queried using a language for the semantic web, called SWRL.\n\nMoyano et al. [54] provide a Conceptual Framework for Trust Models which is also represented using UML. As trust is an abstract concept, which emerges between communication partners, we do not consider it in SECEVAL. However, strategies how to build a network of trust can be modeled in SECEVAL using the concept of a “method”.\n\nGenerally, we prefer to represent evaluation structures in a graphical way, as it allows to quickly get an overview of what is important for an evaluation. Additionally, a description should be provided so that details can be looked up. For example, the C-INCAMI model uses UML to specify concepts as metrics, indicators or decision criteria.\n\nWhen it comes to recording evaluation results, we favor approaches that provide a basic structure, as e.g., the CBK does. We do not think that this structure has to be graphical at any cost, as text- or table-based versions also have their advantages, especially for huge amount of data. However, we provide a graphical structure, because relation between several elements can be recognized at a first glance. In case graphical instance models get bigger during the evaluation process, we suggest to use them only for the main results in order to give an overview. More detailed information can then be provided using tables or texts which are linked from the model. The best reusability of data seems to be given when the structure is implemented in a semantic Wiki, as shown by the CBK. This allows that researchers can add their knowledge in a more or less structured way.\n3 Evaluation Approach in the Security Domain: SECeval\n\nOur aim is to provide an approach for the evaluation of methods, notations and tools for the engineering of secure software systems. Evaluation should also be possible for security properties, vulnerabilities and threats. In this chapter we first introduce our conceptual evaluation framework SECeval [12] which can be used to collect and describe security-related data and metrics to analyze it. Second, we describe how we gathered expert knowledge to verify the soundness of our approach. For the graphical representation of concepts and relationships we selected the UML notation, as we think it fits our needs best.\n\n3.1 Requirements\n\nWe start eliciting the requirements of such a framework, i.e. which stakeholders are involved, which concepts play a role in secure software and evaluation of methods, tools and notations, and how those concepts are related. Therefore, the first step is to name the common stakeholders for secure software: security engineers (i.e. security designers and developers), normal users of the software and attackers. In some cases, users can attack software without knowing it, e.g., when they have a virus installed. For us, those users are also classified as attackers, as well as developers which are e.g. trying to smuggle malicious code in the software. Figure 3.1 depicts stakeholders and use cases in a UML Use Case diagram.\n\nFigure 3.1: Stakeholders and Use Cases\nThe Evaluation package at the top contains all use cases related to evaluation, whereas SDLC at the bottom of the diagram refers to security-related tasks within the Software Development Life Cycle (SDLC). From time to time, all tasks within the SDLC require evaluating possibilities, as for example, which tool should be used for gathering security requirements or for designing secure web applications.\n\nThe «include» dependencies show the order of use cases in the SDLC: implementing secure software requires having a design, and having a design implies that requirements were elicited beforehand. Both, the attacker and the security engineer can identify vulnerabilities, whereas the former usually attacks it and the latter tries to patch it, which is modeled using an «extend» dependency. Those patches can then be installed by users (which also might happen using an automatic update function). While designing software, security requirements need to be identified by the designer or developer.\n\nFor security experts it is helpful to know common security methods and tools that support this method. An umbrella term for methods, tools or notations and linked security properties, vulnerabilities and threats is Knowledge Object (KO). Gathering knowledge usually starts with selecting an evaluation framework, or by (re)inventing one. The framework should record the strategy for collecting and analyzing data in a structured way and support the strategy with suitable means.\n\nCollecting data means to access data, e.g., in papers and to record data, e.g., by conducting empiric studies or executing benchmarks. Analyzing data includes comparing and transforming data as well as the evaluation of risks. An example for a small evaluation is the question during the implementation which library for authentication should be used. A more elaborated evaluation could be the evaluation of risks for a concrete software system which is important in all SDLC phases.\n\n3.2 Ontology\n\nWe first give an overview of SecEval, before going into detail about context model, data collection and data analysis model in the following subsections.\n\nSecEval provides a structure for data as well as a structure to perform a data analysis on the collected data. The aim of analyzing data is to convert facts (e.g., tool $A$ can do this) into context-related knowledge (e.g., tools $A$ and $B$ support the same method, however tool $B$ fulfills our requirements better than $A$ does). Security engineers or attackers thus can choose our evaluation framework SecEval in order to evaluate KOs.\n\nWe depict the concepts and their relationships as a UML model, so that we can instantiate concrete KOs. The use cases from our requirements analysis were a starting point to identify relevant concepts related to security for using and evaluating methods, notations and tools in the software engineering process. We grouped these concepts in three packages: Security Context, Data Collection and Data Analysis. Figure 3.2 shows our ontology represented as a UML class diagram.\n\nThe Security Context package is used to specify the object-oriented data structure we use for describing methods and related security features, notations and tools. Within the Security Context package we represent a security feature as a class element. The classes Method, Notation and Tool inherit general attributes, as e.g., a problem description and whether or not it is based on standards, from the abstract class Mechanism. Additionally, a tool can support methods and a notation can be used for several methods. In this document we also use the upper-case term “Mechanism” when referring to a method, a notation or a tool.\n\nHaving a well-defined data structure which is extensible is one thing, collecting concrete data the other. The package Data Collection contains the search process as well as research questions which should be investigated.\n\nResearch questions define what is inside and outside the scope of research. Before specifying the research questions, a basic understanding of the context is needed, therefore a dependency, stereotyped «use», points from ResearchQuestion to the package SecurityContext. An example question would be “I want to plan how authorization is implemented in my web application for online banking. Which methods exist to support me in this task and which tools can support a secure implementation of authorization issues?”? Queries can be defined accordingly. They are used to find matching sources containing data which might help to answer the research questions. Research questions are questions that ask for results from research and define as precisely as possible what should be in the scope (and what not). Please note that for us the term “research question” does not have to refer to scientific research questions.\nAfter collecting data, the source data may consist of, e.g., some papers, several websites or code. The process of extracting information from the data is called **Data Analysis**. An analysis strategy defines criteria which are important for answering the research question, like costs or preconditions. These criteria are used to classify information which is extracted from the sources. Information can also be processed, for example one could calculate annual costs for tools. The instructions used for those calculations are referred to as **AnalysisAlgorithm** in Figure 3.2. Each piece of information (processed or not) can relate to classes of the security context model, e.g., a tool can be described using information from the website of the tool. Although, information does not have to be related to a context model’s class, as we might want to express aggregated values as for example the average costs of testing tools on the market.\n\nIn practice this implicates that the basic ingredients for an evaluation are:\n\n- a research question to answer,\n- search terms as a basis for searching resources, as online data bases or terms for asking experts,\n- promising sources after finishing a search process,\n- an analysis strategy that describe which sorts of information should be extracted and how it can be grouped by categories and eventually how they should be processed by an analysis algorithm,\n- a set of information which can describe properties of methods, notations and tools (cf. security context) with a criterion attached to each information which provides, e.g., a metric (which could read “all costs should be given in Euros” or “percentages should be represented by $\\ldots, -0, +$ and $++, +$” using a step size of 20%),\n- data which is not assigned to Mechanism(s) or should be categorized additionally can also be expressed using the modeling elements **Information** and **Criteria**.\n\nIn the following, going into more detail describing the three aspects of our conceptual ontology: security context, data collection and data analysis.\n3.2.1 Security Context\n\nFigure 3.3 shows the data structure of the Security Context package. The aim of this package is to provide a sound structure to be able to classify security-related methods, notations and tools together with security properties, vulnerabilities and threats. We introduce an abstract class Mechanism from which the classes Method, Notation and Tool inherit the common attributes such as goals, costs, basedOnStandards, etc. Once Mechanisms are described using this description model, it should be easy to get an overview of existing security-related methods, tools and notations for a certain area. Furthermore, the package should serve as a flexible basis and starting point for an evaluation, which means that it can be adopted to fit the needs of the researcher to examine a concrete research question.\n\nIn Figure 3.3, for convenience enumerations’ texts are grey and the background of classes which can directly be instantiated is colored. All attributes and roles are typed; however the types are not shown in the figures due to brevity. Many types are obvious to be boolean (can, has, is) as binary answers (true, false) can quickly give an overview of the main characteristics of a Mechanism. For a concrete implementation we suggest to use the values true, false and undefined to make clear whether or not an attribute is set. Generally, enumerations should be extensible when it comes to an implementation of our model. The CBK implements this behavior by providing a suggestion field for additional enumeration item. If the same enumeration item is suggested many times, it will become part of the default enumeration.\n\nThe full MagicDraw 17.0\\(^1\\) model can be downloaded from the Web.\\(^2\\)\n\nExplanations of the security context packages’ elements are given one by one in the following.\n\n---\n\n2SecEval Project. http://www.pst.ifi.lmu.de/~busch/SecEval/SecEval.mdzip\n\nFigure 3.3: Security Context\n\nAs mentioned above, a MECHANISM is an abstract notation for a method, notation or tool. It can be\ndescribed by a problem statement, by the goals it strives for, by its costs and by the consequences it implies. Mechanisms can be based on standards or be standardized themselves. They can have arbitrary many creators, as companies, inventors or developers. Before applying a Mechanism, the preconditions that are necessary to use it have to be fulfilled. Furthermore, an estimation regarding technical maturity and adoption in practice should be given. We also like to generally express whether or not the mechanism has a special focus on security, because in practice many mechanisms can also be used for security purposes, but do not directly focus them. Several levels of usability can be stated according to the experience a user needs to use a mechanism, e.g., a certain mechanism should best be used by trained users and experts. The kind of user can be specified by selecting roles which are proposed to use the Mechanism.\n\nA METHOD has some general attributes, which are used to describe the method at a high level of abstraction, as input, output and if it is model-driven. For more extensive methods, each step of the method can also be described in detail, if necessary. A method or step can be supported by notations or tools.\n\nAn advantage of our model is that it can easily be extended. If someone needs a more detailed approach, further elements can be added. For example the steps to be taken while using certain method can be described by more attributes, like a step number, or a boolean which indicates if the step can be repeated iteratively, etc. Further details about methods are provided in the description on page 22.\n\nFor a NOTATION, we consider characteristics such as whether the notation is graphical, textual or based on a tabular representation. We also added a level of formality, which ranges from informal to formal.\n\nFor us, the description of a TOOL comprises the information of languages it is written in, of operating systems it supports, of frameworks it uses and of technical requirements, which have to be fulfilled in order to use it. The tool (or its parts) are released under certain licenses. Additionally, the needed time for installation and configuration can be provided. Booleans are used to describe if the tool can be used interactively or autonomously, if it has start parameters, a GUI or a text-based user interface. Further details about tools are provided in the description on page 25.\n\nAs seen before, a tool supports a certain method. However, we have not yet defined the quality of this support. Does the tool fully support the method? Does it partially support the method and which parts are not supported?\n\nWe add this information using the association class ToolSupportedMethod, as depicted in Figure 3.4 with a dotted line. The association class itself is inherited from the class Method, thus can redefine attributes. For instance, a design tool can partly support a model-driven method (e.g., by facilitating the modeling process), although it cannot generate artifacts. In this case, DesignM.canGenerateArtifacts would be set to false (cf. p. 22).\n\nA method can extends on other methods, which means it might also change them. In case the role extendedMethods should be further specified, we recommend adding an association class which inherits from the class Method (similar to the association between method and tool). In this way, it can be exactly described if and how the original methods are modified. It is also possible that other methods are used without changes (role usesMethods).\nA tool can be based on other tools, which is especially the case when libraries are used or when plugins are written. Notations can also be based on other notations, for example many context-specific extensions for UML exist.\n\nIn addition, we adopted the abstract KNOWLEDGEOBJECT (KO) which was used in previous work to record most information of elements which are described. For SEC EVAL, we applied separation of concerns so that only very general descriptions remain as attributes in a KO, which can be applied to all elements. Therefore, the class knowledgeObject has names, tags and related sources, which could be any kinds of sources, as publications or URLs. A description and examples allow to quickly learn about a specific KO.\n\nSecurity properties, vulnerabilities and mechanisms are kinds of KOs. The relationship “x is a kind of KNOWLEDGEOBJECT” is modeled by a UML inheritance.\n\nWe consider a SECURITY PROPERTY to represent basic concepts of security. A security property can be, e.g., authorization, authentication, integrity, etc. The attribute SecurityGoal denotes a string and describes the goal of the property, for instance authentication “is the act of confirming the truth of an attribute of a datum or entity”\\(^3\\). Security properties can also be based on other security properties, as authorization is based on authentication.\n\nA VULNERABILITY is “a weakness which allows an attacker to reduce a system’s information assurance”\\(^4\\). Thus, it endangers security properties. Examples are XSS, SQL Injection, Buffer Overflows, etc. Methods can detect such vulnerabilities or shield them from being exploited by a threat. Every vulnerability is located at least in one location (which is modeled as a UML enumeration). Furthermore, we include the categorization scheme from OWASP TOP 10 \\(^{23}\\) (which is adapted from the OWASP Risk Rating Methodology \\(^{22}\\)) using exploitability, prevalence, detectability and impact levels. The difficulty theoretical means that it is practically impossible to detect or exploit a vulnerability.\n\nA THREAT is a “possible danger”\\(^5\\) that may exploit vulnerabilities. We treat a threat as a kind of method which is vicious. At least one vulnerability has to be affected, otherwise a threat is not malicious (and the other way around), which is denoted by the multiplicity \\([1..\\star]\\). Additionally, threats can be mitigated by other methods.\n\n**Methods in the Context of the SDLC**\n\nIn Figure 3.6 resp. 3.5, the classes Tool and Method are refined according to their usage in the SDLC, because the attributes which are used to describe a method or tool are related to the SDLC phases it covers. The phases of the SDLC are those we have chosen to classify tools and methods in D2.1 \\(^{10}\\): requirements, design, implementation, testing, assurance, risk & cost, service composition and deployment. We added the phase “runtime” as a category to distinguish methods and tools that operate at the runtime of a system without being plain testing tools. Examples are attack tools. Notations were not associated with phases of the SDLC as they are located in the same phase than the method they support and as far as we know, no phase-related attributes are needed to describe features of notations.\n\nFigure 3.5 again depicts our class Method. The abstract class MAreasOfDev is a wildcard for detailed information about the method. As mentioned above, we group attributes according to the phases of the SDLC. This means that a method can support several development phases. For example a method can be used to design a secure application and the method also describes how to build an implementation accordingly. In this case, the attributes of the classes DesignM and ImplementationM would be used to describe the method.\n\nThe meaning of the attributes is described in the following:\n\n- **RequirementsM.comprisesElicitation** is set to true if a method is used for requirement elicitation.\n- **RequirementsM.comprisesAnalysis** is set to true if a method comprises the analysis of requirements.\n- **RequirementsM.comprisesSpecification** is set to true if a requirements specification is part of a method.\n- **RequirementsM.comprisesManagement** is set to true if the management of requirements is defined by a method.\n- **RequirementsM.levelOfDetail** describes how detailed the method’s requirements features are. As this is a subjective value, we recommend adding a short explanation.\n\n---\n\n\nFigure 3.5: Security Context: Details of Methods\n\n- **DesignM.isUsedForCommunication** is set to true if a design method is also used for communication purposes, such as UML.\n\n- **DesignM.canGenerateArtifacts** is set to true if the method specifies the generation of artifacts (code, configuration files, . . . ) out of the design of an application.\n\n- **ImplementationM.supportedLanguageTypes** are the types of languages which are supported by a method. An example would be: “functional programming languages” are supported by a method which auto-completes fragments of code.\n\n- **ImplementationM.inspectsArtifacts** is true if the method relies on read access to artifacts, such as program code.\n\n- **ImplementationM.writesArtifacts** is true if the method writes artifacts, as in the above-mentioned example of code completion.\n\n- **ImplementationM.changesArtifacts** is true if the method changes existing artifacts.\n\n- **ImplementationM.completesArtifacts** is true if the method completes already existing artifacts. An example is the auto completion used in development environments.\n\n- **ImplementationM.givesSecurityAdvice** is true if security-related hints are provided during the implementation.\n\n- **TestingM.isTestingWebApp** is true if a method describes how to test web applications.\n\n- **TestingM.isTestingNetwork** (same with network-related testing)\n\n- **TestingM.isTestingSystem** (same with system-related testing; the system refers to a soft- or hardware system)\n\n- **TestingM.isWhiteboxTest** is true if the method is based on white-box tests, which means that the tester has full access to all internal details of a system.\n\n- **TestingM.isBlackboxTest** is true if the method is based on black-box tests, which means that code and other internal details cannot be accessed by a tester.\n\n- **TestingM.isGreyboxTest** is true if the method uses tests that are a mixture of white-box and black-box tests, which means that the tester can access some internal details of the system, but not all.\n\n- **DeploymentM.versionTrackingApproach** describes the approach which is used for tracking available versions of a piece of software.\n\n- **DeploymentM.adaptionProcessToNewEnv** describes the process which is specified for adapting software to a changed environment, e.g., if hardware is changed.\nDeploymentM.updateProcess describes the process for updating software.\n\nAssuranceM.usedFormalisms lists the formal methods that are used by an assurance-related method. This is a shortcut in case we do not want to model those formalisms as a method on its own.\n\nAssuranceM.assuranceCriteria gives the criteria the assurance process relies on.\n\nAssuranceM.canProvideCounterExample. In case formal methods are applied, it often makes sense to provide a counter example. The attribute is true in case the method can give at least one.\n\nAssuranceM.canProvideProof is true if a formal proof for a certain criterion can be given.\n\nProtocolVerification.usedAdversaryModels. Protocol verification is an example how to go into more detail without changing the core of SECVAL: e.g., the used adversary models can be specified with this attribute.\n\nProtocolVerification.usedEquation describes the equation which is used.\n\nProtocolVerification.usesFixedProperties is true if fixed properties are used for the protocol verification.\n\nRiskAndCostM.usedIndicators names the indicators used to analyze security-related risks and costs.\n\nRiskAndCostM.supportsRiskIdentification is true if the method gives advice how to identify risks.\n\nRiskAndCostM.supportsRiskAssessment is true if the method supports risk assessment approaches.\n\nRuntimeM.worksWithLanguages lists programming languages on which the method can be applied. Usually, methods which define techniques related to the runtime behavior of the targeted system are rather language-specific.\n\nRuntimeM.canDamageSystem is true if the method describes how to damage a running system. This applies especially for attack-related methods.\n\nRuntimeM.canInsertData is true if the method allows data to be inserted into the running system so that the system uses it.\n\nRuntimeM.canAlterData is true if the method comprises changing data.\n\nRuntimeM.canStealData is true if the method defines how to steal data.\n\nRuntimeM.canInspectData is true if the method assumes that inspecting data is possible. This does not include that data can also be transferred outside of the system, which would be stealing.\n\nRuntimeM.canInspectFlow is true if the flow of data can be inspected.\n\nRuntimeM.canGenerateFlow is true if a data flow chart can be generated.\n\nRuntimeM.canBlockFunctionCalls is true if the method specifies how to block function calls.\n\nServiceCompositionM.supportedTypesOfServices names services which are eligible to be composed.\n\nServiceCompositionM.securesServiceComposition is true if the method describes how to secure a service composition.\n\nServiceCompositionM.knowsAvailableServices is true if the concept is to know available services.\n\nServiceCompositionM.isCentralized is true if the method anticipates a centralized instance for being applied.\n\nPlease notice that the value “true” for attributes, as e.g., “RiskAndCostM.supportsRiskIdentification” can also mean that the risk identification strategy is “foreign”; i.e., the method does not support it itself, but the method comprises another method which supports risk identification. (Reminder: comprising another method is modeled using the role Method.reusedMethods or Method.extendedMethods.)\n\nWhen implementing the security context model in a similar way than the CBK, it might be helpful to add axioms to our ontology. Axioms state assertions which have to be true. In our case, we could think about rules to describe dependencies between attributes, as e.g., that isWhiteboxTest and isGreyboxTest cannot be true at the same time, or that extendedMethods should not point to the same method. In UML those axioms are usually expressed using the Object Constraint Language (OCL) [56] statements. However, we want to keep our model as simple as possible, especially because OCL statements quickly get cryptic and overload the model.\nFigure 3.6: Security Context: Details of Tools\n\nTools in the Context of the SDLC\n\nFigure 3.6 shows the class Tool and gives additional information about features of a tool. Usually, a tool can execute more than one functionality; very often they are grouped by purpose. For functionalities input and output can be specified and they can be used to build tool chains, using the output from one tool as input for another tool, as implemented in a tool workbench, namely the SDE. For further information about the SDE see deliverable D2.3 [11].\n\nSimilar to methods, tools and their functionalities can be described according to the areas of development they cover:\n\n- **RequirementsT.supportsHandwrittenSketches** is true if handwritten sketches can be managed with the tool.\n- **DesignT.generatedArtifacts** lists artifacts (like code) that can be generated by the tool.\n- **ImplementationT.worksWithLanguages** names languages which are supported by the tool. Examples are tools which perform auto-completion on the code. The related method might be called “auto-completion on imperative languages” and a tool could support Java.\n- **TestingT.targetLanguages** lists languages the target system can be written in so that the testing-related tool can be applied.\n- **TestingT.targetArchitectures** describes how the system architecture has to look like in order to test it with the tool.\n- **TestingT.targetFrameworks** names target frameworks that are supported by the tool.\n- **DeploymentT.usedExploitDatabases** refers to databases containing up-to-date exploits.\n- **DeploymentT.canInstallSoftware** is true if tool is able to install software.\n- **DeploymentT.canConfigureSoftware** is true if tool is able to configure software.\n- **DeploymentT.canAdaptSoftwareToChangedEnv** is true if the tool can adapt software to a changed environment, e.g., a changed hardware environment or a changed server configuration.\n- **DeploymentT.canUpdateSoftware** is true if the tool can update software.\n- **DeploymentT.canUninstallSoftware** is true if the tool can uninstall software.\n- **DeploymentT.hasVersionManagement** is true if the tool can track versions of software, which means it manages which versions of different software can be used together.\n- **DeploymentT.canCheckSecureInstallation** is true if the tool can make sure that software was installed correctly so that security requirements are fulfilled.\nDeploymentT.canCheckCorrectInstallation is true if the tool can make sure that software was installed correctly.\n\nDeploymentT.isConnectedToConfigurationMngt is true if the tool is connected to or implements a configuration management system.\n\nAssuranceT.canExportLaTeXproof is true if a proof is part of the assurance-related method and it can be exported as LaTeX formulae.\n\nAssuranceT.canVisualizeAttacks is true if attacks can be visualized using graphical models.\n\nRiskAndCostT.usedManagementInterfaces lists management interfaces used by the tool, e.g., an interface to an Enterprise Resource Planning (ERP) system.\n\nRuntimeT.isInstalledOnTargetSystem is true if the tool is installed on the same system where the target software is installed which is accessed at runtime.\n\nRuntimeT.canCoverOwnTraces is true if the tool is able to cover the own traces, as e.g., logfile entries or additional files that were downloaded. This usually applies to tools that are used for attacks.\n\nRuntimeT.usedExploitDatabases lists databases containing known exploits.\n\nServiceCompositionT.supportsOfflineServices is true if the tool supports services which run offline, i.e., are not running at a server.\n\nServiceCompositionT.supportsOnlineServices is true if the tool supports services which run online, i.e., are running at a server (which is usually not the host where the service composition tool is installed).\n\nAs shown, the security context model can easily be extended or even mapped to another domain by adding and removing elements. In fact, even non-security tools, as e.g., Eclipse\\(^6\\) can be described without changing the model. In this case, neither SecurityProperty nor Vulnerability is instantiated (which is possible due to the multiplicity “∗”) and the role typeOfSecurityMethod should be set to none.\n\nTwo extensions of the context model, one for concrete risk evaluation and one for method evaluation including testing participant’s feedback are detailed in subsection 3.3.2.\n\n### 3.2.2 Data Collection\n\nHigh-quality data is the basis for an evaluation, as the best analysis strategy cannot make up for low-quality data. Our aim is to create a schema which describes properties that have to be defined before starting collecting data. This is particularly needed, if the data collection has to be systematic as usual for scientific approaches (cf. use cases SpecifyDataCollection and CollectData section 3.2). Therefore, we base our approach on Kitchenham’s systematic literature review \\cite{Kitchenham2007}. However, we do not restrict our evaluation approach to reviewing literature, as we also include information about tools which cannot always be found in papers, but on websites and information which is extracted from experience, e.g., data gathered by benchmarks.\n\nIn order to collect data, it is common to define a search process (c.f. Figure 3.7) which specifies several steps called process phases. Each phase may follow another approach, e.g., the search can be automated or not, or it can be a depth-first or a breadth-first search. Depth-first means, that the aim of a search is to extract a lot of detail information about a relatively small topic, whereas a breadth-first search is good to get an overview of a broader topic. We noticed that Kitchenham et al. do not use more than one search phase. This might be the case because they prefer to not be biased by findings from a previous phase. The advantage of more than one search phase is that resources can be added which were considered interesting in a previous phase, such as further contributions from conferences or from authors which seemed promising.\n\nSimilar to Kitchenham’s literature review, research questions are used to define the corner stones and the goals of the search. Queries can be derived from the research questions. They are then used and refined in the phases of the search process. As different search engines support different types of queries, concrete queries are specific for each resource, e.g., Google Scholar\\(^7\\). Thus, concrete queries document what was searched for in a certain resource so that results remain as repeatable and comprehensible as possible. At the same time, concrete queries belong to one query which generally defines what was searched for. Search expressions can contain keywords as well as special characters like “-” to exclude\n\n\\(^6\\)Eclipse. http://eclipse.org/\n\n\\(^7\\)Google Scholar. http://scholar.google.com/\nIt is important to choose resources that will serve as data sources for the evaluation. It is worth noticing that resources can not only be scientific papers but also the web or measured data, code repositories or persons. For contacting a person, the concrete query expression is used as a question, which is asked. When measuring data or providing a “proof of concept”, the source’s exclusion criteria have to be empty or specified in a way that the result is not distorted. The use of an association class for ConcreteQuery (depicted by a dashed line) denotes that for each pair of ProcessPhase and UsedResource, the class ConcreteQuery is instantiated. The concrete search expression is derived from a general search expression.\n\nFor example the general search expression could be “recent approaches in Security Engineering” and we want to ask Google Scholar and a popular researcher. For Google Scholar we could use “\"Security Engineering\" 2012..2013” as a concrete search expression and the concrete expression for asking a researcher could read: “I’m interested in Security Engineering. Which recent approaches in Security Engineering do you know?”. If a concrete query matches sources, as papers, websites or personal answers, we classify the source at least by author and description (as an abstract) and provide information about the type of source and at least one reference where to find it.\n\nProcess phases can use the matching sources to get an idea how to define more appropriate queries, which is especially useful for depth-first search phases.\n\nFigure 3.8 depicts the process of working with SECEVAL as a UML activity diagram. It details Figure 1.1, which was shown in the introduction. Used and produced artifacts can be found on the right. Notice that this process has to be adapted (and usually simplified) for each evaluation. Writing down the exact process might not always be necessary, as many activities can be executed in parallel or in any order, which is indicated by the black, horizontal bars. Artifacts used by the analysis process will be explained in the following.\n\n### 3.2.3 Data Analysis\n\nWe do not only want to collect data in order to know a brief description, but we want to analyze it in order to answer research questions. This is why data analysis is applied. According to Kitchenham, the procedure how to collect as well as analyze data belongs to the “review protocol” and has always to be specified in the first place.\n\nFigure 3.9 depicts what is needed for analyzing data. First, we have to specify which type of strategy\nFigure 3.8: SecEval’s Evaluation Process\nwe want to use. Do we only use quantitative analysis or do we mainly use qualitative analysis? Accordingly, one can later refer to Kitchenham’s checklists for quantitative and qualitative studies [39, table 5 and 6] to ensure the quality of the own answers to the research questions.\n\nFigure 3.9: Data Analysis\n\nThe analysis strategy determines the used categories & criteria, analysis algorithms and filters according to the research question. Criteria can be grouped by categories. Whether or not a criterion is grouped by categories depends on the kind of information which should be associated to the criterion: information with a single value, as “costs” do not have to be grouped, whereas it makes sense to group boolean information if a testing method is testing web applications, networks or systems to a category called “type of testing target”.\n\nA criterion gives more information about data values as it defines the data type (string, list of booleans, ..) and the metric (milliseconds, ..). Additionally, the priority can be defined which is useful when Mechanisms should be compared. We suggest prioritizing using integer values from 0 (unimportant) to 10 (very important).\n\nInformation can be extracted from the sources which were found in the data collection phase (see «use» dependency starting from ExtractedInfo in Figure 3.2), or they can be processed using an analysis algorithm. This algorithm does not have to be executable on a computer. The analysis strategy defines which algorithm is used and makes sure that the result of the algorithm fits to a criterion regarding meaning and metric. The algorithm may, of course, be implemented by tool in the sense of a tool of the security context model. However, we do not want to overload the model at this point.\n\nThe relations we presented in deliverable D2.1 [10, section 3.2] can be seen as instances of analysis algorithms. For instance, the relation IsCompatible_NxN_ToolIO expresses that “two notations are compatible if there exists a tool chain that can transform the first given notation into the second one” [10, p. 22]. In this case, the algorithm might contain the depth-first search for a tool-chain consisting of tools where the output of one tool serves as input for the second one. We experienced that automating this algorithm is challenging, because in- and output of tools are usually described by strings and are influenced by many factors like the tool’s functions which are used.\n\nBesides, a filter can be defined to disqualify results according to certain criteria as costs or quality. This filter is finer grained than the exclusionCriteria used in the data collection (class UsedResource), which only can use obvious criteria, as e.g., the language the source is written in. In addition to this, the\nfilter for data analysis accesses information as well as criteria and thus can exclude, e.g., Mechanisms from the evaluation which do not meet a high-priority requirement.\n\nA valid question is how information, criteria and the security context model fit together. This was shown in Figure 3.2: information can be stored in an instance of our security context model. Consequently, the attributes name and dataType of Criterion can be left blank when information is stored in an instance of our model, as attributes have a name and are typed. However, these attributes are needed when describing information which is not directly related to an instance of a knowledge object.\n\nIn summary it can be said that neither the collection of data nor the data analysis are security specific and thus can be applied equally to other domains within computer science. An example how we collected and analyzed data in the area of security testing can be found in chapter 4.\n\n### 3.3 Gathering Expert Knowledge\n\nComing up with a broad evaluation ontology for security KOs is challenging, because many different areas of expertise are needed. Fortunately, NESSoS (associated) partners encompass the broad area of secure software development, e.g.:\n\n- Security Requirements Engineering\n- Model-driven Security\n- Trust and Reputation\n- Verification\n- Security Monitoring\n- Vulnerability Testing\n- Risk and Cost\n- Privacy requirements engineering\n- Access Control\n- Security Protocols\n- Empirical methods for security\n- Secure Booting\n- Javascript Sandboxing\n\nThe easiest way to tap into each other's know-how was to come up with a basic structure of an evaluation approach and to discuss it. The basic structure we used was based on our experience from deliverable D2.1 [10] and inspired by the model of the CBK [6, Figure 2.1].\n\n#### 3.3.1 Guided Interview\n\nA Guided Interview is “a one-on-one directed conversation with an individual that uses a pre-determined, consistent set of questions but allows for follow-up questions and variation in question wording and order.”\n\nWe used this kind of interview in a slightly modified way: first we explained our basic model (especially the basic Security Context Model) at the NESSoS plenary meeting in Malaga. Second, we handed out a description and a questionnaire, which can be found in Appendix A. Third, we were around while (associated) partners were filling in the questionnaire, answered questions, explained the model in further detail and discussed feedback which went beyond the questionnaire.\n\nThe discussions were very fruitful and they helped us, as well as the detailed answers to the questionnaire. We like to thank again all 14 (associated) partners who contributed with their ideas to the improvement of our evaluation approach.\n\n---\n\n3.3.2 Results and Extensions\n\nThe resulting evaluation approach SecEval is described in the previous section (3.2). Some changes due to the guided interviews are discussed in the following:\n\n- “Maturity Level could be split into Technical Maturity and Adoption.” This is a good point, because there are some Mechanisms which are technical mature, but not very adopted in practice.\n\n- Denote if there is an “interactive or batch” mode for tools. We implemented this using the attributes canBeUsedInteractively and canBeUsedAutonomously.\n\n- Threats can be mitigated by another method. For example the method of a firewall can be used to mitigate the threat by an attacker from outside.\n\n- “Can it be represented that a tool is based on another tool?” We first thought it might be enough to base a method upon another method, but it turned out that tools are often based on other tools which are supporting the same method. We therefore added an association with the role basedOnTools.\n\n- To make it possible to describe functionalities of a tool, two classes, called Functionality and FunctionalitySet were introduced.\n\n- The class ProtocolVerification was added. First, because protocol verification is a common task regarding security. Second, it demonstrates how to easily extend the context model using inheritance.\n\n- The difference between methods and tools sometimes did not become clear immediately. Therefore, we moved all attributes that describe a method and also can describe a tool to the heirs of MAreasOfDev and added the possibility that a tool can partially support a method and thus redefine attributes, which is depicted in Figure 3.4.\n\n- It was suggested to extend the enumeration Location of vulnerability so that operating systems and humans (i.e., human behavior) can be specified as the location of a vulnerability. We liked this suggestion, because in this way we can also model non-technical vulnerabilities and tag them accordingly.\n\nIn order to keep the model as simple as possible, we decided not to implement all suggestions for changes, especially when they were at a high level of detail, which could be added when adapting our security context model to a concrete scenario. An example is the description of detailed asset, risk and attacker models which of course needs more attributes to describe complex relations. Furthermore, the basis of SecEval is used for general information which should not be too specific. When evaluating risks, the risks are usually evaluated for a concrete system. We modeled an extension to show how SecEval can be enhanced using OWASP’s Risk Rating Methodology [22]. Figure 3.10 depicts the extended model whereby added connections use thick line linkings.\n\nThe class Threat, known from the basic context model, inherits its features to a concrete Attack. The severity of the risk (which is an attribute of Threat) can be calculated by likelihood multiplied with impact. The likelihood is derived from the factors which describe the vulnerabilities and the threat agents, whereas the impact is determined by the concrete technical and business-related impact. Therefore, each enumerations’ literal is mapped to a likelihood rating from 0 to 9. For more information the interested reader is referred to [22].\n\nAnother point we omitted is, to detail the costs for using a Mechanism, as the most convenient level of detail has to be defined individually for a set of research questions: sometimes, the overall costs should be recorded, sometimes it is necessary to split the costs into cost to train personal, yearly license costs for using proprietary tools and so on.\n\nA comment on the question why a researcher would not use the proposed evaluation framework was: “I would go for an experimental approach. I would run a set of comparative experiments where the participants apply the methods on a real case. To compare the methods I would use the method evaluation model proposed by Moody. [51]. In this model you have several constructs like actual efficiency, actual effectiveness, perceived ease of use, perceived usefulness, intention to use, actual usage.” We welcome\nFigure 3.10: Inclusion of basic risk evaluation approach\n\nthe use of experimental approaches and SecEval is easy to extend, as shown in Figure 3.11: we introduce a Test class that is connected to at least one method and vice versa. The test uses the method on at least one example and is executed by TestingParticipants. Each participant assesses the method using Moody’s evaluation criteria:\n\n- Actual Efficiency: the effort required to apply a method.\n- Actual Effectiveness: the degree to which a method achieves its objectives.\n- Perceived Ease of Use: the degree to which a person believes that using a particular method would be free of effort.\n- Perceived Usefulness: the degree to which a person believes that a particular method will be effective in achieving its intended objectives.\n• Intention to Use: the extent to which a person intends to use a particular method.\n• Actual Usage: the extent to which a method is used in practice” [51, page 5].\n\nUsually, the average value of the participants’ results is used as final evaluation result for the method under test.\n\nSome misunderstandings occurred due to the brevity of the description that comes with the questionnaire, e.g., it was not clear to some partners that more than one phase of the SDLC can apply to a method or tool, using our context model. Furthermore, it was not pointed out explicitly in the questionnaire that a notation does not need attributes that are related to phases of the SDLC. These misunderstandings showed that it was good to be available personally at Malaga while the questionnaire was filled in.\n\nAs a proof of concept, we additionally use a case study in chapter 4.\n4 Case Study on Security Testing of Web Applications using SecEval\n\nWeb applications came especially under fire in recent years, as they are available, and thus attackable, 24 hours a day from all regions over the world. With 27% of breaches within hacking, web applications of larger companies are a worthwhile target for hackers [69, p. 35].\n\nAn approach to harden web applications is to test for security flaws. Methods as \"penetration testing\" or \"vulnerability scanning\" are supported by many tools. Some tools are commercial, but also open-source and trial versions exist. In this chapter, we use our SecEval approach to evaluate vulnerability scanners for web applications. An excerpt of the data was collected as part of two student theses [60, 44].\n\n4.1 Data Collection\n\nFirst, we have to define what we want to know and how we plan to collect data, as shown in Figure 4.1. It depicts instances of the classes we have already defined in Figure 3.7, e.g., instances of the class ResearchQuestion define our two research questions, a high-level and a concrete one. We used identical background colors for instances of the same class and omitted name attributes in case an instance name (e.g., p3) is given in the header.\n\nResearch question q1 is very general. Examples for methods which were selected in the first process phase and where more information was gathered in the second process phase are: vulnerability scanning, penetration testing, fuzzing and the classification into black- grey- and white-box testing. Examples for tools are WSFuzzer, X-Create and WS-Taxi, just to mention a few. As we already added most of the found methods and tools to the CBK [13], we focus on q2 in this chapter.\n\nQuery instances could record the terms we used while searching the Web. We defined queries in the beginning of our research, but for such a broad question, as q1, we soon stopped recording concrete queries, as the overhead got too high in relation to the advantage of being able to reconstruct the search procedure at a later date. For recording our information sources, we used a table which contains the name of a method / tool and URLs from which information should be extracted in the data analysis phase.\n\nResearch question q2 is a typical question which could be asked by security engineers working in a company. The \"sources\" (i.e., tools) we selected for analysis were (cf. [44]):\n\na) Acunetix Web Vulnerability Scanner\nb) Mavituna Security - Netsparker\n\nc) Burp Scanner\n\nd) Wapiti\n\ne) Arachni\n\nf) Nessus\n\ng) Nexpose\n\nh) Nikto\n\n---\n\n1Acunetix. http://www.acunetix.com/\n8Nikto. http://www.cirt.net/Nikto2\n\nNESSoS - 256980 35\nThe instance `experienceWithTestScenario` (cf. Figure 3.7) describes how the data collection is performed by testing the vulnerability scanners. Please note that SECEVAL does not impose the completion of the data collection phase before the data is analyzed. This means that the tests were partly executed on tools which were later classified as inappropriate. This becomes clear when we think of how evaluation works in practice: sometimes we have to collect a bunch of data before we observe information which, e.g., leads to the exclusion of a tool from the result set. Ideally, the already collected data is then also contributed to a knowledge base like the CBK (or a future implementation of SECEVAL’s context model).\n\n### 4.2 Data Analysis\n\nFor analyzing collected data we define an analysis strategy and select a filter which enforces the requirements (limitations) defined for question q2. Figure 4.2 depicts instances of the data analysis model we defined in Figure 3.9. The background colors of the instances are used to quickly recognize the type of an instance.\n\nBefore we go into detail about particular results of our experiments, we first take a look at the overall result regarding our research question q2. Figure 4.2 thus depicts an instance of the class `ProcessedInfo`.\nwhich is called `weightedResultValues`. Only four tools passed our filter: Arachni and Nikto, which provide command-line interfaces and Nessus and Nexpose, which also use web interfaces. From our list of tools from above, the trial of (a) only allows to scan predefined sites. Tools (b) and (c) do not support a command line or web interface in the versions that are free. A run of tool (d) on our test target Mutillidae took six hours.\n\nApart from information we gathered online, we experimented with the tools that passed the filter, in order to obtain data for our tool evaluation (q2). Additionally to the instance `queryForTestScenario`, we describe what we test in more detail in the following (from [44]):\n\n- **Installation simplicity**\n Do any problems occur during the installation?\n\n- **Costs**\n How much do the tools cost? Is it a one-time payment or an annual license?\n\n- **Processor load**\n How high is the CPU load while running the tool?\n\n- **Clarity and intuitiveness**\n Is the tool easy to understand, clearly structured and user-friendly?\n\n- **Run duration**\n How long does a scan take?\n\n- **Quality of the report**\n How detailed is the report of the scan? Which information does it contain?\n\n- **Detected vulnerabilities**\n How many vulnerabilities does the tool detect on our test environment?\n\nAs we can see in Figure 4.2, an algorithm is involved, which calculates results according to a rating. The rating is depicted in Figure 4.3. Lower factors of a criterions’ priority denote that we consider the criterion less important. The data used for the rankings result from our test and is not further processed, therefore we do not need an algorithm (that is why we use instances of the class `extractedInfo`).\n\nAdditionally, we show how intermediate values of our tests could be described in our data analysis model in Figure 4.4, as e.g., the costs of the tools or the operating systems it runs on. Concrete instances of `Information` classes are not depicted; the interested reader is referred to [44].\n\nTo sum up, Table 4.1 gives an overview of our results. It contains the ranking of the tools as well as average\\(^\\text{10}\\) and weighted\\(^\\text{11}\\) results.\n\n\\(^{9}\\)NOWASP (Mutillidae). http://sourceforge.net/projects/mutillidae/\n\n\\(^{10}\\)AVG: average\n\n\\(^{11}\\)WAVG: weighted average according to ratings\nFigure 4.3: Case Study: Data Analysis – Ratings\n\nFigure 4.4: Case Study: Data Analysis – Values\n<table>\n<thead>\n<tr>\n<th>Tool</th>\n<th>Inst.</th>\n<th>Costs</th>\n<th>CPU</th>\n<th>Clarity</th>\n<th>Time</th>\n<th>Vuln.</th>\n<th>Report</th>\n<th>AVG10</th>\n<th>WAVG11</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Nessus</td>\n<td>1</td>\n<td>2</td>\n<td>2</td>\n<td>1</td>\n<td>4</td>\n<td>1</td>\n<td>2</td>\n<td>1.86</td>\n<td>1.86</td>\n</tr>\n<tr>\n<td>Arachni</td>\n<td>1</td>\n<td>1</td>\n<td>4</td>\n<td>4</td>\n<td>2</td>\n<td>1</td>\n<td>3</td>\n<td>2.29</td>\n<td>2.42</td>\n</tr>\n<tr>\n<td>Nexpose</td>\n<td>4</td>\n<td>4</td>\n<td>1</td>\n<td>2</td>\n<td>3</td>\n<td>3</td>\n<td>1</td>\n<td>2.57</td>\n<td>2.10</td>\n</tr>\n<tr>\n<td>Nikto</td>\n<td>1</td>\n<td>1</td>\n<td>3</td>\n<td>4</td>\n<td>1</td>\n<td>4</td>\n<td>4</td>\n<td>2.57</td>\n<td>3.19</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.1: Case Study: Final Tool Ranking (adapted from [44])\n\n4.3 Security Context Model\n\nTo allow security engineers to easily access the data we collected, we added entries for Nessus, Arachni, Nexpose and Nikto to the CBK [13]. Besides, we integrated all four tools into the NESSoS tool workbench, called SDE [11]. If they are executed from within the SDE, URL and port of the web application under test have to be provided by the user. To try out the vulnerability scanners it is possible to use Multidae as a target, as we did above. Multidae comes with Metasploitable12, an intentionally vulnerable Linux virtual machine. Therefore, the default configuration for the integrated SDE tools point to a local Multidae instance, but can be changed at any time.\n\nHowever, the CBK does not provide fine-grained categories for entering security-specific information. As SecEval’s context model is more detailed, we modeled the context of vulnerability scanning of web applications and two of the tested tools: Nessus and Nikto. Figure 4.5 shows an instance diagram of the context model, which we have already depicted in Figure 3.3.\n\nConnections between vulnerability and security property instances are not depicted, but stored in the model, which can be downloaded from the Web.13 The three vulnerabilities that are modeled are the top 3 from OWASP’s top 10 project 2013. [23] Of course, the shown method is not the only one which is supported by the tools, as e.g., Nessus also supports vulnerability scans on networks and not only on web applications. This would be the main advantage of an implementation of SecEval, similar to the CBK: connections to elements (as methods) which exist, but are not important for the current research, could be added without much effort so that future researchers can build upon them.\n\nWe based our case study on the non-extended version of SecEval. For the tools’ examples, we saw that it would be nice to extend the model to represent further attributes, as run duration or processor load. We recommend using additional classes for those extensions, e.g., a class to detail a test run. Our experience using SecEval and the UML CASE tool MagicDraw was that modeling is easy, but that the layout is not inviting to read the containing information. This is mainly because the order of instances attributes cannot be changed and because the font remains pixelated. Consequently, we are looking forward to a future implementation of SecEval as a kind of semantic wiki.\n\n---\n\n13SecEval: Modeling Example (Testing). [http://www.pst.ifi.lmu.de/~busch/SecEval/SecEval.mdzip](http://www.pst.ifi.lmu.de/~busch/SecEval/SecEval.mdzip)\nFigure 4.5: Case Study: Instances of Context Model (excerpt)\n5 Domain-specific Evaluation of Security Mechanisms\n\nOur evaluation framework SECVAL is brand-new. The following two evaluations in the domains of security design [67] and risk [42, 43] are previous works. Therefore, they do not explicitly use our approach, but have influenced the construction of SECVAL.\n\nThe first evaluation is a mapping study on secure software design. It aims at getting an overview of existing approaches to secure software design and at comparing their properties. A mapping study [58] is a kind of systematic literature review [39] where publications are categorized so that the coverage of the chosen research area can be depicted.\n\nThe second evaluation compares two risk-based methods: visual methods, represented by CORAS [45] and textual methods, represented by SREP [48]. The study is based on the systematic literature review by Kitchenham et al. and the experiment uses, beyond others, Moody’s approach [51] for recording effectiveness, perceived ease of use, perceived usefulness and intention to use.\n\n5.1 Mapping Study on Secure Software Design\n\nThe incorporation of security concerns in software design has become a popular research topic over the last decade. Numerous researchers have proposed a wide variety of approaches to secure software design. Unfortunately these approaches have been developed mostly independent from each other. This results in a complex tangle of different approaches.\n\nIn this section we report on a mapping study (a type of systematic literature review) we performed to disentangle the domain of secure software design. [67] The main goals of this study are first to provide an overview of the current state of the art. Second, identify gaps in current research, leading to interesting research opportunities.\n\n5.1.1 Review method\n\nOur study has been designed following the guidelines of Kitchenham and Charters [39]. The following paragraphs shortly describe the most important aspects of the study.\n\nResearch questions\n\nIn this mapping study we address the following research questions.\n\nRQ1: What approaches to secure software design exist?\nRQ2: What security properties are supported during software design?\nRQ3: What type of support is provided for the security properties?\n RQ3.1: Is a representation supported?\n RQ3.2: Is an analysis supported?\nRQ4: What evaluation is provided for the approaches?\n\nSoftware design refers to both architectural and detailed design. Security properties are properties as, for example confidentiality and authentication. The full set of properties used in this study is shown later. A representation includes each explicit modeling, graphically or textually, of a security property. Analysis includes each verification of security properties against the security requirements of the system under design. An evaluation includes every application of an approach with the purpose of demonstrating and/or proving its use.\nSelection criteria\n\nThere is a need to define which research will (not) be used to answer the above research questions. Research works are included if they satisfy the following inclusion criteria.\n\n- The research work models security properties in software design or\n- analyzes security properties in software design or\n- models attacks or threats in software design or\n- evaluates a proposal described in an included research work.\n\nResearch works are excluded if they satisfy the following exclusion criteria.\n\n- The research work does not satisfy the inclusion criteria or\n- is not published as a book or A-tier\\(^1\\) publication or\n- only mentions security as a general introductory term or\n- is not available as a full version, only an extended abstract or presentation, or\n- is a duplicate of an included research work or\n- is superseded by an included research work or\n- is published more than ten years ago.\n\nWe limited the included research works to books and A-tier publications because of the sheer number of research works available in this domain. Reading and analyzing all available research works was not considered feasible due to time and resource constraints.\n\nIn the case of duplicate research works only the most extensive or most recent, when they are all equally extensive, research work is included. We limited the scope to ten years since older research works either have been developed further, and are thus included by later research works, or have become too outdated for current technology.\n\nData extraction\n\nThe data extracted from the research works to answer the research questions can be divided in two main dimensions. First the security dimension classifies each research work over the security properties it supports and how they are supported (Figure 5.1).\n\nThe security properties are divided in two groups. On one hand the declarative properties which are the known CIAA security concerns. On the other hand the operational mechanisms are those mechanisms used to achieve the declarative properties.\n\nThe support for security concerns is divided in two aspects. A representation is constructive if it is actively used (e.g., used to generate implementation logic) further on in the development cycle. Otherwise it is a documentation representation. Analysis is precise if no expert security knowledge is needed to use it, otherwise it is imprecise. A white hat analysis proves a positive fact, for example a policy ensures confidentiality. A black hat analysis proves a negative fact, for example a system is not vulnerable to a certain attack.\n\nSecond the evaluation dimension classifies each evaluation discussed in the research works (Figure 5.2).\n\nAn industrial application is any evaluation in an industrial sized project. A researcher or student study is an evaluation in which researchers or students apply the approach to a test case. Toy examples are evaluations used to illustrate an approach.\n\nCase studies are evaluations described in high level of detail, usually containing a thorough analysis of good and bad aspects, and a lesson learned element. Illustrations are evaluation described limited to the actual use of the approach, lacking any in-depth analysis. Mentioned evaluations lack any detail in their description.\n\n\\(^1\\)See the Excellence in Research for Australia (ERA) 2010 initiative [http://www.arc.gov.au/era/era_2010/archive/era_journal_list.htm] for more information on this ranking.\n5.1.2 Discussion of the research questions\n\nThis following paragraphs provide answers to the research question based on the data extracted according to the dimensions described above.\n\nRQ1: What approaches to secure software design exist?\n\nA total of 21 different approaches were discovered in the included research works. Table 5.1 shows an overview of the approaches and corresponding research works. Approaches for which the original authors did not specify a name were named after the main author combined with a suffix.\n\nRQ2: What security properties are supported during software design?\n\nLooking at what security properties are supported by each approach we see there is a strong focus on access control (Figure 5.3). Other security properties are considerably less supported and some are not supported at all.\n\nA possible explanation for the popularity of access control the existence of well-known standards such as role-based access control (RBAC) to achieve this specific property. Such standards make it more straightforward to develop approaches supporting access control.\n\nLooking at the number of security properties supported per each approach we see 12 out of 21 approaches, support only a single security property (Figure 5.4). Of these 12 approaches 10 support only access control. At most five security protocols are supported by an approach. This indicates a strong specialization among approaches.\n\nRQ3: What type of support is provided for the security properties?\n\nMost approaches limit their support to a representation of security properties. Only a minority (also) support analysis of their security properties (Figure 5.5).\n\nTaking the type of representation into consideration shows that there is no significant difference in amount of support (Figure 5.6). Approaches do stick to one kind of representation for all supported properties, this is likely related to the fact the supported number of security properties is rather low.\n\nLooking at the types of analysis the most significant is that most approaches support a precise analysis. A precise analysis requires no expert security knowledge making it considerably more practical.\nFigure 5.2: The evaluation dimension classifies each evaluation discussed in a research work over its type, level of description, domain and provider.\n\nFigure 5.3: Access control is supported by considerably more approaches than other security properties.\n\nRQ4: What evaluation is provided for the approaches?\n\nThe research works describe a total of 42 evaluations, most of which are illustrative toy examples (Figure 5.7). Only ten industrial applications have encountered, of which only 2 are described as case studies. Researcher or student studies are, despite the growing popularity of empirical research, still very rare.\n\nLooking from the perspective of the approaches we can see that most approaches only provide toy examples as evaluation (Table 5.3). Only five approaches describe, in varying levels of detail, other types of evaluations. Furthermore there is one approach (Sohr-AC) that does not provide any evaluation. It should also be noted that seven out of ten industrial applications belong to a single approach (UMLsec).\n\nFurthermore, all but three evaluations are provided by the authors of the approach. The three exceptions are industrial applications belonging to the same approach (UMLsec) and are provided by the authors in collaboration with an industrial partner.\n\n5.1.3 Identified Gaps\n\nBased on the above answers to the research questions a number of gaps can be identified. Each gap offers one or more research opportunities.\nTable 5.1: Overview of the 21 approaches discovered in the literature.\n\n<table>\n<thead>\n<tr>\n<th>Approach</th>\n<th>Research works</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Abramov-AC</td>\n<td>[1]</td>\n</tr>\n<tr>\n<td>ADM-RBAC</td>\n<td>[19]</td>\n</tr>\n<tr>\n<td>Breu-WS</td>\n<td>[29]</td>\n</tr>\n<tr>\n<td>FDAF</td>\n<td>[15, 16]</td>\n</tr>\n<tr>\n<td>Georg-AO</td>\n<td>[25, 24]</td>\n</tr>\n<tr>\n<td>Giordano-AC</td>\n<td>[26]</td>\n</tr>\n<tr>\n<td>Gomaa-UML</td>\n<td>[28]</td>\n</tr>\n<tr>\n<td>Kim-AC</td>\n<td>[38]</td>\n</tr>\n<tr>\n<td>Koch-AC</td>\n<td>[40]</td>\n</tr>\n<tr>\n<td>Medina-DB</td>\n<td>[21]</td>\n</tr>\n<tr>\n<td>Nakamura-DB</td>\n<td>[55, 59]</td>\n</tr>\n<tr>\n<td>RBAC-WS-BPEL</td>\n<td>[8]</td>\n</tr>\n<tr>\n<td>SecureSOA</td>\n<td>[49, 50]</td>\n</tr>\n<tr>\n<td>SecureUML-MDS</td>\n<td>[3]</td>\n</tr>\n<tr>\n<td>SoaML4Security</td>\n<td>[41]</td>\n</tr>\n<tr>\n<td>Sohr-AC</td>\n<td>[62]</td>\n</tr>\n<tr>\n<td>UMLS-UMLsProfile</td>\n<td>[30]</td>\n</tr>\n<tr>\n<td>UMLsec</td>\n<td>[34, 36, 35, 9, 37]</td>\n</tr>\n<tr>\n<td>Vela-DB-XML</td>\n<td>[68]</td>\n</tr>\n<tr>\n<td>Wolter-BP</td>\n<td>[72]</td>\n</tr>\n<tr>\n<td>Xu-Petri</td>\n<td>[73]</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.2: Most approaches provide a precise analysis, whereas an imprecise analysis is not often encountered.\n\nSecurity property coverage\n\nThe gap in security property coverage can be seen in two ways. First, a number of security properties are barely or not supported. Second, most approaches only support a limited number of security properties. Both views give rise to the fact that no single approach, or combination of approaches, can be used to incorporate all security properties in software design. This offers the research opportunity to extend existing approaches to more (unsupported) security properties or define more generally applicable (i.e., support for all or most security properties) approaches.\n\nAnalysis support\n\nOnly a minority of the approaches support analysis of their security properties. Therefore, designers often cannot verify whether their design meets the security requirements and must delay this verification until the implementation or deployment phases, where correcting errors is much more costly. Obviously, this is a research opportunity for extending approaches with analysis support or developing new analysis methods.\n\nEvaluation\n\nMost approaches are evaluated by the authors themselves using illustrative toy examples. Since toy examples are typically small and, to a certain degree, designed to fit well, they provide limited information\nUnfortunately performing an evaluation on an industrial application is often difficult. Empirical studies can fill this gap by providing more thorough evaluations.\n\n5.1.4 Limitations of this study\n\nThe main limitation of this study is that only books and A-tier publications are considered. This leads to a substantial amount of research works left uncovered. This can result in possibly biased answers to the research questions.\n\nSince we explicitly choose the top-level research works we believe the selection contains the more mature and advanced approaches available. The major gaps observed in this study (i.e., lack of a generally applicable approach and lack of thorough evaluation) are not likely to be solved by less mature or advanced approaches. Furthermore it is our observation, based on a partial analysis, that approaches described in the other research works tends to follow the same lines as those included.\n\n5.2 Empirical Validation of Risk-based Methods\n\nSeveral methods have been proposed to address security concerns during the early phases of the system development life cycle [48, 45, 53, 27, 18, 61]. However, there has been little empirical evaluation that shows how effective these methods are in practice. With few exceptions [57, 46, 52, 47], security methods are evaluated by the same researchers who have proposed them. As a consequence, security practitioners are not motivated to adopt new security methods, while researchers do not know how to improve their methods. To address this problem, there is thus the pressing need of conducting empirical evaluations to investigate which methods work better to identify threats and mitigations (i.e., security requirements for later phases) and why.\n\nIn this section, we report a controlled experiment that we conducted to compare two classes of risk-based methods [42, 43]: visual methods and textual methods. As instances of these classes of methods,\nNone\n\nNumber of supporting approaches\n\nDocumentation\n\nConstruction\n\n0\n\n1\n\n9\n\n11\n\nNumber of provided evaluations\n\nEvaluation\ntype\n\nCase study\n\nIllustration\n\nMentioned\n\nIndustrial application\n\n4\n\n2\n\n10\n\n1\n\nResearcher or student study\n\n10\n\n1\n\nToy example\n\n2\n\n26\n\nUnknown\n\n3\n\n10\n\nFigure 5.6: There is no significant difference is amount of support between representation types.\n\nFigure 5.7: The large majority of evaluations found in literature are illustrative toy examples.\n\nwe have selected CORAS [45] and SREP [48]. CORAS is a visual method whose analysis is supported by a set of diagrams that represent assets, threats, risks and treatments. In contrast, SREP is a textual method whose artifacts are specified in natural language or in tabular form.\n\nThe goal of the experiment was to evaluate the effectiveness of visual and textual based methods, and the participants’ perception of the methods, according to Moody [51]. Hence, the dependent variables were the effectiveness of the methods measured as number of threats and security requirements and the participants’ perceived ease of use, perceived usefulness and intention to use of the two methods. The independent variable was the method. The experiment involved 28 participants: 16 students of the master in Computer Science and 12 students of the EIT ICT LAB master in Security and Privacy. They were divided into 16 groups using a randomized block design. Each group applied the two methods to identify threats and security requirements for different facets of a Smart Grid application scenario (ranging from security management to database security). The experiment was complemented with participants’ interviews to gain insights on why the methods are effective or they are not.\n\nThe main findings are that the visual method yields to identify more threats than textual one, while the textual one is slightly better to identify security requirements. The difference in the number of threats identified with the two methods is statistically significant and participants’ interviews suggest that this is due to the difference in the artifacts used to model threats. The visual method uses diagrams to represent threats while the textual method uses tables: diagrams help brainstorming on threats and thus yield participants to identify more threats. On the contrary, the difference in the number of security requirements identified with the two methods is not statistically significant. The textual method identified a slightly higher number of security requirements but this is not statistically significant. A possible explanation emerging from the interviews is that process supported by the textual method offers a systematic approach to identify security requirements. In addition, the visual method’s overall perception and intention to use are higher than for the textual method.\nTable 5.3: Most of the approaches are limited to toy examples as evaluation. Seven out of ten industrial applications belong to the same approach.\n\n### Approach\n\n<table>\n<thead>\n<tr>\n<th>Approach</th>\n<th>Industrial application</th>\n<th>Researcher or student study</th>\n<th>Toy Example</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>C</td>\n<td>I</td>\n<td>M</td>\n</tr>\n<tr>\n<td>Abramov-AC</td>\n<td>0</td>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>ADM-RBAC</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Breu-WS</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>FDAF</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Georg-AO</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Giordano-AC</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Gomaa-UML</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Kim-AC</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Koch-AC</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Medina-DB</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Nakamura-SOA</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>RBAC-WS-BPEL</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>SecureSOA</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>SecureUML-MDS</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>SoaML4Security</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Sohr-AC</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>UMLs-UMLSProfile</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>UMLsec</td>\n<td>2</td>\n<td>2</td>\n<td>3</td>\n</tr>\n<tr>\n<td>Vela-DB-XML</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Wolter-BP</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Xu-Petri</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\nC = Case study, I = Illustration, M = Mentioned\n\n5.2.1 Research method\n\nThis section describes the design of the performed experiment, following the guidelines by Wohlin et al. [71].\n\n#### Selection of methods\n\nCORAS is a visual method which consists of three tightly integrated parts, namely, a method for risk analysis, a language for risk modeling, and a tool to support the risk analysis process. The risk analysis in CORAS is a structured and systematic process which use diagrams (see Figure 5.8(a)) to document the result of the execution of each step. The steps are based on the international standard ISO 31000 [31] for risk management: context establishment, risk analysis (that identifies assets, unwanted incidents, threats and vulnerabilities), and risk treatments.\n\nThe Security Requirements Engineering Process (SREP) is an asset-based and risk-driven method for the establishment of security requirements in the development of secure Information Systems. SREP supports a micro-process, consisting of nine steps: agree on definitions, identify critical assets, identify security objectives, identify threats and develop artifacts, risk assessment, elicit security requirements, categorize and prioritize security requirements, requirements inspection, and repository improvement. The result of the execution of each step of the process is represented using tables or natural language (see Figure 5.8(b)). SREP is compliant with international standards ISO/IEC 27002 [33] and ISO/IEC 15408 [32] within the scope of requirements engineering and security management.\n\nFor additional details about CORAS and SREP we refer the reader to [45, Chap. 3] and [48]. Note that, in the rest of the paper, we denote with “security requirements” both the concepts “treatments” in CORAS and “security requirements” in SREP because they have the same semantic: they are both defined as a...\n**Figure 5.8: Examples of Visual (CORAS) and Textual (SREP) Methods’ Artefacts.**\n\nA misuse case with ID 1 is described as follows:\n\n**Name of Misuse Case:** Spoof of information\n\n**ID 1**\n\n**Summary:** The attacker gains access to the message exchange between the SM and SNN and discloses the secret exchange of information.\n\n**Probability:** Frequent\n\n**Preconditions:**\n\n1. The attacker has access to the communication channel between SM and SNN.\n\n**User Interactions**\n\n<table>\n<thead>\n<tr>\n<th>Misuser interactions</th>\n<th>System Interaction</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>The SM sends the information about power consumption</td>\n<td>The attacker reads the information</td>\n</tr>\n<tr>\n<td>The SSN receives the information without knowing that someone has read the message</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**Postconditions:**\n\n1. The attacker knows personal information about the power consumption of the customer.\n\n---\n\n**Figure 5.8: Examples of Visual (CORAS) and Textual (SREP) Methods’ Artefacts.**\n\n- **Means to reduce the risk level associated with a threat:** Implement TLS/SSL protocol to secure communication.\n**Research approach**\n\nThe goal of the experiment was to evaluate and compare two types of risk-driven methods, namely, visual methods (CORAS) and textual methods (SREP) with respect to their effectiveness in identifying threats and security requirements, and the participants’ perception of the two methods. Hence, visual and textual methods were the two treatments that we have considered in the experiment. We want to investigate the following research questions:\n\nRQ1 *Is the effectiveness of the methods significantly different between the two type of methods?*\n\nRQ2 *Does the effectiveness of the methods vary with the assigned tasks?*\n\nRQ3 *Is the participants’ preference of the method significantly different between the two type of methods?*\n\nRQ4 *Is the participants’ perceived ease of use of the method significantly different between the two type of methods?*\n\nRQ5 *Is the participants’ perceived usefulness of the method significantly different between the two type of methods?*\n\nRQ6 *Is the participants’ intention to use the method significantly different between the two type of methods?*\n\nTo answer the first two research questions we have measured effectiveness by counting the number of threats and the number of security requirements as the main outcomes of the methods’ application (as done in [57, 65]). Research questions RQ3 – RQ6 have been answered by measuring perception-based variables perceived usefulness (PU), perceived ease of use (PEOU), intention to use (ITU) with a post-task questionnaire. In order to gain a better understanding of why a method is effective (or more effective than another) we also carried out individual interviews with the participants.\n\n**Hypotheses**\n\nWe have translated research questions RQ1 – RQ6 into a list of null hypotheses to be statistically tested. Due to the lack of space we report here only the main alternative hypotheses to the null ones denoted as $H_{n,A}$ where $n$ specifies the research question to which the hypothesis is related and the index $A$ specifies that is an alternative hypothesis.\n\n$H1.1_A$ There will be a difference in the number of threats found with the visual method and with the textual method\n\n$H1.2_A$ There will be a difference in the number of security requirements found with the visual method and with the textual method\n\n$H2.1_A$ There will be a difference in the number of threats found with the visual and the textual method within each facet\n\n$H2.2_A$ There will be a difference in the number of security requirements found with the visual and the textual method within each facet\n\n$H3_A$ There will be a difference in the participants preference for the visual and the textual method\n\n$H4_A$ There will be a difference in the participants perceived ease of use for the visual and the textual method\n\n$H5_A$ There will be a difference in the participants perceived usefulness for the visual and the textual method\n\n$H6_A$ There will be a difference in the participants intention to use for the visual and the textual method\nTable 5.4: Experimental design\n\n<table>\n<thead>\n<tr>\n<th>Facet/Method</th>\n<th>Visual</th>\n<th>Textual</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Mgmnt</td>\n<td>6</td>\n<td>10</td>\n</tr>\n<tr>\n<td>App/DB</td>\n<td>9</td>\n<td>7</td>\n</tr>\n<tr>\n<td>Net/Teleco</td>\n<td>9</td>\n<td>7</td>\n</tr>\n<tr>\n<td>Mobile</td>\n<td>8</td>\n<td>8</td>\n</tr>\n</tbody>\n</table>\n\nHypotheses $H_{1.1,1}^{A}-H_{1.2,1}^{A}$ are related to $RQ_1$ and suppose that there will be a difference in the effectiveness of the methods. $H_{2.1,1}^{A}-H_{2.2,1}^{A}$ assume a possible relation between the effectiveness of the methods and the facets on which the methods is applied (RQ2). Hypothesis $H_{3,1}^{A}$ assumes there will be a difference in the participants’ overall preference for the methods (RQ3). $H_{4,1}^{A}-H_{6,1}^{A}$ assume that the participants’ perceived ease of use, perceived usefulness, and intention to use variables will differ for the two methods (RQ4-RQ6).\n\n**Experimental design**\n\nParticipants for the experiments were recruited among master students enrolled in the Security Engineering course at the University of Trento. The participants had no previous knowledge of the methods under evaluation. A within-subject design where all participants apply both methods was chosen to ensure a sufficient number of observations to produce significant conclusions. In order to avoid learning effects, the participants had to identify threats and mitigations for different types of security facets of a Smart Grid application scenario. The Smart Grid is an electricity network that can integrate in a cost-efficient manner the behavior and actions of all users connected to it like generators, and consumers. They use information and communication technologies to optimize the transmission and distribution of electricity from suppliers to consumers.\n\nThe tasks differ in the security facets for which the groups had to identify threats and security requirements. The security facets included Security Management (Mgmnt), Application/Database Security (App/DB), Network/Telecommunication Security (Net/Teleco), and Mobile Security (Mobile). For example, in the App/DB facet, groups had to identify application and database security threats like cross-site scripting or aggregation attacks and propose mitigations.\n\nThe participants were divided into 16 groups so that each group would apply the visual method (CORAS) to exactly two facets and the textual method (SREP) to the remaining two facets. For each facet, the method to be applied by the groups was randomly determined. Table 5.4 shows for each facet the number of groups assigned to visual and textual methods.\n\n**Experimental Procedure**\n\nThe experiment was performed during the Security Engineering course held at University of Trento from September 2012 to January 2013. The experiment was organized in three main phases:\n\n- **Training.** Participants were given a tutorial on the Smart Grid application scenario and a tutorial on visual and textual methods of the duration of two hours each. The Smart Grid scenario focused on the gathering of metering information from the smart meters and their transmission to the utility services for billing purposes. Then, participants were administered a questionnaire to collect information about their background and their previous knowledge of other methods and they were divided into groups based on the experimental design.\n\n- **Application.** Once trained on the Smart Grid scenario and the methods, the groups had to repeat the application of the methods on four different facets: Security Management, Application/Database Security, Network Security and Mobile Security. For each facet, the groups:\n - Attended a two hours lecture on the threats and possible mitigations specific for the facet but not concretely applied to the case study.\n- Had one week to apply the assigned method to identify threats and security requirements specific for the facet.\n- Gave a short presentation about the preliminary results of the method application and received feedback.\n- Had one week to deliver an intermediate report to get feedback.\n\nAt the end of the course in mid-January 2013, each group submitted a final report documenting the application of the methods on the four facets.\n\n**Evaluation.** In this phase, the experimenters (the authors of this paper) assessed participants’ final reports while the participants evaluated the method through questionnaires and interviews. First, each group gave a presentation summarizing their work in front of the experimenters and of the expert. The expert evaluated the quality of the threats and the mitigations proposed for the Smart Grid application scenario. Then, participants were administered the post-task questionnaire to be filled in online. Last, each participant was interviewed for half an hour by one of the experimenters to investigate which are the advantages and disadvantages of the methods.\n\nThe interview guide contained open questions about the overall opinion of the methods, their advantages and disadvantages, the difficulties encountered during the application of the methods and the main differences among them. The interview questions were the same for all the interviewees even though some specific questions were added for some of the participants when their answers to the questionnaire were contradictory.\n\nThe questionnaire was adapted from the questionnaire reported in [57] which was inspired to the Technology Acceptance Model (TAM) [17]. The questionnaire consisted of 22 questions which were formulated in an opposite statements (positive statement on the right and negative statement on the left) format with answers on a 5-point Likert scale. The questions were formulated as follows: Q1: Whether the method was easy or hard to use; Q2: The method made the security analysis easier or harder than an ad hoc approach; Q3: The method was easy or difficult to master; Q4: Intention to use the method to identify threats and security requirements in a future project course; Q5: The method is better in identifying threats and security requirements than using common sense; Q6: Intention to use the method to identify threats and security requirements in a future project at work; Q7: Confusion about how to apply the method to the problem; Q8: Whether the method made the search for threats and security requirements more or less systematic; Q9: Intention to use the method if suggested by someone at work; Q10: Whether the method would be easy or hard to remember; Q11: Whether the method makes more or less productive in identifying threats and security requirements; Q12: Intention to use the method in a discussion with a customer; Q13: Whether the process of the method is well or not well detailed; Q14-Q15: A catalog of threats and security requirements makes easier or harder the security analysis with the method; Q16-Q17: The method helps or not helps in brainstorming on the threats and the security requirements; Q18: Whether the tool is easy or hard to use (asked just for the visual method because it had tool support); Q19-Q22: Difficulties of facets. To avoid that the participants answered on “auto-pilot”, some of the questions (e.g., Q2, Q10, Q13) were given with the most positive response on the left and the most negative on the right.\n\n### 5.2.2 Reports’ Analysis\n\n**Coding**\n\nTo assess the effectiveness of visual and textual methods, the final reports delivered by the groups were coded by the authors of this paper to count the number of threats and security requirements. An expert on security of the Smart Grid was asked to assess the quality of the threats and security requirements. The level of quality was evaluated on a four item scale: Unclear (1), Generic (2), Specific (3) and Valuable (4).\n\nBased on this scale, the groups who have got an assessment Valuable or Specific were classified as good groups because they have produced threats and security requirements of good quality. On the contrary, the groups who were assessed Generic or Unclear were considered as not so good (bad) groups.\nFigure 5.9 reports the expert assessment of all groups for all facets. In total we had 64 method applications because each of the 16 groups has applied one of the methods on the four facets. The number inside each bubble denotes the number of method applications which got a given expert’s assessment for threats (reported on x-axis) and security requirements (reported on y-axis). There were 48 (75%) method applications that generated some clear threats (meaning threats evaluated generic, specific and valuable by the expert) while 28 (44%) method applications were specific to the scenario and appreciated by the expert. In contrast, the quality of produced security requirements was slightly lower than for threats: 48 (75%) method applications produced clear security requirements but more than half (36) were generic. In general, we can conclude that the overall quality of the outcomes of method applications was satisfactory.\n\n### Number of threats and security requirements\n\nTo test the effectiveness of visual and textual methods with respect to the number of identified threats and security requirements, we applied the ANOVA statistical test with a significance level $\\alpha$ of 0.05. The ANOVA tables are not reported due to lack of space. Before the application of the test, we verified whether the dependent variables were normally distributed with Shapiro-Wilk test (returned $p$-values are $0.17, 0.68$ for requirements and threats respectively). We also checked the homogeneity of variance with the Fligner-Killeen test (returned $p$-values are $0.45$ for requirements, and $0.64$ for threats). So we have no evidence to reject either assumptions.\n\nWe first analyzed the differences in the number of threats identified with visual and textual methods. As shown in Figure 5.10 (left), if we consider all groups, the visual method is more effective in identifying threats than the textual one. This result is also confirmed if we consider only the groups who have produced good quality threats as shown in Figure 5.10 (right). The ANOVA test shows that the effect of the applied methods on the number of identified threats is statistically significant for all groups ($F = 18.49, p-value = 1.03 \\cdot 10^{-4}$) and good groups ($F = 26.10, p-value = 1.59 \\cdot 10^{-4}$).\n\nSimilarly, Figure 5.11 represents the means of the number of security requirements identified with the visual and the textual method by all groups (left) and by good groups (right). The figure shows that both for all groups and for good groups, the textual method is slightly better than the visual method in identifying security requirements. However, the ANOVA test shows that the difference in the security requirements identified with the textual and visual method is not statistically significant for all groups ($F = 1.18, p-value = 0.28$) and good groups ($F = 1.98, p-value = 0.23$).\n\nFigure 5.12 confirms the results shown in Figure 5.10 and Figure 5.11. The figure reports a scatter\nFigure 5.10: Means of identified threats in all groups (left) and good groups (right).\n\nFigure 5.11: Means of identified security requirements in all groups (left) and good groups (right).\nview of the distribution of identified security requirements, and identified threats for the groups which have applied the visual method (circles) and the one which have applied the textual method (triangles). The groups which applied the visual method tend to identify more threats, but less security requirements than groups which applied the textual method. The linear regression models on security requirements and threats show that the textual method is slightly better than the visual one in terms of the number of identified security requirements given the number of identified threats, but with no statistical significance.\n\nWe have also investigated the differences in the number of threats and security requirements identified with the visual and the textual method within each facet. The boxplots in Figure 5.13 (left) show that the distribution of the visual method is always above the distribution of textual method. This means that using the visual method produces more threats than using the textual method in all four facets. This difference is less marked for the facet Net/Teleco (facet 3) but it is not statistically significant. If we consider only the facets Mgmnt, App/DB, and Mobile, the difference in the number of threats identified with the visual and the textual method is statistically significant because the ANOVA test returned a p-value $2.78 \\cdot 10^{-3}$ ($F = 9.95$) which is less than 0.05. If we consider all facets, the difference is also statistically significant because the p-value returned by the ANOVA test is equal to $1.79 \\cdot 10^{-3}$ ($F = 10.66$). Thus, we can conclude that across all facets the visual method is globally better than the textual method in identifying threats.\n\nFigure 5.13 (right) reports the number of security requirements identified with the visual and the textual method within each facet. The boxplots show that textual method is slightly better than the visual one in identifying security requirements in the first three facets. In particular, in facet Net/Teleco the difference is higher than in the facets Mgmnt and App/DB. However, the ANOVA test given the facet Net/Teleco returned $F = 3.37$, $p\\text{-value} = 0.09$, which means visual and textual methods distributions are different but the difference is not statistically significant. In the last facet Mobile, the situation is inverted and the visual method is better than the textual one in identifying security requirements. Given all facets, the ANOVA test returned $F = 0.57$, $p\\text{-value} = 0.45$ which means the difference in the number of security requirements is not statistically significant.\n5.2.3 Questionnaire Analysis\n\nWe have analyzed the responses to the post-task questionnaire to determine if there is a difference in the participants’ perception of visual and textual methods. When reporting the results all answers have been realigned to 5 being the best. As the responses were paired, in general not normally distributed, and our samples had ties, we have used the exact Wilcoxon signed-ranks test with Wilcoxon method for handling ties [14]. We set the significance level $\\alpha$ to 0.05. As mentioned, for some of the questions (e.g., Q2 or Q10), we had to invert the order of negative and positive responses so that for all questions all negative responses were on the right and positive responses were on the left.\n\nThe results are summarized and compared in Table 5.5. For each question, the table reports to which perception variable the question refers to (PEOU, PU, ITU), the mean of the answers by all and by good participants (the one who were part of groups that produced good quality threats and security requirements based on expert’s assessment), and the level of statistical significance based on the p-value returned by the Wilcoxon test. The level of statistical significance is specified by • ($p<0.1$), or * ($p<0.05$, ** $p<0.01$, *** $p<0.001$). The table also reports the average responses for each perception variable and for all questions related to perception (Q1-Q12).\n\nThe results show that for some aspects the difference in the perception of visual (CORAS) and textual method (SREP) is statistically significant ($p<0.05$) or has minimum 10% significance level:\n\nQ1 All participants prefer visual method over the textual one for easy of use but the difference in perception is not statistically significant. Instead, for good participants the difference is statistically significant.\n\nQ2 Visual method is better than textual approach with respect to making the security analysis easier than an ad hoc approach. All participants prefer visual method with statistical significance. This is also true for good participants but the difference in participants’ perception is not statistically significant.\n\nQ5 When considering finding threats and security requirements more quickly than using common sense...\nthe results are not clear. The results show a small preference for textual method by all participants which is not statistically significant. In contrast, good participants show a statistically significant preference for visual method.\n\nQ14 Both all participants and good participants with statistical significance believe that a catalog of threats would be more needed by textual method than the visual one.\n\nQ16 Visual method is better than textual one with respect to helping brainstorming on the threats. This holds across all participants and the difference of preference is statistically significant. This is also true for good participants but with no statistical significance.\n\nQ17 Visual method is better than the textual one with respect to helping brainstorming on the security requirements. This holds across all participants but it is not statistically significant. This is also true for good participants and it is statistically significant.\n\nPEOU Visual method is better than the textual method with respect to overall PEOU across all participants but the preference is not statistically significant. Good participants show a small preference for visual method with 10% significance level.\n\nPU Visual method is better than the textual one with respect to overall PU across all participants but the preference is not statistically significant. Good participants show a small preference for visual method with 10% significance level.\n\nITU Visual method is better than the textual one with respect to overall ITU across all participants but the preference is not statistically significant. Good participants show a statistically significant preference for visual method.\n\n<table>\n<thead>\n<tr>\n<th>Q Type</th>\n<th>Mean</th>\n<th>Z</th>\n<th>Mean</th>\n<th>Z</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Textual</td>\n<td>Visual</td>\n<td></td>\n<td>Textual</td>\n</tr>\n<tr>\n<td>1</td>\n<td>PEOU</td>\n<td>3.0</td>\n<td>-0.9</td>\n<td>2.8</td>\n</tr>\n<tr>\n<td>2</td>\n<td>PU</td>\n<td>3.1</td>\n<td>-2.1*</td>\n<td>3.3</td>\n</tr>\n<tr>\n<td>3</td>\n<td>PEOU</td>\n<td>3.3</td>\n<td>0.4</td>\n<td>3.5</td>\n</tr>\n<tr>\n<td>4</td>\n<td>ITU</td>\n<td>3.0</td>\n<td>-0.2</td>\n<td>2.8</td>\n</tr>\n<tr>\n<td>5</td>\n<td>PU</td>\n<td>3.1</td>\n<td>0.3</td>\n<td>2.9</td>\n</tr>\n<tr>\n<td>6</td>\n<td>ITU</td>\n<td>2.9</td>\n<td>0.0</td>\n<td>2.5</td>\n</tr>\n<tr>\n<td>7</td>\n<td>PEOU</td>\n<td>3.0</td>\n<td>-0.2</td>\n<td>3.2</td>\n</tr>\n<tr>\n<td>8</td>\n<td>PU</td>\n<td>3.6</td>\n<td>0.4</td>\n<td>3.8</td>\n</tr>\n<tr>\n<td>9</td>\n<td>ITU</td>\n<td>3.2</td>\n<td>-0.9</td>\n<td>3.2</td>\n</tr>\n<tr>\n<td>10</td>\n<td>PEOU</td>\n<td>3.5</td>\n<td>-0.5</td>\n<td>3.8</td>\n</tr>\n<tr>\n<td>11</td>\n<td>PU</td>\n<td>3.1</td>\n<td>-0.4</td>\n<td>2.8</td>\n</tr>\n<tr>\n<td>12</td>\n<td>ITU</td>\n<td>3.0</td>\n<td>-0.8</td>\n<td>2.9</td>\n</tr>\n<tr>\n<td>13</td>\n<td>Control</td>\n<td>3.8</td>\n<td>-0.2</td>\n<td>3.5</td>\n</tr>\n<tr>\n<td>14</td>\n<td>Control</td>\n<td>4.4</td>\n<td>3.1***</td>\n<td>4.5</td>\n</tr>\n<tr>\n<td>15</td>\n<td>Control</td>\n<td>4.3</td>\n<td>0.9</td>\n<td>4.5</td>\n</tr>\n<tr>\n<td>16</td>\n<td>Control</td>\n<td>3.0</td>\n<td>-2.5*</td>\n<td>2.9</td>\n</tr>\n<tr>\n<td>17</td>\n<td>Control</td>\n<td>3.1</td>\n<td>-1.7</td>\n<td>3.2</td>\n</tr>\n</tbody>\n</table>\n\n**PEOU**\n\n**PU**\n\n**ITU**\n\n| Total | 3.2 | -1.6* | 3.1 | 3.5 | -3.5*** |\n\nTable 5.5: Wilcoxon signed-ranks test of responses\n\n- * - p-value <0.01, * - p-value <0.05, ** - p-value <0.01, *** - p-value <0.001\nThe average responses to Q1-Q12 show a small preference for visual method by all participants with 10% significance level. For good participants, instead the preference for visual method is statistically significant.\n\n5.2.4 Interviews’ Analysis\n\nFor a better understanding of which features influence visual and textual methods effectiveness, we complemented our experiment by interviewing each participant for half an hour.\n\nTable 5.6: Frequency of reported aspects of the methods\n\n<table>\n<thead>\n<tr>\n<th>Advantages</th>\n<th>Visual</th>\n<th>Textual</th>\n<th>Total</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Clear process</td>\n<td>12</td>\n<td>16</td>\n<td>28</td>\n</tr>\n<tr>\n<td>Help in brainstorming threats</td>\n<td>21</td>\n<td>15</td>\n<td>36</td>\n</tr>\n<tr>\n<td>Help in brainstorming security requirements</td>\n<td>12</td>\n<td>24</td>\n<td>36</td>\n</tr>\n<tr>\n<td>Easy to use and remember</td>\n<td>17</td>\n<td>11</td>\n<td>28</td>\n</tr>\n<tr>\n<td>Help to understand interdependencies</td>\n<td>6</td>\n<td>7</td>\n<td>13</td>\n</tr>\n<tr>\n<td>Support visual summary</td>\n<td>24</td>\n<td>0</td>\n<td>24</td>\n</tr>\n<tr>\n<td>No time consuming</td>\n<td>0</td>\n<td>4</td>\n<td>4</td>\n</tr>\n<tr>\n<td><strong>Total</strong></td>\n<td>92</td>\n<td>77</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Disadvantages</th>\n<th></th>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>No clear process</td>\n<td>2</td>\n<td>11</td>\n<td>14</td>\n</tr>\n<tr>\n<td>Do not support interdependencies</td>\n<td>2</td>\n<td>3</td>\n<td>5</td>\n</tr>\n<tr>\n<td>No help in brainstorming threats</td>\n<td>3</td>\n<td>3</td>\n<td>6</td>\n</tr>\n<tr>\n<td>No help in brainstorming security requirements</td>\n<td>9</td>\n<td>1</td>\n<td>10</td>\n</tr>\n<tr>\n<td>Primitive tool</td>\n<td>20</td>\n<td>0</td>\n<td>20</td>\n</tr>\n<tr>\n<td>No support visual summary</td>\n<td>1</td>\n<td>6</td>\n<td>7</td>\n</tr>\n<tr>\n<td>Visual summary does not scale</td>\n<td>10</td>\n<td>0</td>\n<td>10</td>\n</tr>\n<tr>\n<td>Too time consuming</td>\n<td>11</td>\n<td>9</td>\n<td>20</td>\n</tr>\n<tr>\n<td>No easy to use and remember</td>\n<td>0</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td><strong>Total</strong></td>\n<td>58</td>\n<td>35</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Improvements</th>\n<th></th>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Have security resource repository</td>\n<td>0</td>\n<td>5</td>\n<td>5</td>\n</tr>\n<tr>\n<td>Have visual summary</td>\n<td>0</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>Support automatic risk level computation</td>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>Support diagram creation</td>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td><strong>Total</strong></td>\n<td>2</td>\n<td>7</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nThe interviews were analyzed with a content analysis technique called coding [63]. The analysis consists of the following steps: 1) we transcribed and analyzed to identify recurring themes, which serve as the basis to build categories that explain why visual and textual methods work in practice or not; 2) we identified a set of recurring participants’ statements in the interviews and we classified them in advantages, disadvantages and improvements of the methods; 3) for each group of statements, we coded and classified them into iteratively emerging categories; 4) we counted the frequency of statements in each category as an indication of their relative importance. Table 5.6 presents the categories and the frequency of statements in each category made by the participants.\n\nThe main advantage of visual method that participants indicated is that it provides a visual summary of the results of the security analysis (89%). Indeed, the diagrams give an overview of the assets and the possible threats scenarios and treatments. A typical statement made by the participants referring to this advantage was: “Diagrams are useful. You have an overview of the possible threat scenarios and you can find links among the scenarios”. Another noteworthy advantage of visual method reported by the 82% of the participants was that it helps brainstorming on the threats. As the participants indicated, diagrams play a key role in helping to brainstorm on threats: “Yes it helped to identify which are the threats. In CORAS method everything is visualized. The diagrams helped brainstorming on threats.” The next advantage refers to perceived ease of use. The 60% of the participants reported that visual method\nTable 5.7: Results of hypothesis testing\n\n<table>\n<thead>\n<tr>\n<th>Hypothesis</th>\n<th>Description</th>\n<th>Conclusion</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>H1.1</td>\n<td>Difference in the number of threats found with visual and with textual method</td>\n<td>YES (More threats were found with visual method than with textual method)</td>\n</tr>\n<tr>\n<td>H1.2</td>\n<td>Difference in the number of security requirements found with visual and with textual method</td>\n<td>NO (Slightly more security requirements were found with textual method than with the visual one but the difference is not statistically significant)</td>\n</tr>\n<tr>\n<td>H2.1</td>\n<td>Difference in the number of threats found with visual and with textual method within each facet</td>\n<td>YES (For each facet more threats were found with visual than with textual method)</td>\n</tr>\n<tr>\n<td>H2.2</td>\n<td>Difference in the number of security requirements found with visual and with textual method within each facet</td>\n<td>NO (For each facet slightly more security requirements were found with textual method than with visual method but the difference is not statistically significant)</td>\n</tr>\n<tr>\n<td>H3</td>\n<td>Difference in the participants preference for visual and textual method</td>\n<td>YES (Overall visual method is preferred to the textual one)</td>\n</tr>\n<tr>\n<td>H4</td>\n<td>Difference in the participants perceived ease of use for visual and textual method</td>\n<td>MAY BE (Visual method is perceived as easier to use than textual approach with 10% significance level)</td>\n</tr>\n<tr>\n<td>H5</td>\n<td>Difference in the participants perceived usefulness for visual and textual method</td>\n<td>MAY BE (Visual method is perceived as more useful than the textual method with 10% significance level)</td>\n</tr>\n<tr>\n<td>H6</td>\n<td>Difference in the participants intention to use for visual and textual method</td>\n<td>YES (Participants intend to use the visual method more than the textual one)</td>\n</tr>\n</tbody>\n</table>\n\nis a “good methodology, not difficult to use. It is much clear to understand the security case there”.\n\nThe main advantage of textual method according to the 96% participants was that the method helps in identifying security requirements. Typical statements in this category were: “SREP helped in brainstorming. The steps were pretty much defined. Step by step helped to discover more” and “SREP helped in brainstorming. The order of the steps helped to identify security requirements”. The second advantage of textual method is that it has a clear process to follow (60%): “Well defined steps. Clear process to follow.” is an example of typical statement made by the participants for this category.\n\nWith respect to methods’ disadvantages and improvements, the statements were fewer than the ones about advantages. The most indicated disadvantage of visual method was that visual notation does not scale well for complex scenarios. Typical statements in this category were: “The diagrams are not scalable when there are too many links” and “For big systems the diagrams would be very large. Even with the support of the computer it would be difficult to see them.” In addition, 75% of the participants complained about the tool. The major problems reported were the tool bad memory usage that makes the tool too slow and the modeling feature of the tool that does not provide automatic support for the generation of the diagrams (e.g., generating a treatment diagram from a threat diagram). Examples of typical statements for this category were: “The tool is not difficult to use but it is very slow. It is impossible to copy a diagram from a type of diagram to another. Objects have no references between the diagrams. Changes on an object in a diagram are not reflected on the same object in other diagrams.” and “The tool takes too much to arrange things. Drawing assets and threats is not easy. When the diagrams are too large, the tool occupies too much memory”. Instead, textual method has two main drawbacks. First, it is unclear how to perform some of the steps of the textual method process: risk assessment, requirements inspection and repository improvement. Second, the use of tables to represent threats makes it difficult to show the link among assets, threats and security requirements, and thus to give a summary of the results of the security analysis. As reported by the participants “It is not easy to represent what you think because there are a lot of tables. If you are project manager and you want to show the results of the security analysis to your boss it is difficult because you use tables”.\n\nNESSoS - 256980\n5.2.5 Discussion\n\nIn this section we present the main findings regarding each of the research questions and possible explanations for the findings. A summary of the findings is shown in Table 5.7.\n\nMethods’ effectiveness\n\nAs shown in the previous sections, visual method is more effective in identifying threats than textual method. This result is also confirmed if we consider the number of threats identified with visual and textual methods across the task assigned to the groups. Since the difference in the number of threats identified with the two methods is statistically significant, we can accept the alternative hypotheses $H_1A$ and $H_2A$ of difference between the number of threats identified with the two methods. Instead, with respect to number of security requirements, textual method is slightly more effective than the visual one in identifying security requirements but the difference is not statistically significant across all groups and tasks. The alternative hypotheses $H_1A$ and $H_2A$ of difference in the number of security requirements can therefore be rejected.\n\nMethods’ perception\n\nParticipants’ overall preference is higher for visual than for textual method. Among all the groups the difference has 10% significance level, while for the participants who were part of groups who produced good quality threats and security requirements, the difference in the overall preference is statistically significant. The conclusion is that the alternative hypothesis $H_3A$ of difference in the overall preference of the two methods is upheld. Similarly, for all participants there is no statistically significant difference in perceived ease of use and usefulness, while for “good” participants the difference has a 10% significance level. For this reason, there is no evidence that the null hypotheses $H_4$ of no difference in the perceived ease of use and $H_5$ of no difference in perceived usefulness do not hold. Thus, the alternative hypotheses $H_4A$ and $H_5A$ cannot be rejected or accepted. With respect to intention to use, “good” participants intend to use more visual than textual method and the difference in participants’ perception is statistically significant. The alternative hypothesis $H_6A$ of difference in the intention to use for the two methods can thus be accepted.\n\nQualitative Explanation\n\nThe different number of threats and security requirements identified with visual and textual methods can be likely explained by the differences between the two methods indicated by the participants during the interviews. Diagrams in visual method help brainstorming on the threats because they give an overview of the possible threats (who initiate the threats), the threat scenarios (possible attacks) and the assets, while the identification of threats in textual method is not facilitated by the use of tables because it is difficult to keep the link between assets and threats. As suggested by the answers to question Q14 in the post-task questionnaire, the identification of threats in textual method could be made easier if a catalog of common threats was available. In addition, during the interviews some of the participants indicated that a visual representation for threats would be better than a tabular one.\n\nTextual method is slightly more effective in eliciting security requirements than visual approach because the order of steps in textual method process guides the analyst in the identification of security requirements, while the same it seems not to hold for the visual method’s process.\n\n5.2.6 Threats to Validity\n\nWe discuss the four main types of threats to validity [71] in what follows.\n\nConclusion validity Conclusion validity is concerned with issues that affect the ability to draw the correct conclusion about the relations between the treatment and the outcome of the experiment. There are three main threats to conclusion validity relevant for our experiment:\n• **Low statistical power.** An important threat to validity is related to the sample size that must be big enough to come to correct conclusions. We conducted a post-hoc power analysis for the ANOVA test and Wilcoxon signed-rank test (with G*Power 3 tool\\(^2\\)) for participants from good groups. For Wilcoxon signed-rank test, we obtained a power \\((1-\\beta)\\) equal to 0.86 setting as parameter the effect size \\(ES = 0.71\\), the total sample size \\(N = 24\\), and \\(\\alpha = 0.05\\). For the ANOVA test, we have instead a power of 0.89 with 32 observations for each method and between variance at least 16 observations are needed to have an effect size of 2 like in our experiment. We thus have enough observations to conclude that our results on the relation between the methods applied and their performance in terms of number of threats and security requirements and with responses to the post-task questionnaire are correct.\n\n• **Violated assumptions of statistical tests.** Before running the ANOVA and Wilcoxon signed rank tests we have checked with Shapiro-Wilk and Flinger-Killeen tests that their assumptions are not violated. For example, before applying ANOVA to test the effect that the method has on the number of assets, threats, and security requirements, we have checked the assumption about the homogeneity of the variance using the Flinger-Killeen test which in all three cases reported a \\(p\\)-value greater than 0.05. Thus, we are sure that the assumptions of statistical tests were not violated and that our results are correct.\n\n• **Heterogeneity of subjects.** If groups in the sample are too heterogeneous, the variation due to individual differences may be larger than due to treatment. We have reduced this threat by running the experiment with master students who had similar knowledge and background.\n\n**Internal validity** Internal validity is concerned with issues that may falsely indicate a causal relationship between the treatment and the outcome, although there is none.\n\n• **Participants’ background.** The familiarity of the participants with the methods evaluated during the experiment is a threat to internal validity. At the beginning of the experiment, we have administered a questionnaire to check the background of the participants and their knowledge of security methods. The questionnaire has shown that all participants had a similar background and had no prior knowledge about visual and textual methods.\n\n• **Bias in the tutorials.** Differences in the methods’ performance may occur if a method is presented in a better way than the other. In our experiment we limit this threat by giving the same structure and the same duration to the tutorials on textual and visual methods.\n\n• **Participants’ behavior.** During the execution of the experiment, the subjects may react differently over time e.g., subjects may become bored or tired, or they may become more or less positive to one or another method. We notice that the performance of the participants in terms of number of threats and security requirements identified was almost the same for the first, second and third task, while on the last task the performance decreases because the participants got tired or did not put much effort. Yet, this phenomenon was common to both methods.\n\n• **Bias in data analysis.** To avoid bias in the reports analysis, the coding of the participants’ reports was conducted by the authors of the paper independently. In addition, the quality of the threats and security requirements identified by each group was assessed by an expert external to the experiment.\n\n**Construct validity** Construct validity concerns generalizing the result of the experiment to the concept and theory behind the experiment. The main threat to construct validity in our experiment is the design of the research instruments: interviews and questionnaires. The questionnaire was designed following the Technology Acceptance Model with four questions for each of the independent variables we wanted to measure: perceived usefulness, perceived ease of use, intention to use. The interview guide included\n\n\\(^2\\)http://wwwpsycho.uni-duesseldorf.de/abteilungen/aap/gpower3/\nquestions concerning research questions $RQ3$ and methods’ advantages and disadvantages. Three re-\nsearchers independently have checked the questions included in the interview guide and in the question-\nnaire: therefore we are reasonably confident that our research instruments measured what we wanted to\nmeasure.\n\nExternal validity External validity concerns the ability to generalize experiment results beyond the ex-\nperiment settings. External validity is thus affected by the objects and the subjects chosen to conduct the ex-\nperiment.\n\n- **Use of students instead of practitioners.** Using students rather than practitioners as subjects is\n known as a major threat to external validity. However, Svahnberg et al. [64] recognized that students\n may work well as subjects in empirical studies in the requirements engineering area.\n\n- **Realism of the application scenario and facets.** We reduce the threat to external validity by making\n the experimental environment as realistic as possible. In fact, as object of our experiment we have\n chosen a real industrial application scenario proposed by National Grid. Furthermore, the reports\n of participants have been evaluated by an expert from National Grid: the quality of both security\n requirements and threats identified is good enough for the study (see also §5.2.2).\n6 Conclusion\n\nWe have presented a full evaluation approach, called SecEVAL, which can be used to do evaluation-based research in the area of secure software in a structured way.\n\nSecEVAL is based on the work previously done in WP2 and WP5 (CBK) [13, 6], as well as on the structured literature review by Kitchenham et al. [39] and inspired by the C-INCAMI framework of Becker et al. [4], to name a few. It defines an ontology which is represented as UML model. SecEVAL specifies:\n\n- an improved, flexible security context model for describing features of methods, notations and tools in the security area.\n- a model that records the way how data is collected. It mainly comprises the research question, collection process, used resources and the queries which are used for finding sources which might be used to answer the question.\n- an analysis model which defines the analysis strategy and the filters and algorithms it uses on the collected sources. Furthermore, the data structure for information is exactly specified, regardless of whether the data is to be stored in the security context model or not.\n\nSecEVAL was improved using a guided interview and we additionally provided a case study about methods and tools from the area of security focusing on a research question about the selection of vulnerability scanner for web applications.\n\nFurthermore, we reported on an evaluation of approaches for secure software design as well as an empirical validation of risk-based methods. The former is a mapping study [58] which provides an overview of the current state of the art regarding secure software design. The latter study compares a textual method (i.e. CORAS [45]) and a graphical method (i.e. SREP [48]), based on the approaches of Kitchenham et al. and Moody [51].\n\nFor both studies, we claim that a slightly extended version of SecEVAL (cf. extension for Moody’s approach in subsection 3.3.2) could easily record the process of doing research as well as the result data. As this process is quite straight-forward, we omitted to draw SecEVAL instance diagrams. However, we strongly recommend to add the outcome to an implemented version of SecEVAL, as soon as it will be available.\n\nSummarizing, SecEVAL provides a sound basis for evaluating research questions related to secure software engineering. This eases the process of doing research in the area of security no matter if the research question aims at scientific or engineering issues.\n\nFurther goals are to evaluate more examples like the testing case study presented in this deliverable. We already noticed that SecEVAL’s security context model can easily be extended or even mapped to another domain by adding and removing elements. Further practical experience would be exciting at this point.\n\nIt would also be interesting to implement the context model in a more flexible version of the CBK, although it is challenging to strike a balance between complexity of the CBK’s implementation and the effort such a flexible model would cause. For the implementation, we suggest experimenting with an attribute-based suggestion system: when creating a new element in the Wiki, it first is empty, but on the right hand side of the screen common attributes are shown which can be dragged onto the Wiki page in order to fill and arrange them. A useful feature is to be able to insert text from other web pages, e.g., from Wikipedia or vulnerability management systems, which are then correctly cited. Step-by-step wizards and good tag recommendation according to the tags selected so far and the information provided would ease this task. Additionally, recommendation includes that the system needs to explain rules inferred by SecEVAL, as e.g., that tools and notations are described by different attributes and that it is useful to describe tool and notation in a separate entry, also in case that a notation is only used by one tool yet. A focus should also be on the connection of several entries and on the possibility to add data which is not only associated with one entry (e.g., data which is semi-automatically extracted from existing papers). Adding metrics to an attribute or to a numeric value within a text-based attribute would round off the implementation.\n\nSo far, we also reported on newly integrated SDE tools in deliverables of WP2. This time, information about the SDE can be found in deliverable D1.4 [2]. Details will follow in deliverable D2.5.\n7 NESSoS Third-Year Publications\n\n\nBibliography\n\n\nA Appendix: Questionnaire\n\nIn the following, the questionnaire about our Security Context model is reprinted. It was handed out at the NESSoS plenary meeting in Malaga (29.5.-31.5.2013). In the original version of the questionnaire, there was space after each question so that the answers could be handwritten.\n\nA.1 Security Engineering Method and Tool Evaluation\n\nOur aim is to provide an approach for the evaluation of methods and tools for the engineering of secure software systems. In our approach we do not only distinguish methods and tools, but also notations. For an evaluation and comparison approach we need to define (1) the process of how to conduct a comparison and (2) the structure used to collect security-related data and metrics to analyze it. Therefore, we define a conceptual framework that comprises these three aspects: Security Context, Data Collection and Analysis. We depict the concepts and their relationships as a model (see Figure A.1 for an overview), so that we can instantiate concrete methods, tools and notations.\n\nAdditionally, we will compare other approaches with our framework in order to further adapt or extend it with the objective to make it more general. The basic structure of our model of the Security Context is as depicted in Figure A.2.\n\nThe classes Method, Notation and Tool are depicted in the center. They inherit general attributes, as e.g., names and URLs, from the abstract class Mechanism (we are still looking for a better name to replace “mechanism”, suggestions are welcome!). A tool can support methods and a notation can be used for several methods.\nSecurity features are shown on the left hand side of Figure A.2.\n\n- A **SECURITY PROPERTY** can be, e.g., authorization, authentication, integrity, etc. Several security properties can be enforced or attacked by a method.\n\n- A **VULNERABILITY** can endanger security properties. Examples are XSS, SQL Injection, Buffer or Overflows, etc.\n\n- A **THREAT** can exploit vulnerabilities. Threats are kind of methods which are vicious.\n\nIn Figure A.3 resp. A.4, the classes **Tool and Method** are refined according to their usage in the Software Development Life Cycle (SDLC).\nFigure A.3: Security Context: Details of Tools\n\nFigure A.4: Security Context: Details of Methods\nA.2 Questions and Suggestions\n\n1. Name:\n Partner:\n\n2. Areas of security you are working in?\n\n3. Can methods from your area be represented using our model?\n Provide examples of methods.\n Are concepts or relationships missing? Which?\n\n4. Can tools from your area be represented using our model?\n Provide examples for tools.\n Are concepts or relationships missing? Which?\n\n5. Can notations from your area be represented using our model?\n Provide examples of notations.\n Are concepts or relationships missing? Which?\n\n7. Would you use our structure to evaluate tool, methods or notations in your area? If not, what would your approach look like?\n If yes, where do you see its strengths?\n\n8. Can you suggest related work (esp. for managing tool and method portfolios for the area you are working in or general approaches to compare with our approach)?\n\n9. General comments or improvements?"}}},{"rowIdx":177,"cells":{"id":{"kind":"string","value":"b47e2ac3b2a9e58c0b47f785f237779fe4352431"},"text":{"kind":"string","value":"Autonomous Service Execution Driven by Service-Level Agreements\nAndré Lage Freitas\n\nTo cite this version:\n\nHAL Id: tel-00715375\nhttps://tel.archives-ouvertes.fr/tel-00715375\nSubmitted on 11 Jul 2012\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.\nTHÈSE INSA Rennes\nsous le sceau de l’Université Européenne de Bretagne\npour obtenir le grade de\nDOCTEUR DE L’INSA DE RENNES\nSpécialité : Informatique\nprésentée par\nAndré Lage Freitas\nÉCOLE DOCTORALE : MATISSE\nLABORATOIRE : IRISA – UMR6074\n\nAutonomous Service Execution\nDriven by Service-Level Agreements\n\nThèse soutenue le 29 mars 2012\ndevant le jury composé de :\nSalima BENBERNOU\nProfesseur à l’Université Paris Descartes / Présidente\nZsolt NÉMETH\nChercheur Senior à MTA SZTAKI / Rapporteur\nChristian PEREZ\nDirecteur de Recherche HDR à l’INRIA / Rapporteur\nJean-Louis ROCH\nMaître de conférence à l’ENSIAMG / Examinateur\nJean-Louis PAZAT\nProfesseur à l’INSA de Rennes / Directeur de thèse\nNikolaos PARLAVANTZAS\nMaître de conférence à l’INSA de Rennes / Co-encadrant de thèse\nContents\n\n**Introduction**\n- On Leveraging Services ................................................. 5\n- The Gap ........................................................................... 6\n- Objectives ........................................................................ 6\n- Organization of the Thesis ............................................. 7\n\n**I State of the Art** .......................................................... 9\n\n**1 Service-Centric Paradigm** ........................................ 11\n\n1.1 Service-Level Agreements ............................................ 11\n\n1.1.1 Overview .................................................................. 11\n1.1.2 SLA Life-Cycle ...................................................... 12\n1.1.3 WSLA and WS-Agreement ...................................... 12\n\n1.2 Quality of Service (QoS) ............................................. 13\n\n1.2.1 Fault Tolerance ....................................................... 13\n1.2.2 Performance .......................................................... 14\n1.2.3 Trade-Off Between Performance and Fault Tolerance .. 14\n\n1.3 Pricing ................................................................. 15\n\n1.3.1 Introduction .......................................................... 15\n1.3.2 Accounting Assessment ......................................... 15\n1.3.3 Price Formation .................................................... 16\n\n1.4 Self-Managed Systems .............................................. 17\n\n1.4.1 Dynamic Adaptation ............................................. 17\n1.4.2 Autonomic Computing ........................................... 17\n\n1.5 Web Services .......................................................... 18\n\n1.5.1 Loosely-Coupled Distributed Applications ............... 18\n1.5.2 Web Services ......................................................... 18\n\n1.6 Grid Computing ......................................................... 19\n\n1.6.1 Overview .......................................................... 19\n1.6.2 Application Programming Interface ......................... 20\n1.6.3 Grid Platforms .................................................... 21\n\n1.7 Cloud Computing ..................................................... 22\n## Contents\n\n1.7.1 Overview ........................................... 22 \n1.7.2 A Common Layered Architecture ......................... 23 \n1.7.3 Infrastructure, Platform and Software as a Service .......... 23 \n\n2 Related Work ........................................... 25 \n2.1 Pricing ............................................ 25 \n2.2 SLA Management ....................................... 26 \n2.2.1 SLA Life-Cycle ..................................... 26 \n2.2.2 SLA Translation ..................................... 26 \n2.2.3 QoS Assurance ...................................... 27 \n2.3 Resource Acquisition .................................... 28 \n2.4 Summary of Related Work ................................... 29 \n2.4.1 Comparison Table .................................... 29 \n2.4.2 The Gap .......................................... 30 \n2.4.3 Filling the Gap ...................................... 31 \n\nII Conception ........................................... 33 \n\n3 SLA-driven Service Execution Management ....................... 35 \n3.1 Underlying Concepts .................................... 35 \n3.1.1 Definitions and Assumptions ............................ 35 \n3.1.2 Variables ......................................... 36 \n3.1.3 Life-Cycles: Contract, Request and Job .................. 36 \n3.2 Profit as a Goal ....................................... 39 \n3.3 Creation of Contract Templates .............................. 40 \n3.3.1 Contract Template Labels ............................. 41 \n3.3.2 QoS Translation ..................................... 42 \n3.3.3 Pricing ........................................... 43 \n3.4 QoS Assurance ......................................... 44 \n3.4.1 Performance ........................................ 45 \n3.4.2 Fault Tolerance ...................................... 45 \n3.5 Resource Acquisition and Allocation .......................... 48 \n3.5.1 Contract Proposals ................................... 48 \n3.5.2 Request Arrivals ..................................... 50 \n\nIII Implementation ........................................... 53 \n\n4 Qu4DS ................................................. 55 \n4.1 Support for Master/Worker Applications ...................... 56 \n4.2 Foundations .......................................... 56 \n4.2.1 Separating Resource Acquisition from Job Management ... 56 \n4.2.2 Assumptions ....................................... 60 \n4.2.3 Profiling .......................................... 62\nIntroduction\n\nOn Leveraging Services\n\nCurrently, computing systems are built based on the integration of other systems in contrast to earlier systems which were partially integrated or even isolated. This integration is motivated by the Internet along with its high-speed backbones which promote the connection of different computing platforms. As a result, current applications are often built on top of electronic services transparent to users. In order to build service-based applications, new paradigms have been proposed such as Internet of Services, Cloud Computing and Web 2.0 which enable building high-level applications by using the Internet infrastructure. Examples include Google Maps [Goo04] and Facebook [Fac04] which bring together different kind of services through a common graphical user interface. These platforms include a great number of functionalities whose interface abstracts the complexity of the underlying environment. For instance, Google Maps allows customers to uniformly access location services such as maps, satellite and street photos, traffic information, and route planner.\n\nService providers take advantage of distributed runtime infrastructures such as clouds and grids. Cloud Computing provides resources on-demand by leveraging virtualization technologies. Thus, resources can be acquired at runtime in order to deploy service instances according to the customer demand. For instance, Zencoder [Zen10] provides audio and video encoding services on top of resources provided by Amazon EC2 [Ama06a]. Grid Computing enables building services by leveraging batch jobs. By using grids, low-level details concerning resource management are transparent to service developers. For example, the Simple Grid API (SAGA) [GJK+05] integrates various grid platforms by providing a uniform grid programming interface.\n\nThe functionalities provided by clouds and grids are useful but taking advantage of them is complex and requires manual effort. Moreover, service execution should be guided by Service-Level Agreements (SLAs) which describe the Quality of Service (QoS) that should be delivered along with the service. In order to meet the agreed QoS properties of an SLA, service execution should address service negotiation, instantiation, provisioning and termination driven by SLA constraints. This problem is challenging owing to the need of: (i) translating QoS metrics to system configurations; (ii) ensuring the agreed QoS; and (iii) managing distributed resources. An orthogonal but complementary concern with regard to managing service execution is to take into account provider profit interests. Indeed, profit augmentation is a main concern of\nservice providers. However, it is hard to implement policies that aim at profit augmentation since they cover various pricing aspects such as price, costs, and fines. For instance, enforcing SLAs may require using more resources; however, profit augmentation policies may rely on reducing costs on infrastructure. Therefore, it is a challenge to manage the service execution on top of distributed resources while addressing SLA life-cycle and profit augmentation simultaneously.\n\nThe Gap\n\nCurrent work has handled the problem of managing service execution guided by SLA directives in various ways. Regarding pricing aspects, current approaches that rely on pricing models do not focus on describing the penalties owing to SLA violations. For instance, some commercial approaches \\cite{Ama06a, Sal99, Zen10} compute penalties based on a limited definition of availability and pay fines by means of service credits.\n\nOther approaches have addressed SLA management concerning SLA life-cycle, QoS assurance and SLA translation. Specification of languages and protocol \\cite{ACD+07, LKD+03} were proposed to handle the SLA life-cycle, but these efforts do not implement underlying mechanisms that manage SLAs. The SLA@SOI project \\cite{THK+10} also addresses SLA management, but it does not define specific realization mechanisms. With respect to SLA translation \\cite{LTH09}, approaches either rely on abstract translation schemes \\cite{KW10, SS09, HKSW06} or do not consider the distributed nature of the runtime environment \\cite{CIL+08}. Most approaches which deal with QoS assurance focus on the underlying infrastructure and do not address pricing aspects. These approaches rely on job replication \\cite{DG08}, job rescheduling \\cite{LZ10, Huc04}, extra resources \\cite{DFL11, LLJ10} and priority policies \\cite{KP11b} in order to improve performance or fault tolerance.\n\nFinally, some approaches handle resource acquisition as part of the service execution management. In this context, resource acquisition is proposed to be decoupled from resource utilization \\cite{TBB+08, CGP+10, LLJ10} as well as automatic virtual machine deployment \\cite{KTNN11}. Moreover, in \\cite{GG11}, the authors investigate different resource acquisition policies and their impact on performance and infrastructure costs.\n\nThe efforts of the aforementioned approaches are incomplete in a sense that they do not address the whole SLA life-cycle, being hence isolated solutions. Moreover, they fail to integrate a pricing model and further economic interests, specifically the augmentation of the service provider profit. Furthermore, current approaches are not automated hence requiring a lot of human effort.\n\nObjectives\n\nThe main goal of this thesis is to provide an autonomous solution for managing service execution under SLA constraints. In addition to guiding the service execution by SLAs, this thesis also aims at increasing the provider profit. Firstly, the autonomous service execution should be able to negotiate contracts, deploy service instantiates, treat requests, and destroy the service instance automatically. Moreover, these tasks should\nbe governed by SLA guidelines which include translating QoS metrics to system configuration, acquiring resources, and prevent SLA violations owing to QoS degradation. The challenge is then to deliver the service while meeting the agreed quality properties. Secondly, the problem of increasing the provider profit should be addressed in parallel, which brings even more complexity to the service execution management. This leads to investigate pricing aspects which impact the profit such as price, fines, and operational expenses. Further, the dynamic, unpredictable and distributed runtime environment on which services are executed brings complexity to this problem.\n\n**Organization of the Thesis**\n\nThis manuscript is organized as follows. The context of this thesis lies on the service abstraction as a means of building distributed applications. This approach is called the Service-Centric Paradigm (SCP) and is introduced in Chapter 1. The importance of SCP relies on the loosely-coupled way of conceiving modular applications whose interactions are defined by Service-Level Agreements (SLAs). SLAs describe service obligations which include the Quality of Service (QoS) that should be associated with the service. Moreover, Chapter 2 discusses how current work addresses QoS on top of distributed infrastructures.\n\nThis thesis deals with two problems: service execution management and service profit augmentation. These problems are discussed in Chapter 3 which presents a solution that addresses the SLA life-cycle while aiming at increasing the provider profit. In order to handle service execution management, this thesis relies on three contributions. Firstly, Section 3.3 addresses how contract templates are created in order to enable contract negotiation which includes SLA translation and pricing aspects. Secondly, QoS assurance mechanisms are proposed in Section 3.4 which are configured based on the translation of QoS metrics to system-level configurations. Thirdly, Section 3.5 deals with resource acquisition and allocation by reacting to contract proposals and request arrivals. Simultaneous to the service execution management, complementary and orthogonal actions are in charge of increasing the provider profit. These actions include rescinding contracts, reduction of infrastructure costs, preventing SLA violations, and minimizing fine payments.\n\nIn order to realize the aforementioned conceived solution, the Chapter 4 depicts the design and implementation of the autonomous Qu4DS (Quality Assurance for Distributed Services) framework. Qu4DS transparently manages service executions by providing a higher-level support for services which abstracts over distributed infrastructures. Qu4DS is in charge of automatizing SLA management tasks based on high-level policies. Furthermore, Qu4DS relies on a modular design which enables employing further policies.\n\nQu4DS is validated in Chapters 5 and 6. In Chapter 5, the experimental environment is introduced which includes the case study and configuration details. As proof of concept, Qu4DS is used to implement the flac2ogg service provider which compress audio files. Chapter 6 depicts Qu4DS evaluation performed on top of the Grid5000\ntestbed. Different experimentation scenarios are introduced in Section 6.1 and followed by the results in Section 6.2. The evaluation validates the solution proposed by this thesis and allows analyzing Qu4DS efficiency under different constraints.\nPart I\n\nState of the Art\nChapter 1\n\nService-Centric Paradigm\n\nThe Service-Centric Paradigm (SCP) refers to the idea of building distributed applications by leveraging elementary software blocks abstracted as electronic services. Indeed, SCP mostly takes advantage of two important concepts: computing utility and separation of concerns. Computing utility dates back to the 60s when computing features were proposed to be offered as public utilities by leveraging the time-sharing technology as if they were conventional services, e.g., electricity and water. Following that, more recent research has implemented technologies which allow computing utility to be conceived in large scale such as early data centers, grid computing and cloud computing. On the other hand, dating back to the 70s, the idea of separation of concerns has been introduced [Dij82, Par72] which is the basis for conceiving modular systems. The basic idea is to separate different concerns and tackle them separately. Technologies which leverage such separation of concerns have been evolved whose examples include Object-Oriented Programming, Aspect-Oriented Programming, and Web Services which rely on hiding implementation and exposing interfaces in order to ease the development, maintenance, and understanding of programs.\n\nTherefore, SCP relies on loosely-coupled services which deliver computing utility capabilities in a distributed environment. The background of this thesis focuses on the SCP and is organized as follows. Firstly, Service-Level Agreements (SLAs) are introduced in Section 1.1. Secondly, Section 1.2 discusses Quality of Services (QoS) offered by SLAs. As services are provisioned under pricing constraints, Section 1.3 exposes some issues with regard to pricing models. Following that, Section 1.4 discusses systems whose management is autonomous. In Sections 1.5, 1.6 and 1.7, three important technologies are introduced in the context of the SCP: Web Services (WS), Cloud Computing, and Grid Computing respectively.\n\n1.1 Service-Level Agreements\n\n1.1.1 Overview\n\nThe Service-Level Agreement (SLA) is used to express the relationship between electronic services whose contacts are employed in short-term and highly-dynamic business\nscenarios. SLAs mimic conventional contracts where the contracted part refers to the service provider while the consumer is represented by the service customer\\textsuperscript{1}. SLAs define not only how services ought to behave, but also how they should not behave. In addition, SLAs do not ensure any obligation; they only define the rules that may be employed in case of non commitment of such obligations \\cite{BLM08,WB12}.\n\n### 1.1.2 SLA Life-Cycle\n\nThree phases govern the SLA life-cycle. The first phase refers to the contract definition when a contract template is generated by describing which quality is offered – commonly, models, meta-models and ontologies are usually used for representing QoS \\cite{UTU08}. The second phase is the contract establishment when parties negotiate and agree on the contract terms which expose the QoS metrics and their associated values. The third phase comprises the contract enactment when the service is executed and both functional and non-functional aspects are monitored in order check whether the service is properly delivered under the terms of the agreed QoS. Moreover, monitoring the SLA should be done by a third party as \\cite{GFI05} for instance.\n\n### 1.1.3 WSLA and WS-Agreement\n\nCurrently, there is no standard for specifying SLAs. In the literature, WSLA and WS-Agreement are the main specifications being often used and referenced \\cite{BLM08,DMRTV07}. The WSLA (Web Service Level Agreement) \\cite{LKD03} SLA specification aims at providing means for configuring both provider and customer systems in order to provide and supervise their services. The WSLA proposes a formal language based on XML by allowing automatizing agreement actions. Then customer and providers are configured by interpreting the WSLA document. The configuration structure includes: (i) the parties, their roles and action interfaces; (ii) service-level parameters (SLA parameters) which are composed of both resource and aggregate metrics; and (iii) service-level objectives (SLOs), composed by guarantee actions that represents the parties’ obligations. The latter SLA specification is the WS-Agreement \\cite{ACD07} specification that proposes a language and a protocol for describing the service capabilities, for creating agreements and for supervising agreement compliance. WS-Agreement assumes that guarantees depend on states based on the idea of stateful Web Services; as proposed by the WS-RF \\cite{CFF04} which wraps resources as stateful Web Services.\n\nWSLA and WS-Agreement provide enough details concerning high-level structures of agreements and how they can be negotiated since they have the same goal: to define how the service will be provide and how it will be supervised. Moreover, both specifications rely on the WSDL (Web Service Description Language) in order to describe the service functionalities. On the other hand, WSLA and WS-Agreement differ from the fact that WS-Agreement also proposes a terminology and a protocol for agreement management. Furthermore, WS-Agreement does not offer a robust QoS (Quality of\n\n\\textsuperscript{1}Also referred as service client in the literature.\nService) model as WSLA provides which allows combining QoS and exploiting QoS semantics.\n\n1.2 Quality of Service (QoS)\n\nThe SLA expresses the terms of the service which are divided in functional and non-functional requirements of the provided service. Functional requirements define the service essential features necessary to meet the service purpose. In contrast, non-functional requirements define further capabilities which are not directly related to the service main purpose such as performance, fault tolerance and data persistence. Moreover, non-functional requirements are also referred as Quality of Services (QoS) as they do qualify the service provider. The QoS has great importance to service providers since service providers can be distinguished based on quality properties. Thereby, QoS are used to offer differentiated services by enabling the service provider to be competitive against further competitor services. For instance, QoS plays an important role in the business model of current technologies such as the Internet of Things, Web 2.0 and clouds.\n\nThe next sections discusses fault tolerant and performance properties of services followed by a discussion of the trade-off performance and fault tolerance.\n\n1.2.1 Fault Tolerance\n\nFault tolerance is a means to ensure that services comply with their specification in the presence of faults \\[\\text{Lap85}\\]. A fault is a representation of a system malfunction which may come from design or execution time. In order to prevent a service failure, i.e., to not disturb the service execution, faults should be handled. In order to measure the degree of fault tolerance, availability and reliability are often employed. Availability measures how often a service is available for responding requests. Availability can be expressed as a ratio of the time which the service was available by the measured time interval. Reliability indicates how much a service is reliable with respect to responding a request. The degree of reliability of a system can be expressed by high-level non-functional constraints such as strong, medium and weak \\[\\text{RFC2119}\\].\n\nMost of commercial service providers rely on providing availability\\(^2\\) QoS. The availability is often represented by means of percentage, exposing the ratio between the total time that the service could be accessed by the customer and a given time interval \\[\\text{WB12, Zen10, Ama06a, Mic08, Goo08}\\]. For instance, Zencoder \\[\\text{Zen10}\\] provides audio and video encoding services whose interfaces are guaranteed to be reachable 99.9% of the time in a month. Amazon EC2 \\[\\text{Ama06a}\\] ensures that virtual machines will be available 99.95% of the time in a year. If Zencoder or Amazon EC2 fail to meet the agreed availability rate, the penalties are computed by means of service credits to customers; while Zencoder is willing to refund customer based on the whole contract\n\n\\(^2\\)Also referred as service uptime.\ntime, Amazon EC2 only refunds ten percent of it. With respect to the monitoring criterion, Amazon EC2 defines an unavailable virtual machine as not being accessible for more than five minutes while Zencoder monitoring interval is one minute. Moreover, both service providers rely on ambiguous and weak definitions of availability which exclude fundamental dependability concepts.\n\n1.2.2 Performance\n\nThe performance characteristic of a service is related to quality properties involving time metrics. Various measures can be used such as latency, throughput, operational time, and response time. Latency is mostly used to express the delay of data transfer with regard to network connections. The throughput metrics is also commonly used in network in order to measure the transfer rate, but it may be used to express the rate of a request treatment as MB/sec for instance. The operational time refers to the time that the service provider takes to make the service operational. Finally, response time typically measures the time to treat a request. While latency and throughput are commonly related to the network-level services, operation time and response time are mostly employed on services at application-level. Specifically, current work addresses the response time metrics by means of trying to decrease the overall response time. Thus, customers might experience performance improvements based on non-accurate metrics which is often expressed as the experimented response time. In this context, examples include approaches which addresses experimented request response time \\cite{DG08, Hue04, KP11b} as well as experimented queue waiting time \\cite{KMB+12}. Further commercial cloud providers such as \\cite{Zen10, Ama06a, Mic08, Goo08} do not specify any performance QoS in their SLAs.\n\n1.2.3 Trade-Off Between Performance and Fault Tolerance\n\nThe use of mechanisms which implement fault-tolerant techniques imply operational overhead \\cite{Lap85}. For instance, error recovery and redundancy techniques require time to be employed thus increasing the total time of the service request. Therefore, there is a trade-off between performance and fault tolerance when designing a system since it is not practicable to prioritize both aspects concurrently. In other words, it is not possible to implement a system that achieves high-performance with a high fault-tolerance degree.\n\nBecause performance QoS metrics are not accurately described by current service provider implementations, approaches that address both fault tolerance and performance QoS do not deal with the trade-off. On the one hand, current cloud providers are more concerned about delivering the agreed availability thus considering the performance assurance a secondary goal. On the other hand, further approaches which implement actual fault-tolerant and performance assurance mechanisms \\cite{DG08, LZ10, Hue04, KP11b} do not consider the stated trade-off as they are not interest in meeting specific QoS metrics, but improving response times.\n1.3 Pricing\n\n1.3.1 Introduction\n\nEconomic interests in software gained special attention in the 60s when software started to be sold as software licenses. Software licenses represent perpetual rights for using a copy of the software. In this model, the license depends on various factors as the number of machines in which the software could be installed, the number of users that can use the software concurrently and so forth. With the popularization of the Internet and the great investment on high-speed networks over the world, not only software, but computing features as virtual resources trended to be sold as a service. In order to sell computing services, service providers propose to customers to pay according to their usage. Perpetual licenses do not fit this business model as the delivered services are now used from a remote client machine thus the software is not installed in the client’s machine anymore. Thereby, customers pay for a service usage instead of buying perpetual software licenses. The fact of trading software and resources as services leads to define how customers pay for them as well as to redefine the price formation. These issues are explained in Sections 1.3.2 and 1.3.3 respectively.\n\n1.3.2 Accounting Assessment\n\nAccounting assessment defines how the customer will be charged for using the service. In order to enabling the accounting assessment, different accounting metrics are used which may be related to specific provided services. For example, accounting metrics may refer to usage time, input or output metrics (file size, video time, etc.), request frequency, number of users per contract, number of functionalities and so forth.\n\nTwo main accounting assessments are employed by service providers. The former accounting assessment is pay-per-use\\(^3\\) which has been popularized and promoted by cloud computing by selling virtual hardware and software as a service. The pay-per-use accounting assessment accounts the service price based on its usage, similar to the way of how taxis and electric energy are paid. For example, the Google App Engine (GAE) \\(^{[Goo08]}\\) does the accounting based on data read/write operations ($ per number of operations) while Zencoder accounting is based on video output length ($ per minute of output video). The latter accounting assessment is called subscription which relies on periodical payments which grants access to the service. For example, service providers use hourly, daily, monthly subscriptions along with the specified accounting metrics.\n\nAlthough the subscription accounting assessment is more profitable for service providers, it is important to also offer the pay-per-use accounting assessment. Charging customers in a pay-per-use fashion is attractive to customers because they pay only for the actual service usage. In contrast, pay-per-use is not interesting for service providers because it negatively influences the provider profit. If the accounting assessment does not depend on the usage, customers tend to pay more than necessary thus increasing the provider profit margin. However, the importance of pay-per-use lies on the follow-\n\n---\n\n\\(^3\\)Also referred in the literature as pay-as-you-go.\nService-Centric Paradigm\n\nReasons for competition purpose as pay-per-use is widely assumed to be an intrinsic characteristic of service providers; (ii) customers are used to think that this model is fair; and (iii) service providers still have a way of overcoming the pay-per-use disadvantages by setting a higher prices than subscription plans. As a result, most of service providers provide both pay-per-use and subscription plans.\n\nLastly, subscription accounting assessment can be understood as a customization of a pay-per-use which relies on the time metrics. If this pay-per-use is modified to rely on periodical payments which time metrics is fixed to a minimal interval, it becomes a subscription accounting assessment; which may also limit to a maximum amount of service-specific accounting metrics. Thus, service providers create subscription plans which usually offer tariff reductions as the maximum amount of specific metrics increases – for example, by mimicking mobile telephony companies. For instance, Zencoder’s pay-per-use option accounts 0.05U\\$ per minute of video output while its launch subscription plan relies on monthly payments of 40U\\$ for a maximum of one-thousand minutes of output\\textsuperscript{4}. Moreover, some of these providers even do not provide the pay-per-use option, hence only offering subscription plans such as SalesForce\\textsuperscript{5}. In a brief, the subscription is widely accepted by customers as it is very hard for customers to predict the service usage. Thus, customers do not mind to rely on predefined subscription plans which brings the feeling that the service is pay-per-use. More details about these issues can be found in \\cite{LB09, LDBK10}.\n\n1.3.3 Price Formation\n\nPrice formation refers to how to define the price of a service. Basically, price formation may be formed in three ways: cost-based, value-based and competition-oriented \\cite{LB09}. Firstly, the cost-based price formation assumes that the price is defined based on its operational costs. These costs are represented by expenses which may include third party services, resource providers, storage providers and software licenses for instance. For instance, the Amazon DevPay \\cite{Ama12} provides an integrated billing tool which takes into account the use of Amazon EC2 instances. Thus Amazon EC2 customers can automatically define the price of the service based on the utilization of the underlying infrastructure in a cost-based fashion. Secondly, the value-based price formation depends on the demand for the service, i.e., how valuable the service is in the current market. Lastly, the price formation can be driven by the price of competitor services. The competition-oriented price formation is then useful for allowing new providers to be competitive or in order to dispute market share to other competitors.\n\nFurthermore, another aspect with regard to the price formation refers to the decision of setting the price. The price can unilaterally be defined by the service provider or it can be set in a flexible manner which includes the price into the negotiation process between customer and providers. However, most of service providers does not allow changing the service price by relying on predefined prices and accounting assessment plans.\n\n\\textsuperscript{4}Further minutes cost 0.04U\\$ per minute.\n\n\\textsuperscript{5}Except for SalesForce Data.com service which also allows customers to pay based the stored data.\n1.4 Self-Managed Systems\n\n1.4.1 Dynamic Adaptation\n\nDynamic adaptation refers to changing the behavior of a system at runtime. Adaptable capabilities are useful in unpredictable scenarios where environment changes or users needs require modifying the system behavior. For instance, resource availability should be dealt with in order to ensure that the system will be able to execute its tasks. Similarly, faults should be handled in order to ensure that the system will behave as specified. Further adaptation goals include optimization interests where the system adapts itself by aiming at improving performance or reducing resource waste for example [Bui06, UPF+08].\n\nMost approaches that offer support for conceiving self-adaptable systems separate the system functional and non-functional system concerns. Then adaptation interests are dealt with as a non-functional concern which simplifies implementing and maintaining the system as well as promoting reusability. The technologies that enable implementing self-adaptable systems in a modular fashion include Aspect-Oriented Programming, component-based design, Web Services and computational reflection. Furthermore, the adaptive behavior can be implemented either in the application-level or as a utility in the middleware-level. Further discussion about adaptation techniques can be found in [BAP05, KC03, AC03, MSKC04, CFI+09].\n\n1.4.2 Autonomic Computing\n\nAutonomic Computing [Hor01] proposes the idea of developing autonomous systems in order to ease system use and administration. Autonomous systems should then manage themselves in an autonomous fashion, inspired in the human autonomic nervous system which controls some functions as breath rate, pupil dilatation and heart rate. In [KC03], the authors propose the MAPE (Monitoring, Analysis, Planning, Execution) control loop which serves as the cornerstone of an architecture for developing self-managed systems. The MAPE control loop decomposes adaptation in four interests as explained next. The Dynaco adaptation model proposes a similar approach to the MAPE for distributed application by leveraging component-based design [BAP05, Bui06].\n\nMonitoring Monitoring is in charge of gathering information about adaptation interests. Monitoring mechanisms may rely on pull and push flows in order to either keep the system aware about monitoring metrics periodically or to allow specific information to be required.\n\nAnalysis During the analysis, it is decided whether an event about the monitored data is relevant enough for triggering an adaptation action. If so, an adaptation strategy should be generated in order to change the application behavior to achieve the targeted state.\n\nPlanning The adaptation strategy is transformed in an adaptation plan in the planning phase. The plan is a set of instructions detailedly describing the actual\nchanges to be executed by the system.\n\n**Execution** The previous plan is then executed in the execution phase. In order to execute the plan, the system execution flow is intercepted and the instructions are applied.\n\n### 1.5 Web Services\n\n#### 1.5.1 Loosely-Coupled Distributed Applications\n\nThe Service-Oriented Computing (SOC) \\[PG03, PTDL07\\] proposes a modular and loosely-coupled design for building distributed applications. SOC takes advantage of the service abstraction whose interactions are described by SLAs. Aiming at instantiating this view, the Service-Oriented Architecture (SOA) was then proposed as a representation of the SOC. The SOA describes an architecture which enables conceiving service-based applications. In a brief, SOA architecture has three layers which respectively address: (i) service discovery and binding; (ii) service composition in which services are combined in order to conceive composite services; and (iii) service management features that are mainly related to service life cycle. Moreover, the SOA has been proposed to rely on Web Services \\[W3C10\\] as a mean of integration of different applications and platforms.\n\nFrom another point of view, the SOA can be understood as a natural evolution of the component-based design \\[Szy03\\]. In \\[CH04, Yan03, PAB11\\], the authors understand components and SOA as complementary approaches: on the one hand, services are loose-coupling, dynamic and business-oriented, on the other hand, components offer an efficient development model that separates concerns and promotes re-usability. These latter properties simplify the service development. Examples of component approaches based on the SOA include the Service-Component Architecture (SCA) \\[Ope07\\], Declarative Services \\[OSG07\\] and iPOJO \\[EHL07\\]. However, both SOC and component point of views about SOA consider the utilization of Web Services for interoperability pur-\\[ose\\,^{6}\n\n#### 1.5.2 Web Services\n\nTwo architectural styles have been used to implement Web Services: one based on WS-* standards, another based on the concept of Representational State Transfer (REST). The former technology relies on the SOAP (Simple Object Access Protocol) protocol as a means for interfacing Web Services \\[W3C10\\]. SOAP leverages lower-level communication protocols such as HTTP (Hypertext Transfer Protocol) by exchanging messages formatted in XML (Extensible Markup Language) through the service descriptor represented by a WSDL (Web Service Definition Language) interface. The WSDL is an XML file which describes the service functionalities in a RPC-based fashion. In other\n\n---\n\n\\[6\\] The use of Web Services by Declarative Services and iPOJO are enabled by Distributed OSGi \\[ASF09\\].\nwords, services send requests to other services by invoking their operations, then these operations will be executed remotely and the result is sent by means of the request response. This way of building service-based application by leveraging Web Services in an RPC-like manner served as basis for several approaches which address service composition by means of BPEL orchestration or choreographies. In spite of the great advantage of not changing the way of how applications are designed, i.e., by calling operations, it is hard to manage SOAP/WS-* service compositions.\n\nIn contrast to the WS-* based architectural style, the second approach for implementing Web Services follows the REST style, which allows building service-based applications in a simpler way. Web Services based on the REST architecture are called RESTful Web Services and take advantage of the HTTP protocol as an application protocol, not only a transport protocol. In the REST architecture, services are exposed as resources identified by URIs that facilitate the referencing of services on a network of distributed servers. RESTful Web Services are accessible through the use of simple HTTP methods, e.g., GET, PUT, POST, UPDATE. In addition, RESTful Web Services take advantage of content negotiation to provide various data formats such as XML and JSON (JavaScript Object Notation,) which allow them to fit the data format according to the service needs. With respect to the service provider state, the stateless characteristics of RESTful Web Services is suitable for developing inter-domain Web Services in large-scale. On the other hand, RESTful Web Services requires that customer services understand the semantics of the data formats (media-types) which are exchanged.\n\n1.6 Grid Computing\n\n1.6.1 Overview\n\nGrid computing was firstly used to aggregate clusters from different domains for performing high-performance computing in large-scale. Following that, grids addressed the utilization of further heterogeneous and low-cost resources such as desktop computers and mobile devices. In order to manage resource access policies, grids leverage the concept of Virtual Organization (VO) to define and ensure user privileges in each set of resources. Thereby, various organizations participating on a grid can configure the grid usage to suit their local policies [Pos02]. In order to make grids transparent for users and promote interoperability, grids leverage programming abstractions based on open standards that unify the way of how grid resources are used. For instance, grid users may develop distributed applications based on abstractions as GridRPC, batch jobs and files [SNM+02, GJK+08].\n\nFigure 1.1 illustrates a common grid architecture. Firstly, according to VO policies, grid users reserve a set of resources and submit jobs through the broker. Secondly, jobs are sent to the grid scheduler which allocates jobs on resources given job resource requirements and according to a scheduling algorithm. Finally, when jobs are executed, users are informed. Moreover, distributed file systems [LS90] are widely used in grids in order to store and share data transparently.\nThe main programming abstraction for developing grid applications is the job abstraction. Jobs can either hold other jobs a parallel program or represent a sequential program as part of a set of jobs. Moreover, jobs contain meta-information which includes their software the resource requirements. By leveraging jobs, various distributed applications can be developed such as BoT (Bag of Tasks) applications [CBC+04], complex workflows [HWS+06] as well as applications that leverage the generic Master/Worker pattern.\n\n### 1.6.2 Application Programming Interface\n\nGrids offer complete Application Programming Interfaces (APIs) which allow grid users to have extensive control of grid resources. However, current grid offer different and complex APIs thus increasing the complexity of application development and maintenance. In order to ease the use of grids, to standardize the grid usage and to allow grid applications to be compliant with different grid platforms, the Simple Grid API (SAGA) [GJK+08] proposes a standard grid programming interface. SAGA addresses interoperability and complexity through simple grid programming abstractions and operations. SAGA enables grid application development by taking into account a unique interface while it enables the execution of such an application in different grids. For achieving interoperability, SAGA relies on adaptors which enable implementing backends for various grids as SSH, Globus, XtreemOS, Condor and so forth.\n\nSAGA compiled the main abstractions for developing distributed applications based on various requirements. Firstly, the file abstracts transparently over a distributed file system an usual local file system. Secondly, the data streaming abstraction eases the utilization of remote communications over sockets. Aiming at a higher-level remote communications, the RPC abstraction is also provided by SAGA whose specifications are defined based on GridRPC [SNM+02]. The task abstraction encapsulates synchronous and asynchronous operations in order to facilitate the management of distributed calls.\nFinally, the job abstraction is supported by SAGA which allows managing jobs based on statical and dynamic information sent through job callbacks. Additionally, jobs can be submitted in both interactive and batch modes.\n\nFurthermore, grid usage can also take advantage of the pilot-job abstraction. The DIRAC (Distributed Infrastructure with Remote Agent Control) [CER04 TBB+08] grid proposes pilot-jobs as an abstraction for improving resource allocation in grids. Before submitting main jobs, meta-jobs called pilot-jobs are submitted to available resources by launching an agent. This agent is responsible for calculating the resource capability of execute main-jobs and send it to the scheduler. The scheduler then matches its job queue received from grid users to available resource capabilities. Thereby, the job scheduling is distributed among the resources by relying on updated resource metrics. Moreover, further grid approaches also takes advantage of the idea of pilot-jobs as SAGA big-job [LLJ10] and Condor [Uni12].\n\n1.6.3 Grid Platforms\n\n**Globus** The Globus Toolkit [Fos06] is a grid middleware as part of the Globus Alliance. Globus Toolkit architecture relies on Web Services in order to manage the grid components. It uses the WS-Resource Framework (WSRF) [CFF+04] and wraps grid resources in order to ease the management of the middleware. Globus Toolkit transfers data through the FTP (File Transfer Protocol) protocol adapted for grids and manage data replication to improve data availability. Moreover, Globus Toolkit also provides an execution management environment for specific applications.\n\n**XtreemOS** The XtreemOS [CFJ+08] project targets providing a transparent grid execution environment as an usual operating system. Core components of the XtreemOS grid operating system are built as Linux kernel modules in user-space which makes common operating systems grid resources. Thus, the overall overhead of tasks that require detailed information about the system is decreased. Moreover, XtreemOS supports desktop computers, clusters and mobile devices. With respect to its interface, it not only provides an extensions of the SAGA interface, but it also provides a console which supports POSIX-compliant commands.\n\n**Grid5000** The Grid5000 aims at offering an integrated distributed environment where researches can deploy their prototypes in large-scale. The Grid5000 currently holds 1,594 nodes, a total of 3,064 processors and 8,700 cores over ten sites in France 7 shared among various research institutes. In order to use Grid5000, an operating system image is deployed on reserved nodes. Indeed, Grid5000 is a resource-oriented testbed and can be compared with IaaS clouds in the sense since both provide resource as abstraction for programmers. Although Grid5000 does not offer higher-level abstraction such as jobs, its extensible and flexible tools, e.g., OAR, Kadeploy, Adage, allow grid users to deploy further programming support as Globus Toolkit, XtreemOS, DIET, Nimbus, Apache Hadoop and so forth.\n\n---\n\n7Two more sites from Brazil and Luxembourg will be added to Grid5000.\nDIET DIET (Distributed Interactive Engineering Tool-box) [CD06] is a grid middleware which tackles the development of grid applications by using GridRPC [NMS+05 SNM+02]. GridRPC lies on the RPC (Remote Procedure Call) paradigm with dynamic resource scheduling in an environment composed by different administrative domains. DIET components are in charge of allocating resources when the application remotely calls computation operations through GridRPC calls.\n\nDIET is based on a hierarchical distributed scheduling design. DIET users send the operation to be computed to a DIET entry point (master agent) by means of a GridRPC call. The master agent dispatches the call to hierarchical lower-level entities called SeD (Server Daemon) which are in charge of executing the actual operation. When an SeD receives the call, it checks if it is able to respond to the call by checking dynamic information such as data availability and resource load and scores its ability. Then the SeD forwards the call to its SeD children which also calculate their ability based on the given call. All SeDs answer their upper SeDs which sort capability scores of their children and store in a list. Following that, the master agent sorts the capability lists of its SeD children in a merged list which is forwarded to the user. Finally, the user chooses which SeD is more suitable for executing the call and sends the call to the chosen SeD to be executed.\n\n1.7 Cloud Computing\n\n1.7.1 Overview\n\nCloud Computing does not have a common definition. At first, most definitions relied on the idea of outsourced service providers which deliver virtual machines on-demand in a pay-per-use accounting assessment. Later, the basic idea of outsourcing resources was extended to a larger and generic set of computing capabilities rather than virtual machines [MG11 Sch10 Beg08 VRMCL08 KTKN11 JMF09].\n\nCloud Computing targets adapting the provided services according to environment changes dynamically. This refers to the idea of elasticity which allows clouds to modify non-functional requirements not only according to demand changes, but also for consolidation purpose. In the context of IaaS clouds, elasticity may refer to either vertical elasticity, whereby virtual machines requirements are modified, or horizontal elasticity, which means changing the amount of virtual machines. For instance, an application which uses a single virtual machine may become overloaded, then it may trigger a vertical elasticity in order to accommodate the current load. On the other hand, the cloud provider may suspend, migrate or shut down some virtual machines in order to save energy consumption during low demand peak.\n\nIn spite of the advantage of acquiring outsourced and elastic services on-demand, clouds main drawbacks lies on privacy, security and dependability [Vie09]. As customer data is stored in clouds, customers do not have control on their own data anymore. This can be used for gathering useful information about cloud customer for business\n\n---\n\n8 Currently, the live migration technology enables migrating virtual machines at runtime without shutting down the virtual machine.\npurpose. Furthermore, some applications require non-trivial security requirements such as critical applications. The way of how availability is offered by cloud providers are not enough for building dependable applications. For instance, the Amazon EC2 SLA terms exclude Amazon from any availability issue caused by factors outside of Amazon’s reasonable control\\(^9\\).\n\n### 1.7.2 A Common Layered Architecture\n\nCurrently, a common cloud layered-architecture is found in the literature \\[\\text{Sch10, KTKN11, CBP}^{+10, \\text{MG11}}\\] where computing capabilities are exchanged between service entities. Figure \\[\\text{1.2}\\] illustrates this cloud architecture. The lowest layer refers to the *Infrastructure as a Service* (IaaS) which relies on the resource abstraction. The IaaS layer leverages virtualization techniques in order to deliver virtual machines as resources. These virtual resources actually are operating system images. The upper layer is called *Platform as a Service* (PaaS) which provides a developing support for building final applications. In the PaaS layer, programming tools and abstractions are offered as external services which play the role of conventional programming libraries. In the highest-level layer, the *Software as a Service* (SaaS)\\(^10\\) layer provides applications for final users.\n\n\n\n**Figure 1.2:** A common view of Cloud Computing as a layered architecture where layers interact with each other by means of services. Service requests are the primitives which enable the service to be delivered according to the SLA.\n\n### 1.7.3 Infrastructure, Platform and Software as a Service\n\n**IaaS** \nIaaS clouds rely on the virtualization technology in order to deploy virtual machine instances on top of physical resources. Virtualization allows running guest operating systems inside a host operating system. Thereby, virtual machine instances actually are operating system running on a virtual resource. The hypervisors are in charge of managing virtual machines by interacting with the physical machine operating system. Examples of current hypervisors include Xen [CS03], KVM [RH06], and VirtualBox [Ora07]. Moreover, kernel containers can also be used to manage virtual machines as a kernel built-in solution.\n\n---\n\n\\(^9\\)For the full Amazon EC2 SLA terms, see [Ama08].\n\n\\(^10\\)Also referred as *Service as a Service.*\nThe first IaaS cloud created was the Amazon EC2 \\cite{Ama06a} as a result of Amazon’s data center improvement. Amazon EC2 relies on its proprietary AMI (Amazon Machine Image) virtual machine format and its own API. Following that, open-source IaaS clouds were developed such as Nimbus, Eucalyptus, OpenStack and OpenNebula, all of them supporting the Amazon EC2 API. Moreover, cloud IaaS solutions are commonly used together with storage services, e.g., Amazon S3 \\cite{Ama06b}.\n\nAiming at standardizing IaaS cloud interfaces, the Open Grid Forum published the OCCI (Open Cloud Computing Interface) \\cite{ME11} specification. OCCI relies on the compute, storage and network abstractions in order to represent cloud IaaS resources. The \\textit{start}, \\textit{stop}, \\textit{restart} and \\textit{suspend} operations govern resources through a RESTful API. Furthermore, proprietary interfaces as Amazon EC2 also relies on these simple operations.\n\nFurthermore, IaaS clouds can be also classified as private, public and hybrid. In order to tackle privacy and security issues, IaaS clouds can be used in an intra-domain scope. This characterizes a \\textit{private cloud} whose virtual instances are managed by the organization which then takes advantage of managing virtual resources instead of physical resources. In contrast, \\textit{public} clouds consist of third parties which provide virtual machines in an outsourced manner. Lastly, clouds can also be classified as \\textit{hybrid} whose virtual machines are held by both private and public clouds. Hybrid clouds is a complementary solution for private clouds in a sense that it enables handling unpredicted resource demands in a private cloud.\n\n\\textbf{PaaS and SaaS} While the IaaS layer has been established on top of well defined interfaces \\cite{Ama06a,ME11}, there is a lack of agreement about PaaS and SaaS cloud interfaces. Despite the OCCI effective description of a cloud IaaS interface, it does not tackle neither PaaS nor SaaS cloud interfaces. Indeed, in these latter layers, a huge number of functionalities should be provided which makes it very difficult to define a simple and clean interface. For instance, the PaaS layer aims at providing services which support data base access, authentication, parallelization and domain-specific libraries as SalesForce \\cite{Sal99} and the Google Application Engine (GAE) \\cite{Goo08}. With respect to the SaaS layer, although SaaS customers needs are more customized rather than developer needs, SaaS interfaces similarly aim at providing specific features. As a consequence, the lack of uniform and standardized PaaS and SaaS interfaces implies the incompatibility of cloud providers; thus subject to vendor lock-in and integration issues.\nChapter 2\n\nRelated Work\n\nThis chapter presents some current approaches which support the development of service providers on top of distributed infrastructures. The main focus is on approaches that provide quality guarantees. In order to organize related work, three main groups were defined based on the following aspects: pricing (cf. Section 2.1), SLA management (cf. Section 2.2) and resource acquisition (cf. Section 2.3). Moreover, the SLA management aspect was divided in three subgroups which address SLA life-cycle (cf. Section 2.2.1), SLA translation (cf. Section 2.2.2), and QoS assurance (cf. Section 2.2.3).\n\nFinally, a comparison table is exposed in Section 2.4 which summarizes the main related work here presented.\n\n2.1 Pricing\n\nIn general, the solutions which address pricing aspects do not include in their SLA the penalties in case that the agreed quality is not met. Some of them [Ama06a, Goo08, Sal99, Zen10] are willing to offer service credits if a percentage of availability is not met. However, these approaches rely on a very limited and often not clear definition of SLA violation because service providers are not able to properly ensure the agreed QoS. Thereby, refunding policies would seriously compromise provider profit.\n\nIn [MFG10, MG10], Macías et al. address the maximization of IaaS cloud providers by means of resource over-provisioning and by dynamically setting the service price according to resource usage. Virtual machines are then shut down based on their usage pattern thus enabling to allocate other virtual machines. In case of resource shortage, the approach minimizes losses by considering either violating SLAs or rescinding contracts. Even though these approaches consider pricing aspects, the authors only tackles the availability QoS. Moreover, similar to Amazon EC2, these approaches only consider an SLA violation as a virtual machine that has been shut down after a fixed and significant amount of time. Furthermore, these solutions tackle the IaaS layer thereby not providing higher-level programming abstractions for building SaaS service providers.\n2.2 SLA Management\n\n2.2.1 SLA Life-Cycle\n\nThe SLA@SOI project [THK+10] proposes a hierarchical and integrated architecture for building service-based applications. The architecture is composed by three SLA managers which address business, software and infrastructure SLA managements in a layered fashion. In the highest-level, business aspects between the provider and its customers are dealt with. The following layers address software and infrastructure wrapped as services. By considering software and resources as service, the SLA@SOI architecture aims at separating service management from SLA management. However, by aiming at a generic approach for supporting arbitrary services, the architecture does not define specific realization mechanisms; it assumes that services dependencies are responsible for meeting service software and resource requirements.\n\nThe SOA4ALL project [KLH+10] aims at easing the conception of service-based applications by leveraging the SOA, Web 2.0 and Semantic Web in a context-aware environment. The SOA4ALL proposes a layered architecture which lies on a graphical user interface, an intermediate communication channel and an underlying infrastructure. Moreover, the communication channel enables third party service to be integrated. In the highest layer, business processes are conceived and then translated to BPEL (Business Process Execution Language) compositions which are executed in the infrastructure. Thereby, the SOA4ALL approach tackles service composition driven by quality aspects through comprehensive service discovery and bindings based on semantics. Nevertheless, the architecture does not specify how resources are acquired nor managed and pricing aspects are not defined. The authors only explain how further technologies might meet these needs. Moreover, actual QoS assurance mechanisms are not proposed: QoS properties are supposed to be met by proper service compositions.\n\nMacías et al. [MFG10] addresses the negotiation and provisioning of virtual machines driven by economic aspects. The architectural details of this approach is described in [MG10]. However, it does not tackle performance, relies on a relaxed definition of SLA violation based on availability as well as it does not support higher-level programming abstractions; as discussed in Section 2.1.\n\n2.2.2 SLA Translation\n\nThe authors of [KW10] model the translation of SLA based to service dependency properties; however they do not tackle how services translate their SLA to infrastructure-level configurations.\n\nIn [CIL+08], the authors profile tier applications to know the response time based. SLAs are translated by means of CPU requirements to application servers. However, this work does not provide fault-tolerant mechanisms and it does not tackle distributed applications.\n\nStantchev and Schröpfer [SS09] service replication is used in order to improve and ensure performance and fault-tolerance QoS. The authors translate QoS to infrastructure-level by means of setting the service replication degree. Nevertheless, the authors do\nnot explain how assurance mechanisms work nor how SLA and resources are managed. Furthermore, the work does not consider economic aspects such as service price, resource costs and fines owing to SLA violations.\n\nThe GridNEXT project [HKSW06] investigate how SLA objectives are translated to infrastructure configurations in order to enable high-performance computing service providers to meet the agreed QoS. The translation process relies on a knowledge database previously filled. However, the architecture remains conceptual thus not providing enough information about how to implement actual QoS assurance mechanisms. The authors assume that the infrastructure should support QoS assurance mechanisms.\n\nMoreover, further work about SLA translation can be found in [LTH09].\n\n2.2.3 QoS Assurance\n\nThe MapReduce programming model [DG10, DG08] addresses data processing in large scale. It leverages the concept of map and reduce primitives of functional languages and considers a data shared space such as a distributed file system. Developers who take advantage of MapReduce should implement the application-specific operations map and reduce and provide information about the location of input and output data. The MapReduce Library [DG08] handles worker failures by periodically checking if workers are reachable. If a worker fails, their task are re-scheduled to be executed on another idle worker. Moreover, the MapReduce Library relies on a replicating scheme for the remaining jobs since latest jobs are more susceptible to fail. In order to improve performance, the MapReduce library also relies on replication of remaining jobs by statically configuring the number of map and reduce operations as well as the number of workers. Indeed, the replication of remaining jobs is a solution for improving performance and fault-tolerance qualities. However, more efficient fault-tolerant techniques can be conceived based on dynamic job metrics as job elapsed time and job state. Thereby, malfunctioning jobs can be earlier identified thus triggering repairing actions at this very moment instead of postponing them to the end of the computation. Moreover, MapReduce does not address a complete PaaS solution, i.e., it misses further supports for dealing with the service negotiation and provisioning. Therefore, MapReduce is understood to be an intermediate-level tool that ease the development of PaaS solutions which aim at data-processing in large-scale, while further service higher-level aspects are not tackled.\n\nClouds resources have been used to improve performance of distributed applications. In [LZ10], the authors propose the $RC^2$ job scheduling algorithm for grids which relies on rescheduling previously queued jobs. The $RC^2$ algorithm replaces grid resources by cloud resources if a grid resource is identified as delaying job executions. Then, the jobs previously assigned to the grid resource are rescheduled to a cloud resource. The argument used by the authors of the $RC^2$ algorithm is that cloud resources are more reliable rather than grid resources. In [DFL11], the authors introduce the SpeQuloS framework which aims at providing QoS to desktop grids. The framework adds further resources from clouds in order to decrease the application response time. Moreover, SpeQuloS relies on a credit service which computes the costs of using extra resources from clouds.\nLastly, the SAGA big-job instrumentally used clouds to ensure deadline \\cite{LLJ10}. The main drawbacks of these solutions is that they only tackle performance aspects and they do not tackle pricing aspects completely.\n\nThe GridWay \\cite{Hue04} project proposes an adaptive framework for job execution on grids. Tools for monitoring and analyzing jobs are added to the Globus middleware in order to check if job performance degrades. If so, the framework reschedules the job in order to improve its performance. However, the scheduling policy does not consider further queued jobs belonged to other applications. This issue can be improved by considering distributed scheduling techniques such as work stealing \\cite{TGT+10}. Moreover, this work does not support neither SLA management functions nor pricing aspects and exposes low-level resource details to applications.\n\nIn \\cite{KP11b}, the authors propose the CooRM architecture for supporting complex high-performance distributed applications with dynamic resource requirements. In CooRM, job scheduling is distributed and employed at the application level thus the central scheduler is in charge of resource discovery and scheduling appliance while applications are in charge of selecting the available resources. In order to improve performance, the authors propose to not delay application executions by prioritizing previously submitted applications based on their estimated execution time. Furthermore, in \\cite{KP11a}, the authors explain how CooRM tackle resource wastage. Nevertheless, fault-tolerance, pricing and SLA management are not addressed.\n\nIn \\cite{Jos08}, the authors propose SLAWs as a flexible architecture for enforcing SLAs. Services are decoupled in order to address non-functional service concerns wrapped in a separated service. However, specific SLA enforcement mechanisms are not described.\n\nIn \\cite{Per05}, the author proposes a hierarchical SLA management for SLA enforcement. The approach relies on adaptation policies guided by high-level objectives which adjust network traffic based on current QoS values. Nevertheless, this work is limited to low-level network traffic control thus not offering higher-level support for services which builds on distributed infrastructures based on the job abstraction.\n\nZencoder \\cite{Zen10} uses Amazon EC2 virtual machines to encode video and audios. In \\cite{Clo11}, Zencoder showed to perform faster than some competitors. However, Zencoder does not publicly explains how the performance is improved and does not include QoS in its public SLA description.\n\n### 2.3 Resource Acquisition\n\nPilot-jobs \\cite{TBB+08, CGP+10} provides a solution for decoupling resource acquisition from resource utilization in a grid environment. In order to also take advantage of IaaS cloud resources, SAGA \\cite{GJK+05} leverages the idea of pilot-job by introducing the big-job \\cite{LLJ10} abstraction which acquires cloud resources, deploys virtual machines and submits grid jobs to the booked resources. With regard to fault tolerance, SAGA big-job replaces pilot-jobs which fail to acquire resources from clouds. However, SAGA big-job assumes that it is the developer charge to customize virtual machines and defining their requirements. Moreover, SAGA big-job does not consider resource costs\nin its pricing model and provide no means for increasing the provider profit.\n\nIn \\cite{KTKN11}, Kecskemeti et al. propose an automatic approach for acquiring and deploying virtual machines in order to aid service developers and decrease the deployment time. The main idea lies on automatic mechanisms which split virtual images and replicate its parts on various repositories. Moreover, the authors complement this approach in \\cite{KMB+12} by addressing the automatic management of virtual appliances in different clouds. Nevertheless, the drawback of these solutions is that service developers have to directly deal with the lower-level resource abstraction as well as they still have to manage the life-cycle of virtual machines. In addition, the authors consider virtual machine instantiation driven by customer requests in contrast to instantiating virtual machines driven by contract establishments.\n\nGenaud and Gossa \\cite{GG11} investigate various policies for acquiring and releasing resources for grid batch jobs. The idea is to fit job completion time and virtual machine booking in a pay-per-use pricing accounted hourly. Thus, the authors propose policies for meeting the trade-off between infrastructure costs and performance. However, the authors fail in addressing SLA management functionalities and performance is not ensured.\n\n### 2.4 Summary of Related Work\n\n#### 2.4.1 Comparison Table\n\nThe Table \\ref{table:related_work} depicts the comparison of this thesis and main work previously identified in Section \\ref{sec:related_work}. The comparing criteria emphasizes the main features for enabling service execution management as explained next.\n\n- **Layer**: Refers to the cloud architecture layer tackled by the approach (cf. Section \\ref{sec:cloud_architecture}). Approaches which provide resources as abstractions are classified as infrastructure-level (IaaS) while approaches which provide further higher-level abstractions such as jobs are considered to tackle the platform-level (PaaS).\n\n- **Pricing**: If set *yes*, means that the approach addresses pricing aspects, e.g., price, costs and fines. Otherwise, *no* is used.\n\n- **SLA Life-Cycle**: This attributed defines whether the approach offer SLA functionalities which enable addressing the SLA life-cycle. *Yes* means that the approach covers the SLA life-cycle while *no* means the contrary.\n\n- **SLA Translation**: Refers to translation of SLA high-level properties or QoS metrics to infrastructure-level configuration. If the approach describes how the translation is employed, it is classified as *yes*, otherwise *no* is used.\n\n- **QoS Aspect**: Expresses which kind of QoS is tackled by the approach. The referred QoS aspects are performance (*Perf.*) and fault tolerance (*FT*). \n\n\\footnote{Although Amazon provides the Amazon Elastic MapReduce \\cite{Amazon09}, MapReduce \\cite{DG08} refers to the Google MapReduce programming model.}\n\n\\begin{table}[h]\n\\centering\n\\begin{tabular}{|l|l|l|l|l|}\n\\hline\nLayer & Refers to the cloud architecture layer tackled by the approach (cf. Section \\ref{sec:cloud_architecture}). Approaches which provide resources as abstractions are classified as infrastructure-level (IaaS) while approaches which provide further higher-level abstractions such as jobs are considered to tackle the platform-level (PaaS). & Pricing & If set *yes*, means that the approach addresses pricing aspects, e.g., price, costs and fines. Otherwise, *no* is used. & SLA Life-Cycle & This attributed defines whether the approach offer SLA functionalities which enable addressing the SLA life-cycle. *Yes* means that the approach covers the SLA life-cycle while *no* means the contrary. & SLA Translation & Refers to translation of SLA high-level properties or QoS metrics to infrastructure-level configuration. If the approach describes how the translation is employed, it is classified as *yes*, otherwise *no* is used. & QoS Aspect & Expresses which kind of QoS is tackled by the approach. The referred QoS aspects are performance (*Perf.*) and fault tolerance (*FT*).\n\\hline\n\\end{tabular}\n\\end{table}\nQoS Assurance If the approach provides QoS assurance mechanisms, *yes* is used, else it is classified as *no*.\n\nResource Acquisition Refers to whether the approach addresses resource acquisition; it may refer to either virtual or physical resources. If so, the approach is classified as *yes*, otherwise *no* is applied.\n\n<table>\n<thead>\n<tr>\n<th>Approach</th>\n<th>Layer</th>\n<th>Pricing</th>\n<th>SLA Life-Cycle</th>\n<th>SLA Translation</th>\n<th>QoS Aspect</th>\n<th>QoS Assurance</th>\n<th>Resource Acquisition</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MapReduce</td>\n<td>PaaS</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n<td>Perf., FT</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>SOA4ALL[KLH+10]</td>\n<td>PaaS</td>\n<td>No</td>\n<td>Yes</td>\n<td>No</td>\n<td>Perf., FT</td>\n<td>No</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Macías et al. [MFG+10]</td>\n<td>IaaS</td>\n<td>Yes</td>\n<td>Yes</td>\n<td>No</td>\n<td>FT</td>\n<td>No</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Keeskemetti et al. [KTKN11]</td>\n<td>IaaS</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n<td>Perf., FT</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>GridWay [Hue04]</td>\n<td>PaaS</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n<td>Perf., FT</td>\n<td>Yes</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>CosRM [KP11b]</td>\n<td>IaaS</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n<td>Perf.</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>SAGA, Big-Job [LLJ+10]</td>\n<td>PaaS, IaaS</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n<td>Perf.</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>SLA@SOI[THK+10]</td>\n<td>PaaS, IaaS</td>\n<td>No</td>\n<td>Yes</td>\n<td>No</td>\n<td>Perf., FT</td>\n<td>NA</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>GridNEXT[HKSW06]</td>\n<td>PaaS</td>\n<td>No</td>\n<td>No</td>\n<td>Yes</td>\n<td>Perf.</td>\n<td>No</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>Stantchev and Schröper [SS09]</td>\n<td>PaaS</td>\n<td>No</td>\n<td>No</td>\n<td>Yes</td>\n<td>Perf., FT</td>\n<td>No</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Genaud and Gossa [GG11]</td>\n<td>PaaS</td>\n<td>Yes</td>\n<td>No</td>\n<td>No</td>\n<td>Perf.</td>\n<td>No</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>This thesis</td>\n<td>PaaS</td>\n<td>Yes</td>\n<td>Yes</td>\n<td>Yes</td>\n<td>Perf., FT</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.1: Comparison of main related work according to various criteria.\n\n2.4.2 The Gap\n\nThe general observation is that approaches that focus on the infrastructure-level provide actual mechanisms which ensure quality aspects. However, these approaches do not consider higher-level aspects as pricing and SLA management. On the contrary, approaches that address SLA aspects do not specify how QoS properties can be enforced since they focus on high-level SLA management tasks.\n\nAnother observation refers to the pricing criterion. Although most approaches enable applying pricing models, they neither define the pricing model nor describe it.\nIn contrast, commercial clouds provide fully information about pricing. Nevertheless, it is not worthy to put these approaches in Table 2.1 because they rely on proprietary solutions which do not described how further criteria are addressed.\n\nWith regard to QoS aspect, both performance and fault tolerance are satisfactorily addressed. However, most of solutions rely either on experimented QoS metrics rather than accurate metrics. Regarding resource acquisition, most approaches solve the problem of acquiring resources. Nevertheless, these approaches often exposes resource-level details for final customers.\n\n2.4.3 Filling the Gap\n\nThis thesis addresses the required features to build a complete solution for service execution management. The last row of the Table 2.1 shows this thesis addressing all the criteria as a solution in the platform layer. Moreover, it is important to remember that the previous criteria were chosen by aiming at enabling service execution management on top of distributed infrastructures. A summary of how this thesis fills the gap is exposed next.\n\n- **Pricing** This thesis relies on a pricing model whose price formation is based on provider’s costs in a pay-per-use accounting assessment. Penalties for SLA violations are also taken into account whose penalties are computed as monetary terms. Moreover, this thesis prioritizes customers which positively contributes for increasing the provider profit.\n\n- **SLA Life-Cycle** This thesis designs and implements a complete set of SLA management functions which include service negotiation, instantiation, provisioning, and termination. Moreover, this thesis defines how pricing aspects are integrated into its solution.\n\n- **SLA Translation** Based on service profiling, this thesis translates performance and fault-tolerance QoS metrics to lower-level system configurations in order to configure the mechanisms responsible for ensuring QoS.\n\n- **QoS Assurance** This thesis provides mechanisms for ensuring both performance and fault-tolerance qualities for distributed services. These mechanisms rely on resource requirements and dynamic job metrics which enable immediately reacting to job malfunctions.\n\n- **Resource Acquisition** This thesis deals with resource acquisition by transparently acquiring, deploying and releasing resources thus freeing service developers from these time-consuming and error-prone tasks. Moreover, by tackling the whole SLA life-cycle, this thesis assumes that contract negotiation triggers resource acquisition in contrast to current approaches that acquire resources when requests are sent.\nRelated Work\nPart II\n\nConception\nChapter 3\n\nSLA-driven Service Execution Management\n\nThe contribution of this thesis is in the context of service providers built on top of distributed infrastructures such as grid and clouds. It provides an autonomous support for service execution management aiming at increasing provider profit. This challenge is achieved by reducing costs on infrastructure usage, preventing SLA violations and prioritizing more profitable customers. In order to address this problem, this thesis translates high-level quality aspects to system configuration to ensure the proper service execution by acquiring resources on-demand. Moreover, service under-provisioning is also taken into account as a feature to increase provider profit.\n\nThe reminder of this chapter is organized as follows. Section 3.1 discusses definitions, assumptions and life-cycles. The main goal of this thesis is explained in Section 3.2. The Section 3.3 explains how contract templates are created. The following Sections 3.4 and 3.5 address service execution management aspects related to QoS assurance and resource acquisition and allocation respectively.\n\n3.1 Underlying Concepts\n\nThis thesis relies on a terminology which is used by the research community but in different contexts. In order to avoid ambiguity during the lecture of this manuscript, the Section 3.1.1 introduces the definitions and assumptions used by this thesis. Following that, the Section 3.1.2 introduces the variables useful for understanding this text. Finally, the life-cycles of contracts, requests and jobs are defined in Section 3.1.3.\n\n3.1.1 Definitions and Assumptions\n\nThis thesis relies on the following definitions and assumptions:\n\nDefinition 3.1 An electronic service – or just service – is a high-level abstraction that represents a way of delivering a software or a computing capability as a part of a\nsoftware. The contract terms of a service is represented by a Service-Level Agreement (SLA) which is established between the service customer and the service provider.\n\n**Definition 3.2** An electronic contract – or just contract – describes the contractual terms of a service between the service customer and the service provider. The contract is represented by a Service-Level Agreement (SLA).\n\n**Definition 3.3** A job is an intermediate-level software abstraction which is useful for building services and handling customer requests.\n\n**Definition 3.4** A request is the means of how customers use the service. Customers send requests to the service provider which should treat it in accordance to the SLA.\n\n**Assumption 3.1** Resources are acquired by the service provider from a resource provider in an outsourcing fashion.\n\n**Assumption 3.2** Jobs may present misbehaviors which means to fail or to be delayed. Moreover, a job misbehavior represents a fault for the service provider.\n\n### 3.1.2 Variables\n\nJobs, contracts and requests are represented by variables as explained next.\n\n- **J** is the set of all jobs where:\n - \\( J_i^n \\) is the \\( i \\)-th job which holds \\( n \\) replacements\n - \\( J_{q_k} \\) set of jobs belonged to the \\( k \\)-th request \\( q_k \\)\n - \\( J^F \\) set of FAILED jobs\n - \\( J^R \\) set of RUNNING jobs\n - \\( J^C \\) set of CANCELED jobs\n- **Q** is the set of all requests where:\n - \\( Q^T \\) set of BEING_TREATED requests\n - \\( q_k \\) is the \\( k \\)-th request\n- **C** is the set of all contracts where:\n - \\( c_i \\) is the \\( i \\)-th contract.\n\n### 3.1.3 Life-Cycles: Contract, Request and Job\n\nThe management of service execution is driven by the states of contracts, requests and jobs. The life-cycle of these abstractions are presented next.\nContract Life-Cycle The contract life-cycle aims at instantiating the SLA life-cycle which comprises the definition, establishment and enactment phases (cf. Section 1.1.2). The Contract life-cycle is depicted by Figure 3.1 which also illustrates the SLA life-cycle phases.\n\nThe contract life-cycle states are described as follows.\n\nNEW A just-arrived contract proposal implies the creation of a contract whose state is NEW.\n\nREJECTED If the service provider decides to not accept the contract proposal, the contract state is set to REJECTED.\n\nESTABLISHED If the service provider accepts the contract proposal, the contract state is set to ESTABLISHED.\n\nCONCLUDED If the contract reaches its duration, the contract is successfully completed and contract state is set to CONCLUDED.\n\nRESCINDED The contract may be rescinded by one of the parties thus the contract state is set to RESCINDED.\n\nRequest Life-Cycle The request life-cycle holds the following states as depicted by Figure 3.2.\n\nNEW A just-arrived request implies the creation of a request whose state is NEW.\n\nBEING_TREATED If the request can be treated, its state is set to BEING_TREATED thus dispatching the request for treatment.\n\nABORTED Requests may be aborted either just after its creation or during its treatment. For both situations, the request state is set to ABORTED.\n**TREATED** If the request is successfully treated, its state is set to TREATED.\n\n[Diagram of request life-cycle]\n\n**Job Life-Cycle** The job life-cycle is based on the SAGA [GJK+08] job state model as depicted Figure 3.3. The job life-cycle holds the states described next.\n\n[Diagram of job life-cycle]\n\n**NEW** A job has the NEW state when it is instantiated.\n\n**RUNNING** When the job is submitted through to be executed, its state is set to RUNNING.\n\n**MIGRATING** Jobs can be under a migration operation which migrates a job to another resource. This implies changing the job state to MIGRATING.\n**Profit as a Goal**\n\n**SUSPENDED** During job execution, jobs can be suspended then their state are changed to SUSPENDED.\n\n**FAILED** If the job fails, it gets the final state FAILED.\n\n**DONE** If the job successfully finishes, it gets the final state DONE.\n\n**CANCELED** The job execution may be interrupted; thus the job gets the final state CANCELED.\n\n### 3.2 Profit as a Goal\n\nA common challenge in the Service-Centric Paradigm (see Chapter 1) is to manage the execution of services. Service execution may still include distributed infrastructures which brings complexity to service execution management. Additionally, service execution should be guided by high-level guidelines defined by SLAs while addressing to increase the provider profit. Dealing with service execution management by taking into account these issues is hard and requires significant effort from service developers and administrators.\n\nThe main goal of this thesis is twofold: **to provide an autonomous service execution management while aiming at increasing the provider profit.** In order to achieve this goal, this thesis is inspired by autonomous systems (cf. Section 1.4) which are guided by high-level guidelines. Hence it proposes a self-managed support for service providers whose highest-level guideline is to increase their profit. Moreover, the means for increasing the provider profit are based on heuristics owing to the high cost optimal solutions.\n\nIn order to let clear the objective of this thesis, service execution is defined as follows.\n\n**Definition 3.5** *Service execution is a set of actions which enables the service provider to address the contract life-cycle thus delivering the service in accordance to its agreed terms.*\n\nThe set of actions used by Definition 3.5 involves interactions between the service customer and provider as well as further interactions between the service provider and other entities related to the underlying infrastructure. These actions are organized in four groups as following described:\n\n**Negotiation** Enables the negotiation of contracts represented by the SLA which holds details as the description, terms, penalties, qualities and so forth.\n\n**Instantiation** Enables instantiating the service on the underlying infrastructure based on contract resource requirements.\n\n**Provision** Enables delivering the actual service by means of responding to customer requests in agreement to quality specifications.\n**Termination** Enables terminating the service instance.\n\nThis thesis addresses these four aforementioned actions by means of *an autonomous support for service execution management*. In order to deal with the goal of increasing the service provider profit, this thesis enhances the previous actions with further complementary actions that address economic aspects. These complementary actions are described next.\n\n**Reducing infrastructure costs** Resource acquisition relies on under-provisioning as means for reducing costs on infrastructure. Moreover, resources are acquired and released according to contract durations.\n\n**Preventing SLA violations** Request treatment relies on fault-tolerant and performance QoS assurance mechanisms. These mechanisms are guided by QoS metrics in order to meet the agreed SLA.\n\n**Rescinding contracts** If the infrastructure cannot provide more resources, the provider may rescind on-going contracts if such an action implies profit augmentation.\n\nIn a brief, Figure 3.4 illustrates the actions that enable to address the service execution according to Definition 3.5. The latter complementary actions precisely aim at economic aspects by positively contributing to increase the provider profit. Ultimately, by preventing SLA violations on top of QoS assurance mechanisms is also useful for improving the service provider reputation. However, reputation is beyond the scope of this thesis which focus on increasing the service provider by the previously mentioned means.\n\n\n\n*Figure 3.4: Actions that address the contract life-cycle along with complementary actions which aim at increasing the provider profit.*\n\n### 3.3 Creation of Contract Templates\n\nIn order to enable the negotiation between service provider and customers, this thesis leverages contract templates. It assumes that the service provider provides contract\ntemplates which are chosen by customers in order to initiate the negotiation process. This section then explains how contract templates are created. In Section 3.3.1 labels are used to customize contract templates based on their QoS metrics. Following that, Section 3.3.2 explains how QoS metrics are translated to system configurations which are used to configure QoS assurance mechanisms. Finally, economic aspects about contract templates are exposed in Section 3.3.3.\n\n### 3.3.1 Contract Template Labels\n\nThis thesis relies on a simple negotiation protocol: customers choose a contract template, set its time interval and propose it to the service provider. If the provider agrees on the contract proposal, a contract is established. Otherwise, the contract proposal is rejected. In order to realize such a protocol, this thesis relies on contract templates whose QoS metrics are predefined by the service provider. Specifically, contract templates are customized based on QoS metrics related to performance and fault-tolerant aspects as explained next.\n\n**Response Time** Means the maximum amount of time that a request treatment can take.\n\n**Reliability** Refers to a degree of dependability.\n\nIn order to facilitate the identification of contract templates, this thesis names contract templates with labels which emphasize their main quality. The main quality of a contract template is defined based on the trade-off between performance and fault-tolerance (cf. Section 1.2.3). Based on this trade-off, labels are defined by combining different values of response time and availability QoS metrics. Moreover, QoS metrics values are expressed by the following high-level constraints: strong, medium, weak [RFCRJ04]. The contract templates, their labels and QoS metrics constraints are stored in the **QoS table**. The QoS table is depicted by Table 3.1 which presents four contract templates whose labels are fast, safe, classic and standard. As a result, the service provider is able to support differentiated contract templates which are easily identified by labels.\n\n<table>\n<thead>\n<tr>\n<th>QoS Aspects</th>\n<th>QoS Metrics</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Response Time</td>\n<td>Performance</td>\n</tr>\n<tr>\n<td>Fast</td>\n<td>strong</td>\n</tr>\n<tr>\n<td>Safe</td>\n<td>weak</td>\n</tr>\n<tr>\n<td>Classic</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Standard</td>\n<td>weak</td>\n</tr>\n</tbody>\n</table>\n\nTable 3.1: The QoS table stores information about contract templates and their respective QoS metrics constraints. Labels are used to name the contract templates which are customized based on the trade-off between performance and fault tolerance.\n3.3.2 QoS Translation\n\nIn order to build mechanisms that actually ensure the quality properties, QoS metrics should be translated to low-level means understandable by the service execution environment. Therefore, QoS translation means to translate QoS metrics constraint to the right configurations which enable the system to deliver such QoS metrics constraint. The QoS translation is represented by the generic function $\\tau$ as depicted Equation 3.1 where $qos$ means a QoS metrics constraint and $sys\\_config$ means a system configuration. Inversely, it is possible to know which QoS metrics constraint a minimal system configuration is able to meet as depicted the generic function $\\tau'$ in Equation 3.2. Thus $\\tau'$ represents the interpretation of a minimal system configuration to which QoS metrics constraint it is able to ensure.\n\n$$\\tau(qos) = sys\\_config$$\n\n(3.1)\n\n$$\\tau'(sys\\_config) = qos$$\n\n(3.2)\n\nThis thesis designs QoS assurance mechanisms that ensure response time and reliability (cf. Section 3.4). Response time is ensured by acquiring resources and instantiating the service provider based on the right resource requirements. On the other hand, reliability is ensured by replacing failed and delayed jobs during request treatment. Thereby, the low-level configuration required by the QoS assurance mechanisms are resource requirements and job replacement thresholds. In order to configure the QoS assurance mechanisms, the function $\\tau$ (cf. Equation 3.1) is used based on the QoS metrics constraints described in the QoS table (cf. Table 3.1 in Section 3.3.1). Thus the Equations 3.3 and 3.4 represent the translation of the QoS metrics response time and reliability respectively; where $constraint \\in \\{strong, medium, weak\\}$ and $failure\\_th\\_constraint, delay\\_th\\_constraint$ are the replacement thresholds.\n\n$$\\tau(resp\\_time\\_constraint) = res\\_req\\_constraint$$\n\n(3.3)\n\n$$\\tau(reliability\\_constraint) = (failure\\_th\\_constraint, delay\\_th\\_constraint)$$\n\n(3.4)\n\nThe previous translation function $\\tau$ is used to quantify a given QoS metrics constraint. This thesis considers different methods for quantifying reliability and response time. Reliability is quantified by defining the failure and delay thresholds statically. On the other hand, response time is quantified by profiling the service provider with various resource requirements. During the profiling, the actual response time and the job execution time metrics are gathered. These metrics are following described.\n\nactual\\_resp\\_time$_{q_k}$ Actual Response Time Means the total amount of time to treat a request $q_k$.\n\n---\n\n1Minimal system configuration is preferred in order to discard further configurations which achieve the same QoS metrics constraint by implying a greater operational cost.\n**exec_time}_{ji}** Job Execution Time Means the total amount of time to execute a job \\( ji \\) belonged to request \\( qk \\).\n\nAs the fault-tolerance QoS assurance mechanism adds operational overhead to the request treatment, both profiling metrics are used to calculate the response time QoS metrics as depicts Equation 3.5. Thereby, response time constraints (i.e., strong, medium, weak) are represented by \\( resp\\_time \\) whose whose translation is the resource requirements used during the profiling of \\( resp\\_time \\).\n\n\\[\nresp\\_time = actual\\_resp\\_time_{q_k} + failure\\_fh\\cdot exec\\_time_{ji} + delay\\_fh\\cdot exec\\_time_{ji} (3.5)\n\\]\n\n### 3.3.3 Pricing\n\nThis section gives details about how the price of the service is formed, how payments are realized and further aspects about the pricing model used by this thesis. In order to define the service price and assesses the accounting, the operational costs are used in a pay-per-use fashion. In addition, fines for aborting requests and rescinding contracts are defined and considered when calculating the net general profit of the service provider.\n\n**Price Formation** This thesis defines the service price in a cost-based manner, i.e., the service price is defined based on its operational costs (cf. Section 1.3.3). Thus the profit actually means how much the provider wants to earn from the given contract. The Equation 3.6 defines the formation of the price \\( \\rho \\) for a contract proposal whose label is \\( l \\) and duration is \\( t \\). Hence the price is defined as a function of its expenses \\( \\epsilon \\) plus its targeted profit \\( \\Pi \\).\n\n\\[\n\\rho(l,t) = \\epsilon(l,t) + \\Pi(l,t) (3.6)\n\\]\n\nMoreover, because the price fluctuates according to its expenses, setting the price as a function of the expenses becomes interesting since it enables guaranteeing the targeted profit margin. In addition, the resource acquisition approach proposed by this thesis acquires resources according to customers demand (cf. Section 3.5). Thus, the cost-based price positively influences the provider profit because operational costs only exist if contracts are established.\n\n**Accounting Assessment** This thesis leverages the pay-per-use accounting assessment by charging the customer according to the contract duration given a contract template label. The time dimension is used in order to keep the approach generic as time is a common metric for most type of services. Although further specific metrics such as number of requests, concurrent usage and key performance indicators are not considered, they can perfectly be taken into account when leveraging the approach proposed by this thesis. Additionally, the pay-per-use is chosen owing to the possibility of customizing it as a subscription plan (cf. Section 1.3.2), thus covering both accounting assessments.\nFines In order to define the fines, this thesis relies on the following assumption.\n\nAssumption 3.3 Penalties owing to SLA violations are payed by means of monetary terms.\n\nThe straight advantage of Assumption 3.3 is that it allows the service provider to positively distinguish itself from its competitors which compute fine payments based on service credits (cf. Section 2.1). Because service execution depends on dynamic factors both from the environment and the service behavior itself, it is very hard to ensure any quality of service in such circumstances. This scenario does not encourage service providers to ensure QoS mainly when the performance aspect is addressed. However, the conception of novel approaches encourages or even requires novel metrics. As this thesis does conceive QoS assurance mechanisms, it enables the service provider to pay fines in currency without compromising its profit.\n\nTwo types of fines are defined as following described.\n\nRequest Abortion Fine $\\psi$: refers to the fine that should be payed owing to non-treatment of a request. This penalty should be then applied for requests that reach the state $\\text{ABORTED}$.\n\nContract Rescission Fine $\\Psi$: refers to the fine that should be payed in case of contract rescission, i.e., contracts that reach the state $\\text{RESCINDED}$.\n\nProfit The price of the contract and the fines are used to calculate the net general profit of the service provider. Basically, it is used Equation 3.6 to deduce that $\\Pi(l,t) = \\rho(l,t) - \\epsilon(l,t)$ and then the fines are taken into account. Thus the Equation 3.7 defines $P$ as the net general profit of the service provider during the time interval $[t,t']$ for each contract $c_i$ the service provider held in $[t,t']$. In Equation 3.7, $\\rho_i$ represents the price of $c_i$, $\\epsilon_i$ represents the expense of $c_i$, $\\Psi_i$ represents the contract rescission fine if the contract was rescinded by the provider, $\\Psi'_i$ represents the contract rescission fine if the contract was rescinded by the customer, and $\\psi_{i,j}$ represents the request abortion fine of the $j$-th request fine of $c_i$.\n\n$$P_{[t,t']} = \\sum_{i=0}^{n} \\rho_i - \\sum_{i=0}^{n} \\epsilon_i - \\sum_{i=0}^{n} \\Psi_i + \\sum_{i=0}^{n} \\Psi'_i - \\sum_{i=0}^{n} \\sum_{j=0}^{m} \\psi_{i,j}$$ (3.7)\n\n3.4 QoS Assurance\n\nIn order to enable service instantiation and the provision, this thesis relies on underlying mechanisms which deal with QoS assurance. Indeed, preventing SLA violations minimizes penalties. If requests are not treated successfully, fines are payed to customers which contributes to decrease provider profit (cf. Equation 3.7). In order to prevent this situation, this thesis proposes QoS assurance mechanisms which handle performance and fault-tolerance in order to ensure that service provisioning will comply to the agreed SLA. On the one hand, performance response time QoS is ensured...\nby executing requests with the right resource requirements that are able to achieve\nthe targeted performance. On the other hand, fault-tolerance qualities are ensured by\nreacting to job misbehaviors which include job failures and delays. Both performance\nand fault-tolerant QoS assurance mechanisms are explained in Sections 3.4.1 and 3.4.2\nrespectively.\n\n3.4.1 Performance\n\nThe goal of the performance QoS assurance mechanism is to ensure that the service\ninstance is configured to meet a given response time. Therefore, performance is guar-\nanteed by properly configuring the service instance. As instance configuration means\nresource requirements, the response time is translated to resource requirements. Then,\nthe service instance treats customer requests based on the right resource requirements\nwhich meet the agree response time. Thereby, performance goals are achieved through\nservice instance configuration at runtime.\n\nThe instance configuration can be done when the service is instantiated or each\ntime a request is sent to this instance. The former way is more interesting for service\ninstances which are based on contracts that do not have their QoS changed during the\nservice provisioning. On the other hand, configuring the service instance each time it\nreceives a request allows changing contract QoS during service provisioning. However\nthis adds unnecessary data overhead to request data as well as it requires configuring\nthe service instance for each request the instance receives. Therefore, this thesis relies\non configuring the service instance at its deployment time since no change on QoS is\nconsidered during service provisioning.\n\nThe Figure 3.5 depicts the configuration of a service instance at deploy-\nment time. When a customer proposes a contract, the service provider translates the QoS metrics\nto its respective resource requirements based on information stored in the QoS table\n(cf. Equation 3.3 in Section 3.3.2). Then the service provider acquires resources from\nthe infrastructure according to the previous resource requirements. These requirements\nare also used by the service provider to configure and deploy a service instance for sup-\nporting this customer requests. When the service instance is operational, the customer\ncan send requests which are forwarded to the right service instance. Thus, requests are\nthen treated by the service instance according to the resource requirements to which\nthe service instance is configured.\n\n3.4.2 Fault Tolerance\n\nThis thesis considers that system faults mean job misbehaviors while system failures\nmean request abortions. This section introduces two mechanisms which aim at over-\ncoming job misbehaviors in order prevent requests to be aborted. In this context, job\nmisbehaviors are job failures or job delays as explained next.\n\nJob Failure A job failure is a crash fault of the job process or one of the job processes\nin case of multi-process jobs. This crash may occur due to a non-successful I/O\noperation for instance.\nJob Delay A job delay is identified when the job elapsed time $\\text{elapsed\\_time}_{ji}$ exceeds its expected execution time $\\text{exec\\_time}_{ji}$. This situation may mean that either the job is correct and will finish eventually or the job is failed and will never finish owing to a software malfunction for instance. This thesis discards the former assumption and assumes that if a job is delayed, then it is failed. This pessimist choice is assumed since it is not possible to differentiate a slow process from a faulty process. Moreover, since the service provider relies on a time-constraint request treatment, it is more suitable to let it assume that a delayed job is failed for performance purpose. The drawback of this assumption is that it does not take advantage of delayed jobs that are up to finish. However, it can be easily circumvented by increasing the value of $\\text{exec\\_time}_{ji}$ for instance.\n\nFault-Tolerance Algorithms This thesis proposes the Algorithms 1 and 2 which replace failed and delayed jobs respectively. Both algorithms rely on job dynamic metrics by reacting to events that inform about job failures and delays. The variables used by these algorithms are previously explained in Section 3.1.2. Moreover, the variable $\\text{adapt\\_th}_{ji}$ represents the adaptation threshold, i.e., the maximum time allowed\nuntil when an adaptation action can be triggered. The $\\text{adapt}_{th_j_i}$ is then calculated by considering the profiled job execution as time the following equation:\n\n$$\n\\text{adapt}_{th_j_i} = \\text{resp}_{time_{q_k}} - \\text{exec}_{time_{j_i}}\n$$\n\n\\textbf{Algorithm 1} Job Failure Tolerance\n\n\\begin{itemize}\n\\item \\textbf{Require: } $j^n_i \\in J_{q_k} \\land j^n_i \\in J^F$\n\\item \\textbf{Ensure: } $j^{n+1}_i \\in J_{q_k} \\land j^{n+1}_i \\in J^R$\n\\item 1: \\textbf{if} $\\text{elapsed}_{time_{q_k}} < \\text{adapt}_{th_{j_i}}$ \\textbf{and} $n \\leq \\text{failure}_{th_{j_i}}$ \\textbf{then}\n\\item 2: \\hspace{1em} $n \\leftarrow n + 1$\n\\item 3: \\hspace{1em} create and run $j^n_i$\n\\item 4: \\textbf{else}\n\\item 5: \\hspace{1em} abort $q_k, j^n_i \\in J_{q_k}$\n\\item 6: \\textbf{end if}\n\\end{itemize}\n\n\\textbf{Algorithm 2} Job Delay Tolerance\n\n\\begin{itemize}\n\\item \\textbf{Require: } $j^n_i \\in J_{q_k} \\land j^n_i$ is delayed\n\\item \\textbf{Ensure: } $j^n_i \\in J^F \\land j^{n+1}_i \\in J_{q_k} \\land j^{n+1}_i \\in J^R$\n\\item 1: \\textbf{if} $\\text{elapsed}_{time_{j_i}} > \\text{exec}_{time_{j_i}}$ \\textbf{and} $\\text{elapsed}_{time_{q_k}} < \\text{adapt}_{th_{j_i}}$ \\textbf{and} $n \\leq \\text{delay}_{th_{j_i}}$ \\textbf{then}\n\\item 2: \\hspace{1em} cancel $j^n_i$\n\\item 3: \\hspace{1em} $n \\leftarrow n + 1$\n\\item 4: \\hspace{1em} create and run $j^n_i$\n\\item 5: \\textbf{else}\n\\item 6: \\hspace{1em} abort $q_k, j^n_i \\in J_{q_k}$\n\\item 7: \\textbf{end if}\n\\end{itemize}\n\nMoreover, further fault-tolerance techniques could be used by the aforementioned Algorithms 1 and 2 which include job replication, migration, or checkpointing. However, replicating jobs implies more costs to the service provider, it is then preferable to rely on mechanisms which do not require further resources. On the other hand, migration and checkpointing are complex to be conceived in a distributed environment without compromising performance accuracy.\n3.5 Resource Acquisition and Allocation\n\nWhile the previous Sections 3.3 and 3.4 address service aspects related to contract template labels and QoS assurance mechanisms, this section addresses how resources are acquired and allocated aiming at decreasing the costs on infrastructure usage.\n\nIndeed, resource acquisition is a crucial aspect of service execution management as it defines how resources are acquired by the service provider. A trivial resource acquisition approach is to rely on a fixed number of acquired resources to satisfy future contracts and only accepting contracts if their resource demand does not exceed the total amount of acquired resources. However, it is not an efficient solution since it wastes resources in a low-demand scenario and limits the number of contracts according to the predefined fixed number of acquired resources. In contrast, resources can be acquired on-demand, i.e., according to customer demand at runtime. This approach is more suitable to service providers since they can fit their resource acquisition to the actual resource demand. Therefore, this thesis relies on a dynamic resource acquisition approach which acquires and releases resources according to contract constraints.\n\nFurthermore, service providers may take advantage of under-provisioning in order to increase their profit. Under-provisioning is applied by this thesis and is useful when customer request demand is often not the maximum allowed. Therefore there will certainly have idle resources which can be used by other requests. However, service under-provisioning eventually requires dealing with the lack of resources when allocating resources to requests. This implies SLA violations thus implying the payment of fines. In order to deal with concurrent resource allocation, the approach proposed by this thesis decides which request should be aborted aiming at minimizing fine payments.\n\nResource acquisition and allocation are dealt with in an event-driven fashion. While new contract proposals trigger the acquisition of resources, new requests trigger resource allocation. Sections 3.5.1 and 3.5.2 discuss the flowcharts of contract proposals and request arrivals respectively.\n\n3.5.1 Contract Proposals\n\nFigure 3.6 depicts the flowchart of a contract proposal. When a contract establishment is proposed, the provider should decide whether it will accept it or not. First, it tries to acquire the needed resources to support the contract. If this operation is successful, then it deploys the service instance on the infrastructure and accepts the contract. Otherwise, it decides whether it is more profitable to rescind an ongoing contract in order to accept the just-arrived contract proposal. If so, it rescinds the chosen established contract and accepts the contract proposal, else it rejects the contract proposal.\n\nThis thesis proposes a simple, dynamic and efficient way of acquiring resources which is driven by the contract proposals. The Algorithm 3 depicts how resources are acquired given a contract template label $l$, the contract duration $t$ and the under-provisioning factor $upf$ which represents the percentage of resources to acquire based on resource requirements of $l$. First, acquire algorithm translates the response time\nto the resource requirements $res\\_req_l$ by using the translation function $\\tau$ (cf. Equation 3.1 Section 3.3.2). Second it applies the reduction factor through the operation $reduce$. Finally, the $acquire$ algorithm acquires resources from the resource provider on-demand through the $book$ operation. Thereby, the service provider is able to take advantage of under-provisioning in order to increase its profit according to its business model. Moreover, the $acquire$ algorithm is configurable in such a way that its under-provisioning characteristic can be disabled by setting $upf = 100\\%$, which means to acquire the exact resource requirements of $l$.\n\n**Algorithm 3 acquire($l, t, upf$)**\n\n**Require:** The contract template label $l$.\n\n**Ensure:** Returns true if $upf$ percent of $l$’s resource requirements is acquired.\n\n1: $res\\_req \\leftarrow \\tau(resp\\_time_l)$\n2: $res\\_req \\leftarrow reduce(res\\_req, upf)$\n3: return $book(res\\_req, t)$\n\nThe $accept$ operation described in Figure 3.6 relies on Algorithm 4 in order to decide whether the contract proposal will be accept when no more resources can be acquired from the infrastructure. This algorithm compares the amount of money to be earned from the contract proposal with the fine to be payed owing to contract rescission. If the total amount of money to be earned is greater, the $accept$ operation rescinds an ESTABLISHED contract and returns true. Otherwise, it returns false.\nAlgorithm 4 accept($c$)\n\nRequire: a contract proposal $c$\n\nEnsure: Returns true if there is an on-going (ESTABLISHED) contract $c'$ whose resource requirements are enough to accept $c$ and the profit for accepting $c$ is greater than the fine for rescinding $c'$ minus the profit of $c'$.\n\n1: $c' \\leftarrow \\text{nil}$\n2: for each $c_i \\in C^E$ do\n3: if ($c_i$ resource requirements assist $c$) and ($\\Pi_c > \\Psi_{c_i} - \\Pi_{c_i}$) then\n4: if $c' = \\text{nil}$ then\n5: $c' \\leftarrow c_i$\n6: else\n7: if $\\Psi_{c'} > \\Psi_{c_i}$ then\n8: $c' \\leftarrow c_i$\n9: end if\n10: end if\n11: end if\n12: end for\n13: if $c' = \\text{nil}$ then\n14: return false\n15: else\n16: rescind $c'$\n17: return true\n18: end if\n\n3.5.2 Request Arrivals\n\nThe flowchart of a request arrival event is depicted by Figure 3.7. If the provider does not rely on under-provisioning, the request treatment is dispatched normally since there are enough resources to treat it. Else, the provider should check if there are available resources to treat the request. If the resource reliability fits the request resource requirements, the request is treated. Otherwise, the request is aborted implying an SLA violation.\n\n\n\nThus the problem is to decide which request will be aborted: the just-arrived request or another on-going request whose resource requirements are suitable to support the former request. As the provider aims at decreasing fine payments, it chooses which\nrequest will be aborted based on request fine abortion values. Then the request to be aborted will be chosen aiming at minimizing the payment of fines as depicts Algorithm 5. The Algorithm 5 returns true if it managed to find an on-going request (BEING_TREATED state) whose resource requirements support the just-arrived request and whose fine is the cheapest.\n\nAlgorithm 5 treat(q)\n\nRequire: the arrival of request q\nEnsure: Returns true if there is an on-going (BEING_TREATED) request q' whose resource requirements are enough to treat q and the fine for aborting q' is the cheapest.\n\n1: q' ← nil\n2: for each q_k ∈ Q^T do\n3: if (q_k resource requirements assist q) and (ψ_q > ψ_{q_k}) then\n4: if q' = nil then\n5: q' ← q_k\n6: else\n7: if ψ_q' > ψ_{q_k} then\n8: q' ← q_k\n9: end if\n10: end if\n11: end if\n12: end for\n13: if q' = nil then\n14: return false\n15: else\n16: abort q'\n17: return true\n18: end if\nSLA-driven Service Execution Management\nPart III\n\nImplementation\nChapter 4\n\nQu4DS\n\nThe previous chapter presented the design of a solution for automatic service execution management which targets increasing the service provider profit. This current Chapter introduces the Qu4DS (Quality Assurance for Distributed Services) framework which implements this solution. Qu4DS addresses all the actions that enable addressing the contract life-cycle and the further complementary actions that deal with economic aspects. Hence, Qu4DS implements an automatic support for services. The development aspect is addressed by means of providing a PaaS (Platform-as-a-Service) support which fills the gap between the conception of higher-level SaaS (Services-as-a-Software) and the underlying infrastructure on which they are executed. Moreover, Qu4DS also assists the administration of the developed service by allowing service administrators to define high-level directions that will guide the service execution management in an automatic and transparent fashion.\n\nQu4DS features include contract negotiation, deployment and management of the service instance on the infrastructure and QoS assurance. These aforementioned features are driven by the contract quality aspects and duration by aiming at increasing the provider profit. Furthermore, Qu4DS supports the development of service providers that leverage the Master/Worker pattern. Qu4DS assists the development of such services by freeing service developers from managing workers and by ensuring their proper execution in accordance with time constraints QoS and reacting to job failure and delays at runtime.\n\nThe reminder of this chapter is organized as follows. Section 4.1 introduces the context of the targeted applications supported by Qu4DS. In order to investigate how to facilitate the development of these applications, the relationship between distributed applications and infrastructures is explored by Section 4.2. As follows, Section 4.3 describes Qu4DS architecture as a PaaS support for easing the development of service providers. Further details about this support are exposed in Section 4.4. Ultimately, Qu4DS usage is explained in Section 4.5.\n4.1 Support for Master/Worker Applications\n\nSome applications require great processing capacity owing to their intrinsic characteristics. For instance, applications which involve geoprocessing, photogrammetry, scientific simulations, huge data compressing take too much time to be executed in desktop computers. Indeed, they require non-trivial computational power to accomplish their tasks such as super-computers. However, super-computers are expensive infrastructures and running these applications on a single machine increases reliability issues.\n\nLow-cost distributed computational infrastructures may be used to circumvent this problem. On the one hand, a set of desktop computers connected through a network provides together enough computational power to assist the requirements of these applications. In addition, they inherently provide a distributed architecture which enables to develop reliable applications. On the other hand, the drawback of this approach is that it is harder to develop distributed applications as a result of the complexity of managing distributed data and processes.\n\nMaster/Worker is a generic pattern for conceiving distributed applications. It relies on a master abstraction that coordinates other tasks executed by workers. When workers finish their tasks, the master may delegate another task to them until the end of the application execution. The simple design of Master/Workers pattern is an advantage for developers against complex distributed workflows for instance. Therefore, this thesis targets supporting applications that are based on the Master/Worker pattern.\n\n4.2 Foundations\n\nThis thesis proposes a framework for supporting Master/Worker service providers which are built on top of distributed infrastructures. This requires investigating how to enable high-level service execution aspects as negotiation and provisioning by leveraging distributed infrastructure interfaces. However, these latter interfaces provide lower-level abstraction as jobs and resources as well as they often address job and resource concerns in a tight-coupled manner. This section discusses how Qu4DS decouples job management from resource acquisition and how it fills the gap between low-level underlying infrastructure and high-level service-oriented interfaces.\n\n4.2.1 Separating Resource Acquisition from Job Management\n\nThe dynamic way of how this thesis deals with resource acquisition requires decoupling it from the management of distributed jobs. While resource are acquired driven by contract arrival events, job management are mainly driven by request arrival events. Therefore, the management of both jobs and resource acquisition should be able to be dealt with separately. This requirement implies understanding distributed infrastructure interfaces along with their set of operations and abstractions.\n\nOn the one hand, grid interfaces define an extensive set of functionalities \\cite{JMF09,CFJ08,Fos06,GJK05} by leveraging the job abstraction (cf. Section 1.6). For instance, the Simple Grid API (SAGA) \\cite{GJK05} interface proposes to ease the use of\ngrids, promote interoperability and standardization while meeting grid applications requirements. In spite of these achievements, grid interfaces deals with the concerns of job management and resource acquisition together and requires static resource configuration and acquisition.\n\nOn the other hand, current interfaces of cloud IaaS providers rely on decoupled and simple resource provisioning interfaces [ME11, Ama06a, Nur09, Beg08] as discussed in Section 1.7.2. These interfaces are limited to the provisioning of bare resources, typically virtual machines, with no support for high-level programming abstractions, such as jobs. Despite the limitation of IaaS interfaces, further cloud-oriented approaches in the context of PaaS and SaaS take into account higher-level abstractions as support for MapReduce applications [DG08], workflows [Inf11] and application frameworks [Goo08, Sal99]. However, while MapReduce and workflow supports are limited to specific applications, application frameworks impose non-standard interfaces which compromises application interoperability and portability; thus enabling applications to vendor lock-in.\n\nIn order to take advantage of jobs by tackling resource acquisition separately, this thesis proposes to leverage the IaaS cloud decoupled way of acquiring resources and the grid standard interfaces which uses jobs as programming abstraction. The separation of resource acquisition from job management is similar to applying pilot-jobs for clouds, e.g., SAGA big-job [LLJ10], which is useful for acquiring resources dynamically. The proposed interfaces which address resource acquisition and job management are explained next.\n\n**Infrastructure Management Interface** The *infrastructure management* interface addresses resource acquisition where resources mean physical or virtual resources. The infrastructure interface exposes a set of operations on top of the resource abstraction. These operations enable resources to be acquired, released or modified based on specific resource requirements. Listing 4.1 describes the infrastructure management interface where resource class is a short term for referring to a set of statical resource requirements.\n\n```\n1 public interface InfrastructureManagement {\n2 public List<InfraResourceType> getResourceTypes();\n3 public int getNumberOfAvailableResources(String resourceClass);\n4 public int reserve(int nOfResources, String resourceClass, String\n start, String end); \n5 public boolean resize(int reservationId, String resourceClass, int\n newNumberOfResources, String endTime, List<Integer> resourcesId);\n6 public List<InfraResource> getReservedResources(int reservationId);\n}\n```\n\nListing 4.1: Description of the infrastructure management interface in Java syntax.\n\nMoreover, the infrastructure interface can be implemented on top of existing IaaS clouds which leverage the OCCI [ME11] specification (cf. Section 1.7.2) for instance. Thereby, OCCI instances can be mapped to resources in such a way that the start\nOCCI action can be implemented by as the `reserve(int nOfResources, String resourceClass, String startTime, String endTime)` method where the `startTime` parameter should be set to the current time. In turn, the stop OCCI action can be mapped to the `resize(int nOfResources, String resourceClass, String startTime, String endTime)` method where the `nOfResources` parameter should be set to zero.\n\n**Job Management Interface** The job management interface leverages jobs as higher-level abstraction. Jobs are useful for managing service instances and its distributed tasks on top of acquired resources. This thesis defines the job management interface based on SAGA in such a way that it is a subset of SAGA. First, this interface leverages the SAGA job life-cycle in order to define the job life-cycle (cf. Figure 3.3 in Section 3.1.3). Then, it provides some operations in the scope of SAGA job management which includes creating, canceling, migrating as well as enabling callbacks for monitoring purpose. Moreover, this interfaces also assumes that jobs share a common data space which may be a distributed file system, a database, a distributed shared memory and so forth. This decision is explained by the very fact that simplicity is prioritized against complexity. However the proposed interface is by far not trivial which allows it to meet several application development requirements.\n\nThe job management interface is described by Listing 4.2.\n\n```java\n1 public interface JobManagement {\n2 public InfraJob createJob(int reservationId, InfraJobDescription jobDescription);\n3 public boolean runJob(int reservationId, InfraJob job, String resourceAddress);\n4 public boolean cancelJob(int reservationId, InfraJob job);\n5 public boolean cancelAllJobsOnResource(int reservationId, String resource);\n6 public boolean checkpointJob(int reservationId, InfraJob job);\n7 public boolean suspendJob(int reservationId, InfraJob job);\n8 public boolean resumeJob(int reservationId, InfraJob job);\n9 public boolean resumeJob(int reservationId, InfraJob job, int checkpointVersion);\n10 public boolean migrateJob(int reservationId, InfraJob job);\n11 public boolean migrateJob(int reservationId, InfraJob job, String resourceAddress);\n12 public void registerCallback(int reservationId, InfraJob job, String metric, boolean on, Observer observer);\n13 public List<InfraJob> getAllJobs(int reservationId);\n14 public List<InfraJob> getJobs(int reservationId, String jobState);\n15 public List<InfraJob> getJobsOnResource(int reservationId, String resourceAddress);\n16 }\n```\n\nListing 4.2: Description of the job management interface in Java syntax.\n\n**Service Negotiation and Provisioning** The previous sections described two interfaces which enable dealing with the underlying infrastructure. In turn, this section\ndescribes the *negotiation and provisioning* interface which addresses the interaction between Qu4DS and the higher-level service-oriented layer. The negotiation and provisioning interface leverages the service abstraction by enabling the service provider to communicate with customer services. Through this interface, contracts are negotiated and customers send requests. The idea is to enable the provider to negotiate contracts rather than to define a complete specification or protocol for SLA negotiation, such as WSLA \\( \\text{LKD}^{+03} \\) or WS-Agreements \\( \\text{ACD}^{+07} \\).\n\nIn order to tackle service communication and membership, Qu4DS assumes that there exists a service registry which acts as repository of services. Then service providers subscribe to the registry from which service customers can look for providers based on their both functional and non-functional requirements. After selecting the service provider that fits its needs, the customer initiates a negotiation process which may conclude in a contract establishment if both parties agrees on the contract terms. This interaction between service providers and customers is commonly used by service-centric approaches owing to its simplicity. On the other hand, it has some drawbacks such as relying on a central service registry, not natively taking into account semantic service discovery, as well as further details that concern service communication protocols and specifications. For the sake of implementation, Qu4DS relies on a central service registry, however the way its architecture is designed allow Qu4DS to be easily coupled to other solutions that tackles service registry issues.\n\nThe negotiation and provisioning interface is described by Listing 4.3. While the `List<SLA> getListOfSLATemplates()` and `SLA proposeContract(SLA contractTemplate)` enable negotiation, the `String request(List<String> args)` method addresses provisioning by allowing customers to send requests. It is important to remark that further service provisioning methods can straightly be added to this interface according to service provider functional requirements.\n\n```java\n1 public interface NegotiationProvisioning {\n2 public List<SLA> getListOfSLATemplates();\n3 public SLA proposeContract(SLA contractTemplate);\n4 public String request(List<String> args);\n5 }\n```\n\nListing 4.3: Description of the negotiation and provisioning interface in Java syntax.\n\nThe Figure 4.1 depicts a sequence diagram of both negotiation and provisioning processes based on the negotiation and provisioning interface. With respect to the negotiation, Qu4DS relies on a template-based contract negotiation. It assumes that the customer obtains contract templates from the provider, chooses the contract template that is more suitable to its requirements, sets the contract duration and finally proposes it to the service provider. In turn, the provider decides whether it will accepted. If the service provider accepts the contract proposal, the customer is able to send requests which are treated by the service provider. Furthermore, in Qu4DS current implementation, the service provider is in charge of auditing the provision and\nmonitoring penalties. However service auditing could be performed by a third neutral party.\n\n\n\nFigure 4.1: The negotiation and provisioning interface methods exposed in a sequence diagram which depicts the interaction between a customer and the service provider.\n\n4.2.2 Assumptions\n\nQu4DS is implemented by taking into account some assumptions which concerns the following aspects.\n\n**Resources**\n\n**Assumption 4.1** Resource failures are not handled.\n\nThe explanation of relying on Assumption 4.1 is that Qu4DS aims at overcoming job failures and delays instead of dealing with resource failures. Moreover, even though the solution presented does not consider resource failures, it can be addressed by conceiving further QoS assurance mechanisms that deals with resource failures, e.g., booking further resources to replace failed resources.\n\n**Assumption 4.2** Resources have the same characteristics.\n\nThe Assumption 4.2 simplifies the experimentation scenarios. Having different types of resources, i.e., resource whose hold different requirements, increases the number of experimentation scenarios. Moreover, this assumption does not limit Qu4DS applicability as infrastructures which deliver homogeneous resources are quite simple to realize on top of current virtualization techniques, e.g., IaaS clouds.\nProfit and Expenses\n\n**Assumption 4.3** The expenses $\\epsilon(l, t)$ represent the costs spent on resource booking by a contract whose template label is $l$ during the contract duration $t$.\n\nIn order to calculate the expenses, Qu4DS relies on Assumption 4.3 and defines the expenses as a function of the number of resources $\\omega(l)$ required by the label $l$ and the cost $\\iota(l)$ of using a single resource that meet $l$ requirements. The following Equation 4.1 depicts how the expenses are calculated.\n\n$$\n\\epsilon(l, t) = t \\cdot \\omega(l) \\cdot \\iota(l)\n$$\n\n**Assumption 4.4** The targeted profit $\\Pi(l, t)$ is a function of the expenses in such a way that $\\Pi(l, t) = \\frac{\\pi(l)}{100} \\cdot \\epsilon(l, t)$, where $\\pi(l)$ is the percentage that represents the targeted profit for label $l$.\n\nAssumption 4.4 is useful for enabling the service provider to rely on various profit margins for each label. Based on Assumption 4.4 and from Equation 3.6 (cf. Section 3.3.3), the following Equation 4.2 defines how Qu4DS calculates the price $\\rho(l, t)$ for each contract template label $l$ whose contract duration is $t$.\n\n$$\n\\rho(l, t) = \\epsilon(l, t) \\cdot \\left(1 + \\frac{\\pi(l)}{100}\\right)\n$$\n\nFines\n\n**Assumption 4.5** The request abortion fine $\\psi_{q_k}$ costs $e_3$ times the cost that request $q_k$ takes to be treated.\n\nBased on Assumption 4.5, the fine cost for aborting the request $q_k$ is given by Equation 4.3 where $\\text{resp\\_time}_{q_k}$ is the $q_k$ response time if the request would be successfully treated.\n\n$$\n\\psi(l, q_k) = e_3 \\cdot \\rho(l, \\text{resp\\_time}_{q_k})\n$$\n\n**Assumption 4.6** Contracts can only be rescinded by the service provider which implies paying the customer the contract rescission fine $\\Psi$.\n\n**Assumption 4.7** The contract rescission fine $\\Psi_i$ costs $e_4$ times the price of the contract $i$.\n\nAccording to Assumption 4.7, the fine for rescinding a contract $\\Psi_i$ is calculated by multiplying $e_4$ by $\\rho_i$ as exposed by Equation 4.4.\n\n$$\n\\Psi(l, t) = e_4 \\cdot \\rho(l, t)\n$$\n\n**Assumption 4.8** If a contract $i$ is rescinded, the customer will be only charged based on the contract rescission fine $\\Psi_i$, request abortion fines $\\psi_{i,j}$ will not be taken into account.\n4.2.3 Profiling\n\nThe Qu4DS monitoring system relies on sensors which periodically inform Qu4DS about job and request dynamic metrics. Monitoring sensors are configured based on a relaxed timeout which directly influences monitoring accuracy. It is not preferable to rely on strong accurate metrics in order to prevent overloading Qu4DS with the arrival of monitoring events. Furthermore, the accuracy of the Qu4DS monitoring system meets Qu4DS requirements since the timeout can be configured by taking into account the targeted accuracy.\n\nBecause distributed infrastructures are subject to fluctuations, the dynamism is an inherent characteristic of such an environment. In order to tackle this issue, Qu4DS defines new measures based on the actual measured values of the QoS metrics in order to avoid that dynamic fluctuations compromise the behavior of its QoS assurance mechanisms. Thus, the values of \\( \\text{exec}_{\\text{time}}_{j_i} \\) and \\( \\text{resp}_{\\text{time}}_{q_k} \\) are relaxed as depicted by Equations 4.5 and 4.6 respectively. In these equations, \\( e_0, e_1 \\) and \\( e_2 \\) are constants, \\( \\text{mean}_{\\text{exec}_{\\text{time}}}_{j_i} \\) and \\( \\text{mean}_{\\text{actual}_{\\text{resp}_{\\text{time}}}}_{q_k} \\) are the respective averages of the repeated measured values of \\( \\text{exec}_{\\text{time}}_{j_i} \\) and \\( \\text{actual}_{\\text{resp}_{\\text{time}}}_{q_k} \\) as well as \\( \\text{sd}_{\\text{exec}_{\\text{time}}}_{j_i} \\), \\( \\text{sd}_{\\text{actual}_{\\text{resp}_{\\text{time}}}}_{q_k} \\) are their standard deviations.\n\n\\[\n\\text{exec}_{\\text{time}}_{j_i} = e_0 \\cdot \\text{mean}_{\\text{exec}_{\\text{time}}}_{j_i} + e_1 \\cdot \\text{sd}_{\\text{exec}_{\\text{time}}}_{j_i} \\quad (4.5)\n\\]\n\n\\[\n\\text{actual}_{\\text{resp}_{\\text{time}}}_{q_k} = \\text{mean}_{\\text{actual}_{\\text{resp}_{\\text{time}}}}_{q_k} + e_2 \\cdot \\text{sd}_{\\text{actual}_{\\text{resp}_{\\text{time}}}}_{q_k} \\quad (4.6)\n\\]\n\n4.3 Architecture\n\nQu4DS serves as a framework for implementing service providers in the scope of the Service-Centric Paradigm. Qu4DS offers a support for increasing the service provider profit by automatically managing resources, service instances and requests according to agreed SLAs. In order to tackle these issues, Qu4DS design abstracts over distributed infrastructures while it assists higher-level service providers in a transparent manner. This section depicts the Qu4DS architecture by firstly explaining how it supports service developers and administrators, then introducing the Qu4DS architecture.\n\nA PaaS Solution for Service Developers and Administrators The way of how Qu4DS design is placed between infrastructures and higher-level service customers is similar to the cloud common architecture introduced in Section 1.7.2. The cloud computing community has relied on a layered architecture for clouds which addresses resources (IaaS), platform (PaaS) and software (SaaS). The cloud common architecture also deals with distributed infrastructures which aim at supporting higher-level service providers. More specific, the PaaS layer offers a support for final service providers (SaaS layer) on top the infrastructure (IaaS layer). Therefore, Qu4DS and the cloud common architecture have a common interest of separating higher-level services from infrastructures resources. Specifically, both Qu4DS and PaaS clouds are placed in an\nImplementation\n\nintermediate level which provides support for conceiving final services by abstracting bare resources.\n\nThereby, from the clouds point of view, Qu4DS indeed is a PaaS solution which tackles service execution management by including negotiating contracts, deploying and terminating service instances on resources acquired on-demand. However, Qu4DS objectives go beyond a PaaS approach with QoS assurance capabilities. It also addresses a support for service administrators by providing automatic service execution management. Qu4DS leverages the idea of an autonomous system (cf. Section 1.4) which is guided by high-level guidelines that define how the service provider behavior is changed at runtime.\n\nArchitecture The Qu4DS architecture is based on the cloud architecture layers as described by Figure 4.2. In the SaaS layer, contracts are negotiated between the service provider and its customers. When leveraging Qu4DS, the provider actually delegates negotiation, service instantiation and provision to Qu4DS. Thus when a contract is proposed, Qu4DS translates the contract QoS through the QoS Translator to the resource requirements able to ensure the contract QoS. The translated resource requirements are forwarded to the resource management control loop which books resources through the infrastructure management interface until the end of the contract duration. Following that, Qu4DS configures a service instance based on the translated resource requirements and deploys in the infrastructure through the job management interface. When the service instance is operational, Qu4DS commits the contract agreement to the right customer, who is now able to send requests.\n\n4.4 Implementation\n\nQu4DS is implemented in Java and contains around 15,500 lines of code. It has been tested on Debian and Ubuntu distributions of the GNU/Linux operating system; however Qu4DS employment in further GNU/Linux distributions is also feasible. Qu4DS requirements include the Sun Java JDK 1.6, support for SSH connections, a distributed file system and the Bash command-line interpreter. Moreover, Qu4DS is a free-software thus allowing the community to perform further experimentations based on customized parameters. In addition, Qu4DS source code is open which allows researchers to directly take advantage of it\\(^1\\).\n\nThis section exposes further information about Qu4DS implementation being organized as follows. Section 4.4.1 discusses the implementation of Qu4DS control loops. Following that, the implementation of the infrastructure, job management and negotiation and provisioning interfaces are described in Section 4.4.2. Ultimately, a sequence diagram is used to explain Qu4DS behavior at runtime in Section 4.4.3.\n\n\\(^1\\)Qu4DS will be publicly available under the Lesser GPL license in the following web site: http://gforge.inria.fr/projects/quads/\n4.4.1 Dynamic Adaptation\n\nQu4DS uses dynamic adaptation in order to change its behavior at runtime. Qu4DS implements three configurable control loops (cf. Figure 4.2) based on an event-condition-action (ECA) decision engine whose actions depend on received events. These control loops are subscribed to communication channels to which events are published. When an event is dispatched, the right control loop receives it and decides whether any action will be employed. Moreover, the ECA decision engine leverages the separation of adaptation concerns as proposed by the Autonomic Computing MAPE control loop, thus decoupling monitoring, decision and adaptation employment.\n\nThe configuration of Qu4DS control loops are employed differently. The QoS assurance control loops have their adaptation policies set at runtime, based on the translation of the QoS metrics described in the contract template. On the other hand, the adaptation policy of the resource management control loop depends on how the provider books resources which is defined statically. Moreover, although this difference, both control loop flows depend on the service price and fines in order to take decisions (cf. Section 3.5.1). The resource management and QoS assurance control loops are explained in details next.\nResource Management Control Loop The resource management control loop addresses resource acquisition and allocation. It implements the flowcharts for both contract proposals and request arrivals introduced in Section 3.5 (cf. Figures 3.6 and 3.7). Thus the resource management control loop reacts to two kinds of events: either a contract proposal or a request arrival. When a contract is proposed, the resource management control loop books resources to support the contract until the end of the contract duration. When a request is sent by a customer, the resource management control loop checks resource availability to treat this request.\n\nBoth previous actions triggered by contract proposals and request arrivals depend on the under-provisioning configuration to which the resource acquisition control loop is configured. The under-provisioning configuration refers to the under-provisioning factor $upf$ as Qu4DS implements the resource acquisition algorithm described by Algorithm 3 in Section 3.5.1. Therefore, different configurations of the under-provisioning factor $upf$ is used to compose different adaptation policies. Moreover, the current Qu4DS implementation applies under-provisioning by means of exploiting horizontal elasticity, i.e., reducing the number of booked resources and not their requirements.\n\nQoS Assurance Control Loops The QoS assurance control loops handle job failures and delays. They are responsible for ensuring that the distributed tasks, i.e. the workers, are successfully executed and finish before the expected execution time. Thus, QoS assurance aspects involve performance and fault tolerance as discussed in Section 3.4. Performance is addressed by Qu4DS by configuring the service instance according to the right resource configuration that allows requests to be treated in the agreed response time QoS (cf. Section 3.4.1). On the other hand, fault tolerance is handled by Qu4DS by reacting to job failures and delays (cf. Section 3.4.2). Moreover, although performance is tackled by service instance configuration, fault tolerance mechanisms complement performance assurance. By handling delayed jobs, the fault tolerance mechanism ensures that delayed jobs will not compromise the request performance.\n\nQu4DS QoS assurance control loops implement fault tolerant algorithms described in Section 3.4.2. The different adaptation policies of the QoS assurance control loops are based on different values of the replacement threshold parameters of Algorithms 1 and 2. In turn, replacement threshold values depend on the contract template label. Therefore, QoS assurance control loops are configured at runtime by translating the contract template fault tolerant aspects to system configurations (cf. Section 3.3.2).\n\n4.4.2 Interfaces\n\nInfrastructure Interface Qu4DS implements the infrastructure management interface according to its description depicted by Listing 4.1 in Section 4.2.1. Such an implementation is simply called as infrastructure for naming purpose. The infrastructure leverages Grid’5000 [CCD05] which was used as the resource provider meeting\nthe role of the IaaS layer. A Grid’5000 operating system image was customized. In such an image, there are all required programs and libraries to execute Qu4DS including an implementation of the job management interface. Additionally, the Qu4DS current version 0.4.0 supports a single resource class.\n\nAs defined by the infrastructure management interface, the infrastructure does not have start and stop operations. Thereby, the interaction between Qu4DS and the infrastructure saves time when booking resources and dismissing them. Importantly, this decision does not compromise the interface, it only assumes that the time for starting an instance is zero. The reason for doing so is owing to the necessity of deploying the Grid’5000 images and configuring them to Qu4DS before using the grid. Since they were previously configured and deployed, it would be useless and time consuming to redo this very same operation. As a result, when a resource is booked, it will be automatically operational and will contain the needed programs installed. Then Qu4DS configuration scripts are in charge of configuring the environment with dynamic information such as IP addresses in order to configure RMI and Web Service remote connections.\n\nJob Management Interface The implementation of the job management interface (cf. Listing 4.2 Section 4.2.1) is called job broker and follows a layered design. Firstly, the higher-level layer is the actual implementation of the job management interface that deals with job life-cycle state management (cf. Figure 3.3 in Section 3.1.3). It keeps Qu4DS informed about job metrics following the publish-subscribe pattern which maps job raw metrics (i.e., UNIX process metrics) to job higher-level metrics and job states. Secondly, the middle layer is implemented by the common InfrastructureBackend abstract class that enables the use of various underlying batch-job systems. In addition, the job broker is able to simulate job misbehaviors. This is configurable by means of the percentage of the jobs that will fail as well as the percentage of the jobs that will be delayed. Moreover, these misbehaving jobs are either failed or delayed in an exclusive fashion and they are chosen randomly. Lastly, the final third layer refers to the actual backend implementations. Currently, Qu4DS implements two backends; one that enables the XtremOS grid [CFJ+08] and another more generic on top of SSH (Secure Shell). The latter backend enables the utilization of the job broker by any operating system with an SSH server and a Bash command-line interpreter.\n\nThe job broker provides a job scheduling algorithm that ensures that resources are shared in an exclusive fashion. It means that resources may be used by any contract but one at once. As a consequence, jobs that run request tasks and jobs run service execution.\ninstances have dedicated resources. This way of sharing resources is necessary to ensure performance constraints since application profiling is performed on dedicated resources. Indeed, it is not feasible to profile applications on non-dedicated resources because the variation of resource load compromises profiling results. Another consequence of the exclusive sharing scheduling algorithm is that applying under-provisioning implies sharing resources among job request tasks, and not among service instances.\n\n**Negotiation and Provisioning Interface** The negotiation and provision interface allows performing the communication between Qu4DS and customers. The goal of this interface is two-fold: to enable the negotiation of contracts and the actual service provisioning by means of request calls. Qu4DS implements the service negotiation and provision interface as a SOAP Web Service whose WSDL file exposes the operations described by Listing 4.3. Thereby, the WSDL file is used by customers to know the service provider functionality as well as negotiation operations.\n\n### 4.4.3 Sequence Diagram\n\nIn order to illustrate the runtime flow of Qu4DS behavior, the Figure 4.3 depicts a sequence diagram of a contract enactment followed by a request treatment. The customer is in charge of initiating the negotiation process whose first step is to get the list of contracts templates from the service provider. Then the customer chooses a contract template, sets its duration and propose the customized contract template to the service provider. In turn, Qu4DS asks the QoS translator the resource requirements of the proposed contract template. Based on these requirements, Qu4DS applies the under-provisioning factor $upf$, creates a new contract and dispatches an event to the resource management control loop which books the necessary resources according to the resource requirements. If resources cannot be booked, the resource management control loop checks if it is more profitable to rescind an on-going contract to accept the just-proposed contract. As resources are successfully acquired, Qu4DS configures a service instance with the right resource requirements and the contract identifier. Through the job broker, Qu4DS creates a job and run it. Following that, the job broker gets an idle resource from the infrastructure and run the job on this resource. This action implies to execute a UNIX process whose process ID is used for monitoring purpose such as the job state. Ultimately, when the job is running, Qu4DS tells the customer that the contract was accepted and the service instance is operational which allows the customer to send requests.\nFigure 4.3: Qu4DS general sequence diagram. A customer establishes a contract, Qu4DS instantiates the service and then treats a request sent by the customer.\nWhen a customer sends a request, it is forwarded to the resource management control loop which decides whether it can be treated. If so, Qu4DS forwards the request to the right service instance deployed on the infrastructure. Then the service instance prepares the distributed tasks necessary to treat the request based on its configuration and asks Qu4DS to execute the tasks. These tasks are also deployed by Qu4DS on the infrastructure through the job broker and monitored by the job failure and job delay control loops. If these control loops are informed about failures or delays, they will replaced failed or delayed jobs up to their respective replacement thresholds; which are known by translating the reliability QoS metrics. If the job executions are successful, Qu4DS answers to the service instance the result of the tasks which is used to finish the request treatment. Then, the service instance tells Qu4DS that the request is treated and Qu4DS forwards the result to the right customer. If any of the QoS assurance control loops informs Qu4DS that the request could not be treated, Qu4DS aborts the request, tells the customer about such SLA violation and computes the penalties.\n\n4.5 Usage\n\nQu4DS provides a PaaS solution for increasing the service provider profit by providing automatic support for service execution management and development. In order to understand Qu4DS usage, three different roles are introduced. Firstly, the *customer* interacts with Qu4DS by negotiating contracts and sending requests as an usual service provider. Secondly, Qu4DS frees the *service developer* from development details involving as negotiation and worker execution. Finally, from the *service administrator* point of view, Qu4DS automatically manages the service provider execution by acquiring resources, instantiating and destroying the service instance. These roles are described next.\n\n**Customer** The *customer* is the service consumer. It establishes contracts with the service provider and send requests to be treated by the service provider.\n\n**Service Developer** The service *developer* is in charge of developing the service provider. In addition to service provider business logics, development tasks include preparing workers, executing them on distributed resources and processing worker results.\n\n**Service Administrator** The service *administrator* manages the service provider execution. Management actions include dealing with resource acquisition, instance configuration, instantiation and destruction.\n\nQu4DS usage is illustrated by Figure [4.4]. It depicts the service provider as the common entity among the customer, the service developer and the service administrator. During the contract negotiation (cf. arrow 1), Qu4DS books resources from the infrastructure in order to deploy the service instance. Since the service is instantiated (cf. arrow 2), the contract is established and customer requests (cf. arrow 3) are then forwarded by Qu4DS to the service instance by calling the remote method.\ntreatRequest(request) (cf. arrow 4). The service instance prepares the workers and send them through the remote method executeWorkers(workers) (cf. arrow 5) to be executed by Qu4DS. Then Qu4DS manages worker execution according to the contract template reliability constraints. After executing the workers, Qu4DS sends their results to the service instance by calling the remote method workerResults(results) (cf. arrow 6). Following that, the service instance processes the previous results and answers Qu4DS the request response by calling the method requestResponse(response) remotely (cf. arrow 7). Then the request is finally forwarded to the customer by Qu4DS (cf. arrow 8). Moreover, when the contract duration finishes, Qu4DS destroys the service instance (cf. arrow 9) and releases the resources booked to assist this contract. Thereby, Qu4DS ensures the proper execution of workers by handling non-successful worker executions transparently as well as Qu4DS deals with resource acquisition and further runtime environment aspects also in a transparent fashion.\n\nFigure 4.4: Qu4DS aids service developers and administrators automatically and transparently. On the one hand, Qu4DS usage assists service provider developer by managing the execution of workers. On the other hand, Qu4DS assists service administrators by instantiating the service provider and dealing with resource acquisition.\nRegarding the service administration, configuring Qu4DS requires setting its configuration parameters in the **quas.properties** file as illustrated in Figure 4.4. Firstly, choosing the under-provisioning factor means to decide how much percent of the necessary resources will be acquired (cf. `under.provisioning_factor`). Secondly, the resource requirements and replacement thresholds should be fulfilled according to their constraints. Then, profiling parameters refers to setting the constants that will be used when profiling the service provider (cf. `e_0`, `e_1`, `e_2`). Finally, pricing parameters are the targeted margin profit (cf. `p_1`) and the constants `e_3`, `e_4` are used to calculate request abortion and contract rescission fines, $\\psi$ and $\\Psi$ respectively.\n\nWith respect to the service development, the service developer should import the a Java library in order to take advantage of Qu4DS. This library uses distributed server-client communications and contains an abstract class that should be extended. This class requires implementing the `treatRequest(request)` and `workersResults(results)` methods which allow the service instance to be called by Qu4DS as a server. In turn, the service instance plays the role of a client by calling the `executeWorkers(workers)` and `requestResponse(response)` methods. These latter methods are implemented by Qu4DS library as a server. All these aforementioned methods are remotely invoked by using Java Remote Method Invocation (RMI) whose configuration is automatically done by the library when the service is instantiated.\n\nUltimately, the bold texts in the sequence diagram depicted by Figure 4.3 also represent the interaction between the service provider and Qu4DS depicted by Figure 4.4. Moreover, in spite of this tight-coupled way of delivering a PaaS service as a Java library, the `executeWorkers(workers)` method can perfectly be also implemented as an external Web Service for instance. This allows taking advantage of a dynamic binding between the service provider and Qu4DS thus exploiting Qu4DS as service provider completely separated from the service provider.\nPart IV\n\nValidation\nChapter 5\n\nEnvironment\n\nThis chapter explains the experimentation environment. Section 5.1 introduces the flac2ogg service as a case study that involves parallel audio compression. Following that, Section 5.2 exposes the configuration parameters which concerns the Web Service customer generator, Qu4DS and the infrastructure. Lastly, Section 5.3 explains how the flac2ogg service provider was profiled and details about the QoS translation.\n\n5.1 Case Study: The Flac2Ogg Service Provider\n\nAudio Compression Nowadays, audio is widely utilized in different digital medias such as videos, streaming, radios, social networks and so forth. Owing to the huge quantity of data stored by media servers, audio compression is employed in order to save storage space. Moreover, audio contents is often compressed by applying algorithms that imply minor audio content losses which significantly reduces the media to be stored. For instance, the Free Lossless Audio Codec (FLAC) [The11a] is a compressed audio format which maintains the original audio quality. Although the great advantage of having a lossless compressed audio, FLAC is not suitable for storing a huge quantity of audio in a audio streaming server for instance. An alternative is to this issue is to compress even more FLAC audios to the lossy compressed OGG (Vorbis OGG) [The11b, The11c] audio format thus reducing the audio file size.\n\nThe computational requirements for compressing audio files depends on the input file size. It can be done by a desktop computer, however its computational capability is not enough when compressing great quantity of audio. For instance, web sites which rely on audio streaming as Jamendo, Deezer, LastFM compress a huge quantity of audio for streaming lossy audio over the Internet. In order to not deal with the problem of compressing great audio data, these web sites can outsource this task by using external services such as Zencoder, Panda, Sorenson or Encoding.com for instance.\n\n\\footnote{OGG actually is an audio container which supports the Vorbis audio format. Since the .ogg file extension is commonly used to refer to a Vorbis audio supported by the OGG container, this thesis will refer to it as OGG. Moreover, OGG container also support FLAC audio formats, however this thesis will refer to the FLAC audio format simply as FLAC since it has its own container which is used widely.}\nOverview The flac2ogg service provider aims at providing an audio encoder solution which compresses FLAC files to OGG. The flac2ogg provider relies on a distributed Master/Worker design as depicted by Figure 5.1. The flac2ogg service provider compresses FLAC files in parallel in order to improve its performance. The flac2ogg service provider splits the FLAC file given a number of workers to which it is configured and prepares these workers by setting up their input and output files based on the split FLAC parts. Then, the flac2ogg service provider encodes in parallel each split FLAC file on top of distributed resources. When the encoding process is finished, the flac2ogg provider merges the encoded OGG files to a single OGG file that represents the encoded FLAC file input. Moreover, the FLAC and OGG formats were chosen to be used by this case study not only because both are patent-free formats with open-source implementations, but also owing to their technical advantages against further formats such as WAV and MP3 for instance.\n\nFigure 5.1: The flac2ogg service provider compress FLAC audio files to OGG based on the Master/Worker pattern.\n\nImplementation The whole process of encoding an audio file in parallel by the flac2ogg service provider comprises splitting, submitting, encoding, and merging phases as explained next.\n\nSplitting Consists of splitting the input FLAC in $n$ equal parts where $n$ is the number of workers by using the shnsplit Shntool [Jor09] command. The performance of the splitting phase depends on the FLAC file size where the greater the FLAC file is, the more time it will take to be split. The shnsplit Shntool command does not actually split the original FLAC file, it creates $n$ FLAC files where each file represents a copy of a part of the original FLAC file. Moreover, the shninfo Shntool command is used to get audio meta-information used by shnsplit.\n\nSubmitting Means to wrap the workers as jobs and submit them to be executed on the infrastructure through the job management interface. This phase does depend on the number of workers since the more fragmented the FLAC file is, the more time it take to submit all split FLAC parts to be encoded. However, it does not\n\n2The terminology encode is widely used to refer to the action of converting audio file formats where compression is often employed. This thesis will use the verb encode to mean a compressing conversion of FLAC audio files to OGG audio files.\nConfiguration Parameters\n\ndepend neither on the size of the FLAC size nor on the size of each FLAC split part.\n\n**Encoding** Employs the actual compression of each FLAC split part to its respective OGG output. The more number of workers, the faster it is. In addition, the actual compression is performed by the `oggenc` Vorbis Tools [Xip11] command.\n\n**Merging** Means to merge all the generated OGG files to a single OGG file that represent the compressed original FLAC input. The number of workers here is insignificant, however the FLAC file size affects the merging phase performance. Similar to the splitting phase, the greater the FLAC input is, the more it will take to accomplish this phase. However, because the size of the OGG output file is is smaller than the FLAC input, the merging phase is faster than the splitting phase since there is less data to be stored.\n\nThe Figure 5.2 depicts how the `flac2ogg` provider is implemented by using Qu4DS. The Qu4DS framework aids the service developer by handling the submitting and encoding phases. When a request is sent the developer splits the FLAC file and prepares the workers by setting each FLAC part as input and the `/usr/bin/oggenc` as the executable to process the input. Then the developer asks Qu4DS to execute the workers which includes wrapping them as jobs and managing job submissions through the job broker. The encoding phase is performed in parallel on distributed resources and it is up to Qu4DS to ensure that jobs will be successfully ran. When all the FLAC parts are encoded, Qu4DS warns the service developer who then merges the OGG parts into a single OGG output and respond the request. Importantly, Qu4DS only requires worker inputs and executable which enhances Qu4DS generic characteristic thus be able to support different service providers.\n\n5.2 Configuration Parameters\n\nThis section discusses the configuration parameters regarding to Qu4DS evaluation. First, it exposes the customer generator and its configuration aspects in Section 5.2.1. Then, Qu4DS configuration parameters are introduced by Section 5.2.2. The Section 5.2.3 explains the parameters which allow configuring the infrastructure and the job broker.\n\n5.2.1 Customer Generator\n\nA customer generator was designed and implemented in order to perform the experiments. The customer generator implements Web Service (WS) customers which have their own request schedule. The request schedule defines when customers will trigger the contract negotiation and send requests if the contract is accepted. The features\n\n---\n\n3For systems which use Debian packages, the Vorbis Tools [Xip11] package places the the OGG encoder binary at `/usr/bin/oggenc`. \nEnvironment\n\nFigure 5.2: Qu4DS is in charge of managing worker execution in distributed resources thus letting the service developer concentrate in specific-domain tasks.\n\nof the customer generator include customer scheduling; loading previously created customer schedules; launching simulation; and plotting schedules to a graphic. Moreover, configuring, the customer generator requires setting the following parameters.\n\n**Experiment duration** It sets the total time of the experimentation. The more time the experimentation takes, the more suitable it is for creating heterogeneous scenarios, i.e., scenarios with greater scheduling variations.\n\n**Number of customers** It sets the total amount of customers for each contract template label. The more customers, the more contract negotiations occur. Furthermore, contract template labels which rely on high resource requirements require more resources, while labels that prioritize fault tolerance use less resources. The experimentation includes all labels (fast, safe, classic, standard) and set the total number of customers to ten or twelve depending on the scenario.\n\n**Contract duration** The lower contract durations are, the less requests can be scheduled. The experimentation relies on fixed and variable contract durations, varying from the time to treat one request up to the whole experimentation duration.\n\n**Request load** ($\\lambda'$) Defines the expected request load within the contract duration. The parameter $\\lambda'$ represents a percentage of the maximum number of requests within the contract duration ($\\phi_{max}$). As the targeted request load $\\lambda'$ is the expected load and not the actual load, $\\lambda'$ is used to generate a random number which will be the actual number of requests sent during the contract duration. This random number is based on the Poisson distribution since it expresses the probability of the number of events to occur during a time interval where the average rate is known. Therefore, Poisson’s $\\lambda = \\lambda' \\cdot \\phi_{max}$. Moreover, if the\n\n```python\nflac2ogg\nimport Qu4DS\n...\n\ntreatRequest(FLAC) {\n splits FLAC in n parts\n prepare n workers\n executeWorkers(workers)\n}\n...\n\nworkerResults(results) {\n merge OGG files\n requestResponse(OGG)\n}\n...\n```\nrandom number is zero, the customer generator sets it to one since it assumes that if a customer establishes a contract, it will eventually use the service. On the other hand, if the random number generated is greater than $\\phi_{max}$, the customer generator sets it to $\\phi_{max}$ since the number of requests cannot exceed $\\phi_{max}$. Last, the greater $\\lambda'$ is, the higher is the probability of having greater number of requests during the contract duration. Thereby, the parameter $\\lambda'$ directly influences resource usage.\n\n**Demand Profiles** The customer generator is used to create diversified customer demand profiles. The contract template labels are combined in order to qualify the targeted customer demands based on differentiated QoS. Table 5.1 exposes the customer demand profiles used by the experimentation scenarios. The former is called high-FT and represents a customer demand which requires a high-level of fault tolerance, being then composed by customers whose contract template label is safe. The next customer demand profile is called hybrid and expresses a heterogeneous customer demand whose customers hold different contract template labels by including fast, safe, classic and standard labels. Finally, the high-RR profile addresses representing a customer demand that has strong resource requirements, hence it holds customers whose contract template label is fast.\n\n<table>\n<thead>\n<tr>\n<th>Demand Profile</th>\n<th>high-FT</th>\n<th>hybrid</th>\n<th>high-RR</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Fast</td>\n<td>0</td>\n<td>3</td>\n<td>10</td>\n</tr>\n<tr>\n<td>Safe</td>\n<td>10</td>\n<td>3</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Classic</td>\n<td>0</td>\n<td>3</td>\n<td>0</td>\n</tr>\n<tr>\n<td>Standard</td>\n<td>0</td>\n<td>3</td>\n<td>0</td>\n</tr>\n<tr>\n<td><strong>Number of resources</strong></td>\n<td><strong>30</strong></td>\n<td><strong>45</strong></td>\n<td><strong>50</strong></td>\n</tr>\n</tbody>\n</table>\n\nTable 5.1: The formation of customer demand profiles is based on the combination of different contract template labels. *Number of resources* means the total amount of resources required by all contracts of a demand profile.\n\nFive request schedules were created for each demand profile which are divided in two groups as depicted by Table 5.2. The first group is based on four values of request load $\\lambda'$: 0.25, 0.50, 0.75, 1.00 whose contract durations were fixed to the experimentation duration, i.e., nine-hundred seconds. The second group refers to demand profiles with variable contract durations and request load set to $\\lambda' = 1.00$. These parameters along with the Table 5.1 were used by the customer generator to create the request schedules for each demand profile. Furthermore, request schedules with variable contract durations assume that cheaper contracts are firstly established, then more expensive contracts are proposed to the provider. The graphics representing all request schedules can be found in Appendix A.\n\n### 5.2.2 Qu4DS\n\nQu4DS configuration parameters include the under-provisioning factor and parameters related to QoS translation constraints, profiling and pricing as discussed in Section 4.5.\nTable 5.2: Each customer demand profile holds five request schedules which are divided into two groups based on the contract duration.\n\n<table>\n<thead>\n<tr>\n<th>Request schedule</th>\n<th>Request load</th>\n<th>Total</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>fixed contract duration (exp. duration)</td>\n<td>( \\lambda = 1.00, 0.75, 0.50, 0.25 )</td>\n<td>4</td>\n</tr>\n<tr>\n<td>variable contract durations</td>\n<td>( \\lambda = 1.00 )</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\nThey are summarized next.\n\n**Resource acquisition** The under-provisioning factor parameter configures Qu4DS to apply the given under-provisioning factor when booking resources. The experimentation relies on the following values; \\( upf = 100, 70, 50 \\).\n\n**QoS translation constraints** The parameters used to fill the QoS translation constraints refer to resource requirements and replacement thresholds constraint. The former depends on service profiling while the latter is statically defined.\n\n**Profiling** It includes the fixed \\( e_0, e_1, e_2 \\) parameters which refer to setting the response times and job execution times.\n\n**Pricing** The values of \\( \\pi \\) is statically defined to \\( \\pi = 100 \\) which means that the provider earns one-hundred percent from each contract. The \\( e_3 \\) and \\( e_4 \\) constants, which are used to set fine costs, assume the following values: 0.5, 1.0, 2.0.\n\nFurthermore, the Section 5.3 explains how fixed values of the QoS table, profiling and pricing parameters are set.\n\n**Under-Provisioning Profiles** In order to experiment Qu4DS with different resource acquisition policies, three under-provisioning profiles are defined as depicted by Table 5.3. On the one hand, the no-UP under-provisioning profile does not reduce the resource requirements since \\( upf = 100\\% \\). On the other hand, the UP-70 and UP-50 under-provisioning profiles imply respectively acquiring seventy and fifty percent of the total amount of the required resources.\n\n<table>\n<thead>\n<tr>\n<th>Under-Provisioning Profile</th>\n<th>no-UP</th>\n<th>UP-70</th>\n<th>UP-50</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Under-provisioning factor ( (upf) )</td>\n<td>100</td>\n<td>70</td>\n<td>50</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.3: The under-provisioning profiles are created based on various values of the under-provisioning factor \\( upf = 100, 70, 50 \\).\n\n### 5.2.3 Infrastructure\n\nThis configuration parameters related to the infrastructure and job broker described as follows.\n\n**Infrastructure capacity** Sets the total amount of resources that the infrastructure can provide. The less resources the infrastructure holds, the more contracts may\nbe rescinded if the customer demand profile is great enough to saturate the infrastructure provision capacity. The experimentation sets the infrastructure capacity based on a percentage of the total amount of resources required by a customer demand profile whose values are 100%, 75%, 50%.\n\n**Percentage of job misbehaviors** Sets the percentage of jobs which will present misbehaviors at runtime. The experimentation assumes that 0, 5, 10, 20, 40 percent of the total jobs\\(^4\\) misbehave. For instance, when set to 20%, implies 10% of the jobs will be failed and other 10% of them will be delayed. These jobs are chosen randomly based on the normal distribution. In addition, the greater the percentage of job misbehaviors, the more SLA violations may occur thus the more adaptation actions may be triggered.\n\n### 5.3 Profiling\n\nThis section tackles profiling issues by explaining how the flac2ogg service provider was profiled. It comprises the choice of profiling, pricing and performance constants used to fill the QoS table.\n\n#### 5.3.1 Constants\n\n**Profiling:** \\(e_0, e_1, e_2\\) \\(e_0\\) and \\(e_1\\) are used to calculate the job execution threshold (cf. Equation 4.5, Section 4.2.3) which is used to decide whether a job is delayed by the QoS assurance mechanism presented in Section 3.4.2. These constants were set to \\(e_0 = 1 \\times 10^0\\) and \\(e_1 = 3 \\times 10^0\\). With regard to the constant \\(e_2\\), it is used to calculate the response time (cf. Equation 4.6, Section 4.2.3). This constant was set to \\(e_2 = 3 \\times 10^0\\).\n\n**Pricing:** \\(\\pi\\) The constant \\(\\pi\\) refers to the profit that the provider wants to earn (cf. Equation 4.2 in Section 4.2.2). The value for the constants \\(\\pi\\) (cf. Section 4.5) was set to 100 which means that the service provider earns 100% from each contract.\n\n#### 5.3.2 Response Time Constraints\n\nThis section explains how the performance constraint parameters \\(\\text{res}_\\text{req}_\\text{strong}, \\text{res}_\\text{req}_\\text{medium}, \\text{res}_\\text{req}_\\text{weak}\\) were chosen by profiling the service provider. Service profiling consisted of executing the flac2ogg provider with based on different resource requirements.\n\n**The Size of the FLAC File** The request response time depends on the size of the FLAC file. In order to rely on short experimentation durations, the size of the FLAC file was fixed. It is important to remark that this decision does not compromise the experimentation results since it can be easily overcome by dynamically checking the right request response time for the given variable FLAC file size. The size of the\n\n\\(^4\\)Service instance jobs excluded, only jobs belonged to requests can be failed or delayed.\nFLAC file was fixed to 194MB as the benefits of the parallelization present significant performance differences for FLAC file greater than 194MB.\n\n**The Number of Workers** In order to understand the relationship between the request response time and the number of workers, the number of workers vary from two to nine. Figure 5.3 depicts the profiling of the flac2ogg provider whose goal is to identify which numbers of workers are not worth to be used. With respect to the job execution time, the *job-exec-time* line shows that the more the FLAC file is divided, the faster each part is encoded since the smaller the split FLAC part is, the faster it is encoded. In contrast, the *actual-resp-time* line does not follow this behavior because the submitting phase of the encoding process increases the overall encoding time. It is explained by the fact that the more fragmented the FLAC file is, the more time the submitting phase takes.\n\n\n\nFigure 5.3: Profiling of the flac2ogg service provider based on different number of workers. The input FLAC file has 194MB.\n\nFinally, the *actual-resp-time* line shows that when the number of workers is greater than five, the request response time starts to increase. Thus more than five workers are not worth to be used. In order to not require a great number of resources, the chosen number of workers to work with are two, three and four.\n\n### 5.3.3 QoS Table\n\nWhile the profiled data are used to enable the translation of response time, data concerning the translation of reliability is set statically. The Table 5.4 depicts the QoS table introduced in Section 3.3.1 (cf. Table 3.1) with the translation of each QoS metrics constraints. The translation of the response time constraints represent the number of workers and were set based on the previously chosen number of workers two, three and\nfour. The translation of the availability constraints were set statically and represent the replacement thresholds of the QoS assurance mechanisms.\n\n<table>\n<thead>\n<tr>\n<th>QoS Aspects</th>\n<th>Performance</th>\n<th>Fault-Tolerance</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Response Time</td>\n<td>Reliability</td>\n</tr>\n<tr>\n<td>Fast</td>\n<td>$\\tau(\\text{strong}) = 4$</td>\n<td>$\\tau(\\text{weak}) = (0, 0)$</td>\n</tr>\n<tr>\n<td>Safe</td>\n<td>$\\tau(\\text{weak}) = 2$</td>\n<td>$\\tau(\\text{strong}) = (1, 1)$</td>\n</tr>\n<tr>\n<td>Classic</td>\n<td>$\\tau(\\text{medium}) = 3$</td>\n<td>$\\tau(\\text{medium}) = (1, 0)$</td>\n</tr>\n<tr>\n<td>Standard</td>\n<td>$\\tau(\\text{weak}) = 2$</td>\n<td>$\\tau(\\text{weak}) = (0, 0)$</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.4: The QoS table used in Qu4DS evaluation whose QoS metrics are presented along with their respective translated system configurations. The translation of the response time means the number of workers while the translation of the reliability represents the replacement thresholds.\nEnvironment\nChapter 6\n\nEvaluation\n\nThis chapter discusses the evaluation of Qu4DS through empirical experimentation. First, the scenarios are introduced in Section 6.1 which explains how basis parameters, under-provisioning profiles and customer demand profiles are combined in order to create the scenarios. Section 6.2 then discusses the results. Note that this chapter refers to the Qu4DS current version 0.4. Previous results from earlier Qu4DS versions can be found in [FPP11] and [FPP10a].\n\n6.1 Scenarios\n\nThe general goal of the experimentation scenarios is to analyze the impact on the provider general profit when reducing infrastructure costs, rescinding contracts and preventing SLA violations (cf. Section 3.2). Qu4DS configuration should be driven by the service provider business goals, customer demand and infrastructure conditions; thus different configurations of Qu4DS, customer demand and execution environment are employed.\n\nUnder-provisioning is used as a capability of reducing infrastructure costs which indeed is a mean of increasing the provider profit by compromising QoS assurance. Hence under-provisioning involves a risk which may be worthwhile to consider in some situations. Therefore, another goal of the evaluation is to identify these worthy situations and measure the negative impact of under-provisioning when it should not be applied.\n\nWith respect to preventing SLA violations and rescinding contracts, two patches were added to Qu4DS which allows disabling the fault tolerance QoS assurance mechanism and contract rescissions. The former patch ignores the replacement threshold values by setting them to zero. The latter patch bypasses the accept operation described by Algorithm 4 in the flowchart illustrated by Figure 3.6 (cf. Section 3.5.1).\n\nIn order to address the experimentation objectives, Scenarios A, B and C were created as depicted by Table 6.1. The objectives of each scenario are described next.\n\nScenario A Focus on reducing infrastructure costs. The goal is to understand how under-provisioning profiles applied to the customer schedule profiles on different\nrequest loads impact on the profit.\n\n**Scenario B** Focus on rescinding contracts. The goal is to understand how various infrastructure capacities impact on the profit with and without contract rescission.\n\n**Scenario C** Focus on preventing SLA violations. The goal is to understand how different percentages of misbehaved jobs impact on the profit and analyze with and without the fault tolerance QoS assurance.\n\n<table>\n<thead>\n<tr>\n<th>Configuration</th>\n<th>Scenario A</th>\n<th>Scenario B</th>\n<th>Scenario C</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Customer profile</td>\n<td>fixed contract duration</td>\n<td>variable contract duration</td>\n<td>fixed contract duration</td>\n</tr>\n<tr>\n<td>Request load</td>\n<td>0.25, 0.50, 0.75, 1.00</td>\n<td>1.00</td>\n<td>1.00</td>\n</tr>\n<tr>\n<td>Under-prov. profile</td>\n<td>no-UP, UP-70, UP-50</td>\n<td>no-UP</td>\n<td>no-UP</td>\n</tr>\n<tr>\n<td>Infra. capacity</td>\n<td>100%</td>\n<td>100%, 75%, 50%</td>\n<td>100%</td>\n</tr>\n<tr>\n<td>Misbehaved jobs</td>\n<td>0%</td>\n<td>0%</td>\n<td>0%, 5%, 10%, 20%, 40%</td>\n</tr>\n<tr>\n<td>FT QoS assurance</td>\n<td>on</td>\n<td>on</td>\n<td>on, off</td>\n</tr>\n<tr>\n<td>Contract rescission</td>\n<td>on, off</td>\n<td>on</td>\n<td>on</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.1: The configurations used to create the Scenarios A, B and C.\n\nFurthermore, fine costs have a direct impact on the provider profit, hence it is important to let the experimentation scenarios rely on variable fine costs. Request abortion fines ($\\psi$) are defined based on the price requests cost to be treated while rescission fines ($\\Psi$) are defined based on the contract price in such a way that both fines depend on the $e_3$ and $e_4$ variables respectively (cf. Equation 4.3 in Section 4.2.2). Thus the relationship between fine costs and their commitments can be expressed based on different values of the $e_3$ and $e_4$ variables as presented next.\n\n- $e_3$ or $e_4$ **equals to 0.5** means that fines cost half the price of their commitments.\n- $e_3$ or $e_4$ **equals to 1.0** means that the fine costs the same price of their commitments.\n- $e_3$ or $e_4$ **equals to 2.0** means that the fine costs twice the price of their commitments.\n\n**6.2 Results**\n\nThe experiments were performed in the Rennes site of the Grid5000 [CCD+05] testbed grid. Specifically, the paraden cluster was used which holds nodes with eight 2.5GHz processors, 32GB RAM memory connected through a Gigabit network. Moreover, all graphics express the net general profit (cf. Equation 3.7) as a function of a given variable in the X-axis. Each dot plotted in the graphics represents a different experiment whose total duration is fifteen minutes.\n6.2.1 Scenario A\n\nThe evaluation results of the Scenario A are depicted by Figure 6.1. The Scenario A assumes that the infrastructure capacity is enough to satisfy the customer demand profiles. Moreover, it also assumes that there is no job misbehavior. On the other hand, there are three variable parameters. The former variable parameter is the request load $\\lambda'$ which is placed in the X-axis. The second and third variable parameters are drawn as curves: the under-provisioning profiles (no-UP, UP-70, UP-50) and the cost of the request abortion fine $\\psi$ which depends on different values of the $e_3$ constant.\n\n\n\nThe first general observation regarding the results of the Scenario A is that all the no-UP curves (full lines) approximatively are horizontal lines which means that the profit does not vary as the request load increases. This continuous profit happens because there is neither under-provisioning, nor SLA violations which would eventually increase or decrease the profit. Hence all the no-UP lines serve as a basis to know which profit is reached when no under-provisioning is applied. Moreover, different customer demand profiles have different continuous profit values as the price of the contract\ndepends on resource usage which varies according to the customer demand profile.\n\nOn the other hand, the **UP-70** and **UP-50** curves make the profit vary given a request load. Theoretically, the lower the under-provisioning factor is, the greater the profit is until the request load begins to be important enough to imply lack of resources owing to parallel request treatments. This behavior is an interesting aspect to observe in Scenario A in order to know in which situation a given under-provisioning factor is worth to be applied.\n\nIn general, the use of under-provisioning showed to be effective in increasing the service provider for these experiments. Both up-50 and up-70 under-provisioning profiles allowed increasing the profit if compared to the no-UP under-provisioning profile. However, the up-50 and up-70 under-provisioning profiles decrease as the fine cost increases. Moreover, up-50 decreases quicker than up-70 because up-50 represents a more aggressive under-provisioning profile which is more appropriated for low request loads. Thereby, up-50 reached greater profit when the request load is not high while up-70 enables to increase the profit in the average case. Therefore, it is more prudent to apply the up-70 under-provisioning profile for unknown request loads. In contrast, if a low request loads is expected, the up-50 under-provisioning profile allows increasing even more the profit.\n\nThe curve-crossing points indicate the request load which an under-provisioning profile is less effective than another under-provisioning profile. In Scenario A, by doubling the fine costs, i.e. $e_2 = 0.5, 1.0, 2.0$, anticipates the curve-crossing points in a inverse ratio approximatively, i.e., by halving the request loads of the curve-crossing points. Therefore, in order to maximize the provider profit in a situation similar to Scenario A, the up-50 under-provisioning profile should be used for values of $e_3$ around 0.5 approximately. Moreover, the up-70 under-provisioning profile showed to be an interesting configuration for the average case, i.e, it satisfactorily increased the profit for various request loads.\n\n### 6.2.2 Scenario B\n\nFigure 6.2 depicts the evaluation results of the Scenario B. The Scenario B assumes that there is no under-provisioning and it does not take into account job misbehaviors. Because rescinding contracts compares contract prices and fines, the Scenario B relies on customer demand profiles with variable contract durations by implying different contract prices even for contracts with the same label. With regard to the variable parameters, the first variable is the infrastructure capacity whose values are exposed in the X-axis. The second variable is the rescission fine ($\\Psi$) cost which varies according to different values of the $e_4$ constant. The last variable parameter refers to the contract rescission patch which was enabled and disabled for each experiment of Scenario B.\n\nThe advantage of this rescinding contracts is to allow the service provider to try to increase its profit even when the infrastructure cannot deliver no more resources. In this sense, the results depicted by Figure 6.2 show the profit being increased for almost all the results, cf. the full lines above the dashed lines.\n\nMoreover, as one can note, the profit grows as the infrastructure capacity increases.\nThis expected behavior is explained by the fact that the more resources can be acquired, the more contract will be established then increasing the profit.\n\nLastly, the greater the fine is, the less effective rescinding rescission is. Indeed, the configurations of the Scenario B implied Qu4DS similar behaviors when the rescission fine is the highest. Because high fine costs inhibits rescinding contracts, few contracts are rescinded when $e_4 = 2.0$ for instance. On the other hand, setting lower fine costs allows the rescinding capability to increase the profit, i.e., $e_4 = 0.5, 1.0$.\n\n### 6.2.3 Scenario C\n\nThe Figure 6.3 shows the results from Scenario C. The Scenario C relies on a execution environment where the infrastructure capacity is able to deliver all the required resources. It also assumes that the request load is $\\lambda' = 1.0$ based on a fixed contract duration. Moreover, there is no under-provisioning which means that the no-UP under-provisioning profile is applied. On the other hand, since the Scenario C evaluates Qu4DS effectiveness in preventing SLA violations, the job misbehavior rate is variable.\nIn addition, the FT QoS assurance patch is also variable; being only applied for the hybrid and high-FT customer demand profiles as high-RR does not include contract template labels that require fault tolerance. The last variable parameter is the request abortion fine ($\\psi$) whose costs are defined based on values of the $e_4$ constant.\n\nThe first general observation is that the greater the misbehavior rate is, the lower the profit is. This expected behavior happens because misbehaved jobs increases the chances of implying SLA violations. Regarding the customer demand profiles, the more it holds contract template labels which require fault tolerance capabilities, the more moderate the profit drops. For instance, the curves of the high-RR customer demand profile (i.e., no fault tolerance is required) decreases sharper than hybrid and high-FT profiles. Specifically, the high-FT profile was able to keep a moderate decrease of profit curves.\n\nSecondly, it is remarkable the difference between the profits when the FT QoS assurance is disabled. Qu4DS QoS assurance mechanism that addresses fault tolerance\nshowed to be effective for the configuration of Scenario C. All the full line curves are plotted above the dashed lines which means that disabling the QoS assurance mechanism negatively influences the profit.\n\nFinally, the greater the fine is, the sharper the profit decreases. An interesting aspect to note in the Scenario C is that Qu4DS QoS assurance mechanism showed to be effective even for great job misbehavior rates. For instance, when the job misbehavior rate is 40% (cf. Figure 6.3(c)), Qu4DS prevented the profit to reach negative values.\nPart V\n\nConclusion\nConclusion\n\nThis thesis addressed the problem of managing service execution in distributed infrastructures while meeting SLA constraints. SLA management functionalities are proposed which handle service negotiation, instantiation, provisioning and termination in an autonomous fashion. In addition, the thesis employs further management actions in order to increase the profit. These actions include rescinding contracts, reducing infrastructure costs and preventing SLA violations. This thesis also implements the Qu4DS framework which supports the development and management of services in distributed infrastructures. Moreover, experimental results in Grid5000 show Qu4DS effectiveness in maintaining SLAs while increasing the provider profit. The contributions of this thesis are explained in more detail next.\n\nContract Templates, SLA Translation, Pricing This thesis proposes a systematic approach for creating contract templates based on the combination of performance and fault tolerance aspects. Firstly, labels are used to ease the identification of each contract template based on its response time and reliability QoS metrics. Then, high-level QoS metrics constraints are translated to system-level configurations which allow enforcing specific QoS metrics values. Finally, contract templates are integrated with a pricing model which considers aspects concerning both the service provider and its underlying environment. Thereby, the way of how contract templates are created proposed by this thesis: (i) enables contract negotiation through contract templates identified by labels; (ii) translates SLA quality properties to system configuration; and (iii) enables the realization of runtime environment mechanisms driven by SLA objectives.\n\nQoS Assurance Mechanisms This thesis proposes two mechanisms which ensure the QoS properties described in the SLA. The first QoS assurance mechanism addresses performance by ensuring the response time QoS metrics. It relies on the translation of the response time QoS metrics to resource requirements able to meet the given response time. Then these resource requirements are used to acquire resources as well as to configure and deploy the service instance. The second QoS assurance mechanism deals with fault tolerance by ensuring the reliability QoS metrics. The fault tolerance QoS assurance mechanism replaces failed and delayed jobs based on the translation of the reliability QoS metrics to replacement thresholds. Therefore, this thesis proposes QoS assurance mechanisms which guarantee that both performance and fault tolerance\nQoS are ensured at runtime. As a consequence, SLA violations are prevented which contributes to increasing the provider profit.\n\n**Resource Acquisition and Allocation** This thesis proposes algorithms for handling resource acquisition and allocation which are driven by contract proposals and request arrivals respectively. Contract proposals trigger resource acquisition which is based on the resource requirements translated from response time QoS metrics. In order to increase the provider profit, this thesis applies under-provisioning by reducing the resource requirements. Moreover, if the infrastructure cannot deliver the required resources, current established contracts may be rescinded if this positively influences the general profit. With regard to resource allocation, upon a request arrival, resource availability is checked in order to decide whether the request will be carried on or aborted. If there are not enough resources available, the request to be aborted is chosen by aiming at minimizing the impact on the profit. As a result, this thesis automatically handles resource acquisition and allocation while applying techniques for profit increase in a transparent manner.\n\n**The Qu4DS Framework** This thesis describes the design and implementation of an autonomous framework which manages service execution driven by business-level objectives. The Qu4DS framework aims at the cloud PaaS layer by aiding the development of SaaS services on top of IaaS resource providers. On the one hand, the Qu4DS framework eases the development of Web Services by abstracting over distributed infrastructures. On the other hand, Qu4DS autonomously manages the service execution while increasing the service profit. In other words, Qu4DS deals with service negotiation, instantiation, provision and termination at runtime under business-oriented policies. These policies serve as high-level guidelines for under-provisioning, contract rescission, QoS assurance as well as pricing parameters. Moreover, the Qu4DS design enables extensibility in order to support further policies. In order to evaluate Qu4DS, experiments were carried out in Grid5000 based on different configurations and customer demands. The results confirm the effectiveness of Qu4DS in increasing the service provider profit while meeting SLAs terms.\n\n**Future Work: Short Term**\n\n**Scalability** The current implementation of the Qu4DS framework does not aim at scalability. It relies on a centralized design which makes it difficult to support increasing number of requests. When the number of concurrent requests increases, the Qu4DS workload also increases owing to the management of distributed tasks and their event handling. In order to address this issue, request management should be delegated to the deployed service instances in order to let Qu4DS focus on higher-level SLA management tasks. Thereby, customers would directly send requests to service instances which would be in charge of treating requests according to the agreed QoS. In order to implement such a design change, scalable peer-to-peer techniques may be used to address\nlocation and communication of distributed resources. Examples of such techniques include DHTs (Distributed Hash Tables) and unstructured peer-to-peer networks based on epidemic protocols.\n\n**Leveraging IaaS Cloud Capabilities** Currently, the Qu4DS framework relies on a single resource provider and it only considers horizontal elasticity as means for improving performance. With respect to elasticity, it profiles the service provider with various numbers of resources whose requirements are the same. It would be interesting to also exploit vertical elasticity features from clouds providers by also changing resource requirements (i.e., resource class) and not only the number of resources. Exploiting vertical elasticity allows implementing further QoS assurance mechanisms, and it eases adapting the Qu4DS load according to customer demand.\n\nRegarding different resource providers, future work may consider enabling Qu4DS to support various IaaS clouds by checking prices and negotiating contracts with them. This would allow overcoming resource shortages and the utilization of cheaper resource providers. In order to implement this solution, different IaaS clouds can be abstracted by using the common OCCI IaaS cloud interface \\[\\text{ME11}\\] or by using the Apache Libcloud API \\[\\text{ASF11}\\].\n\n**On-The-Fly Profiling** The profiling mechanism implemented by the Qu4DS framework profiles the service provider before provisioning. However, profiling data during provisioning is useful for calibrating Qu4DS according to unpredictable environment changes, e.g., network throughput degradation and unusual customer demands. An improvement to this issue is enabling Qu4DS to update the provider profiling while treating customer requests. As a consequence, current values of job execution times and actual request response times would be used to calculate the response time QoS metrics. Therefore, profiling the service provider on-the-fly allows adjusting QoS metrics to the current customer demand load.\n\n**Enable Renegotiation** The way that Qu4DS negotiates contracts can be performed in a more flexible manner by including renegotiation of established contracts. Supporting renegotiation allows adapting the service provisioning to environment changes without violating SLAs. In case of resource fluctuations, new contract proposals or changes on the provider business model, it may be preferable to try to renegotiate current SLA terms instead of rescinding contracts or aborting requests in order to increase the provider profit. In order to enable contract renegotiation, complete negotiation protocols should be considered as WS-Agreement \\[\\text{ACD}^+07\\]. For instance, the WSAG4J \\[\\text{Fra08}\\] WS-Agreement implementation can be used by creating Agreement Template documents along with their Guarantee Terms. In this case, the Business Value List would express how the fines are assessed while the Service Level Objective would express which QoS metrics should be met.\nAutomatic Under-Provisioning Configuration This thesis allows configuring service execution management based on the under-provisioning factor \\( upf \\), i.e., a percentage of the resource requirements. The proposed solution relies on a fixed value of \\( upf \\). A future research direction is to investigate the automatic adjustment of \\( upf \\) at runtime according to changes on infrastructure, service reputation, service business model and customer demand. This may require predicting the customer demand based on historical data which can be done by simple but effective methods such as exponentially weighted moving average (EWMA).\n\nFurther Perspectives\n\nQu4DS as a Service A future work may consider to completely decouple Qu4DS from the service provider. This requires investigating the relationship between Qu4DS and provider SLAs and profits. Regarding the SLA, the interaction between Qu4DS and the SaaS provider (e.g., the flac2ogg service provider) would be defined by another SLA which describes Qu4DS as a self-contained PaaS provider. Qu4DS obligations would include meeting QoS metrics constraints (i.e., strong, medium, weak) and applying the PaaS provider margin of profit \\( (\\pi) \\) and fine costs \\( (\\psi, \\Psi) \\). Thus Qu4DS would be in charge of QoS translation and profiling by transparently handling lower-level details related to the underlying infrastructure. With respect Qu4DS and provider profits, Qu4DS profit could rely on adjusting the under-provisioning factor based on its own business objectives. On the other hand, the under-provisioning factor could be described in the SLA in order to let it be part of the PaaS provider business objectives. However, this requires that Qu4DS profit come from its profit margin which would increase the price of the final service delivered to customers.\n\nReputation The way that this thesis handles service profit maximization does not consider the provider reputation. If the service provider business objectives includes long-term provisioning, then reputation plays an important role. Nevertheless, a solution which addresses concurrently profit and reputation interests should decide which aspect will be prioritized. Future work that addresses reputation but prioritizes profit can take advantage of this thesis. For instance, dependability can be improved by enhancing its QoS assurance mechanisms, e.g., supporting availability, resource failures, replication and so forth. Another example refers to the contract rescission policy which may be changed to a less aggressive policy or even be disabled. Moreover, the benefits for enhancing reputation should be quantified in order to define how reputation impacts the profit. Although it is not trivial to coherently map reputation aspects to monetary terms, provider business objectives should serve as guidelines for solutions that address this challenge. For instance, opportunist and intermittent service providers should attribute lower values for reputation when compared to providers which aim at long-term service provisioning.\nSupport for Composite Services Future work may consider supporting composite services, i.e., services which are composed of other services. This extends the scope of this thesis by enabling to address more complex service relationships in addition to the current SLAs that address customers and the underlying infrastructure. However, this implies dealing with multiple SLAs which increases the complexity of the SLA management. Firstly, future work concerning composite services should add to the negotiation phase further negotiations whose SLAs define the service provider role as provider and consumer. In addition, service instantiation and provisioning should be also driven by these previous SLAs. Secondly, the service provider should add to its pricing model more pricing parameters whose complexity make it harder to increase the provider profit. These challenges are difficult to address and are currently being studied in the context of BPEL (Business Process Execution Language) compositions, where services are composed according to SLA objectives.\n\nThird-Party Insurance Services The way in which this thesis addresses QoS assurance may be enhanced by considering third-party insurance services. The idea is to mimic conventional insurance companies by delegating to them fine payments. Thus, insurance services would cover eventual provider expenses, as fine payments, which imply losses. Insurance services can be added to the whole picture during the negotiation phase. Before booking resources for supporting the proposed contract, the service provider contacts the insurance service and tries to establish a contract which covers the losses for the contract proposal. If the insurance service accepts the contract, then the service provider acquires resources and deploys the service instance. Otherwise, the service provider should decide whether it will accept the contract proposal. In [LZL10], some issues about this subject are discussed.\n\nSupport Beyond Master/Worker Services Although the solution proposed by this thesis relies on service instances built according to the Master/Worker style, it can be extended to also support further kind of services. However, such a change may require redesigning QoS assurance mechanisms as well as monitoring metrics. For instance, in order to offer MapReduce support, the Qu4DS interface should add both map and reduce operations and the Qu4DS configuration should include details about the underlying distributed file system. In this context, a Qu4DS extension for MapReduce applications may take advantage of the Apache Hadoop framework and the Hadoop Distributed File System (HDFS). Thereby, QoS assurance would be dealt with by Hadoop built-in capabilities on top of HDFS; on the other hand, Qu4DS would address higher-level tasks regarding the SLA life-cycle management and pricing aspects.\n\nViolation of Resource Requirements Resource providers may fail to meet the resource requirements owing to different reasons, e.g., because of applying over-provisioning in order to increase their own profit. As a consequence, QoS assurance mechanisms at PaaS-level will be compromised since they rely on service provider profiling. A trivial solution for handling the violation of resource requirements consists of relying\nConclusion\n\non relaxed QoS metrics instead of QoS metrics with strict constraints. More efficient solutions require adding new assurance mechanisms. For instance, if any resource requirement change is perceived, resources could be replaced in order to try to prevent execution delay. Alternatively, resources could be booked from another IaaS provider, or the contracts could be renegotiated or terminated.\nAppendix A\n\nRequest Schedules\n\nThis appendix depicts the request schedules created by the customer generator for the customer demand profiles high-FT, hybrid, high-RR as depicted by Figures A.1, A.2 and A.3 respectively.\n\nEach customer demand profile holds five request schedules. The first four request schedules depicted by (a), (b), (c), (d) sub-figures represent the different request loads $\\lambda' = 1.00, 0.75, 0.50, 0.25$ whose contract durations were set to the whole experimentation duration. The last request schedule is depicted by the (e) sub-figures and represents a fixed request load $\\lambda' = 1.00$ with variable contract durations. Moreover, the first cross in the figures means the time in which customers start the negotiation; the second cross means the beginning of contract durations; and the last cross means the end of contract durations.\nFigure A.1: Request schedules of the high-FT customer demand profile.\nFigure A.2: Request schedules of the hybrid customer demand profile.\nFigure A.3: Request schedules of the **high-RR** customer demand profile.\nAppendix B\n\nPublications and Research Activities\n\nThe research activities carried out by this thesis were part of the European Community’s Seventh Framework Programme [FP7/2007-2013] under grant agreement 215483 (S-CUBE). During this thesis, various interactions with the scientific community were established which includes publications and collaboration. They are summarized next.\n\n- **International Conferences: Full Papers**\n\n- **International Workshop**\n\n- **International Conference: Poster**\n\n- **Technical Reports**\nPublications and Research Activities\n\n\n- Internship\n\n Informatics Center, Federal University of Pernambuco, Brazil. Research activities focused on the dynamic configuration of the QoS assurance mechanisms based on the translation of non-functional requirements.\nBibliography\n\n\n[DG10] Jeffrey Dean and Sanjay Ghemawat. System and method for efficient large-scale data processing, 2010. 27\n\n\n[Jos08] Jose Antonio Parejo and Pablo Fernandez and Antonio Ruiz-Cortés and José María García. SLAWs: Towards a Conceptual Architecture for SLA\n\n\nde Catalunya. Departament d’Arquitectura de Computadors, 2010. 25\n\n\nings of the 21st International Symposium on Algorithms and Computation (ISAAC), volume LNCS no XXXX, Jeju Island, Korea, Dec 2010. Springer Verlag. 28\n\n\n[UTU+08] Université Claude Bernard Lyon, TUW – Vienna University of Technology, UPM – Universidad Politécnica de Madrid, Polimi – Politecnico di Milano, INRIA – Institut National de Recherche en Informatique et Automatique, UniDue – University of Duisburg-Essen, FBK – Center for Scientific and Technological Research, SZTAKI – The Computer and Automation Research Institute, Hungarian Academy of Sciences, UOC –\n\n\nList of Figures\n\n1.1 Grid usage .................................................. 20\n1.2 Cloud architecture ......................................... 23\n\n3.1 Contract life-cycle ........................................... 37\n3.2 Request life-cycle ........................................... 38\n3.3 Job life-cycle ................................................ 38\n3.4 Actions for SLA management .............................. 40\n3.5 QoS assurance mechanism: response time ................ 46\n3.6 Flowchart of contract proposals ......................... 49\n3.7 Flowchart of request arrivals ............................. 50\n\n4.1 Qu4DS sequence diagram .................................. 60\n4.2 Qu4DS architecture ......................................... 64\n4.3 Qu4DS general sequence diagram ....................... 68\n4.4 Qu4DS usage ................................................ 70\n\n5.1 The flac2ogg service provider ............................. 76\n5.2 Qu4DS used to develop the flac2ogg provider ........... 78\n5.3 flac2ogg profiling .......................................... 82\n\n6.1 Results: Scenario A ........................................ 87\n6.2 Results: Scenario B ........................................ 89\n6.3 Results: Scenario C ........................................ 90\n\nA.1 high-FT request schedules ............................... 102\nA.2 hybrid request schedules ................................. 103\nA.3 high-RR request schedules ............................... 104\nList of Tables\n\n2.1 Related work ................................................. 30\n3.1 QoS table .................................................. 41\n5.1 Customer demand profiles .................................. 79\n5.2 Request schedules ........................................... 80\n5.3 Under-provisioning profiles .................................. 80\n5.4 Evaluation QoS table ....................................... 83\n6.1 Configurations of the Scenarios A, B and C .............. 86\nAbstract\n\nServices enable building loosely-coupled and dynamic applications in distributed environments. Service-Level Agreements (SLAs) are used to define service relationships by describing how services should behave. Moreover, SLAs include the Quality of Service (QoS) that should be delivered along with the service. However, managing service executions on top of distributed infrastructure while meeting agreed QoS is challenging. Firstly, QoS metrics should be mapped to low-level system configurations in order to enable building QoS assurance mechanisms. Secondly, service execution should deal with failures and load variations. In addition to these issues, service execution should be driven by pricing aspects since profit increase is an important concern for service providers. Current approaches that handle service execution support neither the whole SLA life-cycle nor profit augmentation.\n\nThis thesis proposes an autonomous solution for managing service execution in distributed infrastructures by aiming at increasing the provider profit. In particular, this thesis supports the full SLA life-cycle based on: (i) SLA translation under pricing constraints; (ii) mechanisms which ensure fault-tolerant and performance QoS; and (iii) resource acquisition and allocation driven by contract proposals and requests. In order to realize this solution, this thesis describes the design and implementation of the Qu4DS (Quality Assurance for Distributed Services) framework. Qu4DS includes a rich set of SLA management functionalities that provides a higher-level support for service developers. Moreover, Qu4DS is evaluated on top of Grid5000 and the results show that Qu4DS is able to increase the provider profit while meeting SLAs in different scenarios."}}},{"rowIdx":178,"cells":{"id":{"kind":"string","value":"055960846489e4b1970b91323bea9ba416f844f8"},"text":{"kind":"string","value":"How to Contact The MathWorks\n\nwww.mathworks.com Web\ncomp.soft-sys.matlab Newsgroup\nwww.mathworks.com/contact_TS.html Technical Support\n\n@\nsuggest@mathworks.com Product enhancement suggestions\nbugs@mathworks.com Bug reports\ndoc@mathworks.com Documentation error reports\nservice@mathworks.com Order status, license renewals, passcodes\ninfo@mathworks.com Sales, pricing, and general information\n\n508-647-7000 (Phone)\n\n508-647-7001 (Fax)\n\nThe MathWorks, Inc.\n3 Apple Hill Drive\nNatick, MA 01760-2098\n\nFor contact information about worldwide offices, see the MathWorks Web site.\n\n3-D Visualization\n\n\nThe software described in this document is furnished under a license agreement. The software may be used or copied only under the terms of the license agreement. No part of this manual may be photocopied or reproduced in any form without prior written consent from The MathWorks, Inc.\n\nFEDERAL ACQUISITION: This provision applies to all acquisitions of the Program and Documentation by, for, or through the federal government of the United States. By accepting delivery of the Program or Documentation, the government hereby agrees that this software or documentation qualifies as commercial computer software or commercial computer software documentation as such terms are used or defined in FAR 12.212, DFARS Part 227.72, and DFARS 252.227-7014. Accordingly, the terms and conditions of this Agreement and only those rights specified in this Agreement, shall pertain to and govern the use, modification, reproduction, release, performance, display, and disclosure of the Program and Documentation by the federal government (or other entity acquiring for or through the federal government) and shall supersede any conflicting contractual terms or conditions. If this License fails to meet the government’s needs or is inconsistent in any respect with federal procurement law, the government agrees to return the Program and Documentation, unused, to The MathWorks, Inc.\n\nTrademarks\n\nMATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, and xPC TargetBox are registered trademarks, and SimBiology, SimEvents, and SimHydraulics are trademarks of The MathWorks, Inc.\n\nOther product or brand names are trademarks or registered trademarks of their respective holders.\n\nPatents\n\nThe MathWorks products are protected by one or more U.S. patents. Please see www.mathworks.com/patents for more information.\n**Revision History**\n\n<table>\n<thead>\n<tr>\n<th>Date</th>\n<th>Version</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>March 2006</td>\n<td>Online only</td>\n<td>New for MATLAB 7.2 (Release 2006a)</td>\n</tr>\n<tr>\n<td>September 2006</td>\n<td>Online only</td>\n<td>Revised for MATLAB 7.3 (Release 2006b)</td>\n</tr>\n<tr>\n<td>March 2007</td>\n<td>Online only</td>\n<td>Revised for MATLAB 7.4 (Release 2007a)</td>\n</tr>\n</tbody>\n</table>\n\nThis publication was previously part of the Using MATLAB Graphics User Guide.\n## Creating 3-D Graphs\n\n### 1\n\n<table>\n<thead>\n<tr>\n<th>Topic</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A Typical 3-D Graph</td>\n<td>1-2</td>\n</tr>\n<tr>\n<td>Line Plots of 3-D Data</td>\n<td>1-4</td>\n</tr>\n<tr>\n<td>Plotting Matrix Data</td>\n<td>1-4</td>\n</tr>\n<tr>\n<td>Representing a Matrix as a Surface</td>\n<td>1-6</td>\n</tr>\n<tr>\n<td>Mesh and Surface Plots</td>\n<td>1-6</td>\n</tr>\n<tr>\n<td>Visualizing Functions of Two Variables</td>\n<td>1-7</td>\n</tr>\n<tr>\n<td>Surface Plots of Nonuniformly Sampled Data</td>\n<td>1-9</td>\n</tr>\n<tr>\n<td>Parametric Surfaces</td>\n<td>1-11</td>\n</tr>\n<tr>\n<td>Hidden Line Removal</td>\n<td>1-13</td>\n</tr>\n<tr>\n<td>Coloring Mesh and Surface Plots</td>\n<td>1-14</td>\n</tr>\n<tr>\n<td>Coloring Techniques</td>\n<td>1-14</td>\n</tr>\n<tr>\n<td>Types of Color Data</td>\n<td>1-15</td>\n</tr>\n<tr>\n<td>Colormaps</td>\n<td>1-15</td>\n</tr>\n<tr>\n<td>Indexed Color Surfaces — Direct and Scaled Color</td>\n<td>1-17</td>\n</tr>\n<tr>\n<td>Example — Mapping Surface Curvature to Color</td>\n<td>1-19</td>\n</tr>\n<tr>\n<td>Altering Colormaps</td>\n<td>1-20</td>\n</tr>\n<tr>\n<td>Truecolor Surfaces</td>\n<td>1-21</td>\n</tr>\n<tr>\n<td>Texture Mapping</td>\n<td>1-23</td>\n</tr>\n</tbody>\n</table>\n\n## Defining the View\n\n### 2\n\n<table>\n<thead>\n<tr>\n<th>Topic</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Viewing Overview</td>\n<td>2-3</td>\n</tr>\n<tr>\n<td>Positioning the Viewpoint</td>\n<td>2-3</td>\n</tr>\n<tr>\n<td>Setting the Aspect Ratio</td>\n<td>2-3</td>\n</tr>\n<tr>\n<td>Default Views</td>\n<td>2-4</td>\n</tr>\n</tbody>\n</table>\n## Setting the Viewpoint with Azimuth and Elevation ............................. 2-5\n Azimuth and Elevation ................................................. 2-5\n\n## Defining Scenes with Camera Graphics ...................................... 2-9\n\n## View Control with the Camera Toolbar ........................................ 2-10\n Camera Toolbar .................................................................. 2-10\n Camera Motion Controls .................................................. 2-13\n Orbit Camera .................................................................... 2-13\n Orbit Scene Light .......................................................... 2-15\n Pan/Tilt Camera .................................................................. 2-15\n Move Camera Horizontally/Vertically .................................... 2-16\n Move Camera Forward and Backward ..................................... 2-17\n Zoom Camera ..................................................................... 2-18\n Camera Roll ....................................................................... 2-19\n\n## Camera Graphics Functions ...................................................... 2-21\n\n## Example — Dollying the Camera ............................................... 2-22\n Summary of Techniques .................................................... 2-22\n Implementation .................................................................. 2-22\n\n## Example — Moving the Camera Through a Scene ......................... 2-24\n Summary of Techniques .................................................... 2-24\n Graphing the Volume Data ................................................... 2-25\n Setting Up the View .......................................................... 2-25\n Specifying the Light Source ............................................... 2-26\n Selecting a Renderer .......................................................... 2-26\n Defining the Camera Path as a Stream Line ............................ 2-26\n Implementing the Fly-Through ............................................. 2-27\n\n## Low-Level Camera Properties ................................................... 2-30\n Default Viewpoint Selection .............................................. 2-31\n Moving In and Out on the Scene ......................................... 2-31\n Making the Scene Larger or Smaller ..................................... 2-33\n Revolving Around the Scene .............................................. 2-34\n Rotation Without Resizing of Graphics Objects ....................... 2-34\n Rotation About the Viewing Axis ....................................... 2-34\n\n## View Projection Types .......................................................... 2-37\n Projection Types and Camera Location ................................... 2-38\nContents\n\n4\n\nTransparency\n\nMaking Objects Transparent ........................................... 4-2\nSpecifying Transparency ............................................. 4-3\n\nSpecifying a Single Transparency Value ........................... 4-6\nExample — Transparent Isosurface ................................ 4-6\n\nMapping Data to Transparency — Alpha Data ....................... 4-8\nSize of the Alpha Data Array ........................................ 4-9\nMapping Alpha Data to the Alphamap ................................. 4-9\nExample — Mapping Data to Color or Transparency ............ 4-10\n\nSelecting an Alphamap .................................................. 4-12\nExample — Modifying the Alphamap ................................ 4-14\n\n5\n\nCreating 3-D Models with Patches\n\nIntroduction to Patch Objects ......................................... 5-2\nDefining Patches ......................................................... 5-2\nBehavior of the patch Function ........................................ 5-3\nCreating a Single Polygon ............................................... 5-4\n\nMultifaceted Patches ...................................................... 5-7\nExample — Defining a Cube ............................................ 5-7\nModifying Patch Data .................................................... 5-10\n\nSpecifying Patch Coloring ............................................... 5-14\nPatch Color Properties .................................................. 5-14\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>Patch Edge Coloring</strong></td>\n<td>5-16</td>\n</tr>\n<tr>\n<td>Example — Specifying Flat Edge and Face Coloring</td>\n<td>5-16</td>\n</tr>\n<tr>\n<td>Coloring Edges with Shared Vertices</td>\n<td>5-17</td>\n</tr>\n<tr>\n<td><strong>Interpreting Indexed and Truecolor Data</strong></td>\n<td>5-19</td>\n</tr>\n<tr>\n<td>Indexed Color Data</td>\n<td>5-19</td>\n</tr>\n<tr>\n<td>Truecolor Patches</td>\n<td>5-22</td>\n</tr>\n<tr>\n<td>Interpolating in Indexed Color Versus Truecolor</td>\n<td>5-22</td>\n</tr>\n</tbody>\n</table>\n\n### Volume Visualization Techniques\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>Overview of Volume Visualization</strong></td>\n<td>6-3</td>\n</tr>\n<tr>\n<td>Examples of Volume Data</td>\n<td>6-3</td>\n</tr>\n<tr>\n<td>Selecting Visualization Techniques</td>\n<td>6-4</td>\n</tr>\n<tr>\n<td>Steps to Create a Volume Visualization</td>\n<td>6-4</td>\n</tr>\n<tr>\n<td><strong>Volume Visualization Functions</strong></td>\n<td>6-5</td>\n</tr>\n<tr>\n<td>Functions for Scalar Data</td>\n<td>6-5</td>\n</tr>\n<tr>\n<td>Functions for Vector Data</td>\n<td>6-6</td>\n</tr>\n<tr>\n<td><strong>Visualizing Scalar Volume Data</strong></td>\n<td>6-7</td>\n</tr>\n<tr>\n<td>Techniques for Visualizing Scalar Data</td>\n<td>6-7</td>\n</tr>\n<tr>\n<td><strong>Visualizing MRI Data</strong></td>\n<td>6-8</td>\n</tr>\n<tr>\n<td>Example — Ways to Display MRI Data</td>\n<td>6-8</td>\n</tr>\n<tr>\n<td><strong>Exploring Volumes with Slice Planes</strong></td>\n<td>6-14</td>\n</tr>\n<tr>\n<td>Example — Slicing Fluid Flow Data</td>\n<td>6-14</td>\n</tr>\n<tr>\n<td>Modifying the Color Mapping</td>\n<td>6-17</td>\n</tr>\n<tr>\n<td><strong>Connecting Equal Values with Isosurfaces</strong></td>\n<td>6-19</td>\n</tr>\n<tr>\n<td>Example — Isosurfaces in Fluid Flow Data</td>\n<td>6-19</td>\n</tr>\n<tr>\n<td><strong>Isocaps Add Context to Visualizations</strong></td>\n<td>6-21</td>\n</tr>\n<tr>\n<td>Other Isocap Applications</td>\n<td>6-22</td>\n</tr>\n<tr>\n<td>Defining Isocaps</td>\n<td>6-22</td>\n</tr>\n</tbody>\n</table>\nExample — Adding Isocaps to an Isosurface .......... 6-23\n\nVisualizing Vector Volume Data ....................... 6-26\n Using Scalar Techniques with Vector Data .......... 6-26\n Specifying Starting Points for Stream Plots .......... 6-27\n Accessing Subregions of Volume Data ............... 6-30\n\nStream Line Plots of Vector Data ..................... 6-32\n Example .......................................... 6-32\n\nDisplaying Curl with Stream Ribbons .................. 6-35\n Example .......................................... 6-35\n\nDisplaying Divergence with Stream Tubes ............... 6-38\n Example .......................................... 6-38\n\nCreating Stream Particle Animations ................... 6-41\n Example .......................................... 6-41\n\nVector Field Displayed with Cone Plots ................. 6-44\n Example .......................................... 6-44\n\nIndex\n## Creating 3-D Graphs\n\n<table>\n<thead>\n<tr>\n<th>Topic</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A Typical 3-D Graph (p. 1-2)</td>\n<td>The steps to follow to create a typical 3-D graph</td>\n</tr>\n<tr>\n<td>Line Plots of 3-D Data (p. 1-4)</td>\n<td>Line plots of data having x-, y-, and z-coordinates</td>\n</tr>\n<tr>\n<td>Representing a Matrix as a Surface (p. 1-6)</td>\n<td>Graphing matrix (2-D array) data on a rectangular grid</td>\n</tr>\n<tr>\n<td>Coloring Mesh and Surface Plots (p. 1-14)</td>\n<td>Techniques for coloring surface and mesh plots, including colormaps, truecolor, and texture mapping.</td>\n</tr>\n</tbody>\n</table>\n**A Typical 3-D Graph**\n\nThis table illustrates typical steps involved in producing 3-D scenes containing either data graphs or models of 3-D objects. Example applications include pseudocolor surfaces illustrating the values of functions over specific regions and objects drawn with polygons and colored with light sources to produce realism. Usually, you follow either step 4 or step 5.\n\n<table>\n<thead>\n<tr>\n<th>Step</th>\n<th>Typical Code</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1 Prepare your data.</td>\n<td>( Z = \\text{peaks}(20); )</td>\n</tr>\n<tr>\n<td>2 Select window and position plot region within window.</td>\n<td><code>figure(1) subplot(2,1,2)</code></td>\n</tr>\n<tr>\n<td>3 Call 3-D graphing function.</td>\n<td><code>h = \\text{surf}(Z);</code></td>\n</tr>\n</tbody>\n</table>\n| 4 Set colormap and shading algorithm. | `colormap hot` \n `shading interp` \n `set(h,'EdgeColor','k')` |\n<table>\n<thead>\n<tr>\n<th>Step</th>\n<th>Typical Code</th>\n</tr>\n</thead>\n</table>\n| 5 Add lighting. | `light('Position',[-2,2,20])` \n`lighting phong` \n`material([0.4,0.6,0.5,30])` \n`set(h,'FaceColor',[0.7 0.7 0],...)` \n`'BackFaceLighting','lit')` |\n| 6 Set viewpoint. | `view([30,25])` \n`set(gca,'CameraViewAngleMode','Manual')` |\n| 7 Set axis limits and tick marks. | `axis([5 15 5 15 -8 8])` \n`set(gca,'ZTickLabel','Negative||Positive')` |\n| 8 Set aspect ratio. | `set(gca,'PlotBoxAspectRatio',[2.5 2.5 1])` |\n| 9 Annotate the graph with axis labels, legend, and text. | `xlabel('X Axis')` \n`ylabel('Y Axis')` \n`zlabel('Function Value')` \n`title('Peaks')` |\n| 10 Print graph. | `set(gcf,'PaperPositionMode','auto')` \n`print -dps2` |\nLine Plots of 3-D Data\n\nThe 3-D analog of the `plot` function is `plot3`. If \\( x, y, \\) and \\( z \\) are three vectors of the same length,\n\n\\[\n\\text{plot3}(x,y,z)\n\\]\n\ngenerates a line in 3-D through the points whose coordinates are the elements of \\( x, y, \\) and \\( z \\) and then produces a 2-D projection of that line on the screen. For example, these statements produce a helix.\n\n\\[\nt = 0:\\pi/50:10*\\pi;\n\\]\n\\[\n\\text{plot3}(\\sin(t),\\cos(t),t);\n\\]\n\\[\n\\text{axis square; grid on}\n\\]\n\nPlotting Matrix Data\n\nIf the arguments to `plot3` are matrices of the same size, MATLAB® plots lines obtained from the columns of \\( X, Y, \\) and \\( Z \\). For example,\n\\[ X, Y ] = \\text{meshgrid}([-2:0.1:2]);\nZ = X.*exp(-X.^2-Y.^2);\n\\text{plot3}(X,Y,Z)\n\\text{grid on}\n\nNotice how MATLAB cycles through line colors.\nRepresenting a Matrix as a Surface\n\n- “Mesh and Surface Plots” on page 1-6\n- “Visualizing Functions of Two Variables” on page 1-7\n- “Surface Plots of Nonuniformly Sampled Data” on page 1-9\n- “Parametric Surfaces” on page 1-11\n- “Hidden Line Removal” on page 1-13\n\nMATLAB defines a surface by the \\( z \\)-coordinates of points above a rectangular grid in the \\( x \\)-\\( y \\) plane. The plot is formed by joining adjacent points with straight lines. Surface plots are useful for visualizing matrices that are too large to display in numerical form and for graphing functions of two variables.\n\nMATLAB can create different forms of surface plots. Mesh plots are wire-frame surfaces that color only the lines connecting the defining points. Surface plots display both the connecting lines and the faces of the surface in color. This table lists the various forms.\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Used to Create</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>mesh, surf</td>\n<td>Surface plot</td>\n</tr>\n<tr>\n<td>meshc, surfc</td>\n<td>Surface plot with contour plot beneath it</td>\n</tr>\n<tr>\n<td>meshz</td>\n<td>Surface plot with curtain plot (reference plane)</td>\n</tr>\n<tr>\n<td>pcolor</td>\n<td>Flat surface plot (value is proportional only to color)</td>\n</tr>\n<tr>\n<td>surfl</td>\n<td>Surface plot illuminated from specified direction</td>\n</tr>\n<tr>\n<td>surface</td>\n<td>Low-level function (on which high-level functions are based) for creating surface graphics objects</td>\n</tr>\n</tbody>\n</table>\n\nMesh and Surface Plots\n\nThe `mesh` and `surf` commands create 3-D surface plots of matrix data. If \\( Z \\) is a matrix for which the elements \\( Z(i,j) \\) define the height of a surface over an underlying \\((i,j)\\) grid, then\n\n\\[\n\\text{mesh}(Z)\n\\]\ngenerates a colored, wire-frame view of the surface and displays it in a 3-D view. Similarly,\n\n surf(Z)\n\ngenerates a colored, faceted view of the surface and displays it in a 3-D view. Ordinarily, the facets are quadrilaterals, each of which is a constant color, outlined with black mesh lines, but the shading command allows you to eliminate the mesh lines (shading flat) or to select interpolated shading across the facet (shading interp).\n\nSurface object properties provide additional control over the visual appearance of the surface. You can specify edge line styles, vertex markers, face coloring, lighting characteristics, and so on.\n\nVisualizing Functions of Two Variables\nThe first step in displaying a function of two variables, \\( z = f(x,y) \\), is to generate \\( X \\) and \\( Y \\) matrices consisting of repeated rows and columns, respectively, over the domain of the function. Then use these matrices to evaluate and graph the function.\n\nThe **meshgrid** function transforms the domain specified by two vectors, \\( x \\) and \\( y \\), into matrices \\( X \\) and \\( Y \\). You then use these matrices to evaluate functions of two variables. The rows of \\( X \\) are copies of the vector \\( x \\) and the columns of \\( Y \\) are copies of the vector \\( y \\).\n\nTo illustrate the use of **meshgrid**, consider the \\( \\frac{\\sin(r)}{r} \\) or sinc function. To evaluate this function between -8 and 8 in both \\( x \\) and \\( y \\), you need pass only one vector argument to **meshgrid**, which is then used in both directions.\n\n [X,Y] = meshgrid(-8:.5:8);\n R = sqrt(X.^2 + Y.^2) + eps;\n\nThe matrix \\( R \\) contains the distance from the center of the matrix, which is the origin. Adding \\( \\text{eps} \\) prevents the divide by zero (in the next step) that produces Inf values in the data.\n\nForming the sinc function and plotting \\( Z \\) with **mesh** results in the 3-D surface.\n\n Z = sin(R)./R;\nEmphasizing Surface Shape\n\nMATLAB provides a number of techniques that can enhance the information content of your graphs. For example, this graph of the sinc function uses the same data as the previous graph, but employs lighting and view adjustment to emphasize the shape of the graphed function (daspect, axis, view, camlight).\n\n```matlab\nsurf(X,Y,Z,'FaceColor','interp','EdgeColor','none','FaceLighting','phong')\ndaspect([5 5 1])\naxis tight\nview(-50,30)\ncamlight left\n```\nSee the \\texttt{surf} function for more information on surface plots.\n\n**Surface Plots of Nonuniformly Sampled Data**\n\nYou can use \\texttt{meshgrid} to create a grid of uniformly sampled data points at which to evaluate and graph the \\texttt{sinc} function. MATLAB then constructs the surface plot by connecting neighboring matrix elements to form a mesh of quadrilaterals.\n\nTo produce a surface plot from nonuniformly sampled data, first use \\texttt{griddata} to interpolate the values at uniformly spaced points, and then use \\texttt{mesh} and \\texttt{surf} in the usual way.\n\n**Example — Displaying Nonuniform Data on a Surface**\n\nThis example evaluates the \\texttt{sinc} function at random points within a specific range and then generates uniformly sampled data for display as a surface plot. The process involves these tasks:\n\n- Use \\texttt{linspace} to generate evenly spaced values over the range of your unevenly sampled data.\n- Use \\texttt{meshgrid} to generate the plotting grid with the output of \\texttt{linspace}. \n\n\n• Use `griddata` to interpolate the irregularly sampled data to the regularly spaced grid returned by `meshgrid`.\n\n• Use a plotting function to display the data.\n\n1 First, generate unevenly sampled data within the range [-8, 8] and use it to evaluate the function.\n\n```matlab\nx = rand(100,1)*16 - 8;\ny = rand(100,1)*16 - 8;\nr = sqrt(x.^2 + y.^2) + eps;\nz = sin(r)./r;\n```\n\n2 The `linspace` function provides a convenient way to create uniformly spaced data with the desired number of elements. The following statements produce vectors over the range of the random data with the same resolution as that generated by the -8:.5:8 statement in the previous `sinc` example.\n\n```matlab\nxlin = linspace(min(x),max(x),33);\nylin = linspace(min(y),max(y),33);\n```\n\n3 Now use these points to generate a uniformly spaced grid.\n\n```matlab\n[X,Y] = meshgrid(xlin,ylin);\n```\n\n4 The key to this process is to use `griddata` to interpolate the values of the function at the uniformly spaced points, based on the values of the function at the original data points (which are random in this example). This statement uses a triangle-based cubic interpolation to generate the new data.\n\n```matlab\nZ = griddata(x,y,z,X,Y,'cubic');\n```\n\n5 Plotting the interpolated and the nonuniform data produces\n\n```matlab\nmesh(X,Y,Z) %interpolated\naxis tight; hold on\nplot3(x,y,z,'.','MarkerSize',15) %nonuniform\n```\n**Parametric Surfaces**\n\nThe functions that draw surfaces can take two additional vector or matrix arguments to describe surfaces with specific $x$ and $y$ data. If $Z$ is an $m$-by-$n$ matrix, $x$ is an $n$-vector, and $y$ is an $m$-vector, then\n\n$$\\text{mesh}(x, y, Z, C)$$\n\ndescribes a mesh surface with vertices having color $C(i, j)$ and located at the points\n\n$$(x(j), y(i), Z(i, j))$$\n\nwhere $x$ corresponds to the columns of $Z$ and $y$ to its rows.\n\nMore generally, if $X$, $Y$, $Z$, and $C$ are matrices of the same dimensions, then\n\n$$\\text{mesh}(X, Y, Z, C)$$\n\ndescribes a mesh surface with vertices having color $C(i, j)$ and located at the points.\nCreating 3-D Graphs\n\nThis example uses spherical coordinates to draw a sphere and color it with the pattern of pluses and minuses in a Hadamard matrix, an orthogonal matrix used in signal processing coding theory. The vectors theta and phi are in the range \\(-\\pi \\leq \\theta \\leq \\pi\\) and \\(-\\pi/2 \\leq \\phi \\leq \\pi/2\\). Because \\(\\theta\\) is a row vector and \\(\\phi\\) is a column vector, the multiplications that produce the matrices \\(X\\), \\(Y\\), and \\(Z\\) are vector outer products.\n\n```matlab\nk = 5;\nn = 2^k-1;\ntheta = pi*(-n:2:n)/n;\nphi = (pi/2)*(-n:2:n)'/n;\nX = cos(phi)*cos(theta);\nY = cos(phi)*sin(theta);\nZ = sin(phi)*ones(size(theta));\ncolormap([0 0 0;1 1 1])\nC = hadamard(2^k);\nsurf(X,Y,Z,C)\naxis square\n```\n**Hidden Line Removal**\n\nBy default, MATLAB removes lines that are hidden from view in mesh plots, even though the faces of the plot are not colored. You can disable hidden line removal and allow the faces of a mesh plot to be transparent with the command\n\n```\nhidden off\n```\n\nThis is the surface plot with hidden set to off.\nColoring Mesh and Surface Plots\n\n- “Coloring Techniques” on page 1-14\n- “Types of Color Data” on page 1-15\n- “Colormaps” on page 1-15\n- “Indexed Color Surfaces — Direct and Scaled Color Mapping” on page 1-17\n- “Example — Mapping Surface Curvature to Color” on page 1-19\n- “Altering Colormaps” on page 1-20\n- “Truecolor Surfaces” on page 1-21\n- “Texture Mapping” on page 1-23\n\nYou can enhance the information content of surface plots by controlling the way MATLAB applies color to these plots. MATLAB can map particular data values to colors specified explicitly or can map the entire range of data to a predefined range of colors called a colormap.\n\nColoring Techniques\n\nThere are three coloring techniques:\n\n- Indexed Color -- MATLAB colors the surface plot by assigning each data point an index into the figure’s colormap. The way MATLAB applies these colors depends on the type of shading used (faceted, flat, or interpolated).\n\n- Truecolor — MATLAB colors the surface plot using the explicitly specified colors (i.e., the RGB triplets). The way MATLAB applies these colors depends on the type of shading used (faceted, flat, or interpolated). To be rendered accurately, truemcolor requires computers with 24-bit displays; however, MATLAB simulates truecolor on indexed systems. See the shading command for information on the types of shading.\n\n- Texture Mapping -- Texture mapping displays a 2-D image mapped onto a 3-D surface.\nTypes of Color Data\nThe type of color data you specify (i.e., single values or RGB triplets) determines how MATLAB interprets it. When you create a surface plot, you can\n\n- Provide no explicit color data, in which case MATLAB generates colormap indices from the \\( z \\)-data.\n- Specify an array of color data that is equal in size to the \\( z \\)-data and is used for indexed colors.\n- Specify an \\( m \\)-by-\\( n \\)-by-3 array of color data that defines an RGB triplet for each element in the \\( m \\)-by-\\( n \\) \\( z \\)-data array and is used for truecolor.\n\nColormaps\nEach MATLAB figure window has a colormap associated with it. A colormap is simply a three-column matrix whose length is equal to the number of colors it defines. Each row of the matrix defines a particular color by specifying three values in the range 0 to 1. These values define the RGB components (i.e., the intensities of the red, green, and blue video components).\n\nThe colormap function, with no arguments, returns the current figure’s colormap.\n\nFor example, the MATLAB default colormap contains 64 colors and the 57th color is red.\n\n\\[\n\\begin{align*}\n\\text{cm} & = \\text{colormap} ; \\\\\n\\text{cm}(57,:) & \\\\\n\\text{ans} & = \\\\\n& \\begin{bmatrix} 1 & 0 & 0 \\end{bmatrix}\n\\end{align*}\n\\]\n\nRGB Color Components\nThis table lists some representative RGB color definitions.\n<table>\n<thead>\n<tr>\n<th>Red</th>\n<th>Green</th>\n<th>Blue</th>\n<th>Color</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>Black</td>\n</tr>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>1</td>\n<td>White</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n<td>Red</td>\n</tr>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n<td>Green</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>1</td>\n<td>Blue</td>\n</tr>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n<td>Yellow</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>Magenta</td>\n</tr>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>1</td>\n<td>Cyan</td>\n</tr>\n<tr>\n<td>0.5</td>\n<td>0.5</td>\n<td>0.5</td>\n<td>Gray</td>\n</tr>\n<tr>\n<td>0.5</td>\n<td>0</td>\n<td>0</td>\n<td>Dark red</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0.62</td>\n<td>0.40</td>\n<td>Copper</td>\n</tr>\n<tr>\n<td>0.49</td>\n<td>1</td>\n<td>0.83</td>\n<td>Aquamarine</td>\n</tr>\n</tbody>\n</table>\n\nYou can create colormaps with MATLAB array operations or you can use any of several functions that generate useful maps, including `hsv`, `hot`, `cool`, `summer`, and `gray`. Each function has an optional parameter that specifies the number of rows in the resulting map.\n\nFor example,\n\n```matlab\nhot(m)\n```\n\ncreates an \\( m \\)-by-3 matrix whose rows specify the RGB intensities of a map that varies from black, through shades of red, orange, and yellow, to white.\n\nIf you do not specify the colormap length, MATLAB creates a colormap the same length as the current colormap. The default colormap is `jet(64)`.\n\nIf you use long colormaps (\\( > 64 \\) colors) in each of several figure windows, it might become necessary for the operating system to swap in different color lookup tables as the active focus is moved among the windows.\nDisplaying Colormaps\nThe `colorbar` function displays the current colormap, either vertically or horizontally, in the figure window along with your graph. For example, the statements\n\n\\[\n[x,y] = \\text{meshgrid([-2:.2:2])};\nZ = x.*\\exp(-x.^2-y.^2);\nsurf(x,y,Z,\\text{gradient}(Z))\ncolorbar\n\\]\n\nproduce a surface plot and a vertical strip of color corresponding to the colormap. Note how the colorbar indicates the mapping of data value to color with the axis labels.\n\nIndexed Color Surfaces — Direct and Scaled Color Mapping\nMATLAB can use two different methods to map indexed color data to the colormap — direct and scaled.\n**Direct Mapping**\n\nDirect mapping uses the color data directly as indices into the colormap. For example, a value of 1 points to the first color in the colormap, a value of 2 points to the second color, and so on. If the color data is noninteger, MATLAB rounds it toward zero. Values greater than the number of colors in the colormap are set equal to the last color in the colormap (i.e., the number length(colormap)). Values less than 1 are set to 1.\n\n**Scaled Mapping**\n\nScaled mapping uses a two-element vector \\([c_{\\text{min}} \\ c_{\\text{max}}]\\) (specified with the caxis command) to control the mapping of color data to the figure colormap. \\(c_{\\text{min}}\\) specifies the data value to map to the first color in the colormap and \\(c_{\\text{max}}\\) specifies the data value to map to the last color in the colormap. Data values in between are linearly transformed from the second to the next-to-last color, using the expression\n\n\\[\n\\text{colormap\\_index} = \\text{fix}((\\text{color\\_data}-c_{\\text{min}})/(c_{\\text{max}}-c_{\\text{min}})\\times\\text{cm\\_length})+1\n\\]\n\n\\(\\text{cm\\_length}\\) is the length of the colormap.\n\nBy default, MATLAB sets \\(c_{\\text{min}}\\) and \\(c_{\\text{max}}\\) to span the range of the color data of all graphics objects within the axes. However, you can set these limits to any range of values. This enables you to display multiple axes within a single figure window and use different portions of the figure's colormap for each one. See Calculating Color Limits in Axes Properties of the Using MATLAB Graphics documentation for an example that uses color limits.\n\nBy default, MATLAB uses scaled mapping. To use direct mapping, you must turn off scaling when you create the plot. For example,\n\n\\[\n\\text{surf}(Z,C,'\\text{CDataMapping}',\\text{'direct'})\n\\]\n\nSee surface for more information on specifying color data.\n\n**Specifying Indexed Colors**\n\nWhen creating a surface plot with a single matrix argument, \\texttt{surf}(Z) for example, the argument \\(Z\\) specifies both the height and the color of the surface. MATLAB transforms \\(Z\\) to obtain indices into the current colormap.\nWith two matrix arguments, the statement\n\n```\nsurf(Z,C)\n```\n\nindependently specifies the color using the second argument.\n\n**Example — Mapping Surface Curvature to Color**\n\nThe Laplacian of a surface plot is related to its curvature; it is positive for functions shaped like \\( i^2 + j^2 \\) and negative for functions shaped like \\(-i^2 + j^2\\). The function `del2` computes the discrete Laplacian of any matrix. For example, use `del2` to determine the color for the data returned by `peaks`.\n\n```\nP = peaks(40);\nC = del2(P);\nsurf(P,C)\ncolormap hot\n```\n\nCreating a color array by applying the Laplacian to the data is useful because it causes regions with similar curvature to be drawn in the same color.\nCompare this surface coloring with that produced by the statements\n\n```matlab\nsurf(P)\ncolormap hot\n```\n\nwhich use the same colormap, but map regions with similar $z$ value (height above the $x$-$y$ plane) to the same color.\n\n---\n\n**Altering Colormaps**\n\nBecause colormaps are matrices, you can manipulate them like other arrays. The `brighten` function takes advantage of this fact to increase or decrease the intensity of the colors. Plotting the values of the R, G, and B components of a colormap using `rgbplot` illustrates the effects of `brighten`. \n**NTSC Color Encoding**\n\nThe brightness component of television signals uses the NTSC color encoding scheme.\n\n\\[\nb = 0.30 \\cdot \\text{red} + 0.59 \\cdot \\text{green} + 0.11 \\cdot \\text{blue} \\\\\n= \\text{sum(diag([0.30 \\ 0.59 \\ 0.11])}\\cdot\\text{map\\}'\\}');\n\\]\n\nUsing the nonlinear greyscale map,\n\n\\[\n\\text{colormap([b b b])}\n\\]\n\neffectively converts a color image to its NTSC black-and-white equivalent.\n\n**Truecolor Surfaces**\n\nComputer systems with 24-bit displays are capable of displaying over 16 million \\(2^{24}\\) colors, as opposed to the 256 colors available on 8-bit displays. You can take advantage of this capability by defining color data directly as RGB values and eliminating the step of mapping numerical values to locations in a colormap.\n\nSpecify truecolor using an \\(m\\)-by-\\(n\\)-by-3 array, where the size of \\(Z\\) is \\(m\\)-by-\\(n\\).\nCreating 3-D Graphs\n\nFor example, the statements\n\n\\[\nZ = \\text{peaks}(25);\nC(:, :, 1) = \\text{rand}(25);\nC(:, :, 2) = \\text{rand}(25);\nC(:, :, 3) = \\text{rand}(25);\nsurf(Z, C)\n\\]\n\ncreate a plot of the peaks matrix with random coloring.\n\nYou can set surface properties as with indexed color.\n\n\\[\nsurf(Z, C, 'FaceColor', 'interp', 'FaceLighting', 'phong')\ncamlight right\n\\]\nRendering Methods for Truecolor\nMATLAB always uses either OpenGL or the Z-buffer rendering method when displaying truecolor. If the figure RendererMode property is set to auto, MATLAB automatically switches the value of the Renderer property to zbuffer whenever you specify truecolor data.\n\nIf you explicitly set Renderer to painters (this sets RendererMode to manual) and attempt to define an image, patch, or surface object using truecolor, MATLAB returns a warning and does not render the object.\n\nSee the image, patch, and surface functions for information on defining truecolor for these objects.\n\nTexture Mapping\nTexture mapping is a technique for mapping a 2-D image onto a 3-D surface by transforming color data so that it conforms to the surface plot. It allows you to apply a \"texture,\" such as bumps or wood grain, to a surface without performing the geometric modeling necessary to create a surface with these features. The color data can also be any image, such as a scanned photograph.\n\nTexture mapping allows the dimensions of the color data array to be different from the data defining the surface plot. You can apply an image of arbitrary\nCreating 3-D Graphs\n\nsize to any surface. MATLAB interpolates texture color data so that it is\nmapped to the entire surface.\n\n**Example — Texture Mapping a Surface**\n\nThis example creates a spherical surface using the `sphere` function and\ntexture maps it with an image of the earth taken from space. Because the\nearth image is a view of earth from one side, this example maps the image to\nonly one side of the sphere, padding the image data with 1s. In this case, the\nimage data is a 257-by-250 matrix, so it is padded equally on each side with\ntwo 257-by-125 matrices of 1s by concatenating the three matrices.\n\nTo use texture mapping, set the `FaceColor` to `texturemap` and assign the\nimage to the surface’s `CData`.\n\n```matlab\nload earth % Load image data, X, and colormap, map\nsphere; h = findobj('Type','surface');\nhemisphere = [ones(257,125),...\n X,...\n ones(257,125)];\nset(h,'CData',flipud(hemisphere),'FaceColor','texturemap')\ncolormap(map)\naxis equal\nview([90 0])\nset(gca,'CameraViewAngleMode','manual')\nview([65 30])\n```\nCreating 3-D Graphs\nDefining the View\n\nViewing Overview (p. 2-3) Overview of topics covered in this chapter\n\nSetting the Viewpoint with Azimuth and Elevation (p. 2-5) Using the simple azimuth and elevation view model to define the viewpoint, including definition and examples\n\nDefining Scenes with Camera Graphics (p. 2-9) Using the camera view model to control 3-D scenes (illustration defines terms)\n\nView Control with the Camera Toolbar (p. 2-10) Camera tools for manipulating 3-D scenes\n\nCamera Graphics Functions (p. 2-21) Functions that control the camera view model\n\nExample — Dollying the Camera (p. 2-22) Example showing how to reposition a scene when the user clicks over an image\n\nExample — Moving the Camera Through a Scene (p. 2-24) Example showing how to move a camera through a scene along a path traced by a stream line and showing how to move a light source with the camera\n\nLow-Level Camera Properties (p. 2-30) Description of the graphic object properties that control the camera\n<table>\n<thead>\n<tr>\n<th>Topic</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>View Projection Types (p. 2-37)</td>\n<td>Orthographic and perspective project types compared and illustrated and the interaction between camera properties and projection type</td>\n</tr>\n<tr>\n<td>Understanding Axes Aspect Ratio (p. 2-42)</td>\n<td>How MATLAB determines the axes aspect ratio for graphs and how you can specify aspect ratio</td>\n</tr>\n<tr>\n<td>Axes Aspect Ratio Properties (p. 2-47)</td>\n<td>Axes properties that control the aspect ratio and how to set them to achieve particular results</td>\n</tr>\n</tbody>\n</table>\nViewing Overview\n\nThe view is the particular orientation you select to display your graph or graphical scene. The term viewing refers to the process of displaying a graphical scene from various directions, zooming in or out, changing the perspective and aspect ratio, flying by, and so on.\n\nThis section describes how to define the various viewing parameters to obtain the view you want. Generally, viewing is applied to 3-D graphs or models, although you might want to adjust the aspect ratio of 2-D views to achieve specific proportions or make a graph fit in a particular shape.\n\nMATLAB viewing is composed of two basic areas:\n\n- Positioning the viewpoint to orient the scene\n- Setting the aspect ratio and relative axis scaling to control the shape of the objects being displayed\n\nPositioning the Viewpoint\n\n- Setting the Viewpoint -- Discusses how to specify the point from which you view a graph in terms of azimuth and elevation. This is conceptually simple, but does have limitations.\n- Defining Scenes with Camera Graphics, View Control with the Camera Toolbar, and Camera Graphics Functions — How to compose complex scenes using the MATLAB camera viewing model.\n- Dollying the Camera and Moving the Camera Through a Scene -- Programming techniques for moving the view around and through scenes.\n- Low-Level Camera Properties — The graphics properties that control the camera and illustrates the effects they cause.\n\nSetting the Aspect Ratio\n\n- View Projection Types -- Describes orthographic and perspective projection types and illustrates their use.\n• Understanding Axes Aspect Ratio and Axes Aspect Ratio Properties — How MATLAB sets the aspect ratio of the axes and how you can select the most appropriate setting for your graphs.\n\nDefault Views\nMATLAB automatically sets the view when you create a graph. The actual view that MATLAB selects depends on whether you are creating a 2- or 3-D graph. See “Default Viewpoint Selection” on page 2-31 and “Default Aspect Ratio Selection” on page 2-48 for a description of how MATLAB defines the standard view.\nSetting the Viewpoint with Azimuth and Elevation\n\nMATLAB enables you to control the orientation of the graphics displayed in an axes. You can specify the viewpoint, view target, orientation, and extent of the view displayed in a figure window. These viewing characteristics are controlled by a set of graphics properties. You can specify values for these properties directly or you can use the `view` command and rely on MATLAB automatic property selection to define a reasonable view.\n\nAzimuth and Elevation\n\nThe `view` command specifies the viewpoint by defining azimuth and elevation with respect to the axis origin. Azimuth is a polar angle in the $x$-$y$ plane, with positive angles indicating counterclockwise rotation of the viewpoint. Elevation is the angle above (positive angle) or below (negative angle) the $x$-$y$ plane.\n\nThis diagram illustrates the coordinate system. The arrows indicate positive directions.\n\nDefault 2-D and 3-D Views\n\nMATLAB automatically selects a viewpoint that is determined by whether the plot is 2-D or 3-D:\nFor 2-D plots, the default is azimuth = 0° and elevation = 90°.\n\nFor 3-D plots, the default is azimuth = -37.5° and elevation = 30°.\n\nExamples of Views Specified with Azimuth and Elevation\n\nFor example, these statements create a 3-D surface plot and display it in the default 3-D view.\n\n\\[\n[X,Y] = \\text{meshgrid([-2:.25:2])};\nZ = X.*\\exp(-X.^2 -Y.^2);\nsurf(X,Y,Z)\n\\]\n\nThe statement\n\n\\[\\text{view([180 0])}\\]\n\nsets the viewpoint so you are looking in the negative y-direction with your eye at the z = 0 elevation.\nYou can move the viewpoint to a location below the axis origin using a negative elevation.\n\nview([-37.5, -30])\n\nAzimuth = -37.5° Elevation = -30°\nLimitations of Azimuth and Elevation\n\nSpecifying the viewpoint in terms of azimuth and elevation is conceptually simple, but it has limitations. It does not allow you to specify the actual position of the viewpoint, just its direction, and the z-axis is always pointing up. It does not allow you to zoom in and out on the scene or perform arbitrary rotations and translations.\n\nMATLAB camera graphics provides greater control than the simple adjustments allowed with azimuth and elevation. The following sections discuss how to use camera properties to control the view.\nDefining Scenes with Camera Graphics\n\nWhen you look at the graphics objects displayed in an axes, you are viewing a scene from a particular location in space that has a particular orientation with regard to the scene. MATLAB provides functionality, analogous to that of a camera with a zoom lens, that enables you to control the view of the scene created by MATLAB.\n\nThis picture illustrates how the camera is defined in terms of properties of the axes.\nView Control with the Camera Toolbar\n\n- “Camera Toolbar” on page 2-10\n- “Camera Motion Controls” on page 2-13\n- “Orbit Camera” on page 2-13\n- “Orbit Scene Light” on page 2-15\n- “Pan/Tilt Camera” on page 2-15\n- “Move Camera Horizontally/Vertically” on page 2-16\n- “Move Camera Forward and Backward” on page 2-17\n- “Zoom Camera” on page 2-18\n- “Camera Roll” on page 2-19\n\nThe Camera toolbar enables you to perform a number of viewing operations interactively. To use the Camera toolbar,\n\n- Display the toolbar by selecting Camera Toolbar from the figure window’s View menu.\n- Select the type of camera motion control you want to use.\n- Position the cursor over the figure window and click, hold down the right mouse button, then move the cursor in the desired direction.\n\nMATLAB updates the display immediately as you move the mouse.\n\nCamera Toolbar\nThe toolbar contains the following parts:\n• Camera Motion Controls — These tools select which camera motion function to enable. You can also access the camera motion controls from the **Tools** menu.\n\n• Principal Axis Selector — Some camera controls operate with respect to a particular axis. These selectors enable you to select the principal axis or to select nonaxis constrained motion. The selectors are grayed out when not applicable to the currently selected function. You can also access the principal axis selector from the **Tools** menu.\n\n• Scene Light — The scene light button toggles a light source on or off in the scene (one light per axes).\n\n• Projection Type — You can select orthographic or perspective projection types.\n\n• Reset and Stop — Reset returns the scene to the standard 3-D view. Stop causes the camera to stop moving (this can be useful if you apply too much cursor movement). You can also access an expanded set of reset functions from the **Tools** menu.\n\n**Principal Axes**\n\nThe principal axis of a scene defines the direction that is oriented upward on the screen. For example, a MATLAB surface plot aligns the up direction along the positive \\( z \\)-axis.\n\nPrincipal axes constrain camera-tool motion along axes that are (on the screen) parallel and perpendicular to the principal axis that you select. Specifying a principal axis is useful if your data is defined with respect to a specific axis. \\( Z \\) is the default principal axis, because this matches the MATLAB default 3-D view.\n\nTwo of the camera tools (Orbit and Pan/Tilt) allow you to select a principal axis as well as axis-free motion. On the screen, the axes of rotation are determined by a vertical and a horizontal line, both of which pass through the point defined by the **CameraTarget** property and are parallel and perpendicular to the principal axis.\n\nFor example, when the principal axis is \\( z \\), movement occurs about\n• A vertical line that passes through the camera target and is parallel to the z-axis\n\n• A horizontal line that passes through the camera target and is perpendicular to the z-axis\n\nThis means the scene (or camera, as the case may be) moves in an arc whose center is at the camera target. The following picture illustrates the rotation axes for a z principal axis.\n\nThe axes of rotation always pass through the camera target.\n\n**Optimizing for 3-D Camera Motion**\n\nWhen you create a plot, MATLAB displays it with an aspect ratio that fits the figure window. This behavior might not create an optimum situation for the manipulation of 3-D graphics, as it can lead to distortion as you move the camera around the scene. To avoid possible distortion, it is best to switch to a 3-D visualization mode (enabled from the command line with the command\naxis vis3d). When using the Camera toolbar, MATLAB automatically switches to the 3-D visualization mode, but warns you first with the following dialog box.\n\nThis dialog box appears only once per MATLAB session.\n\nFor more information about the underlying effects of related camera properties, see “Understanding Axes Aspect Ratio” on page 2-42. The next section, “Camera Motion Controls” on page 2-13, discusses how to use each tool.\n\n**Camera Motion Controls**\n\nThis section discusses the individual camera motion functions selectable from the toolbar.\n\n*Note* When interpreting the following diagrams, keep in mind that the camera always points towards the camera target. See “Defining Scenes with Camera Graphics” on page 2-9 for an illustration of the graphics properties involved in camera motion.\n\n**Orbit Camera**\nOrbit Camera rotates the camera about the z-axis (by default). You can select $x$-, $y$-, $z$-, or free-axis rotation using the Principal Axis Selectors. When using no principal axis, you can rotate about an arbitrary axis.\n\n**Graphics Properties**\n\nOrbit Camera changes the CameraPosition property while keeping the CameraTarget fixed.\n**Orbit Scene Light**\n\nThe scene light is a light source that is placed with respect to the camera position. By default, the scene light is positioned to the right of the camera (i.e., `camlight right`). Orbit Scene Light changes the light’s offset from the camera position. There is only one scene light; however, you can add other lights using the `light` command.\n\nToggle the scene light on and off by clicking the yellow light bulb icon.\n\n**Graphics Properties**\n\nOrbit Scene Light moves the scene light by changing the light’s Position property.\n\n**Pan/Tilt Camera**\n\nPan/Tilt Camera moves the point in the scene that the camera points to while keeping the camera fixed. The movement occurs in an arc about the \\(z\\)-axis by default. You can select \\(x\\)-, \\(y\\)-, \\(z\\)-, or free-axis rotation using the Principal Axes Selectors.\n\n**Graphics Properties**\n\nPan/Tilt Camera moves the point in the scene that the camera is pointing to by changing the CameraTarget property.\nDefining the View\n\nMove Camera Horizontally/Vertically\n\nMoving the cursor horizontally or vertically (or any combination of the two) moves the scene in the same direction.\n\nGraphics Properties\n\nThe horizontal and vertical movement is achieved by moving the CameraPosition and the CameraTarget in unison along parallel lines.\nMove Camera Forward and Backward\n\nMoving the cursor up or to the right moves the camera toward the scene. Moving the cursor down or to the left moves the camera away from the scene. It is possible to move the camera through objects in the scene and to the other side of the camera target.\n\nGraphics Properties\n\nThis function moves the CameraPosition along the line connecting the camera position and the camera target.\nZoom Camera\n\nZoom Camera makes the scene larger as you move the cursor up or to the right and smaller as you move the cursor down or to the left. Zooming does not move the camera and therefore cannot move the viewpoint through objects in the scene.\n\nGraphics Properties\nZoom is implemented by changing the CameraViewAngle. The larger the angle, the smaller the scene appears, and vice versa.\n**Camera Roll**\n\nCamera Roll rotates the camera about the viewing axis, thereby rotating the view on the screen.\n\n**Graphics Properties**\n\nCamera Roll changes the CameraUpVector.\nDefining the View\n\nCursor Motion\n\n- Counterclockwise around camera target\n- Clockwise around camera target\nCamera Graphics Functions\n\nThe following table lists MATLAB functions that enable you to perform a number of useful camera maneuvers. The individual command descriptions provide information on using each one.\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>camdolly</td>\n<td>Move camera position and target</td>\n</tr>\n<tr>\n<td>camlookat</td>\n<td>View specific objects</td>\n</tr>\n<tr>\n<td>camorbit</td>\n<td>Orbit the camera about the camera target</td>\n</tr>\n<tr>\n<td>campan</td>\n<td>Rotate the camera target about the camera position</td>\n</tr>\n<tr>\n<td>campos</td>\n<td>Set or get the camera position</td>\n</tr>\n<tr>\n<td>camproj</td>\n<td>Set or get the projection type (orthographic or perspective)</td>\n</tr>\n<tr>\n<td>camroll</td>\n<td>Rotate the camera about the viewing axis</td>\n</tr>\n<tr>\n<td>camtarget</td>\n<td>Set or get the camera target location</td>\n</tr>\n<tr>\n<td>camup</td>\n<td>Set or get the value of the camera up vector</td>\n</tr>\n<tr>\n<td>camva</td>\n<td>Set or get the value of the camera view angle</td>\n</tr>\n<tr>\n<td>camzoom</td>\n<td>Zoom the camera in or out on the scene</td>\n</tr>\n</tbody>\n</table>\nExample – Dollying the Camera\n\nIn the camera metaphor, a dolly is a stage that enables movement of the camera from side to side with respect to the scene. The camdolly command implements similar behavior by moving both the position of the camera and the position of the camera target in unison (or just the camera position if you so desire).\n\nThis example illustrates how to use camdolly to explore different regions of an image.\n\nSummary of Techniques\n\nThis example uses\n\n- `ginput` to obtain the coordinates of locations on the image\n- The `camdolly data coordinates` option to move the camera and target to the new position based on coordinates obtained from `ginput`\n- `camva` to zoom in and to fix the camera view angle, which is otherwise under automatic control\n\nImplementation\n\nFirst load the Cape Cod image and zoom in by setting the camera view angle (using `camva`).\n\n```matlab\nload cape\nimage(X)\ncolormap(map)\naxis image\ncamva(camva/2.5)\n```\n\nThen use `ginput` to select the x- and y-coordinates of the camera target and camera position.\n\n```matlab\nwhile 1\n [x,y] = ginput(1);\n if ~strcmp(get(gcf,'SelectionType'),'normal')\n break\n end\n```\nct = camtarget;\ndx = x - ct(1);\ndy = y - ct(2);\ncamdolly(dx,dy,ct(3),'movetarget','data')\ndrawnow\nend\nExample — Moving the Camera Through a Scene\n\n- “Summary of Techniques” on page 2-24\n- “Graphing the Volume Data” on page 2-25\n- “Setting Up the View” on page 2-25\n- “Specifying the Light Source” on page 2-26\n- “Selecting a Renderer” on page 2-26\n- “Defining the Camera Path as a Stream Line” on page 2-26\n- “Implementing the Fly-Through” on page 2-27\n\nA fly-through is an effect created by moving the camera through three-dimensional space, giving the impression that you are flying along with the camera as if in an aircraft. You can fly through regions of a scene that might be otherwise obscured by objects in the scene or you can fly by a scene by keeping the camera focused on a particular point.\n\nTo accomplish these effects you move the camera along a particular path, the $x$-axis for example, in a series of steps. To produce a fly-through, move both the camera position and the camera target at the same time.\n\nThe following example makes use of the fly-through effect to view the interior of an isosurface drawn within a volume defined by a vector field of wind velocities. This data represents air currents over North America.\n\nSee `coneplot` for a fixed visualization of the same data.\n\nSummary of Techniques\n\nThis example employs a number of visualization techniques. It uses\n\n- Isosurfaces and cone plots to illustrate the flow through the volume\n- Lighting to illuminate the isosurface and cones in the volume\n- Stream lines to define a path for the camera through the volume\n- Coordinated motion of the camera position, camera target, and light\nGraphing the Volume Data\nThe first step is to draw the isosurface and plot the air flow using cone plots.\n\nSee isosurface, isonormals, reducepatch, and coneplot for information on using these commands.\n\nSetting the data aspect ratio (daspect) to \\([1,1,1]\\) before drawing the cone plot enables MATLAB to calculate the size of the cones correctly for the final view.\n\n```matlab\nload wind\nwind_speed = sqrt(u.^2 + v.^2 + w.^2);\n\nhpatch = patch(isosurface(x,y,z,wind_speed,35));\nisonormals(x,y,z,wind_speed,hpatch)\nset(hpatch,'FaceColor','red','EdgeColor','none');\n\n[f vt] = reducepatch(isosurface(x,y,z,wind_speed,45),0.05);\ndaspect([1,1,1]);\nhcone = coneplot(x,y,z,u,v,w,vt(:,1),vt(:,2),vt(:,3),2);\nset(hcone,'FaceColor','blue','EdgeColor','none');\n```\n\nSetting Up the View\nYou need to define viewing parameters to ensure the scene is displayed correctly:\n\n- Selecting a perspective projection provides the perception of depth as the camera passes through the interior of the isosurface (camproj).\n- Setting the camera view angle to a fixed value prevents MATLAB from automatically adjusting the angle to encompass the entire scene as well as zooming in the desired amount (camva).\n\n```matlab\ncamproj perspective\ncamva(25)\n```\nSpecifying the Light Source\nPositioning the light source at the camera location and modifying the reflectance characteristics of the isosurface and cones enhances the realism of the scene:\n\n- Creating a light source at the camera position provides a \"headlight\" that moves along with the camera through the isosurface interior (camlight).\n- Setting the reflection properties of the isosurface gives the appearance of a dark interior (AmbientStrength set to 0.1) with highly reflective material (SpecularStrength and DiffuseStrength set to 1).\n- Setting the SpecularStrength of the cones to 1 makes them highly reflective.\n\n```matlab\nhlight = camlight('headlight');\nset(hpatch,'AmbientStrength',.1,...\n 'SpecularStrength',1,...\n 'DiffuseStrength',1);\nset(hcone,'SpecularStrength',1);\nset(gcf,'Color','k')\n```\n\nSelecting a Renderer\nBecause this example uses lighting, MATLAB must use either zbuffer or, if available, OpenGL renderer settings. The OpenGL renderer is likely to be much faster displaying the animation; however, you need to use gouraud lighting with OpenGL, which is not as smooth as Phong lighting, which you can use with the zbuffer renderer. The two choices are\n\n```matlab\nlighting gouraud\nset(gcf,'Renderer','OpenGL')\n```\n\nor for zbuffer\n\n```matlab\nlighting phong\nset(gcf,'Renderer','zbuffer')\n```\n\nDefining the Camera Path as a Stream Line\nStream lines indicate the direction of flow in the vector field. This example uses the x-, y-, and z-coordinate data of a single stream line to map a path\nthrough the volume. The camera is then moved along this path. The tasks include\n\n- Create a stream line starting at the point $x = 80, y = 30, z = 11$.\n- Get the $x$-, $y$-, and $z$-coordinate data of the stream line.\n- Delete the stream line (note that you could also use `stream3` to calculate the stream line data without actually drawing the stream line).\n\n```matlab\nhsline = streamline(x,y,z,u,v,w,80,30,11);\nxd = get(hsline,'XData');\nyd = get(hsline,'YData');\nzd = get(hsline,'ZData');\ndelete(hsline)\n```\n\n### Implementing the Fly-Through\n\nTo create a fly-through, move the camera position and camera target along the same path. In this example, the camera target is placed five elements further along the $x$-axis than the camera. A small value is added to the camera target $x$ position to prevent the position of the camera and target from becoming the same point if the condition $xd(n) = xd(n+5)$ should occur:\n\n- Update the camera position and camera target so that they both move along the coordinates of the stream line.\n- Move the light along with the camera.\n- Call `drawnow` to display the results of each move.\n\n```matlab\nfor i=1:length(xd)-50\n campos([xd(i),yd(i),zd(i)])\n camtarget([xd(i+5)+min(xd)/100,yd(i),zd(i)])\n camlight(hlight,'headlight')\n drawnow\nend\n```\n\nThese snapshots illustrate the view at values of $i$ equal to 10, 110, and 185.\nLow-Level Camera Properties\n\n- “Default Viewpoint Selection” on page 2-31\n- “Moving In and Out on the Scene” on page 2-31\n- “Making the Scene Larger or Smaller” on page 2-33\n- “Revolving Around the Scene” on page 2-34\n- “Rotation Without Resizing of Graphics Objects” on page 2-34\n- “Rotation About the Viewing Axis” on page 2-34\n\nCamera graphics is based on a group of axes properties that control the position and orientation of the camera. In general, the camera commands make it unnecessary to access these properties directly.\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>CameraPosition</td>\n<td>Specifies the location of the viewpoint in axes units.</td>\n</tr>\n<tr>\n<td>CameraPositionMode</td>\n<td>In automatic mode, MATLAB determines the position based on the scene. In manual mode, you specify the viewpoint location.</td>\n</tr>\n<tr>\n<td>CameraTarget</td>\n<td>Specifies the location in the axes pointed to by the camera. Together with the CameraPosition, it defines the viewing axis.</td>\n</tr>\n<tr>\n<td>CameraTargetMode</td>\n<td>In automatic mode, MATLAB specifies the CameraTarget as the center of the axes plot box. In manual mode, you specify the location.</td>\n</tr>\n<tr>\n<td>CameraUpVector</td>\n<td>The rotation of the camera around the viewing axis is defined by a vector indicating the direction taken as up.</td>\n</tr>\n<tr>\n<td>CameraUpVectorMode</td>\n<td>In automatic mode, MATLAB orients the up vector along the positive y-axis for 2-D views and along the positive z-axis for 3-D views. In manual mode, you specify the direction.</td>\n</tr>\n<tr>\n<td>CameraViewAngle</td>\n<td>Specifies the field of view of the "lens." If you specify a value for CameraViewAngle, MATLAB overrides stretch-to-fill behavior (see “Understanding Axes Aspect Ratio” on page 2-42).</td>\n</tr>\n</tbody>\n</table>\nLow-Level Camera Properties\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>CameraViewAngleMode</td>\n<td>In automatic mode, MATLAB adjusts the view angle to the smallest angle that captures the entire scene. In manual mode, you specify the angle. Setting CameraViewAngleMode to manual overrides stretch-to-fill behavior.</td>\n</tr>\n<tr>\n<td>Projection</td>\n<td>Selects either an orthographic or perspective projection.</td>\n</tr>\n</tbody>\n</table>\n\n**Default Viewpoint Selection**\n\nWhen all the camera mode properties are set to auto (the default), MATLAB automatically controls the view, selecting appropriate values based on the assumption that you want the scene to fill the position rectangle (which is defined by the width and height components of the axes Position property).\n\nBy default, MATLAB\n\n- Sets the CameraPosition so the orientation of the scene is the standard MATLAB 2-D or 3-D view (see the view command)\n- Sets the CameraTarget to the center of the plot box\n- Sets the CameraUpVector so the y-direction is up for 2-D views and the z-direction is up for 3-D views\n- Sets the CameraViewAngle to the minimum angle that makes the scene fill the position rectangle (the rectangle defined by the axes Position property)\n- Uses orthographic projection\n\nThis default behavior generally produces desirable results. However, you can change these properties to produce useful effects.\n\n**Moving In and Out on the Scene**\n\nYou can move the camera anywhere in the 3-D space defined by the axes. The camera continues to point towards the target regardless of its position. When the camera moves, MATLAB varies the camera view angle to ensure the scene fills the position rectangle.\nMoving Through a Scene\nYou can create a fly-by effect by moving the camera through the scene. To do this, continually change CameraPosition property, moving it toward the target. Because the camera is moving through space, it turns as it moves past the camera target. Override the MATLAB automatic resizing of the scene each time you move the camera by setting the CameraViewAngleMode to manual.\n\nIf you update the CameraPosition and the CameraTarget, the effect is to pass through the scene while continually facing the direction of movement.\n\nIf the Projection is set to perspective, the amount of perspective distortion increases as the camera gets closer to the target and decreases as it gets farther away.\n\nExample — Moving Toward or Away from the Target\nTo move the camera along the viewing axis, you need to calculate new coordinates for the CameraPosition property. This is accomplished by subtracting (to move closer to the target) or adding (to move away from the target) some fraction of the total distance between the camera position and the camera target.\n\nThe function movecamera calculates a new CameraPosition that moves in on the scene if the argument dist is positive and moves out if dist is negative.\n\n```matlab\nfunction movecamera(dist) %dist in the range [-1 1]\n set(gca,'CameraViewAngleMode','manual')\n newcp = cpos - dist * (cpos - ctarg);\n set(gca,'CameraPosition',newcp)\nfunction out = cpos\n out = get(gca,'CameraPosition');\nfunction out = ctarg\n out = get(gca,'CameraTarget');\n```\nNote that setting the CameraViewAngleMode to manual overrides MATLAB stretch-to-fill behavior and can cause an abrupt change in the aspect ratio. See “Understanding Axes Aspect Ratio” on page 2-42 for more information on stretch-to-fill.\n\n**Making the Scene Larger or Smaller**\n\nAdjusting the CameraViewAngle property makes the view of the scene larger or smaller. Larger angles cause the view to encompass a larger area, thereby making the objects in the scene appear smaller. Similarly, smaller angles make the objects appear larger.\n\nChanging CameraViewAngle makes the scene larger or smaller without affecting the position of the camera. This is desirable if you want to zoom in without moving the viewpoint past objects that will then no longer be in the scene (as could happen if you changed the camera position). Also, changing the CameraViewAngle does not affect the amount of perspective applied to\nthe scene, as changing CameraPosition does when the figure Projection property is set to perspective.\n\n**Revolving Around the Scene**\n\nYou can use the view command to revolve the viewpoint about the z-axis by varying the azimuth, and about the azimuth by varying the elevation. This has the effect of moving the camera around the scene along the surface of a sphere whose radius is the length of the viewing axis. You could create the same effect by changing the CameraPosition, but doing so requires you to perform calculations that MATLAB performs for you when you call view.\n\nFor example, the function orbit moves the camera around the scene.\n\n```matlab\nfunction orbit(deg)\n [az el] = view;\n rotvec = 0:deg/10:deg;\n for i = 1:length(rotvec)\n view([az+rotvec(i) el])\n drawnow\n end\n```\n\n**Rotation Without Resizing of Graphics Objects**\n\nWhen CameraViewAngleMode is auto, MATLAB calculates the CameraViewAngle so that the scene is as large as can fit in the axes position rectangle. This causes an apparent size change during rotation of the scene. To prevent resizing during rotation, you need to set the CameraViewAngleMode to manual (which happens automatically when you specify a value for the CameraViewAngle property). To do this in the orbit function, add the statement\n\n```matlab\nset(gca,'CameraViewAngleMode','manual')\n```\n\n**Rotation About the Viewing Axis**\n\nYou can change the orientation of the scene by specifying the direction defined as up. By default, MATLAB defines *up* as the y-axis in 2-D views (the CameraUpVector is [0 1 0]) and the z-axis for 3-D views (the CameraUpVector is [0 0 1]). However, you can specify up as any arbitrary direction.\nThe vector defined by the `CameraUpVector` property forms one axis of the camera’s coordinate system. Internally, MATLAB determines the actual orientation of the camera up vector by projecting the specified vector onto the plane that is normal to the camera direction (i.e., the viewing axis). This simplifies the specification of the `CameraUpVector` property, because it need not lie in this plane.\n\nIn many cases, you might find it convenient to visualize the desired up vector in terms of angles with respect to the axes $x$-, $y$-, and $z$-axis. You can then use direction cosines to convert from angles to vector components. For a unit vector, the expression simplifies to\n\n\\[\n\\begin{align*}\nXComponent &= \\cos(\\alpha \\times (\\pi/180)); \\\\\nYComponent &= \\cos(\\beta \\times (\\pi/180)); \\\\\nZComponent &= \\cos((\\Gamma) \\times (\\pi/180));\n\\end{align*}\n\\]\n\n(Consult a mathematics book on vector analysis for a more detailed explanation of direction cosines.)\n\n**Example — Calculating a Camera Up Vector**\n\nTo specify an up vector that makes an angle of $30^\\circ$ with the $z$-axis and lies in the $y$-$z$ plane, use the expression\nDefining the View\n\nupvec = [cos(90*(pi/180)), cos(60*(pi/180)), cos(30*(pi/180))];\n\nand then set the CameraUpVector property.\n\nset(gca,'CameraUpVector',upvec)\n\nDrawing a sphere with this orientation produces\nView Projection Types\n\nMATLAB supports both orthographic and perspective projection types for displaying 3-D graphics. The one you select depends on the type of graphics you are displaying:\n\n- **orthographic** projects the viewing volume as a rectangular parallelepiped (i.e., a box whose opposite sides are parallel). Relative distance from the camera does not affect the size of objects. This projection type is useful when it is important to maintain the actual size of objects and the angles between objects.\n\n- **perspective** projects the viewing volume as the frustum of a pyramid (a pyramid whose apex has been cut off parallel to the base). Distance causes foreshortening; objects further from the camera appear smaller. This projection type is useful when you want to display realistic views of real objects.\n\nBy default, MATLAB displays objects using orthographic projection. You can set the projection type using the `camproj` command.\n\nThese pictures show a drawing of a dump truck (created with `patch`) and a surface plot of a mathematical function, both using orthographic projection.\nIf you measure the width of the front and rear faces of the box enclosing the dump truck, you’ll see they are the same size. This picture looks unnatural because it lacks the apparent perspective you see when looking at real objects with depth. On the other hand, the surface plot accurately indicates the values of the function within rectangular space.\n\nNow look at the same graphics objects with perspective added. The dump truck looks more natural because portions of the truck that are farther from the viewer appear smaller. This projection mimics the way human vision works. The surface plot, on the other hand, looks distorted.\n\n**Projection Types and Camera Location**\n\nBy default, MATLAB adjusts the CameraPosition, CameraTarget, and CameraViewAngle properties to point the camera at the center of the scene and to include all graphics objects in the axes. If you position the camera so that there are graphics objects behind the camera, the scene displayed can be affected by both the axes Projection property and the figure Renderer property. The following summarizes the interactions between projection type and rendering method.\n<table>\n<thead>\n<tr>\n<th></th>\n<th><strong>Orthographic</strong></th>\n<th><strong>Perspective</strong></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Z-buffer</strong></td>\n<td>CameraViewAngle determines extent of scene at CameraTarget.</td>\n<td>CameraViewAngle determines extent of scene from CameraPosition to infinity.</td>\n</tr>\n<tr>\n<td><strong>Painters</strong></td>\n<td>All objects are displayed regardless of CameraPosition.</td>\n<td>Not recommended if graphics objects are behind the CameraPosition.</td>\n</tr>\n</tbody>\n</table>\n\nThis diagram illustrates what you see (gray area) when using orthographic projection and Z-buffer. Anything in front of the camera is visible.\n\nIn perspective projection, you see only what is visible in the cone of the camera view angle.\nPainters rendering method is less suited to moving the camera in 3-D space because MATLAB does not clip along the viewing axis. Orthographic projection in painters method results in all objects contained in the scene being visible regardless of the camera position.\n\n**Printing 3-D Scenes**\n\nThe same effects described in the previous section occur in hardcopy output. However, because of the differences in the process of rendering to the screen and to a printing format, MATLAB might render using Z-buffer and generate printed output using painters. You might need to specify Z-buffer printing.\nexplicitly to obtain the results displayed on the screen (use the -zbuffer option with the print command).\n\n**Additional Information**\nSee Basic Printing and Exporting and Selecting a Renderer in Figure Properties in the Using MATLAB Graphics documentation for information on printing and rendering methods.\nUnderstanding Axes Aspect Ratio\n\n- “Stretch-to-Fill” on page 2-42\n- “Specifying Axis Scaling” on page 2-42\n- “Specifying Aspect Ratio” on page 2-43\n- “Example — axis Command Options” on page 2-44\n- “Additional Commands for Setting Aspect Ratio” on page 2-46\n\nAxes shape graphics objects by setting the scaling and limits of each axis. When you create a graph, MATLAB automatically determines axis scaling based on the values or size of the plotted data, and then draws the axes to fit the space available for display. Axes aspect ratio properties control how MATLAB performs the scaling required to create a graph.\n\nThis section discusses MATLAB default behavior as well as techniques for customizing graphs.\n\nStretch-to-Fill\n\nBy default, the size of the axes MATLAB creates for plotting is normalized to the size of the figure window (but is slightly smaller to allow for borders). If you resize the figure, the size and possibly the aspect ratio (the ratio of width to height) of the axes changes proportionally. This enables the axes to always fill the available space in the window. MATLAB also sets the $x$-, $y$-, and $z$-axis limits to provide the greatest resolution in each direction, again optimizing the use of available space.\n\nThis stretch-to-fill behavior is generally desirable; however, you might want to control this process to produce specific results. For example, images need to be displayed in correct proportions regardless of the aspect ratio of the figure window, or you might want graphs always to be a particular size on a printed page.\n\nSpecifying Axis Scaling\n\nThe axis command enables you to adjust the scaling of graphs. By default, MATLAB finds the maxima and minima of the plotted data and chooses appropriate axes ranges. You can override the defaults by setting axis limits.\nUnderstanding Axes Aspect Ratio\n\n```plaintext\naxis([xmin xmax ymin ymax zmin zmax])\n```\n\nYou can control how MATLAB scales the axes with predefined `axis` options:\n\n- **axis auto** returns the axis scaling to its default, automatic mode. `v = axis` saves the scaling of the axes of the current plot in vector `v`. For subsequent graphics commands to have these same axis limits, follow them with `axis(v)`.\n\n- **axis manual** freezes the scaling at the current limits. If you then set `hold on`, subsequent plots use the current limits. Specifying values for axis limits also sets axis scaling to manual.\n\n- **axis tight** sets the axis limits to the range of the data.\n\n- **axis ij** places MATLAB into its \"matrix\" axes mode. The coordinate system origin is at the upper left corner. The `i`-axis is vertical and is numbered from top to bottom. The `j`-axis is horizontal and is numbered from left to right.\n\n- **axis xy** places MATLAB into its default Cartesian axes mode. The coordinate system origin is at the lower left corner. The `x`-axis is horizontal and is numbered from left to right. The `y`-axis is vertical and is numbered from bottom to top.\n\n**Specifying Aspect Ratio**\n\nThe `axis` command enables you to adjust the aspect ratio of graphs. Normally MATLAB stretches the axes to fill the window. In many cases, it is more useful to specify the aspect ratio of the axes based on a particular characteristic such as the relative length or scaling of each axis. The `axis` command provides a number of useful options for adjusting the aspect ratio:\n\n- **axis equal** changes the current axes scaling so that equal tick mark increments on the `x`, `y`, and `z`-axis are equal in length. This makes the surface displayed by `sphere` look like a sphere instead of an ellipsoid. `axis equal` overrides stretch-to-fill behavior.\n\n- **axis square** makes each axis the same length and overrides stretch-to-fill behavior.\n\n- **axis vis3d** freezes aspect ratio properties to enable rotation of 3-D objects and overrides stretch-to-fill. Use this option after other `axis` options to keep settings from changing while you rotate the scene.\nDefining the View\n\n- `axis image` makes the aspect ratio of the axes the same as the image.\n- `axis auto` returns the x-, y-, and z-axis limits to automatic selection mode.\n- `axis normal` restores the current axis box to full size and removes any restrictions on the scaling of the units. It undoes the effects of `axis square`. Used in conjunction with `axis auto`, it undoes the effects of `axis equal`.\n\nThe `axis` command works by manipulating axes graphics object properties.\n\n**Example — `axis` Command Options**\n\nThe following three pictures illustrate the effects of three `axis` options on a cylindrical surface created with the statements:\n\n```matlab\nt = 0:pi/6:4*pi;\n[x,y,z] = cylinder(4+cos(t),30);\nsurf(x,y,z)\n```\n\n`axis normal` is the default behavior. MATLAB automatically sets the axis limits to span the data range along each axis and stretches the plot to fit the figure window.\n**Understanding Axes Aspect Ratio**\n\n- **axis square** creates an axes that is square regardless of the shape of the figure window. The cylindrical surface is no longer distorted because it is not warped to fit the window. However, the size of one data unit is not equal along all axes (the z-axis spans only one unit while the x-axes and y-axes span 10 units each).\n\n- **axis equal** makes the length of one data unit equal along each axis while maintaining a nearly square plot box. It also prevents warping of the axis to fill the window’s shape.\n**Additional Commands for Setting Aspect Ratio**\n\nYou can control the aspect ratio of your graph in three ways:\n\n- Specifying the relative scales of the $x$-, $y$-, and $z$-axes (data aspect ratio)\n- Specifying the shape of the space defined by the axes (plot box aspect ratio)\n- Specifying the axis limits\n\nThe following commands enable you to set these values.\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>daspect</td>\n<td>Set or query the data aspect ratio</td>\n</tr>\n<tr>\n<td>pbaspect</td>\n<td>Set or query the plot box aspect ratio</td>\n</tr>\n<tr>\n<td>xlim</td>\n<td>Set or query $x$-axis limits</td>\n</tr>\n<tr>\n<td>ylim</td>\n<td>Set or query $y$-axis limits</td>\n</tr>\n<tr>\n<td>zlim</td>\n<td>Set or query $z$-axis limits</td>\n</tr>\n</tbody>\n</table>\n\nSee “Axes Aspect Ratio Properties” on page 2-47 for a list of the axes properties that control aspect ratio.\nAxes Aspect Ratio Properties\n\n- “Default Aspect Ratio Selection” on page 2-48\n- “Overriding Stretch-to-Fill” on page 2-51\n- “Effects of Setting Aspect Ratio Properties” on page 2-52\n- “Example — Displaying Cross-Sections of Surfaces” on page 2-55\n- “Example — Displaying Real Objects” on page 2-57\n\nThe axis command works by setting various axes object properties. You can set these properties directly to achieve precisely the effect you want.\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DataAspectRatio</td>\n<td>Sets the relative scaling of the individual axis data values. Set DataAspectRatio to [1 1 1] to display real-world objects in correct proportions. Specifying a value for DataAspectRatio overrides stretch-to-fill behavior.</td>\n</tr>\n<tr>\n<td>DataAspectRatioMode</td>\n<td>In auto, MATLAB selects axis scales that provide the highest resolution in the space available.</td>\n</tr>\n<tr>\n<td>PlotBoxAspectRatio</td>\n<td>Sets the proportions of the axes plot box (set box to on to see the box). Specifying a value for PlotBoxAspectRatio overrides stretch-to-fill behavior.</td>\n</tr>\n<tr>\n<td>PlotBoxAspectRatioMode</td>\n<td>In auto, MATLAB sets the PlotBoxAspectRatio to [1 1 1] unless you explicitly set the DataAspectRatio and/or the axis limits.</td>\n</tr>\n<tr>\n<td>Position</td>\n<td>Defines the location and size of the axes with a four-element vector: [left offset, bottom offset, width, height].</td>\n</tr>\n<tr>\n<td>XLim, YLim, ZLim</td>\n<td>Sets the minimum and maximum limits of the respective axes.</td>\n</tr>\n<tr>\n<td>XLimMode, YLimMode, ZLimMode</td>\n<td>In auto, MATLAB selects the axis limits.</td>\n</tr>\n</tbody>\n</table>\n\nBy default, MATLAB automatically determines values for all of these properties (i.e., all the modes are auto) and then applies stretch-to-fill. You can override any property’s automatic operation by specifying a value for the\nproperty or setting its mode to manual. The value you select for a particular property depends primarily on what type of data you want to display.\n\nMuch of the data visualized with MATLAB is either\n\n- Numerical data displayed as line or mesh plots\n- Representations of real-world objects (e.g., a dump truck or a section of the earth’s topography)\n\nIn the first case, it is generally desirable to select axis limits that provide good resolution in each axis direction and to fill the available space. Real-world objects, on the other hand, need to be represented accurately in proportion, regardless of the angle of view.\n\n**Default Aspect Ratio Selection**\n\nThere are two key elements to MATLAB default behavior — normalizing the axes size to the window size and stretch-to-fill.\n\nThe axes Position property specifies the location and dimensions of the axes. The third and fourth elements of the Position vector (width and height) define a rectangle in which MATLAB draws the axes (indicated by the dotted line in the following pictures). MATLAB stretches the axes to fill this rectangle.\n\nThe default value for the axes Units property is normalized to the parent figure dimensions. This means the shape of the figure window determines the shape of the position rectangle. As you change the size of the window, MATLAB reshapes the position rectangle to fit it.\nThe view is the 2-D projection of the plot box onto the screen.\n\nAs you can see, reshaping the axes to fit into the figure window can change the aspect ratio of the graph. MATLAB applies stretch-to-fill so the axes fill the position rectangle and in the process can distort the shape. This is\ngenerally desirable for graphs of numeric data, but not for displaying objects realistically.\n\nExample — MATLAB Defaults\nMATLAB surface plots are well suited for visualizing mathematical functions of two variables. For example, to display a mesh plot of the function\n\n\\[ z = xe^{(-x^2 - y^2)} \\]\n\nevaluated over the range \\(-2 \\leq x \\leq 2, -4 \\leq y \\leq 4\\), use the statements\n\n\\[\n[X,Y] = \n\\text{meshgrid}([-2:.15:2],[-4:.3:4]); \\\\\nZ = X.*exp(-X.^2 - Y.^2); \\\\\n\\text{mesh}(X,Y,Z)\n\\]\n\nThe MATLAB default property values are designed to\n\n- Select axis limits to span the range of the data (XLimMode, YLimMode, and ZLimMode are set to auto).\n- Provide the highest resolution in the available space by setting the scale of each axis independently (DataAspectRatioMode and the PlotBoxAspectRatioMode are set to auto).\n- Draw axes that fit the position rectangle by adjusting the CameraViewAngle and then stretch-to-fill the axes if necessary.\n**Overriding Stretch-to-Fill**\n\nTo maintain a particular shape, you can specify the size of the axes in absolute units such as inches, which are independent of the figure window size. However, this is not a good approach if you are writing an M-file that you want to work with a figure window of any size. A better approach is to specify the aspect ratio of the axes and override automatic stretch-to-fill.\n\nIn cases where you want a specific aspect ratio, you can override stretching by specifying a value for these axes properties:\n\n- `DataAspectRatio` or `DataAspectRatioMode`\n- `PlotBoxAspectRatio` or `PlotBoxAspectRatioMode`\n- `CameraViewAngle` or `CameraViewAngleMode`\n\nThe first two sets of properties affect the aspect ratio directly. Setting either of the mode properties to `manual` simply disables stretch-to-fill while maintaining all current property values. In this case, MATLAB enlarges the axes until one dimension of the position rectangle constrains it.\n\nSetting the `CameraViewAngle` property disables stretch-to-fill, and also prevents MATLAB from readjusting the size of the axes if you change the view.\nEffects of Setting Aspect Ratio Properties\n\nIt is important to understand how properties interact with each other, in order to obtain the results you want. The DataAspectRatio, PlotBoxAspectRatio, and the x-, y-, and z-axis limits (XLim, YLim, and ZLim properties) all place constraints on the shape of the axes.\n\nData Aspect Ratio\n\nThe DataAspectRatio property controls the ratio of the axis scales. For a mesh plot of the function $Z = x e^{(-x^2 - y^2)}$ evaluated over the range $-2 \\leq x \\leq 2$, $-4 \\leq y \\leq 4$\n\n```matlab\n[X,Y] = meshgrid([-2:.15:2],[-4:.3:4]);\nZ = X.*exp(-X.^2 - Y.^2);\nmesh(X,Y,Z)\n```\n\nthe values are\n\n```matlab\nget(gca,'DataAspectRatio')\nans =\n 4 8 1\n```\n\nThis means that four units in length along the x-axis cover the same data values as eight units in length along the y-axis and one unit in length along the z-axis. The axes fill the plot box, which has an aspect ratio of [1 1 1] by default.\n\nIf you want to view the mesh plot so that the relative magnitudes along each axis are equal with respect to each other, you can set the DataAspectRatio to [1 1 1].\n\n```matlab\nset(gca,'DataAspectRatio',[1 1 1])\n```\nSetting the value of the `DataAspectRatio` property also sets the `DataAspectRatioMode` to `manual` and overrides stretch-to-fill so the specified aspect ratio is achieved.\n\n**Plot Box Aspect Ratio**\n\nLooking at the value of the `PlotBoxAspectRatio` for the graph in the previous section shows that it has now taken on the former value of the `DataAspectRatio`.\n\n```matlab\ngca('PlotBoxAspectRatio')\nans =\n 4 8 1\n```\n\nMATLAB has rescaled the plot box to accommodate the graph using the specified `DataAspectRatio`.\n\nThe `PlotBoxAspectRatio` property controls the shape of the axes plot box. MATLAB sets this property to `[1 1 1]` by default and adjusts the `DataAspectRatio` property so that graphs fill the plot box if stretching is on, or until reaching a constraint if stretch-to-fill has been overridden.\nWhen you set the value of the DataAspectRatio and thereby prevent it from changing, MATLAB varies the PlotBoxAspectRatio instead. If you specify both the DataAspectRatio and the PlotBoxAspectRatio, MATLAB is forced to change the axis limits to obey the two constraints you have already defined.\n\nContinuing with the mesh example, if you set both properties,\n\n```matlab\nset(gca,'DataAspectRatio',[1 1 1],...\n 'PlotBoxAspectRatio',[1 1 1])\n```\n\nMATLAB changes the axis limits to satisfy the two constraints placed on the axes.\n\n### Adjusting Axis Limits\nMATLAB enables you to set the axis limits to the values you want. However, specifying a value for DataAspectRatio, PlotBoxAspectRatio, and the axis limits overconstrains the axes definition. For example, it is not possible for MATLAB to draw the axes if you set these values:\n\n```matlab\nset(gca,'DataAspectRatio',[1 1 1],...\n 'PlotBoxAspectRatio',[1 1 1],...\nIn this case, MATLAB ignores the setting of the `PlotBoxAspectRatio` and\ndetermines its value automatically. These particular values cause the\n`PlotBoxAspectRatio` to return to its calculated value.\n\n```matlab\nget(gca, 'PlotBoxAspectRatio')\nan = 4 8 1\n```\n\nMATLAB can now draw the axes using the specified `DataAspectRatio` and\naxis limits.\n\n**Example — Displaying Cross-Sections of Surfaces**\n\nSometimes projecting a 3-D surface onto an x-, y-, or z-axis can aid\nvisualization. To do this, you might change the aspect ratio, in order to make\nspace for the projection. The following example illustrates how to do this:\n1 Create an x-y grid and z-values for it:\n\n```matlab\n[x,y] = meshgrid([-2:.2:2]);\nZ = x.*exp(-x.^2-y.^2);\n```\n\n2 Plot the surface in 3-D; annotate with a colorbar and axis labels:\n\n```matlab\nsurf(x,y,Z,gradient(Z))\ncolorbar\nxlabel('X-AXIS')\nylabel('Y-AXIS')\nzlabel('Z-AXIS')\n```\n\n3 Use axis to change the Ymax value in to 3, stretching the plot in one direction:\n\n```matlab\naxis([-2 2 -2 2 -3 0.5]) %\n```\n\n4 Regrid the surface, setting all Y-values equal to 3:\n\n```matlab\ny = 3*ones(21);\n```\n\n5 Plaster a plot of the surface onto the Y-axis:\nExample — Displaying Real Objects\n\nIf you want to display an object so that it looks realistic, you need to change MATLAB defaults. For example, this data defines a wedge-shaped patch object.\n\n```matlab\nvertex_list =\n0 0 0\n0 1 0\n1 1 0\n1 0 0\n0 0 1\n0 1 1\n1 1 4\n1 0 4\n\nvertex_connection =\n1 2 3 4\n2 6 7 3\n4 3 7 8\n1 5 8 4\n1 2 6 5\n5 6 7 8\n\npatch('Vertices',vertex_list,'Faces',vertex_connection,...\n```\nDefining the View\n\n`'FaceColor','w','EdgeColor','k')\nview(3)\n\nHowever, this axes distorts the actual shape of the solid object defined by the data. To display it in correct proportions, set the `DataAspectRatio`.\n\n```\nset(gca,'DataAspectRatio',[1 1 1])\n```\n\nThe units are now equal in the x-, y-, and z-directions and the axes is not being stretched to fill the position rectangle, revealing the true shape of the object.\n# Lighting as a Visualization Tool\n\n- **Lighting Overview (p. 3-2)**: Contains links to examples throughout the graphics documentation that illustrate the use of lighting.\n- **Lighting Commands (p. 3-3)**: Commands for creating lighting effects.\n- **Light Objects (p. 3-4)**: Creation and properties of light objects.\n- **Adding Lights to a Scene (p. 3-5)**: Examples of how to position lights and set properties.\n- **Properties That Affect Lighting (p. 3-7)**: Properties of axes, patches, and surfaces that affect lights.\n- **Selecting a Lighting Method (p. 3-9)**: Illustration of various lighting methods showing which to use.\n- **Reflectance Characteristics of Graphics Objects (p. 3-11)**: Catalog illustrating various lighting characteristics.\nLighting Overview\n\nLighting is a technique for adding realism to a graphical scene. It does this by simulating the highlights and dark areas that occur on objects under natural lighting (e.g., the directional light that comes from the sun). To create lighting effects, MATLAB defines a graphics object called a light. MATLAB applies lighting to surface and patch objects.\n\nLighting Examples\n\nThese examples illustrate the use of lighting in a visualization context.\n\n- Tracing a stream line through a volume — Sets properties of surfaces, patches, and lights (MATLAB Graphics documentation).\n\n- Using slice planes and cone plots — Sets lighting characteristics of objects in a scene independently to achieve a desired result (MATLAB coneplot function).\n\n- Lighting multiple slice planes independently to visualize fluid flow (MATLAB Graphics documentation).\n\n- Combining single-color lit surfaces with interpolated coloring. See \"Example — Visualizing MRI Data\" (3-D Visualization documentation).\n\n- Employing lighting to reveal surface shape. The fluid flow isosurface example and the surface plot of the sinc function examples illustrate this technique (3-D Visualization documentation).\nLighting Commands\n\nMATLAB provides commands that enable you to position light sources and adjust the characteristics of lit objects. These commands include the following.\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>camlight</td>\n<td>Create or move a light with respect to the camera position</td>\n</tr>\n<tr>\n<td>lightangle</td>\n<td>Create or position a light in spherical coordinates</td>\n</tr>\n<tr>\n<td>light</td>\n<td>Create a light object</td>\n</tr>\n<tr>\n<td>lighting</td>\n<td>Select a lighting method</td>\n</tr>\n<tr>\n<td>material</td>\n<td>Set the reflectance properties of lit objects</td>\n</tr>\n</tbody>\n</table>\n\nYou might find it useful to set light or lit-object properties directly to achieve specific results. In addition to the material in this topic area, you can explore the following lighting examples as an introduction to lighting for visualization.\nLight Objects\n\nYou create a light object using the light function. Three important light object properties are\n\n- **Color** — Color of the light cast by the light object\n- **Style** — Either infinitely far away (the default) or local\n- **Position** — Direction (for infinite light sources) or the location (for local light sources)\n\nThe **Color** property determines the color of the directional light from the light source. The color of an object in a scene is determined by the color of the object and the light source.\n\nThe **Style** property determines whether the light source is a point source (**Style** set to **local**), which radiates from the specified position in all directions, or a light source placed at infinity (**Style** set to **infinite**), which shines from the direction of the specified position with parallel rays.\n\nThe **Position** property specifies the location of the light source in axes data units. In the case of a light source at infinity, **Position** specifies the direction to the light source.\n\nLights affect surface and patch objects that are in the same axes as the light. These objects have a number of properties that alter the way they look when illuminated by lights.\nAdding Lights to a Scene\n\nThis example displays the membrane surface and illuminates it with a light source emanating from the direction defined by the position vector [0 -2 1]. This vector defines a direction from the axes origin passing through the point with the coordinates 0, -2, 1. The light shines from this direction toward the axes origin.\n\n```matlab\nmembrane\nlight('Position',[0 -2 1])\n```\n\nCreating a light activates a number of lighting-related properties controlling characteristics such as the ambient light and reflectance properties of objects. It also switches to Z-buffer renderer if not already in that mode.\n\nIlluminating Mathematical Functions\n\nLighting can enhance surface graphs of mathematical functions. For example, use the `ezsurf` command to evaluate the expression \\( \\sin(\\sqrt{x^2 + y^2}) + \\sqrt{x^2 + y^2} \\) over the region -6\\(\\pi\\) to 6\\(\\pi\\).\nezsurf('sin(sqrt(x^2+y^2))/sqrt(x^2+y^2)',[-6*pi,6*pi])\n\nNow add lighting using the lightangle command, which accepts the light position in terms of azimuth and elevation.\n\nview(0,75)\nshading interp\nlightangle(-45,30)\nset(gcf,'Renderer','zbuffer')\nset(findobj(gca,'type','surface'),...\n 'FaceLighting','phong',...\n 'AmbientStrength',.3,'DiffuseStrength',.8,...\n 'SpecularStrength',.9,'SpecularExponent',25,...\n 'BackFaceLighting','unlit')\n\nAfter obtaining the surface object’s handle using findobj, you can set properties that affect how the light reflects from the surface. See “Properties That Affect Lighting” on page 3-7 for more detailed descriptions of these properties.\nProperties That Affect Lighting\n\nYou cannot see light objects themselves, but you can see their effects on any patch and surface objects present in the axes containing the light. A number of functions create these objects, including `surf`, `mesh`, `pcolor`, `fill`, and `fill3` as well as the `surface` and `patch` functions.\n\nYou control lighting effects by setting various axes, light, patch, and surface object properties. All properties have default values that generally produce desirable results. However, you can achieve the specific effect you want by adjusting the values of these properties.\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Effect</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>AmbientLightColor</td>\n<td>An axes property that specifies the color of the background light in the scene, which has no direction and affects all objects uniformly. Ambient light effects occur only when there is a visible light object in the axes.</td>\n</tr>\n<tr>\n<td>AmbientStrength</td>\n<td>A patch and surface property that determines the intensity of the ambient component of the light reflected from the object.</td>\n</tr>\n<tr>\n<td>DiffuseStrength</td>\n<td>A patch and surface property that determines the intensity of the diffuse component of the light reflected from the object.</td>\n</tr>\n<tr>\n<td>SpecularStrength</td>\n<td>A patch and surface property that determines the intensity of the specular component of the light reflected from the object.</td>\n</tr>\n<tr>\n<td>SpecularExponent</td>\n<td>A patch and surface property that determines the size of the specular highlight.</td>\n</tr>\n<tr>\n<td>SpecularColorReflectance</td>\n<td>A patch and surface property that determines the degree to which the specularly reflected light is colored by the object color or the light source color.</td>\n</tr>\n<tr>\n<td>FaceLighting</td>\n<td>A patch and surface property that determines the method used to calculate the effect of the light on the faces of the object. Choices are either no lighting, or flat, Gouraud, or Phong lighting algorithms.</td>\n</tr>\n<tr>\n<td>EdgeLighting</td>\n<td>A patch and surface property that determines the method used to calculate the effect of the light on the edges of the object. Choices are either no lighting, or flat, Gouraud, or Phong lighting algorithms.</td>\n</tr>\n<tr>\n<td>Property</td>\n<td>Effect</td>\n</tr>\n<tr>\n<td>-------------------</td>\n<td>-----------------------------------------------------------------------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>BackFaceLighting</td>\n<td>A patch and surface property that determines how faces are lit when their vertex normals point away from the camera. This property is useful for discriminating between the internal and external surfaces of an object.</td>\n</tr>\n<tr>\n<td>FaceColor</td>\n<td>A patch and surface property that specifies the color of the object faces.</td>\n</tr>\n<tr>\n<td>EdgeColor</td>\n<td>A patch and surface property that specifies the color of the object edges.</td>\n</tr>\n<tr>\n<td>VertexNormals</td>\n<td>A patch and surface property that contains normal vectors for each vertex of the object. MATLAB uses vertex normal vectors to perform lighting calculations. While MATLAB automatically generates this data, you can also specify your own vertex normals.</td>\n</tr>\n<tr>\n<td>NormalMode</td>\n<td>A patch and surface property that determines whether MATLAB recalculates vertex normals if you change object data (auto) or uses the current values of the VertexNormals property (manual). If you specify values for VertexNormals, MATLAB sets this property to manual.</td>\n</tr>\n</tbody>\n</table>\n\nFor more information, see descriptions of axes, surface, and patch object properties.\nSelecting a Lighting Method\n\nWhen you add lights to an axes, MATLAB determines the effects these lights have on the patch and surface objects that are displayed in that axes. There are different methods used to calculate the face and edge coloring of lit objects, and the one you select depends on the results you want to obtain.\n\nFace and Edge Lighting Methods\nMATLAB supports three different algorithms for lighting calculations, selected by setting the `FaceLighting` and `EdgeLighting` properties of each patch and surface object in the scene. Each algorithm produces somewhat different results:\n\n- Flat lighting — Produces uniform color across each of the faces of the object. Select this method to view faceted objects.\n- Gouraud lighting — Calculates the colors at the vertices and then interpolates colors across the faces. Select this method to view curved surfaces.\n- Phong lighting — Interpolates the vertex normals across each face and calculates the reflectance at each pixel. Select this choice to view curved surfaces. Phong lighting generally produces better results than Gouraud lighting, but takes longer to render.\n\nThis illustration shows how a red sphere looks using each of the lighting methods with one white light source.\nThe lighting command (as opposed to the light function) provides a convenient way to set the lighting method.\n**Reflectance Characteristics of Graphics Objects**\n\nYou can modify the reflectance characteristics of patch and surface objects and thereby change the way they look when lights are applied to the scene. The characteristics discussed in this section include\n\n- “Specular and Diffuse Reflection” on page 3-11\n- “Ambient Light” on page 3-12\n- “Specular Exponent” on page 3-13\n- “Specular Color Reflectance” on page 3-14\n- “Back Face Lighting” on page 3-14\n- “Positioning Lights in Data Space” on page 3-17\n\nIt is likely you will adjust these characteristics in combination to produce particular results.\n\nAlso see the material command for a convenient way to produce certain lighting effects.\n\n**Specular and Diffuse Reflection**\n\nYou can control the amount of specular and diffuse reflection from the surface of an object by setting the SpecularStrength and DiffuseStrength properties. This picture illustrates various settings.\nAmbient Light\n\nAmbient light is a directionless light that shines uniformly on all objects in the scene. Ambient light is visible only when there are light objects in the axes. There are two properties that control ambient light — AmbientLightColor is an axes property that sets the color, and AmbientStrength is a property of patch and surface objects that determines the intensity of the ambient light on the particular object.\n\nThis illustration shows three different ambient light colors at various intensities. The sphere is red and there is a white light object present.\nThe green [0 1 0] ambient light does not affect the scene because there is no red component in green light. However, the color defined by the RGB values [.5 0 1] does have a red component, so it contributes to the light on the sphere (but less than the white [1 1 1] ambient light).\n\n**Specular Exponent**\n\nThe size of the specular highlight spot depends on the value of the patch and surface object’s SpecularExponent property. Typical values for this property range from 1 to 500, with normal objects having values in the range 5 to 20.\n\nThis illustration shows a red sphere illuminated by a white light with three different values for the SpecularExponent property.\n\n\n**Specular Color Reflectance**\n\nThe color of the specularly reflected light can range from a combination of the color of the object and the color of the light source to the color of the light source only. The patch and surface `SpecularColorReflectance` property controls this color. This illustration shows a red sphere illuminated by a white light. The values of the `SpecularColorReflectance` property range from 0 (object and light color) to 1 (light color).\n\n**Back Face Lighting**\n\nBack face lighting is useful for showing the difference between internal and external faces. These pictures of cut-away cylindrical surfaces illustrate the effects of back face lighting.\nThe default value for BackFaceLighting is **reverselit**. This setting reverses the direction of the vertex normals that face away from the camera, causing the interior surface to reflect light towards the camera. Setting BackFaceLighting to **unlit** disables lighting on faces with normals that point away from the camera.\n\nYou can also use BackFaceLighting to remove edge effects for closed objects. These effects occur when BackFaceLighting is set to **reverselit** and pixels along the edge of a closed object are lit as if their vertex normals faced the camera. This produces an improperly lit pixel because the pixel is visible but is really facing away from the camera.\n\nTo illustrate this effect, the next picture shows a blowup of the edge of a lit sphere. Setting BackFaceLighting to **lit** prevents the improper lighting of pixels.\nLighting as a Visualization Tool\n\nBackFaceLighting = reverselit\n\nBackFaceLighting = lit\nPositioning Lights in Data Space\n\nThis example creates a sphere and a cube to illustrate the effects of various properties on lighting. The variables vert and fac define the cube using the patch function.\n\n```matlab\nvert =\n1 1 1 1\n1 2 1 2\n2 2 1 4\n2 1 1 1\n1 1 2 1\n1 2 2 5\n2 2 2 6\n2 1 2 7\n\nfac =\n2 3 4\n2 6 7 3\n4 3 7 8\n1 5 8 4\n1 2 6 5\n5 6 7 8\n\nsphere(36);\nh = findobj('Type','surface');\nset(h,'FaceLighting','phong',\n 'FaceColor','interp',\n 'EdgeColor',[.4 .4 .4],\n 'BackFaceLighting','lit')\nhold on\npatch('faces',fac,'vertices',vert,'FaceColor','y');\nlight('Position',[1 3 2]);\nlight('Position',[-3 -1 3]);\nmaterial shiny\naxis vis3d off\nhold off\n```\n\nAll faces of the cube have FaceColor set to yellow. The sphere function creates a spherical surface and the handle of this surface is obtained using findobj to search for the object whose Type property is surface. The light functions define two white (the default color) light objects located at infinity in the direction specified by the Position vectors. These vectors are defined in axes coordinates \\([x, y, z]\\).\nThe patch uses flat FaceLighting (the default) to enhance the visibility of each side. The surface uses phong FaceLighting because it produces the smoothest interpolation of lighting effects. The material shiny command affects the reflectance properties of both the cube and sphere (although its effects are noticeable only on the sphere because of the cube’s flat shading).\n\nBecause the sphere is closed, the BackFaceLighting property is changed from its default setting, which reverses the direction of vertex normals that face away from the camera, to normal lighting, which removes undesirable edge effects.\n\nExamining the code in the lighting and material M-files can help you understand how various properties affect lighting.\nTransparency\n\nMaking Objects Transparent (p. 4-2) — Overview of the object properties that specify transparency\nSpecifying a Single Transparency Value (p. 4-6) — How to specify a transparency value that applies to all the faces of a graphics object\nMapping Data to Transparency — Alpha Data (p. 4-8) — How to use transparency as another dimension for visualizing data\nSelecting an Alphamap (p. 4-12) — Characteristics of various alphamaps and illustrations of the effects they produce\nMaking Objects Transparent\n\nMaking graphics objects semitransparent is a useful technique in 3-D visualization to make it possible to see an object, while at the same time, see what information the object would obscure if it was completely opaque. You can also use transparency as another dimension for displaying data, much the way color is used in MATLAB.\n\nThe transparency of a graphics object determines the degree to which you can see through the object. You can specify a continuous range of transparency varying from completely transparent (i.e., invisible) to completely opaque (i.e., no transparency).\n\nObjects that support transparency are\n\n- Image\n- Patch\n- Surface\n\nThe following picture illustrates the effect of transparency. The green isosurface (patch object) reveals the cone plot that lies in the interior.\nNote You must have OpenGL available on your system to use transparency. MATLAB automatically uses OpenGL if it is available. See the figure RendererMode property for more information.\n\nSpecifying Transparency\n\nTransparency values, which range from [0 1], are referred to as alpha values. An alpha value of 0 means completely transparent (i.e., invisible); an alpha value of 1 means completely opaque (i.e., no transparency).\n\nMATLAB treats transparency in a way that is analogous to how it treats color for the respective objects:\n- Patches and surfaces can define a single face and edge alpha value or use flat or interpolated transparency based on values in the figure’s alphamap.\n- Images, patches, and surfaces can define alpha data that is used as indices into the alphamap or directly as alpha values.\n- Axes define alpha limits that control the mapping of object data to alpha values.\n- Figures contain alphamaps, which are m-by-1 arrays of alpha values.\n\nSee the following sections for more information on color:\n\n- “Specifying Patch Coloring” on page 5-14 in Creating 3-D Models with Patches in the Using MATLAB Graphics documentation\n- “Coloring Mesh and Surface Plots” on page 1-14 in Creating 3-D Graphs in the Using MATLAB Graphics documentation\n\n**Transparency Properties**\n\nThe following table summarizes the object properties that control transparency.\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>AlphaData</td>\n<td>Transparency data for image and surface objects</td>\n</tr>\n<tr>\n<td>AlphaDataMapping</td>\n<td>Transparency data mapping method</td>\n</tr>\n<tr>\n<td>FaceAlpha</td>\n<td>Transparency of the faces (patch and surface only)</td>\n</tr>\n<tr>\n<td>EdgeAlpha</td>\n<td>Transparency of the edges (patch and surface only)</td>\n</tr>\n<tr>\n<td>FaceVertexAlphaData</td>\n<td>Patch only alpha data property</td>\n</tr>\n<tr>\n<td>ALim</td>\n<td>Alpha axis limits</td>\n</tr>\n<tr>\n<td>ALimMode</td>\n<td>Alpha axis limits mode</td>\n</tr>\n<tr>\n<td>Alphamap</td>\n<td>Figure alphamap</td>\n</tr>\n</tbody>\n</table>\n**Transparency Functions**\nThere are three functions that simplify the process of setting alpha properties.\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>alpha</td>\n<td>Set or query transparency properties for objects in current axes</td>\n</tr>\n<tr>\n<td>alphamap</td>\n<td>Specify the figure alphamap</td>\n</tr>\n<tr>\n<td>alim</td>\n<td>Set or query the axes alpha limits</td>\n</tr>\n</tbody>\n</table>\nSpecifying a Single Transparency Value\n\nSpecifying a single transparency value for graphics objects is useful when you want to reveal structure that is obscured with opaque objects. For patches and surfaces, use the FaceAlpha and EdgeAlpha properties to specify the transparency of faces and edges. The following example illustrates this.\n\nExample — Transparent Isosurface\n\nThis example uses the flow function to generate data for the speed profile of a submerged jet within an infinite tank. One way to visualize this data is by creating an isosurface illustrating where the rate of flow is equal to a specified value.\n\n```matlab\n[x y z v] = flow;\np = patch(isosurface(x,y,z,v,-3));\nisonormals(x,y,z,v,p);\nset(p,'facecolor','red','edgecolor','none');\ndaspect([1 1 1]);\nview(3); axis tight; grid on;\ncamlight; lighting gouraud;\n```\n\nAdding transparency to the isosurface reveals that there is greater complexity in the fluid flow than is visible using the opaque surface. The statement\nalpha(.5)\n\nsets the FaceAlpha value for the isosurface face to .5.\n\n---\n\n**Setting a Single Transparency Value for Images**\n\nFor images, the statement\n\n\\[\n\\text{alpha(.5)}\n\\]\n\nsets AlphaData to .5. When the AlphaDataMapping property is set to none (the default), setting AlphaData on an image causes the entire image to be rendered with the specified alpha value.\nMapping Data to Transparency — Alpha Data\n\n- “Size of the Alpha Data Array” on page 4-9\n- “Mapping Alpha Data to the Alphamap” on page 4-9\n- “Example — Mapping Data to Color or Transparency” on page 4-10\n\nAlpha data is analogous to color data (e.g., the CData property of surfaces). When you create a surface, MATLAB maps each element in the color data array to a color in the colormap. Similarly, each element in the alpha data maps to a transparency value in the alphamap.\n\nSpecify surface and image alpha data with the AlphaData property. For patch objects, use the FaceVertexAlphaData property.\n\nYou can control how MATLAB interprets alpha data with the following properties:\n\n- FaceAlpha and EdgeAlpha — Enable you to select flat or interpolated transparency rendering. If set to a single transparency value, MATLAB applies this value to all faces or edges and does not use the alpha data.\n- AlphaDataMapping and ALim — Determine how MATLAB maps the alpha data to the alphamap. By default, MATLAB scales the alpha data to be within the range [0 1].\n- Alphamap — Contains the actual transparency values to which the data is to be mapped.\n\nNote that there are differences between the default values of equivalent color and alpha properties because, in contrast to color, transparency is not displayed by default. The following table highlights these differences.\n\n<table>\n<thead>\n<tr>\n<th>Color Property</th>\n<th>Default</th>\n<th>Alpha Property</th>\n<th>Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>FaceColor</td>\n<td>Flat</td>\n<td>FaceAlpha</td>\n<td>1 (opaque)</td>\n</tr>\n<tr>\n<td>CData</td>\n<td>Equal to ZData</td>\n<td>AlphaData and FaceVertexAlphaData</td>\n<td>1 (scalar)</td>\n</tr>\n</tbody>\n</table>\nBy default, objects have single-valued alpha data. Therefore you cannot specify flat or interp FaceAlpha or EdgeAlpha without first setting AlphaData to an array of the appropriate size.\n\nThe sections that follow illustrate how to use these properties to display object data as degrees of transparency.\n\n**Size of the Alpha Data Array**\n\nIn order to use nonscalar alpha data, you need to specify the alpha data as an array equal in size to\n\n- CData of images and surfaces\n- The number of faces (flat) or the number of vertices (interpolated) defined in the FaceVertexAlphaData property of patches\n\nOnce you have specified an alpha data array of the proper size, you can select the face and edge rendering you want to use. Flat uses one transparency value per face, while interpolated performs bilinear interpolation of the values at each vertex.\n\n**Mapping Alpha Data to the Alphamap**\n\nYou can control how MATLAB maps the alpha data to the alphamap using the AlphaDataMapping property. There are three possible mappings:\n\n- none — Interpret the values in alpha data as transparency values (data values must be between 0 and 1, or will be clamped to 0 or 1). This is the default mapping.\n- scaled — Transform the alpha data to span the portion of the alphamap indicated by the axes ALim property, linearly mapping data values to alpha values. This is the same way color data is mapped to the colormap.\n- direct — Use the alpha data directly as indices into the figure alphamap.\n\nBy default, objects have scalar alpha data (AlphaData and FaceVertexAlphaData) set to the value 1.\nExample — Mapping Data to Color or Transparency\n\nThis example displays a surface plot of a function of two variables. The color is mapped to the gradient of the $z$ data.\n\n\\[\n\\begin{align*}\n[x,y] &= \\text{meshgrid}([-2:.2:2]); \\\\\nz &= x.*\\exp(-x.^2-y.^2); \\\\\nsurf(x,y,z,\\text{gradient}(z)); \\quad \\text{axis tight}\n\\end{align*}\n\\]\n\nYou can map transparency to the gradient of $z$ in a similar way.\n\n\\[\n\\begin{align*}\nsurf(x,y,z,'\\text{FaceAlpha}','flat',... \\\\\n'\\text{AlphaDataMapping}','\\text{scaled}',... \\\\\n'\\text{AlphaData}',\\text{gradient}(z),... \\\\\n'\\text{FaceColor}','\\text{blue}') \\\\\n\\text{axis tight}\n\\end{align*}\n\\]\nSelecting an Alphamap\n\nAn alphamap is simply an array of values ranging from 0 to 1. The size of the array can be either m-by-1 or 1-by-m.\n\nThe default alphamap contains 64 values ranging linearly from 0 to 1, as you can see in the following plot.\n\n```matlab\nplot(get(gcf,'Alphamap'))\n```\n\nThis alphamap displays the lowest alpha data values as completely transparent and the highest alpha data values as opaque.\n\nThe alphamap function creates some useful predefined alphamaps and also enables you to modify existing maps. For example,\n\n```matlab\nplot(alphamap('vup'))\n```\n\nproduces the following alphamap.\nYou can shift the values using the increase or decrease options. For example,\n\n```plaintext\nalphamap('increase', .4)\n```\n\nadds the value .4 to all values in the current figure’s alphamap. Replotting the 'vup' alphamap illustrates the change. Note how the values are clamped to the range [0 1].\n\n```plaintext\nplot(get(gcf, 'Alphamap'))\n```\nExample — Modifying the Alphamap\n\nThis example uses slice planes to examine volume data. The slice planes use the color data for alpha data and employ a rampdown alphamap (the values range from 1 to 0):\n\n1. Create the volume data by evaluating a function of three variables.\n\n \\[\n [x,y,z] = \\text{meshgrid}(-1.25:.1:-.25,-2:.2:2,-2:.1:2);\n \\v = x.*\\exp(-x.^2-y.^2-z.^2);\n \\]\n\n2. Create the slice planes, set the alpha data equal to the color data, and specify interpolated FaceAlpha.\n\n \\[\n h = \\text{slice}(x,y,z,v,[\\text{-1 -0.75 -0.5}],[],[]);\\]\n \\[\n \\text{alpha('color')}\\]\n \\[\n \\text{set}(h,'\\text{EdgeColor}','none','\\text{FaceColor}','\\text{interp}',...\n '\\text{FaceAlpha}','\\text{interp}')\\]\n\n3. Install the rampdown alphamap and increase each value in the alphamap by .1 to achieve the desired degree of transparency. Specify the hsv colormap.\n\n \\[\n \\text{alphamap('rampdown')}\\]\nalphamap('increase', .1)\ncolormap(hsv)\n\nThis alphamap causes the smallest values of the function (around zero) to be displayed with the least transparency and the greatest values to display with the most transparency. This enables you to see through the slice planes, while at the same time preserving the data around zero.\n# Creating 3-D Models with Patches\n\n<table>\n<thead>\n<tr>\n<th>Topic</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Introduction to Patch Objects (p. 5-2)</td>\n<td>Overview of what a patch object is and how to define one</td>\n</tr>\n<tr>\n<td>Multifaceted Patches (p. 5-7)</td>\n<td>Shows how to define a 3-D patch object using both x-, y-, and z-coordinate and faces/vertices data, and illustrates flat and interpolated face coloring</td>\n</tr>\n<tr>\n<td>Specifying Patch Coloring (p. 5-14)</td>\n<td>How to specify patch coloring using various patch properties</td>\n</tr>\n<tr>\n<td>Patch Edge Coloring (p. 5-16)</td>\n<td>Details about how MATLAB determines patch edge coloring</td>\n</tr>\n<tr>\n<td>Interpreting Indexed and Truecolor Data (p. 5-19)</td>\n<td>Specifying color data that uses colormaps or defines explicit colors</td>\n</tr>\n</tbody>\n</table>\nIntroduction to Patch Objects\n\n- “Defining Patches” on page 5-2\n- “Behavior of the patch Function” on page 5-3\n- “Creating a Single Polygon” on page 5-4\n\nA patch graphics object is composed of one or more polygons that may or may not be connected. Patches are useful for modeling real-world objects such as airplanes or automobiles, and for drawing 2- or 3-D polygons of arbitrary shape.\n\nIn contrast, surface objects are rectangular grids of quadrilaterals and are better suited for displaying planar topographies such as the values of mathematical functions of two variables, the contours of data in a rectangular plane, or parameterized surfaces such as spheres.\n\nA number of MATLAB functions create patch objects — fill, fill3, isosurface, isocaps, some of the contour functions, and patch. This section concentrates on use of the patch function.\n\nDefining Patches\n\nYou define a patch by specifying the coordinates of its vertices and some form of color data. Patches support a variety of coloring options that are useful for visualizing data superimposed on geometric shapes.\n\nThere are two ways to specify a patch:\n\n- By specifying the coordinates of the vertices of each polygon, which MATLAB connects to form the patch\n- By specifying the coordinates of each unique vertex and a matrix that specifies how to connect these vertices to form the faces\n\nThe second technique is preferred for multifaceted patches because it generally requires less data to define the patch; vertices shared by more than one face need be defined only once. This section provides examples of both techniques.\n**Behavior of the patch Function**\n\nThere are two forms of the patch function -- high-level syntax and low-level syntax. The behavior of the patch function differs somewhat depending on which syntax you use.\n\n**High-Level Syntax**\n\nWhen you use the high-level syntax, MATLAB automatically determines how to color each face based on the color data you specify. The high-level syntax enables you to omit the property names for the x-, y-, and z-coordinates and the color data, as long as you specify these arguments in the correct order.\n\n\\[\n\\text{patch(x-coordinates,y-coordinates,z-coordinates,colordata)}\n\\]\n\nHowever, you must specify color data so MATLAB can determine what type of coloring to use. If you do not specify color data, MATLAB returns an error.\n\n\\[\n\\text{patch(sin(t),cos(t))}\n\\]\n\n??? Error using ==> patch\nNot enough input arguments.\n\n**Low-Level Syntax**\n\nThe low-level syntax accepts only property name/property value pairs as arguments and does not automatically color the faces unless you also change the value of the FaceColor property. For example, the statement\n\n\\[\n\\text{patch('XData',sin(t),'YData',cos(t))} \\quad \\% \\text{Low-level syntax}\n\\]\n\ndraws a patch with white face color because the factory default value for the FaceColor property is the color white.\n\n\\[\n\\text{get(0,'FactoryPatchFaceColor')}\n\\]\n\\[\n\\text{ans =}\n\\]\n\\[\n\\begin{bmatrix}\n1 \\\\\n1 \\\\\n1\n\\end{bmatrix}\n\\]\n\nSee the list of patch properties in the MATLAB Function Reference and the get command for information on how to obtain the factory and user default values for properties.\nInterpreting the Color Argument\nWhen you use the low-level syntax, MATLAB interprets the third (or fourth if there are z-coordinates) argument as color data. If you intend to define a patch with x-, y-, and z-coordinates, but leave out the color, MATLAB interprets the z-coordinates as color data, and then draws a 2-D patch. For example,\n\n\\[ h = \\text{patch}(\\sin(t), \\cos(t), 1: \\text{length}(t)) \\]\n\ndraws a patch with all vertices at \\( z = 0 \\), colored by interpolating the vertex colors (since there is one color for each vertex), whereas\n\n\\[ h = \\text{patch}(\\sin(t), \\cos(t), 1: \\text{length}(t), 'y') \\]\n\ndraws a patch with vertices at increasing values of \\( z \\), colored yellow.\n\n“Specifying Patch Coloring” on page 5-14 provides more information on options for coloring patches.\n\nCreating a Single Polygon\nA polygon is simply a patch with one face. To create a polygon, specify the coordinates of the vertices and color data with a statement of the form\n\n\\[ \\text{patch}(x\\text{-coordinates}, y\\text{-coordinates}, [z\\text{-coordinates}], \\text{colordata}) \\]\n\nFor example, these statements display a 10-sided polygon with a yellow face enclosed by a black edge. The \\text{axis equal} command produces a correctly proportioned polygon.\n\n\\[ t = 0: \\pi/5: 2* \\pi; \\]\n\\[ \\text{patch}(\\sin(t), \\cos(t), 'y') \\]\n\\[ \\text{axis equal} \\]\nThe first and last vertices need not coincide; MATLAB automatically closes each polygonal face of the patch. In fact, it is generally better to define each vertex only once, particularly if you are using interpolated face coloring.\n\n**Interpolated Face Colors**\n\nYou can control many aspects of the patch coloring. For example, instead of specifying a single color, you can provide a range of numerical values that map the color at each vertex to a color in the figure colormap.\n\n```matlab\na = t(1:length(t)-1); %remove redundant vertex definition\npatch(sin(a),cos(a),1:length(a),'FaceColor','interp')\ncolormap cool;\naxis equal\n```\nMATLAB now interpolates the colors across the face of the patch. You can color the edges of the patch the same way, by setting the edge colors to be interpolated. The command is\n\n```matlab\npatch(sin(t),cos(t),1:length(t),'EdgeColor','interp')\n```\n\n“Specifying Patch Coloring” on page 5-14 provides more information on options for coloring patches.\nMultifaceted Patches\n\n- “Example — Defining a Cube” on page 5-7\n- “Modifying Patch Data” on page 5-10\n\nIf you specify the x-, y-, and z-coordinate arguments as vectors, MATLAB draws a single polygon by connecting the points. If the arguments are matrices, MATLAB draws one polygon per column, producing a single patch with multiple faces. These faces need not be connected and can be self-intersecting.\n\nAlternatively, you can specify the coordinates of each unique vertex and the order in which to connect them to form the faces. The examples in this section illustrate both techniques.\n\nExample — Defining a Cube\nA cube is defined by eight vertices that form six sides. This illustration shows the coordinates of the vertices defining a cube in which the sides are one unit in length.\nSpecifying X, Y, and Z Coordinates\nEach of the six faces has four vertices. Because you do not need to close each polygon (i.e., the first and last vertices do not need to be the same), you can define this cube using a 4-by-6 matrix for each of the x-, y-, and z-coordinates.\n\n$$\n\\begin{array}{cccccc}\n0 & 1 & 1 & 0 & 0 & 0 \\\\\n1 & 1 & 0 & 0 & 1 & 1 \\\\\n1 & 1 & 0 & 0 & 1 & 1 \\\\\n0 & 1 & 1 & 0 & 0 & 0 \\\\\n0 & 0 & 1 & 1 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 1 \\\\\n\\end{array}\n$$\n\nEach column of the matrices specifies a different face. Note that while there are only eight vertices, you must specify 24 vertices to define all six faces. Since each face shares vertices with four other faces, you can define the patch more efficiently by defining each vertex only once and then specifying the order in which to connect these vertices to form each face. The patch Vertices and Faces properties define patches in just this way.\n\nSpecifying Faces and Vertices\nThese matrices specify the cube using Vertices and Faces.\n\n```\nVertices\nx y z\n1st vertex 0 0 0\n2nd vertex 1 0 0\n3rd vertex 1 1 0\n4th vertex 0 1 0\n5th vertex 0 0 1\n6th vertex 1 0 1\nFaces\n1 2 6 5\n2 3 7 6\n3 4 8 7\n4 1 5 8\n5 6 7 8\n```\n\nThis data draws the first face by connecting vertices 1, 2, 6, and 5 in that order.\nUsing the vertices/faces technique can save a considerable amount of computer memory when patches contain a large number of faces. This technique requires the formal patch function syntax, which entails assigning values to the Vertices and Faces properties explicitly. For example,\n\n\\[\n\\text{patch('Vertices',vertex_matrix,'Faces',faces_matrix)}\n\\]\n\nBecause the high-level syntax does not automatically assign face or edge colors, you must set the appropriate properties to produce patches with colors other than the default white face color and black edge color.\n\n**Flat Face Color**\nFlat face color is the result of specifying one color per face. For example, using the vertices/faces technique and the FaceVertexCData property to define color, this statement specifies one color per face and sets the FaceColor property to flat.\n\n\\[\n\\text{patch('Vertices',vertex_matrix,'Faces',faces_matrix,...}\n\\quad \\text{'FaceVertexCData',hsv(6),'FaceColor','flat'})\n\\]\n\nBecause truecolor specified with the FaceVertexCData property has the same format as a MATLAB colormap (i.e., an \\(n\\)-by-3 array of RGB values), this example uses the \\text{hsv} colormap to generate the six colors required for flat shading.\n\n**Interpolated Face Color**\nInterpolated face color means the vertex colors of each face define a transition of color from one vertex to the next. To interpolate the colors between vertices, you must specify a color for each vertex and set the FaceColor property to interp.\n\n\\[\n\\text{patch('Vertices',vertex_matrix,'Faces',faces_matrix,...}\n\\quad \\text{'FaceVertexCData',hsv(8),'FaceColor','interp'})\n\\]\n\nChanging to the standard 3-D view and making the axis square,\n\n\\[\n\\text{view(3); axis square}\n\\]\n\nproduces a cube with each face colored by interpolating the vertex colors.\nTo specify the same coloring using the x, y, z, c technique, c must be an $m$-by-$n$-by-3 array, where the dimensions of x, y, and z are $m$-by-$n$.\n\nThis diagram shows the correspondence between the FaceVertexCData and CData properties.\n\n```\nFaceVertexCData =\n1.00 0.00 0.00\n1.00 0.75 0.00\n0.50 1.00 0.00\n0.00 1.00 0.25\n0.00 1.00 1.00\n0.00 0.25 1.00\n0.50 0.00 1.00\n1.00 0.00 0.75\n```\n\n```\nCData(:,1) =\n1.00 1.00 0.50 0.00 1.00 0.00\n1.00 0.50 0.00 1.00 1.00 0.00\n0.00 0.50 1.00 0.00 0.50 0.50\n0.00 0.00 0.50 1.00 0.00 1.00\n0.00 1.00 1.00\n0.00 0.75 1.00 1.00 0.00 1.00\n0.75 1.00 1.00 0.00 0.75 0.25\n0.25 0.00 0.00 1.00 1.00 0.00\n```\n\n```\nCData(:,2) =\nRed page\nGreen page\nBlue page\n```\n\n```\nCData(:,3) =\n```\n\n“Specifying Patch Coloring” on page 5-14 discusses coloring techniques in more detail.\n\n**Modifying Patch Data**\n\nIn general, if you define a patch with Faces and Vertices data and then want to modify its data, you should continue to use these same properties. Do not switch modes and modify the XData, YData, ZData, or CData properties.\nHow to Handle Mixed Data\nWhen you create a patch specified with Faces and Vertices data, MATLAB constructs arrays of data for the XData, YData, ZData and CData properties when you query them. However, these arrays contain only enough data to define the same number of vertices as there are referred to in the Faces property. If the number of vertices in the Vertices property is greater than the number of vertices used by the Faces property, then MATLAB cannot generate complete x, y, and z data from the faces and vertex data.\n\nWhile it is better to avoid mixing how you specify data when defining patches directly, you might need to modify patch data when using functions that themselves create patch objects. For example, the bar function creates patch objects to implement the bars in a graph.\n\n**Note** The barseries YData property enables you to modify the bar graph without the need to use the following steps. See the bar function for more information on working with bar graphs.\n\nThe function uses y-data values to determine the height of each bar, but creates each bar as the face of a patch specified by faces and vertices. For example,\n\n```matlab\nrand('state',4)\nh = bar(rand(10,1)); % y data for each bar\np = get(h,'children'); % get the handle of the patch\ncl = get(gca,'CLim');\n```\nBefore you can change the patch YData property, you must switch the patch to x, y, and z data as follows:\n\n```matlab\nxd = get(p,'XData');\nyd = get(p,'YData');\nzd = get(p,'ZData');\ncd = get(p,'CData');\nset(p,'XData',xd,'YData',yd,'ZData',zd,'CData',cd);\nset(gca,'CLim',cl)\n```\n\nThis setting of the XData, YData, ZData and CData properties causes the patch function to match the faces and vertex data with x, y, and z data. Note that because there is a change in the patch data, the color limits change, so you must use the original values for the axes CLim property.\n\nYou can now modify the y data values to change your graph. For example, the value of bar at x = 10 is 0.0122:\n\n```matlab\nyd(:,10)\nans =\n0\n```\nYou can change this bar by changes rows 2 and 3:\n\n\\[ yd(2:3,10) = [.65 .65]; \\]\n\nNow reset the patch YData property:\n\n```matlab\nset(p,'YData',yd)\n```\n\nAnother reason you might want to modify face-vertex data for bar graphs or other objects is to modify their CData to customize how they are colored. Techniques for doing this for 2–D and 3–D bar graphs are explained in “Coloring 2-D Bars According to Height” and “Coloring 3-D Bars According to Height” in the MATLAB Graphics documentation.\nSpecifying Patch Coloring\n\nPatch coloring is defined differently from surface object coloring in that patches do not automatically generate color data based on the value of the z-coordinate at each vertex. You must explicitly specify patch coloring, or MATLAB uses the default white face color and black edge color.\n\nYou can specify patch face coloring by defining\n\n- A single color for all faces\n- One color for each face, which is used for flat coloring\n- One color for each vertex, which is used for interpolated coloring\n\nSpecify the face color using either the CData property, if you are using x-, y-, and z-coordinates, or the FaceVertexCData property, if you are specifying vertices and faces.\n\nPatch Color Properties\n\nThis table summarizes the patch properties that control color (exclusive of those used when light sources are present).\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>CData</td>\n<td>Specify single, per face, or per vertex colors in conjunction with x, y, and z data</td>\n</tr>\n<tr>\n<td>CDataMapping</td>\n<td>Specifies whether color data is scaled or used directly as indices into the figure colormap</td>\n</tr>\n<tr>\n<td>FaceVertexCData</td>\n<td>Specify single, per face, or per vertex colors in conjunction with faces and vertices data</td>\n</tr>\n<tr>\n<td>EdgeColor</td>\n<td>Specifies whether edges are invisible, a single color, a flat color determined by vertex colors, or interpolated colors determined by vertex colors</td>\n</tr>\n<tr>\n<td>FaceColor</td>\n<td>Specifies whether faces are invisible, a single color, a flat color determined by vertex colors, or interpolated colors determined by vertex colors</td>\n</tr>\n</tbody>\n</table>\n### Specifying Patch Coloring\n\n<table>\n<thead>\n<tr>\n<th>Property</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MarkerEdgeColor</td>\n<td>Specifies the color of the marker, or the edge color for filled markers</td>\n</tr>\n<tr>\n<td>MarkerFaceColor</td>\n<td>Specifies the fill color for markers that are closed shapes</td>\n</tr>\n</tbody>\n</table>\n**Patch Edge Coloring**\n\n- “Example — Specifying Flat Edge and Face Coloring” on page 5-16\n- “Coloring Edges with Shared Vertices” on page 5-17\n\nEach patch face has a bounding edge, which you can color as\n\n- A single color for all edges\n- A flat color defined by the color of the vertex that precedes the edge\n- Interpolated colors determined by the two vertices that bound the edge\n\nNote that patch edge colors can be flat or interpolated only when you specify a color for each vertex. For flat edge coloring, MATLAB uses the color of the vertex preceding the edge to determine the color of the edge. The order in which you specify the vertices establishes which vertex colors a particular edge.\n\nThe following examples illustrate patch edge coloring:\n\n- “Example — Specifying Flat Edge and Face Coloring” on page 5-16\n- “Coloring Edges with Shared Vertices” on page 5-17\n\n**Example — Specifying Flat Edge and Face Coloring**\n\nThese statements create a square patch.\n\n```matlab\nv = [0 0 0; 1 0 0; 1 1 0; 0 1 0];\nf = [1 2 3 4];\nfvc = [1 0 0; 0 1 0; 1 0 1; 1 1 0];\npatch('Vertices',v,'Faces',f,'FaceVertexCData',fvc,...\n 'FaceColor','flat','EdgeColor','flat',...\n 'Marker','o','MarkerFaceColor','flat')\n```\n\n5-16\nPatch Edge Coloring\n\nThe `Faces` property value, `[1 2 3 4]`, determines the order in which MATLAB connects the vertices. In this case, the order is red, green, magenta, and yellow. If you change this order, the results can be quite different. For example, specifying the `Faces` property as\n\n```\nf = [4 3 2 1];\n```\n\nchanges the order to yellow, magenta, green, and red. Note that changing the order not only changes the color of the edges, but also the color of the face, which is the color of the first vertex specified.\n\n**Coloring Edges with Shared Vertices**\n\nEach patch face is bound by edges, which are line segments that connect the vertices. When patches have multiple faces that share vertices, some of the\nedges might overlap. In such cases, the edges of the most recently drawn face overlie previously drawn edges.\n\nFor example, this illustration shows a patch with four faces and flat colored edges (FaceColor set to none, EdgeColor set to flat).\n\nThe arrows indicate the order in which each edge is drawn in the first, second, third, and fourth face. The color at each vertex determines the color of the edge that follows it. Notice how the second edge in the first face would be green except that the second face drew its fourth edge from the magenta vertex. You can see similar effects in all shared edges.\n\nFor EdgeColor set to interp, MATLAB interpolates colors between adjacent vertices. In this case, the order in which you specify the vertices does not affect the edge color.\nInterpreting Indexed and Truecolor Data\n\n- “Indexed Color Data” on page 5-19\n- “Truecolor Patches” on page 5-22\n- “Interpolating in Indexed Color Versus Truecolor” on page 5-22\n\nMATLAB interprets the patch color data in one of two ways:\n\n- Indexed color data — Numerical values that are mapped to colors defined in the figure colormap\n- Truecolor data — RGB triples that define colors explicitly and do not make use of the figure colormap\n\nThe dimensions of the color data (CData or FaceVertexCData) determine how MATLAB interprets it. If you specify only one numeric value per patch, per face, or per vertex, then MATLAB interprets the data as indexed. If there are three numeric values per patch, face, or vertex, then MATLAB interprets the data as RGB values.\n\nIndexed Color Data\n\nMATLAB interprets indexed color data as either values to scale before mapping to the colormap, or directly as indices into the colormap. You control the interpretation by setting the CDataMapping property. The default is to scale the data.\n\nScaled Color\n\nBy default, MATLAB scales the color data so that the minimum value maps to the first color in the colormap, the maximum value maps to the last color in the colormap, and values in between are linearly transformed to span the colormap. This enables you to use colormaps of different sizes without changing your data and to use data in any range of values without changing the colormap.\n\nFor example, the following patch has eight triangular faces with a total of 24 (nonunique) vertices. The color data are integers that range from one to 24, but could be any values.\nThe variable \\( c \\) contains the color data. It is a 3-by-8 matrix, with each column specifying the colors for the three vertices of each face.\n\n\\[\nc = \n\\begin{bmatrix}\n1 & 4 & 7 & 10 & 13 & 16 & 19 & 22 \\\\\n2 & 5 & 8 & 11 & 14 & 17 & 20 & 23 \\\\\n3 & 6 & 9 & 12 & 15 & 18 & 21 & 24\n\\end{bmatrix}\n\\]\n\nThe color bar (colorbar) on the right side of the patch illustrates the colormap used and indicates with the vertical axis which color is mapped to the respective data value.\n\nYou can alter the mapping of color data to colormap entry using the `caxis` command. This command uses a two-element vector \\([c_{\\text{min}} \\ c_{\\text{max}}]\\) to specify what data values map to the beginning and end of the colormap, thereby shifting the color mapping.\n\nBy default, MATLAB sets \\( c_{\\text{min}} \\) to the minimum value and \\( c_{\\text{max}} \\) to the maximum value of the color data of all graphics objects within the axes. However, you can set these limits to span any range of values and thereby\nshift the color mapping. See Calculating Color Limits in \"Axes Properties\" in the Using MATLAB Graphics documentation for more information.\n\nThe color data does not need to be a sequential list of integers; it can be any matrix with dimensions matching the coordinate data. For example,\n\n\\[\n\\text{patch}(x,y,z,\\text{rand}(\\text{size}(z)))\n\\]\n\n**Direct Color**\n\nIf you set the patch \\texttt{CDataMapping} property to \\texttt{direct},\n\n\\[\n\\text{set(patch\\_handle,'CDataMapping','direct')}\n\\]\n\nMATLAB interprets each color data value as a direct index into the colormap. That is, a value of 1 maps to the first color, a value of 2 maps to the second color, and so on.\n\nThe patch from the previous example would then use only the first 24 colors in the colormap.\nThis example uses integer color data. However, if the values are not integers, MATLAB converts them according to these rules:\n\n- If value is < 1, it maps to the first color in the colormap.\n- If value is not an integer, it is rounded to the nearest integer toward zero.\n- If value > length(colormap), it maps to the last color in the colormap.\n\nUnscaled color data is more commonly used for images where there is typically a colormap associated with a particular image.\n\n**Truecolor Patches**\n\nTruecolor is a means to specify a color explicitly with RGB values rather than pointing to an entry in the figure colormap. Truecolor generally provides a greater range of colors than can be defined in a colormap.\n\nUsing truecolor eliminates the mapping of data to colormap entries. On the other hand, you cannot change the coloring of the patch without redefining the color data (as opposed to just changing the colormap).\n\n**Interpolating in Indexed Color Versus Truecolor**\n\nWhen you specify interpolated face coloring, MATLAB determines the color of each face by interpolating the vertex colors. The method of interpolation depends on whether you specified truecolor data or indexed color data.\n\nWith truecolor data, MATLAB interpolates the numeric RGB values defined for the vertices. This generally produces a smooth variation of color across the face. In contrast, indexed color interpolation uses only colors that are defined in the colormap. With certain colormaps, the results can be quite different.\n\nTo illustrate this difference, these two patches are defined with the same vertex colors. Circular markers indicate the yellow, red, and blue vertex colors.\nInterpreting Indexed and Truecolor Data\n\nThe patch on the left uses indexed colors obtained from the six-element colormap shown next to it. The color data maps the vertex colors to the colormap elements indicated in the picture. With this colormap, interpolating from the cyan vertex to the blue vertex can include only the colors green, red, yellow, and magenta, hence the banding.\n\nInterpolation in RGB space makes no use of the colormap. It is simply the gradual transition from one numeric value to another. For example, interpolating from the cyan vertex to the blue vertex follows a progression similar to these values.\n\n\\[\n0\\ 1\\ 1,\\ 0\\ 0.9\\ 1,\\ 0\\ 0.8\\ 1,\\ \\ldots\\ 0\\ 0.2\\ 1,\\ 0\\ 0.1\\ 1,\\ 0\\ 0\\ 1\n\\]\n\nIn reality each pixel would be a different color so the incremental change would be much smaller than illustrated here.\n## Volume Visualization Techniques\n\n<table>\n<thead>\n<tr>\n<th>Title</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Overview of Volume Visualization (p. 6-3)</td>\n<td>Volume data visualization with MATLAB, including examples of available techniques</td>\n</tr>\n<tr>\n<td>Volume Visualization Functions (p. 6-5)</td>\n<td>Functions used for volume visualization</td>\n</tr>\n<tr>\n<td>Visualizing Scalar Volume Data (p. 6-7)</td>\n<td>Techniques available for visualizing scalar volume data</td>\n</tr>\n<tr>\n<td>Visualizing MRI Data (p. 6-8)</td>\n<td>Visualizing MRI data using 2- and 3-D contour slices, isosurfaces, isocaps, and lighting</td>\n</tr>\n<tr>\n<td>Exploring Volumes with Slice Planes (p. 6-14)</td>\n<td>Using slice planes to scan the interior of scalar volumes</td>\n</tr>\n<tr>\n<td>Connecting Equal Values with Isosurfaces (p. 6-19)</td>\n<td>Using isosurfaces to illustrate scalar fluid-flow data</td>\n</tr>\n<tr>\n<td>Isocaps Add Context to Visualizations (p. 6-21)</td>\n<td>Using isocaps to improve the shape definition of isosurface plots</td>\n</tr>\n<tr>\n<td>Visualizing Vector Volume Data (p. 6-26)</td>\n<td>Techniques for visualizing vector volume data, including scalar techniques, determining starting points for stream plots, and plotting subregions of volumes</td>\n</tr>\n<tr>\n<td>Stream Line Plots of Vector Data (p. 6-32)</td>\n<td>Using stream lines, slice planes, and contour lines in one graph</td>\n</tr>\n<tr>\n<td>Technique</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>-----------------------------------------------</td>\n<td>-----------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>Displaying Curl with Stream Ribbons (p. 6-35)</td>\n<td>Example using stream ribbon plots to display the curl of a vector field</td>\n</tr>\n<tr>\n<td>Displaying Divergence with Stream Tubes (p. 6-38)</td>\n<td>Example using stream tube plots to display the divergence of a vector field. Slice planes and contour lines enhance the visualization.</td>\n</tr>\n<tr>\n<td>Creating Stream Particle Animations (p. 6-41)</td>\n<td>Example using stream lines and stream particles to create an animation illustrating wind currents</td>\n</tr>\n<tr>\n<td>Vector Field Displayed with Cone Plots (p. 6-44)</td>\n<td>Example using cone plots, isosurfaces, lighting, and camera placement to visualize a vector field</td>\n</tr>\n</tbody>\n</table>\nOverview of Volume Visualization\n\n- “Examples of Volume Data” on page 6-3\n- “Selecting Visualization Techniques” on page 6-4\n- “Steps to Create a Volume Visualization” on page 6-4\n\nVolume visualization is the creation of graphical representations of data sets that are defined on three-dimensional grids. Volume data sets are characterized by multidimensional arrays of scalar or vector data. These data are typically defined on lattice structures representing values sampled in 3-D space. There are two basic types of volume data:\n\n- **Scalar volume data** contains single values for each point.\n- **Vector volume data** contains two or three values for each point, defining the components of a vector.\n\nExamples of Volume Data\n\nAn example of scalar volume data is that produced by the `flow` M-file. The `flow` data represents the speed profile of a submerged jet within an infinite tank. Typing\n\n```\n[x,y,z,v] = flow;\n```\n\nproduces four 3-D arrays. The x, y, and z arrays specify the coordinates of the scalar values in the array v.\n\nThe `wind` data set is an example of vector volume data that represents air currents over North America. You can load this data in the MATLAB workspace with the command\n\n```\nload wind\n```\n\nThis data set comprises six 3-D arrays: x, y, and z are the coordinate data for the arrays u, v, and w, which are the vector components for each point in the volume.\nSelecting Visualization Techniques\n\nThe techniques you select to visualize volume data depend on what type of data you have and what you want to learn. In general,\n\n- Scalar data is best viewed with isosurfaces, slice planes, and contour slices.\n- Vector data represents both a magnitude and direction at each point, which is best displayed by stream lines (particles, ribbons, and tubes), cone plots, and arrow plots. Most visualizations, however, employ a combination of techniques to best reveal the content of the data.\n\nThe material in these sections describes how to apply a variety of techniques to typical volume data.\n\nSteps to Create a Volume Visualization\n\nCreating an effective visualization requires a number of steps to compose the final scene. These steps fall into four basic categories:\n\n1. Determine the characteristics of your data. Graphing volume data usually requires knowledge of the range of both the coordinates and the data values.\n\n2. Select an appropriate plotting routine. The information in this section helps you select the right methods.\n\n3. Define the view. The information conveyed by a complex three-dimensional graph can be greatly enhanced through careful composition of the scene. Viewing techniques include adjusting camera position, specifying aspect ratio and project type, zooming in or out, and so on.\n\n4. Add lighting and specify coloring. Lighting is an effective means to enhance the visibility of surface shape and to provide a three-dimensional perspective to volume graphs. Color can convey data values, both constant and varying.\nMATLAB provides functions that enable you to apply a variety of volume visualization techniques. The following tables group these functions into two categories based on the type of data (scalar or vector) that each is designed to work with. The reference page for each function provides examples of the intended use.\n\n**Volume Visualization Functions**\n\n- “Functions for Scalar Data” on page 6-5\n- “Functions for Vector Data” on page 6-6\n\n**Functions for Scalar Data**\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>contourslice</td>\n<td>Draw contours in volume slice planes</td>\n</tr>\n<tr>\n<td>isocaps</td>\n<td>Compute isosurface end-cap geometry</td>\n</tr>\n<tr>\n<td>isocolors</td>\n<td>Compute the colors of isosurface vertices</td>\n</tr>\n<tr>\n<td>isonormals</td>\n<td>Compute normals of isosurface vertices</td>\n</tr>\n<tr>\n<td>isosurface</td>\n<td>Extract isosurface data from volume data</td>\n</tr>\n<tr>\n<td>patch</td>\n<td>Create a patch (multipolygon) graphics object</td>\n</tr>\n<tr>\n<td>reducepatch</td>\n<td>Reduce the number of patch faces</td>\n</tr>\n<tr>\n<td>reducevolume</td>\n<td>Reduce the number of elements in a volume data set</td>\n</tr>\n<tr>\n<td>shrinkfaces</td>\n<td>Reduce the size of each patch face</td>\n</tr>\n<tr>\n<td>slice</td>\n<td>Draw slice planes in volume</td>\n</tr>\n<tr>\n<td>smooth3</td>\n<td>Smooth 3-D data</td>\n</tr>\n<tr>\n<td>surf2patch</td>\n<td>Convert surface data to patch data</td>\n</tr>\n<tr>\n<td>subvolume</td>\n<td>Extract subset of volume data set</td>\n</tr>\n</tbody>\n</table>\n## Functions for Vector Data\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>coneplot</code></td>\n<td>Plot velocity vectors as cones in 3-D vector fields</td>\n</tr>\n<tr>\n<td><code>curl</code></td>\n<td>Compute the curl and angular velocity of a 3-D vector field</td>\n</tr>\n<tr>\n<td><code>divergence</code></td>\n<td>Compute the divergence of a 3-D vector field</td>\n</tr>\n<tr>\n<td><code>interpstreamspeed</code></td>\n<td>Interpolate streamline vertices from vector-field magnitudes</td>\n</tr>\n<tr>\n<td><code>streamline</code></td>\n<td>Draw stream lines from 2-D or 3-D vector data</td>\n</tr>\n<tr>\n<td><code>streamparticles</code></td>\n<td>Draw stream particles from vector volume data</td>\n</tr>\n<tr>\n<td><code>streamribbon</code></td>\n<td>Draw stream ribbons from vector volume data</td>\n</tr>\n<tr>\n<td><code>streamslice</code></td>\n<td>Draw well-spaced stream lines from vector volume data</td>\n</tr>\n<tr>\n<td><code>streamtube</code></td>\n<td>Draw stream tubes from vector volume data</td>\n</tr>\n<tr>\n<td><code>stream2</code></td>\n<td>Compute 2-D stream line data</td>\n</tr>\n<tr>\n<td><code>stream3</code></td>\n<td>Compute 3-D stream line data</td>\n</tr>\n<tr>\n<td><code>volumebounds</code></td>\n<td>Return coordinate and color limits for volume (scalar and vector)</td>\n</tr>\n</tbody>\n</table>\n**Visualizing Scalar Volume Data**\n\nTypical scalar volume data is composed of a 3-D array of data and three coordinate arrays of the same dimensions. The coordinate arrays specify the x-, y-, and z-coordinates for each data point.\n\nThe units of the coordinates depend on the type of data. For example, flow data might have coordinate units of inches and data units of psi.\n\n**Techniques for Visualizing Scalar Data**\n\nMATLAB supports a number of functions that are useful for visualizing scalar data:\n\n- **Slice planes** provide a way to explore the distribution of data values within the volume by mapping values to colors. You can orient slice planes at arbitrary angles, as well as use nonplanar slices. (For illustrations of how to use slice planes, see `slice`, a volume slicing example, and slice planes used to show context.) You can specify the data used to color isosurfaces, enabling you to display different information in color and surface shape (see `isocolors`).\n\n- **Contour slices** are contour plots drawn at specific coordinates within the volume. Contour plots enable you to see where in a given plane the data values are equal. See `contourslice` for an example.\n\n- **Isosurfaces** are surfaces constructed by using points of equal value as the vertices of `patch` graphics objects.\nVisualizing MRI Data\n\nAn example of scalar data includes Magnetic Resonance Imaging (MRI) data. This data typically contains a number of slice planes taken through a volume, such as the human body. MATLAB includes an MRI data set that contains 27 image slices of a human head. This section describes some useful techniques for visualizing MRI data.\n\nExample — Ways to Display MRI Data\n\nThis example illustrate the following techniques applied to MRI data:\n\n- A series of 2-D images representing slices through the head\n- 2-D and 3-D contour slices taken at arbitrary locations within the data\n- An isosurface with isocaps showing a cross section of the interior\n\nChanging the Data Format\n\nThe MRI data, \\( D \\), is stored as a 128-by-128-by-1-by-27 array. The third array dimension is used typically for the image color data. However, since these are indexed images (a colormap, \\( \\text{map} \\), is also loaded) there is no information in the third dimension, which you can remove using the \\text{squeeze} command. The result is a 128-by-128-by-27 array.\n\nThe first step is to load the data and transform the data array from 4-D to 3-D.\n\n```matlab\nload mri\nD = squeeze(D);\n```\n\nDisplaying Images of MRI Data\n\nTo display one of the MRI images, use the \\text{image} command, indexing into the data array to obtain the eighth image. Then adjust \\text{axis} scaling, and install the MRI colormap, which was loaded along with the data.\n\n```matlab\nimage_num = 8;\nimage(D(:, :, image_num))\naxis image\ncolormap(map)\n```\nSave the x- and y-axis limits for use in the next part of the example.\n\n```matlab\nx = xlim;\ny = ylim;\n```\n\n**Displaying a 2-D Contour Slice**\n\nYou can treat this MRI data as a volume because it is a collection of slices taken progressively through the 3-D object. Use `contourslice` to display a contour plot of a slice of the volume. To create a contour plot with the same orientation and size as the image created in the first part of this example, adjust the y-axis direction (`axis`), set the limits (`xlim`, `ylim`), and set the data aspect ratio (`daspect`).\n\n```matlab\ncontourslice(D,[],[],image_num)\naxis ij\nxlim(x)\nylim(y)\ndaspect([1,1,1])\n```\ncolormap('default')\n\nThis contour plot uses the figure colormap to map color to contour value.\n\nDisplaying 3-D Contour Slices\nUnlike images, which are 2-D objects, contour slices are 3-D objects that you can display in any orientation. For example, you can display four contour slices in a 3-D view. To improve the visibility of the contour line, increase the LineWidth to 2 points (one point equals 1/72 of an inch).\n\nphandles = contourslice(D,[],[],[1,12,19,27],8);\nview(3); axis tight\nset(phandles,'LineWidth',2)\n**Displaying an Isosurface**\n\nYou can use isosurfaces to display the overall structure of a volume. When combined with isocaps, this technique can reveal information about data on the interior of the isosurface.\n\nFirst, smooth the data with `smooth3`; then use `isosurface` to calculate the isodata. Use `patch` to display this data as a graphics object.\n\n```matlab\nDs = smooth3(D);\nhiiso = patch(isosurface(Ds,5),...\n 'FaceColor',[1,.75,.65],...\n 'EdgeColor','none');\n```\n\n**Adding an Isocap to Show a Cutaway Surface**\n\nUse `isocaps` to calculate the data for another patch that is displayed at the same isovalue (5) as the surface. Use the unsmoothed data (D) to show details of the interior. You can see this as the sliced-away top of the head.\n\n```matlab\nhcap = patch(isocaps(D,5),...\n 'FaceColor','interp',...\n 'EdgeColor','none');\n```\ncolormap(map)\n\n**Defining the View**\nDefine the view and set the aspect ratio (view, axis, daspect).\n\n```matlab\nview(45,30)\naxis tight\ndaspect([1,1,.4])\n```\n\n**Add Lighting**\nAdd lighting and recalculate the surface normals based on the gradient of the volume data, which produces smoother lighting (camlight, lighting, isonormals). Increase the AmbientStrength property of the isocap to brighten the coloring without affecting the isosurface. Set the SpecularColorReflectance of the isosurface to make the color of the specular reflected light closer to the color of the isosurface; then set the SpecularExponent to reduce the size of the specular spot.\n\n```matlab\nlightangle(45,30);\nset(gcf,'Renderer','zbuffer'); lighting phong\nisonormals(Ds,hiso)\nset(hcap,'AmbientStrength',.6)\nset(hiso,'SpecularColorReflectance',0,'SpecularExponent',50)\n```\n\n*Example of an Isocap*\nThe isocap uses interpolated face coloring, which means the figure colormap determines the coloring of the patch. This example uses the colormap supplied with the data.\n\nTo display isocaps at other data values, try changing the isosurface value or use the `subvolume` command. See the `isocaps` and `subvolume` reference pages for examples.\nExploring Volumes with Slice Planes\n\n- “Example — Slicing Fluid Flow Data” on page 6-14\n- “Modifying the Color Mapping” on page 6-17\n\nA slice plane (which does not have to be planar) is a surface that takes on coloring based on the values of the volume data in the region where the slice is positioned. Slice planes are useful for probing volume data sets to discover where interesting regions exist, which you can then visualize with other types of graphs (see the slice example). Slice planes are also useful for adding a visual context to the bound of the volume when other graphing methods are also used (see coneplot and “Stream Line Plots of Vector Data” on page 6-32 for examples).\n\nUse the slice function to create slice planes.\n\nExample — Slicing Fluid Flow Data\nThis example slices through a volume generated by the flow M-file.\n\n1. Investigate the Data\nGenerate the volume data with the command\n\n\\[\n[x, y, z, v] = \\text{flow};\n\\]\n\nDetermine the range of the volume by finding the minimum and maximum of the coordinate data.\n\n\\[\nx_{\\text{min}} = \\text{min}(x(:));\n\\]\n\n\\[\ny_{\\text{min}} = \\text{min}(y(:));\n\\]\n\n\\[\nz_{\\text{min}} = \\text{min}(z(:));\n\\]\n\n\\[\nx_{\\text{max}} = \\text{max}(x(:));\n\\]\n\n\\[\ny_{\\text{max}} = \\text{max}(y(:));\n\\]\n\n\\[\nz_{\\text{max}} = \\text{max}(z(:));\n\\]\n2. Create a Slice Plane at an Angle to the X-Axes\n\nTo create a slice plane that does not lie in an axes plane, first define a surface and rotate it to the desired orientation. This example uses a surface that has the same x- and y- coordinates as the volume.\n\n```matlab\nhslice = surf(linspace(xmin,xmax,100),\n linspace(ymin,ymax,100),\n zeros(100));\n```\n\nRotate the surface by -45 degrees about the x-axis and save the surface XData, YData, and ZData to define the slice plane; then delete the surface.\n\n```matlab\nrotate(hslice,[-1,0,0],-45)\nxd = get(hslice,'XData');\nyd = get(hslice,'YData');\nzd = get(hslice,'ZData');\ndelete(hslice)\n```\n\n3. Draw the Slice Planes\n\nDraw the rotated slice plane, setting the FaceColor to interp so that it is colored by the figure colormap, and set the EdgeColor to none. Increase the DiffuseStrength to .8 to make this plane shine more brightly after adding a light source.\n\n```matlab\nh = slice(x,y,z,v,xd,yd,zd);\nset(h,'FaceColor','interp','EdgeColor','none','\n 'DiffuseStrength',.8)\n```\n\nSet hold to on and add three more orthogonal slice planes at xmax, ymax, and zmin to provide a context for the first plane, which slices through the volume at an angle.\n\n```matlab\nhold on\nhx = slice(x,y,z,v,xmax,[],[]);\nset(hx,'FaceColor','interp','EdgeColor','none')\nhy = slice(x,y,z,v,[],ymax);\nset(hy,'FaceColor','interp','EdgeColor','none')\n```\nhz = slice(x,y,z,v,[],[],zmin);\nset(hz,'FaceColor','interp','EdgeColor','none')\n\n4. Define the View\n\nTo display the volume in correct proportions, set the data aspect ratio to [1,1,1] (daspect). Adjust the axis to fit tightly around the volume (axis) and turn on the box to provide a sense of a 3-D object. The orientation of the axes can be selected initially using rotate3d to determine the best view.\n\nZooming in on the scene provides a larger view of the volume (camzoom). Selecting a projection type of perspective gives the rectangular solid more natural proportions than the default orthographic projection (camproj).\n\ndaspect([1,1,1])\naxis tight\nbox on\nview(-38.5,16)\ncamzoom(1.4)\ncamproj perspective\n\n5. Add Lighting and Specify Colors\n\nAdding a light to the scene makes the boundaries between the four slice planes more obvious because each plane forms a different angle with the light source (lightangle). Selecting a colormap with only 24 colors (the default is 64) creates visible gradations that help indicate the variation within the volume.\n\nlightangle(-45,45)\ncolormap (jet(24))\nset(gcf,'Renderer','zbuffer')\nThe “Modifying the Color Mapping” on page 6-17 section shows how to modify how the data is mapped to color.\n\n**Modifying the Color Mapping**\n\nThe current colormap determines the coloring of the slice planes. This enables you to change the slice plane coloring by\n\n- Changing the colormap\n- Changing the mapping of data value to color\n\nSuppose, for example, you are interested in data values only between -5 and 2.5 and would like to use a colormap that mapped lower values to reds and higher values to blues (that is, the opposite of the default jet colormap).\n\n**Customizing the Colormap**\n\nThe first step is to flip the colormap (colormap, flipud).\n\n```\n colormap (flipud(jet(24)))\n```\n**Adjusting the Color Limits**\n\nAdjusting the color limits enables you to emphasize any particular data range of interest. Adjust the color limits to range from -5 to 2.4832 so that any value lower than the value -5 (the original data ranged from -11.5417 to 2.4832) is mapped into the same color. (See `caxis` and Axis Color Limits - The CLim Property in Axes Properties in the MATLAB documentation for an explanation of color mapping.)\n\n```\n caxis([-5,2.4832])\n```\n\nAdding a color bar provides a key for the data-to-color mapping.\n\n```\n colorbar('horiz')\n```\nConnecting Equal Values with Isosurfaces\n\nIsosurfaces are constructed by creating a surface within the volume that has the same value at each vertex. Isosurface plots are similar to contour plots in that they both indicate where values are equal.\n\nIsosurfaces are useful to determine where in a volume a certain threshold value is reached or to observe the spatial distribution of data by selecting various isovalues at which to generate a plot. The isovalue must lie within the range of the volume data.\n\nCreate isosurfaces with the isosurface and patch commands.\n\nExample — Isosurfaces in Fluid Flow Data\n\nThis example creates isosurfaces in a volume generated by the flow M-file. Generate the volume data with the command\n\n\\[\n[x,y,z,v] = \\text{flow};\n\\]\n\nTo select the isovalue, determine the range of values in the volume data.\n\n\\[\n\\text{min}(v(:))\n\\]\n\\[\n\\text{ans} =\n\\]\n\\[\n-11.5417\n\\]\n\\[\n\\text{max}(v(:))\n\\]\n\\[\n\\text{ans} =\n\\]\n\\[\n2.4832\n\\]\n\nThrough exploration, you can select isovalues that reveal useful information about the data. Once selected, use the isovalue to create the isosurface:\n\n- Use isosurface to generate data that you can pass directly to patch.\n- Recalculate the surface normals from the gradient of the volume data to produce better lighting characteristics (isonormals).\n- Set the patch FaceColor to red and the EdgeColor to none to produce a smoothly lit surface.\n- Adjust the view and add lighting (daspect, view, camlight, lighting).\n```matlab\nhpatch = patch(isosurface(x,y,z,v,0));\nisonormals(x,y,z,v,hpatch)\nset(hpatch,'FaceColor','red','EdgeColor','none')\ndaspect([1,4,4])\nview([-65,20])\naxis tight\ncamlight left;\nset(gcf,'Renderer','zbuffer'); lighting phong\n```\nIsocaps Add Context to Visualizations\n\n- “Other Isocap Applications” on page 6-22\n- “Defining Isocaps” on page 6-22\n- “Example — Adding Isocaps to an Isosurface” on page 6-23\n\nIsocaps are planes that are fitted to the limits of an isosurface to provide a visual context for the isosurface. Isocaps show a cross-sectional view of the interior of the isosurface for which the isocap provides an end cap.\n\nThe following two pictures illustrate the use of isocaps. The first is an isosurface without isocaps.\n\nThe second picture shows the effect of adding isocaps to the same isosurface.\nOther Isocap Applications\nSome additional applications of isocaps are shown in the following examples.\n\n- Isocaps show the interior of a cut-away volume.\n- Isocaps cap the end of a volume that would otherwise appear empty.\n- Isocaps enhance the visibility of the isosurface limits.\n\nDefining Isocaps\nIsocaps, like isosurfaces, are created as patch graphics objects. Use the isocaps command to generate the data to pass to patch. For example,\n\n```matlab\npatch(isocaps(voldata, isoval), ...'FaceColor', 'interp', ...'EdgeColor', 'none')\n```\n\ncreates isocaps for the scalar volume data `voldata` at the value `isoval`. You should create the isosurface using the same volume data and isovalue to ensure that the edges of the isocaps fit the isosurface.\n\nSetting the patch `FaceColor` property to `interp` results in a coloring that maps the data values spanned by the isocap to colormap entries. You can also set other patch properties to control the effects of lighting and coloring on the isocaps.\nExample — Adding Isocaps to an Isosurface\nThis example illustrates how to set coloring and lighting characteristics when working with isocaps. There are five basic steps:\n\n- Generate and process your volume data.\n- Create the isosurface and isocaps and set patch properties to control the coloring and lighting.\n- Create the isocaps and set properties.\n- Specify the view.\n- Add lights to the scene.\n\n1. Prepare the Data\nThis example uses a 3-D array of random (rand) data to define the volume data. The data is then smoothed (smooth3).\n\n```matlab\ndata = rand(12,12,12);\ndata = smooth3(data,'box',5);\n```\n\n2. Create the Isosurface and Set Properties\nUse isosurface and patch to create the isosurface and set coloring and lighting properties. Reduce the AmbientStrength, SpecularStrength, and DiffuseStrength of the reflected light to compensate for the brightness of the two light sources used to provide more uniform lighting.\n\nRecalculate the vertex normals of the isosurface to produce smoother lighting (isonormals).\n\n```matlab\nisoval = .5;\nh = patch(isosurface(data,isoval),...'\n'FaceColor','blue',...'\n'EdgeColor','none',...'\n'AmbientStrength',.2,...'\n'SpecularStrength',.7,...'\n'DiffuseStrength',.4);\nisonormals(data,h)\n```\n3. Create the Isocaps and Set Properties\nDefine the isocaps using the same data and isovalue as the isosurface. Specify interpolated coloring and select a colormap that provides better contrasting colors with the blue isosurface than those in the default colormap (colormap).\n\n```\npatch(isocaps(data, isoval), ...\n 'FaceColor', 'interp', ...\n 'EdgeColor', 'none')\ncolormap hsv\n```\n\n4. Define the View\nSet the data aspect ratio to [1,1,1] so that the display is in correct proportions (daspect). Eliminate white space within the axes and set the view to 3-D (axis tight, view).\n\n```\ndaspect([1,1,1])\naxis tight\nview(3)\n```\n\n5. Add Lighting\nTo add fairly uniform lighting, but still take advantage of the ability of light sources to make visible subtle variations in shape, this example uses two lights, one to the left and one to the right of the camera (camlight). Use Phong lighting to produce the smoothest variation of color (lighting). Phong lighting requires the zbuffer renderer.\n\n```\ncamlight right\ncamlight left\nset(gcf,'Renderer','zbuffer');\nlighting phong\n```\nIsocaps Add Context to Visualizations\nVisualizing Vector Volume Data\n\n- “Using Scalar Techniques with Vector Data” on page 6-26\n- “Specifying Starting Points for Stream Plots” on page 6-27\n- “Accessing Subregions of Volume Data” on page 6-30\n\nVector volume data contains more information than scalar data because each coordinate point in the data set has three values associated with it. These values define a vector that represents both a magnitude and a direction. The velocity of fluid flow is an example of vector data.\n\nMATLAB supports a number of techniques that are useful for visualizing vector data:\n\n- Stream lines trace the path that a massless particle immersed in the vector field would follow.\n- Stream particles are markers that trace stream lines and are useful for creating stream line animations.\n- Stream ribbons are similar to stream lines, except that the width of the ribbons enables them to indicate twist. Stream ribbons are useful to indicate curl angular velocity.\n- Stream tubes are similar to stream lines, but you can also control the width of the tube. Stream tubes are useful for displaying the divergence of a vector field.\n- Cone plots represent the magnitude and direction of the data at each point by displaying a conical arrowhead or an arrow.\n\nIt is typically the case that these functions best elucidate the data when used in conjunction with other visualization techniques, such as contours, slice planes, and isosurfaces. The examples in this section illustrate some of these techniques.\n\nUsing Scalar Techniques with Vector Data\n\nVisualization techniques such as contour slices, slice planes, and isosurfaces require scalar volume data. You can use these techniques with vector data by taking the magnitude of the vectors. For example, the wind data set returns\nthree coordinate arrays and three vector component arrays, \\( u, v, w \\). In this case, the magnitude of the velocity vectors equals the wind speed at each corresponding coordinate point in the volume.\n\n\\[\n\\text{wind\\_speed} = \\sqrt{u.^2 + v.^2 + w.^2};\n\\]\n\nThe array `wind_speed` contains scalar values for the volume data. The usefulness of the information produced by this approach, however, depends on what physical phenomenon is represented by the magnitude of your vector data.\n\n**Specifying Starting Points for Stream Plots**\n\nStream plots (stream lines, ribbons, tubes, and cones or arrows) illustrate the flow of a 3-D vector field. The MATLAB stream plotting routines (`streamline`, `streamribbon`, `streamtube`, `coneplot`, `stream2`, `stream3`) all require you to specify the point at which you want to begin each stream trace.\n\n**Determining the Starting Points**\n\nGenerally, knowledge of your data’s characteristics helps you select the starting points. Information such as the primary direction of flow and the range of the data coordinates helps you decide where to evaluate the data.\n\nThe `streamslice` function is useful for exploring your data. For example, these statements draw a slice through the vector field at a z value midway in the range.\n\n```matlab\nload wind\nzmax = max(z(:)); zmin = min(z(:));\nstreamslice(x,y,z,u,v,w,[],[],(zmax-zmin)/2)\n```\nThis stream slice plot indicates that the flow is in the positive $x$ direction and also enables you to select starting points in both $x$ and $y$. You could create similar plots that slice the volume in the $x$-$z$ plane or the $y$-$z$ plane to gain further insight into your data’s range and orientation.\n\n**Specifying Arrays of Starting-Point Coordinates**\n\nTo specify the starting point for one stream line, you need the $x$-, $y$-, and $z$-coordinates of the point. The `meshgrid` command provides a convenient way to create arrays of starting points. For example, you could select the following starting points from the wind data displayed in the previous stream slice.\n\n```matlab\n[sx,sy,sz] = meshgrid(80,20:10:50,0:5:15);\n```\n\nThis statement defines the starting points as all lying on $x = 80$, $y$ ranging from 20 to 50, and $z$ ranging from 0 to 15. You can use `plot3` to display the locations.\n\n```matlab\nplot3(sx(:),sy(:),sz(:),'*r');\naxis(volumebounds(x,y,z,u,v,w))\ngrid; box; daspect([2 2 1])\n```\nYou do not need to use 3-D arrays, such as those returned by `meshgrid`, but the size of each array must be the same, and `meshgrid` provides a convenient way to generate arrays when you do not have an equal number of unique values in each coordinate. You can also define starting-point arrays as column vectors. For example, `meshgrid` returns 3-D arrays.\n\n```matlab\n[sx, sy, sz] = meshgrid(80, 20:10:50, 0:5:15);\nwhos\nName Size Bytes Class \nsx 4x1x4 128 double array \nsy 4x1x4 128 double array \nsz 4x1x4 128 double array \n```\n\nIn addition, you could use 16-by-1 column vectors with the corresponding elements of the three arrays composing the coordinates of each starting point. (This is the equivalent of indexing the values returned by `meshgrid` as `sx(:), sy(:), and sz(:)`.)\n\nFor example, adding the stream lines produces\n\n```matlab\nstreamline(x, y, z, u, v, w, sx(:), sy(:), sz(:))\n```\nAccessing Subregions of Volume Data\n\nThe subvolume function provides a simple way to access subregions of a volume data set. subvolume enables you to select regions of interest based on limits rather than using the colon operator to index into the 3-D arrays that define volumes. Consider the following two approaches to creating the data for a subvolume — indexing with the colon operator and using subvolume.\n\nIndexing with the Colon Operator\n\nWhen you index the arrays, you work with values that specify the elements in each dimension of the array.\n\n```matlab\nload wind\nxsub = x(1:10,20:30,1:7);\nysub = y(1:10,20:30,1:7);\nzsub = z(1:10,20:30,1:7);\nusub = u(1:10,20:30,1:7);\nusub = u(1:10,20:30,1:7);\n\nvsub = v(1:10,20:30,1:7);\nwsub = w(1:10,20:30,1:7);\n```\nUsing the subvolume Function\n\nsubvolume enables you to use coordinate values that you can read from the axes. For example,\n\n\\[\n\\text{lims} = [100.64 \\ 116.67 \\ 17.25 \\ 28.75 \\ -0.02 \\ 6.86]; \\\\\n[xsub,ysub,zsub,usub,vsub,wsub] = \\text{subvolume}(x,y,z,u,v,w,\\text{lims});\n\\]\n\nYou can then use the subvolume data as inputs to any function requiring vector volume data.\nStream Line Plots of Vector Data\n\nMATLAB includes a vector data set called wind that represents air currents over North America. This example uses a combination of techniques:\n\n- Stream lines to trace the wind velocity\n- Slice planes to show cross-sectional views of the data\n- Contours on the slice planes to improve the visibility of slice-plane coloring\n\nExample\n\n1. Determine the Range of the Coordinates\nLoad the data and determine minimum and maximum values to locate the slice planes and contour plots (load, min, max).\n\n```matlab\nload wind\nxmin = min(x(:));\nxmax = max(x(:));\nymax = max(y(:));\nzmin = min(z(:));\n```\n\n2. Add Slice Planes for Visual Context\nCalculate the magnitude of the vector field (which represents wind speed) to generate scalar data for the slice command. Create slice planes along the x-axis at xmin, 100, and xmax, along the y-axis at ymax, and along the z-axis at zmin. Specify interpolated face coloring so the slice coloring indicates wind speed, and do not draw edges (sqrt, slice, FaceColor, EdgeColor).\n\n```matlab\nwind_speed = sqrt(u.^2 + v.^2 + w.^2);\nhsurfaces = slice(x,y,z,wind_speed,[xmin,100,xmax],ymax,zmin);\nset(hsurfaces,'FaceColor','interp','EdgeColor','none')\n```\n\n3. Add Contour Lines to the Slice Planes\nDraw light gray contour lines on the slice planes to help quantify the color mapping (contourslice, EdgeColor, LineWidth).\nhcont = ...\ncontourslice(x,y,z,wind_speed,[xmin,100,xmax],ymax,zmin);\nset(hcont,'EdgeColor',[.7,.7,.7],'LineWidth',.5)\n\n4. Define the Starting Points for the Stream Lines\nIn this example, all stream lines start at an x-axis value of 80 and span\nthe range 20 to 50 in the y direction and 0 to 15 in the z direction. Save\nthe handles of the stream lines and set the line width and color (meshgrid,\nstreamline, LineWidth, Color).\n\n[sx,sy,sz] = meshgrid(80,20:10:50,0:5:15);\nhlines = streamline(x,y,z,u,v,w,sx,sy,sz);\nset(hlines,'LineWidth',2,'Color','r')\n\n5. Define the View\nSet up the view, expanding the z-axis to make it easier to read the graph\n(view, daspect, axis).\n\nview(3)\ndaspect([2,2,1])\naxis tight\nSee coneplot for an example of the same data plotted with cones.\nDisplaying Curl with Stream Ribbons\n\nStream ribbons illustrate direction of flow, similar to stream lines, but can also show rotation about the flow axis by twisting the ribbon-shaped flow line. The streamribbon function enables you to specify a twist angle (in radians) for each vertex in the stream ribbons.\n\nWhen used in conjunction with the curl function, streamribbon is useful for displaying the curl angular velocity of a vector field. The following example illustrates this technique:\n\nExample\n\n1. Select a Subset of Data to Plot\nLoad and select a region of interest in the wind data set using subvolume. Plotting the full data set first can help you select a region of interest.\n\n```matlab\nload wind\nlims = [100.64 116.67 17.25 28.75 -0.02 6.86];\n[x,y,z,u,v,w] = subvolume(x,y,z,u,v,w,lims);\n```\n\n2. Calculate Curl Angular Velocity and Wind Speed\nCalculate the curl angular velocity and the wind speed.\n\n```matlab\ncav = curl(x,y,z,u,v,w);\nwind_speed = sqrt(u.^2 + v.^2 + w.^2);\n```\n\n3. Create the Stream Ribbons\n- Use meshgrid to create arrays of starting points for the stream ribbons. See “Starting Points for Stream Plots” in this chapter for information on specifying the arrays of starting points.\n- stream3 calculates the stream line vertices with a step size of .5.\nstreamribbon scales the width of the ribbon by a factor of 2 to enhance the visibility of the twisting (which indicates curl angular velocity).\n\nstreamribbon returns the handles of the surface objects it creates, which are then used to set the color to red (FaceColor), the color of the surface edges to light gray (EdgeColor), and slightly increase the brightness of the ambient light reflected when lighting is applied (AmbientStrength).\n\n\\[\n[sx \\ sy \\ sz] = \\text{meshgrid}(110,20:5:30,1:5); \\\\\n\\text{verts} = \\text{stream3}(x,y,z,u,v,w,sx,sy,sz,.5); \\\\\nh = \\text{streamribbon}(\\text{verts},x,y,z,cav,\\text{wind\\_speed},2); \\\\\n\\text{set}(h,\\text{FaceColor'},'r',... \\\\\n\\text{'}EdgeColor',[.7 .7 .7],..., \\\\\n\\text{'}AmbientStrength',.6)\n\\]\n\n4. Define the View and Add Lighting\n\nThe volumebounds command provides a convenient way to set axis and color limits.\n\nAdd a grid and set the view for 3-D (streamribbon does not change the current view).\n\ncamlight creates a light positioned to the right of the viewpoint and lighting sets the lighting method to Phong (which requires the Z-buffer renderer).\n\n\\[\n\\text{axis(volumebounds}(x,y,z,\\text{wind\\_speed})) \\\\\n\\text{grid on} \\\\\n\\text{view}(3) \\\\\n\\text{camlight right; } \\\\\n\\text{set(gcf,'Renderer','zbuffer'); lighting phong}\n\\]\nDisplaying Divergence with Stream Tubes\n\nStream tubes are similar to stream lines, except the tubes have width, providing another dimension that you can use to represent information.\n\nBy default, MATLAB indicates the divergence of the vector field by the width of the tube. You can also define widths for each tube vertex and thereby map other data to width.\n\nThis example uses the following techniques:\n\n- Stream tubes to indicate flow direction and divergence of the vector field in the wind data set\n- Slice planes colored to indicate the speed of the wind currents overlaid with contour line to enhance visibility\n\nInputs include the coordinates of the volume, vector field components, and starting locations for the stream tubes.\n\nExample\n\n1. Load Data and Calculate Required Values\n\nThe first step is to load the data and calculate values needed to make the plots. These values include\n\n- The location of the slice planes (maximum x, minimum y, and a value for the altitude)\n- The minimum x value for the start of the stream tubes\n- The speed of the wind (magnitude of the vector field)\n\n```matlab\nload wind\nxmin = min(x(:));\nxmax = max(x(:));\nymin = min(y(:));\nalt = 7.356; % z-value for slice and streamtube plane\nwind_speed = sqrt(u.^2 + v.^2 + w.^2);\n```\n2. Draw the Slice Planes\n\nDraw the slice planes (slice) and set surface properties to create a smoothly colored slice. Use 16 colors from the hsv colormap.\n\n```matlab\nhslice = slice(x,y,z,wind_speed,xmax,ymin,alt);\nset(hslice,'FaceColor','interp','EdgeColor','none')\ncolormap hsv(16)\n```\n\n3. Add Contour Lines to Slice Planes\n\nAdd contour lines (contourslice) to the slice planes. Adjust the contour interval so the lines match the color boundaries in the slice planes:\n\n- Call `caxis` to get the current color limits.\n- Set the interpolation method used by `contourslice` to `linear` to match the default used by `slice`.\n\n```matlab\ncolor_lim = caxis;\ncont_intervals = linspace(color_lim(1),color_lim(2),17);\nhcont = contourslice(x,y,z,wind_speed,xmax,ymin,...\n alt,cont_intervals,'linear');\nset(hcont,'EdgeColor',[.4 .4 .4],'LineWidth',1)\n```\n\n4. Create the Stream Tubes\n\nUse `meshgrid` to create arrays for the starting points for the stream tubes, which begin at the minimum x value, range from 20 to 50 in y, and lie in a single plane in z (corresponding to one of the slice planes).\n\nThe stream tubes (`streamtube`) are drawn at the specified locations and scaled to be 1.25 times the default width to emphasize the variation in divergence (width). The second element in the vector [1.25 30] specifies the number of points along the circumference of the tube (the default is 20). You might want to increase this value as the tube size increases, to maintain a smooth-looking tube.\n\nSet the data aspect ratio (daspect) before calling `streamtube`. \nStream tubes are surface objects, therefore you can control their appearance by setting surface properties. This example sets surface properties to give a brightly lit, red surface.\n\n```matlab\n[sx,sy,sz] = meshgrid(xmin,20:3:50,alt);\ndaspect([1,1,1]) % set DAR before calling streamtube\nhtubes = streamtube(x,y,z,u,v,w,sx,sy,sz,[1.25 30]);\nset(htubes,'EdgeColor','none','FaceColor','r',...\n 'AmbientStrength',.5)\n```\n\n### 5. Define the View\nThe final step is to define the view and add lighting (view, axis volumebounds, Projection, camlight).\n\n```matlab\nview(-100,30)\naxis(volumebounds(x,y,z,wind_speed))\nset(gca,'Projection','perspective')\ncamlight left\n```\nCreating Stream Particle Animations\n\nA stream particle animation is useful for visualizing the flow direction and speed of a vector field. The \"particles\" (represented by any of the line markers) trace the flow along a particular stream line. The speed of each particle in the animation is proportional to the magnitude of the vector field at any given point along the stream line:\n\n**Example**\n\n1. **Specify the Starting Points of the Data Range to Plot**\n This example determines the region of the volume to plot by specifying the appropriate starting points. In this case, the stream plots begin at $x = 100$, $y$ spans 20 to 50 and in the $z = 5$ plane. Note that this is not the full volume bounds.\n\n ```\n load wind\n [sx sy sz] = meshgrid(100,20:2:50,5);\n ```\n\n2. **Create Stream Lines to Indicate the Particle Paths**\n This example uses stream lines (stream3, streamline) to trace the path of the animated particles. This adds a visual context for the animation. Another possibility is to set the EraseMode property of the stream particle to none, which would be useful for a single trace through the volume.\n\n ```\n verts = stream3(x,y,z,u,v,w,sx,sy,sz);\n sl = streamline(verts);\n ```\n\n3. **Define the View**\n While all the stream lines start in the $z = 5$ plane, the values of some spiral down to lower values. The following settings provide a clear view of the animation:\n\n - The viewpoint (view) selected shows both the plane containing most stream lines and the spiral.\n• Selecting a data aspect ratio (daspect) of \\([2 \\ 2 \\ 0.125]\\) provides greater resolution in the \\(z\\) direction to make the stream particles more easily visible in the spiral.\n\n• Set the axes limits to match the data limits (axis) and draw the axis box (box).\n\n\\[\n\\begin{align*}\n\\text{view}(-10.5,18) \\\\\n\\text{daspect([2 2 0.125])} \\\\\n\\text{axis tight; box on}\n\\end{align*}\n\\]\n\n4. **Calculate the Stream Particle Vertices**\n\nThe first step is to determine the vertices along the stream line where a particle should be drawn. The \\texttt{interpstreamspeed} function returns this data based on the stream line vertices and the speed of the vector data. This example scales the velocities by 0.05 to increase the number of interpolated vertices.\n\nSetting the axes \\texttt{DrawMode} property to \\texttt{fast} enables the animation to run faster.\n\nThe \\texttt{streamparticles} function sets the following properties:\n\n• \\texttt{Animate} to 10 to run the animation 10 times\n\n• \\texttt{ParticleAlignment} to \\texttt{on} to start all particle traces together\n\n• \\texttt{MarkerEdgeColor} to \\texttt{none} to draw only the face of the circular marker. Animations usually run faster when marker edges are not drawn.\n\n• \\texttt{MarkerFaceColor} to \\texttt{red}\n\n• \\texttt{Marker} to \\texttt{o}, which draws a circular marker. You can use other line markers as well.\n\n\\[\n\\begin{align*}\n\\texttt{iverts = interpstreamspeed(x,y,z,u,v,w,verts,0.05);} \\\\\n\\texttt{set(gca,'drawmode','fast');} \\\\\n\\texttt{streamparticles(iverts,15,...} \\\\\n\\texttt{'Animate',10,...} \\\\\n\\texttt{'ParticleAlignment','on',...} \\\\\n\\texttt{'MarkerEdgeColor','none',...}\n\\end{align*}\n\\]\n'MarkerFaceColor','red',...\n'Marker','o');\nVector Field Displayed with Cone Plots\n\nThis example plots the velocity vector cones for the wind data. The graph produced employs a number of visualization techniques:\n\n- An isosurface is used to provide visual context for the cone plots and to provide means to select a specific data value for a set of cones.\n- Lighting enables the shape of the isosurface to be clearly visible.\n- The use of perspective projection, camera positioning, and view angle adjustments composes the final view.\n\nExample\n\n1. Create an Isosurface\n\nDisplaying an isosurface within the rectangular space of the data provides a visual context for the cone plot. Creating the isosurface requires a number of steps:\n\n- Calculate the magnitude of the vector field, which represents the speed of the wind.\n- Use `isosurface` and `patch` to draw an isosurface illustrating where in the rectangular space the wind speed is equal to a particular value. Regions inside the isosurface have higher wind speeds, regions outside the isosurface have lower wind speeds.\n- Use `isonormals` to compute vertex normals of the isosurface from the volume data rather than calculate the normals from the triangles used to render the isosurface. These normals generally produce more accurate results.\n- Set visual properties of the isosurface, making it red and without drawing edges (`FaceColor`, `EdgeColor`).\n\n```matlab\nload wind\nwind_speed = sqrt(u.^2 + v.^2 + w.^2);\nhiso = patch(isosurface(x,y,z,wind_speed,40));\nisonormals(x,y,z,wind_speed,hiso);\nset(hiso,'FaceColor','red','EdgeColor','none');\n```\n2. Add Isocaps to the Isosurface\nIsocaps are similar to slice planes in that they show a cross section of the volume. They are designed to be the end caps of isosurfaces. Using interpolated face color on an isocap causes a mapping of data value to color in the current colormap. To create isocaps for the isosurface, define them at the same isovalue (isocaps, patch, colormap).\n\n\\[ \\text{hcap} = \\text{patch}(\\text{isocaps}(x,y,z,\\text{wind}\\_\\text{speed},40),... \\]\n\\[ '\\text{FaceColor}', '\\text{interp}',... \\]\n\\[ '\\text{EdgeColor}', '\\text{none'}); \\]\n\\[ \\text{colormap hsv} \\]\n\n3. Create First Set of Cones\n- Use daspect to set the data aspect ratio of the axes before calling coneplot so MATLAB can determine the proper size of the cones.\n- Determine the points at which to place cones by calculating another isosurface that has a smaller isovalue (so the cones are displayed outside the first isosurface) and use reducepatch to reduce the number of faces and vertices (so there are not too many cones on the graph).\n- Draw the cones and set the face color to blue and the edge color to none.\n\n\\[ \\text{daspect}([1,1,1]); \\]\n\\[ [f \\text{ verts}] = \\text{reducepatch}(\\text{isosurface}(x,y,z,\\text{wind}\\_\\text{speed},30),0.07); \\]\n\\[ \\text{h1} = \\text{coneplot}(x,y,z,u,v,w,\\text{verts(:,1)},\\text{verts(:,2)},\\text{verts(:,3)},3); \\]\n\\[ \\text{set(h1,}'\\text{FaceColor}'\\text{'},'blue','\\text{EdgeColor}'\\text{'},'none'); \\]\n\n4. Create Second Set of Cones\n- Create a second set of points at values that span the data range (linspace, meshgrid).\n- Draw a second set of cones and set the face color to green and the edge color to none.\nvolume Visualization Techniques\n\nxrange = linspace(min(x(:)),max(x(:)),10);\nyrange = linspace(min(y(:)),max(y(:)),10);\nzrange = 3:4:15;\n[cx,cy,cz] = meshgrid(xrange,yrange,zrange);\nh2 = coneplot(x,y,z,u,v,w,cx,cy,cz,2);\nset(h2,'FaceColor','green','EdgeColor','none');\n\n5. Define the View\n\n- Use the axis command to set the axis limits equal to the minimum and maximum values of the data and enclose the graph in a box to improve the sense of a volume (box).\n\n- Set the projection type to perspective to create a more natural view of the volume. Set the viewpoint and zoom in to make the scene larger (camproj, camzoom, view).\n\n axis tight\n box on\n camproj perspective\n camzoom(1.25)\n view(65,45)\n\n6. Add Lighting\n\nAdd a light source and use Phong lighting for the smoothest lighting of the isosurface (Phong lighting requires the Z-buffer renderer). Increase the strength of the background lighting on the isocaps to make them brighter (camlight, lighting, AmbientStrength).\n\ncamlight(-45,45)\nset(gcf,'Renderer','zbuffer');\nlighting phong\nset(hcap,'AmbientStrength',.6)\nA\nalpha values 4-3\nambient light 3-12\nAmbientLightColor property 3-7\n illustration 3-12\nAmbientStrength property 3-7\n illustration 3-12\naspect ratio 2-42 2-58\n for realistic objects 2-57\n for surface displays 2-55\n properties that affect 2-47\n specifying 2-52\naxes\n aspect ratio 2-42 2-47\n 3-D 2-42\n properties that affect 2-47\n specifying 2-52\ncamera properties 2-30\ncontrolling the shape of 2-52\ndefault aspect ratio 2-48\nlimits 2-42\n example 2-54\nplot box 2-9\nposition rectangle 2-31\nscaling 2-42\nstretch-to-fill 2-42\naxis 2-42\n auto 2-43\n equal 2-43\n ij 2-43\n illustrated examples, 3-D 2-44\n image 2-44\n manual 2-43\n normal 2-44\n square 2-43\n tight 2-43\n vis3d 2-43\n xy 2-43\nazimuth of viewpoint 2-5\ndefault 2-D 2-6\n limitations 2-8\n\nB\nBackFaceLighting property 3-8\n illustration 3-14\n brighten 1-20\n\nC\ncamdolly 2-21\ncamera position, moving 2-31 to 2-32\ncamera properties 2-30\n illustration showing 2-9\ncamera toolbar 2-10\nCameraPosition property 2-30\n and perspective 2-32\n fly-by 2-32\nCameraPositionMode property 2-30\nCameraTarget property 2-30\nCameraTargetMode property 2-30\nCameraUpVector property 2-30 2-34\n example 2-35\nCameraUpVectorMode property 2-30\nCameraViewAngle property 2-30\n and perspective 2-33\n zooming with 2-33\nCameraViewAngleMode property 2-31 2-34\ncamlookat 2-21\ncamorbit 2-21\ncampan 2-21\ncampos 2-21\ncamproj 2-21\ncamroll 2-21\ncamtarget 2-21\ncamup 2-21\ncamva 2-21\ncamzoom 2-21\nCData property\npatches 5-14\nCDataMapping property 1-18\npatches 5-14\ncolorbar 1-17\ncolormap 1-15\ncolormaps\naltering 1-20\nbrightening 1-20\nbrightness component of TV signal 1-21\ndisplaying 1-17\nfor surfaces 1-15\nfunctions that create 1-16\nrange of RGB values in 1-15\ncolors\ncolormaps 1-15\nindexed 1-14 to 1-15\ndirect 1-17\nscaled 1-17\ninterpreted by surfaces 1-15\nNTSC encoding of 1-21\nof patches 5-14\nof surface plots 1-14\nscaling algorithm 1-18\nspecifying for surface plot, example 1-18\ntruecolor 1-14\nspecifying 1-21\ntypical RGB values 1-15\ncone plots 6-44\ncoordinate system and viewpoint 2-5\n\nD\nDataAspectRatio property 2-47\nexample 2-52\nDataAspectRatioMode property 2-47\ndefault\naspect ratio 2-48\nazimuth\n2-D 2-6\n3-D 2-6\nCameraPosition 2-31\nCameraTarget 2-31\nCameraUpVector 2-31\nCameraViewAngle 2-31\nelevation\n2-D 2-6\n3-D 2-6\nProjection 2-31\nview 2-31\ndel2 1-19\ndiffuse reflection 3-11\nDiffuseStrength property 3-7\nillustration 3-11\ndirect color mapping 1-18\ndirection cosines 2-35\n\nE\ndge effects and lighting 3-15\nEdgeColor property 3-8\nEdgeLighting property 3-7\ndges of patches 5-17\nelevation of viewpoint 2-5\ndefault 2-D 2-6\ndefault 3-D 2-6\nlimitations 2-8\nexamples\n3-D graph 1-2\naxis 2-44\nchanging CameraPosition 2-32\nDataAspectRatio property 2-52\ndel2 1-19\ndirection cosines 2-35\ndisplaying real objects 2-55 2-57\nlinspace 1-10\nmeshgrid 1-4 1-10\nof lighting 3-2\nparametric surfaces 1-12\nplot3 1-4\nPlotBoxAspectRatio property 2-53\nspecifying truecolor\nsurfaces 1-21\nstretch-to-fill 2-52\ntexture mapping 1-24\nunevenly sampled data 1-9\nview 2-34\n\nF\nFaceColor property 3-8\nFaceLighting property 3-7\nFaces property 5-8\nFaceVertexCData property 5-10 5-14\nfly-by effect 2-32\n\nG\nGouraud lighting algorithm 3-9\ngraphs\n steps to create 3-D 1-2\ngriddata 1-10\n\nH\nHadamard matrix 1-12\nhidden 1-13\nhidden line removal 1-13\n\nI\nindexed color\n surfaces 1-14\nInfs, avoiding in data 1-7\ninterpolated colors\n patches 5-9\n indexed vs. truecolor 5-22\nisosurface\n illustrating flow data 6-19\n\nL\nLaplacian of a matrix 1-19\nlight 3-4\nlighting 3-2 3-18\n algorithms\n flat 3-9\n Gouraud 3-9\n Phong 3-9\nambient light 3-12\nbackface 3-14\ndiffuse reflection 3-11\nimportant properties 3-4\nproperties that affect 3-7\nreflectance characteristics 3-11 3-14\nspecular\n color 3-14\n exponent 3-13\n reflection 3-11\nlighting command 3-10\nlines\n removing hidden 1-13\nlinspace 1-9\n\nM\nmaterial command 3-11\nmathematical functions\n visualizing with surface plot 1-7\nmatrix\n Hadamard 1-12\n representing as\n surface 1-6\nmesh 1-6\nmeshgrid 1-7\nMRI data, visualizing 6-8\n\nN\nnonuniform data, plotting 1-9\nNormalMode property 3-8\nNTSC color encoding 1-21\n\northographic projection 2-37\n and Z-buffer 2-39\n\nparametric surfaces 1-11\npatch\n behavior of function 5-3\n interpreting color 5-4\npatches\n coloring 5-14\n edges 5-16\n face coloring\n flat 5-9\n interpolated 5-9\n indexed color 5-19\n direct 5-21\n scaled 5-19\n interpreting color data 5-19\n multifaceted 5-7\n single polygons 5-4\n specifying faces and vertices 5-8\n truecolor 5-22\n ways to specify 5-2\nperspective projection 2-37\n and Z-buffer 2-39\nPhong lighting algorithm 3-9\nplot box 2-9\nplot3 1-4\nPlotBoxAspectRatio property 2-47\n example 2-53\nPlotBoxAspectRatioMode property 2-47\nplotting\n 3-D\n matrices 1-4\n vectors 1-4\n nonuniform data 1-9\n surfaces 1-6\n polygons, creating with patch 5-2\n position rectangle 2-9\nprinting\n 3-D scenes 2-40\n projecting surfaces onto an axis 2-55\nProjection property 2-31\nprojection types 2-37 2-41\n camera position 2-38\n orthographic 2-37\n perspective 2-37\n rendering method 2-38\nrealism, adding with lighting 3-2\nrealistic display of objects 2-57\nreflection, specular and diffuse 3-11\nRenderer property 1-23\nRendererMode property 1-23\nRGB\n color values 1-15\nrgbplot 1-20\nrotation\n about viewing axis 2-34\n without resizing 2-34\nscaled color mapping 1-18\nslice planes\n colormapping 6-17\n slicing a volume 6-14\nspecular\n color 3-14\n exponent 3-13\n highlight 3-13\n reflection 3-11\nSpecularColorReflectance property 3-7\nillustration 3-14\nSpecularExponent property 3-7\n illustration 3-13\nSpecularStrength property 3-7\n illustration 3-11\nsphere 1-24\nstarting points for stream plots 6-27\nstream line plots 6-32\nstream plots\n starting points 6-27\nstretch-to-fill 2-42\n overriding 2-51\nsurf 1-6\nsurfaces\n CData 1-24\n coloring 1-14\n curvature mapped to color 1-19\n FaceColor 1-24\n parametric 1-11\n plotting 1-6\n nonuniformly sampled data 1-9\n texturemap 1-24\n\nT\ntexture mapping 1-23\nthree-dimensional objects, creating with\n patch 5-2\ntoolbar, camera 2-10\ntruecolor\n patches 5-22\n rendering method used for 1-23\n surface plots 1-21\n\nV\nvectors\n determined by direction cosines 2-35\nvertex normals and back face lighting 3-15\n VertexNormals property 3-8\nVertices property 5-8\nview 2-5\n azimuth of viewpoint 2-5\n camera properties 2-30\n coordinate system defining 2-5\n definition of 2-3\n elevation of viewpoint 2-5\n example of rotation 2-34\n limitation of azimuth and elevation 2-8\n limitations using 2-8\n MATLAB default behavior 2-31\n projection types 2-37\n specifying 2-30\n specifying with azimuth and elevation 2-5\nviewing axis 2-9\n moving camera along 2-32\nviewpoint, controlling 2-5 to 2-6 2-8\nvisualizing\n commands for volume data 6-5\n mathematical functions 1-7\n steps for volume data 6-4\n techniques for visualizing 6-4\nvolume data\n accessing subregions 6-30\n examples of 6-3\n MRI 6-8\n scalar 6-7\n slicing with plane 6-14\n steps to visualize 6-4\n techniques for visualizing 6-4\n vector 6-26\n visualizing 6-3\n\nW\nwire frame surface 1-6 1-13\n\nZ\nZ-buffer\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>orthographic projection</td>\n<td>2-39</td>\n</tr>\n<tr>\n<td>perspective projection</td>\n<td>2-39</td>\n</tr>\n<tr>\n<td>rendering truecolor</td>\n<td>1-23</td>\n</tr>\n<tr>\n<td>zooming by setting camera angle</td>\n<td>2-33</td>\n</tr>\n</tbody>\n</table>"}}},{"rowIdx":179,"cells":{"id":{"kind":"string","value":"7482d31892ccfe529a15e3fc63a842d7dae44e6a"},"text":{"kind":"string","value":"Visual GUI Testing in Practice: Challenges, Problems and Limitations\n\nEmil Alégroth · Robert Feldt · Lisa Ryrholm\n\nReceived: date / Accepted: date\n\nAbstract In today's software development industry, high-level tests such as Graphical User Interface (GUI) based system and acceptance tests are mostly performed with manual practices that are often costly, tedious and error prone. Test automation has been proposed to solve these problems but most automation techniques approach testing from a lower level of system abstraction. Their suitability for high-level tests has therefore been questioned. High-level test automation techniques such as Record and Replay exist, but studies suggest that these techniques suffer from limitations, e.g. sensitivity to GUI layout or code changes, system implementation dependencies, etc.\n\nVisual GUI Testing (VGT) is an emerging technique in industrial practice with perceived higher flexibility and robustness to certain GUI changes than previous high-level (GUI) test automation techniques. The core of VGT is image recognition which is applied to analyze and interact with the bitmap layer of a system's front end. By coupling image recognition with test scripts, VGT tools can emulate end user behavior on almost any GUI-based system, regardless of implementation language, operating system or platform. However, VGT is not without its own challenges, problems and limitations (CPLs) but, like for many other automated test techniques, there is a lack of empirically-based knowledge of these CPLs and how they impact industrial applicability. Crucially, there is also a lack of information on the cost of applying this type of test automation in industry.\n\nThis manuscript reports an empirical, multi-unit case study performed at two Swedish companies that develop safety-critical software. It studies their transition from manual system test cases into tests automated with VGT. In total, four different test suites that together include more than 300 high-level system test cases were automated for two multi-million lines of code systems. The results show that the transitioned test cases could find defects in the tested systems and that all applicable test cases could be automated. However, during these transition projects a number of hurdles had to be addressed; a total of 58 different CPLs were identified and then categorized into 26 types. We present these CPL types and an analysis of the implications for the transition to and use of VGT in industrial software development practice. In addition, four high-level solutions are presented that were identified during the study, which would address about half of the identified CPLs.\n\nFurthermore, collected metrics on cost and return on investment of the VGT transition are reported together with information about the VGT suites’ defect finding ability. Nine of the identified defects are reported, 5 of which were unknown to testers with extensive experience from using the manual test suites. The main conclusion from this study is that even though there are many challenges related to the transition and usage of VGT, the technique is still valuable, flexible and considered cost-effective by the industrial practitioners. The presented CPLs also provide decision support in the use and advancement of VGT and potentially other automated testing techniques similar to VGT, e.g. Record and Replay.\n\nKeywords Visual GUI Testing · Industrial case study · Challenges, Problems and Limitations · System and acceptance test automation · Development cost\n\nEmil Alégroth\nDepartment of Computer Science and Engineering\nChalmers University of Technology & University of Gothenburg\nSE-412 96 Gothenburg, Sweden\nTel.: +46703-338022\nE-mail: emil.alegroth@chalmers.se\n1 Introduction\n\n\nManual testing has long been the main approach for testing and quality assurance in software industry and in recent years there has been a renewed interest in approaches such as exploratory testing that focus on the creativity and experience of the tester [Itkonen and Rautiainen(2005a)]. The more traditional manual tests are often pre-defined sets of steps performed on a high level of system abstraction to verify or validate system conformance to its requirement specification, i.e. system tests, or that the system behaves as expected in its intended domain, i.e. acceptance tests [Miller and Collins(2001),Hsia et al(1997)Hsia, Kung, and Sell,Hsia et al(1994)Hsia, Gao, Samuel, Kung, Toyoshima, and Chen,Myers et al(2011)Myers, Sandler, and Badgett]. However, software is prone to change and therefore requires regression testing [Onoma et al(1998)Onoma, Tsai, Poonawala, and Suganuma,Rothermel et al(2001)Rothermel, Untch, Chu, and Harrold], which can lead to excessive costs since testers continuously need to re-test. Manually having to repeatedly follow the same test descriptions and look for the same problems is also tedious and error prone.\n\nTo mitigate these problems, whilst retaining or increasing the end quality of the software being tested, automated testing has been proposed as a key solution [Dustin et al(1999)Dustin, Rashka, and Paul]. Many automated test techniques approach testing from lower levels of system abstraction, e.g. unit tests [Olan(2003),Gamma and Beck(1999),Cheon and Leavens(2006)], which make them a powerful tool for finding component and function level defects. However, the use of these techniques for high-level testing has been questioned since empirical evidence suggests that high-level tests based on low-level test techniques become complex, costly and hard to maintain [Bernier et al(2005)Bernier, Weber, and Keller,Grechanik et al(2009a)Grechanik, Xie, and Fu].\n\nThus, a considerable body of work has been devoted to high-level test automation, resulting in techniques such as coordinate- and widget/component-based Record and Replay with a plethora of tools such as Selenium [Holmes and Kellogg(2006)], JFCUnit [Hackner and Memon(2008)], TestComplete [Vizulis and Diebelis(2012)], etc. The tools record the coordinates or properties of GUI-components during manual user interaction with the system’s GUI. These recordings can then be played back to emulate user interaction and assert system correctness automatically during regression testing. However, empirical studies have identified limitations with these techniques. They are typically sensitivity to GUI layout or code change and the tools are dependent on the specifics of the system implementation, etc., which negatively affect the techniques’ applicability and raises the cost of maintaining the tests [Horowitz and Singhera(1993),Sjösten-Andersson and Pareto(2006),Grechanik et al(2009b)Grechanik, Xie, and Fu,Bernier et al(2005)Bernier, Weber, and Keller].\n\nVisual GUI Testing is an emerging technique in industrial practice that combines scripting with image recognition in open source tools such as Sikuli [Yeh et al(2009)Yeh, Chang, and Miller], and commercial tools such as JAutomate [Alegrhot et al(2013b)Alegrhot, Nass, and Olsson]. Image recognition provides support for emulating user interaction with the bitmap components, e.g. images and buttons, shown to the user on the computer monitor and can therefore enable testing of GUI-based systems, regardless of their implementation, operating system or even platform. Empirical research has shown the technique’s industrial applicability for high-level test automation with equal or even better defect finding ability than its manual counterparts [Börjeson and Feldt(2012),Alegrhot et al(2013a)Alegrhot, Feldt, and Olsson]. However, VGT is not without its challenges, problems or limitations (CPLs), such as CPLs related to tool immaturity, image recognition volatility and limitations in use for highly animated GUIs. These CPLs have not been sufficiently explored in existing research and it is thus hard to give a balanced description of VGT to industrial practitioners as well as advice and help them in successfully applying the technique. Furthermore, we make no distinction between the three CPL subtypes in this paper, i.e. between challenges, problems and limitations, since a challenge in one context could be a problem in another. As such, we define a CPL as a challenge, problem or limitation that hinders the transition to or usage of VGT in a given context.\nbut where no distinction is made between the three CPL subtypes since their impact in different contexts will vary.\n\nIn this paper we present an empirical study performed at two different companies within the Swedish defense and security systems corporation Saab, in which two teams transitioned existing, manual system test cases to VGT test scripts. The two projects were independent from each other and in two different sites, one driven by a researcher and the other by industrial practitioners, yet both projects provided corroborating results. However, due to differences between the study contexts, this manuscript will report both corroborated, generalized, results and context dependent results. Context dependent results are reported together with the factors that affect their generalizability.\n\nDuring the study, a total of 58 CPLs were identified that were categorized into 26 unique CPL types that affect either the transition to or usage of VGT in industrial practice. These CPL types have implications for the industrial applicability of VGT but also other automated test techniques, e.g. adding frustration, confusion and cost to the transition and usage of the techniques. Consequently, the results of this study contribute to the general body of knowledge on automated testing, which is currently lacking empirical evidence regarding CPLs [Rafi et al(2012)].\n\nWe also present several CPL types that are present for other test techniques, e.g. how to synchronize scripts and the SUT, common to Record and Replay tools, misalignment between system implementation and specification which affects all testing, etc.\n\nIn addition, several solutions were identified during the study that solve most of the identified CPL types. However, since most of these solutions were ad hoc, and the focus of this work is on the VGT CPLs, only four general solutions will be presented. These solutions solve roughly half of the identified CPL types and provide guidance to industrial practitioners that intend to evaluate or use the technique.\n\nFurthermore, quantitative information regarding the VGT suites’ defect finding ability, the VGT suites’ development costs and the projects’ evaluated return on investment are presented. This information can provide decision support for industrial practitioners regarding the potential value and cost of transitioning their manual testing to VGT. Based on these results we draw a conclusion regarding the CPLs implications on the cost-effectiveness, value and applicability of VGT for high-level test automation in industry.\n\nWe also present, based on results from literature, that not only are the identified CPLs and solutions to said CPLs general for other VGT tools, but other test techniques as well. Thus providing a more general contribution of empirical results to the software engineering body of knowledge.\n\nTo summarize, the specific contributions of this work for test researchers and industrial practitioners are:\n\n- Detailed descriptions of the challenges, problems and limitations (CPLs) that impact either the transition to, or usage of, VGT in industry.\n- Descriptions of identified practices, from the industrial projects, which solve or mitigate CPLs that impact the transition to, or usage of, VGT in industry.\n- Quantitative information on the defect finding ability of the developed VGT suites compared to the manual test suites that were used as specification for the automated tests.\n- Detailed information on the cost of transition, usage and return on investment of the VGT suites in comparison to the cost of manual test suite execution.\n\nThe next section, Section 2, presents a background to manual testing and GUI-based testing as well as related work on previously used GUI-based test techniques and VGT. Sections 4 presents the results from the study, including identified VGT related CPLs, solutions to said CPLs, VGT bug finding ability, metrics on the cost of transitioning to VGT and ROI metrics. Section 5, presents a discussion regarding the results, future work, as well as the threats to validity of the study. Finally Section 7 will conclude the paper.\n\n2 Background and Related work\n\nThe purpose of high-level testing, e.g. system and acceptance testing, is to verify and/or validate system conformance to a set of measurable objectives for the system, i.e. the system’s requirements [Myers et al(2011)]. These tests are generally performed on a higher-level of system abstraction since their goal is to test the system in its entirety, which also makes them hard to automate, generally requiring large and complex test cases. Tests that are particularly hard to automate are non-functional/quality requirements (NFR) conformance tests for NFRs such as usability, user experience, etc. The reason is because NFRs differ from the functional requirements since they encompass the system in its entirety, i.e. they depend on the properties of a larger subset, or even all, of the functional components.\nHence, for a non-functional/quality requirement to be fulfilled, all, or most, of the components of the system have to adhere to that requirement, which is verified either during system or acceptance testing of the system. Both system and acceptance tests are, in general, based around scenarios [Regnell and Runeson(1998), Memon et al.(2003)Memon, Banerjee, and Nagarajan], but with the distinction that system tests only aim to verify the functionality of the system. In contrast, acceptance tests aim to validate the system-based on end user scenarios, i.e. how the system will be used in its intended domain. Note that we use the word scenario loosely in this context, i.e. not just documented scenarios, e.g. use cases, but ad hoc scenarios as well. These tests should, according to [Miller and Collins(2001), Hsia et al.(1997)Hsia, Kung, and Sell, Hsia et al.(1994)Hsia, Gao, Samuel, Kung, Toyoshima, and Chen, Myers et al.(2011)Myers, Sandler, and Badgett], be performed regularly on the system under test (SUT), preferably using automated testing. Automated testing is proposed because both manual system and acceptance testing are suggested to be costly, tedious and error-prone [Grechanik et al.(2009c)Grechanik, Xie, and Fu, Grechanik et al.(2009a)Grechanik, Xie, and Fu, Finsterwalder(2001), Leitner et al.(2007)Leitner, Ciupa, Meyer, and Howard, Memon(2002), Dustin et al.(1999)Dustin, Rashka, and Paul]. Therefore, a considerable amount of research has been devoted to high-level test automation techniques, which has resulted in both frameworks and tools, including graphical user interface (GUI) based interaction tools [Lowell and Stell-Smith(2003), Andersson and Bache(2004)].\n\nGUI-based test automation has received a lot of academic attention, with research into both high-level functional requirement and NFR conformance testing, as shown by Adamoli et al. [Adamoli et al.(2011)Adamoli, Zaparamuk, Jovic, and Hauswirth]. In their work on automated performance testing they identified 50 articles related to automated GUI testing using different techniques. One of the most common techniques they identified was capture/Record and Replay (R&R) [Adamoli et al.(2011)Adamoli, Zaparamuk, Jovic, and Hauswirth, Andersson and Bache(2004), Memon(2002)]. R&R is a two step approach, where user input, e.g. mouse and keyboard interaction performed on the SUT, are first captured in a recording, e.g. a script. In the second step, the recording is replayed to automatically interact with the SUT to assert correctness during regression testing. However, different R&R techniques capture recordings on different levels of system abstraction, i.e. from a GUI component level to the actual GUI bitmap level shown to the user on the computer’s monitor. The GUI bitmap level R&R techniques drive the test scenarios by replaying interactions at exact coordinates on the monitor, i.e. where the GUI interactions were performed by the user during recording. However, the assertions are generally performed on lower levels of system abstraction, i.e. component level, but some tools also support bitmap comparisons. In contrast, widget/component-based R&R techniques are performed completely on a GUI component level, i.e. by capturing properties of the GUI-components during recording and using these properties, in combination with direct interaction with the GUI components, e.g. invoking clicks, to perform interaction during playback. However, both of these techniques suffer from different limitations that affect their robustness, usability, cost, but foremost their maintainability, suggested by empirical evidence related to the technique [Memon and Soffa(2003), Zaraket et al.(2012)Zaraket et al., Masri, Adam, Hammoud, Hamzeh, Farhat, Khamissi, and Noujaim, Finsterwalder(2001), Li and Wu(2004), Grechanik et al.(2009b)Grechanik, Xie, and Fu, Horowitz and Singhera(1993)]. The coordinate-based R&R techniques are sensitive to GUI layout change [Memon(2002)], e.g. changing the GUI layout will cause the script to fail, whilst being robust to changes in the code of the tested system. Widget/component-based R&R techniques are instead sensitive to API or code structure change, whilst being robust to GUI layout change [Jösten-Andersson and Pareto(2006)]. In addition, the technique can pass test cases that a human user would fail, e.g. if a widget blocks another widget, the use of direct component interaction still allows the tool to interact with the hidden widget. Furthermore, because direct component interaction is used, the technique requires more direct access to the SUT, for instance through hooks added into the SUT or access to its GUI library, e.g. Java Swing, PyGTK, Eclipse RCP, etc., which limits the tools’ applicability. In addition, these tools can generally only interact with one GUI library at a time and also require special interaction code to be developed to interact with custom GUI components. Some exceptions exist, e.g. TestComplete [smartbear(2013)], which supports many different programming languages, or even interaction with the Windows operating system, but not other operating systems, e.g. MacOS. Hence, even though previous techniques have properties that support their use for high-level testing, they still suffer from limitations that perceivably limit their use for systems written in different programming languages, distributed systems, and cloud-based systems where access to the backend is limited. Thus, indicating that there is a need for more research into high-level test automation.\n\nVisual GUI Testing is an emerging technique in industrial practice that uses tools with image recognition capabilities to interact with the bitmap layer of a system, i.e. what is shown to the user on the computer’s monitor. Several VGT tools are available to the market, including both open source, e.g. Sikuli [Chang et al.(2010)Chang, Yeh, and Miller], and commercial, e.g. JAutomate [Alegrith et al.(2013)Alegrith, Nass, and Olsson], but still the technique is only sparsely used in industry. VGT is performed by either manual\ndevelopment, or recording, of scripts that define the intended interaction with the SUT, usually defined as scenarios, which also include images of the bitmap-components the tools should interact with, e.g. buttons. During script execution, the images are matched, using image recognition, against the SUT's GUI and if a match is found an interaction is performed. This capability is also used to assert system correctness by comparing expected visual output with actual visual output from the SUT. Hence, VGT uses image recognition both to drive the script execution and assert correctness compared to previous techniques where image recognition was only used in some tools for assertions. Furthermore, VGT is a blackbox technique, meaning that it does not require any knowledge of the backend and can therefore interact with any system, regardless of implementation language or development platform, e.g. desktop (Windows, MacOS, Linux, etc.), mobile (iPhone, Android, etc.), web (Javascript, HTML, XML, etc.).\n\nIn our previous work [Börjesson and Feldt(2012)], we performed an empirical, comparative, study with two VGT tools to identify initial support for the technique’s industrial applicability. The tools, Sikuli and CommercialTool\\(^1\\), were compared based on their static properties as well as their ability to automate industrial test cases for a safety-critical air traffic management system. 10 percent of the tested system’s manual test cases were automated with both tools, which showed that there was no statistical significant difference between the tools and that both tools were fully capable of performing the automation with equal defect finding ability as the manual test cases. However, the study was performed by academic experts in VGT and therefore a second study was performed, driven by industrial practitioners in an industrial project [Alegroth et al(2013a); Alegroth, Feldt, and Olsson]. Results of the second study showed that VGT is also applicable when performed in a real project environment when used by industrial practitioners under real-world time and cost constraints. Thus, providing further support that VGT is applicable in industry.\n\nThe study presented in this paper builds on our previous work but with another focus. Whilst the previous works have focused on the applicability of VGT, with successful and corroborating results that such is the case, this study focuses on the challenges, problems and limitations of VGT. Thus, information that is currently missing in the academic body of knowledge [Rafi et al(2012); Rafi, Moses, Petersen, and Mantyla]. Hence, this work aims to provide a more balanced view of the benefits and drawbacks of the technique based on empirically collected information. As such, providing both researchers and industrial practitioners with insights as to what hurdles they should focus on in research or expect when transitioning to VGT in practice. Furthermore, we also present the adaptations and architectural solutions that were taken in order for the companies to be successful in their VGT transition. Thus, contributing to research application rather than fundamental research of the technique and its tools. In addition, since the observed CPLs and solutions to said CPLs are identified to be generic for contexts other than VGT, our results and conclusions also provide a more general contribution to the academic body of knowledge regarding automated testing.\n\nA general conception within the software engineering community is that automated testing is key to solving all of industry's test-related problems. However, Rafi et al. [Rafi et al(2012); Rafi, Moses, Petersen, and Mantyla] that performed a systematic literature review regarding the benefits and limitations of automated testing, as well as an industrial survey on the subject, found little support for this claim. In their work, they scanned 24,706 academic reports but only found 25 reports with empirical evidence of the benefits and limitations of automated testing. Additionally, they found that most empirical work focus on benefits of automation rather than the limitations. Furthermore, the survey they conducted showed that 80 percent of the industrial participants, 115 participants in total, were opposed to fully automating all testing. In addition, they found that the industrial practitioners experienced a lack of tool support for automated testing, e.g. the tools are not applicable in their context, have high learning curves, etc. Consequently, their work shows that there are gaps in the academic body of knowledge regarding empirical work focusing on the benefits and in particular the limitations of automated testing as well as the actual needs for test automation in industry. A gap that this work helps to bridge by explicitly reporting on the challenges, problems and limitations related to high-level test automation using VGT.\n\n3 Industrial case study\n\nThe empirical study presented in this manuscript consisted of two VGT transition projects. VGT transition/automation is in this study defined as the practice or process of manually writing or recording a VGT test script that automatically performs GUI-based interactions and assertions on the system under test equivalent to a manual test case for said system under test. As such, a VGT (test) script is defined\n\n\\(^1\\) The name of CommercialTool can not be disclosed due to confidentiality reasons.\nas a programming artifact with coded interactions and GUI bitmaps that can be executed to autonomously stimulate a system under test through its GUI for test or automation purposes.\n\nThe first VGT transition project was performed at the company Saab AB, in the Swedish city of Gothenburg, building upon our previous work [Börjesson and Feldt(2012)]. The VGT transition was performed by a research team member with no prior knowledge of Saab or VGT but with frequent support from the research team. Focus was therefore on the applicability of VGT to automate a complete manual test suite for an industrial system and the challenges, problems and limitations (CPLs) of said VGT transition. Applicability is in this context defined as how well and at what cost a technique/process/practice can be implemented in a given context to provide benefit. As such, Visual GUI Testing is highly applicable in a context where it requires only small and cheap changes to implement and it gives quick return on investment, whilst it has low applicability in a context where requires large and costly changes to implement with slow return on investment.\n\nThe second VGT transition project was performed in another Saab company within the Saab corporation, in the Swedish city of Jär只需lla, and had two focuses. First, to evaluate if VGT could be applied in practice in an industrial project, results presented in [Alegroth et al.(2013a)Alegroth, Feldt, and Olsson]. Second, to evaluate the CPLs experienced by industrial practitioners during VGT transition in this context. As such, the second project was driven by industrial practitioners with minimal support of the research team.\n\nThe two projects complement each other by providing information of scientific rigor from the first project and information from the practical usage of VGT from the second project. Thus, this study contributes to the academic body of knowledge with the results from two empirical holistic case studies [Runeson and Höst(2009)] from two different companies2, in the continuation of this manuscript referred to as Case 1, the study in Gothenburg, and Case 2, the study in Jär只需lla. The two case studies were conducted in parallel, but with different research units of analysis [Runeson and Höst(2009)]. In Case 1 the unit of analysis was the VGT transition of one complete manual system test suite of a safety-critical air traffic management system, performed by experts from academia. In Case 2, the unit of analysis was instead the success or failure of the VGT transition project when performed in a practical context by industrial practitioners under real-world time and cost constraints. Consequently, Case 1 provided more detailed information about the VGT transition, whilst Case 2 provided information from a VGT transition project performed by industrial practitioners under practical conditions.\n\nIn the following subsections we first present the industrial projects and their context followed by two sections that give a more in depth view of the companies and how the projects were performed. Finally, in the fourth subsection, we will present the test suite architecture that was used in both companies.\n\n3.1 Industrial projects and Research Design\n\nBoth VGT transition projects were conducted in industry with two mature industrial software products/systems. In Case 1, the VGT scripts were developed from a scenario-based test suite intended to be performed manually by testers on a distributed, safety-critical, air traffic management system. The system consisted of an excess of 1 million lines of code developed in several programming languages with the bulk of it written in C# and XML. XML was used to configure the system for different customer needs. Configuration included, but was not limited to, changing the layout of the graphical user interface (GUI), data interface timeouts, the simulator environments, etc.\n\nFurthermore, the system’s GUI was shallow, meaning that it consisted of a set of GUI components that were continuously shown to the user with the property that interaction with a specific component did not obstruct or deny interaction with any other component in the GUI. An example of another application, that should be known to the reader, with this GUI property is a calculator application. As such, the GUI view was flat but the system’s backend functionality was advanced, i.e. airstrip and airport radar control. The GUI was also distributed across two separate, physical monitors connected to two computers and one server over a local area network. This system attribute required special consideration during the study that will be described in Section 3.2. In the development environment both parts of the GUI were controlled using a mouse and keyboard. However, after deployment at a customer one of the GUIs was instead controlled using a touchscreen monitor. The touchscreen monitor put specific requirements on the size and look and feel of the GUI components.\n\n2 Even though the companies are part of the same corporation they have no contact in practice and can be considered different organizations\nThe system has been developed in both plan-driven and iterative development projects that started with requirements acquisition activities, followed by development activities and finally testing activities. For each activity, a set of artifacts were developed, such as requirements specifications, design documents, user guides, test documentation, etc. However, for the study, the only document of interest was the system’s test description that specifies the manual test cases used for system testing. This system testing is typically performed once or twice every development iteration at the company, i.e. once or twice every six months. During such a system test, all test cases in the test description are performed and any behavioral deviations noted. The test cases were defined as scenarios that were documented in tables where each row defines input and expect output for each test step. Because of the system’s GUI was distributed, most test cases also required the tester to physically move from one computer monitor to the other. A more detailed description of the test specification can be found in Section 3.4.\n\nFurthermore, the system was developed in compliance with RTCA DO-278 quality assurance standard for airplane and air traffic management software. RTCA DO-278 compliance is required by the system’s customers that consist of domestic public and military airports as well as international public airports. The standard defines a set of test quality objectives that all test practices/techniques, the company use, must adhere to, including VGT.\n\nMost of the company’s developers hold masters of science and technology degrees and have, on average, three to five years of industrial experience as developers, testers and/or project managers. Furthermore, the company does not have dedicated testers, instead all testing is performed by the developers. The company has a hierarchal, yet flexible, organization, situated in two Swedish sites: Gothenburg and Växjö.\n\nIn Case 2 the VGT transition was performed for a battlefield control system that was both safety- and mission-critical. The system was distributed across several computers and tested with test cases that required interaction with several physical computers, which as stated required further consideration that will be explained in Section 3.2.\n\nDue to the limited involvement of the research team in Case 2, but primarily for confidentiality reasons, less can be disclosed about the system’s details. The product is however mature, i.e. it has been developed, maintained and deployed for many years, and is similar in terms of complexity and criticality as the system in Case 1. The system is used for military control and its main feature is to allow military commanders to track the movement of friendly and enemy forces on the battlefield. This feature is accomplished through a sophisticated map engine that allows the commander to drag and drop units onto the screen but also scroll around and scale the map for battlefield awareness and overview. Hence, the system is GUI-driven but with a deeper GUI than in Case 1. The deeper GUI means that interaction with a specific component from the set of all GUI components in the system can obstruct or deny interaction with another component on the GUI. An example of such an application, which should be familiar to the reader, is a webpage with several pages. Hence, the system has several views that, at least partly, cover each other. In the test environment manual interaction with the system is performed using a mouse and keyboard but when deployed, as for the system in Case 1, the system is controlled through a touchscreen monitor.\n\nDevelopment of the system was, at the time of the study, performed using an iterative process with regular manual testing performed by dedicated testers. However, the tested system did not adhere to any specific quality assurance standard. The look and feel of the system’s GUI was however specified by a military standard with specific regulations on button sizes and positioning to maximize its usability in a mobile environment, i.e. in a vehicle moving across rough terrain. Finally, the product’s main customer is a Swedish military contractor.\n\nFigure 1 visualizes the research process and the three parallel tracks that were performed by the researchers in Case 1, practitioners in Case 2 and the support and data acquisition performed by the research team. The information acquisition and support activities were continuous in Case 1 with members of the research team at Saab daily during the project. The VGT transition was performed by one member of the research team, supported by the other researchers and developers at the company when needed. Information was acquired according to a structured process that will be described in section 3.2.\n\nIn Case 2, personal support was only given during two full-day workshops on site whilst all other support activities were conducted over email or telephone. The workshops performed in Case 2 were also the main source of data acquisition from the company. In the first workshop, information such as what type of system they were working with, what the Sikuli test architecture would look like, etc., was acquired. In relation to the second workshop, two semi-structured, one hour, interviews were also held with the industrial practitioners to validate previously acquired information through triangulation. Consequently, the data acquisition in Case 2 was divided into three distinct phases, introduction (Workshop 1, in phase 1), data acquisition and implementation support through remote communication (Phase 2) and finally a retrospective analysis (Workshop 2, phase 3).\nAfter the completion of Case 1 and Case 2, all acquired information was analyzed to identify the CPLs. The input for the analysis was the detailed documentation of observations, the interview transcripts and the email correspondence from Case 2. When a potential CPL was identified through qualitative document analysis of the input information, its characteristics were compared to previously identified CPLs and if the new CPL was found to be unique the CPL would be abstracted and counted. The initial analysis found 58 CPLs. However, many of the CPLs had such similar characteristics that they could be grouped together into types, resulting in a reduction from the 58 identified CPLs to 26 unique types with one to seven CPLs in each type. In order to mitigate bias, this analysis was performed by a member of the research team that had not taken part in the VGT transition. Additionally, to mitigate bias and faulty assumptions made by the analyst, the 26 CPL types were discussed and validated with the participants of the study, i.e. the research team member from Case 1 and the industrial practitioners from Case 2, to ensure that the CPLs had been correctly identified. These CPL types were created to raise the abstraction level of some of the CPLs by removing or merging their characteristics and thereby make them more generalizable for other contexts. Some of the characteristics that were analyzed were,\n\n- Origin or cause of the CPL (VGT tool IDE, the image recognition, the manual test specification, etc.).\n- Where it was observed (Case 1, Case 2 or both).\n- Commonality to other CPLs (Iterative analysis of above characteristics).\n- Impact on transition or usage of VGT (Criticality of the CPL).\n- CPL solution (Solved during the project, feasible to solve in theory, not solvable)\n- Etc.\n\nThe two projects were performed mutually exclusively from one another, meaning that the researcher performing the VGT transition in Case 1 had no contact with the industrial practitioners in Case 2. All communication in Case 2 was performed by the other research team members. Thereby ensuring that corroborating evidence or information from one of the projects was not influenced by the other project.\n\nAfter identification, the CPLs were categorized into four tiers, with the 58 individual CPL observations on the lowest level of abstraction, i.e. Tier 4. The Tier 4 CPLs were then divided into 26 unique CPL types, Tier 3, that were then collected into eight types on a higher level of abstraction, Tier 2 CPLs, which could be grouped even further into three top tier CPL types, i.e. Tier 1 CPLs. Furthermore, the Tier 3 CPLs were analyzed to identify which were the most prominent CPLs in the projects. Prominence was evaluated based on occurrence in both projects, as well as more subjective measures, e.g. perceived negative impact.\non the transition or usage of VGT, added frustration to the VGT transition, and perceived external validity. Additionally, the characteristics listed above were also taken into consideration.\n\nFurthermore, this analysis revealed four high-level solutions that could be derived from the specific solutions that had been identified during the two projects. These four identified solutions are estimated to solve 50 percent of the identified CPLs and are presented in Section 4.5. The retaining 50 percent of the CPLs were either not solved or solved using ad hoc practices and solutions that were only applicable for specific CPLs. For instance, the VGT tool only supported a US keyboard which made it impossible to input special characters from the Swedish alphabet. This was solved by entering the ascii codes for said letters instead. Thus, solving the problem, but it could not solve any other CPL and it was only used in Case 1.\n\nProject cost and return on investment was also evaluated during the study by collecting quantitative metrics from both cases. In Case 1 the metrics were recorded in detail during the VGT transition. However, in Case 2 they were obtained primarily post project completion, i.e. during the interviews in Phase 3 of the study. In order to mitigate estimation bias the reported values were triangulated through the interview transcripts and previously collected data from Case 2. All information analysis was performed by a member of the research team that did not take part in the VGT transition project in Case 1 to mitigate bias in the results. It should be noted that due to the differences between the contexts of the two cases, many of the quantitative data points are context dependent and therefore only limited generalization can be done of said data, see Section 4.6. Finally, all conclusions drawn from the analyzed information were reviewed and validated by the study participants to eliminate bias introduced during the analysis.\n\n3.2 Detailed data collection in Case 1\n\nThe VGT transition in Case 1 started with an analysis of the automated test scripts that were developed in our previous work at Saab in Gothenburg to identify what should/could be reused [Börjesson and Feldt(2012)]. A thorough document analysis of the system under tests (SUT) manual test suite was also performed to evaluate if the previously developed VGT test scripts were still applicable. The document analysis was necessary because the version of the SUT differed from the system that had been used in [Börjesson and Feldt(2012)]. In addition, the document analysis was required for the research team member performing the VGT transition to get familiar with the SUT and our previous work. Because the VGT transition was performed at the company, any questions that the research team member had could quickly be resolved by asking a developer at the company, consulting the SUT documentation or asking one of the other research team members. The research team member who performed the VGT transition held a post-graduate degree in computer science but had no previous industrial experience.\n\nFurthermore, to ensure information quality the research team defined a thorough documentation process at this stage of the project. The process defined a set of quantitative and qualitative metrics and practices how these metrics should be collected for each developed VGT script and/or the VGT test suite. These metrics included, but were not limited to, development time of each test step and the entire test case, execution time of the test case, lines of code for each test step and the entire test case, CPLs found during development, etc. Specifically, the information collection focused on sources and causes of CPLs that affected the VGT transition, e.g. was the CPL related to the script, a GUI component, the VGT tool or the system. Practically, the data collection was done on printed forms or Excel sheets. All information was later transferred to Excel to simplify the analysis.\n\nEven though the version of the SUT differed from the one used in our previous work, the core functionality of the new version was the same as the old, i.e. airport landing and air traffic management. The main difference was that the new version only had one control position, whilst the old system had three, each with different capabilities for different operators. Consequently, the new version had limited functionality and analysis of the manual tests therefore showed that only 33 out of the 50 manual test cases, mentioned in [Börjesson and Feldt(2012)], were applicable. However, all of these 33, applicable, test cases could be automated and thereby constituted a complete test suite of Sikuli scripts for that particular version of the system.\n\nAs stated, the SUT was distributed over three computers, connected to one another over a local area network (LAN), which required the human tester to physically move around during manual system testing. In order to give Sikuli this capability, the tool was paired with a third part virtual network connection (VNC) software that provides support for remote computer control by streaming the target computers desktop to the viewing computer. VNC servers were added to the three computers of the system and connected, over LAN, to a fourth computer with a VNC viewer application that the Sikuli scripts were executed against.\nConsequently, the Sikuli scripts were executed remotely. In the continuation of this manuscript these four computers will be referred to as the test system which has been visualized in Figure 2.\n\nOnce the test system had been setup, an architecture was developed for the VGT test suite. The VGT scripts were implemented one at a time using the manual test cases as specifications. Thus, ensuring that each VGT script was a 1-to-1 mapped representation of the manual test case with equivalent GUI interactions and assertions. This VGT transition was possible because the test steps in the manual test cases were defined in sequential scenarios. The VGT suite architecture and script development will be presented in detail in Section 3.4. 33 manual test case descriptions where transitioned into VGT during the study, resulting in 33 equivalent automated VGT scripts. Several of these manual test scenarios were however applied to all components of the GUI, e.g. the same test scenario was applied on several different buttons to verify their functional conformance to their specification. Thus making the actual number of tests cases greater than the number of test case descriptions.\n\nDuring the VGT transition, the test scripts were executed after each test step had been developed and verified against the results of corresponding manual test step. The automated test steps were implemented as individual Python methods that were called in sequential order to perform the test scenario. This implementation approach made the scripts modular and allowed test steps to be reused. Modularity was one of the keywords for the VGT transition to ensure reusability and maintainability of the scripts. Modularization made it possible to run the Python methods out of order, thereby shortening script verification cost, since the entire test script did not have to be re-executed every time new functionality had been added or changed. Maintainability was also achieved since the Python methods are interchangeable and can simply be replaced if the scenario or functionality of the system under test is changed.\n\nA second keyword for the VGT transition was robustness. Robustness was achieved by implementing the scripts with three levels of failure redundancy for critical functions. The redundancy was put in place to mitigate catastrophic failure either due to image recognition failure, script failure, test system failure or defect detection in the tested system. This redundancy mainly consisted of several levels of exception handling that was implemented using Python.\n\nAs a final step of the VGT transition process, after a test script had completed, and successfully executed against the tested system, it was integrated into the VGT suite. In situations where erroneous test script behavior was identified post-integration into the VGT suite, the test script(s) were corrected and validated during execution of the entire VGT suite, i.e. execution of all the test cases in sequence. The validation process was rigorous and performed by comparing the outcome of each automated test step with the outcome of corresponding manual test step. This process was time consuming but required to ensure VGT script quality.\n\n3.3 Detailed data collection in Case 2\n\nCase 2 was driven by industrial practitioners and started with a three week long evaluation of VGT as a technique. Three tools were evaluated during this period, i.e. Sikuli [Yeh et al(2009)Yeh, Chang, and Miller], eggPlant [TestPlant(2013)] and Squish [froglogic(2013)], to identify the most suitable tool to fulfill\nthe company’s needs\\(^5\\). After the evaluation, Sikuli [Yeh et al(2009)Yeh, Chang, and Miller] was identified as the most suitable alternative for the transition. Further information regarding the VGT tool selection can be found in [Alegroth et al(2013a)Alegroth, Feldt, and Olsson].\n\nThe industrial practitioners held postgraduate degrees and had several years, i.e. 1-3 years per person, of industrial experience in testing among them. The majority of the VGT transition was performed by two testers. However, towards the end of the project a third tester joined the team but this person’s contributions to the project was considered negligible.\n\nSimilarly to the transition in Case 1, the industrial practitioners in Case 2 used their manual test cases as specifications for the automated test cases. However, since the testers possessed expert domain knowledge, not every test case was implemented as a 1-to-1 mapping to a manual test case. The deviations from the 1-to-1 mappings were required since the manual tests, defined as use cases, were not mutually exclusive from one another. This lack of mutual exclusion originated from the depth of GUI, i.e. its many views, which for some tests required certain use cases to be executed in order to put the system in a specific state for the assertion in a subsequent use case. Therefore some of the use cases that were used often were grouped together into a single script that could be called to setup the system in a given state before continuing the execution with more independent use cases. However, the manual test case architecture in Case 2 was perceived to provide the VGT suite with a higher degree of flexibility and reusability than the manual test architecture used in Case 1. The reason was because the test cases consisted of small interchangeable pieces, i.e. the use cases, which made the creation of new test cases very quick and simple. The manual test suites that were automated consisted of several hundred individual use cases that were transitioned into an estimated 300 automated test cases. An exact number cannot be given because of the flexible coupling between use cases that made it possible to create many test cases from just a few scripts.\n\nSimilar to the VGT suite developed in Case 1, the developed VGT suite in Case 2 was based around a main script that imported individual test cases and executed these according to a predefined order that was specified by the user. The order of test case execution could also be saved in the script. Thus, very little effort was required to setup and run the test suite.\n\nTo acquire information during the study, an information acquisition process was proposed to the industrial practitioners for the collection of quantitative and qualitative metrics. However, because Case 2 was performed during an actual development project in industry, the process could not be followed consistently due to time and cost constraints. Thus, lowering the quality of the collected information. This lack of information quality was compensated with triangulation and the interviews that were held in relation to the second workshop. The information collected by the industrial practitioners was conveyed in a continuous manner to the research team, as shown in Figure 1, through e-mail and over telephone.\n\n### 3.4 The VGT suites\n\nIn this study we do not consider the developed VGT suites, or their architecture, part of the main contributions of the work since the main focus of the study was on the challenges, problems and limitations (CPLs) that were identified during VGT transition and usage. However, to provide background and replicability of the study the following section will describe the developed VGT suites in more detail.\n\nThe input for the VGT transition were the scenario-based test case specifications that were used for manual system testing in Case 1 and 2. In Case 1 the test specification constituted a complete test suite with 67 manual test cases that were defined in table form. Each table constituted a test case scenario where each row was a test step of the scenario. The columns in turn defined the input and expected output. A test step was considered successful if the observed output was equal to the expected output. Further, if all test steps were successful in a test scenario then the test case was successful. The minimum number of steps (rows) in a test case was 1, the average was 7.88, median 6 and the maximum was 22. However, it should be noted that the number of manual test steps was not indicative of the effort required to run the scripts manually or to automate the tests since the level of detail in the natural language descriptions often differed. As such, a script with only a few steps could take longer to automate than a test case with many steps because these few steps defined many interactions with the SUT, whilst scripts with many steps often defined one interaction per step. These deviations originated from the test scripts being written by different people at different points in time. The tables were defined in a 126 page long Word document.\n\nIn Case 2 the test specification consisted of small use cases. Small in this context means only one or two human interactions with the system per use case. The use cases were defined as a custom sequence diagram notation with a bubble(s) showing what input the tester should give to the system on the left,\\(^3\\) eggPlant and Squish are commercial tools developed by TestPlant and Froglogic respectively.\nand system’s expected response in a bubble(s) to the right. However, these use cases only defined the test\nsteps. These use cases, examples shown in the right of Figure 3, were then tied together on a meta-level\nto form test scenarios, as shown in the left of Figure 3. Figure 3, on the left, exemplifies a test chain used\nin Case 2 which is made up from three different test flows, or scenarios. These scenarios all start with use\ncase 1 and 2, i.e. UC 1 and UC 2, and are then followed by one out of three exchangeable use cases, i.e.\nUC 3A, 3B or 3C (Middle of Figure 3). However, the manual test structure in Case 2 also allowed test\nscenarios to be of unequal length, exemplified with UC 3AA, bottom left of Figure 3. The three different\ntest chains are then joined again, and completed, by UC 4 (Bottom of Figure 3). This architecture allowed\nthe testers to switch use cases within the graph and thereby create different test scenarios. A test scenario\nwas successful if all expected outputs, from all uses cases in said scenario, were observed. Each interaction\nor observed result, i.e. bubble in the sequences, was defined in one to two sentences of natural language.\n\nThe VGT suites developed in Case 1 and Case 2 were similar in terms of architecture and were both built\nin Sikuli script, which is based on Python. Sikuli has support for writing individual VGT based component\ntests and includes special assertion methods for this type of testing, referred to in the tool as “unit tests” on\nGUI level. However, Sikuli does not have support for creating test suites of several individual unit tests. As\nsuch, to develop an entire test suite using Sikuli’s standard functionality, all test cases have to be grouped\ninto one file. However, this has negative effects on the reusability, maintainability, usability, etc., of the\ntests.\n\nCustom test suite solutions were therefore developed in both Case 1 and Case 2 by using Python’s object\norientation and its ability to import scripts into other scripts. Both VGT suites consisted of a main script\nthat imported the individual test cases and executed these according to an order specified in a list in the\nmain script. This list, or lists, could easily be defined manually or be generated at runtime to, for instance,\nrandomize the order of the test case execution. Thus, the individual test cases were coupled using the main\nscript. However, neither data-driven nor keyword-driven testing was used even though the tests could be\nrefactored to support these properties. The general architecture for the two VGT suites is visualized in\nFigure 4. As can be seen in the figure, each script was given a setup method, a test method, containing\nthe test steps of each test case, and a teardown method. Consequently, the VGT scripts followed the same\nframework as typically used for automated unit tests, e.g. JUnit [Cheon and Leavens(2006)]. This pattern\nwas supported by creating a skeleton script that was reused as the basis for all test cases.\n\nIn addition, user defined methods, variables to setup the VGT suite, etc., were extracted from the indi-\nvidual scripts and put in a set of support scripts that were then imported to the main script and/or the\ntest scripts that required them. Each test step was also defined as an individual method to increase mod-\nularity. The modular, and hierarchal, architecture helped shorten development time by simplifying reuse,\nbut also improved maintainability of the scripts since all components were easily accessible. Modularization\nalso improved robustness since it became easy to encapsulate all method calls to test steps with exception\nhandling. Thus, if a test step failed, the exception could be handled both locally in the individual scripts\nor on a global level in the main script.\n\nAll assertions were conducted through visual comparison between expected and actual output from\nthe SUT’s GUI using Sikuli’s image recognition capability. This was achieved using branch statements\nthat were defined as: if expected graphical output, then report pass and continue to the next test step, else\nreport fail and rerun the assertion. The reason why the assertion was rerun if it failed was to verify that\nFig. 4 The architecture of the VGT suites developed in Case 1 and Case 2. Each test script included a setup, a test and a teardown method. The test method in turn called the individual test step methods, thus separating the test step execution order from the actual test step implementation. This design perceptively improved maintainability and reusability of the test cases.\n\nthe cause of the failure was a fault in the SUT rather than a false positive caused by, for instance, failed image recognition. In Case 1, in addition to the above functionality, a second failed assertion resulted in the SUT being rerolled to a known state and the entire test case being rerun. If the same test step would fail again, the entire system would be restarted and the test case rerun a third time. This redundancy was implemented in order to with absolute certainty identify the cause of a failure. In Case 2 the only action that was taken after a failed assertion was to rerun the assertion.\n\nAnother difference between the VGT suite developed in Case 1 compared to Case 2 was how test result output was generated. In Case 1, the output was generated as textual log files using a custom solution that was spread across the main script and the individual test scripts. The solution documented the results of individual test steps but also summarized the results from each test case. In addition, the output included video recordings of failed script executions, created using the third party recording software Camtasia.\n\nIn Case 2, the output was produced using an open source Python library that formatted the output from the test scripts into an HTML file with similar graphical format to the output from automated unit tests, e.g. JUnit [Cheon and Leavens(2006)]. However, Case 2’s VGT suite did not record video clips of failed test scenarios, instead it took screenshots of the tested system’s faulty state when a test case failed. The screenshots were taken using a Java library that was called from the Python scripts.\n\nThe reason for adding screenshots and video recordings to the VGT suites’ output was to provide the SUT’s developers with more information to simplify defect identification and recreation. This functionality also helped the VGT script developers to distinguish defects in the SUT from defects in the VGT suite itself.\n\nIt should be noted that the VGT suite architecture presented in this manuscript is generally applicable but not necessary in most other tools than Sikuli [Yeh et al(2009)Yeh, Chang, and Miller]. The reason is because most VGT tools, e.g. JAutomate [Alegroth et al(2013b)] and EggPlant [TestPlant(2013)], have built in support for test suite creation and maintenance. As such, these tools also have built in failure mitigation and exception handling support. However, for individual test cases, we propose a general practice of using the setup, test and teardown design as described by unit test frameworks. This pattern encourages modularity and effectively separates the tests preconditions, tests and postconditions.\n\nAs stated, the test cases were implemented as 1-to-1 mappings of the manual test cases using a structured process where each test step was implemented and verified against the manual test case outcome. Furthermore, if a test script failed during test execution the failure would be evaluated to verify that it was caused by a SUT defect, i.e. evaluation of the assertion to verify its outcome. In Case 1 this practice was considered sufficient for verification since the system did not evolve during the course of the project. However, since the VGT suite was being developed in a real project in Case 2, all test cases and assertions\nwere verified with even intervals through complete executions of the manual test suite. This practice verified\nthat no test cases that should have failed were reported as successful. However, due to cost constraints,\nonly the standard test case execution order from test case 1 to n was evaluated. Thus, it is possible, but\nunlikely, that there could have been assertions that failed to report defective SUT behavior. However, it is\nunlikely that assertions that should have failed instead succeeded because of the sensitivity of the image\nrecognition that is more prone to failure than to succeeding when the expected output is not present on the\nscreen. However, since this behavior cannot be ruled out, a theoretical mitigation practice is to also verify\nsucceeding test scripts randomly post development.\n\n4 Results and Analysis\n\nThis section will present the main contributions of this work including the Challenges, Problems and\nLimitations (CPLs) related to the transition to and usage of VGT, potential solutions to these CPLs and\nresults regarding the bug-finding ability and ROI of the VGT transition. The Tier 3 CPLs (The 26 CPL\ntypes) are presented in the following subsections according to the order of the Tier 2 CPL types as they are\npresented in Figure 5. In addition, each Tier 3 CPL has been marked in the text with the number proceeding\nits name in Figure 5, i.e. CPL type x is marked as (x) in the text. Furthermore, in order to provide the\nreader with an overview of the distribution of the 58 CPLs (Tier 4), each subsection is proceeded with a\ntable how many CPLs there were of each type.\n\nSince the number of CPLs and types of CPLs are extensive we have summarized the main results for\neach type and provide a summary in Section 4.4, including a table listing the most prominent CPLs, Table\n5. The summary section also analyses if the identified CPLs have been found, or are likely to hold, also for\nalternative test techniques. Table 6 summarizes the outcome of this analysis.\n\nThe result section then continues with a description of the identified solutions to CPLs in Section\n4.5. These solutions have also been summarized in Table 7. This is followed by results regarding the bug\nfinding ability of the VGT test suites and quantitative results on the development time, execution time,\netc., and the evaluated return on investment of the VGT transition, summarized in Table 8. These results\nare presented together with a discussion regarding the impact of the results for industry and a theoretical\nmodel for the ROI in a general VGT transition project, presented in Figure 8.\n\n4.1 Test system version CPLs (Tier 1)\n\nThe Tier 1 CPL type related to the tested system (SUT) was split into five Tier 2 CPL types, as shown in\nFigure 5. These Tier 2 CPL types are related to the version of the SUT, the general SUT, defects in the\nSUT, the company or the SUT’s simulators. The following subsections will describe the CPL types related\nto these categories.\n\n4.1.1 Test system version (Tier 2)\n\nComplex systems with several versions and/or variants are associated with test related CPLs that affect\nall types of testing, including VGT. For instance, these system’s require appropriate version control to\nensure alignment between code and system specifications, e.g. test specifications. This CPL was observed\nin Case 1 where the SUT was a demo build of the product, intended for customer demonstrations rather\nthan customer delivery. As such, the SUT did not include all the functionality of the product (1), had a\nfaulty test specification (2), etc. The SUT was used during the project because of resource constraints (14),\ni.e. whilst the product SUT required 12 computers, including three servers, the demo system required only\nthree computers in total. Thus, lowering the costs for setting up the SUT and the VGT transition project\noverall. Resource/budget constraints is a common CPL in implementation and improvement projects in\nthe industrial context which limits the amount of evaluation and implementation that can be done.\n\nThe lack of documentation for the SUT in Case 1 required the research team to use a test specification\nfor another version of the system which was not aligned with the SUT’s functionality (2, 13). In addition,\nthe research team member who performed the VGT transition in Case 1 lacked domain knowledge which\nmade it difficult to evaluate which manual test cases were applicable before the starting a new script. As\nsuch, several scripts were already partially implemented before it was identified that they could not be\ncompleted. Thus, adding unnecessary costs to the transition project. Note that the cause of this CPL was\nthe lack of SUT functionality (1) rather than limitations in the VGT tool.\nIn addition, several of the manual test cases tested the SUT’s functionality incorrectly (2) or were out of date (4) and no longer valid because of changes to the SUT. Other tests were ambiguous (3) or aimed at testing functionality that had been removed (2). These test cases were reported to the company and were considered a positive side effect of the VGT transition. Thus, this CPL relates to the complexity of keeping test specifications up to date (4) as a mature system evolves into versions/variants over time. Consequently, it is important to evaluate the manual test suite before VGT transition to ensure that the test cases are applicable. Failure to do so will result in additional cost and erroneous automated test cases that in the worst case can lead to SUT defects propagating post customer delivery.\n\nHowever, identifying if a manual test specification is faulty requires domain and SUT knowledge, which, as previously stated, the research team member performing the VGT transition lacked. This lack of domain knowledge resulted in additional cost to the project because the company’s developers had to be consulted to, for instance, interpret ambiguous manual test cases, explain SUT functionality, etc. As such, it is perceived that VGT transition will be more effective if it is performed by a domain and/or SUT expert. A statement that is corroborated by the practitioners in Case 2 who reported that they had not found any test case that they could not automate.\n\nIn our previous work [Börjesson(2010)] we automated manual test cases for a version of the system with 50 manual test cases. However, for the main branch version of the system there were 67 manual test cases, of which only 33 were applicable on the version of the SUT used in Case 1. Hence, restricting the usability and portability of the developed VGT test suite for other versions or variants of the SUT.\n\nLack of functionality that prohibited automation of more manual test cases were, but not limited to, the SUT version’s lack of operator roles (1), missing GUI components (5), missing radar functionality (1),\n### Table 1\nSummary, and distribution, of problems, challenges and limitations (CPLs) related to the tested system out of the 58 CPLs that were found in total.\n\n<table>\n<thead>\n<tr>\n<th>CPL category</th>\n<th>CPL sub-category</th>\n<th>Nr. of (Tier 4) CPLs</th>\n<th>Percentage out of the 58 CPLs</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Test System</td>\n<td>Test System version</td>\n<td>20</td>\n<td>34.4</td>\n</tr>\n<tr>\n<td></td>\n<td>Test System (General)</td>\n<td>6</td>\n<td>10.3</td>\n</tr>\n<tr>\n<td></td>\n<td>Test System (Defects)</td>\n<td>6</td>\n<td>10.3</td>\n</tr>\n<tr>\n<td></td>\n<td>Test Company specific</td>\n<td>1</td>\n<td>1.72</td>\n</tr>\n<tr>\n<td></td>\n<td>Test System (Environment)</td>\n<td>1</td>\n<td>1.72</td>\n</tr>\n<tr>\n<td></td>\n<td>Total</td>\n<td>37</td>\n<td>58.44</td>\n</tr>\n</tbody>\n</table>\n\nIn summary, misalignment between system implementation and test specifications leads to partially completed test cases, faulty test results and additional transition cost. Missing system functionality leads to only partially completed test cases.\n\n#### 4.1.2 Test system (General) (Tier 2)\n\nOne of the CPLs that was reported to cause the most frustration during the study was that the VGT script execution had to be synchronized with the SUT’s execution (6). This CPL has been visualized in Figure 6. In the figure, the VGT tool’s image recognition is successful at time T0 and input is sent to the SUT which triggers a transition from State 0 to State 1. At time T1 the image recognition is once again successful because it occurs after the SUT has reached a stable state, State 1. However, at time Tx the image recognition fails because the SUT is currently transitioning from State 1 to State 2 where the sought GUI component is not yet visible on the SUT’s GUI. Thus causing a script failure.\n\nThis is a common scenario during VGT script development and requires the image recognition at Tx to be delayed until the SUT has reached the stable state in State 2. There are two approaches to add delays in, to the best of our knowledge, all VGT tools (6). The first approach is to delay the script dynamically until a sought GUI component is visible and the SUT is perceived to have reached a stable state. The second approach is statically wait for n number seconds before proceeding with the script execution. Dynamic delays are more robust to SUT performance change but can fail because they rely on the VGT tool’s image recognition algorithm. In contrast the static delay is completely robust but slows down script execution since the static delay has to be based on worst case SUT state transition time.\n\nHowever, even though delays improve VGT scripts robustness, they also add maintenance costs since they require realignment over time to match the SUT’s performance (6,7). Dynamic delays also require the sought GUI component (bitmap) to be updated over time. The practitioners in Case 2 reported that adding...\ndelays was frustrating because the script had to be rerun to verify its correctness. Additionally, since the worst case state transition time could only be estimated, static delays required some trial and error before they became robust.\n\nSynchronization was also a CPL in Case 1 because it was observed that the SUT’s state transition time increased after a couple of days if the computers were not restarted (7). Similar observations were made in Case 2, causing test scripts that had previously succeeded to fail (7). The solution for this CPL was simply to restart the computer(s) and it is therefore considered a minor CPL. However, the CPL is still worth mentioning since dips in state transition time shorter than a human can observe can cause the scripts to fail and cause frustration among the test script developers.\n\nIt should be noted that the synchronization CPL between scripts and the SUT is common to other automated testing techniques and that the general solution is to add delays to the scripts, as presented above (6).\n\nAnother CPL concerns unexpected SUT behavior (8) caused by events that are not part of the test scenario but which can interrupt the test script execution. This type of behavior can be caused by the SUT, the operating system (9) or third party software used to run the tested system or its surrounding environment. Events which cause this type of behavior are popups, e.g. software update messages or error messages, which are launched by the operating system, sudden performance dips due to, for instance, a new process being started by the operating system, hardware failure or a defect in the tested system, etc (8, 9).\n\nIn summary,\n\n– Synchronizing script execution with system execution is time consuming and one of the main sources of frustration during VGT transition.\n– Unexpected system behavior triggered by the system under test, operating system, etc., causes a lot of frustration and requires additional failure mitigation code.\n\n4.1.3 Test system (Defect) (Tier 2)\n\nDuring execution of a VGT suite practice, i.e. during regression testing, a VGT script would terminate after identifying a defect, report the defect in the test output, followed by a roll-back of the system to a known state before executing the next script. Consequently, a manual test case that identifies a defect at test step n can only be automated up to step n since the defect would prohibit any interaction with the tested system after this step. Additionally, even if the execution would not have been prohibited, all execution after identifying a defect at a test step could be in an invalid and/or useless system state that would not appear in real-world use of the system. Furthermore, continued execution after a test step has failed has a higher probability of reporting a false positive test results. Hence, reporting both test step x and test step x+n, dependent on the interaction at step x, as failed even though step x+n had passed if step x had passed. However, since the failure at step x could have been caused by failed image recognition it should not be assumed that the first failure shows the defect and the second is a false positive. Thus, both failures need to be investigated to find their cause, which adds cost. Therefore, the test suites in both Case 1 and 2 stopped script execution after an assertion failed, rolled back the system to a known state and continued with the next test case.\n\nHowever, not all SUT defects that lead to SUT failure are recoverable, many cause the SUT or the SUT’s GUI to freeze or crash (10, 11, 12). A human tester can resolve this by restarting the application, but for the VGT scripts it poses a CPL. If the defect in the SUT causes the SUT’s computer to crash or freeze then the VGT scripts can no longer access the SUT or resolve the situation (10, 11). However, if it is only the SUT that crashes or freezes, exception handling can be built into the VGT suite that automatically restarts the SUT.\n\nException handling of this type was implemented in Case 1 where a crash would result in the VGT application restarting the operating system of the SUT’s computer. This was possible since the VGT suite was run remotely over a Virtual Network Connection (VNC).\n\nSix SUT defects were identified during the study, of which four were previously known to the company in Case 1. However, the study also revealed two defects that were previously unknown or only partially known to the company. The reason why these previously unknown faults were uncovered by VGT was because of the quicker and more cost effective execution of the VGT suite compared to manual tests. This VGT property made it feasible to rerun test cases to find faults that only appeared sporadically during SUT interaction. One such defect, observed in Case 1, was in a tab menu in the SUT that did not always load.\nproperly during system startup. In combination with the video recording functionality of the VGT suite, described in Section 3.4, the faulty behavior of the system could be determined and reported in detail to the company. This example shows how the video recordings adds to defect finding ability. The identified defects were of different type, from defective GUI functionality, e.g. tabs not launching, to complex defects in the services of the tested system’s backend, e.g. missing alarms intended to warn the system user of incorrect or missing input from external interfaces. All of the defects were considered critical because of the safety-criticality of the SUT.\n\nIn Case 2, three unknown defects were identified in the SUT in addition to known defects found by the previously used manual testing. However, the reason why the defects had previously not been identified was different from Case 1. The manual test cases in Case 2 were always executed in order from test case 1 to test case n, once every development iteration, i.e. every six months to one year. Furthermore, due the company’s strict testing budget, not all of the manual test cases could be executed each iteration. In contrast to the manual tests, the VGT scripts could be executed several times every week and several times in row each time with different orderings among the test cases. These VGT properties lead to the discovery of the previously unknown defects, which the practitioners in Case 2 reported would not have been found if it hadn’t been for the VGT transition.\n\nThe defect finding ability of VGT is a strength but also presents a possible CPL, i.e. that a company becomes so confident with VGT that it is used as a substitute for manual testing. However, VGT is not perceived to be a replacement for manual testing, primarily because the technique can only find defects that are covered by an assertion in the test scenarios [Berner et al(2005)Berner, Weber, and Keller]. In contrast, human testers can also identify defects that are triggered by a scenario but not covered by an assertion. Hence, manual scenario based and exploratory testing is still required to complement VGT to uncover defects [Itkonen and Rautiainen(2005b)]. A statement that was corroborated by the practitioners in Case 2.\n\nThe results regarding how the unknown defects were identified also shows the importance of test case execution order. Executing test case x after test case y may not have the same outcome as executing test case y after test case x. In addition, executing test case x twice in a row can also lead to another outcome. Thus, providing support that the low cost of running a VGT suite can help uncover new defects by supporting multiple test executions in a row with different predetermined, or even random, test case orderings. A statement corroborated by [Rothermel et al(2001)Rothermel, Untch, Chu, and Harrold] since different orderings cover more system states and sequences of interaction that may appear during real-world usage of the system. Completely random ordering can result in test case execution scenarios that may never appear in practical use but still add value by exposing what features of the SUT are associated with faulty system behavior. However, how to find the optimal, or even most suitable orderings that identify defects is still a CPL. During the study, the orderings were only evaluated randomly, i.e. no systematic practice was found to improve the defect finding ability of a VGT suite.\n\nA prerequisite for a VGT suite to be used effectively with different test case orderings is that the test cases have been developed in a consistent and suitable manner that make them interchangeable within the test suite. As such, the test cases and overall test suite should adhere to a well defined architecture or framework. For Sikuli test suite developers this presents a CPL that is more related to traditional software development than testing since Sikuli does not have built in support for test suite creation. Consequently, efficient test suite development is a common problem for all VGT tools but more explicit in Sikuli.\n\nIn summary,\n\n– Defects in the system can cause it to crash or freeze, which requires failure handling code in the VGT scripts.\n– More defects can be found with VGT since there is no cost associated with running the test suites which allows it to be run with different test case orderings. However, finding what orderings identify more/less SUT defects is still an unexplored CPL.\n– A good test script architecture is essential for test suite usability.\n\n4.1.4 Company specific (Tier 2)\n\nThe manual test specification used in Case 1 was not aligned with the SUT’s implementation (13) as explained in Section 4.1.1. The research team member in Case 1 also lacked the domain knowledge to identify this misalignment which later required several partially completed test cases to be refactored. Thus, raising the cost of the VGT transition. However, the source of this CPL is general to all testing and relates to the complexity of product management [Ebert(2007)]. Product management that becomes increasingly more difficult as the number of artifacts, e.g. test specifications, increase for different versions\nTable 2 Summary, and distribution, of problems, challenges and limitations (CPLs) related to the test tool (Sikuli) out of the 58 CPLs that were found in total.\n\n<table>\n<thead>\n<tr>\n<th>CPL category</th>\n<th>CPL sub-category</th>\n<th>Nr. of (Tier 4) CPLs</th>\n<th>Percentage out of the 58 CPLs</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Test Tool</td>\n<td>Test tool (Sikuli)</td>\n<td>13</td>\n<td>22.4</td>\n</tr>\n<tr>\n<td></td>\n<td>Test scripts</td>\n<td>1</td>\n<td>1.72</td>\n</tr>\n<tr>\n<td><strong>Total</strong></td>\n<td></td>\n<td>14</td>\n<td>24.12</td>\n</tr>\n</tbody>\n</table>\n\nand variants of a system. Hence, this CPL indicates that any VGT transition project should be driven by a domain and/or test system expert in order to mitigate unnecessary development cost.\n\nAnother company specific CPL in Case 2 was the VGT transition project’s limited budget (14). The limited budget forced the industrial practitioners to develop the first possible VGT script solution they could identify, which wasn’t necessarily the best in terms of script performance, reusability, etc. This CPL is common in industry and general to all types of process improvement.\n\nIn summary,\n\n- Improper version control and budget constrains set by the company affects the VGT transition success-fulness, test case quality and test case results.\n\n4.1.5 Test system (Environment) (Tier 2)\n\nThe SUT in Case 1 had several external interfaces to control an airport’s landing lights and radar during operation. Since these external systems, e.g. the radar, are not available during testing the company instead uses simulators to stimulate the SUT’s external interfaces. Software simulation of hardware is a common practice in industry [Mongrédien et al(2006)Mongrédien, Lachapelle, and Cannon, Börjesson and Feldt(2012)]. However, simulators are often SUT version/variant dependent (15). As such, misalignment between the SUT and the used simulator will limit the SUT’s functionality (1) and in continuation what test cases can be applied. Thus presenting a version control CPL that must be taken into account during VGT transition and execution.\n\nIn summary,\n\n- Improper simulator support for the system under test leads to incomplete test cases and test cases that will require more maintenance.\n\n4.2 Test tool (Tier 1)\n\nIn the following section we will focus on CPLs related to the VGT tool. Some of these CPLs are Sikuli specific, whilst others are perceived as general to other VGT tools as well. Two sub-categories of CPLs were identified as VGT tool specific. First, CPLs related to the tool’s image recognition. Second, CPLs related to deficiencies in the VGT tool such as lack of documentation, bugs in the IDE, etc.\n\n4.2.1 Image recognition (Tier 2)\n\nSikuli is a tool developed and maintained in an open source project that was started at the User Interface Design Group at the Massachusetts Institute of Technology but is now maintained and developed by the Sikuli Lab at the University of Colorado Boulder. The tool was at the time of the study still a release candidate (version X-1.0rc3), i.e. not a finished product. Therefore, the tool contained software defects that made the tool’s integrated development environment (IDE) and image recognition unstable.\n\nSikuli’s image recognition algorithm instability caused it to randomly fail in cases where it had previously succeeded, click on generic positions next to the sought images, etc. These failures were observed in both Case 1 and Case 2 and were another source of frustration during the VGT transition because of the random nature of the CPLs and because no solution could be found to mitigate them. The source of the CPL is perceived to be software defects in Sikuli (16).\n\nAnother cause of image recognition failure is the image recognition algorithm itself because it is performance intensive (17). The performance requirements can cause the SUT to run slower than in normal use, which can lead to faulty SUT behavior and perceivably random image recognition failure.\nHowever, not all image recognition failures identified in the study were random. Sikuli uses a fuzzy image recognition algorithm that allows the user to set the required similarity level for the sought image to be a match. If the similarity is set too high or too low it is possible that the tool will find an incorrect match or no match at all (18). Fine-tuning the image similarity to assure correct image identification was together with the synchronization CPL, presented in Section 4.1.2, reported to be the two main contributors to development cost and frustration during the VGT transition projects.\n\nTo help the script developer to set the image similarity, Sikuli’s IDE has a built in feature that allows the user to preview what the image recognition algorithm considers a match to the sought image on the screen, indicated with a square. If several matches are found, these are ranked using colors ranging from blue for a poor match to red for a good match. During script execution, Sikuli will always interact with the image with the highest similarity, if not told otherwise. According to the study participants, corroborated by the authors’ own experiences, the preview feature has never failed to find a match. Thus, indicating that the image recognition algorithm has a 100 percent success rate. However, it was reported from both Case 1 and 2 that even though the preview feature finds a match, this does not guarantee that the script will succeed during execution (18). Thus, the preview feature’s behavior does not always match the script execution behavior, leading to confusion and frustration among the script developers.\n\nAnother image recognition CPL concerns Sikuli’s inconsistent ability to find certain types of bitmap objects, for instance animated images (19) and images with similar appearance but with slightly different color (18). This functionality was required in Case 1 since the SUT had animated buttons that indicated alarms to warn the user. A conclusion was therefore drawn that Sikuli is not equally usable for animated GUIs (19). This conclusion is corroborated by results from our previous work [Börjesson and Feldt(2012)]. However, the SUTs in Case 1 and 2 were mostly non-animated and therefore this CPL did not prohibit the use of VGT. In our previous work [Börjesson and Feldt(2012)] we also showed that another VGT tool, CommercialToll, was equally susceptible to this CPL.\n\nSecondly, it was possible to switch the color set of the SUTs GUI in Case 1, from light gray to dark gray, to make it more comfortable in different lighting conditions. However, this presented a CPL for Sikuli that could not always distinguish between the lighter and darker colors and therefore this SUT functionality could not be tested with complete confidence. This CPL may arise when, for instance, a test aims to verify that a button has changed its graphical state after being clicked, given that the images of the different states are similar. Thus, this CPL provides support for the need to also do complementary manual testing.\n\nIn summary,\n\n– Sikuli’s image recognition algorithm sometimes fails even though the image recognition preview feature finds a match, which added a lot of frustration to the VGT transition.\n– Sikuli’s image recognition has lowered success rate when attempting to recognize images that are very similar or that are animated.\n\n4.2.2 Deficiencies (Tier 2)\n\nSikuli script is a Python-based scripting language with unique methods that incorporate the tool’s image recognition capabilities. However, there is no comprehensive API documentation for the language, which added confusion and frustration during the study because not all of the language methods are intuitive (21). One such method is called wait, which is a delay method that takes an image and/or a delay in seconds as input. However, wait(image, delay) and wait(delay, image) have different properties. Whilst the first alternative waits for a maximum of delay seconds for an image to appear, the second always waits delay number of seconds and then tries to find the image. However, as reported in our previous work [Börjesson and Feldt(2012)], Sikuli script is in general an intuitive scripting language even for novice users.\n\nThe transition approach used during the study was to implement all VGT scripts as 1-to-1 mappings to the manual test cases. This approach has several benefits, including improved verifiability of the scripts because they can simply be compared to the manual test execution. However, this approach is not always applicable and not always the most efficient. As reported in Section 3.3 it was not possible to implement all test cases in a 1-to-1 fashion in Case 2, because of dependencies among the use cases that formed the test scenarios. The practitioners in Case 2 therefore stated that future development would not be based on the manual test cases but rather on the testers’ domain knowledge and that the test cases would first be developed for the core functionality of the SUT. Thus, the SUT features that were the most stable and were the most essential from a business perspective. However, this presents a CPL regarding script complexity and how to verify script correctness.\n\nAnother CPL that must be taken under consideration during VGT transition is that VGT tools, even though they emulate human user behavior, are not human. Therefore, the tools sometimes perform GUI\ninteractions in unnatural ways that can cause unintuitive CPLs. For instance, Sikuli can perform interactions much quicker than a human user, which can lead to faulty script behavior (23).\n\nAs stated, there are many CPLs related to Sikuli’s IDE, scripts and image recognition. Through experimentation with approximately 50 computers we came to the conclusion that the stability of Sikuli is related to what version of the Java runtime environment (JRE) is installed on the computer. Hence, the tool was perceived considerably more stable on some JRE versions than other. However, no explicit information was acquired what versions improved stability the most. The effect of this CPL is that users with less advanced computer knowledge can be discouraged from using or even test the tool, if they can get it to work at all. This problem threatens the trustworthiness of VGT as a technique and is perceived to only be solvable through continued development of the Sikuli tool.\n\nIn addition, several other low-level, technical, CPLs were identified, for instance that Sikuli cannot type or read swedish letters using its optical character recognition (OCR) algorithm, frequent IDE crashes, etc. However, due to the technical nature of these CPLs, we will not go into more detail about them here. It was reported by the study participants that most of these CPLs could be solved, e.g. by running the scripts from the command prompt rather than through Sikuli’s IDE, but that the CPLs caused confusion and frustration during the project.\n\nIn summary,\n– Sikuli lacks proper API documentation, which added confusion during the VGT transition since some methods have several different behavior depending on the order of the input parameters, etc.\n– 1-to-1 mapping between manual test cases and VGT scripts improves verifiability and maintainability of the scripts.\n– Sikuli can emulate human behavior but it is not human, which has to be taken into consideration to avoid faults, e.g. Sikuli double clicks much faster than a human.\n– The version of Sikuli (version X-1.0rc3) used in the study was sensitive to what Java runtime environment was installed on the computer running tool.\n\n4.3 Support software (Tier 1) and Third party software (Tier 2)\n\nVirtual network connection (VNC) software was used in both Case 1 and 2 to make it possible for Sikuli to interact with the SUTs, which were distributed across several physical computers. Secondly to make Sikuli’s script execution non-intrusive, which meant removing the impact of running the performance intensive image recognition algorithm on the same computer as the tested system. Non-intrusiveness helps mitigate the CPL that the image recognition algorithm might steal computational resources from the SUT, which could for instance slow down the SUT execution and cause script failure due to desynchronization of the SUT and the VGT script executions.\n\nHowever, as mentioned, the use of VNC was also the cause of several CPLs. First, the use of VNC was reported to lower the image recognition success rate from 100 to 70 percent because of network latency (24). Thus, even when the VNC application was running in an optimized state, the frame rate of the viewer caused the image recognition to fail. This CPL was especially troublesome for test cases that included interaction with animated graphical components (19, 24). For instance the emergency nets in Case 1, since the lower frame-rate could cause the SUT’s animated buttons to become distorted as they were toggling color. Another CPL is that the mouse cursor can not be removed from the rendered images sent from the VNC server to the viewer, which requires extra consideration in the script, e.g. to move the mouse cursor to an appropriate location after each interaction (24). This is a simple practice but adds script lines of code.\n\nFurthermore, as observed in Case 1, the choice of VNC application is a relevant factor for the success of the script execution. The general conclusion is therefore that even though VGT tools can interact with any third party software, the developer should, if there are multiple software options, seek to find the one most\ncompatible with VGT. In addition, the developer should try to find the most qualitative product to avoid CPLs related to the VNC application freezing, showing the wrong colors, compression of the imagestream, etc.\n\nIn Case 1 a third party recording software, Camtasia, was also added to the VGT suite. The tool was used to capture recordings of the test suite execution which helped developers to recreate the defect and easier identify its cause. However, in several occasions Camtasia would not start properly during script execution which resulted in the VGT scripts failing as well (25). This CPL shows that even though VGT is able to interact with any bitmap component on the screen, precautions still have to be taken that said interaction is robust. Furthermore, switching between several different applications in one test case perceivably adds overhead and complexity. However, there is no empirical evidence to corroborate this claim, which is therefore a subject of future work.\n\nAttempts were also made in Case 1 to migrate the VGT transition from the demo version of the SUT to the product version of the SUT by emulating it on 12 virtual machines on a single computer. However, this attempt was unsuccessful because the performance load of the entire system was too great (26). Hence, a more powerful computer had been required which was could not be acquired due to budget limitations (14).\n\nIn summary,\n\n- Running VGT tools on Virtual Network Connection (VNC) software can improve VGT usability, e.g. for execution of distributed test cases and lowers performance strain on the computer running the system and the VGT tool.\n- VNC lowers image recognition success rate because of image transfer latency.\n- Adding a screen recording software, e.g. Camtasia, to the VGT suite improves the quality of the test results and makes it easier to replicate system under test faults manually.\n- Adding more third party tools to the VGT solution/suite means that more aspects of the suite can fail, e.g. incorrect third party tool startup, crash, etc.\n\n### 4.4 CPL Summary\n\n58 challenges, problems and limitations (CPLs) were observed during this study at Saab in Gothenburg and Järfalla. Analysis of the CPLs made it possible to categorize them into three tiers, with the lowest tier containing 26 unique types of CPLs, as shown in Figure 5. Table 4 summarizes, numerically, how these 26 types were distributed over the Tier 2 CPL types and in turn how the Tier 2 CPLs were divided over the top three Tier 1 CPL types. The table also shows that most CPLs were related to the tested system (SUT) and the test environment (58.4 percent) rather than the VGT tool (24.1 percent). This is a significant result since SUT related CPLs are perceived to be more general to other test techniques, as shown in Table 6 that we will return to shortly.\n\n<table>\n<thead>\n<tr>\n<th>CPL category</th>\n<th>CPL sub-category</th>\n<th>Nr. of (Tier 4) CPLs</th>\n<th>Percentage out of the 58 CPLs</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Test System</td>\n<td>Test System version</td>\n<td>20</td>\n<td>34.4</td>\n</tr>\n<tr>\n<td>Test Tool</td>\n<td>Test tool (Sikuli)</td>\n<td>10</td>\n<td>17.2</td>\n</tr>\n<tr>\n<td>Support software</td>\n<td>Third party software</td>\n<td>6</td>\n<td>10.3</td>\n</tr>\n<tr>\n<td>Test System</td>\n<td>Test System (General)</td>\n<td>6</td>\n<td>10.3</td>\n</tr>\n<tr>\n<td>Test System</td>\n<td>Test System (Defects)</td>\n<td>6</td>\n<td>10.3</td>\n</tr>\n<tr>\n<td>Test System</td>\n<td>Company specific</td>\n<td>1</td>\n<td>1.72</td>\n</tr>\n<tr>\n<td>Test System</td>\n<td>Test System (Environment)</td>\n<td>1</td>\n<td>1.72</td>\n</tr>\n<tr>\n<td>Test Tool</td>\n<td>Test scripts</td>\n<td>1</td>\n<td>1.72</td>\n</tr>\n<tr>\n<td><strong>Total</strong></td>\n<td></td>\n<td>58</td>\n<td>∼100 (99.8)</td>\n</tr>\n</tbody>\n</table>\n\nTable 4 Summary of distribution of problems, challenges and limitations (CPLs) that were identified during the automation process ordered according to occurrence of the Tier 2 CPL types. Tier 1 CPL types have been listed for each sub-category.\n<table>\n<thead>\n<tr>\n<th>Nr.</th>\n<th>CPL theme title (Tier 3 CPLs)</th>\n<th>Description</th>\n<th>Q-attr.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Test tool deficiencies (20-23)</td>\n<td>The VGT tool used in the study, Sikuli, was an immature product and therefore included several defects, lacked proper API documentation, etc., resulting in frustration and confusion among the study participants. Some of the CPLs related to this theme could be solved with innovative scripting but it is perceived that only further development of the tool will solve the CPLs in this theme completely. As such this theme is considered Sikuli specific, even though other VGT tools may be subject to similar CPLs.</td>\n<td>Robustness, Usability, Reusability, Learnability, Portability, Maintainability</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Image recognition (16-19)</td>\n<td>This theme of CPLs is unique to VGT but considered general to all VGT tools. Image recognition algorithms are technologically advanced but also complex and performance intensive, which is associated with several CPLs, including less than perfect success rate. These CPLs are however reported, from both Case 1 and 2, to be solvable through innovative scripting and exception handling. Thus providing current VGT tools with sufficient robustness to be industrially applicable. However, further advances in the area of image recognition are still required to further improve the industrial applicability of VGT.</td>\n<td>Robustness, Usability</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Negative VNC effects (24)</td>\n<td>VNC constituted a significant part of the VGT test architectures used in Case 1 and 2 and made it possible for the VGT tool to perform test cases that required interaction with several different computers. In addition, VNC made the VGT script execution non-intrusive. However, VNC also lowered the image recognition success rate from almost 100 percent to 70 percent. As such, there is a tradeoff between tool usability for distributed systems and script robustness. This CPL theme is considered generic for VGT tools with the exception of EggPlant that has built in, robust, VNC support. It is therefore perceived that this theme could be solved through technical innovation from the VGT tool providers.</td>\n<td>Robustness, Usability, Portability</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Test specification (2-4,13)</td>\n<td>This CPL theme is considered general to all test techniques, including manual testing, since faulty, ambiguous or out of date test cases will lead to faulty test results regardless of how the tests are performed. The CPL is caused by the complexity of maintaining a SUT over time, including version control, documentation and SUT alignment, etc. The solution for this CPL theme was outside the scope of this study but it is perceived that it can be solved through improved industrial documentation practices and tooling.</td>\n<td>Usability, Reusability, Learnability, Portability, Maintainability</td>\n</tr>\n<tr>\n<td>5</td>\n<td>SUT testability deficiencies (1,5,15)</td>\n<td>Missing SUT, GUI and simulator functionality constitute a CPL for any test technique, including manual testing. For VGT the main effects, observed during the study, was that it leads to unnecessary costs and incomplete VGT scripts. This theme is linked to theme 4 since faulty SUT behavior can be the result of improper or incomplete specifications. No solution was identified for this theme during the study but it is perceived that it would be mitigated as the functionality of the SUT increases over time.</td>\n<td>Robustness, Usability, Reusability, Portability</td>\n</tr>\n<tr>\n<td>6</td>\n<td>Script tuning (6, 7, 18)</td>\n<td>This theme was considered the most time consuming and frustrating during the study and includes VGT script/SUT synchronization and image similarity tuning. Both these practices require trial and error because no structured approach could be identified how to systematically delay or set the image similarity in a VGT script. However, reports from the study participants indicates that good estimations of where to delay or adjust image similarity can be achieved once the script developers become more experienced with the technique. This CPL theme is considered general to all automated test techniques. A statement which is corroborated by academic literature, e.g. [Horowitz and Singhera(1993)].</td>\n<td>Robustness, Usability, Reusability, Portability, Maintainability</td>\n</tr>\n</tbody>\n</table>\n\nTable 5 Compilation of the six most prominent themes of challenges, problems and limitations (CPLs) observed in both Case 1 and Case 2 during the study. The numbers in parentheses after the CPL theme titles correspond to the Tier 3 CPLs in Figure 5. These CPLs were chosen based on occurrence, perceived negative impact on the transition to, or usage of, VGT, added frustration, etc. Deficiencies are in this context attributes that cause CPLs, or allow the CPLs to emerge. VNC - Virtual Network Connection, SUT - System under test.\nfrom Table 4 indicates that even though most CPLs were SUT related, the most influential CPLs were related to the VGT tool. The table also shows that all of the six themes affect VGT’s usability and most affect its robustness, which is a concern for the techniques industrial applicability. However, this observation is countered by reports from the study participants that stated that despite the technique’s many CPLs, it was still valuable, cost-effective and had equal or even better fault finding ability than manual tests.\n\nTable 6, in turn, shows the results of an indicative analysis of the CPL themes generalizability to other GUI-based test techniques and manual testing. The input for this analysis were the observations from the study and reports from academic literature, presented in Section 2. As such, no empirical evaluation was performed between VGT and other GUI-based techniques and we therefore stress that there might exist tools and practices that are exceptions to the presented results. However, the table provides an overview of the similarities between VGT and other techniques and more importantly, but not surprisingly, that the CPLs that are unique to VGT are mostly image recognition related. All other CPLs, except two, are common to GUI-based testing and manual testing, e.g. test synchronization to the SUT [Horowitz and Singhera(1993)] and usage of faulty manual test specifications that lead to faulty test results regardless of how they are executed. This result is a significant since other GUI-based testing techniques are used successfully in industrial practice, which would corroborate our previous research results that VGT is industrially applicable [Börjesson and Feldt(2012), Alegroth et al(2013a)]. However, other GUI-based techniques have been reported to be associated with high maintenance costs [Sjösten-Andersson and Pareto(2006)], costs that are still unknown for VGT. As such, further research is required to identify these costs and the impact of the VGT unique CPLs on the technique’s long-term industrial applicability.\n\n4.5 Potential CPL solutions\n\nBased on the acquired information from the study it was possible to derive four general solutions that solve more than half of the presented CPLs. These solutions have been summarized in Table 7 and have been linked to the CPL themes from Table 5 that they solve or mitigate. The reason why precise solutions are not presented for all CPLs is because some CPLs were never solved, other CPL solutions required too much effort to be solved during the study but most solutions were ad hoc and could therefore not be generalized. Thus, in an attempt to keep the length of this manuscript down we have chosen to only present the most general solutions we identified.\n\nThe first general solution was to ensure that the scripts were developed with several levels of exception handling to mitigate CPLs such as tool and image recognition failure, failure due to SUT fault identification, etc. This solution is taken from traditional programming and can be achieved in Sikuli by using Python’s exception handling. In combination with the VGT suite architecture presented in Section 3.4 it is possible to achieve a good level of script robustness. However, as reported by the study participants, making the entire VGT suite robust can be quite time consuming, especially since many exceptions are caused by unexpected tool or system behavior.\n\nThere are two practical ways of achieving robustness in Sikuli scripts. The first is to add exception handling locally in the scripts after a failure event has been observed. An example from Case 1 was in scripts that required the system to be restarted, which often caused Window’s “failure to terminate process” messages to appear and deny the script from performing the next script operation. By adding a check if the message was visible after initiating the system restart, and close the message, this CPL was resolved.\n\nThe second way is to create a global solution that is triggered regardless of which exception is thrown. Hence, if an interaction with the SUT fails, the exception is sent up the VGT suite architecture to the main script that runs through a series possible mitigation operations. Some examples of these operations could be to search for buttons labeled “OK, Okey, Close, Continue” or specific buttons, such as the Windows close button found in the top right of every application window, etc. Another, more drastic global solution is to reset the system after each failure by restarting it to ensure that the SUT is in a known and fault free state. The VGT suites developed during the study were implemented with a combination of both local and global solutions.\n\nException handling is perceived to be a general solution for all VGT tools that have similar scripting support as Sikuli. However, other tools, e.g. JAutomate [Alegroth et al(2013b)], EggPlant [TestPlant(2013)], also have built in failure mitigation support such as multiple image recognition algorithms, etc. Failure mitigation that relieves some, but not all, of the need for custom robustness improvements and exception handling solutions.\n\nSikuli lacks documentation for Sikuli script, which was regarded as a very frustrating CPL during the study. The solution to this CPL is simply to add comments to the scripts during development, e.g.\n<table>\n<thead>\n<tr>\n<th>CPL theme Nr.</th>\n<th>Tier 3 Nr.</th>\n<th>Name</th>\n<th>Effect</th>\n<th>GUI-based test techniques</th>\n<th>Manual GUI-based testing</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>20</td>\n<td>Script image gets corrupted</td>\n<td>Leads to required script maintenance.</td>\n<td>N/A</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>21</td>\n<td>VGT tool documentation</td>\n<td>Lack of documentation adds frustration to VGT transition and lowers learnability of VGT</td>\n<td>Yes</td>\n<td>N/A</td>\n<td></td>\n</tr>\n<tr>\n<td>22</td>\n<td>Only US keyboard</td>\n<td>Leads to script developer/ tester frustration.</td>\n<td>Yes</td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td>23</td>\n<td>Selecting text</td>\n<td>Requires additional script development and leads to script developer frustration.</td>\n<td>Yes</td>\n<td>N/A</td>\n<td></td>\n</tr>\n<tr>\n<td>2</td>\n<td>16</td>\n<td>(Image recognition) Failure</td>\n<td>Can lead to false positive test results.</td>\n<td>N/A</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>17</td>\n<td>(Image recognition) Performance intensive</td>\n<td>Can lead to false positive test results if image recognition affects SUT performance/timing.</td>\n<td>N/A</td>\n<td>N/A</td>\n<td></td>\n</tr>\n<tr>\n<td>18 (*)</td>\n<td>(Image recognition) Differentiation</td>\n<td>Can lead to false positive test results.</td>\n<td>N/A</td>\n<td>N/A</td>\n<td></td>\n</tr>\n<tr>\n<td>19</td>\n<td>Animated components</td>\n<td>Leads to false positive test results if image recognition is slower than the animation.</td>\n<td>No</td>\n<td>No</td>\n<td></td>\n</tr>\n<tr>\n<td>3</td>\n<td>24</td>\n<td>VNC</td>\n<td>Leads to lowered image recognition success rate and more false positive test results.</td>\n<td>N/A</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>4</td>\n<td>2</td>\n<td>Manual test faulty</td>\n<td>Leads to faulty test case results if used as specification for test script or manual testing.</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Manual test ambiguous</td>\n<td>Can lead to faulty test case results if used as specification for test script or manual testing.</td>\n<td>Yes</td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td>4</td>\n<td>Manual test out of date</td>\n<td>Leads to faulty test case results if used as specification for test script or manual testing.</td>\n<td>Yes</td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td>13</td>\n<td>Wrong test specification</td>\n<td>Can lead to faulty test case results if used as specification for test script or manual testing.</td>\n<td>Yes</td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td>5</td>\n<td>1</td>\n<td>Missing SUT functionality</td>\n<td>Can lead to incomplete/incorrect test case results.</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>15</td>\n<td>Simulator missing functionality</td>\n<td>Can lead to incomplete/incorrect test case results.</td>\n<td>Yes</td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td>5</td>\n<td>Missing (Missing/wrong bitmap) GUI components</td>\n<td>Can lead to incomplete/incorrect test case results.</td>\n<td>No</td>\n<td>No</td>\n<td></td>\n</tr>\n<tr>\n<td>6</td>\n<td>6</td>\n<td>SUT/Tool synchronization</td>\n<td>Can lead to faulty test case results due to incorrect timing.</td>\n<td>Yes</td>\n<td>N/A</td>\n</tr>\n<tr>\n<td>7</td>\n<td>SUT slower after time</td>\n<td>Can lead to faulty test case results due to incorrect timing.</td>\n<td>Yes</td>\n<td>N/A</td>\n<td></td>\n</tr>\n<tr>\n<td>18 (*)</td>\n<td>(Image recognition) Differentiation</td>\n<td>Can lead to false positive test results due to faulty GUI object similarity.</td>\n<td>N/A</td>\n<td>N/A</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTable 6: Indicative analysis of how the six CPL themes from Table 5 are perceived common to other GUI-based test techniques and manual testing. For each theme, the Tier 3 CPLs from Figure 5 have been listed together with the most notable effects of the CPLs. (*) - Note that CPL 18 has been listed twice because it overlaps between theme 2 and 6. The table should be interpreted as follow: (Yes, Yes) - The VGT CPL is also a CPL for GUI-based test techniques and manual testing. (Yes, No) - The VGT CPL is also a CPL for GUI-based test techniques but not for manual testing. (No, No) - The VGT CPL is not a CPL for GUI-based test techniques or manual testing. (Yes, N/A) - The VGT CPL is also a CPL for GUI-based test techniques but not applicable for manual testing. (N/A, N/A) - The VGT CPL is not applicable for GUI-based test techniques or manual testing.\n\nDocument the test suite architecture, the functionality of help scripts and methods, it is possible to build a repository of reusable and simple to use Sikuli script code. Hence, another best practice taken from traditional programming. This practice makes it simpler for new testers and/or developers to start working with the test suite, which mitigates degradation of the test suite over time [Berner et al(2005)Berner, Weber, and Keller], improves reusability of the code and improves maintainability.\n\nExperience reports from the study indicate that documentation and code comments are mainly required for the test suite architecture, whilst the VGT scripts are intuitive on their own. This intuitiveness comes from the combination of the GUI level operations in the scripts and the images in the scripts that define on which GUI components the operations are performed. In addition, if the scripts are implemented as 1-to-1 mappings of the manual test cases, the manual test cases also serve as documentation for the scripts.\nThe third general solution that was identified aims to raise script robustness and regards the removal, or non-usage, of remote computer control software, e.g. virtual network connection (VNC) applications. Removing VNC from the test architecture raises stability of the test execution by mitigating detrimental effects to the image recognition due to network latency, lowered frame-rate, etc. It was found in Case 2 that removing VNC can improve script success rate from 70 to 100 percent.\n\nHowever, this practice has drawbacks because, even though it raises robustness, it restricts the number of test cases that can be performed on a distributed system. In addition, by running the test scripts locally, more load is put on the computer running the SUT. Hence, raising the risk of faulty SUT behavior due to a lack of performance resources, e.g. access to the central processing unit or the computers random access memory. Consequently, the use of VNC allows VGT tools, e.g. Sikuli, to test distributed systems but it lowers the success rate of the image recognition. This discussion only relates to VGT since other techniques, e.g. property-based GUI testing, require local access to the tested applications’ GUI components or the layers below the GUI.\n\nThe fourth solution aims to solve the CPL that VGT scripts generally execute quicker than the tested system can update its GUI, i.e. the scripts are not properly synchronized with the tested system. This CPL, as stated, is not VGT specific [Horowitz and Singhera(1993)] and in addition to being a huge source of frustration during the VGT transition, it was also considered one of the most time consuming. However, the study participants reported that the CPL could be mitigated through systematic insertion of delays in the scripts. No pattern could be identified where to put the delays, instead they were placed ad hoc based on experience the study participants gained throughout the VGT transition. In Case 1, this solution practice was further supported through custom methods with an additional time delay parameter. For instance, the click(img) method from Sikuli’s API, where “img” is the sought image, was expanded to click(img, delay) which delayed the script execution “delay” number of seconds before performing the click. Thus lowering the number of lines of code in each individual script and perceivably mitigated the synchronization CPL for the script developer.\n\nHowever, whilst the custom methods provided additional script robustness, they also increased script execution time. The reason was because these methods required the sought image to be found twice, first by Sikuli’s “wait for image method” and second by the “click method”. Thus, doubling the minimum number of required image recognition sweeps. However, due to the increased robustness, reports from Case 1 still indicates that they were beneficial. Especially since the image recognition algorithm in Sikuli is quite fast, i.e. can perform upwards of 5 complete image recognition sweeps of the computer monitor per second. The solution perceivably also mitigates some of the frustration related to the synchronization CPL by systematically adding dynamic delays.\n\nIn addition to the four reported solutions there were many ad hoc solutions that were too project specific to be generalized and are therefore not reported here since the manuscript is already quite substantial. Additionally there were several CPL types that could not be solved during the study. First, CPLs for which potential solutions could be identified but where the solution implementation required too much effort that it was out of scope for the project. Second, CPLs where no solution was identified at all, e.g. how to ensure image recognition robustness.\n\nHowever, we believe that more general solutions can be identified and that there are several approaches to identify them. First, more case studies can be performed to empirically identify solutions. Second, since it has been established that there are many commonalities between VGT and other techniques, solutions could perceivably be migrated from said other techniques to VGT. For instance through experimentation, case studies and action research.\n\n4.6 Defect finding ability, development cost and return on investment (ROI)\n\nThus far, we have focused on the CPLs related to the transition and usage of VGT, and the number of CPLs has been considerate. However, the industrial practitioners in Case 2 still stated that VGT, performed with Sikuli, is a valuable and cost effective technique. They reported that they did not encounter any functionality that they could not automate using Sikuli but that some operations were more or less challenging. However, since VGT is a test technique, the primary measure of successful application is still the defect finding ability of the VGT scripts. In Case 1, six defects were identified in the SUT.\n\n1. Switching between military and civil landing lights did not work.\n2. The button to switch military and civil landing lights did not disable as intended.\n3. The button to switch military and civil landing lights did not disappear as intended.\n4. Switching quickly between runways caused the tested system to freeze.\n<table>\n<thead>\n<tr>\n<th>Nr.</th>\n<th>Title</th>\n<th>Description</th>\n<th>Solves/ mitigates CPL themes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Failure/ exception handling</td>\n<td>Adding failure mitigation code in the scripts, i.e. exception handling, on several levels of script abstraction can mitigate failure due to tool or image recognition volatility as well as unexpected system behavior. However, since it might be hard to predict the failures, this practice can be time consuming. For more experienced VGT script developers it is however easier to see patterns of when certain mitigation practices are required.</td>\n<td>2 and 5</td>\n</tr>\n<tr>\n<td>2</td>\n<td>VGT script documentation</td>\n<td>In order to raise script robustness, usability, reusability, etc., it is recommended to construct user defined methods and other reusable artifacts. However, in order to preserve the knowledge of these artifacts, they should be thoroughly documented to make it easier for new developers/testers to start working with the scripts. In addition, this documentation should include descriptions of native Sikuli methods to complement the official, but lacking, Sikuli documentation.</td>\n<td>1</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Local/Remote script execution</td>\n<td>Executing the VGT scripts without a remote system control application, e.g. virtual network control (VNC) application, raises script execution stability and image recognition robustness. However, this also limits what test cases can be executed for distributed systems. Another drawback is that the image recognition is performance intensive and can therefore modify the behavior of the tested system when run locally.</td>\n<td>3</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Systematic SUT synchronization</td>\n<td>The VGT suite needs to be synchronized with the SUT using static or dynamic delays. By creating custom methods that take timing input and usage of the "wait for image method" in Sikuli script, a process can be constructed to iteratively synchronize the script with the tested system.</td>\n<td>6</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Other or no solution</td>\n<td>For several of the CPLs ad hoc solutions had to be identified. These solutions included, but were not limited to, analysis and replacement of the used manual test specifications, hardware and software reboots to reset the tested system and/or Sikuli, change of VNC application, development of partially implemented test cases, etc. For the sake of completeness, we also state here that there were CPLs that could not be solved, e.g. stopping Sikuli scripts from getting corrupted. Hence, there are CPLs that should be investigated in future work to be solved and/or mitigated.</td>\n<td>1-6</td>\n</tr>\n</tbody>\n</table>\n\nTable 7 A summary of general solutions that were identified for the CPL themes presented in Table 5.\n\n5. Tabs for switching between views would not load.\n6. Logging out of Windows caused the tested system to freeze (The main thread of the tested system would not terminate).\n\nThese defects were reported to the company and have since the study been corrected and are no longer present in any commercial version or variant of the system.\n\nThese defects were identified during implementation or execution of the VGT suite. Analysis of the identified defects found that four of the defects were previously known to the company and had already been corrected in later versions of the system, but two of the defects were still unknown. Analysis of the manual test cases showed that they could identify all six defects but since two of the defects were sporadic they required several test suite executions to trigger the SUT’s faulty behavior. This was also the reason why they had previously not been found since the manual tests were only executed once every test iteration. As such, the VGT scripts were able to provide the same level of confidence as the manual tests and even identify more defects.\n\nIn Case 2, the industrial practitioners reported corroborating results, i.e. the VGT scripts could identify all the defects that the manual tests could identify. Additionally, they reported that three previously unknown defects were found. In the past, due to budget constraints, not all of the system’s manual test cases could be executed each iteration. However, because of the VGT transition it became possible to test more often and therefore not only provide quicker feedback to the developers but also execute more test cases for higher test coverage. In addition, the test cases could be executed with different orderings, which\nresulted in the VGT suite finding the previously unknown defects. Thus showing the importance of what order the individual test cases are executed.\n\nVGT provides you with the flexibility to change the execution order. However, this flexibility requires that the test cases are independent such that they can be run out of order. In addition, it is important that the teardown, or rollback, methods of each script are well defined to put the system back into known states before the next test case is executed to mitigate any side-effects of failed tests [Cheon and Leavens(2006)]. Failure to rollback the system can result in testing of invalid system states and false negative test results. The manual test cases in Case 2 were not completely independent, which required several manual test cases to be merged. Thus, deviating from the 1-to-1 mapping between manual and automated test cases as reported in Section 3.3.\n\nTable 8 summarizes some of the cost metrics that were acquired in Case 1 and 2. However, we stress that the contexts and conditions were significantly different between the two cases so any comparison between them need to be made with care. Whilst Case 1 was performed with only one researcher, Case 2 was performed by two industrial practitioners. In addition, the researcher in Case 1 had limited VGT and domain knowledge and knowledge of the SUT whilst the practitioners in Case 2 were domain experts for their SUT. Furthermore, only one manual test suite was transitioned into VGT in Case 1, whilst in Case 2 a total of three suites were transitioned. Two of the test suites in Case 2 were considered to be more complex than the average test suites used at the company, whilst the third was considered equal in complexity compared to the average. The test suite from Case 1 was perceived to be equal in complexity to one of the more complex test suites in Case 2. Complexity was evaluated based on the qualitative and quantitative information gathered during the study about the manual test cases’ number of test steps, importance of test case success, complexity of test cases GUI interactions, etc.\n\nFurthermore, whilst the test suite in Case 1 was built around tables that defined test scenarios with defined input and expected output for each test step, defined on each row of the table, the test cases in Case 2 were built around more loosely coupled use cases, as described in Section 3.4. This use case-based structure perceivably improved the manual test cases usability, maintainability and reusability since the use cases could simply be switched out to test newly added system functionality, provided that the pre- and postconditions of the new use case were aligned with the scenario. The drawback of this approach, for manual testing, is that many of the test scenarios become very similar and therefore tedious to test, i.e. the tester has to perform the same interactions over and over. However, once automated, the tediousness no longer becomes a problem. Whilst the benefits such as reusability and maintainability are kept intact since new scripts can easily be created by reusing the individual use cases together with newly developed scripts. As such, this type of structure is recommended as a base for the VGT test suite architecture.\n\nTable 8 shows the development time of the VGT suites in Case 1 and Case 2. As can be seen from the table, the development time in Case 1 was considerably lower than the development time in Case 2. However, the time in Case 1 is based on very precise measurements that represent the actual time spent on script development in rigorous detail. In contrast, in Case 2 the development time had low priority compared to the development itself. Consequently, the measured time from Case 2 contains more overhead, i.e. time not spent on development, than the measured time in Case 1. Hence, the number of implemented test suites, the manual test architectures, expertise of the script developers, and time measurement methods, all differed between the two cases. Therefore, the data in Table 8 comes from two different contexts and should therefore not be compared directly without taking the context, and measurement methods, into account. As such, no general conclusions can be drawn from the data. Instead, the data provides a broader view of the likely, but not yet validated, transition costs in industrial practice.\n\nTable 8 does however show some interesting, and comparable, data regarding the improved execution time between the manual test suites and the developed VGT suites. In Case 2, the improved execution time\n\n<table>\n<thead>\n<tr>\n<th>Project</th>\n<th>Dev. time (mh)</th>\n<th>Nr. of Man. test suites</th>\n<th>Dev. time per suite (mh)</th>\n<th>Maintena- nce (mh)</th>\n<th>Manual suite Exe. time (mh)</th>\n<th>VGT suite Exe. time (h)</th>\n<th>Pos. ROI after executions</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Case 1</td>\n<td>213</td>\n<td>1</td>\n<td>213</td>\n<td>-</td>\n<td>16</td>\n<td>13</td>\n<td>14</td>\n</tr>\n<tr>\n<td>Case 2</td>\n<td>1032</td>\n<td>3</td>\n<td>344</td>\n<td>266</td>\n<td>80</td>\n<td>2.5</td>\n<td>13</td>\n</tr>\n</tbody>\n</table>\n\nTable 8 Summary of quantitative metrics collected during the VGT transition projects in Case 1 and Case 2. mh - man-hour, h - hour\ntime was quite considerable, i.e. by a factor of 16 \\(^5\\), whilst in Case 1 the improvement was only marginal, i.e. 1.06. The reason for this difference can be found in the individual test cases, and what they aim to test. The manual test suite used in Case 1 contains several quite large test cases, test cases that contain loops and tests to verify the safety requirements of the system, i.e. non-functional attributes of the system. The looping test cases, for instance, aimed to verify the functionality of all the buttons of the GUI, i.e. the same test scenario applied to every button but grouped together into one manual test case to save space. Performing these tests manually is very time consuming and tedious and are therefore often only performed on a few buttons during test suite execution. However, with the VGT script all of the buttons can be verified during each execution, providing better coverage, without additional cost. However, even these automatic tests take quite some time to execute due to the sheer number of buttons that are tested. Thus, since each loop is measurable in length with the test suite’s other test cases but all counted as one single test case, rather than several, it has a large impact on the overall execution time of the test suite. Hence, some of the VGT scripts had considerably longer test execution time than others, visualized in a boxplot in Figure 7. The boxplot shows that the average execution time of the VGT scripts was 27 minutes, with a standard deviation of approximately 44. The cause of this deviation can be found in Figure 7 which shows that there were several outliers with much higher execution time, i.e. at most 198 minutes, which also affected the total execution time of the VGT suite. In addition, the execution time of the manual test suite in Case 1, 16 hours, is an ideal time, i.e. when performed by an expert tester who are capable of determining, for instance, which buttons it is necessary to repeat all the steps of the looped test cases. For a junior tester, the manual test suite can take upwards of 40 hours, as presented in our previous work \\cite{Börjesson and Feldt(2012)}. Thus, if the outliers are removed and the calculations are performed with the manual execution time of a junior tester, i.e. 40 hours, the results from Case 1 show that the automated scripts execute approximately 4.5 times faster than the manual tests.\n\nFig. 7 Boxplot showing the execution times for individual test scripts from the VGT suite developed in Case 1. Time, shown on the x-axis, is measured in minutes.\n\nThe slow script execution time in Case 1 was also contributed by manual test cases that required the tester to just sit and wait for a number of seconds, or even minutes, for an event to be triggered. Tests of this nature aim to test, as an example, the alarm notification service in the tested system, i.e. that an alarm is triggered if the tested system looses its connection to its hardware interfaces. As a more concrete example, if the wind measurement service looses its connection to the airports wind measurement sensors, it should wait for the connection to be re-established within 30 seconds before triggering an alarm. Hence, for 30 seconds, during this test, the tester is expected to just sit and wait, and since the VGT test cases were implemented in a 1-to-1 fashion they also had to wait. These tests have significant impact on the total execution time of the VGT suite and relate back to the previous statement that the VGT tests are unable to execute tests quicker than the tested system can respond. In contrast, the test cases that were transitioned in Case 2 were more on a functional level and did not consider timing issues, etc, which made it possible for the VGT suite to gain a larger performance advantage over the manual test cases.\n\n\\(^5\\) Manual test execution time was 80 man hours but performed by two testers, i.e. 40 work hours in total.\nHowever, even though the tests were implemented in a 1-to-1 fashion, results from Case 1 and 2 showed that the VGT suites had improved execution time compared to the manual test suite (even though only very slightly better in Case 1). One factor that explains this speedup is that a human tester continuously has to read the manual test step descriptions in order to know what to input and what output to expect from the system. This factor also explains why test experts can execute the test cases faster, since they are familiar with both the tested system and tests and therefore do not need to spend as much overhead time consulting the test specification. Furthermore, in contrast to a human tester, the scripts only needs to execute their commands, i.e. removing the reading overhead completely. Additional execution time gains are provided by the scripts ability to quickly paste textual input into the tested system, whilst a human has to write the input. These gains might seem small, but in the overall perspective these small gains add up and become significant.\n\nBased on the collected metrics, the return on investment (ROI) for the VGT transition can be calculated by comparing the development time of the VGT suites with the manual test suites’ execution time. Hence, the ROI can be calculated using the following simple equation where cost is measured in time:\n\n\\[ R_{VGT} = \\frac{C_{VGT}}{C_{manual}} \\]\n\nwhere \\( R_{VGT} \\) is the number of VGT suite executions required for the VGT suite development cost (\\( C_{VGT} \\)) to break even with the cost of performing the system tests manually (\\( C_{manual} \\)), i.e. the number of runs required to get positive ROI. This ROI calculation is however simplified, since it does not take the number of found defects into consideration, nor the costs for maintenance of the VGT suites. Maintenance costs that are currently unknown. Only initial data has been acquired [Alegroth et al(2013a)Alegroth, Feldt, and Olsson], and more studies that focus on these costs are therefore required in the future.\n\nOnce again, these result calculations are only comparable between Case 1 and 2 if the contexts of these cases are taken into account. As shown in Table 8, the ROI in Case 1 would become positive after 14 executions of the VGT suite, i.e. the cost of executing the manual test suite 14 times equals the implementation cost of the VGT suite. For Case 2, a positive ROI would be reached after 13 executions. However, since there is no cost associated with running the VGT suites, and because they can be run at night, they can greatly improve the test frequency and thereby provide daily feedback to the developers [Berner et al(2005)Berner, Weber, and Keller]. Hence, both VGT suites would reach a positive ROI within less than one calendar month, given that they identify defects.\n\nA graph visualizing when positive ROI is reached, conceptually, based on VGT transition cost and cost per manual test suite execution, is shown in Figure 8, supported by the model defined by Berner et al., 2005 [Berner et al(2005)Berner, Weber, and Keller]. This model assumes that the cost of the manual test case execution is linear, and that the maintenance costs are small and almost linear. Thus, positive ROI would be reached when the two lines cross, i.e. at time \\( t_N \\) in Figure 8. It should also be noted that during the VGT transition period, \\( t_0 \\) to \\( t_1 \\), the VGT suite is executed continuously during development, whilst the manual test suite might not be. However, the ROI calculations assume that the VGT suite must first be completed before execution.\n5 Discussion\n\nOur findings suggest that Visual GUI Testing (VGT) is industrially applicable, can find defects as effectively as manual testing and makes economic sense even though there are many challenges and problems in transitioning to and using VGT. A majority of the identified CPLs are similar to ones that have been identified for other automated testing techniques although some are unique to VGT. Our findings imply that VGT is industrially applicable today but that there is plenty of potential to improve both the technique itself as well as its tools. Below we discuss our major findings in more detail and point to important future work before concluding our discussion with a description of the limitations of our study.\n\n5.1 Challenges, problems and limitations\n\nEven though a significant number of CPLs regarding the transition to or usage of VGT were identified in this study, our main conclusion is still that VGT is a valuable and cost-effective technique with equal or even better defect-finding ability as manual testing. This conclusion was corroborated in discussions with the industrial practitioners that took part in the study and contributed to the identification of the CPLs; they also consider the benefits of VGT outweighing its drawbacks. The CPLs we found originated either from the SUT, the VGT tool or the test environment and resulted in frustration and confusion during test script development, raised VGT transition costs, etc.\n\nThe CPLs and the information we have provided about them provide decision support for industrial practitioners that aim to implement VGT. Our list of CPLs can be used to anticipate problems and costs and help create plans for the transitions as well as for finding solutions in a new company and automation context. This contribution is of particular interest since it has been established that there is an industrial need and want for VGT [Alegroth et al(2013b)Alegroth, Nass, and Olsson]. In addition, the CPLs can help guide future research both in developing solutions and work-arounds but also in further development of testing techniques and tools that overcome them.\n\nThe CPLs also provide a general contribution to test automation since many of them are also likely to be encountered when transitioning to other test automation techniques. A recent systematic literature review and practitioner survey [Rafi et al(2012)Rafi, Moses, Petersen, and Mantyla] found that there is currently a lack of industrial experience reports from using test automation; our study is one step towards filling this gap. In particular, the CPLs in theme number 4 (\"SUT Testability\" in Table 5) are general enough to pose problems for most test automation in industrial software development, and CPLs in theme number 5 (\"Test specification\" in Table 5) for testing in general. Any testing activities are constrained by the correctness of the requirements and test specifications and the alignment between them and the actual and current SUT. Thus, faulty, ambiguous or incorrect test specifications lead to faulty test results regardless if they are executed manually or automatically through a script. If a SUT has not been designed or implemented to a degree where it is easily testable it is harder or sometimes impossible to adapt a testing tool to the specific SUT. Thus, resulting in incomplete test cases and additional transition costs for said technique or tool.\n\nAnother CPL that would affect most automated test techniques [Horowitz and Singhera(1993)] is 'SUT/Tool synchronization', e.g. how to effectively synchronize SUT and VGT script execution to avoid script failure or false positive test results. Since one of the benefits of automation is that tests can be executed faster than manual this is likely to be a problem for many automation techniques. This CPL was also reported as one of the most frustrating and costly CPLs during this study. Another 'Script tuning' CPL was also considered costly but is unique to VGT: how to set the similarity level of sought GUI object images in the scripts to maximize robustness. All of the CPLs unique to VGT was related to the image recognition algorithm and how to robustly ensure that the right images are matched at the right time. Future work needs to look further into the long-term effects of these VGT-unique CPLs; if the scripts need to be continuously tuned even for minor GUI changes this will affect the long-term cost effectiveness of VGT.\n\nSeveral of the CPLs (theme 1 in Table 5) relates to the specific VGT tool we used, Sikuli. Sikuli is still in active development and only released as a beta version and on both of our industrial cases it was found to be immature which caused several CPLs. Since we have only used one specific tool it is also possible that we have only uncovered a subset of VGT-unique CPLs. Future work with other VGT tools could provide additional information.\n5.2 Solutions\n\nIt was reported during the study that almost all of the identified CPLs could be solved using context dependent or case specific practices or technical solutions. However, only four of these solutions were found to be general beyond the studied contexts but they were also identified solve almost half of the identified CPLs whilst the retaining half required more context dependent solutions.\n\nThe observation that almost all CPLs could be solved/overcome is significant since no CPL was identified that prohibits, or renders VGT useless, in the industrial contexts we studied. However, we also found that some solutions were both time consuming and tedious. For example, much efforts had to be spent to implement a custom, yet robust, script suite solution in Sikuli (to run different selections of individual test cases in groups) and to find ad hoc solutions and work-arounds for CPLs that the practitioners had expected the tool to solve, e.g. that Sikuli cannot type Swedish letters. These two results, in particular, show the immaturity of the Sikuli tool and presents features that industrial practitioners expect from all VGT tools.\n\nThe similarities between VGT and other GUI-based test techniques makes it likely that solutions can be migrated such techniques. For instance the SUT and VGT script execution was synchronized through static and dynamic delays, as presented in [Horowitz and Singherra(1993)], in Case 1 by implementing custom methods on top of the basic Sikuli delay functionality. More research is however required to find more of these common solutions, which could be identified through literature review and verified through empirical case studies, experiments or action research.\n\nFurthermore, even though no CPLs were identified that prohibit the use of VGT it is possible that not all CPLs can be solved in another context. One example would be how to ensure that the test specifications used for the VGT transition are unambiguous, correct and valid for the SUT. This problem is not VGT or even test related, but rather product management and development process related. Still it was perceived as a very complex problem in both our cases with complex systems with many different versions and variants. As such, it is an example of a CPL that is perceived not to be solvable in a VGT transition project but which would heavily affect the transition.\n\nIn summary, even though it was reported that most CPLs could be solved, the significant number of CPLs still post concerns for the long-term applicability of the technique and could, despite the several beneficial properties of the technique, discourage industrial practitioners from using or even testing VGT.\n\n5.3 Defect finding ability\n\nResults from the studied cases showed that the VGT scripts could identify all defects found by the manual test scenarios the scripts were transitioned from, but also previously unknown defects (Five in total in the studied cases). Thus, providing VGT scripts with the same level of confidence as manual test cases.\n\nThe reason why VGT can find more faults is because of the techniques low execution cost and speed. These properties allows VGT scripts to be run more often and with different orderings among the test cases. Thus stimulating more combinations of test scenarios that can occur during practical usage of the SUT and thereby uncover more defects [Rothermel et al(2001)]Rothermel, Untch, Chu, and Harrold]. Additionally, some defects are intermittent and therefore require multiple test executions to be identified, which is supported by VGT. This adds to the cost-effectiveness, value and defect-finding ability of the technique and can lead to higher quality software and lower overall development costs. However, we stress that VGT, regardless of the high level of confidence, should not be used as a substitute to manual testing, rather it should be a complement. The reason is because VGT scripts, like all script-based techniques, can only find defects explicitly asserted by the test scenario [Berner et al(2005)Berner, Weber, and Keller,Hkonen and Rautiainen(2005b)]. However, it seems reasonable that VGT can be used to automate scripted test scenarios while the manual testing can be focused more on exploring the system and finding difficult usage scenarios.\n\nAn analysis performed during the study also showed that VGT can fulfill the requirements set by the RTCA DO-278 quality assurance standard, which was a requirement for the technique’s use in Case 1. The main reasons is because VGT can replicate manual testing in a 1-to-1 fashion, with equivalent inputs and assertions as a human tester, and because the standard puts further emphasis on what to test, not how to test it. The results of this analysis indicate that VGT, because it provides the same level of confidence as manual testing, can fulfill other standards of similar rigor as well. This is a valuable result since it implies that VGT can be used, or at least complement other test practices, in safety- and life-critical domains.\nThe results regarding the defect-finding ability of VGT is also contributes to the body of knowledge about the technique and strengthens the support for the technique’s industrial value and applicability. We also present six defects of varying nature that were identified using VGT that provide further decision support for industrial practitioners regarding what types of defects they can expect to identify using VGT. In addition, the defects represent a benchmark for academic researchers that aim to compare their tools and techniques against VGT and other techniques in an industrial context. However, we once again stress that VGT was only compared against manual testing in this study and that it is unclear how VGT would compare to other GUI-based or automated testing techniques. This types of comparisons is an important subject for future work.\n\n5.4 Return on Investment\n\nResults from the study showed that the return on investment (ROI) of transitioning the manual test suites into VGT would be positive within one month after completion, assuming that the VGT suite was executed every other night, i.e. after approximately 15 executions. We therefore conclude that VGT can be both a feasible and cost effective technique in industrial practice. However, because of the limited length of our study we have not studied the long-term cost effectiveness of the technique since we lack detailed data on VGT’s maintenance costs.\n\nFurthermore, because the studies were performed in different contexts, with different input and different number of script developers, no common cost model can be formulated from the data. The presented development costs and ROI metrics provide only indicative measures that provide further decision support for industrial practitioners. In addition, the costs are only for one test suite from Case 1 and three from Case 2 respectively, whilst a larger big-bang effort, with more test suites, would raise the up-front costs further and would require more time and more test executions for these costs to pay back. Thus, the high transition costs indicates that the choice of transition approach, iterative or big-bang, is important. As shown in related research, an iterative approach can be more beneficial [Berner et al(2005)Berner, Weber, and Keller, Williams et al(2009)Williams, Kudrjavets, and Nagappan]. However, at the same time we found that test cases that covered SUT functionality that had not been completed lead to partially implemented test cases. This shows that the SUT must have reached a certain level of maturity for VGT to be applicable since the scripts, just as system tests, aim to test SUT usage scenarios in its entirety [Beizer(2002)]. As such, in order to maximize ROI the script developer should have good knowledge about the system and perceivably start by implementing the test cases that are the most stable, test the core or most problematic functionality of the SUT. This is supported in discussions with the practitioners in Case 2 that in the future will prioritize and select test suites for transitioning based on several of these factors.\n\nFurthermore, it should be noted that our ROI calculations do not explicitly cover maintenance costs of the VGT scripts. Maintenance was conducted in Case 2 during the study [Alegroth et al(2013a)Alegroth, Feldt, and Olsson] and has affected our ROI analysis, but in Case 1 the ROI is solely based on the development costs. As such, the calculated ROI may not be representative for a project with extensive maintenance or one with a GUI that makes image recognition harder and thus requires more script tuning.\n\n5.5 Similarities between VGT and other GUI-based techniques\n\nVGT has several similarities to other GUI-based test techniques such as required up front development costs, dependencies on correct SUT documentation, requirements on SUT maturity, etc. The main difference identified in this study revolve around CPLs related to the technique’s use of image recognition and the currently unknown maintenance costs. These distinctions prohibit any conclusion to be drawn if VGT is better or worse than other GUI-based test techniques in industrial practice due to lacking empirical data.\n\nThe identified commonalities are however significant since it allows CPL solutions to be migrated to and from other techniques. Furthermore, this could lead to joint research opportunities and indicates that an empirical comparison between VGT and other GUI-based techniques, e.g. Record and Replay with Selenium [Holmes and Kellogg(2006)], is both feasible. However, to the authors’ best knowledge, there are no studies that compare VGT with other GUI-based techniques in an industrial context; this can be an important area of future work.\n\nAs also stated, this study was only performed with one VGT tool and it is therefore possible that greater differences could be observed with other tools, e.g. JAutomate [Alegroth et al(2013b)Alegroth, Nass, and Olsson]. However, based on the commonalities between VGT tools [Alegroth et al(2013b)Alegroth, Nass, and Olsson], this is considered a minor risk.\n5.6 Threats to validity\n\nOne of the limitations of this study is that both of the VGT transitions were performed on test cases for safety-critical systems with legacy code and similar characteristics. This is a threat to external validity. In particular, the results might not be applicable for smaller systems or companies that are young or immature in their development practices and processes. However, the studied companies use fairly different development processes, one more plan-driven and one more agile, but we have found no evidence that this has any large effects on the transitioning to automated test scripts.\n\nThere was also a difference in the architecture and structure of the manual test suites at the two companies. We have mitigated this threat by analyzing and discussed this difference in detail. Since both projects used the same VGT tool (Sikuli) the results are likely to depend on the tool. However, in earlier research we found that Sikuli had comparable properties and capabilities to a commercial VGT tool [Börjesson and Feldt(2012)] so we don’t think this threat external validity is a major one.\n\nWe still caution that the collected quantitative information should not be compared without considering the context of these transitioning projects since the projects were performed with different systems, by individuals with different experience and with different information acquisition processes. However, since data collection procedures differed between projects but still corroborated each other we consider little negative effect from these factors on the identified CPL’s; apart from the system-specific CPL’s they are likely to be seen also in other contexts.\n\nThe study participants in Case 1 and 2 were all inexperienced with VGT and the tool at the start of the projects. We do not consider this a major threat to validity since this is likely to be typical of these types of transition projects in industry. The more experienced researchers can be considered as a kind of expert consultants which would typically be made available in most companies deciding to do large test suite transitioning. They supported data collection and lead study design in early stages. Also, the experienced researchers lead interviews and feedback workshops during the later stages of the project and performed the analysis. Triangulation was also achieved through independent interviews and inclusion of different roles. We also stress that Table 6 is based on an indicative analysis based on empirical and secondary data from literature that only aims to provide an overview of the commonalities between VGT CPLs and CPLs related to other GUI-based test techniques and manual testing. As such, there may exist exceptions to the presented results. We have covered this threat by stating the tables limitations in Section 4.4.\n\nThere is additional threats to validity in Case 2 since it was driven by industrial partitioners and the researchers were not on site other than on specific occasions. However, the researchers had continuous contact with the practitioners and focused on setting up good procedures and communication in early stages, as well as collecting experiences and feedback in later stages. We argue that the threats to internal validity that comes from using industrial practitioners in research are unavoidable. If the empirical software engineering community want data from real, industrial projects a certain lack of control must be accepted. Furthermore, since the industrial practitioners had been tasked with doing the transition and evaluating VGT they were highly motivated to do the work and collect relevant data.\n\n6 Conclusions\n\nMany software development companies rely on manual test practices to perform high-level (typically GUI-based) testing even though these practices are considered costly, tedious and error prone. Test automation, such as unit testing or Record and Replay, is generally proposed as a panacea to these types of problems. However, even though there is evidence that these techniques can be applied there is also empirical evidence to suggest that these techniques have problems that can limit their industrial applicability in certain contexts. Because of these limitations there is a need for further research into high-level test automation.\n\nVisual GUI Testing is one such and a fairly recent technique with interest from industry. It combines image recognition with scripting to automate high-level tests. Empirical studies have shown that the technique can be applied for testing complex software systems but like any other technique, VGT has challenges, problems and limitations (CPLs) when applied on a larger scale in industrial practice. These CPLs have previously not been explored and there is a general lack of empirical studies in industry on high level and GUI level testing.\n\nIn this paper we have presented an empirical study performed in two industrial projects where researchers and industrial practitioners used VGT to automate circa 300 high-level (GUI level) system test cases in a total of four different test suites. During the study, a total of 58 CPLs were identified that were categorized into 26 unique types of CPLs that relate either to the transition to, or usage of, VGT in\nindustrial practice. The CPLs concern different aspects: version of the tested system, the tested system in general, defects in the tested system, the company’s specific hindrances, the test environment, the VGT tool’s image recognition, deficiencies in the tool, or third party software.\n\nThe most prominent CPLs was classified into six main themes, three of which were related to VGT or more specifically the used VGT tool Sikuli, e.g. image recognition volatility, immaturity of the VGT tool, lack of integration with third party software and more. Two of the remaining three themes were general for any type of testing, e.g. negative effects due to ambiguous or faulty test specifications, lack of version control of the SUT, and more. The last theme was general for GUI-based testing and amounted to the need to fine-tune test scripts to ensure robust script execution. This CPLs theme was also the cause of the most frustration and cost and included how to effectively synchronize VGT script execution with the SUT’s execution and how to set image similarity to make test execution robust. The identified CPLs may discourage industry practitioners from trying or using the technique, whilst also posing concerns for the long-term applicability of VGT in industrial practice, but can also be used in decision support and planning as well as in mitigating problems.\n\nFour generic solutions that address about half of the identified CPLs, and mitigate their negative effects was identified during the study. More specific solutions were identified, but these were ad hoc and context dependent and could therefore not be generalized from the specific companies or the used tool. The latter solutions included specific development practices, additional script logic to mitigate faulty tool behavior, explicit choices of support software, etc.\n\nDespite the identified challenges the industrial practitioners considered VGT to be both effective at finding defects and cost-effective overall. In the case project driven by industrial practitioners, the system test frequency was increased from once every six months to several times a week at a minimal cost. Three previously unknown defects were also identified during the transition project. Similar results were acquired from the case project driven by the research team where four previously known and two unknown defects were identified. These results were further supported by the quantitative information that was acquired during the study that indicate that the VGT transition costs are feasible with the potential to provide positive return on investment within one month after development, with up to 16 times quicker execution speed compared to manual testing, whilst still providing equal or even better defect finding ability than manual testing.\n\nIn conclusion, this study has shown that VGT is a valuable and cost-effective technique for high-level (GUI level) test automation but also that it has many challenges that warrant future research. Our detailed description and analysis of the cases, the identified problems as well as solutions, costs and identified defects can help inform industrial VGT transition projects as well as help researchers prioritize their improvement efforts of VGT, GUI-based testing as well as test automation in general.\n\nAcknowledgment\n\nThe authors of this manuscript would like to thank Saab AB for their participation in these projects and their continued support in answering the question if Visual GUI Testing is an industrially applicable technique. We would also like to thank the reviewers and the editor for the constructive and valuable feedback on the manuscript.\n\nReferences\n\n\n"}}},{"rowIdx":180,"cells":{"id":{"kind":"string","value":"cedb11fb0a61e58d97a58d86db424240c3278e8a"},"text":{"kind":"string","value":"Integration of parametric and “ad hoc” second order polymorphism in a calculus with subtyping\n\nGiuseppe Castagna\n\n\nKeywords: type theory, typed foundation of object-oriented programming, second order λ-calculus, bounded polymorphism.\n\nAbstract. In this paper we define an extension of $F_≤$ [CG92] to which we add functions that dispatch on different terms according to the type they receive as argument. In other words, we enrich the explicit parametric polymorphism of $F_≤$ by an explicit “ad hoc” polymorphism (according the classification of [Str67]). We prove that the calculus we obtain, called $F_≤^\\&$, enjoys the properties of Church-Rosser and Subject Reduction and that its proof system is coherent. We also define a significant subcalculus for which the subtyping is decidable.\n\nThis extension has not only a logical interest but it is strongly motivated by the foundation of a broadly used programming style: object-oriented programming. The connections between $F_≤^\\&$ and object-oriented languages are widely stressed, and the modeling by $F_≤^\\&$ of some features of the object-oriented style is described, continuing the work of [CGL92].\n\nIn this paper we present a calculus where the computation of a function can depend on the type the function is applied to. There are two main motivations to this work. The first is to start a type theoretic foundation of second order “ad hoc” polymorphism. The second is to solve the problem of the “loss of information” in the overloading based model of object-oriented programming [CGL92] in the same way as $F_≤$ solved it for the record-based one [GM94].\n\n1 Part of this work has appeared under the title “$F_≤^\\&$: integrating parametric and ‘ad hoc’ second order polymorphism” in the 4th International Workshop on Database Programming Languages, New York City, August 1993\n\n2 The author was supported by the grant n. 203.01.56 of the Consiglio Nazionale delle Ricerche - Comitato Nazionale delle Scienze Matematiche to work at LIENS\n\nCorrespondence and offprint requests to: Giuseppe Castagna, LIENS, 45 rue d’Ulm, 75005 Paris, FRANCE, e-mail: castagna@dmi.ens.fr.\nThe overloading-based model has as advantage with respect to the record-based one that it can model multiple dispatch\\(^3\\), and therefore it gives a typed account both for the class-based object-oriented languages (such as Smalltalk) and for the generic-functions-based ones (such as CLOS). However we do not lean for any of the two styles: multiple dispatch is indeed essential for generic functions, but it is of great importance also in class-based languages (see [Cas95a]).\n\nThe awkwardness of the theory developed in this paper is an example of the disadvantages of the overloading-based with respect to the record-based one.\n\n1. Introduction\n\nSystem \\(F\\) is a language that allows us to write functions that take types as inputs; however these functions depend on their input in a very strict way: computation does not depend on the input type in the sense that different input types will return always the same (type-free) result but in different types. The practical counterpart of this observation is given by the fact that types are thrown away during the computation which is then performed on the erasure of the terms. \\(F_\\prec\\) is a conservative extension of \\(F\\), which allows the specification of bounds on the types that are passed to a function; the type-checker uses this further information to type the body of the function. But the functions of \\(F_\\prec\\) still have the same kind of dependence as in System \\(F\\), since types again disappear during the computation. Here we want to extend \\(F_\\prec\\) by a type dependency also affecting the computation. We want to have functions that dispatch on different codes according to the type passed as argument. As a side effect, types will no longer be erasable at runtime.\n\nThis research fits into a larger framework: In language theory, polymorphism has two orthogonal classifications: “parametric vs. ad hoc” (see [Str67]) and “explicit vs. implicit”. Parametric polymorphism, i.e. the capability of performing the same code on different types, has been widely studied, both in the explicit form (where types participate directly in the syntax; e.g. System \\(F\\)) and in the implicit one (where types participate via the terms they type; e.g. ML). “Ad hoc” polymorphism, i.e. the capability of performing a different code for each different type, has not received the same attention. In [CGL92], with the definition of the \\(\\&\\&\\)-calculus, we started a theoretical analysis of implicit “ad hoc” polymorphism (on the line of some ideas in [Ghe91]). In this paper we tackle the explicit counterpart, by defining \\(F_\\&\\prec\\) a calculus with subtyping, which integrates parametric and “ad hoc” explicit polymorphism. The practical counterpart is the definition of a type discipline that avoids the loss of information in object-oriented programming and fits the paradigms based on generic functions, as explained right below.\n\nObject-oriented programming\n\nThis extension is not of mere logical interest but is strongly motivated by the modeling of object-oriented languages and the definition of a type discipline to strongly type them. Let us try to be more specific. In object-oriented languages the computation evolves on objects. Objects are programming items grouped in \\textit{classes} and possessing an internal state that is modified by sending messages to the object. When an object receives a message it invokes the method (i.e. code or procedure) associated to that message. The association between methods and messages is described by the class the object belongs\n\n---\n\n\\(^3\\) In object-oriented languages, multiple dispatch is the capability of performing the selection of the method not only on the class of the receiver but also on the classes of further parameters.\nto. Now, there are two possible ways to implement message-passing: the first is to consider objects as records that associate to each message a method. Thus messages are labels of a record, methods are the values in the fields and message passing corresponds to field selection. This implementation has been extensively studied and corresponds to the “objects as records” analogy of [Car88]. The second way is to consider messages as (identifiers of) special functions which take an object as argument and are able to dispatch on different codes according to the class of that argument (this is done in CLOS: [DG87]). This is the approach taken in [CGL92] where classes are used to type objects and messages are thus overloaded functions, i.e. functions that dispatch on different codes according to the type (the class) of their arguments. There, an overloaded function is a finite collection of ordinary functions (λ-abstractions) that are grouped together to form the different branches, and its type is the set of the types of its branches. More precisely the different branches are glued together by means of “&” (whence the name of λ&-calculus); thus\n\n\\[ m = (a_1 \\& a_2 \\& \\ldots \\& a_n) \\]\n\nis an overloaded function with \\( n \\) branches \\( a_1, \\ldots, a_n \\). If \\( a_i : C_i \\rightarrow T_i \\) then the type of \\( m \\) is\n\n\\[ m : \\{ C_1 \\rightarrow T_1, \\ldots, C_n \\rightarrow T_n \\} \\]\n\nIn object-oriented terms, this means that the “message” \\( m \\) has been associated to a method in the “classes” \\( C_1, \\ldots, C_n \\), each method returning a result of type \\( T_i \\) respectively.\n\nIf we apply \\( m \\) to a value \\( b \\) of type \\( C_j \\) (i.e. if we pass the message \\( m \\) to an object \\( b \\) of class \\( C_j \\)) then the branch (method) \\( a_j \\) is selected and \\( a_j(b) \\) is executed.\n\n**Example 1.1.** Suppose that we have defined the following (class) types:\n\n\\[ 2\\text{DPoint} = \\langle x : \\text{Int}; y : \\text{Int} \\rangle \\]\n\\[ 3\\text{DPoint} = \\langle x : \\text{Int}; y : \\text{Int}; z : \\text{Int} \\rangle \\]\n\nA simple example of a method for these classes is \\( \\text{Norm} \\) that can be implemented by the following overloaded function:\n\n\\[ \\text{Norm} \\equiv (\\lambda \\text{self} 2\\text{DPoint}. \\sqrt{\\text{self}.x^2 + \\text{self}.y^2}) \\]\n\\[ \\& (\\lambda \\text{self} 3\\text{DPoint}. \\sqrt{\\text{self}.x^2 + \\text{self}.y^2 + \\text{self}.z^2}) \\]\n\nwhose type is \\( 2\\text{DPoint} \\rightarrow \\text{Real}, 3\\text{DPoint} \\rightarrow \\text{Real} \\). In this case if we apply \\( \\text{Norm} \\) to an object of type \\( 2\\text{DPoint} \\) (i.e. we pass the message \\( \\text{Norm} \\) to that object) then the first branch is selected; if the object has type smaller than or equal to \\( 3\\text{DPoint} \\) the second branch is executed.\n\n**Inheriting methods**\n\nIn this calculus a subtyping relation is defined on types. Intuitively, a type is smaller than another type when every value of the former type can be safely used where a value of the latter is expected. Thus in the case as before it may happen that the type \\( C \\) of \\( b \\) does not exactly match one of the \\( C_i \\)'s but it is a subtype of one of them. In this case the selected branch is the one that best approximates the type of the argument, i.e. the branch \\( j \\) such that \\( C_j = \\min_{i=1, n} \\{ C_i \\mid C \\leq C_i \\} \\). On this selection of the minimum relies the mechanism of inheritance, and it corresponds to the usual method look-up of object-oriented languages: in object-oriented terms if we send the message \\( m \\) to the object \\( b \\) of type \\( C \\) then the method defined in the class \\( C_j = \\min_{i=1, n} \\{ C_i \\mid C \\leq C_i \\} \\) is executed: if this minimum is exactly \\( C \\), this means that the receiver \\( b \\) uses the method that has been defined in its class; otherwise, that is if this minimum is strictly greater than \\( C \\), then the receiver uses the method that its class, \\( C \\), has inherited from the class \\( C_j \\), which is the least super-class of \\( C \\) in which the message \\( m \\) has been (re)defined.\nExample 1.2. [continued] Suppose that \\(3DPoint \\leq 2DPoint\\): this means that \\(3DPoint\\) has been defined as a subclass of \\(2DPoint\\) and that the method defined for \\(Norm\\) in \\(2DPoint\\) (first line of the definition) has been redefined (overridden) by a new method in \\(3DPoint\\) (second line of the definition). Suppose now to have a third class \\(3DColorPoint \\leq 3DPoint\\). If an object of this new class is applied to that same \\(Norm\\) then, by the selection of the minimum, the method defined in \\(3DPoint\\) is executed; this means that the class \\(3DColorPoint\\) has inherited the method defined in its superclass \\(3DPoint\\).\n\nThe problem of loss of information\n\nSuppose we have a message \\(m'\\) which modifies the internal state of a class \\(C_1\\). Since we are in a functional approach the method in \\(C_1\\) returns a new object of class \\(C_1\\). Thus \\(m': \\ldots, C_1 \\rightarrow C_1, \\ldots\\). Let \\(C_2\\) be a subclass of \\(C_1\\) from which it inherits the method at issue. If we pass the message \\(m'\\) to an object of \\(C_2\\) then the branch defined in \\(C_1\\) is selected. Since this branch has type \\(C_1 \\rightarrow C_1\\), the result of message passing has type \\(C_1\\), rather than \\(C_2\\) as would be natural. This problem was already pointed out for the record-based model in [Car88] and it is known as the “loss of information problem”. In our case the problem is less serious than in Cardelli’s calculus: indeed, in the case above we could imagine to add to \\(m'\\) a fake branch \\(C_2 \\rightarrow C_2\\) which would be used only during the phase of type-checking and then it would be discarded\\(^4\\) (this has been done in [Cas92]). However this solution is interesting only in practical cases, where there is a finite number of classes; otherwise an infinite branching would be required. Although this solution works whenever the set of classes has a well-founded ordering (as it is always the case in practice) it becomes unmanageable when one starts to distinguish subtyping from subclassing (as done in [CHC90]). In conclusion we need a new type system to account for this problem.\n\nFor the record-based model there the solution adopted was to pass to a second order formalism. This yielded the definition of Fun in [CW85], which was further developed in many works (a non exhaustive list includes [CCH+89, Ghe90, CHC90, CL91, CMMS91, BTCGS91, Bru94, PT93]) and, in particular, which gave raise to the definition of \\(F_{\\leq}\\) in [CG92].\n\nHere we adopt the same solution w.r.t. the \\(\\lambda\\&\\)-calculus, and we pass to a second order formalism to avoid the problem of loss of information. The idea is to have a type system which types the previous \\(m'\\) in the following way:\n\n\\[\nm': \\ldots, \\forall X \\leq C_1. X \\rightarrow X, \\ldots\n\\]\n\nFor this reason in this paper we define \\(F_{\\leq}\\) where this type dependency is dealt with in an explicit way\\(^5\\).\n\nType dependency\n\nIn a programming language a function which performs a dispatch on a type passed as argument would be probably be written as:\n\n\\[^4\\) Note that such a solution cannot be used also for the record-based model. We cannot replace the function, say, \\(\\lambda x: C_1. x\\) by \\(\\lambda x: C_2. x\\) since the latter would no longer accept inputs of type \\(C_1\\).\n\n\\[^5\\) The other solution is to deal with it in an implicit way by introducing type schemas à la ML, with bounds on the generic variables.\\]\nFun(X:*):= case X<T1: exp1\n | X<T2: exp2\n | ... \n | X<Tn: exp_n\n\nThis function executes exp_1 if we pass a type less than or equal to T_1, exp_2 if it is less than or equal to T_2 and so on. The case structure suggests a parallel testing. Thus, if there is more than one candidate we select among them the branch with the least bound. In F ≤ this function is denoted by:\n\n\\( (\\Lambda X \\leq T_1. \\text{exp}_1 \\& \\Lambda X \\leq T_2. \\text{exp}_2 \\& \\ldots \\& \\Lambda X \\leq T_n. \\text{exp}_n) \\)\n\nand its type is \\( \\forall X \\{T_1, S_1, T_2, S_2, \\ldots, T_n, S_n\\} \\) (where \\( \\text{exp}_i : S_i \\)). However this type is a rough approximation yet. Indeed, to obtain a coherent and expressive system, we need strong restrictions on the \\( T_i \\)'s and the \\( S_i \\)'s.\n\nFirst of all note that the selected branch may change during the computation. For example take a function \\( f \\) of type \\( \\forall X \\{T_1, S_1, T_2, S_2\\} \\) with \\( T_2 \\leq T_1 \\). Consider now the expression \\( \\( \\Lambda Y \\leq T_1. f[Y] \\) \\). Since \\( Y \\leq T_1 \\) we guess that the branch selected in \\( f[Y] \\) will be the one associated to \\( T_1 \\) and thus the type of this expression will be \\( \\forall (X \\leq T_1) S_1 \\) (more exactly \\( \\forall (Y \\leq T_1) S_1 [X := Y] \\)). But if we pass to the function above the type \\( T_2 \\) then, as \\( Y \\) is bound to \\( T_2 \\), the selected branch will be the second one and the result will have type \\( S_2 \\). System \\( F \\) and \\( F \\leq \\) satisfy the subject reduction property, i.e. types are preserved under reductions. If we want reductions to preserve the type also in the new system we must require \\( S_2 \\) to be the same type as \\( S_1 \\). But, it turns out that this is too strong a condition to model object-oriented languages (see the examples in section 6). Thus we adopt a less restrictive discipline, according to which types are allowed to decrease during computation. Thus in the example above it must be possible to deduce \\( X \\leq T_2 + S_2 \\leq S_1 \\). Summing up, the first restriction we impose on an overloaded type \\( \\forall X \\{T_i, S_i\\} \\) is that if \\( T_i \\leq T_j \\) then \\( X \\leq T_i + S_i \\leq S_j \\) (we call it the covariance condition, since it accounts for a longstanding debate on covariance vs. contravariance in the subtyping of the arrow types: see more on it in [CGL92]). Note the use of sequents: the premise records the subtyping relation on the type variables; we call it a type constraint system.\n\n**Definition 1.3.** \\( \\emptyset \\) is a type constraint systems (tcs); \\( \\text{dom}(\\emptyset) = \\emptyset \\). If \\( C \\) is a tcs, \\( X \\not\\in \\text{dom}(C) \\) and for every \\( Y \\in \\text{FV}(T) \\), \\( Y \\in \\text{dom}(C) \\) then \\( C \\cup \\{X \\leq T\\} \\) is a type constraint system and \\( \\text{dom}(C \\cup \\{X \\leq T\\}) = \\text{dom}(C) \\cup \\{X\\} \\).\n\nSometimes we will use the notation \\( C(X) \\) to denote the bound associated to \\( X \\) in \\( C \\). By the definition above for a given tcs \\( C \\) and a type variable \\( X \\in \\text{dom}(C) \\) there always exists a least non variable type \\( T \\) greater than \\( X \\). We denote it by \\( B(X)_C \\) (the \\( B \\) stands for bound). More precisely we have the following definition.\n\n**Definition 1.4.** Let \\( C \\) be a tcs and \\( T \\) a raw type such that \\( \\text{FV}(T) \\subseteq \\text{dom}(C) \\) then\n1. \\( B(T)_C = T \\) if \\( T \\) is not a type variable.\n2. \\( B(T)_C = B(C(T))_C \\) otherwise.\n\nIn the rest of the paper we omit the subscript \\( C \\) in \\( B(T)_C \\) when it is clear from the context.\n\nWe limit our study to the case where the bounds of an overloaded function range over basic types (e.g. Bool, Int, Real ...). Indeed, the use of arrow types in the bounds\n\n---\n\n\\(^6\\) A raw type is a type that may not be well formed. See section 2\nposes many non-trivial problems, due to the contravariance of the left argument in the subtyping relation. Therefore the second restriction we impose is that \\( \\forall X \\{ T_i, S_i \\}_{i \\in I} \\) is well-formed only if for every \\( i \\in I \\) \\( B(T_i) \\) is a basic type\\(^7\\).\n\nThus every bound \\( T_i \\) must be an atomic type, i.e. either a basic type or a type variable.\n\nWhen the bound is a type variable, say \\( X \\), the basic type \\( B(X) \\) plays an important role, since the set of its subtypes (denoted by \\( \\mathcal{P}(B(X)) \\) ) is the range of \\( X \\). When we apply an overloaded function to a type, a selection rule picks the branch to execute. As we already said, this rule selects the branches with a bound provably larger than or equal to the type passed as the argument, and among them it chooses the one with the least bound.\n\nSome conditions are required to assure that this minimum exists. In \\( \\lambda \\text{c} \\)-calculus this existence was assured by requiring that the bounds had to form a partial downward semi-lattice.\\(^8\\)\n\nBut there we had only closed types. Now with type variables this restriction no longer suffices: consider the example of the figure above; it is clear that \\( X \\) and \\( A \\) have no common lower bound (since the only judgment we can prove for \\( X \\) is that \\( X \\leq B(X) \\)).\n\nNevertheless if \\( X \\) takes the value \\( B \\), it can enter in conflict with \\( A \\) since they have a common lower bound \\( C \\).\n\nThus if a variable \\( X \\) appears in an overloaded type as a bound then conflicts must be checked taking into account every type in \\( \\mathcal{P}(B(X)) \\). To this purpose we require that every set of bounds satisfies the property of \\( \\cap \\)-closure, defined as follows:\n\n**Definition 1.5.** Let \\( C \\) be a type constraint system. Given a set of atomic types \\( \\{ A_i \\}_{i \\in I} \\) we write \\( C \\vdash \\{ A_i \\}_{i \\in I} \\cap \\)-closed iff for all \\( i, j \\in I \\) if \\( B(A_i) \\subseteq B(A_j) \\) then there exists \\( h \\in I \\) such that \\( C \\vdash A_h = A_i \\cap A_j \\).\n\nHere \\( C \\vdash A_h = A_i \\cap A_j \\) means that from \\( C \\) it is provable that \\( A_h \\) is the g.l.b. of \\( A_i \\) and \\( A_j \\) (i.e. we need a derivation for \\( C \\vdash A_h \\leq A_i \\), one for \\( C \\vdash A_h \\leq A_j \\) and one for \\( C \\vdash A \\leq A_h \\) for every \\( A \\) which is a common lower bound of \\( A_i \\) and \\( A_j \\)—note that they is a finite number of such \\( A \\)), and \\( B_1 \\not\\sqsubseteq B_2 \\) that \\( B_1 \\) and \\( B_2 \\) have a common lower bound (in this case we need the proof only for two judgments).\n\nNote that \\( \\cap \\)-closure is quite a draconian restriction. Indeed \\( \\cap \\)-closed sets of bounds have a very precise form (see proposition 2.5): they are partial downward semi-lattices, i.e. formed by disjoint unions of downward semi-lattices. These semi-lattices are divided in two parts: the upper part is a semi-lattice formed only by basic types; the lower part is formed by a chain of type variables starting from the least element of a semi-lattice of basic types. Any of these two parts may be missing. A pictorial representation of the situation is given in figure 1.\n\n---\n\n\\(^7\\) The major drawback of this restriction is that we cannot obtain the quantification of System \\( F \\) as a special case of the overloaded one and thus we will be obliged to add it explicitly. See also sections 6.3 and 7.\n\n\\(^8\\) A set \\( S \\) is a partial downward semi-lattice iff for all \\( a, b \\in S \\) if \\( a \\not\\sqsubseteq b \\) then \\( a \\cap b \\in S \\). Here \\( a \\not\\sqsubseteq b \\) means that \\( a \\) and \\( b \\) have a common lower bound (in \\( S \\)) and \\( a \\cap b \\) denotes their greatest lower bound.\nParametric and \"ad hoc\" polymorphism\n\nRemark that \\( \\cap \\)-closure is always relative to a tc's since it determines the order for type variables (we assume that the order on basic types is predefined).\n\n2. Type system\n\nIn this section we describe the type system. We first define the raw types. Among them we select the types, i.e. those raw types that do not contain overloaded types not satisfying the three rules we hinted in the introduction. In other terms \\( \\forall X \\{ A_i, T_i \\}_{i \\in I} \\) must:\n\n1. have bounds ranging over basic types, i.e. for each \\( i \\in I, B(A_i) \\) must be a basic type.\n2. have a \\( \\cap \\)-closed set of bounds.\n3. satisfy covariance, i.e. if \\( A_i \\leq A_j \\) then \\( X \\leq A_i \\Rightarrow T_i \\leq T_j \\).\n\nWe suppose we have a predefined ordering on basic types which forms a partial lattice. This partial order is extended to higher types by a set of subtyping rules that are mutually recursive with those selecting the types.\n\n**Raw Types**\n\n\\[\nA ::= X \\mid B \\quad \\text{(atomic types \\([B\\text{ basic types}]\\))}\n\\]\n\n\\[\nT ::= A \\mid \\text{Top} \\quad \\text{(raw } F_{\\leq} \\text{ types)}\n\\]\n\n\\[\nT \\rightarrow T \\quad \\forall (X \\leq T) T \\quad \\forall X \\{ A_1, T_1, \\ldots, A_n, T_n \\} \\quad \\text{(also denoted by } \\forall X \\{ A_i, T_i \\}_{i=1}^n \\text{)}\n\\]\n\n**Judgments**\n\nWe have three kinds of judgment: for type well-formedness \\( C \\vdash T \\text{ type} \\), for the subtyping relation \\( C \\vdash T \\leq T' \\) and for the typing relation \\( C \\vdash a : T \\). We call the first two kinds of judgments type judgments. Throughout the paper we also use some informal judgements: for example \"\\( C \\vdash T = \\min_{i \\in I} \\{ T_i \\} \\)\" stands for \"\\( T \\in \\{ T_i \\}_{i \\in I} \\) and for all \\( i \\in I C \\vdash T \\leq T_i \\).\"\nTypes\n\n(Basic\\textsubscript{type}) \\quad C \\vdash B \\text{ type}\n\n(Top\\textsubscript{type}) \\quad C \\vdash \\text{Top type}\n\n(Vars\\textsubscript{type}) \\quad C \\vdash T \\text{ type} \\quad \\frac{C \\cup \\{X \\leq T\\} \\vdash X \\text{ type}}{C \\vdash \\{X \\leq T\\} \\text{ type}}\n\n(\\rightarrow\\textsubscript{type}) \\quad C \\vdash T \\text{ type} \\quad C \\vdash T' \\text{ type} \\quad \\frac{C \\vdash T \\rightarrow T' \\text{ type}}{C \\vdash T \\text{ type}}\n\n(\\forall\\textsubscript{type}) \\quad C \\vdash \\forall(X \\leq T) \\text{ type} \\quad \\frac{C \\vdash T \\text{ type}}{C \\vdash \\forall(X \\leq T) \\text{ type}} \\quad (\\ast)\n\n(\\forall\\textsubscript{type}) \\quad C \\vdash A_i \\text{ type} \\quad \\frac{C \\vdash \\{A_i\\}_{i \\in 1..n} \\text{ n-closed}}{C \\vdash \\forall(X \\leq A_i) \\text{ type}}\n\n(\\forall\\textsubscript{type}) \\quad \\text{ if } C \\vdash A_i \\leq A_j \\text{ then } C \\cup \\{X \\leq A_i\\} \\vdash T_i \\leq T_j \\quad \\frac{C \\vdash \\forall X \\{A_1, T_1, \\ldots, A_n, T_n\\} \\text{ type}}{(\\ast\\ast)}\n\n\\text{Subtyping}\n\n(refl) \\quad \\frac{C \\vdash T \\text{ type}}{C \\vdash T \\leq T} \\quad (\\ast)\n\n(trans) \\quad C \\vdash T_1 \\leq T_2 \\quad C \\vdash T_2 \\leq T_3 \\quad \\frac{C \\vdash T_1 \\leq T_3}{C \\vdash T_1 \\leq T_2}\n\n(taut) \\quad \\frac{C \\vdash T \\text{ type}}{C \\vdash \\forall(X \\leq T) \\text{ type}} \\quad (\\ast)\n\n(Top) \\quad C \\vdash T \\text{ type} \\quad \\frac{C \\vdash \\text{Top type}}{C \\vdash T \\leq \\text{Top}}\n\n(\\rightarrow) \\quad C \\vdash T_1 \\leq T_i \\quad C \\vdash T_2 \\leq T_j \\quad \\frac{C \\vdash T_1 \\rightarrow T_2 \\leq T_i \\rightarrow T_j}{C \\vdash T_1 \\leq T_2 \\rightarrow T_i \\rightarrow T_j}\n\n(\\forall) \\quad \\frac{C \\vdash T_i \\leq T_i \\quad C \\vdash T_2 \\leq T_2 \\quad C \\vdash \\forall(X \\leq T_1) \\text{ type}}{C \\vdash \\forall(X \\leq T_1) \\text{ type}} \\quad (\\ast)\n\n\\forall \\{A_{ij}, T_{ij}\\}_{i \\in J} \\text{ type} \\quad C \\vdash \\forall X \\{A_{ij}, T_{ij}\\}_{i \\in I} \\text{ type}\n\n(\\forall) \\quad \\text{ for all } i \\in I \\text{ exists } j \\in J \\text{ s.t. } C \\vdash A_{ij} \\leq A_i \\quad \\frac{C \\vdash \\forall X \\{A_{ij}, T_{ij}\\}_{i \\in I}}{C \\vdash \\forall X \\{A_{ij}, T_{ij}\\}_{i \\in I}} \\quad (\\ast)\n\n\\text{for all } i \\in I \\text{ exists } j \\in J \\text{ s.t. } C \\vdash A_{ij} \\leq A_i \\quad \\frac{C \\vdash \\forall X \\{A_{ij}, T_{ij}\\}_{i \\in I}}{C \\vdash \\forall X \\{A_{ij}, T_{ij}\\}_{i \\in I}} \\quad (\\ast)\nTypes are considered equal modulo the order in overloaded types. The substyping rules above define a pre-order. Antisymmetry does not hold but on atomic types (therefore lub’s and glb’s are univocally defined).\n\n2.1. Some useful results\n\nTheorem 2.1. If \\( C \\vdash T \\leq T' \\) then \\( C \\vdash T \\) type and \\( C \\vdash T' \\) type\n\nProof. By induction on the depth of the proof of \\( C \\vdash T \\leq T' \\).\n\nLet us introduce some terminology: we say that two types have the same shape if they are both constant types or both type variables, or both \\( \\text{Top} \\), or both arrow types, or they are both overloaded or both parametric types.\n\nThe following result on the form of the judgements will be frequently used in the rest of the paper.\n\nProposition 2.2. Let \\( C \\vdash T_1 \\leq T_2 \\). Then\n\n1. If \\( T_1 \\) is not a variable then \\( T_2 \\) either is \\( \\text{Top} \\) or it has the same shape as \\( T_1 \\).\n2. If \\( T_2 \\) is not \\( \\text{Top} \\) then \\( T_1 \\) either is a variable or it has the same shape as \\( T_2 \\).\n\nProof. By induction on the depth of the proof of \\( C \\vdash T_1 \\leq T_2 \\), performing a case analysis on the last applied rule of the proof.\n\nAnother useful fact that will be extensively used in the proofs of this paper is the following one:\n\nProposition 2.3. If \\( C \\vdash T_1 \\leq T_2 \\) then \\( C \\vdash B(T_1)_C \\leq B(T_2)_C \\).\n\nLemma 2.4. If \\( C \\vdash X \\leq Y \\) then \\( B(X)_C = B(Y)_C \\).\n\nProof. An easy induction on the number of steps of the definition of \\( B(X)_C \\).\n\nThe following proposition describes the the form of the \\( \\cap \\)-closed set of types:\n\nProposition 2.5. If \\( C \\vdash \\{A_i\\}_{i \\in I} \\cap \\)\\(-\\)closed then for any pair of elements \\( A_i \\) and \\( A_j \\) such that \\( B(A_i)_C \\nleq B(A_j)_C \\) one of these cases must hold:\n\n1. \\( B(A_i)_C \\) and \\( B(A_j)_C \\) are unrelated (w.r.t. the substyping relation), \\( A_i \\) and \\( A_j \\) are both basic types and their g.l.b. is in \\( \\{A_i\\}_{i \\in I} \\).\n2. \\( B(A_i)_C \\leq B(A_j)_C \\) and both \\( A_i \\) and \\( A_j \\) are basic types (or the reverse).\n3. \\( B(A_i)_C \\leq B(A_j)_C \\), \\( A_i \\) is a variable and \\( A_j \\) is a basic type.\n4. \\( B(A_i)_C \\leq B(A_j)_C \\), \\( A_i \\) and \\( A_j \\) are both variables and \\( C \\vdash A_i \\leq A_j \\) (or the reverse).\n\nProof. Let us examine all the possible cases:\n\n1. \\( A_i \\) and \\( A_j \\) are both basic types. Then all the possible cases are covered by the first two points of the proposition.\n2. \\( A_i \\) is a variable and \\( A_j \\) is a basic type. Then we want to prove that \\( B(A_i)_C \\leq B(A_j)_C \\). Consider \\( A_h = A_i \\cap A_j \\). Since \\( C \\vdash A_h \\leq A_i \\) then by proposition 2.2 \\( A_h \\) is a variable too. By lemma 2.4 \\( B(A_h)_C = B(A_i)_C \\). Since \\( C \\vdash A_h \\leq A_j \\) then by proposition 2.3 we obtain the result.\n\n---\n\n8 Without loss of generality, we can consider for this case and for the case 4 that \\( B(A_i)_C \\leq B(A_j)_C \\) holds. Thus in this proof and in those that follow we will skip the reverse case.\n3. $A_i$ and $A_j$ are both variables. Consider $A_h = A_i \\cap A_j$. By proposition 2.2, $A_h$ is also a variable and by lemma 2.4, $B(A_h)_C = B(A_i)_C = B(A_j)_C$. Thus both $A_i$ and $A_j$ appear in the chain from $A_h$ to $B(A_h)_C$. Therefore either $C \\vdash A_i \\leq A_j$ or $C \\vdash A_j \\leq A_i$ holds, according to the order they appear in the chain.\n\n\\[ \\square \\]\n\n2.2. Transitivity elimination\n\nThe rules of subtyping given above do not describe a deterministic algorithm: a subtyping judgment does not univocally determine neither the rule to prove it nor the parameters that such a rule must have. In particular non-determinism is introduced by the rules (refl) and (trans):\n\nConsider the judgment $C \\vdash T \\leq T$; if $T$ is not a variable nor $\\top$ then the judgment can be proved by at least two different derivations, one consisting just of the rule (refl) the other obtained by applying the structural rule for $T$ (e.g. $(\\rightarrow)$ if $T$ is an arrow type) and the rule (refl) to the components of $T$. This kind of non-determinism can be easily solved by choosing either to use (refl) as soon as possible or to use it as late as possible (i.e. only on atomic types). We choose this second solution thus we substitute the rule (refl) above by the following one:\n\n\\[\n\\frac{C \\vdash Type}{C \\vdash A \\leq A}\n\\]\n\nIt is then very simple to prove that this new system is sound and complete w.r.t. the previous one: soundness is obvious and completeness is given by the following lemma:\n\n**Lemma 2.6.** For each $C$ and $T$ such that $C \\vdash T$ type the judgment $C \\vdash T \\leq T$ is provable using reflexivity only on atomic types.\n\n**Proof.** A straightforward induction on the structure of $T$ \\[ \\square \\]\n\nAlso the rule (trans) produces a non-determinism similar to the one of (refl): we have always the choice to apply transitivity or to push it to the subcomponents. But, besides that, (trans) introduces a deeper form of non-determinism quite harder to eliminate. Indeed, the (trans) rule does not respect the so-called “sub-formula property”, according to which all the types appearing at the premises of a rule must appear in its consequence, too. When proving $T_1 \\leq T_3$ by transitivity, a new level of non-determinism is introduced by the choice of the intermediate type $T_2$ such that $T_1 \\leq T_2$ and $T_2 \\leq T_3$.\n\nThe reader will have recognized in it a cut elimination problem. Indeed, transitivity elimination in subtyping systems corresponds to cut elimination in Gentzen’s sequent calculus for the first order logic. Both of them lead to a coherence result of the corresponding proof system, by returning a canonical derivation for each provable judgment. The resemblance is even stronger since we can use the Gentzen’s technique for cut elimination to prove also transitivity elimination. Namely, we define a weakly normalizing rewriting system on the derivations of subtyping judgments. This system will push the transitivity rules towards the leaves of the derivation; whenever it has to choose between pushing transitivity up into a left or a right subderivation it (arbitrarily) chooses the one on the right. The derivations in normal form will have all the (trans) rules applied to a leaf of the derivation tree.\n\nSince it is difficult to work directly with derivations, we use the Curry-Horward isomorphism [How80] to define a set a terms to univocally codify subtyping derivations. We follow for their definition [CG92], where these terms are called coercion expressions.\nThe syntax of the coercion expressions is:\n\n\\[\ne : = K_{B_1, B_2} \\mid Id_A \\mid X_T \\mid \\text{Top}_T \\mid c \\rightarrow c' \\mid \\forall (X \\leq e) e' \\mid \\forall T X \\{ c_1, c_1', \\ldots, c_n, c_n' \\}\n\\]\n\nwhere \\( \\phi \\) denotes a total function between two sets of indexes \\( \\phi : I \\rightarrow J \\).\n\nWe next show how to use coerce expressions to codify derivations. In the rules that follow we do not consider the judgements of type formation \\((C \\vdash T_{\\text{type}})\\) and we concentrate only on the subtyping judgements. Considering them would greatly complicate the exposition, without bringing any benefit: firstly the rules defining type formation describe a deterministic algorithm (note indeed that type formation uses subtyping only on atomic types, thus there is not a real mutual recursion), and thus they do not pose any coherence problem; secondly, all the proofs in the rest of this section will work on a given type and on its syntactical sub-formulas; if we suppose by hypothesis that the type is well formed then the proofs will be valid also when restricted to well formed types (sub-formulae of well formed types are well formed types).\n\nThus the derivations we codify involve only subtyping judgements and work under the hypothesis that all the types appearing in them are well-formed. We also use (refl) defined only for atomic types.\n\n\\[\n(C) \\quad C \\vdash K_{B_1, B_2} : B_1 \\leq B_2 \\quad (\\dagger)\n\\]\n\n\\[\n(C) \\quad C \\vdash Id_A : A \\leq A\n\\]\n\n\\[\n(C) \\quad C \\vdash c : T_1 \\leq T_2 \\quad C \\vdash c' : T_2 \\leq T_3 \\\\\n\\quad \\Rightarrow \\quad C \\vdash c \\cdot c' : T_1 \\leq T_3\n\\]\n\n\\[\n(C) \\quad C \\cup \\{ X \\leq T \\} \\vdash X_T : X \\leq T\n\\]\n\n\\[\n(C) \\quad C \\vdash \\text{Top}_T : T \\leq \\text{Top}\n\\]\n\n\\[\n(C) \\quad C \\vdash c_1 : T_1 \\leq T_1' \\quad C \\vdash c_2 : T_2 \\leq T_2' \\\\\n\\quad \\Rightarrow \\quad C \\vdash c_1 \\rightarrow c_2 : T_1 \\rightarrow T_2 \\leq T_1' \\rightarrow T_2'\n\\]\n\n\\[\n(C) \\quad C \\vdash c_1 : T_1 \\leq T_1' \\\\\n\\quad \\forall (X \\leq c_1) c_2 : \\forall (X \\leq T_1') c_2 : \\forall (X \\leq T_1') T_2 \\leq \\forall (X \\leq T_1') T_2' \\\\\n\\quad \\Rightarrow \\quad C \\vdash \\forall (X \\leq c_1) \\forall (X \\leq T_1') c_2 : \\forall (X \\leq T_1') T_2 \\leq \\forall (X \\leq T_1') T_2'\n\\]\n\n\\[\n(C) \\quad \\forall i \\in I \\quad C \\vdash c_i : A_i \\leq A_{d(i)} \\\\\n\\quad \\forall (X \\leq A_i) c_i' : \\forall (X \\leq A_i') \\vdash c_i' : T_{d(i)} \\leq T_i' \\\\\n\\quad \\Rightarrow \\quad C \\vdash \\forall^\\phi_{X \\leq (x, \\tau)} X \\{ c_i, c_i' \\} : \\forall (X \\leq A_i) c_i' : \\forall (X \\leq A_i') \\vdash c_i' : T_{d(i)} \\leq T_i'\n\\]\n\n\\[\n(C) \\quad \\text{for all basic types } B_1, B_2 \\text{ such that } B_1 \\leq B_2\n\\]\n\n\\[\n(\\dagger) \\quad \\phi : I \\rightarrow J \\text{ total}\n\\]\n\nNote that the term associated to transitivity is the composition of the terms associated to the sub-derivations.\n\nThe last rule shows the use of the function \\( \\phi \\): during the subtyping of two overloaded types, \\( \\phi \\) associates each branch of the greater overloaded type with the branch in the smaller type to which it has been compared in the proof of subtyping. Note that this information would not suffice to univocally determine the derivation codified by a given\ncoercion expression; in case of overloaded types we need also to know the type on the left-hand side of the relation, which is recorded in the lower index of $\\forall$.\n\n**Proposition 2.7.** There is a 1-1 correspondence between well-typed coerce expressions and subtyping derivations.\n\n**Proof.** A simple analysis of the rules shows that the normal forms of this rewriting system are subterms of $(c \\to d) \\epsilon_1 \\ldots \\epsilon_n$ or of $(\\forall (X \\leq c) \\epsilon_1 \\ldots \\epsilon_n$ or of $(\\forall T X \\{c_i, d_i\\}) \\epsilon_1 \\ldots \\epsilon_n$, where $c, c_i,$ and $d_i$ are in normal form and $\\epsilon_1, \\ldots, \\epsilon_n$ are either $X_i$ or $\\text{Top}_T$ of $K_{BB}$ (composition is right associative). These normal forms correspond to derivations in which every left premise of a (trans) rule is a leaf. Thus the rewriting system pushes the transitivity up to the leaves. It remains to prove two facts:\n\n1. The rewriting system is sound, i.e. it rewrites a valid derivation for a certain judgment into another valid derivation for the same judgment. By the Curry-Howard isomorphism this is equivalent to proving the subject reduction theorem for the calculus of the coercion expressions; namely we have to show that a well typed coerce expression rewrites only to well typed coerce expressions of the same type.\n2. The rewriting system is weakly normalizing. In this case there exists a reduction strategy which transforms every derivation into another that proves the same judgment and is in normal form (i.e. with the (trans) rules at the right places).\n\n---\n\n$^{5}$ Strictly speaking this theorem is true modulo weakenings of the tcs'\n### 2.2.2. Soundness of the rewriting system\n\nThe proof of the soundness of the rewriting system is very similar to the corresponding one in [CG92]. We first have to prove the following lemmas:\n\n**Lemma 2.8. (weakening)** If \\( C \\vdash c : \\Delta \\) is provable and \\( C \\cup \\{ X \\leq T \\} \\) is a tcs then also \\( C \\cup \\{ X \\leq T \\} \\vdash c : \\Delta \\) is provable.\n\n**Proof.** By a simple induction on the proof of \\( C \\vdash c : \\Delta \\).\n\n**Lemma 2.9. (substitution)** If \\( C \\vdash c : U \\leq V \\) and \\( C \\vdash c : X \\rightarrow T \\) are provable then \\( C \\vdash c : X \\rightarrow T \\vdash c : a \\rightarrow \\overline{U} \\leq V \\) is provable too.\n\n**Proof.** By induction on the structure of \\( c \\). We only detail the proof when \\( c \\) is a variable; all the other cases are either trivial (\\( K_{BB} \\), \\( \\text{Top} \\), and \\( \\text{Id} \\)) or they are solved by a straightforward use of the induction hypothesis (\\( \\rightarrow, \\forall, \\forall' \\)).\n\nThere are two subcases:\n1. \\( c \\equiv X_T \\). The result becomes \\( C \\cup \\{ X \\leq S \\} \\vdash d : X \\leq T \\) which is satisfied by hypothesis.\n2. \\( c \\equiv Y_V \\). The hypothesis becomes \\( C \\cup \\{ X \\leq T \\} \\vdash Y_V : Y \\leq V \\). Therefore \\( C \\vdash Y_V : Y \\leq V \\). By a weakening (lemma 2.8) we obtain the result \\( C \\cup \\{ X \\leq S \\} \\vdash Y_V : Y \\leq V \\).\n\nNow we are able to prove the soundness of the rewriting system\n\n**Theorem 2.10.** If \\( c \\rightsquigarrow d \\) and \\( C \\vdash c : \\Delta \\) then \\( C \\vdash d : \\Delta \\).\n\n**Proof.** Follow the proof of section 5.2 in [CG92]. For the cases (\\( \\{ \\} \\)‘) and (\\( \\{ \\} \\)’‘) lemma 2.9. The detailed proof of these cases can be found in [Cas94].\n\n#### 2.2.3. Weak normalization\n\nThe task of proving that the rewriting system is weakly normalizing is very simple since all the work has already been done in [CG92]: define\n\n\\[\n\\begin{align*}\n\\text{size}(A) &= \\text{size}(\\text{Top}) & \\overset{def}{=} 1 \\\\\n\\text{size}(S \\rightarrow T) &= \\text{size}(\\forall(X \\leq S)T) & \\overset{def}{=} \\text{size}(S) + \\text{size}(T) \\\\\n\\text{size}(\\forall X \\{ A_i : T_i \\})_{i \\in I} &= \\overset{def}{=} \\sum_{i \\in I} (\\text{size}(A_i) + \\text{size}(T_i))\n\\end{align*}\n\\]\n\nLet \\( m \\) and \\( m' \\) be two multisets of natural numbers; define\n\n\\( m < m' \\overset{def}{=} \\forall n' \\in m' \\exists n \\in m \\ n < n' \\)\n\n**Definition 2.11.** ([CG92]) Define the intermediate type of a coerce composition \\( d \\circ c \\), where \\( c : S \\leq T \\) and \\( d : T \\leq U \\), as the type \\( T \\). Then the complexity measure of a coerce expression \\( c \\) is the multiset of the sizes of the intermediate types of all the redexes of \\( c \\) modulo \\( \\text{ Assoc } \\).\n\n**Theorem 2.12.** Every innermost strategy for \\( \\rightsquigarrow \\) strictly decreases the complexity measure and thus terminates.\n\n**Proof.** The proof is strictly the same as the one of section 5.3.3 in [CG92] modulo some slight modifications for the cases involving overloaded types.\n2.3. Subtyping algorithm and coherence of the system\n\nConsider the following rewriting rules\n\n(id₁) \\[ \\text{Id}_T c \\leadsto c \\]\n(id₂) \\[ c \\text{Id}_S \\leadsto c \\]\n(bas') \\[ K_{BC} K_{AB} \\leadsto K_{AC} \\]\n(bas'') \\[ K_{BC} (K_{AB} c) \\leadsto K_{AC} c \\]\n(top) \\[ \\text{Top}_T c \\leadsto \\text{Top}_S \\]\n(varTop) \\[ X_{\\text{Top}} \\leadsto \\text{Top}_X \\]\n\nThese rules perform some cleaning of the derivations, basically by erasing useless coercions.\n\nThis set of rules clearly constitutes a strongly normalizing rewriting system (use as metrics for the coercion expressions the lexicographical order of the pairs formed by the number of compositions in the expression and by the number of variables occurring in it). Furthermore no rule increases the complexity measure given in the previous section for weak normalization, and they are all sound. Therefore we can safely add these rules to the previous rewriting system: all the results of the previous section still hold. In the rest of this section we will always consider the rewriting system formed by the old rules and those introduced above.\n\n2.3.1. The shape of the normal forms\n\nIt is very important to analyze the shape of the normal forms of the composed rewriting system. We have the following theorem:\n\n**Proposition 2.13.** Every well-typed coerce expression in normal form has the form \\( c_0 \\ldots c_n \\) with \\( n \\geq 0 \\), where \\( c_0 \\) can be any coerce expression different from composition, whose subformulae are in normal form, and \\( c_1 \\ldots c_n \\) are variables.\n\n**Proof.** This proposition can be easily proved by induction on \\( n \\) (where \\( n \\) is the number of outer compositions of the normal form at issue). For \\( n = 0 \\) the result is obvious. The inductive case \\( n > 0 \\) is proved by a case analysis on the shape of \\( c_0 \\), by using proposition 2.2 and the reduction rules. First of all note that because of the rewriting rules (top) and (id₁) \\( c_0 \\) can be neither \\( \\text{Top}_T \\) nor \\( \\text{Id}_A \\):\n\n\\[\nc_0 \\equiv X_T \\quad \\text{Consider } c_1: \\text{it cannot be a composition because of (Assoc). By proposition 2.2 it can be nothing but a variable: indeed we have that } c_1: S \\leq X \\text{ thus } S \\text{ must be a type variable, say, } Y \\text{ and therefore } c_1 \\equiv Y_X. \\text{The result follows by induction hypothesis.}\n\\]\n\n\\[\nc_0 \\equiv K_{B_1 B_2} \\quad \\text{Consider } c_1: \\text{it cannot be a composition because of (Assoc); it cannot be a constant because of (bas') if } n = 1, \\text{ because of (bas'') if } n > 1; \\text{ it cannot be } \\text{Top}_T \\text{ or } c \\to c' \\text{ or } \\forall (X \\leq c) c' \\text{ or } \\forall^\\phi T X \\{c_1, c_1', \\ldots, c_n, c_n'\\} \\text{ because of proposition 2.2. Thus it can be but a variable. The result follows by induction hypothesis.}\n\\]\n\n\\[\nc_0 \\equiv c \\to c' \\quad \\text{Consider } c_1: \\text{it cannot be a composition because of (Assoc); it cannot be a } d \\to d' \\text{ because of (\\(\\to\\)) if } n = 1, \\text{ because of (\\(\\to\\)) if } n > 1; \\text{ it cannot be } \\text{Top}_T \\text{ or } c \\to c' \\text{ or } \\forall (X \\leq c) c' \\text{ or } \\forall^\\phi T X \\{c_1, c_1', \\ldots, c_n, c_n'\\} \\text{ because of proposition 2.2. Thus it can be but a variable. The result follows by induction hypothesis.}\n\\]\n\nAll the other cases are solved as the last two cases. \\(\\square\\)\n\nThis theorem has two important consequences: the coherence of the proof system for the subtyping relation and the definition of a subtyping algorithm.\nLemma 2.14. For every provable subtyping judgment there exists only one coercion expression in normal form proving it.\n\nProof. We follow the pattern of the proof of the corresponding proposition in [CG92]. Let $c$ be a well typed coercion expression in normal form. From propositions 2.13 and 2.2 it follows almost immediately that we have only these possible cases:\n\n1. if $c : A \\leq A$ then $c = Id_A$\n2. if $c : X \\leq Y$ then $c$ is a composition of variables, which is determined in an unique way by the tcs.\n3. if $c : B_1 \\leq B_2$ then $c = K_{B_1,B_2}$\n4. if $c : S \\rightarrow S' \\leq T \\rightarrow T'$ then $c$ is a $\\rightarrow$ coercion.\n5. if $c : \\forall X \\{A_i : T_i\\}_{i \\in I} \\leq \\forall X \\{A'_i : T'_i\\}_{i \\in I}$ then $c$ is a $\\forall^\\forall$ coercion.\n6. if $c : X \\leq B$ then $c$ is a composition of variables, which is determined in an unique way by the tcs, composed with a coercion of class 3 if $B(X) \\neq B$\n7. if $c : X \\leq T \\rightarrow T'$ then $c$ is a $\\rightarrow$ coercion.\n8. if $c : X \\leq T$ then $c$ is a composition of variables, which is determined in an unique way by the tcs, composed with a coercions of class 4 if $B(X) \\neq T \\rightarrow T'$\n9. if $c : X \\leq \\forall X \\{A_i : T_i\\}_{i \\in I}$ then $c$ is a composition of variables, which is determined in an unique way by the tcs, composed with a coercion of class 5 if $B(X) \\neq \\forall X \\{A'_i : T'_i\\}_{i \\in I}$\n10. if $c : X \\leq \\forall X \\{A_i : T_i\\}_{i \\in I}$ then $c$ is a composition of variables, which is determined in an unique way by the tcs, composed with a coercion of class 6 if $B(X) \\neq \\forall X \\{A'_i : T'_i\\}_{i \\in I}$\n11. if $c : T \\leq Top$ then $c$ is $Top_T$\n\nAfter this simple observation then the result can be proved by induction on the structure of $c$.\n\nTheorem 2.15. (coherence) Let $\\Pi_1$ and $\\Pi_2$ be two proofs of the same subtyping judgment $C \\vdash \\Delta$. If $c_1$ and $c_2$ are the corresponding coercion expressions then $c_1$ and $c_2$ are equal modulo the rewriting system.\n\nProof. By the weak normalization there exist two coercion expressions in normal form $d_1$ and $d_2$ such that $c_1 \\sim d_1$ and $c_2 \\sim d_2$. By the soundness of the rewriting system (theorem 2.10) it follows that $C \\vdash d_1 : \\Delta$ and $C \\vdash d_2 : \\Delta$. But then by lemma 2.14 we have that $d_1 \\equiv d_2$ (note that this constitutes also a proof that $\\sim$ is Church-Rosser.)\n\n2.3.3. Subtyping algorithm\n\nConsider once more the normal forms of proposition 2.13. These correspond to derivations in which every application of a (trans) rule has as left premise an application of the rule (taut). From this observation one directly derives the definition of the following subtyping algorithm:\n\n(AlgRefl) \\[ C \\vdash_\\alpha X \\leq X \\]\n\n(AlgTrans) \\[\n\\frac{C \\vdash_\\alpha C(X) \\leq T}{C \\vdash_\\alpha X \\leq T}\n\\]\n\n(AlgTop) \\[ C \\vdash_\\alpha T \\leq Top \\]\nThis set of rules denotes a deterministic algorithm since the form of the input—the judgment one has to prove—unequivocally determines the rule that must be used and all the parameters of any recursive calls.\n\nThis algorithm (which is a semi-decision procedure) is sound and complete w.r.t. our first system. This means that the sets of provable judgments of the two systems are the same. This is stated by the following theorem:\n\n**Theorem 2.16.** \\( C \\vdash \\Delta \\iff C \\triangleright \\Delta \\)\n\n**Proof.** Soundness \\((\\Rightarrow)\\) is easily proved by induction on the depth of the derivation of \\( C \\vdash \\Delta \\). Completeness \\((\\Leftarrow)\\) stems directly from the work of this section: take any proof of \\( C \\vdash \\Delta \\), apply to it the complete rewriting system with an innermost strategy; replace in the obtained normal form all the sequences of (taut) (trans) rules by an (AlgTrans) rule; add the index \\( A \\) to every turnstile and you have obtained a proof for \\( C \\vdash \\Delta \\).\n\n### 3. Terms\n\nIn this section we describe the terms of the language. We start by the definition of the raw terms, among which we distinguish the terms, i.e., those raw terms that possess a type.\n\nRoughly speaking, (raw) terms are divided in three classes: terms of the simply typed \\( \\lambda \\)-calculus, terms for parametric polymorphism and terms for overloading. Overloaded functions are built in a list fashion, starting by an empty overloaded function \\( \\varepsilon \\) and concatenating new branches by \\&. The \\&’s are indexed by a list of types which is used to type the term and to perform the selection of the branch.\n\n#### Indexes\n\n\\[ I ::= [A_1, T_1] \\mid \\ldots \\mid [A_n, T_n] \\]\n\n#### Raw Terms\n\n\\[\n\\begin{align*}\na & ::= x^T \\mid (\\lambda x^T . a) \\mid a(a) & \\text{(simply typed } \\lambda \\text{-calc)} \\\\\n& \\mid \\text{top} \\mid \\Lambda X \\leq T . a \\mid a(T) & F \\leq \\\\\n& \\mid \\varepsilon \\mid (a \\& I a) \\mid a[A] & \\text{overloading}\n\\end{align*}\n\\]\n\nWe required that the bounds of an overloaded function range over atomic types. Therefore the argument of an overloaded function can be restricted to be an atomic type \\( (a[A]) \\) since a term of the form, say, \\( a[S \\rightarrow T] \\) would be surely rejected by the type checker.\n\n#### Terms\n\nWe use the meta notation: \\( a[x := b] \\), \\( a[X := S] \\), \\( T[X := S] \\) for substitutions and \\( \\cup \\) for\nParametric and “ad hoc” polymorphism\n\nset-theoretic union. Also we use \\( C \\vdash a : S \\leq T \\) to denote that \\( C \\vdash a : S \\) and \\( C \\vdash S \\leq T \\). Type substitutions are performed on indexes, too. Terms are selected by the rules below; since term variables are indexed by their type, the rules do not need assumptions of the form \\( \\{x : T\\} \\):\n\n\\[\n\\begin{align*}\n\\text{[Vars]} & \\quad C \\vdash x^T : T & C \\vdash T \\text{ type} \\\\\n\\text{[\\rightarrow Intro]} & \\quad C \\vdash a : T' & C \\vdash T \\text{ type} \\\\\n\\text{[\\rightarrow Elim]} & \\quad C \\vdash a : T' & C \\vdash b : S' \\leq S & B(T')_c = S \\to T \\\\\n\\text{[Top]} & \\quad C \\vdash \\top : \\top \\\\\n\\text{[\\forall Intro]} & \\quad C \\vdash \\forall X \\leq T : a : T' & C \\vdash \\forall (X \\leq T) \\to T' & C \\vdash T \\text{ type} \\\\\n\\text{[\\forall Elim]} & \\quad C \\vdash a : T' & C \\vdash \\forall S' \\leq S & B(T')_c = \\forall (X \\leq S) \\to T \\\\\n\\text{[\\exists]} & \\quad C \\vdash e : \\forall X \\{ \\} \\\\\n\\text{[\\| Intro]} & \\quad C \\vdash a : S_1 \\leq \\forall X \\{ A_i : T_i \\}, i \\leq n \\& C \\vdash b : S_2 \\leq \\forall (X \\leq A) \\to T \\\\\n& \\quad C \\vdash (a \\& [A_i : T_i], \\ldots \\& [A_n : T_n], \\& [A.T]) ; \\forall X \\{ \\{ A_i, T_i \\}, i \\leq n \\} \\cup \\{ A.T \\} & (\\&)\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{[\\| Elim]} & \\quad C \\vdash a : T & C \\vdash A_j = \\min_{i \\leq l} \\{ A_i : C \\vdash A \\leq A_i \\} \\\\\n& \\quad C \\vdash a[A] ; T_j [X := A] & (\\&\\&)\n\\end{align*}\n\\]\n\n(\\&) \\( C \\vdash \\forall X \\{ \\{ A_i, T_i \\}, i \\leq n \\} \\cup \\{ A.T \\} \\} \\text{ type} \\\\\n(\\&\\&) \\ B(T')_c = \\forall X \\{ A_i, T_i \\}, i \\leq l\n\nNote the form of the premises in the rule [\\| Intro]; we cannot require that the components of an \\& must have the same type as the one specified in the index: since it is possible to reduce inside an \\& then the types of the components may decrease (see the subject reduction theorem 4.6) and cannot be fixed (the index does not change with the reduction thus even if types are equal modulo the ordering in overloaded types, terms are not equal modulo index reordering).\n\nA first non trivial result for this system is given by the following theorem.\n\n**Theorem 3.1.** If \\( C \\vdash a : T \\) then \\( C \\vdash T \\text{ type} \\)\n\n**Proof.** The proof is an easy induction on the depth of the proof of \\( C \\vdash a : T \\) by performing a case analysis on the last applied rule. The cases for [\\forall Elim] and [\\| Elim] are solved by using the lemma 4.3. □\n\nAs the careful reader will have noticed, we do not use subsumption in the type checking; since the selection of a branch is done according to the type of the argument we want,\nto avoid ambiguities, that every well typed term has a unique type. This is stated by the following theorem:\n\n**Theorem 3.2.** If \\( C \\vdash a : T_1 \\) and \\( C \\vdash a : T_2 \\) then and \\( T_1 = T_2 \\)\n\n**Proof.** An easy induction on sum of the depths of the derivation of \\( C \\vdash a : T_1 \\) and \\( C \\vdash a : T_2 \\), by performing a case analysis on the structure of \\( a \\) \\( \\Box \\)\n\nBy theorem 2.15, we can associate to every provable judgment a canonical derivation.\n\n**Theorem 3.3.** Let \\( \\Pi_1 \\) and \\( \\Pi_2 \\) be two derivations for the same judgment \\( C \\vdash a : T \\). Let \\( (\\Pi_1)^* (i = 1, 2) \\) denote the derivation \\( \\Pi_i \\) in which every (sub-)derivation of a subtyping judgment has been replaced by its canonical form. Then \\( \\Pi_1 \\equiv \\Pi_2 \\).\n\n**Proof.** By induction on the structure of \\( a \\) (which univocally determines the typing rule to apply). \\( \\Box \\)\n\nBy combining the result of this two theorems we obtain that every well typed term has a canonical derivation for its type.\n\nThus one would expect that it is possible to define a type-checking algorithm for the raw terms. This is the case, indeed: if in the system above you replace every subtyping judgment \\( C \\vdash S \\leq T \\) by \\( C \\vdash S \\leq T \\) you have a type-checking algorithm that can be easily proved sound and complete w.r.t. the original system.\n\n4. Reduction\n\nIn this section we give the equational theory of the terms of \\( F^C \\). We present it under the form of reduction rules. We assume we work modulo \\( \\alpha \\)-conversion for term variables; note that no clash is possible for type variables because of the definition of tcs. The reduction rules are context dependent.\n\n**Notions of reduction**\n\n\\[(\\beta) \\quad C \\vdash (\\lambda x^T. a)(b) \\Rightarrow a[x^T := b] \\]\n\n\\[(\\beta_n) \\quad C \\vdash (\\lambda X^T. a)(T') \\Rightarrow a[X := T'] \\]\n\n\\[(\\beta_1) \\quad \\text{If } A, A_1, \\ldots, A_n \\text{ are closed then} \\]\n\n\\[ C \\vdash (a \\& [A_1.T_1; \\ldots; A_n.T_n])b)[A] \\Rightarrow \\begin{cases} b[A] & \\text{if } A_n = \\min_{1 \\leq i \\leq n} \\{ A_i; C \\vdash A \\leq A_i \\} \\\\ a[A] & \\text{otherwise} \\end{cases} \\]\n\nNote that the selection of the branch is made on the index. Therefore while overloaded types are equal modulo reordering of their components, in indexes the order is meaningful since to a different ordering may correspond a different selection.\n\nBesides these rules there are the usual rules for the context; among these the only one that deserves a note is the rule for \\( \\lambda \\), for it changes the tcs of the reduction:\n\n\\[ C \\cup \\{ X \\leq T \\} \\vdash a \\Rightarrow a' \\]\n\nFor what it concerns the rules note that in \\( \\beta_1 \\) we require that the types involved in the selection of a branch are closed. In this way we always select the most precise branch (i.e. the one with the smallest possible bound). This correspond in object-oriented programming to the implementation of the *dynamic binding* (for a wider discussion on this topic see [CGL93].)\n4.1. Subject Reduction\n\nIn this section we prove that the type-checking system of $P^S_\\xi$ is well behaved w.r.t. the reduction rules. More precisely we prove that every (well-typed) term rewrites to another (well-typed) term, whose type is smaller than or equal to the type of the former. The proof of subject reduction is very technical and complex. The crux of the problem is to prove that the property of $\\cap$-closure is conserved under reductions, more precisely under (feasible) substitutions. For this reason we suggest the reader to skip at first reading the proofs of the three lemmas that follows.\n\nWe need first some notation:\n\n**Notation 4.1.** Let $C \\cup \\{X \\leq T\\}$ be a tcs. Define $(C \\cup \\{X \\leq T\\})[Y := S]$ as $(C[Y := S] \\cup \\{X \\leq T[Y := S]\\})$ and $\\emptyset[X := S]$ as $\\emptyset$. Let $C \\vdash \\Delta$ be a type judgment. Then $C \\vdash \\Delta[X := S]$ is defined as $C \\vdash T[X := S]$ type if $\\Delta \\equiv T$ type, as $C \\vdash T_1[X := S] \\leq T_2[X := S]$ if $\\Delta \\equiv T_1 \\leq T_2$.\n\nThe proof of subject reduction requires an assumption and three technical lemmas:\n\n**Assumption 4.2.** Recall that the proof of $C \\vdash \\{A_i\\}_{i=1..n} \\cap$-closed is indeed an appropriate set of proofs with final judgments of the form $C \\vdash A_i \\leq A_j$ proving the meet closure of $\\{A_i\\}_{i=1..n}$. In particular we suppose that this set contains at least one proof of $C \\vdash A_i \\leq A_j$ for every $i, j$ in $[1..n]$ for which such a proof exists.\n\n**Lemma 4.3. (main lemma)** If $C \\cup \\{X \\leq S\\} \\vdash \\Delta$ is a provable type judgment, $X \\notin FV(S')$ and $C[\\vdash X := S'] \\vdash S' \\leq S$ is also provable, then $C[\\vdash X := S'] \\vdash \\Delta[X := S']$ is provable, too.\n\nBefore proving the lemma, we want clarify a point: indeed the reader may wonder why in this lemma, as well as in lemma 4.5, we used the tcs $C[\\vdash X := S']$ rather than $C$. Actually if you replace $C[\\vdash X := S']$ by $C$ the theorem can no longer be proved, since at some points it is not possible to use the induction hypothesis (more precisely when you introduce a new variable in the tcs). The intuitive reason is that even if $C \\cup \\{X \\leq S\\}$ and $C[\\vdash X := S']$ are well formed tcs’s this does not imply the good formation of $C$. For example take $S' \\equiv S \\equiv B$ and $C \\equiv \\{Y \\leq X\\}$: $C$ is not well formed but $C[\\vdash X := S'] \\equiv Y \\leq B$ and $C \\cup \\{X \\leq S\\} \\equiv \\{Y \\leq X\\} \\cup \\{X \\leq B\\}$ are well formed.\\(^\\text{10}\\) We can now prove the lemma.\n\n**Lemma 4.4. (term substitution)** If $C \\vdash b : T' \\leq T$ and $C \\vdash a : S$ then $C \\vdash a[x := b] : S' \\leq S$.\n\n**Lemma 4.5. (type substitution)** If $C \\cup \\{X \\leq S\\} \\vdash a : T$, $C[\\vdash X := S'] \\vdash S' \\leq S$ and $X \\notin FV(S')$ then $C[\\vdash X := S'] \\vdash a[\\vdash X := S'] : T' \\leq T[\\vdash X := S']$.\n\nLemmas 4.3 and 4.5 constituted the hard part of the proof. It is then rather straightforward to prove the theorem of subject reduction by using the same technique of [CGL92].\n\n**Theorem 4.6. (subject reduction)** If $C \\vdash a : T$ and $C \\vdash a \\triangleright b$ then $C \\vdash b : T'$ and $C \\vdash T \\leq T$\n\n**Proof.** The proof is by induction on the depth of the proof of $C \\vdash a \\triangleright b$. Instead of presenting the proof for the base case (the rules $(\\beta)$, $(\\beta_k)$ and $(\\beta_l)$) and for the inductive case (the context rules), we think that a case analysis on the structure of $a$ is more intelligible. However we change only the order of presentation of the proof not the proof itself:\n\n\\(^{10}\\) The order in tcs is not important.\n\\(a \\equiv x^T \\) trivial.\n\\(a \\equiv \\varepsilon\\) trivial.\n\\(a \\equiv \\text{Top}\\) trivial.\n\\(a \\equiv \\lambda x^T . a' \\) and \\(b \\equiv \\lambda x^T . b'\\). This case is solved by a straightforward use of the induction hypothesis.\n\\(a \\equiv \\Lambda X \\leq T_1 . a' \\cup \\{X \\leq T_1\\} \\triangleright a' \\triangleright b'\\) and \\(b \\equiv \\Lambda X \\leq T_1 . b'\\). This case is solved by a straightforward use of the induction hypothesis.\n\\(a \\equiv (a_1 \\triangleleft a_2)\\) just note that whichever reduction is performed the reductum is well-typed and the type does not change.\n\\(a \\equiv a_1 (a_2)\\) where \\(C \\vdash a_1 : W , C \\vdash a_2 : S' \\leq S\\) and \\(B(W)_c = S \\rightarrow T\\). Then there are three possible subcases:\n1. \\(a_1 \\equiv \\lambda x^S . a_3\\) and \\(b \\equiv a_3[x^S : = a_2]\\), this case follows from lemma 4.4.\n2. \\(C \\vdash a_1 \\triangleright a_3'\\). Then by induction hypothesis we have \\(C \\vdash a_3' : T'' \\leq W\\). By proposition 2.3 \\(C \\vdash B(T''_c) \\leq B(W)_c\\). Since \\(B(T''_c)\\) is a not a type variable then it is of the form \\(S'' \\rightarrow T''\\) with \\(C \\vdash S' \\leq S'' \\leq S'\\) and \\(C \\vdash T'' \\leq T\\). Thus \\(b\\) is well-typed and with type \\(T'' \\leq T\\).\n3. \\(C \\vdash a_1 \\triangleright a_2'\\). Then by induction hypothesis we have \\(C \\vdash a_2' : S'' \\leq S' \\leq S\\). Thus \\(C \\vdash b : T\\).\n\\(a \\equiv a'(S)\\) where \\(C \\vdash a' : W , C \\vdash S \\leq S' , B(W)_c = \\forall (X \\leq S') . S''\\) and \\(T \\equiv S'' [X : = S]\\). Since \\(B(W)_c = \\forall (X \\leq S') . S''\\), then\n\\(C \\vdash \\forall (X \\leq S') . S''\\) type\nthis holds only if\n\\(C \\cup \\{X \\leq S'\\} \\vdash S''\\) type\nfrom which we deduce that \\(X \\not\\in \\text{dom}(C)\\). From this and from \\(C \\vdash S \\leq S'\\) we deduce that \\(X \\not\\in \\text{FV}(S)\\).\nNow there are two possible subcases:\n1. \\(a' \\equiv \\Lambda X \\leq S . a''\\) and \\(b \\equiv a''[X : = S]\\). But since \\(C \\vdash S \\leq S'\\) and \\(X \\not\\in \\text{FV}(S)\\) we can apply lemma 4.5. The result follows from \\(X \\not\\in \\text{dom}(C)\\).\n2. \\(C \\vdash b' : T'' \\leq W\\) and \\(C \\vdash B(T''_c) \\leq B(W)_c\\). Since \\(B(T''_c)\\) is not a type variable then it is of the form \\(\\forall (X \\leq U') . U''\\) with \\(C \\vdash S \\leq S' \\leq U'\\) and \\(C \\cup \\{X \\leq S'\\} \\vdash U'' \\leq S''\\). Thus \\(b\\) is well-typed and \\(C \\vdash b : U''[X : = S]\\). The result follows from the main lemma applied to \\(C \\vdash U'' \\leq S''\\) and the fact that \\(X \\not\\in \\text{dom}(C)\\).\n\\(a \\equiv a'(A)\\) where \\(C \\vdash a' : W\\) and \\(B(W)_c = \\forall X \\{A_i ; T_i\\} . A_i\\). As in the case before it is possible to prove that \\(X \\not\\in \\text{dom}(C)\\) and that \\(X \\not\\in \\text{FV}(A)\\). Let \\(A_b = \\min_{i \\in I} \\{A_i \\mid C \\vdash A \\leq A_i\\}\\). Then \\(T \\equiv T_b[X : = A]\\). Again we have two subcases:\n1. \\(a' \\equiv (a_1 \\triangleleft T_1 \\triangleright \\ldots \\triangleleft T_n \\triangleright a_2)\\) and \\(A_1, \\ldots , A_n\\) are closed and a \\(\\beta_i\\) -reduction is performed. Then either \\(b \\equiv a_1[A]\\) (case \\(A_b \\neq A_n\\)) or \\(b \\equiv a_2[A]\\) (case \\(A_b = A_n\\)). In both cases, by \\([\\{}\\text{ELIM}\\)] or by \\([\\forall \\text{ELIM}\\] according to the case, it is easy to prove that the terms have type \\(T' \\leq T_b[X : = A]\\) just use the induction hypothesis and then apply the main lemma.\n2. \\(C \\vdash a' \\triangleright a''\\). Then by induction hypothesis \\(C \\vdash a'' : W' \\leq W\\) and by proposition 2.3 \\(C \\vdash B(W')_c \\leq B(W)_c\\). Since \\(B(W')_c\\) is not a type variable then there exists \\(h \\in J\\) such that \\(C \\vdash A \\leq A_b \\leq A_{h'}\\). Therefore the set \\(\\{A'_{j} \\mid C \\vdash A \\leq A'_{j} , j \\in J\\}\\) is not empty,\nand by the meet-closure of $\\{A'_j\\}_{j,e}$, it has also a minimum. Call this minimum $A'_{k}$. Then $C \\vdash b : T'_k[X := A]$. Since $S \\equiv T_0[X := A]$ we have to prove that\n\n$$C \\vdash T'_k[X := A] \\leq T_0[X := A]$$\n\nTake again the previous $\\tilde{h}$, by the rule (1) we have\n\n$$C \\vdash \\forall (X \\leq A'_h) T'_h \\leq \\forall (X \\leq A_h) T_h$$\n\n(1)\n\nBy the definition of $A_h$:\n\n$$C \\vdash A \\leq A_h$$\n\n(2)\n\nFrom (1):\n\n$$C \\vdash A_h \\leq A'_h$$\n\n(3)\n\nFrom (trans):\n\n$$C \\vdash A \\leq A'_h$$\n\n(4)\n\nFrom the definition of $A'_k$ and from (3) we obtain\n\n$$C \\vdash A'_k \\leq A'_h$$\n\nand from this and the rule (1) applied to $\\forall X \\{A'_j : T'_j\\}_{j,e}$ it follows\n\n$$C \\vdash \\{X \\leq A_h\\} \\vdash T'_k \\leq T'_h$$\n\n(5)\n\nBy (2) and by the choice of $k$ we respectively have that $C \\vdash A \\leq A_h$ and $C \\vdash A \\leq A'_h$; thus we can apply the main lemma to (4) and (5) to obtain:\n\n$$C[X := A] \\vdash T'_k[X := A] \\leq T_0[X := A]$$\n\n$$C[X := A] \\vdash T'_k[X := A] \\leq T'_h[X := A]$$\n\nBut $X \\notin dom(C)$, thus the judgments above get\n\n$$C \\vdash T'_k[X := A] \\leq T_0[X := A]$$\n\n$$C \\vdash T'_k[X := A] \\leq T'_h[X := A]$$\n\nFinally by (trans) we obtain the result:\n\n$$C \\vdash T'_k[X := A] \\leq T_0[X := A]$$\n\n□\n\n4.2. Church-Rosser\n\nIn section 2.3 we proved the syntactic coherence of the proof system of $F^\\leq_k$. In this section we prove the syntactic coherence of the reduction system of $F^\\leq_k$.\n\nIn the reductions that follow we omit, without loss of generality, all the tcs. To prove the Church-Rosser property (CR) we use a method of Hindley [Hin64] and Rosen [Ros73]:\n\n**Lemma 4.7. (Hindley-Rosen)** Let $R_1$ and $R_2$ be two notions of reduction. If $R_1$ and $R_2$ are CR and $P_{R_1}$ commutes with $P_{R_2}$ then $R_1 \\cup R_2$ is CR.\n\n---\n\n11. The only place where this omission really matters is in the lemma 4.10 whose complete statement should be: If $C \\vdash \\{X \\leq S\\} \\vdash a \\vdash a'$ then $C \\vdash a[X := T] \\vdash a'[X := T]$. \n\n\nSet now \\( R_1 \\equiv \\beta_1 \\) and \\( R_2 \\equiv \\beta \\cup \\beta_r \\); if we prove that these notions of reduction satisfy the hypotheses of the lemma above then we proved CR. It is easy to prove that \\( \\beta \\cup \\beta_r \\) is CR; indeed in [Ghe90] it is proved that \\( \\beta \\cup \\beta_r \\) is terminating; by a simple check of the conflicts it is possible to prove that it is also locally confluent; since it has no critical pair then by the Knuth-Bendix lemma ([KB70]) it is locally confluent; finally by applying the Newman’s Lemma ([New42]) we obtain CR.\n\n**Lemma 4.8.** \\( \\beta_1 \\) is CR.\n\n**Proof.** By lemma 3.2.2 of [Bar84] it suffices to prove that the reflexive closure of \\( \\mathcal{P}_{\\beta_1} \\) (denoted by \\( \\mathcal{P}_{\\beta_1}^\\ast \\)) satisfies the diamond property. Thus by induction on \\( a \\mathcal{P}_{\\beta_1}^\\ast b \\) we show that for all \\( a \\mathcal{P}_{\\beta_1}^\\ast b \\) there exists a common \\( \\mathcal{P}_{\\beta_1}^\\ast c \\) reduct \\( a_3 \\) of \\( a_1 \\) and \\( a_2 \\). We can assume that \\( a_1 \\neq a \\) and \\( a_2 \\neq a \\). Let examine the possible cases:\n\n1. \\( (b_1 \\& b_2) [A] \\mathcal{P}_{\\beta_1}^\\ast b_1 [A] \\). If \\( a_2 \\equiv (b_1 \\& b_2) [A] \\) then \\( a_3 \\equiv a_1 \\); else \\( a_2 \\equiv (b_1' \\& b_2) [A] \\) then \\( a_3 \\equiv b_1'[A] \\).\n2. \\( (b_1 \\& b_2) [A] \\mathcal{P}_{\\beta_1}^\\ast b_2 (A) \\). If \\( a_2 \\equiv (b_1 \\& b_2) [A] \\) then \\( a_3 \\equiv a_1 \\); else \\( a_2 \\equiv (b_1 \\& b_2') [A] \\) then \\( a_3 \\equiv b_2'(A) \\).\n3. \\( b_1 (b_2) \\mathcal{P}_{\\beta_1}^\\ast b_1 (b_2) \\). If \\( a_2 \\equiv b_1 (b_2) \\) then \\( a_3 \\equiv b_1 (b_2) \\); else \\( a_2 \\equiv b_1' (b_2) \\); then by induction hypothesis there exists \\( b_3 \\) common \\( \\mathcal{P}_{\\beta_1}^\\ast \\) reduct of \\( b_1' \\) and \\( b_2' \\); thus \\( a_3 \\equiv b_3 (b_1) \\).\n4. \\( b_1 (b_2) \\mathcal{P}_{\\beta_1}^\\ast b_1 (b_2') \\) as the case before.\n5. \\( (b_1 \\& b_2) [A] \\mathcal{P}_{\\beta_1}^\\ast (b_1' \\& b_2) \\) as the case before.\n6. \\( (b_1 \\& b_2) [A] \\mathcal{P}_{\\beta_1}^\\ast (b_1 \\& b_2') \\) as the case before.\n7. \\( \\lambda x.T. a \\mathcal{P}_{\\beta_1}^\\ast \\lambda x.T. a' \\). Then \\( a_2 \\equiv \\lambda x.a'' \\) and by induction hypothesis there exists \\( b_3 \\) common \\( \\mathcal{P}_{\\beta_1}^\\ast \\) reduct of \\( a' \\) and \\( a'' \\). Thus \\( a_3 \\equiv \\lambda x.T. b_3 \\).\n8. \\( \\lambda X \\leq T. a \\mathcal{P}_{\\beta_1}^\\ast \\lambda X \\leq T. a' \\). as the case before (apart from the change of tcs in the induction hypothesis).\n9. \\( a(T) \\mathcal{P}_{\\beta_1}^\\ast a'(T) \\) as the case before.\n10. \\( a[A] \\mathcal{P}_{\\beta_1}^\\ast a'[A] \\) as the case before.\n\nTo prove that the two notions of reduction commute we need three technical lemmas:\n\n**Lemma 4.9.** If \\( a \\mathcal{P}_{\\beta_1} \\ a' \\) then \\( a[x := b] \\mathcal{P}_{\\beta_1} a'[x := b] \\)\n\n**Lemma 4.10.** If \\( a \\mathcal{P}_{\\beta_1} \\ a' \\) then \\( a[x := T] \\mathcal{P}_{\\beta_1} a'[x := T] \\)\n\n**Lemma 4.11.** If \\( b \\mathcal{P}_{\\beta_1} b' \\) then \\( a[x := b] \\mathcal{P}_{\\beta_1} a[x := b'] \\)\n\nThese lemmas can be proved by a straightforward use of induction (on \\( a \\mathcal{P}_{\\beta_1} \\ a' \\) for the first two and on \\( a \\) for the third). Just for the proof of the second, note that in \\( \\beta_1 \\), the atomic types \\( A, A_1, \\ldots, A_n \\) are required to be closed. We can now prove that the two notions of reduction commute.\n\n**Lemma 4.12.** If \\( a \\mathcal{P}_{\\beta \\cup \\beta_r} a_1 \\) and \\( a \\mathcal{P}_{\\beta_1} a_2 \\) then there exists \\( a_3 \\) such that \\( a_1 \\mathcal{P}_{\\beta_1} a_3 \\).\n$a_3$ and $a_2 \\triangleright_{\\beta \\cup \\beta'} a_3$. Pictorially:\n\n\\[\n\\begin{array}{ccc}\n\\text{Proof} & \\text{Proof} & \\text{Proof} \\\\\nC[\\lambda x. a] & C[a[x = b]] & C[(\\lambda x. a)b'] \\\\\n\\text{Lemma 4.9} & \\text{Lemma 4.11} & \\\\\nC[a'[x = b]] & C[a[x = b']] & \\\\\n\\end{array}\n\\]\n\n(Where full arrows are used for the hypotheses and dashed arrows for the theses.)\n\nProof. A proof of this lemma can be given by a simple diagram chase. Let $C[\\ ]$ be a context (in the sense of [Bar84])$^{12}$. Then we have the following cases:\n\n---\n\n$^{12}$ Avoid confusion between a context, denoted by $C[\\ ]$ and a type constraint system, denoted by $C$.\nCorollary 4.13. $\\beta_{\\beta_1}$ commutes with $\\beta_{\\beta_\\beta_\\beta}$\n\nProof. By lemma 3.3.6 in [Bar84].\n\nIn conclusion all the hypotheses of lemma 4.7 are satisfied, and we can conclude that $F_{\\leq}^\\leq$ is CR.\n\n5. A Decidable Subcalculus\n\nIt is well known that the type system of $F_{\\leq}$ is undecidable and that this problem comes from the subtyping system [Pie93]. Of course undecidability is inherited by $F_{\\leq}^\\leq$. The crux of the problem is the ($\\forall$) rule, which is responsible for the loss of many other syntactical properties (for a review see [CP94]).\n\nIn [CP94] we have defined a restriction of the subtyping system of $F_{\\leq}$, called $F_{\\leq}^T$, which enjoys many of the syntactical properties that $F_{\\leq}$ lacks, foremost decidability of subtyping. Furthermore nothing seems to be lost from a pragramatical viewpoint since all the programs that in our ken have been written for $F_{\\leq}$ are well typed also in our restriction.\n\nThe definition of this restriction is very easy: just substitute the incriminated ($\\forall$) rule by the following one\n\n\\[(\\forall\\text{-new}) \\quad \\frac{C \\vdash T_1 \\leq T_1 \\quad C \\cup \\{ X \\leq \\text{Top} \\} \\vdash T_2 \\leq T_2} {C \\vdash \\forall (X \\leq T_1) T_2 \\leq \\forall (X \\leq T_1') T_2} \\quad X \\not\\in \\text{dom}(C)\\]\n\nin which the right-hand premise requires that the bodies be (covariantly) related under no assumption about the bound variable. This essentially amounts to considering the subtyping relation relative to an unchanging context, since the type variables added to the context always have trivial bounds; the only type variables with interesting bounds will be those already present in the environment at the point where a subtyping check is required. (These are introduced, as usual, by the quantifier introduction rule.)\n\nThis simple change makes the subtyping relation decidable; thus one may wonder if by the same change in $F_{\\leq}^\\leq$ one obtains decidability. This is indeed the case, as we show in this section. As we already did when dealing with the transitivity elimination, we concentrate our attention on the subtyping rules, forgetting the type good formation; thus once more we suppose that all the types that appear below are well formed. By analogy with [CP94] we call it $F_{\\leq}^\\leq T$. \n\n5.1. Subtyping algorithm\n\nIn order to verify the decidability of the subtyping relation of $\\leq^\\Sigma_T$, one has first to define a subtyping algorithm which is sound and complete with respect to the type system. This is obtained by replacing the (Alg$^\\Sigma$) rule in the algorithm of section 2.3 by the new rule:\n\n$$\n\\frac{C \\vdash T_1 \\leq T_2 \\quad C \\cup \\{X \\leq \\text{Top}\\} \\vdash T_2 \\leq T'_2}{C \\vdash \\forall (X \\leq T_1) T_2 \\leq \\forall (X \\leq T'_1) T'_2} \\quad X \\notin \\text{dom}(C)\n$$\n\nNote that we do not change the rule (Alg$\\{\\}$); one might expect that also the bound in $C \\cup \\{X \\leq A'_i\\} \\vdash T_2 \\leq T'_2$ should be changed form $A'_i$ to $\\text{Top}$. This is not necessary to obtain decidability: indeed the bounds used in the overloaded quantification are far less general than those used in standard quantification, since the former can range only on constant types while the latter can range on all types (whence the undecidability). Thus we leave (Alg$\\{\\}$) as it is; in section 6 we will show how to use its full expressiveness, by defining some methods that would not be typed if (Alg$\\{\\}$) used the bound $\\text{Top}$ in comparing the types of different branches (see the definition of Erase). This however has a minor drawback, since we are not allowed to use the simple technique of [CP94] to prove transitivity elimination and thus the completeness of the algorithm. We are obliged to use the technique of [CG92] and prove again all the theorems of sections 2.2 and 2.3 from scratch.\n\nWe will not rewrite them here since actually very few modifications to the proofs in section 2.2 suffice to do the work. The main modification is in the rewriting system of section 2.2.1 where you have to substitute the rules\n\n$$(\\forall^\\prime) \\quad \\forall (X \\leq c) \\forall (X \\leq c') d' \\quad \\vdash \\forall (X \\leq c) d[X_T := c X_S]$$\n$$(\\forall^\\prime) \\quad \\forall (X \\leq c) (\\forall (X \\leq c') d) e \\quad \\vdash (\\forall (X \\leq c') d[X_T := c X_S]) e$$\n\nby the following ones\n\n$$(\\forall^\\prime) \\quad \\forall (X \\leq c) d \\quad \\forall (X \\leq c') d' \\quad \\vdash \\forall (X \\leq c') d$$\n$$(\\forall^\\prime) \\quad \\forall (X \\leq c) d \\quad (\\forall (X \\leq c') d) e \\quad \\vdash (\\forall (X \\leq c') d) e$$\n\nOf course now $\\forall (X \\leq c) d$ codifies the new $(\\forall)$ rule:\n\n$$(\\forall\\text{-new}) \\quad \\frac{C \\vdash c_1: T_1 \\leq T_2 \\quad C \\cup \\{X \\leq \\text{Top}\\} \\vdash c_2: T_2 \\leq T'_2}{C \\vdash \\forall (X \\leq c_1) c_2: \\forall (X \\leq T_1) T_2 \\leq \\forall (X \\leq T'_1) T'_2}$$\n\nThe reader can now move across the proofs of section 2.2 and check the obvious modifications; the proofs of section 2.3 are essentially unchanged.\n\n5.1.1. Termination\n\nWe now prove that this algorithm terminates.\n\n**Definition 5.1.** Let $C$ be a tcs and $T$ a type such that $\\text{FV}(T) \\subseteq \\text{dom}(C)$ then define\n\n$$\\mathcal{L}(T)_C = \\begin{cases} 0 & \\text{if } T \\text{ is not a type variable} \\\\ \\mathcal{L}(C(T))_C + 1 & \\text{otherwise} \\end{cases}$$\n\n($\\mathcal{L}$ stays for “length”) □\n\n**Notation 5.2.** Let $C$ be a tcs; we denote by $\\hat{Y}$ a type variable $Y \\in \\text{dom}(C)$ such that\n\n$$\\mathcal{L}(\\hat{Y})_C = \\max_{X \\in \\text{dom}(C)} \\{\\mathcal{L}(X)_C\\}$$\nIf there is more than one such a variable then choose any of them (e.g. use the textual order).\n\nWe can now define a weight $T$ for a type $T$ with respect to a tcs $C$ (such that $T$ is well formed in $C$):\n\n\\[\n\\begin{align*}\nT(B)_C & \\overset{def}{=} 1 \\\\\nT(\\text{Top})_C & \\overset{def}{=} 1 \\\\\nT(X)_C & \\overset{def}{=} T(C(X))_C + 1 \\\\\nT(S_1 \\to S_2)_C & \\overset{def}{=} T(S_1)_C + T(S_2)_C \\\\\nT(\\forall X \\leq S_1) S_2)_C & \\overset{def}{=} T(S_1)_C + T(S_2)_{C \\cup \\{x \\leq S_1\\}} \\\\\nT(\\forall X \\{A_i, T_j\\}_{i \\in I})_C & \\overset{def}{=} \\max_{i \\in I} \\{T(A_i)_C, T(T_i)_C \\cup \\{X \\leq \\hat{C}\\} \\} + 1\n\\end{align*}\n\\]\n\n**Lemma 5.3.** For each type $T$ well formed in a tcs $C$, the weight $T(T)_C$ is finite and positive.\n\n**Proof.** First, it is obvious that the weight $T(T)_C$ is always positive. Now to prove that it is also finite, we give a well founded rank for $T(T)_C$ (i.e. we define a weight for the definition of the weight) and we show that it decreases at each stage in the definition of $T$. To define the rank of $T(T)_C$ consider all the variables that appear in $T$ and $C$ (no matter whether they appear free or bounded, only in a quantifier or in a bound). Since $T$ is well formed in $C$, every variable is associated to a unique bound (either in $C$ or in $T$) apart those appearing in $T$ as a quantification of an overloaded type; to these variables associate as bound $\\hat{C}$. Furthermore it is also possible to totally order these variables in a way that if $X_j$ is defined in the bound of $X_j$ then $X_i$ precedes $X_j$ ($C$ is a tcs so it is $C \\cup \\{X \\leq \\hat{C}\\}$ —with $X \\notin \\text{dom}(C)$—, $T$ is well formed in $C$, thus loops are not possible). If there is more than one order satisfying this condition then choose one arbitrarily. Define the depth of each variable as the number of variables that precede it in this order. Then the rank of $T(T)_C$ is the lexicographical size of the pair $(D, L)$, where $D$ is the maximum depth of any of the variables that appear in $T$, and $L$ is the textual length of $T$. This rank is well founded (the least element is $(0, 1)$). Take now the definition of $T$: it easy to see that for the subproblems on the right-hand side of $T(S_1 \\to S_2)_C$, $T(\\forall X \\leq S_1) S_2)_C$ and $T(\\forall X \\{A_i, T_j\\}_{i \\in I})_C$, the component $D$ either is the same or it decreases, while the $L$ component always strictly decreases; for the case $T(X)_C$, the component $D$ strictly decreases. \\[\\square\\]\n\nThe weight of the types is extended to a weight for type judgments in the obvious way:\n\n\\[T(C \\vdash S_1 \\leq S_2) = T(S_1)_C + T(S_2)_C.\\]\n\nNow we can show the termination of the algorithm.\n\n**Lemma 5.4.** Given a tcs $C$ and a type variable $X$, for all types $T_1, T_2$ such that $\\text{FV}(T_i) \\subseteq \\text{dom}(C)$ ($i = 1, 2$) $T(T_1)_C \\cup \\{x \\leq \\text{Top}\\} \\leq T(T_1)_C \\cup \\{x \\leq T_2\\}$.\n\n**Proof.** A simple induction on the definition of $T(T)$ (note that one of the consequences of lemma 5.3 is that it is possible to use induction on $T$). \\[\\square\\]\n\n**Lemma 5.5.** Given a tcs $C$, a type variable $X \\notin \\text{dom}(C)$, two atomic types $A$ and $A'$ such that $B(A)_C$ and $B(A')_C$ are constant types, if $L(A)_C \\leq L(A')_C$ then:\nUp to now we dealt with the types and reduction rules. The task is easy for the raw terms, which are exactly the\n\n\\[ \\mathcal{T}(T_{c \\cup \\{X \\leq A\\}}) \\leq \\mathcal{T}(T_{c \\cup \\{X \\leq A'\\}}) \\]\n\nProof: there are three possible cases:\n\n1. Both \\( A \\) and \\( A' \\) are constant types: (a) is trivial; (b) follows by a straightforward\n induction on \\( \\mathcal{T}(T_{c \\cup \\{X \\leq A\\}}) + \\mathcal{T}(T_{c \\cup \\{X \\leq A'\\}}) \\), performing a case analysis on \\( T \\).\n\n2. \\( A \\) is a constant type and \\( A' \\) is a type variable: as the previous case\n\n3. Both \\( A \\) and \\( A' \\) are type variables: we prove (a) by induction on \\( \\mathcal{L}(A)_c + \\mathcal{L}(A')_c \\).\n The base case is when \\( \\mathcal{L}(A)_c = \\mathcal{L}(A')_c = 1 \\). In that case it is easy to check that\n \\( \\mathcal{T}(A)_c = \\mathcal{T}(A')_c = 2 \\). When that sum is strictly larger than 2 then by definition of\n \\( T \\)\n \\[ \\mathcal{T}(A)_c \\leq \\mathcal{T}(A')_c \\iff \\mathcal{T}(C(A))_c \\leq \\mathcal{T}(C(A'))_c \\]\n By definition of \\( \\mathcal{L} \\), \\( \\mathcal{L}(A)_c \\leq \\mathcal{L}(A')_c \\) implies \\( \\mathcal{L}(C(A))_c \\leq \\mathcal{L}(C(A'))_c \\); therefore\n we can apply the induction hypothesis to obtain the result.\n\nOnce more, (b) follows by a straightforward induction on \\( \\mathcal{T}(T_{c \\cup \\{X \\leq A\\}}) + \\mathcal{T}(T_{c \\cup \\{X \\leq A'\\}}) \\),\nperforming a case analysis on \\( T \\); use the case (a) of this lemma when \\( T \\equiv X \\).\n\n\\[ \\square \\]\n\nTheorem 5.6. At every step of the subtyping algorithm, the weight of each of the\npremises is strictly smaller than the weight of the conclusion.\n\nProof. The verification is easy in most cases. The only non-trivial cases are (Alg\\( \\forall \\)) and\n(Alg\\( \\{ \\})). The first case is proved by the following inequalities:\n\n\\[ \\mathcal{J}(C \\cup \\{X \\leq \\text{Top}\\} \\vdash S_1 \\leq T_2) = \\]\n\\[ \\mathcal{T}(S_2)_{c \\cup \\{X \\leq \\text{Top}\\}} + \\mathcal{T}(T_2)_{c \\cup \\{X \\leq \\text{Top}\\}} \\]\n\\[ \\leq \\mathcal{T}(S_2)_{c \\cup \\{X \\leq S_1\\}} + \\mathcal{T}(T_2)_{c \\cup \\{X \\leq T_1\\}} \\quad \\text{by lemma 5.4} \\]\n\\[ < \\mathcal{T}(S_1)_c + \\mathcal{T}(T_1)_c + \\mathcal{T}(S_2)_{c \\cup \\{X \\leq S_1\\}} + \\mathcal{T}(T_2)_{c \\cup \\{X \\leq T_1\\}} \\]\n\\[ = \\mathcal{J}(\\forall (X \\leq S_1)S_2)_c + \\mathcal{J}(\\forall (X \\leq T_1)T_2)_c \\]\n\\[ = \\mathcal{J}(C \\vdash \\forall (X \\leq S_1)S_2 \\leq \\forall (X \\leq T_1)T_2) \\]\n\nFor (Alg\\( \\{ \\}) the proof is given by these inequalities:\n\n\\[ \\mathcal{J}(C \\cup \\{X \\leq A'\\} \\vdash T_j \\leq T'_j) = \\]\n\\[ \\mathcal{T}(T_j)_{c \\cup \\{X \\leq A'\\}} + \\mathcal{T}(T'_j)_{c \\cup \\{X \\leq A'\\}} \\]\n\\[ \\leq \\mathcal{T}(T_j)_{c \\cup \\{X \\leq C\\}} + \\mathcal{T}(T'_j)_{c \\cup \\{X \\leq C\\}} \\quad \\text{by lemma 5.5} \\]\n\\[ \\leq \\max_{j \\in J}\\{ \\mathcal{T}(A_j)_c \\leq T_j \\}_{c \\cup \\{X \\leq C\\}} + \\max_{j \\in J}\\{ \\mathcal{T}(A'_j)_c \\leq T'_j \\}_{c \\cup \\{X \\leq C\\}} \\]\n\\[ < \\mathcal{J}(C \\vdash \\forall X \\{A_j \\leq T_j\\}_{j \\in J} \\leq \\forall X \\{A'_j \\leq T'_j\\}_{j \\in J}) \\]\n\n\\[ \\square \\]\n\nCorollary 5.7. The algorithm terminates\n\n5.2. Terms and reduction\n\nUp to now we dealt with the types of \\( \\mathcal{P}_{\\leq} \\). To end with it, it still remains to describe\nits terms and reduction rules. The task is easy for the raw terms, which are exactly the\nsame as those for $F\\leq\\Sigma$. More difficult is instead the case for reduction rules and typing rules; we have two different choices: either we use the same typing rules as for $F\\leq\\Sigma$ and we do not allow reductions involving free type variables, or we add to these rules the rule of subsumption and we leave the reduction unchanged. As in $F\\leq\\Sigma$, in the first case we are not able to prove the subject-reduction property (but we gain the decidability of the typing relation), while in the second, as recently remarked by Giorgio Ghelli, the minimal typing property does not hold and the decidability of type checking is an open problem (see also [CP95]).\n\nNote that in both cases there will be less well-typed terms than in $F\\leq\\Sigma$, since the subtyping relation of $F\\leq\\Sigma$ (with or without subsumption) is strictly contained in that of $F\\leq\\Sigma$: therefore there will be less well-formed types (some types well-formed in $F\\leq\\Sigma$ may not satisfy the covariance rule) and some functional applications may no longer result well-typed.\n\nSince subject-reduction is very important from both a theoretical and a practical point of view, we prefer to use the subsumption rule to define the type system of $F\\leq\\Sigma$; in this case the property of subject-reduction still holds. It just requires some work to adapt to the subcalculus the proof of subject reduction of section 4.1: essentially you have to modify the various cases of $a\\equiv a^\\prime(T)$ to take into account the new subtyping rule ($\\forall$-new), and use the subsumption rule in the cases $a\\equiv \\lambda X \\leq S_1, a^\\prime$ to show that the type is preserved; in the case of lemma 4.5 the proof results even simplified. The proof of Church-Rosser for $F\\leq\\Sigma$ is then a consequence of its subject reduction property, and of the fact that $F\\leq\\Sigma$ is CR: given a term $M$ of $F\\leq\\Sigma$, if $M \\vdash N_1$ and $M \\not\\vdash N_2$ then there exists $N_3$ in $F\\leq\\Sigma$ such that $N_1 \\vdash N_3$ and $N_2 \\not\\vdash N_3$. But, since the notion of reduction is the same in both calculi, the subject reduction theorem for $F\\leq\\Sigma$ guarantees that $N_3$ is a term of $F\\leq\\Sigma$, too. However decidability of type-checking is an open problem.\n\nOf course, we would choose not to use the subsumption as soon as we proved that $F\\leq\\Sigma$ without subsumption and reductions involving free type variables satisfies the subject-reduction property, since, in this system, the decidability of the subtyping relation implies the decidability of the typing relation. We are comforted in this choice by the fact that the tests we did to check the expressiveness of $F\\leq\\Sigma$ in [CP93] have been performed by modifying the subtyping algorithm for $F\\leq\\Sigma$, i.e. by using a system that does not use the subsumption rule.\n\nClearly with $F\\leq\\Sigma$ we lose in expressive power since the terms (and the reductions) of $F\\leq\\Sigma$ are strictly contained in those of $F\\leq\\Sigma$. Thus some terms are lost; but are those terms really interesting? We cannot answer this question as we did in [CP94], where we tried to type-check existing libraries of $F\\leq\\Sigma$ programs, by $F\\leq\\Sigma$: there is no library for $F\\leq\\Sigma$ since we have just defined it. However we think that for object-oriented programming $F\\leq\\Sigma$ is a good calculus to start from. We will give an idea of this it in the next section where we show how to use this calculus to model object-oriented features; all the examples we will show are typable in $F\\leq\\Sigma$.\n\n6. Object-oriented programming\n\nIn this section we want to sketch how the theory developed so far can be used to type object-oriented languages. We mainly consider class-based object-oriented languages.\nsince their modeling in the overloading-based model seems less natural than for languages based on generic functions. We will give few hints about generic functions at the end of the section.\n\nFrom the examples given in the introduction it should be clear that we use the name of a class to type the objects of that class. A message then is (an identifier of) an overloaded function whose branches are the methods associated to that message. The method to be executed is selected according to the type (the class-name) passed as argument which will be the class of the object the message is sent to. Thus the sending of a message \\texttt{mesg} to an object \\texttt{a} of class \\texttt{A} will be modeled by \\texttt{(mesg[A])a}.\n\nClass-names are basic types. We want to associate to each basic type a representation type; in particular we want to associate to each class-name the type of the internal state of its objects (i.e. the type of the instances variables). The way to formalize it does not concern the subject of this paper (this is done in [Cas95b]); thus here we follow the rudimentary approach of [CGL92]: we suppose that a program (a \\( F^L \\)-term) may be preceded by a declaration of class types: a class type is a basic type, that is associated by its declaration to a unique representation type, which is a record type. Two class types are in subtyping relation if this relation has been explicitly declared and it is feasible, in the sense that the respective representation types are in subtyping relation too. There is an operation \\( \\pi^{\\text{classType}} \\) to transform a record value \\( r : R \\) into a class type value \\( \\pi^{\\text{classType}}(r) \\) of type \\( \\text{classType} \\), provided that the representation type of \\( \\text{classType} \\) is \\( R \\).\n\nWe use italics to distinguish class types from the usual types, and \\( \\doteq \\) to declare a class type and to give it a name; we will use \\( \\equiv \\) to associate a name to a value (e.g. to a function). For example we can declare the following class types:\n\n\\begin{align*}\n2\\text{DPoint} & \\doteq \\langle x : \\text{Int}; y : \\text{Int} \\rangle \\\\\n3\\text{DPoint} & \\doteq \\langle x : \\text{Int}; y : \\text{Int}; z : \\text{Int} \\rangle\n\\end{align*}\n\nand then impose on them that \\( 3\\text{DPoint} \\subseteq 2\\text{DPoint} \\) (which is feasible since it respects the ordering of the record types these class types are associated to).\\(^{13} \\) We can define a message \\texttt{Norm} working on these class types:\\(^{14} \\)\n\n\\[\n\\texttt{Norm} \\equiv \\ ( \\Lambda \\text{MyType} \\subseteq \\text{2DPoint}. \\lambda x. \\text{MyType} \\\\sqsubseteq \\text{2DPoint}. \\lambda x. \\\\sqrt{x^2 + y^2} \\\\\n\\quad \\land \\Lambda \\text{MyType} \\subseteq \\text{3DPoint}. \\lambda x. \\text{MyType} \\\\sqsubseteq \\text{3DPoint}. \\lambda x. \\sqrt{x^2 + y^2 + z^2})\n\\]\n\nWhose type is \\( \\forall \\text{MyType}. \\{ \\text{2DPoint}. \\text{MyType} \\rightarrow \\text{Real}, \\text{3DPoint}. \\text{MyType} \\rightarrow \\text{Real} \\} \\)\n\nWe have used the variable \\texttt{self} to denote the receiver of the message and, following the notation of [Bru94], the type variable \\texttt{MyType} to denote the type of the receiver. Note however that we do not need, as in [Bru94], recursion for these features since they are just parameters of the message.\n\nLet us consider the meaning of the covariance condition of section 2 in this framework. Define the message \\texttt{Erase} that set to zero the internal state of an object\n\n\\[\n\\texttt{Erase} \\equiv \\ ( \\Lambda \\text{MyType} \\subseteq \\text{2DPoint}. \\lambda x. \\text{MyType} \\\\sqsubseteq \\text{2DPoint}. \\lambda x. \\langle x \\leftarrow 0, y = 0 \\rangle \\\\\n\\quad \\land \\Lambda \\text{MyType} \\subseteq \\text{3DPoint}. \\lambda x. \\text{MyType} \\\\sqsubseteq \\text{3DPoint}. \\lambda x. \\langle x \\leftarrow 0, y = 0, z = 0 \\rangle)\n\\]\n\nit has type: \\( \\forall \\text{MyType}. \\{ \\text{2DPoint}. \\text{MyType} \\rightarrow \\text{2DPoint}, \\text{3DPoint}. \\text{MyType} \\rightarrow \\text{MyType} \\} \\)\n\nSince \\( \\text{3DPoint} \\subseteq \\text{2DPoint} \\) we check that the covariance condition is satisfied:\n\n\\[\n\\{ \\text{MyType} \\subseteq \\text{3DPoint} \\} \\vdash \\text{MyType} \\rightarrow \\text{MyType} \\\\sqsubseteq \\text{MyType} \\rightarrow \\text{2DPoint}\n\\]\n\n\\(^{13} \\) Note that records are encodable in \\( F^L_\\leq \\), and thus in \\( F^L \\) too.\n\n\\(^{14} \\) In the examples we will omit \\( \\tau \\) and the indexes of \\( \\& \\).\nIn general if a method has been defined for the message $m$ in the classes $B_i$ for $i \\in I$ then its type is of the form $\\forall MyType. \\{ B_i. MyType \\rightarrow T_i \\}_{i \\in I}$. If $B_h \\leq B_k$ that means that the method defined for $m$ in the class $B_h$ overrides the one defined in $B_k$. Since $MyType$ is the same in both branches then the covariance condition reduces to prove that\n\n$$\\{ MyType \\leq B_h \\} \\models T_h \\leq T_k$$\n\nIn other terms the covariance condition requires that an overriding method returns a type smaller than or equal to the type returned by the overridden one. Note that if a method returns a result of type $MyType$ then a method that overrides it has to return $MyType$ too and it is not allowed to return say the class-name of the class in which the method has been defined (since, by inheritance, this could be a type larger than the actual value of $MyType$).\\(^{15}\\)\n\nSuppose now that $3DColoredPoint$ is a subclass of $3DPoint$ from which it inherits the method for $Erase$; then the definition of $Erase$ persists unchanged. If an object $b$ of type $3DColoredPoint$ receives the message $Erase$ then the method selected is the one for $3DPoint$; but since $Erase[3DColoredPoint](b) : 3DColoredPoint$ the loss of information is avoided.\n\nIn this framework bounds are always basic types (more precisely class-names); thus the $\\cap$-closure reduces to impose that if a message has type $\\forall X. \\{ B_i. T_i \\}_{i \\in I}$ and there exists $h, k \\in I$ such that $B_h$ and $B_k$ have a common subclass then there must be a method defined for the message, in the class that is the $g.l.b.$ of $B_h$ and $B_k$. In other terms, in a class defined by multiple inheritance if two common ancestors can respond to a same message, then the method for that message cannot be inherited but must be explicitly redefined, as in [CGL92].\n\nThe way we have written these methods may seem complicated with respect to the simplicity and modularity of object-oriented languages. Indeed the terms above can be regarded as the result of a compilation (or translation) of the following higher-level object-oriented program:\n\n```plaintext\nclass 2DPoint\n state\n x: Int;\n y: Int\n methods\n Norm = sqrt(x^2 + y^2);\n Erase = update(x=0; y=0);\ninterface\n Norm: Real\n Erase: MyType\nendclass\n\nclass 3DPoint is 2DPoint\nendclass\n\nclass 3DColorPoint is 3DPoint\n state\n color: String\nendclass\n```\n\n\\(^{15}\\) Of course in the previous example it would have been more reasonable that $Erase$ returned $MyType$ rather than $2DPoint$.\\)\n\n6.1. Extending classes\n\nInheritance is not the only way to specialize classes: if every time we had to add a method to a class we were obliged to define a new class, the existing objects of the old class could not use the new method. The same is worth also in the case that a method of a class must be redefined: \\textit{overriding} would not suffice. For this reason some object-oriented languages such as Objective-C [NeX91], Dylan [App92] and CLOS [DG87] offer the capability to add new methods to existing classes or to redefine the old ones. The extension of the set of the methods of a class affects all its subclasses, in the sense that when a class is extended with a method then that method is available to the objects of every subclass. For example in Dylan the following expression\n\n\\begin{verbatim}\n(define-method isOrigin (self <2DPoint>)\n (and (zero? self.x) (zero? self.y)))\n\\end{verbatim}\n\nadds to the class \\texttt{2DPoint} a method responding to the message \\texttt{isOrigin}\\footnote{This is not the standard Dylan’s syntax where record (slot) selection of the field \\texttt{x} of \\texttt{self} is written \\texttt{(x self)}}. If a method for that message has already been defined in the class then it is replaced by the new one.\n\nThis can be implemented in our system by adding a new branch to the overloaded function denoted by the message at issue:\n\n\\begin{verbatim}\nlet isOrigin = ( isOrigin\n & \\lambda M, y \\in \\text{2DPoint}. \\lambda x, y \\in M.type \\in \\text{2DPoint}. (self.x = 0) \\land (self.y = 0)\n)\\end{verbatim}\n\nThat is, the new definition of \\texttt{isOrigin} is given by the old definition of \\texttt{isOrigin} concatenated with the new method (if \\texttt{isOrigin} was undefined we consider it as equal to \\texttt{\\varepsilon}).\n\nRemark that by this construction one does not define a new class but only new methods; in other terms one does not modify the existing types but only (the environment of) the expressions. This is possible in our system since the type of an object is not bound to the procedures that can work on it (and for this reason it differs from abstract data types and, for those who know, the theoretical “objects as records” approach). Of course this flexibility is paid by a minor protection. For that reason for example Dylan has a function \\texttt{freeze-methods} which prevents certain methods associated to a message to be replaced or removed.\n\n6.2. First class messages\n\nIn this model messages are identifiers of overloaded functions. Since overloaded functions have first class citizenship, then also messages are first class. Thus it is possible to model functions that take as parameter a message, or functions whose result is a message. A trivial example is the implementation of a super-like function: suppose that in the definition of a method you want to send a message to \\texttt{self} but that the method selected must be the one defined for the objects of a certain class \\texttt{C}. This can be obtained by the following function:\n\n\\begin{verbatim}\nlet super\\_C = \\lambda m, x, y : X. M[C]. \\lambda self. m[C]self\n\\end{verbatim}\n\nThis function takes a message \\texttt{m} accepting objects of class \\texttt{C} and sends it to \\texttt{self} but\nselecting the method defined for the object of class \\( C \\) (of course this function is well typed if \\( M \\) \\( T \\) \\( \\leq \\) \\( C \\)).\n\n### 6.3. Multiple dispatch\n\nIn this paper we have studied a very kernel calculus. A simple extension of this calculus allows us to model multiple dispatch, i.e. a mechanism of selection of methods (in this case called multi-methods), based not only on the class of the receiver but also on the class of further parameters. The simplest extension of \\( F^\\leq/\\leq \\) to obtain multiple-dispatch consists in allowing as bounds of an overloaded function products of basic types. Thus we redefine atomic types in the following way\n\n\\[\nA := X \\mid B \\mid B \\times \\ldots \\times B \\quad \\text{(atomic types \\([B\\ \\text{basic types}])}\n\\]\n\nwe modify the condition in the rule of good formation for overloaded types as follows:\n\n\\[\n\\begin{aligned}\nC & \\vdash A_i \\ \\text{type} \\\\\nC & \\vdash \\{A_i\\}_{i=1\\ldots n} \\ \\cap \\text{-closed} \\\\\nC & \\cup \\{X \\leq A_i\\} \\vdash T_i \\ \\text{type} \\\\\n\\text{if } & C \\vdash A_i \\leq A_j \\ \\text{then } C \\cup \\{X \\leq A_i\\} \\vdash T_i \\leq T_j \\\\\nC & \\vdash \\forall X \\{A_1,T_1,\\ldots,A_n,T_n\\} \\ \\text{type}\n\\end{aligned}\n\\]\n\nand of course we add tuples to terms:\n\n\\[\na := < a, \\ldots, a >\n\\]\n\nThere are other more general extensions: for example we can change the condition in the good formation of overloaded types into “\\( B(A_i)_C \\) basic type or product of atomic basic types” allowing as bounds variables ranging on the product of basic types; or we can allow as bounds products formed by type variables and basic types.\n\nHowever the extension above largely suffice to model multi-methods, and furthermore it is very easy to check that it enjoys all the properties we have already proved for \\( F^\\leq_\\leq \\) (and \\( F^\\leq_\\geq \\)); just run through the proofs by taking into account that now proposition 2.5 has the following fourth case:\n\n4. \\( A_i \\) and \\( A_j \\) are both products of basic types and their g.l.b. is in \\( \\{A_i\\}_{i \\in I} \\)\n\nOne example of use of multiple dispatch is the method \\( \\text{Equal} \\): you want to extend the class \\( 2DPoint \\) with a method that compares two points and to redefine it for \\( 3DPoint \\); furthermore you want that in comparing a \\( 2DPoint \\) with a \\( 3DPoint \\) the method for \\( 2DPoint \\) is used. In \\( \\lambda \\& \\) we had that a function \\( \\text{Equal} \\) of type \\( \\{2DPoint \\to 2DPoint \\to \\text{Bool}, 3DPoint \\to 3DPoint \\to \\text{Bool}\\} \\) would not have a well-formed type since covariance is not respected. So in \\( \\lambda \\& \\) we defined\n\n\\[\n\\text{Equal} : \\{(2DPoint \\times 2DPoint) \\to \\text{Bool}, (3DPoint \\times 3DPoint) \\to \\text{Bool}\\}\n\\]\n\nobtaining in this way multiple dispatching. When \\( \\text{Equal} \\) is applied to \\( 2DPoint \\) and a \\( 3DPoint \\) or viceversa the first branch is executed.\n\nIn \\( F^\\leq_\\leq \\) the difference is subtler: indeed\n\n\\[\n\\forall X \\{2DPoint.X \\to X \\to \\text{Bool}, 3DPoint.X \\to X \\to \\text{Bool}\\}\n\\]\n\nis well formed. However to select the right branch you have to pass to a function of this type the greater of the types of the two actual parameters. This is not what one would like to have: one would like to pass to the function both the types of the arguments\nand leave to the system the task to select the right branch. This can be done by using multi-methods and defining \\( \\text{Equal} \\) with the following type:\n\n\\[\n\\forall X \\{2DPoint \\times 2DPoint. X \\to \\text{Bool}, 3DPoint \\times 3DPoint. X \\to \\text{Bool}\\}\n\\]\n\nA possible implementation of \\( \\text{Equal} \\) is then\n\n\\[\nEqual \\equiv (\\Lambda X \\leq 2DPoint \\times 2DPoint. \\\\\n\\lambda p^X.(\\pi_1(p).x = \\pi_2(p).x) \\wedge \\\\\n\\quad (\\pi_1(p).y = \\pi_2(p).y) \\\\\n\\lor \\Lambda X \\leq 3DPoint \\times 3DPoint. \\\\\n\\lambda p^X.(\\pi_1(p).x = \\pi_2(p).x) \\wedge \\\\\n\\quad (\\pi_1(p).y = \\pi_2(p).y) \\land \\\\\n\\quad (\\pi_1(p).z = \\pi_2(p).z)\n\\]\n\nIf we want to use multiple dispatch in class-based languages then the type above must be slightly changed. In class-based languages the method is always chosen according to the class of the receiver but in with multiple dispatching a class may have different specifications for the method; one of these specifications will be selected according to the class of some extra parameters. Thus for example the equality function could be added to \\( 2DPoint \\) and \\( 3DPoint \\) in the following way:\n\n```plaintext\nclass 2DPoint\nstate\n x: Int;\n y: Int\nmethods\n Equal(p: Mytype) = ...\nendclass\n\nclass 3DPoint is 2DPoint\nstate\n z: Int\nmethods\n Equal(p: Mytype) = ...\ninterface\n Equal: Mytype \\rightarrow \\text{Bool}\nendclass\n```\n\nwhere horizontal and vertical dots are substituted for the method bodies and the further methods, respectively.\n\nWhen the message \\( \\text{Equal} \\) is passed to an object of class \\( 3DPoint \\) then if the argument is of class \\( 2DPoint \\) then the first definition of \\( \\text{Equal} \\) is executed. The second definition is executed if the argument is of a type smaller than or equal to \\( 3DPoint \\). This correspond to have an \\( \\text{Equal} \\) overloaded function of the following type.\n\n\\[\n\\forall X \\{2DPoint. X \\rightarrow \\forall Y \\{X, Y \\rightarrow \\text{Bool}\\}, 3DPoint. X \\rightarrow \\forall Y \\{2DPoint, Y \\rightarrow \\text{Bool}, X, Y \\rightarrow \\text{Bool}\\}\n\\]\n\nHere the variable \\( X \\) stands for \\( MyType \\).\n\nIn case of languages with generic functions the application of the theory is easier. Consider the language Cecil [CL94, Cha92] and the following subtyping relation:\n\n\\[ \\text{natural} \\leq \\text{integer} \\leq \\text{rational} \\leq \\text{real} \\]\nIn Cecil it is possible to define a generic function (multi-method in Cecil’s jargon) \\texttt{plus} with the following signature:\n\n\\begin{verbatim}\nsignature plus/(natural,natural)/:natural;\nsignature plus/(integer,integer)/:integer;\nsignature plus/(real,real)/:real;\n\\end{verbatim}\n\nThis correspond to have three different implementations for the operator \\texttt{plus}, one for each signature. This corresponds to have in $\\lambda \\&$ the following typing\n\n\\begin{verbatim}\nplus : \\{natural \\times natural \\to natural, integer \\times integer \\to integer, real \\times real \\to real\\}\n\\end{verbatim}\n\nIf $a$ and $b$ are two terms of type \\texttt{rational} then in Cecil (as well as in $\\lambda \\&$) \\texttt{plus}(a, b) has type \\texttt{real} instead of \\texttt{rational}. If instead we had typed it as\n\n\\begin{verbatim}\n\\texttt{plus} : \\forall X \\{natural. X \\times X \\to X, integer. X \\times X \\to X, real. X \\times X \\to X\\}\n\\end{verbatim}\n\nthen \\texttt{plus}[\\texttt{rational}](a, b) would have type \\texttt{rational}. However, some more work is needed in order to define a modification of the Cecil’s syntax to take into account type variables. To that end it would be interesting to explore the extension of $F_\\leq$ with the intersection types. A possible syntax for the signature would then be:\n\n\\begin{verbatim}\nsignature plus/(X<natural,Y<natural>/:X//\\Y/;\nsignature plus/(X<integer,Y<integer>/:X//\\Y/;\nsignature plus/(X<real,Y<real>/:X//\\Y/;\n\\end{verbatim}\n\nBut this is subject for future work.\n\n7. Future work\n\nIn this and in the previous chapter we defined and studied $F_\\leq$ and its decidable variant, and we sketched how they can be used to model object-oriented features. We showed that they account for many features of object-oriented programming and that they also suggest new features to add to the existing paradigms. However there are some features that are not easily handled (e.g. the keyword \\texttt{super}; see at this purpose [Cas95b]).\n\nThe major restriction is that meet-closure allows overloading only on atomic types. In the last section we showed how to weaken this condition to model multiple dispatching; though also this definition still prevents us to model the generic classes of Eiffel [Mey88]. A generic class is a class parameterized by a type variable. For example if $X$ is a type variable, one would like to define a class \\texttt{Stack}[X] with methods \\texttt{pop}: $X$ and \\texttt{push}: $X \\to ()$, and then obtain a stack of integers by instantiating the type variable $X$ in the following way: \\texttt{new(Stack[Int])}. We believe that it is not difficult to further weaken meet-closure to allow among the bounds of an overloaded function, monotonic type constructors. But we are at a loss to think how to allow non monotonic type constructors. In the same way it should be possible to extend meet-closure to closed types and to add recursive types to implement recursive objects (even if we think that recursive types are not indispensable; see [PT93]).\n\nMeet closure constitutes an even more serious limitation from a proof-theoretical point of view. It would be very interesting to let bounds range over all the types; this would require a suitable definition of $\\cap$-closure assuring consistency also for higher order bounds. Note that the proof theory would be greatly complicated since a new level of impredicativity would be added. However this would correspond to a major increase of the expressive power. In that case, indeed, by a slight weakening of the $\\beta_1$\nParametric and \"ad hoc\" polymorphism\n\nrule, it would be possible to obtain parametric functions as a special case of overloaded functions with only one branch.\n\nTo the end it seems very promising the extension of $F_{\\leq}$ by intersection types hinted in the last section. The $\\cap$-closure would then correspond to requiring that the set of domains is closed for intersections.\n\nDespite these problems $F_{\\leq}$ is a step forward in the research of the overloading-based model for object-oriented programming, since it gives us the basic type checking rules to deal with the problem of the loss of information. At the moment of the redaction of this paper we are studying the integration of generic functions (i.e. overloaded functions with late binding) into the core of ML [MH88], in order to add object-oriented features to the languages of this family. Also underway is the definition of an object-oriented database programming language, whose type system is based on $F_{\\leq}$.\n\nAcknowledgments\nI am very grateful to Martín Abadi and Florian Matthes for their valuable suggestions on an earlier draft. Many thanks also to the two referees of this journal for their valuable advice. I want also to thank Giuseppe Longo for his constant advice, for his patient in reading the proofs and . . . a lot more.\n\nReferences\n\n\nA. Proofs\n\nA.1.\n\nProof of Lemma 4.3. By induction on the depth of the proof of \\( C \\cup \\{ X \\leq S \\} \\vdash \\Delta \\).\nFor depth=1 there are only two possible cases: \\( \\Delta \\equiv \\text{B type} \\) or \\( \\Delta \\equiv \\text{Top type} \\). In both cases the result is trivially satisfied. For depth>1 we perform a case analysis on the last rule of the proof:\n\n\\[(\\text{refl})\\] a straightforward use of the induction hypothesis\n\n\\[(\\text{trans})\\] a straightforward use of the induction hypothesis\n\n\\[(\\text{taut})\\] suppose that \\( \\Delta \\equiv Y \\leq T \\) then there are two possible subcases:\n\n1. \\( Y \\not\\equiv X \\): a straightforward use of the induction hypothesis\n2. \\( Y \\equiv X \\): then the hypothesis gets \\( C \\cup \\{ X \\leq S \\} \\vdash X \\leq S \\); since \\( X \\not\\in \\text{fv}(S) \\) the result reduces to \\( C[X := S'] \\vdash S' \\leq S \\) which follows by hypothesis\n\n\\[(\\text{top})\\] a straightforward use of the induction hypothesis\n\n\\[(\\rightarrow)\\] a straightforward use of the induction hypothesis\n\n\\[(\\forall)\\] suppose that \\( \\Delta \\equiv \\forall(Y \\leq T_{1})T_{2} \\leq \\forall(Y \\leq T_{1})T_{2} \\). Recall that \\( C[X := S'] \\vdash S' \\leq S \\). Thus by theorem 2.1 \\( C[X := S'] \\vdash S' \\text{ type} \\) and therefore \\( \\text{fv}(S') \\subseteq \\text{dom}(C[X := S']) \\). By hypothesis we have that both \\( C \\cup \\{ Y \\leq T_{1} \\} \\cup \\{ X \\leq S \\} \\) and \\( C[X := S'] \\) are tc's. Since \\( X \\not\\in \\text{fv}(S') \\) then \\( \\text{fv}(T_{2}[X := S']) = (\\text{fv}(T_{1}) \\cup \\text{fv}(S')) \\setminus \\{ X \\} \\); thus also \\( C[X := S'] \\cup \\{ Y \\leq T_{1}[X := S'] \\} \\) is a tc. Once this remark done, then the result follows by a straightforward use of the induction hypothesis.\n\n\\[\\{\\}\\) As the previous case.\n\n\\[(\\text{Vars type})\\] suppose that \\( \\Delta \\equiv Y \\text{ type} \\). Then there are two possible subcases:\n\n1. \\( Y \\not\\equiv X \\): a straightforward use of the induction hypothesis\n2. \\( Y \\equiv X \\): then the result reduces to \\( C[X := S'] \\vdash S' \\text{ type} \\) which follows from \\( C[X := S'] \\vdash S' \\leq S \\) and theorem 2.1\n\n\\[(\\rightarrow_{\\text{type}})\\] a straightforward use of the induction hypothesis\n\n\\[(\\forall_{\\text{type}})\\] This is the hard case. The pattern of the proof of this case is essentially the same as that of the case \\( (\\forall) \\). The hard task is to prove that \\( C \\cup \\{ X \\leq S \\} \\vdash \\{ A_{i} \\}_{i=1}^{n} \\text{ closed}, C[X := S'] \\vdash S' \\leq S \\) and the induction hypothesis imply\n\n\\[C[X := S'] \\vdash A_{i}[X := S'], \\quad i=1, \\ldots, n \\text{ closed}\\]\n\nThis is equivalent to prove that whenever\n\n\\[B(A_{i}[X := S']), C[X := S'] \\downarrow B(A_{j}[X := S']), C[X := S']\\] \\hspace{1cm} (6)\n\nthen there exists \\( h \\in [1..n] \\) such that\n\n\\[C[X := S'] \\vdash A_{h}[X := S'] = A_{i}[X := S'] \\cap A_{j}[X := S'] \\]\nSuppose that (6) holds, and examine all the possible cases for $A_i$ and $A_j$:\n\ni. $(A_i$ and $A_j$ basic). Then $A_i[X := S'] = A_i = B(A_i[X := S']) = B(A_i)_{c \\cup \\{X \\leq S\\}}$ and the same for $j$. From the meet-closure of $\\{A_i\\}_{i=1,n}$ follows that there exists a basic type $A_k = A_k[X := S'] = A_i \\cap A_j = A_i[X := S'] \\cap A_j[X := S']$ independently from the tcs we are taking into account.\n\nii. $(A_i \\equiv A_j \\equiv X)$ trivial\n\niii. $(A_i \\equiv X$ and $A_j \\not\\equiv X$). Then the hypothesis gets\n\n$$B(S')_c[X := S'] \\Downarrow B(A_j)_c[X := S'] \\tag{7}$$\n\nWe prove the result by showing that $S' \\cap A_j$ is always either $S'$ or $A_j$.\n\nFrom $C[X := S'] \\vdash S' \\leq S$ and proposition 2.3 we deduce that $B(S')_c[X := S'] \\leq B(S)_c[X := S']$ and then from (7) follows that\n\n$$B(S)_c[X := S'] \\Downarrow B(A_j)_c[X := S'] \\tag{8}$$\n\nNow, first of all note that by definition of $B$ one has $B(X)_{c \\cup \\{X \\leq S\\}} = B(S)_{c \\cup \\{X \\leq S\\}}$. Then observe that $B(S)_c[X := S'] = B(S)_{c \\cup \\{X \\leq S\\}}$: this is obvious if $S'$ is a basic type, when $S$ is a variable this follows from the fact that the substitution $[X := S']$ does not affect the definition of $B(S)$. Indeed if\n\n$$C[X := S'] \\vdash C' \\cup \\{S' \\leq X_i\\} \\cup \\{X_1 \\leq X_2\\} \\cup \\ldots \\cup \\{X_n \\leq B(S)\\} \\quad (n \\geq 0)$$\n\nthen $X \\not\\equiv X_i$ for all $i \\in [1..n]$ otherwise $C' \\cup \\{X \\leq S\\}$ would not be a tcs.\n\nThus from $B(X)_{c \\cup \\{X \\leq S\\}} = B(S)_{c \\cup \\{X \\leq S\\}}$ and $B(S')_{c \\cup \\{X \\leq S\\}} = B(S)_{c \\cup \\{X \\leq S\\}}$ we deduce\n\n$$B(X)_{c \\cup \\{X \\leq S\\}} = B(S)_{c \\cup \\{X \\leq S\\}} \\tag{9}$$\n\nNow there are two possible subcases:\n\na. $A_j$ is a basic type: then $B(A_j)_{c \\cup \\{X \\leq S\\}} = A_j = B(A_j)_{c \\cup \\{X := S\\}}$ and thus (8) gets\n\n$$B(X)_{c \\cup \\{X \\leq S\\}} \\Downarrow B(A_j)_{c \\cup \\{X \\leq S\\}}$$\n\nbut since $C \\cup \\{X \\leq S\\} \\vdash \\{A_i\\}_{i=1..n}$ closed (and $X \\not\\equiv \\{A_i\\}_{i=1..n}$) we have that $C' \\cup \\{X \\leq S\\} \\vdash X \\not\\equiv A_j$ (by proposition 2.5 the variable must be smaller than the basic type) and therefore $B(S')_{c \\cup \\{X := S\\}} = B(X)_{c \\cup \\{X \\leq S\\}} \\leq B(A_j)_{c \\cup \\{X \\leq S\\}} = A_j$.\n\nThus $C[X := S'] \\vdash S' \\leq B(S)_{c \\cup \\{X := S\\}} \\leq A_j$ whence we can conclude that\n\n$$C'[X := S'] \\vdash S' = S' \\cap A_j \\tag{10}$$\n\nb. $A_j$ is a variable: then we have that\n\n$$C[X := S'] \\equiv C'' \\cup \\{A_j \\leq X_i\\} \\cup \\{X_1 \\leq X_2\\} \\cup \\ldots \\cup \\{X_n \\leq B(A_j)\\} \\quad (n \\geq 0)$$\n\nIf $S' \\equiv X_i$ for some $i \\in [1..n]$ then $C[X := S'] \\vdash A_j \\leq S'$ and therefore\n\n$$C'[X := S'] \\vdash A_j = S' \\cap A_j \\tag{11}$$\n\nOtherwise if $S' \\not\\equiv X_i$ for all $i \\in [1..n]$ then the substitution $[X := S']$ does not affect the definition of $B(A_j)$ and thus\n\n$$B(A_j)_{c \\cup \\{X \\leq S\\}} = B(A_j)_{c \\cup \\{X := S\\}}$$\n\nThus once more (8) and (9) yield\n\n$$B(X)_{c \\cup \\{X \\leq S\\}} \\Downarrow B(A_j)_{c \\cup \\{X \\leq S\\}}$$\nRecall that both $X$ and $A_j$ are variables contained in $\\{A_i\\}_{i=1..n}$ and that $C \\cup \\{X \\leq S\\} \\vdash \\{A_i\\}_{i=1..n}$-closed. Thus by proposition 2.5 either\n\\[ C \\cup \\{X \\leq S\\} \\vdash X \\leq A_j \\]\nor\n\\[ C \\cup \\{X \\leq S\\} \\vdash A_j \\leq X \\]\nmust hold. Whichever judgment holds, we supposed in the assumption 4.2 that its proof is contained in the proof of meet closure of $\\{A_i\\}_{i=1..n}$; thus we can apply the induction hypothesis obtaining either (10) or (11), respectively.\n\niv. ($A_j$ and $A_j$ are both different from $X$ and at least one of them is a variable) Thus $A_i[X := S'] = A_i$ and $A_j[X := S'] = A_j$ and the hypothesis becomes\n\\[ B(A_i)_{c[X := S']} \\downarrow B(A_j)_{c[X := S']} \\]\n\nLet us open a short parenthesis: suppose to have a type variable $Y \\neq X$ with $Y \\in dom(C)$ and consider $B(Y)_{c \\cup \\{X \\leq S\\}}$. Then if\n\\[ C \\cup \\{X \\leq S\\} \\equiv C' \\cup \\{Y \\leq X_1\\} \\cup \\{X_1 \\leq X_2\\} \\cup \\ldots \\cup \\{X_n \\leq B(Y)_{c \\cup \\{X \\leq S\\}}\\} \\quad (n \\geq 0) \\]\nthere are two possible cases\n\n(1) $X \\equiv X_h$ for some $h \\in [1..n]$ and in this case note that\n\\[ B(Y)_{c[X := S']} = B(S')_{c[X := S']} \\]\n\n(2) $X \\neq X_h$ for all $h \\in [1..n]$ and in this case\n\\[ B(Y)_{c[X := S']} = B(Y)_{c \\cup \\{X \\leq S\\}} \\]\n\nAfter this short remark we can now consider the various cases for $A_i$ and $A_j$\n\na. $A_i$ is a variable in the situation like $Y$ in (1) and $A_j$ is a basic type. But then by the point (1) the hypothesis becomes\n\\[ B(S')_{c[X := S']} \\downarrow B(A_j)_{c[X := S']} \\]\nwhich has already been solved in (ii).\n\nb. $A_i$ is a variable in a situation like $Y$ in (2) and $A_j$ is a basic type. By the meet-closure of $\\{A_i\\}_{i=1..n}$ and by the point (2) we deduce that\n\\[ B(A_i)_{c[X := S']} = B(A_j)_{c \\cup \\{X \\leq S\\}} \\leq A_j = B(A_j)_{c \\cup \\{X \\leq S\\}} \\]\nand thus $C[X := S'] \\vdash A_i \\leq A_j$\n\nc. $A_i$ is a variable in the situation like in (1) and $A_j$ is a variable in the situation like in (2); but then we are in a case similar to the one of (a).\n\nd. $A_i$ and $A_j$ are both variables in the situation like in (1). Then $B(A_i)_{c[X := S']} = B(S')_{c[X := S']} = B(A_j)_{c[X := S']}$. Thus either $C[X := S'] \\vdash A_i \\leq A_j$ or $C[X := S'] \\vdash A_j \\leq A_i$ holds.\n\ne. $A_i$ and $A_j$ are both variables in the situation like in (2). Thus $B(A_i)_{c \\cup \\{X \\leq S\\}} \\downarrow B(A_j)_{c \\cup \\{X \\leq S\\}}$ and by the meet-closure either $C \\cup \\{X \\leq S\\} \\vdash A_i \\leq A_j$ or $C \\cup \\{X \\leq S\\} \\vdash A_j \\leq A_i$ holds. But since they are variables like in (2) this come to say that either $C[X := S'] \\vdash A_i \\leq A_j$ or $C[X := S'] \\vdash A_j \\leq A_i$ holds.\n\nA.2.\n\nProof of Lemma 4.4. By induction on the structure of $a$:\n\n$a \\equiv y$ if $y \\equiv x$ then $S \\equiv T$ and $S' \\equiv T'$; else if $y \\neq x$ the result trivially holds.\na\\equiv \\varepsilon \\text{ trivial}\na\\equiv \\textbf{Top} \\text{ trivial}\na\\equiv \\lambda y^{S_1}, a'. \\text{ if } y \\equiv x \\text{ then the result trivially holds; otherwise } S \\equiv S_1 \\rightarrow S_2 \\text{ and } C \\vdash a': S_2. \\text{ By induction hypothesis } C \\vdash a'[x^T; \\equiv b]: S^T_2 \\leq S \\text{ thus }\nC \\vdash a[x^T; \\equiv b]: S_1 \\rightarrow S^T_1 \\leq S_1 \\rightarrow S_2\na\\equiv (a_1 \\&^T a_2) \\text{ just note that by induction hypothesis } (a_1[x^T; \\equiv b] \\&^T a_2[x^T; \\equiv b]) \\text{ is well-typed, and that its type is } S.\na\\equiv \\lambda X \\leq S_1, a'. \\text{ then } C \\cup \\{X \\leq S_1\\} \\vdash a': S_2 \\text{ with } S \\equiv \\forall(X \\leq S_1)S_2. \\text{ By induction hypothesis } C \\cup \\{X \\leq S_1\\} \\vdash a'[x^T; \\equiv b]: S^T_2 \\leq S_2. \\text{ Thus }\nC \\vdash a[x^T; \\equiv b] \\equiv \\lambda X \\leq S_1, a'[x^T; \\equiv b]: \\forall(X \\leq S_1)S_2 \\leq \\forall(X \\leq S_1)S_2\na\\equiv a_1(a_2) \\text{ then } C \\vdash a_1:S_2, B(S_3)_C = S_1 \\rightarrow S \\text{ and } C \\vdash a_2:S_2 \\leq S_1. \\text{ By induction hypothesis } C \\vdash a_1[x^T; \\equiv b]: U_3 \\leq S_3 \\text{ and } C \\vdash a_2[x^T; \\equiv b]: U_2 \\leq S_2 \\leq S_1. \\text{ By proposition 2.3 } C \\vdash B(U_3)_C \\leq B(S_3)_C. \\text{ Since } B(U_3)_C \\text{ is not a type variable then by proposition 2.2 it is of the form } U_1 \\rightarrow U \\text{ with } C \\vdash S_1 \\leq U_1 \\text{ and } C \\vdash U \\leq S. \\text{ Thus we have: }\n- C \\vdash a_1[x^T; \\equiv b]: U_3\n- C \\vdash a_2[x^T; \\equiv b]: U_3 \\leq S_1\n- C \\vdash B(U_3)_C = U_1 \\rightarrow U\nThen by \\{\\rightarrow \\text{ELIM}_{\\leq 1}\\} \\text{ we obtain }\nC \\vdash a[x^T; \\equiv b] \\equiv a_1[x^T; \\equiv b](a_2[x^T; \\equiv b]): U \\leq S\na\\equiv a'[U] \\text{ then } C \\vdash a': S_3, B(S_3)_C = \\forall(X \\leq S_1)S_3, C \\vdash U \\leq S_1 \\text{ and } S \\equiv S_3[X; \\equiv U]. \\text{ Note that } X \\not\\in \\text{dom}(C) \\text{ and thus } X \\not\\in FV(U). \\text{ By induction hypothesis } C \\vdash a'[x^T; \\equiv b]: U_3 \\leq S_3 \\text{ and by proposition 2.3 } C \\vdash B(U_3)_C \\leq B(S_3)_C. \\text{ Since } B(U_3)_C \\text{ is not a type variable then by proposition 2.2 it is of the form } \\forall(X \\leq S_1)_S S_3. \\text{ Since } C \\cup \\{X \\leq S_1\\} \\vdash S^T_2 \\leq S_2, C \\vdash U \\leq S_1 \\leq S_2 \\text{ and } X \\not\\in FV(U) \\text{ we can apply the main lemma and obtain }\nC[X; := U] \\vdash S^T_2[X; := U] \\leq S_2[X; := U]\nBut } X \\not\\in \\text{dom}(C) \\text{ thus } C[X; := U] \\equiv C, \\text{ from which it follows }\nC \\vdash a[x^T; \\equiv b]: S^T_2[X; := U] \\leq S_2[X; := U]\na\\equiv a'[A] \\text{ then } C \\vdash a': S_3, B(S_3)_C = \\forall\\{X; \\{A_i,T_i\\}_{i \\in I} \\}, \\text{ and } S \\equiv T_h[X; := A] \\text{ where }\nC \\vdash A_h = \\min_{\\ell \\in I} \\{A_i \\mid C \\vdash A \\leq A_i\\}.\n\\text{ By induction hypothesis } C \\vdash a'[x^T; \\equiv b]: U_3 \\leq S_3 \\text{ and by proposition 2.3 } C \\vdash B(U_3)_C \\leq B(S_3)_C. \\text{ Since } B(U_3)_C \\text{ is not a type variable then it is of the form } \\forall\\{X; \\{A'_j,T'_j\\}_{j \\in J}\\}. \\text{ Thus by the subtyping rule } \\{\\{\\}\\} \\text{ there exists } h \\in J \\text{ such that } C \\vdash A \\leq A_h \\leq A'_j. \\text{ Therefore the set } \\{A'_j \\mid C \\vdash A \\leq A'_j, j \\in J\\} \\text{ is not empty, and by the meet-closure of } \\{A'_j\\}_{i \\in I} \\text{ it has also a minimum. Call this minimum } A'_j. \\text{ Then } C \\vdash a'[A][x^T; \\equiv b]: T'_h[X; := A]. \\text{ Since } S \\equiv T_h[X; := A] \\text{ we have to prove that }\nC \\vdash T'_h[X; := A] \\leq T_h[X; := A]\nTake again the previous } h; \\text{ by the rule } \\{\\{\\}\\} \\text{ we have }\nC \\vdash \\forall(X \\leq A'_h)T'_h \\leq \\forall(X \\leq A_h)T_h \\tag{12}\n\\text{ By the definition of } A_h:\nC \\vdash A \\leq A_h \\tag{13}\nFrom (12):\nC \\vdash A_h \\leq A'_h\nFrom (trans):\n\n\\[ C \\vdash A \\leq A'_h \\] \n\n(14)\n\nFrom (12):\n\n\\[ C \\cup \\{ X \\leq A_h \\} \\vdash T'_h \\leq T_h \\] \n\n(15)\n\nFrom the definition of \\( A'_h \\) and from (14) we obtain\n\n\\[ C \\vdash A'_h \\leq A'_h \\]\n\nand from this and the rule (\\([\\{\\}\\]_\\text{triv.}) applied to $\\forall X \\{ A'_j, T'_j \\}_{j \\in E}$, it follows\n\n\\[ C \\cup \\{ X \\leq A_h \\} \\vdash T'_h \\leq T_h \\] \n\n(16)\n\nFrom $X \\notin \\text{dom}(C)$ and from (13) we deduce that $X \\notin \\text{FV}(A)$; by (13) and by the choice of $k$ we respectively have that $C \\vdash A \\leq A_k$ and $C \\vdash A \\leq A'_k$; thus we can apply the main lemma to (15) and (16) to obtain:\n\n\\[\nC[X := A] \\vdash T'_h[X := A] \\leq T_h[X := A] \\\\\nC[X := A] \\vdash T'_k[X := A] \\leq T'_h[X := A]\n\\]\n\nBut $X \\notin \\text{dom}(C)$, thus the judgements above get\n\n\\[\nC \\vdash T'_k[X := A] \\leq T_h[X := A] \\\\\nC \\vdash T'_h[X := A] \\leq T'_h[X := A]\n\\]\n\nFinally by (trans) we obtain the result:\n\n\\[ C \\vdash T'_k[X := A] \\leq T_h[X := A] \\]\n\n\\[ \\Box \\]\n\nA.3.\n\n\\textbf{Proof of Lemma 4.5.} By induction on the structure of $a$:\n\n- $a \\equiv x^T$ then $T' \\equiv T[X := S']$.\n- $a \\equiv \\varepsilon$ trivial\n- $a \\equiv \\text{Top}$ trivial\n- $a \\equiv \\lambda x^T \\cdot a'$ where $T \\equiv T_1 \\rightarrow T_2$ and $C \\cup \\{ X \\leq S \\} \\vdash a': T_2$. Thus by induction hypothesis we deduce that $C[X := S] \\vdash a'[X := S'] : T_2 \\leq T_h[X := S']$. Therefore $C[X := S'] \\vdash a[X := S'] = \\lambda x^T[X := S'].a'[X := S'] : T_1[X := S'] \\rightarrow T_2 \\leq T[X := S']$.\n- $a \\equiv \\Lambda Y \\leq T_1 \\cdot a'$ First of all note that $Y \\neq X$, since by hypothesis $C \\cup \\{ X \\leq S \\} \\vdash \\Lambda Y \\leq T_1 \\cdot a': T$ and we have made the assumption of having all the type variables different in a tcs. Thus $C \\cup \\{ X \\leq S \\} \\cup \\{ Y \\leq T_1 \\} \\vdash a': T_2$ and $T \\equiv \\forall(Y \\leq T_1)[T_2]$. Note that $C[X := S']$ and $C \\cup \\{ X \\leq S \\}$ are tcs's, and also that $\\text{FV}(S') \\subseteq C[X := S']$ (since $C[X := S'] \\vdash S' \\leq S$). Thus we can conclude that also $C[X := S'] \\cup \\{ Y \\leq T_1[X := S'] \\}$ is a tcs, being $\\text{dom}(C) = \\text{dom}(C[X := S'])$ and $\\text{FV}(T_1[X := S']) = (\\text{FV}(T_1) \\cup \\text{FV}(S')) \\setminus \\{ X \\}$ (the latter because $X \\notin \\text{FV}(S)$). Then by a weakening we can prove that $\\{ C \\cup \\{ Y \\leq T_1 \\} \\}[X := S'] \\vdash S' \\leq S$. By induction hypothesis thus we have $C[X := S'] \\cup \\{ Y \\leq T_1[X := S'] \\} \\vdash a'[X := S'] : T'_2 \\leq T'_2[X := S']$. Thus by $[\\forall \\text{Intro}]$ and ($\\forall$) we have that\n\n\\[\nC[X := S'] \\vdash \\Lambda Y \\leq T_1[X := S'], a'[X := S'] \\forall(Y \\leq T_1[X := S'])[T'_2 \\leq T[X := S']]\n\\]\nThere are two subcases:\n\n1. $X \\not= X_i$ for all $i \\in [1..n]$; then $B(\\overline{W})_{C \\cup \\{X \\not\\in S\\}} = B(\\overline{W})_{C[X := s]}$\n\n2. $X \\equiv X_i$ for some $i \\in [1..n]$; then\n \n $$B(\\overline{W})_{C[X := s]} = B(S')_{C[X := s]}$$\n $$B(\\overline{W})_{C \\cup \\{X \\not\\in S\\}} = B(S)_{C \\cup \\{X \\not\\in S\\}}$$\n\nNow it is easy to check that $B(S')_{C[X := s]} = B(S')_{C \\cup \\{X \\not\\in S\\}}$ (otherwise $C[X := S']$ and $C \\cup \\{X \\not\\in S\\}$ could not both satisfy the conditions of tcs). Thus by proposition 2.3 we obtain\n\n$$C \\cup \\{X \\not\\in S\\} \\vdash B(\\overline{W})_{C[X := s]} = B(S')_{C[X := s]}$$\n\nThus in both cases we have that\nWe can then apply the main lemma and obtain\n\\[ C[X := S'] \\vdash B(W)V_{C[X := S']} \\leq B(W)V_{C[X := S]} \\]\n\nBy hypothesis \\( X \\not\\in FV(S') \\); this implies that \\( X \\not\\in FV(C[X := S']) \\) and thus\n\\[ B(W)V_{C[X := S']} [X := S'] = B(W)V_{C[X := S]}. \\]\nTherefore to conclude the proof of (18) it just remains to prove the following equation:\n\\[ C[X := S'] \\vdash B(W)V_{C[X := S']} [X := S'] \\leq B(W)V_{C[X := S]} [X := S'] \\]\n\nThis is obvious if \\( W \\) is not a variable (since \\( X \\not\\in FV(S') \\) then the substitution \\( [X := S'] \\) is idempotent) or if it is a variable different from \\( X \\) (then \\( W = W \\)). If \\( W \\equiv X \\) then just note that (19) gets\n\\[ C[X := S'] \\vdash B(S')V_{C[X := S]} [X := S'] \\leq B(S)V_{C[X := S]} [X := S'] \\]\nby observing that \\( B(X)V_{C[X := S]} = B(S)V_{C[X := S]} \\). This judgments becomes:\n\\[ C[X := S'] \\vdash B(S')V_{C[X := S]} [X := S'] \\leq B(S)V_{C[X := S]} [X := S'] \\]\n\nTo prove it first apply proposition 2.3 to the hypothesis \\( C[X := S'] \\vdash S' \\leq S \\) and obtain\n\\[ C[X := S'] \\vdash B(S')V_{C[X := S]} [X := S'] \\leq B(S)V_{C[X := S]} [X := S] \\] \\hspace{1cm}(21)\n\nAssume now that we have proved that \\( B(S')V_{C[X := S]} = B(S)V_{C[X := S]} \\) and \\( B(S)V_{C[X := S]} = B(S)V_{C[X := S]} \\). In this case (21) implies (20). So let us prove the assumption: we start with \\( S' \\). When \\( S' \\) is not a type variable then the result follows from the definition of \\( B \\) and the fact that \\( X \\not\\in FV(S') \\). If \\( S' \\) is a type variable then\n\\[ C[X := S'] \\equiv C' \\cup \\{ S' \\leq X_1 \\} \\cup \\ldots \\cup \\{ X_n \\leq B(S')V_{C[X := S]} \\} \\]\n\nSince \\( C \\cup \\{ X \\leq S \\} \\) is a tcs then \\( X \\not\\equiv X_i \\) for all \\( i \\in [1..n] \\). By this\n\\[ C \\cup \\{ X \\leq S \\} \\equiv C'' \\cup \\{ S' \\leq X_1 \\} \\cup \\ldots \\cup \\{ X_n \\leq T''' \\} \\cup \\{ X \\leq S \\} \\]\n\nNote that \\( T''' \\) cannot be a type variable: it cannot be \\( X \\) otherwise \\( B(S')V_{C[X := S]} = S' \\) (a loop in a tcs); it cannot be another variable otherwise \\( C[X := S'] \\{ X \\} \\) would be a variable, too. Therefore \\( T''' \\) is not a type variable which implies that \\( T''' = B(S')V_{C[X := S]} \\) and thus \\( B(S')V_{C[X := S]} = B(S')V_{C[X := S]} \\). A similar proof holds for \\( S', \\) too.\n\nThis ends the proof of (18)\n\nFrom (17) and (18) we obtain:\n\\[ C[X := S'] \\vdash B(W')V_{C[X := S']} \\leq U[X := S'] \\rightarrow T[X := S'] \\]\n\nSince \\( B(W')V_{C[X := S]} \\) is not a variable then it must be of the form \\( U''' \\rightarrow T' \\) with\n\\[ C[X := S'] \\vdash U[X := S'] \\leq U''' \\text{ and } C[X := S'] \\vdash T' \\leq T[X := S'] \\]\n\nSumming up we have:\n- \\( C[X := S'] \\vdash a_1[X := S'] : W' \\)\n- \\( C[X := S'] \\vdash a_2[X := S'] : U''' \\rightarrow U''' \\)\n- \\( B(W')V_{C[X := S]} = U''' \\rightarrow T' \\)\n\nThen by \\([\\rightarrow \\text{ElM}_{i \\leq j}] \\) we obtain\n\\[ C[X := S'] \\vdash a_1[X := S'] \\equiv a_1[X := S'] \\{ a_2[X := S'] \\} : T' \\leq T[X := S'] \\]\n$a \\equiv a'(U)$. Let $C \\cup \\{X \\leq S\\} \\vdash a' : W$, $C \\cup \\{X \\leq S\\} \\vdash U \\leq U'$, $B(W)_{C \\cup \\{X \\leq S\\}} = \\forall(Y \\leq U')[T \\equiv U'[Y := U]]$. First of all note that $Y \\not\\in \\text{dom}(C) \\cup \\{X\\}$; then by induction hypothesis\n\n$$C[X := S'] \\vdash a'[X := S'] : W' \\leq W[X := S']$$\n\nBy the main lemma we have that\n\n$$C[X := S'] \\vdash U[X := S'] \\leq U'[X := S'] \\tag{22}$$\n\nProceeding exactly as in the previous case we can prove that\n\n$$C[X := S'] \\vdash B(W')_{C[X := S']} \\leq B(W)_{C \\cup \\{X \\leq S\\}}[X := S']$$\n\nSince $B(W')_{C[X := S']} \\not\\in \\text{var}$ then it is of the form $\\forall(Y \\leq Y')[V']$ with\n\n$$C[X := S'] \\vdash U'[X := S'] \\leq V'$$\n\n$$C[X := S'] \\cup \\{Y \\leq U'[X := S']\\} \\vdash V'' \\leq U'[X := S'] \\tag{23}$$\n\nThus we have:\n\n- $C[X := S'] \\vdash a'[X := S'] : W' \\leq V''$\n- $C[X := S'] \\vdash U'[X := S'] \\leq V'$\n- $B(W')_{C[X := S']} \\leq B(W)_{C \\cup \\{X \\leq S\\}}[X := S']$\n\nTherefore by $\\text{INVLM}$ we obtain:\n\n$$C[X := S'] \\vdash a'[X := S'] = a'[X := S'](U[X := S']) : V''[Y := U[X := S']]$$\n\nNow from the hypothesis $C[X := S'] \\vdash S' \\leq S$ and from $Y \\not\\in \\text{dom}(C)$ we deduce that $Y \\not\\in FV(S')$; from $C \\cup \\{X \\leq S\\} \\vdash U \\leq U'$ and $Y \\not\\in (\\text{dom}(C) \\cup \\{X\\})$ we deduce that $Y \\not\\in FV(U)$. Thanks to this and to (22) we can apply the main lemma to (23) and obtain\n\n$$C[X := S'] \\cup \\{Y \\leq U'[X := S']\\} \\vdash V''[Y := U[X := S']] \\tag{24}$$\n\nSince $Y \\not\\in FV(S')$ then\n\n$$([X := S'][Y := U[X := S']]) = ([Y := U][X := S'])$$\n\nand then (24) rewrites to\n\n$$C[Y := U][X := S'] \\vdash V''[Y := U[X := S']] \\leq U''[Y := U[X := S']] \\leq T[X := S']$$\n\nand since $Y \\not\\in \\text{dom}(C)$ it becomes\n\n$$C[X := S'] \\vdash V''[Y := U[X := S']] \\leq T[X := S']$$\n\ni.e. the result.\n\n\\[a \\equiv a'[A]\\]\n\nLet $C \\cup \\{X \\leq S\\} \\vdash a' : W$, $C \\cup \\{X \\leq S\\} \\vdash A_i = \\min_{i \\in I} \\{A_i : C \\cup \\{X \\leq S\\} \\vdash A \\leq A_i\\}$, $B(W)_{C \\cup \\{X \\leq S\\}} = \\forall Y[A_i : T_i[Y := A]]$, and $T \\equiv T_i[Y := A_i]$. Again $Y \\not\\in \\text{dom}(C) \\cup \\{X\\}$. By induction hypothesis\n\n$$C[X := S'] \\vdash a'[X := S'] : W' \\leq W[X := S']$$\n\nApplying the main lemma we also obtain that\n\n$$C[X := S'] \\vdash \\min_{i \\in I} \\{A_i[X := S'] : C[X := S'] \\vdash A[X := S'] \\leq A_i[X := S']\\} \\leq A_i[X := S']$$\n\nProceeding as in the two previous cases we have that\n\n$$C[X := S'] \\vdash B(W')_{C[X := S']} = \\forall Y[A_i : T_i[Y := A_i][X := S'] \\leq \\forall Y[A_i[X := S'] : T_i[X := S']] \\tag{25}$$\nBy the rule ({} ) for each \\( i \\in I \\) there exists \\( j \\in J \\) such that \\( C[X:=S'] \\vdash A_i[X:=S'] \\leq A'_j \\). Thus by the main lemma we have that \\( \\{ A'_j \\mid C[X:=S'] \\vdash A[X:=S'] \\leq A'_j, j \\in J \\} \\) is not empty, and by the meet-closure of \\( \\{ A'_j \\}_{j \\in J} \\) it has also a minimum. Therefore if\n\\[\nC[X:=S'] \\vdash A'_h = \\min_{j \\in J} \\{ A'_j \\mid C[X:=S'] \\vdash A[X:=S'] \\leq A'_j \\}\n\\]\nthen \\( C[X:=S'] \\vdash A[X:=S'] \\leq A'[X:=S'] \\). Consider now (25); by the rule ({} ) one has that there exists \\( h \\in J \\) such that\n\\[\nC[X:=S'] \\vdash \\forall(Y \\leq A'_j) T'_h \\leq \\forall(Y \\leq A'_h[X:=S'])(T_h[X:=S']) \\tag{26}\n\\]\nSince \\( C \\cup \\{ X \\leq S \\} \\vdash A \\leq A_h \\) then by the main lemma\n\\[\nC[X:=S'] \\vdash A[X:=S'] \\leq A_h[X:=S'] \\tag{27}\n\\]\nFrom (26):\n\\[\nC[X:=S'] \\vdash A_h[X:=S'] \\leq A'_h \\tag{28}\n\\]\nFrom (trans):\n\\[\nC[X:=S'] \\vdash A[X:=S'] \\leq A'_h \\tag{29}\n\\]\nFrom (26):\n\\[\nC[X:=S'] \\cup \\{ Y \\leq A_h[X:=S'] \\} \\vdash T'_h \\leq T_h[X:=S'] \\tag{30}\n\\]\nFrom the definition of \\( A'_h \\) and from (28) we obtain\n\\[\nC[X:=S'] \\vdash A'_h \\leq A'_h \\tag{30}\n\\]\nand from this and the rule ({} ) applied to \\( \\forall Y \\{ A'_i, T'_j \\}_{i \\in J} \\) it follows that\n\\[\nC[X:=S'] \\cup \\{ Y \\leq A'_h \\} \\vdash T'_h \\leq T'_h \\tag{30}\n\\]\nFrom (27) and \\( Y \\not\\in dom(C) \\) (and thus \\( Y \\not\\in dom(C[X:=S']) \\)) follows that \\( Y \\not\\in FV(A[X:=S']) \\); by (27) and by the choice of \\( k \\) we respectively have that\n\\[\nC[X:=S'] \\vdash A[X:=S'] \\leq A_h[X:=S'] \\text{ and } C[X:=S'] \\vdash A[X:=S'] \\leq A'_h; \\text{ thus we can apply the main lemma to (29) and (30) to obtain:}\n\\]\n\\[\n\\]\nBut \\( Y \\not\\in dom(C) \\), thus \\( Y \\not\\in dom(C[X:=S']) \\) and whence, by the definition of tcs, \\( Y \\not\\in FV(C[X:=S']) \\). Then the judgements above get\n\\[\nC[X:=S'] \\vdash T'_h[Y:=A[X:=S']] \\leq T_h[X:=S'][Y:=A[X:=S']]\n\\]\nBy (trans):\n\\[\nC[X:=S'] \\vdash T'_h[Y:=A[X:=S']] \\leq T_h[X:=S'][Y:=A[X:=S']] \\tag{30}\n\\]\nFrom \\( C[X:=S'] \\vdash S' \\leq S \\) and \\( Y \\not\\in dom(C[X:=S']) \\) follows that \\( Y \\not\\in FV(S') \\). Thus the last judgement becomes:\n\\[\nC[X:=S'] \\vdash T'_h[Y:=A[X:=S']] \\leq T_h[Y:=A][X:=S'] = T[X:=S']\n\\]"}}},{"rowIdx":181,"cells":{"id":{"kind":"string","value":"8452d648bc469dd8f213220d17a9109e362b77a3"},"text":{"kind":"string","value":"DESIGN FOR DEPENDABILITY: A SIMULATION-BASED APPROACH\n\nKumar K. Goswami\n\nCoordinated Science Laboratory\nCollege of Engineering\nUNIVERSITY OF ILLINOIS AT URBANA-CHAMPAIGN\n\nApproved for Public Release. Distribution Unlimited.\nThis research addresses issues in simulation-based system level dependability analysis of fault-tolerant computer systems. The issues and difficulties of providing a general simulation-based approach for system level analysis are discussed and a methodology that address and tackle these issues is presented. The proposed methodology is designed to permit the study of a wide variety of architectures under various fault conditions. It permits detailed functional modeling of architectural features such as sparing policies, repair schemes, routing algorithms as well as other fault-tolerant mechanisms, and it allows the execution of actual application software. One key benefit of this approach is that the behavior of a system under faults does not have to be pre-defined as it is normally done. Instead, a system can be simulated in detail and injected with faults to determine its failure modes.\n\nThe thesis describes how object-oriented design is used to incorporate this methodology into a general purpose design and fault injection package called DEPEND. A software model is presented that uses abstractions of application programs to study the behavior and effect of software on hardware faults in the early design stage when actual code is not available. Finally, an acceleration technique that combines hierarchical simulation, time acceleration algorithms and hybrid simulation to reduce simulation time is introduced.\nAn extensive simulation based study of the Tandem Integrity S2 is conducted with DEPEND to illustrate its capabilities. The system is evaluated to determine how it handles near-coincident errors caused by correlated and latent faults. Issues such as memory scrubbing, re-integration policies and workload dependent repair times which affect how the system handles near-coincident errors are also evaluated. Application specific analysis of the existing and a newly proposed scrubbing scheme is performed. Unlike other simulation-based dependability studies, measurements from injection experiments conducted on an actual Tandem Integrity S2 computer are used to validate the software model and the simulation model of the Integrity S2. Results from a detailed simulation model that does not use acceleration are used to validate the acceleration technique.\nDESIGN FOR DEPENDABILITY: A SIMULATION-BASED APPROACH\n\nBY\n\nKUMAR K. GOSWAMI\n\nB.S.C.S., Embry-Riddle Aeronautical University, 1982\nM.S., University of Illinois at Urbana-Champaign, 1988\n\nTHESIS\n\nSubmitted in partial fulfillment of the requirements\nfor the degree of Doctor of Philosophy in Computer Science\nin the Graduate College of the\nUniversity of Illinois at Urbana-Champaign, 1993\n\nUrbana, Illinois\n©Copyright by\nKumar K. Goswami\n1993\nAbstract\n\nThis research addresses issues in simulation-based system level dependability analysis of fault-tolerant computer systems. The issues and difficulties of providing a general simulation-based approach for system level analysis are discussed and a methodology that address and tackle these issues is presented. The proposed methodology is designed to permit the study of a wide variety of architectures under various fault conditions. It permits detailed functional modeling of architectural features such as sparing policies, repair schemes, routing algorithms as well as other fault-tolerant mechanisms, and it allows the execution of actual application software. One key benefit of this approach is that the behavior of a system under faults does not have to be pre-defined as it is normally done. Instead, a system can be simulated in detail and injected with faults to determine its failure modes.\n\nThe thesis describes how object-oriented design is used to incorporate this methodology into a general purpose design and fault injection package called DEPEND. A software model is presented that uses abstractions of application programs to study the behavior and effect of software on hardware faults in the early design stage when actual code is not available. Finally, an acceleration technique that combines hierarchical simulation, time acceleration algorithms and hybrid simulation to reduce simulation time is introduced.\n\nAn extensive simulation based study of the Tandem Integrity S2 is conducted with DEPEND to illustrate its capabilities. The system is evaluated to determine how it handles near-coincident errors caused by correlated and latent faults. Issues such as memory scrubbing, re-integration policies and workload dependent repair times which affect how the system handles near-coincident errors are also evaluated. Application specific analysis of the existing and a newly proposed scrubbing scheme is performed. Unlike other simulation-based dependability studies, measurements from injection experiments conducted on an actual Tandem Integrity S2 computer are used to validate the software model and the simulation model of the Integrity S2. Results from a detailed simulation model that does not use acceleration are used to validate the acceleration technique.\n\nResults from the study show that accurate application specific analysis using the software model can produce coverage values that are over 100% different from those obtained with simple\nestimations of program behavior. A simulation model using the acceleration technique is shown to produce results that are within the 99% confidence interval of a simulation model that does not use acceleration, but it does so in 7 minutes as opposed to 36 hours. Accurate modeling of the \"staggered failure\" effect caused by near-coin-cident errors observed on actual systems show that the impact of correlation (for the Integrity S2) is dependent on the error latency distribution. Simple analytical models that fail to represent this relationship produce mean time between failures (MTBF) that are orders of magnitude lower. Different latency distributions with the same mean are shown to produce statistically significant changes in system MTBF when correlation is considered. Inter-component dependencies, which are a function of the architecture and error latency, are shown to substantially reduce system MTBF. Scrubbing is shown to be ineffective unless the latency times exceed half the cycle time of the scrubber.\nAcknowledgements\n\nI am very grateful to my advisor, Professor Ravi Iyer for his continual support and encouragement. His patience, insight and assistance made this thesis possible. I would also like to thank Professors W. Kent Fuchs, Laxmikant Kale, Jane Liu, David Padua and Janak Patel for serving on my dissertation committee.\n\nI would like to thank Luke Young for allowing me to freely use his hybrid injection facility and answer my million and one questions. Special thanks go to Tim Tsai for valuable discussions and for the time he took to run many fault injection experiments for me. His effort made it possible for me to complete the thesis on time. Discussions, debates and collaboration with Jim Barnette, Axel Hein, Dan Olson and Darren Sawyer gave me the second wind that I needed to complete this work. I truly appreciate all their effort and encouragement. Thanks are due to In Hwan Lee, Dong Tang and Gwan Choi, who were always there to answer questions, review my papers and offer suggestions.\n\nI was fortunate to have a very supportive and special bunch of friends at CRHC who made my stay in Urbana fun and enjoyable: Jeff Baxter, Paul Chen, Bob Dimpsey, John Fu, John Holm, Bob Janssens, Antoine Mourad, Mike Peercy, Paul Ryan, Jonathan Simonson, and Nancy Warter. I will miss their company. I would like to thank Krishna Subramanian for being a dear friend during the final stretch. I am very grateful to a very special friend, Rahul, for his loving warmth and affection (and for those lovely B.D. Baggies). Finally, I am especially indebted to my parents, my two sisters and Karyn whose unwavering support has been my source of strength and inspiration over these past years.\n# Table of Contents\n\nChapter\n\n1 Introduction ........................................ 1\n 1.1 Related Work ...................................... 2\n 1.2 Contributions ...................................... 3\n 1.3 Overview ........................................ 4\n\n2 Development Issues .................................... 6\n\n3 Simulation Environment ................................... 9\n 3.1 Approach ........................................ 9\n 3.2 Architecture ....................................... 11\n 3.2.1 User Environment ............................... 13\n 3.2.2 The Object Library ............................ 13\n 3.2.3 Fault Models .................................. 15\n 3.2.4 Fault injector .................................. 17\n 3.2.5 Fault-tolerant server .............................. 19\n 3.2.6 Fault-tolerant communication link .............. 21\n 3.2.7 Programming environment .......................... 22\n 3.3 Comparison ....................................... 25\n\n4 Tool Capabilities ....................................... 27\n 4.1 Behavioral Modeling .................................. 27\n 4.2 Modeling Real Fault Scenarios ....................... 31\n 4.3 Discussion ........................................ 35\n<table>\n<thead>\n<tr>\n<th>Chapter</th>\n<th>Section</th>\n<th>Title</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>5</td>\n<td>5.1</td>\n<td>The Tandem Integrity S2 Architecture</td>\n<td>37</td>\n</tr>\n<tr>\n<td></td>\n<td>5.2</td>\n<td>Simulation Model</td>\n<td>39</td>\n</tr>\n<tr>\n<td>6</td>\n<td>6.1</td>\n<td>Model Overview</td>\n<td>44</td>\n</tr>\n<tr>\n<td></td>\n<td>6.2</td>\n<td>Model Description</td>\n<td>45</td>\n</tr>\n<tr>\n<td></td>\n<td>6.2.1</td>\n<td>The Memory System</td>\n<td>46</td>\n</tr>\n<tr>\n<td></td>\n<td>6.2.2</td>\n<td>The Probabilistic Control Flow Graph</td>\n<td>47</td>\n</tr>\n<tr>\n<td></td>\n<td>6.2.3</td>\n<td>The Memory Subspace</td>\n<td>48</td>\n</tr>\n<tr>\n<td></td>\n<td>6.2.4</td>\n<td>The Execution Environment</td>\n<td>48</td>\n</tr>\n<tr>\n<td></td>\n<td>6.2.5</td>\n<td>The Injector</td>\n<td>52</td>\n</tr>\n<tr>\n<td></td>\n<td>6.2.6</td>\n<td>Specification Language</td>\n<td>53</td>\n</tr>\n<tr>\n<td></td>\n<td>6.3</td>\n<td>Model Application</td>\n<td>54</td>\n</tr>\n<tr>\n<td></td>\n<td>6.3.1</td>\n<td>Application Programs</td>\n<td>54</td>\n</tr>\n<tr>\n<td></td>\n<td>6.3.2</td>\n<td>Experiment Setup</td>\n<td>55</td>\n</tr>\n<tr>\n<td></td>\n<td>6.3.3</td>\n<td>Validation Environment</td>\n<td>55</td>\n</tr>\n<tr>\n<td></td>\n<td>6.3.4</td>\n<td>Program Detection Latency</td>\n<td>57</td>\n</tr>\n<tr>\n<td></td>\n<td>6.3.5</td>\n<td>Coverage of the Memory Scrubber</td>\n<td>66</td>\n</tr>\n<tr>\n<td></td>\n<td>6.4</td>\n<td>Summary</td>\n<td>69</td>\n</tr>\n<tr>\n<td>7</td>\n<td>7.1</td>\n<td>Acceleration Approach</td>\n<td>71</td>\n</tr>\n<tr>\n<td></td>\n<td>7.2</td>\n<td>Stage 1: Hierarchical Simulation and Time Acceleration</td>\n<td>76</td>\n</tr>\n<tr>\n<td></td>\n<td>7.2.1</td>\n<td>Validation of the First Stage</td>\n<td>78</td>\n</tr>\n<tr>\n<td></td>\n<td>7.3</td>\n<td>Stage 2: Hybrid Simulation</td>\n<td>79</td>\n</tr>\n<tr>\n<td></td>\n<td>7.3.1</td>\n<td>Markov modeling</td>\n<td>81</td>\n</tr>\n<tr>\n<td></td>\n<td>7.3.2</td>\n<td>Monte Carlo simulation</td>\n<td>81</td>\n</tr>\n<tr>\n<td></td>\n<td>7.3.3</td>\n<td>Validation of the Hybrid Approach</td>\n<td>83</td>\n</tr>\n<tr>\n<td></td>\n<td>7.4</td>\n<td>Discussion</td>\n<td>92</td>\n</tr>\n</tbody>\n</table>\n## List of Tables\n\n3.1 A few fundamental classes. ........................................ 14\n3.2 Some key classes that model the architectural components of a fault-tolerant system. ........................................ 15\n3.3 Comparison of the features of several simulation tools. .......... 26\n4.1 The parameters used. All times are in hours. ..................... 34\n5.1 Measured global memory re-integration times with varying machine idle percentages ........................................ 38\n6.1 Parameters for the three low level error detection models. ........ 58\n6.2 Statistics of the measured and simulated program detection latency for the Gaussian elimination program. .................. 62\n6.3 Sensitivity of the mean detection latency time to varying values of \\( \\rho_l \\) (LIMIT = 5). ........................................ 64\n6.4 Parameters for the low level error detection models. .......... 64\n6.5 Statistics of the measured and simulated program detection latency for Sort. ................................ 65\n6.6 The active coverage of the scrubber. .......................... 67\n6.7 Active coverage of the new scrubber. .......................... 68\n6.8 The estimated active coverage of the new scrubber for one program using a fitted \\( f_{R_1}(p) \\). .................................................. 69\n6.9 Active coverage of the new scrubber using ramp and an exponential detection latency distribution. .................. 69\n7.1 Empirical pdfs fitted with hypoexponential pdfs. ................. 87\n7.2 System MTBF obtained with the pure simulation and hybrid approaches. . . . 90\n7.3 System MTBF for the two error latencies (Experiment 3) . . . . . . . . . . . 90\n7.4 System MTBF for various memory re-integration times. . . . . . . . . . . . . 92\n8.1 System MTBF for two latency distributions with various means. . . . . . . 97\n8.2 System MTBF for two fast error arrival rates. . . . . . . . . . . . . . . . . 98\n8.3 System MTBF with inter-component dependence. . . . . . . . . . . . . . . . 99\n8.4 System MTBF for two latency distributions with various means. . . . . . 100\n8.5 System MTBF for the normal latency distributions with varying $C_x$ values. . 101\n8.6 System MTBF for the exponential and normal latency distributions with inter-\n component dependence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101\n8.7 Comparison of MTBF obtained with DEPEND and the Petri-net model . . . . . . . 104\n8.8 Scrubber coverage for various exponential error latency distributions. . . . . 105\n8.9 Parameters of the experiment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108\n8.10 Coverage of the two scrubbing schemes. . . . . . . . . . . . . . . . . . . . . . . . 109\n8.11 System MTBF obtained for various application memory space sizes. . . . . 109\n8.12 System MTBF obtained for various application memory space sizes with the new\n memory configuration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110\n8.13 System MTBF with modeling of near-coincident errors. . . . . . . . . . . . . 113\n## List of Figures\n\n3.1 The DEPEND architecture ........................................ 12\n3.2 Steps in developing and simulating a model with DEPEND .......... 14\n3.3 The Fault-Tolerant Server Object .................................. 20\n3.4 The Fault-Tolerant Communication Link ............................ 21\n3.5 A simple example program using DEPEND – the main co-routine ...... 23\n3.6 A simple example program using DEPEND – the co-routine ........ 24\n4.1 Distributed system executing the load balancing heuristic .......... 28\n4.2 Database maintained by Node 0 and the status messages it receives .... 29\n4.3 Impact of corrupted status update messages .......................... 31\n4.4 Impact of destroyed status update messages – before and after design change .. 32\n4.5 The error injection process that models error latency .............. 33\n4.6 The repair process that considers the state of the other CPUs in the system ... 33\n4.7 Comparison of system MTTF for the three models .................. 35\n5.1 The Tandem Integrity S2 processing subsystem ..................... 38\n5.2 Simulation model of the Integrity S2 system developed with DEPEND .... 40\n6.1 The complete software model execution environment ............... 44\n6.2 Example program and corresponding PCFG .......................... 53\n6.3 An injection environment using hybrid monitoring .................. 56\n6.4 Program used to inject errors and obtain measurements ............ 57\n6.5 Cumulative detection latency distribution functions ................ 59\n6.6 Histogram of the program detection latency in seconds, for 1 program .... 60\n6.7 Access time depends on location of the PC and the error ............ 60\n6.8 Histogram of the measured detection times for Gauss ........................................ 61\n6.9 Histogram of multiple reads of corrupted locations ......................................... 62\n6.10 Histogram of the program detection latency of two programs (sec.) .................. 63\n6.11 Measured and simulated cumulative detection latency distribution functions .... 65\n6.12 Frequency of multiple accesses of corrupted location (Measured) ................ 66\n\n7.1 The framework of the acceleration technique .................................................. 73\n7.2 Time acceleration: “Error” driven simulation ................................................ 74\n7.3 Hybrid simulation for dependability evaluation .............................................. 75\n7.4 The error occurrence process for 2 CPUs ...................................................... 77\n7.5 Injection program used to measure the MTBF .............................................. 79\n7.6 The Time to CPU shutdown distribution (in seconds) ................................... 80\n7.7 Distribution of the number of latent errors prior to a CPU shutdown ............... 81\n7.8 The hybrid approach ....................................................................................... 82\n7.9 Markov model of system with exponential failure & repair distributions .......... 83\n7.10 Inter-failure times extracted from an execution of the functional simulation .... 84\n7.11 Failure density functions for experiment 1 .................................................... 85\n7.12 Failure density functions for the two error latencies (Experiment 3) ............. 86\n7.13 Empirical and fitted failure pdfs for a single processor & memory ................. 88\n7.14 CTMC that models the system with hyperexponential failure distributions .... 89\n7.15 GSPN description with 2-phase HYPO failure distribution .......................... 91\n\n8.1 Petri-net model of the three CPUS with memory scrubbing ......................... 103\n8.2 System MTBF for various latency distributions (Hourly Scrubbing) .............. 104\n8.3 System MTBF when inter-component dependence is modeled with hourly scrub-\n\n8.4 System MTBF obtained with the single and dual scrubbing schemes .............. 108\n8.5 System MTBF for various subsystem re-integration times ............................ 112\n8.6 System MTBF for various subsystem re-integration times - New Memory Con-\n\nA.1 Definition of class used to collect distributions ........................................... 126\nA.2 Definition of statistical model consisting of two distributions. ....... 126\nA.3 Definition of statistical model consisting of two distributions. ....... 127\nA.4 The Monte Carlo program that uses the failure and repair submodel. ....... 128\nChapter 1\n\nIntroduction\n\nThe increasing demand and growing complexity of dependable systems has spurned the need for automated design tools that can reduce design time while ensuring that dependability (e.g. availability, reliability) specifications are met. The focus has been on developing electrical and gate level fault analysis tools. Though these tools are ideal for analyzing LSI and VLSI components they are not suited to analyze a complete system. Dependability is a system issue and as such isolated analysis of the individual components is insufficient. Ideally, system level dependability analysis should consider the hardware, the system software, the application and the interaction and inter-dependencies of all of these components under realistic fault scenarios. This is an extremely complex task and the difficulties that arise depend on the approach taken. Currently, two approaches are primarily used for system level dependability analysis. Analytical tools, and in particular tools that represent systems with continuous time Markov chains (CTMC), are used for very high-level trade-off analysis. These tools are best suited for the early design stages when little information is known about the target machine. However, the accuracy of their results is limited by the level of detail to which they can represent a system. The second approach is fault injection of proto-type systems. Though this approach provides the most believable results, it has three major drawbacks. First, it does not provide feedback during the design stages. Second, because the system is fixed, it cannot be used to study alternate configurations. Third, it cannot provide many dependability measures such as availability and mean time between failure (MTBF) because it would require measuring the system for years.\nThis thesis explores a third approach: functional simulation-based system level dependability analysis. Unlike analytical models, functional simulation can accurately model the functional behavior of the system components, the inter-component dependencies, workload patterns and reconfiguration schemes. This makes the approach more useful during the intermediate stages of system development when more information is available about these system characteristics. Furthermore, if the functional simulation tool can also inject faults, it can be used to perform injection experiments and provide early design feedback. There are a few simulation-based tools that are specifically geared for system level dependability analysis. However, they either handle very specific architectures and fault models or only use probabilistic modeling and hence are essentially extensions of analytical tools. This thesis focuses on the development of an integrated fault injection and functional simulation environment for system level dependability analysis that can be used to evaluate a wide variety of systems. The thesis identifies the major issues that impede the development of such a tool, presents solutions to tackle these issues and uses them to perform a comprehensive study of an actual fault-tolerant machine.\n\n1.1 Related Work\n\nIn [19], the authors describe and compare several tools that solve CTMC models. There is increasing work in software and hardware fault injection of prototype systems [38, 64, 75, 18, 36]. However, there is a lack of simulation tools for system level dependability analysis. Most simulation tools are designed to facilitate performance analysis (CSIM [60], ASPOL [43], SES Workbench [61], RESQ [58]). These tools do not provide the mechanisms needed to interrupt the system and inject faults. VHDL [30] is a powerful hardware specification language but it does not contain built-in facilities to support dependability analysis. NEST [17] is a functional simulation and proto-typing tool used explicitly to analyze distributed networks and system protocols. It is very specialized and has a limited set of facilities to fail links and nodes. Another functional simulation tool called REACT [12] is specifically designed for analyzing alternative TMR architectures. Metasan [56] and the Rainbow Net [35] are Petri-net tools. An extended Petri-net structure is used to input a model and solve it via simulation. Though the Petri-net tools have greater applicability than analytical tools, they rely solely on probabilistic modeling to describe a system. This is a major limitation because, as we show in detail in\nChapter 3, it requires that the user pre-define the fault behavior of a system. Furthermore, these tools provide only a limited set of fault models and provide no mechanism to reduce simulation time explosion.\n\n1.2 Contributions\n\nThe focus of this research is the development and use of simulation techniques for system level dependability analysis. Ad-hoc techniques are commonly used to conduct detailed system level dependability analysis using functional simulation. Each system design effort is accompanied by the fresh development of simulation models specific to the architecture being built and the fault models being considered. There has been no prior attempt to characterize and provide a more structured approach to functional simulation-based dependability analysis at the system level. The goals of this thesis are to provide a structured approach and to develop methods that allow a comprehensive study of a system including the hardware and software components. Towards these goals, several issues that impede the development of a general-purpose, integrated fault injection and simulation environment for system level dependability analysis are identified. Broadly, they are:\n\n- Modeling a large variety of components.\n- Coping with the large fault model domain.\n- Reducing model development time and model complexity.\n- Incorporating software behavior under faults in a simulation-based study.\n- Reducing simulation time explosion.\n\nMethods to tackle these issues are discussed and presented. A synergy of these methods is used to analyze an actual system under realistic fault conditions for specific applications. The methods are validated by comparing the simulation results with those obtained from fault injection experiments on an actual machine. Finally, the methods are incorporated into a simulation tool called DEPEND.\n1.3 Overview\n\nChapter 2 discusses the major issues in developing a general-purpose system level functional simulation tool. Chapter 3 presents the approach used to tackle the first three issues mentioned earlier. It also presents the DEPEND integrated simulation and fault injection environment that incorporates these approaches. The chapter presents the key features of the tool and the fault models it provides. A table comparing DEPEND's features with existing simulation-based system level dependability analysis tools is also included.\n\nHaving described the essential features, Chapter 4 illustrates the uses and benefits of the tool. One can ask, given the large number of analytical and Petri-net based simulation tools, what is the need for functional simulation tools for system level dependability analysis? What additional information and capabilities can they provide over analytical tools and fault-injection environments? The goal of Chapter 4 is to answer these questions with a few examples.\n\nDEPEND is used to analyze a triple-modular redundant (TMR) system and in particular the Tandem Integrity S2 fault-tolerant system under realistic fault scenarios. It is well established that this system is very effective against single faults [34, 75]. An important question is how such systems cope with near-coincident errors caused by correlated and latent faults. Architectural issues that have a bearing on how the system handles near-coincident faults include memory scrubbing, re-integration policies and workload dependent repair times. Since the reliability of a system is also affected by the application and because most fault-tolerant systems are geared to perform specific functions, it is also imperative to study such systems within the context of an application. To study these issues, DEPEND is used to simulate the Integrity S2 system and evaluate the combined effect of all these factors. Furthermore, the simulation of the Integrity S2 system is validated by comparing the results of the simulations with measurements obtained from fault injection experiments conducted on a production Integrity S2 machine. Chapter 5 describes the salient features of the Tandem Integrity S2 system. It also presents the basic simulation model developed with DEPEND.\n\nThe focus of Chapter 6 is on application specific dependability analysis. It presents the simulation-based model developed to analyze software behavior under hardware faults and to study the impact of latent errors on system dependability. A probabilistic graph model is proposed that represents program behavior at an abstract level and can obtain key application\nspecific parameters that affect system dependability. These parameters are used to perform application specific analysis of functional detection schemes. It is shown that if alternate, simple techniques are used to model application program behavior the system dependability measures obtained can be grossly inaccurate.\n\nChapter 7 presents the acceleration technique that reduces simulation time explosion. The technique uses a combination of hierarchical simulation, time acceleration, and hybrid simulation. This technique makes it possible to conduct a detailed simulation study of the TMR system. Unlike other simulation acceleration techniques, this technique is general and not limited to any particular type of simulation model.\n\nChapter 8 describes the simulation experiments in detail and presents results of the study. The impact of correlated errors, latent errors and various repair and memory scrubbing schemes are quantized and dependability bottlenecks are identified. Results obtained with simplistic fault models are compared with those obtained with DEPEND's fault models to illustrate the need for accurate modeling of the fault occurrence process. Finally, Chapter 9 summarizes the main points of the thesis and the findings of the TMR study. It also contains an assessment of functional simulation-based dependability analysis and suggests future extensions of this research.\nChapter 2\n\nDevelopment Issues\n\nFunctional simulation (also referred to as behavioral simulation) allows more detailed and accurate modeling of computer systems. But this accuracy comes at a cost. Accurate modeling requires greater information about the system components, more knowledge about their specific fault models, and more time in developing a simulation. There are at least five issues that impede the development of general-purpose, functional simulation tools for system level dependability analysis. The first is a lack of well established system level fault models. This is partly due to the second issue which is a large and varied component domain. At the gate level, the basic components are gates with single functions and well defined interconnections. At this level, it is possible to establish a fault model such as the single stuck-at fault model that can consistently be applied to all gates to model their fault behavior. At the system level, the basic components include CPUs, communication channels, disks, software systems and memory. The components have complex inputs, perform multiple functions, have varied physical attributes (e.g. hardware and software) and complex interconnections. In addition to the diversity of the components that comprise a system, two similar components (such as two CPUs) can have different functions and behavior. This makes it difficult to establish a single fault model that can be consistently applied to all components. Limiting the types of components or fault models represented is one solution but it restricts the tool’s applicability (e.g. NEST).\n\nThe third issue, which is especially significant when simulating large complex systems, is the effort and time required to develop a functional simulation model. For fault injection studies and dependability analysis, there are two factors that contribute to this. One is the time and\neffort needed to describe the detailed functionality of the system components. The other is\nthe time and effort required to inject faults, initiate repairs, abort, reschedule and synchronize\nevents and maintain a whole host of fault statistics. As the number of components in the system\nbecomes large, a well formulated, structured and automated approach is needed to contend with\nthe complexity.\n\nThe fourth issue is the impact of the software on system dependability. Dependability\nstudies have tended to focus on a system's hardware components. But as the hardware becomes\nmore reliable, the software component is becoming a more dominant factor [27]. The behavior\nand effect of the software on hardware faults is a major concern. The process of software\nexecution determines parameters such as detection latency times, probability of propagation\nand propagation times. These parameters have a bearing on the effectiveness of functional\ndetection and repair schemes, which in turn have a huge impact on the dependability of a\nsystem. Since the process of software execution is determined by an application program, it is\nimperative to perform application specific analysis of functional detection schemes and fault-\ntolerant mechanisms in the early design stages. Hence, methods are needed that allow the\ndesigner to incorporate the application into the overall dependability study.\n\nThe fifth issue, an extremely important issue and one that is common to both functional and\nprobabilistic simulation, is simulation time explosion. This occurs when the system modeled\nhas extremely small failure probabilities requiring large simulation runs to obtain statistically\nsignificant results. This is especially a problem with functional simulation because its primary\nbenefit is detailed modeling which further contributes to simulation time explosion. Unless\neffective techniques are found to reduce simulation execution time, functional simulation-based\ndependability analysis will not be generally applicable. Two approaches to reduce simulation\ntime that have been extensively studied in the literature are importance sampling and parallel\nsimulation. Importance sampling [50, 41, 72] is a statistical technique that skews the proba-\nbility of failure, thereby reducing the number of trials needed to collect failure data, and then\n\"unskews\" the results obtained. Though this heuristic has been shown to be very effective\nin selected cases, it has several drawbacks. It is not generally applicable, it is meant for use\nwith probabilistic simulation, and it cannot be used to obtain many steady-state dependability\nmeasures (e.g. mean time between failure) for general failure distributions. Hence, if this is the\nsole acceleration technique used, it will preclude the use of behavioral models and the generality of the tool.\n\nParallel simulation breaks up the simulation model into several processes and executes them on different machines. Many heuristics [2, 33, 32, 49, 23] have been developed to synchronize the simulation so that events generated on the separate processors are executed in chronological order. Unfortunately, the effectiveness of these schemes are application dependent and work well only with applications that require little synchronization. The focus of past research has been on synchronization heuristics, even though dividing a simulation into separate logical processes and assigning them to processors is not a trivial problem and has a significant bearing on the speed-up achieved. Even when this approach is successful for certain applications, the speed-up achieved is not linear and is limited to the number of processors available to the user.\n\nTo summarize, a general-purpose simulation-based system level dependability analysis tool must effectively handle the large component and fault model domain, provide an environment that facilitates the development of functional simulation models, incorporate the impact of software to allow application specific analysis and furnish generally applicable methods to accelerate the simulation.\nChapter 3\n\nSimulation Environment\n\nThis chapter presents the approach used to solve the first three issues mentioned in the previous chapter and it describes the key features of the integrated fault injection and simulation tool, DEPEND, that has been developed.\n\n3.1 Approach\n\nThe object-oriented design paradigm is used to tackle the first three issues discussed earlier. Object-oriented design is the construction of a software system as a structured collection of abstract data type implementations [47]. A class is an implementation of an abstract data type and an object is a instantiation of a class. A class contains private internal data structures and methods, which are analogous to functions and procedures, that manipulate its internal data. The word collection reflects that each class is an independent, useful component of the system. The key, however, is the word structured which reflects an intelligent division of the system into classes and the existence of important relationships among them.\n\nThrough an intelligent, structured, development of classes, the problems of large component and fault domain are tackled. A combination of two criteria: modular decomposition and modular composability [46], is used to break up the simulation process into individual classes. Modular decomposition consists of breaking down a problem into small elements whereas modular composition favors production of elements that can be freely combined with each other to provide new functionality. Two relations, clientship and inheritance [6] are used to combine the elements (or classes). In a clientship, one class is a client of another that provides the service.\nFor example, a class that implements a stack could rely on a singly linked list for its implementation and thus be a client of the class that implements the linked list. Inheritance, a central mechanism of object oriented programming, allows a new class to be derived from an existing class. The new (or derived) class inherits the features of and is an extension or a specialization of the existing class, the ancestor. An example will help to clarify how modular decomposition and composition are used to tackle the large fault model domain. The fault injection process can be broken down into two processes. One process determines when to inject a fault and interrupt the system and another process responds to the fault injected. The first process is common to all fault injection methods. It encapsulates the various mechanisms used to determine the arrival time of a fault and interrupt the system. The second process is the fault model and is specific to the component and the type of fault being injected. If we encapsulate the first process into a class called the fault injector class and combine it with one of a multiple fault model classes, it is possible to create an environment that can inject many types of faults. The fault injector class is ignorant of the types of faults injected and the components injected. The fault model class encapsulates this component and fault specific information. As a result, this approach can be used to inject not only electronic components but mechanical components. This same structured, modular approach is used to cope with the large component domain; common aspects of similar components are encapsulated in a class which then combines with other classes to provide more specific functionality. Furthermore, because users can specify the classes that model component specific behaviors, the tool is not limited to any pre-defined set of fault models or component types.\n\nA library of pre-developed classes is used to reduce the time and effort needed to develop simulation models. The classes in the library provide the skeletal foundation necessary to rapidly model an architecture and conduct simulated fault injection experiments. The classes form a hierarchy with fundamental classes at the top and derived classes, which inherit these fundamental classes, at the bottom. The complexity and specificity of the classes increase as the bottom of the hierarchy is reached. The fundamental classes provide functionality that is general and widely used. Such functions include the fault injection mechanism, fault tracing where a list of all faults injected is recorded and reported, and maintaining fault statistics (e.g. MTBF, MTBR, Availability, Coverage). Other fundamental classes include events, mailboxes, queues, stacks and servers. These are basic constructs needed for functional simulation. At the\nbottom of the hierarchy are classes that model components found in fault-tolerant computer systems: voters, self-checking components, fault tolerant servers, communication links and triple-modular redundant systems. These classes are developed incrementally by combining (clientship and inheritance) several fundamental classes and adding new methods that are specific to the class.\n\nObject oriented design facilitates reusability [47, 5] and the classes in the library were specifically designed for reuse. Model development time is reduced by the library because it provides a kernel of classes that can be used as is, or readily inherited to create more specific classes thus eliminating the need to develop them from scratch. The complexity of injecting faults, initiating repairs, maintaining statistics etc. is reduced because each derived class inherits fundamental classes that provide these services. As a result, each class automatically injects its own faults, initiates its own repairs and maintains all statistics. At the beginning of a simulation, the user provides the fault and repair distributions and at the end, the user polls the classes to obtain the fault statistics. This automation makes it possible to model large systems more easily.\n\n3.2 Architecture\n\nDEPEND is an integrated design and fault injection environment. It provides facilities to rapidly model fault-tolerant architectures and conduct extensive fault injection studies. Figure 3.1 shows the DEPEND architecture. DEPEND can be executed on various hardware platforms. The hardware specific code is contained in the simulation engine which provides a pseudo-parallel run time environment. The objects provide the skeletal framework with which a user can rapidly build a simulation model for fault injection and dependability analysis.\n\nDEPEND is a functional, discrete-event, process-based [37, 60] simulation tool. The system behavior is described by a collection of asynchronous processes that interact with one another. These processes (also called coroutines) are independent threads of execution that can be suspended and resumed at user specified points in the code [53]. The simulation engine implements processes entirely at the user-level without operating system services. As a result, the processes are light weight and do not execute simultaneously. The simulation engine provides a pseudo-parallel environment. It does this by sequentially executing all processes scheduled to run at\nFigure 3.1: The DEPEND architecture.\nthe same time and then incrementing the simulation clock. The current version of DEPEND uses CSIM to support the process-based paradigm and the pseudo-parallel environment. CSIM uses a single function call stack for all processes. When an active process is suspended, its runtime stack frames and registers are copied into its static process control block. When a process is resumed, the saved stack is copied back onto the runtime stack and the saved registers are restored [15]. The original CSIM has been modified to support fault-injection and the ability to abort, reschedule and kill processes.\n\nAn alternative to process-based simulation is event-driven simulation where a system is described by a set of events and their associated actions. Even though process-based simulation has a large context-switching overhead not present in event-driven simulation, it was selected for several reasons. It is an effective and intuitive way to model system behavior, repair schemes, and system software in detail. It facilitates modeling of inter-component dependencies, especially when the system is large and the dependencies are complex, and it allows actual programs to be executed within the simulation environment with minimal retrofitting.\n\n3.2.1 User Environment\n\nThe steps required to develop and execute a model are shown in Figure 3.2. The user writes a control program in C++ using the objects in the DEPEND library. The program is then compiled and linked with the DEPEND objects. The model is executed in the pseudo-parallel runtime environment. Here, the assortment of objects including the fault injectors, CPUs and communication links execute simultaneously to simulate the functional behavior of the architecture. Faults are injected and repairs are initiated, according to the user's specifications and a report containing the essential statistics of the simulation is generated.\n\n3.2.2 The Object Library\n\nThe object library contains fundamental and complex classes. A fundamental class is not a derived class. A complex class may be a derived class, it may consist of a combination of several classes or both. The classes were designed with four criteria:\n\n- Simulate the general behavior of a computer system component (Decomposability & composability).\n**Figure 3.2:** Steps in developing and simulating a model with DEPEND.\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Event</td>\n<td>Basic synchronization mechanism. Processes wait at and set events.</td>\n</tr>\n<tr>\n<td>Active_elem</td>\n<td>Simulates a server with various queueing disciplines (FCFS, round-robin, etc.). Processes queue at server to model resource contention.</td>\n</tr>\n<tr>\n<td>Injector</td>\n<td>Automatically injects faults based on statistical distributions and trace files.</td>\n</tr>\n</tbody>\n</table>\n\n**Table 3.1:** A few fundamental classes.\n\n- Allow users to specify key parameters (Parameterization).\n- Provide default functions to minimize design time (e.g. fault models, sparing policies).\n- Permit easy reuse.\n\nThe fundamental classes provide basic functions like injecting faults and compiling statistics. Some key fundamental classes are described in Table 3.1. Complex classes created from these fundamental classes simulate components found in fault-tolerant architectures. Such components include CPUs, self-checking processors, N-modular redundant processors, communication links, voters and memory. This kernel of classes can be combined and replicated to simulate a wide range of fault-tolerant architectures.\nTable 3.2: Some key classes that model the architectural components of a fault-tolerant system.\n\nTable 3.2 lists a few complex classes in the library. A detailed description of all classes can be found in [22]. The next subsection describes the basic fault models provided by DEPEND and the following subsections present three essential classes in the library: the fault injector, the fault-tolerant server, and the fault-tolerant communication link. This is followed by an example simulation program.\n\n3.2.3 Fault Models\n\nFunctional fault models are used to simulate the system level manifestation of gate-level faults such as stuck-at faults. Functional fault models are used because they are best suited for system level fault injection where the focus is on the behavior of a component due to a fault. Furthermore, at this high level of integration, gate-level implementation faults become prohibitive [14]. Functional testing approaches and fault models for microprocessors have been presented in [69, 65, 52]. DEPEND provides four types of faults which can be used to simulate specific fault behavior:\n\n- Status faults.\n- Process faults.\n- Server faults.\n- Data faults.\n\nThe simplest fault is the status fault. It is called a status fault because a flag is set to indicate that the status of the component is faulty. Methods of the injected component’s class can be queried to determine its state and, based on the status, specific fault actions can be invoked.\n\nA process fault either aborts or kills a process. Aborting a process entails dequeuing it from an event or server queue, setting the “aborted” flag in its program control block (PCB) and returning control to the process. The process can then poll its “aborted” flag and if set take special action. Killing a process entails dequeuing the process, releasing all resources it has acquired, and destroying its PCB.\n\nA server fault can be injected into any class that is derived from the Active_elem class (see Table 3.1). A server fault causes the server to abort all processes queued for service and update its fault and performance statistics. The aborted processes can then take remedial action such as rollback or restart to simulate the effect of the fault.\n\nWhen actual programs are executed with DEPEND, the data fault can be used to corrupt data elements used by the program. Given a mask, a size and a pointer to the data region, a byte is selected randomly from the region and XORed with the mask.\n\nNote that these basic fault models are general and only interrupts the simulation (e.g. stops a server and dequeues all requests). All specific fault models, including the default fault models provided with DEPEND classes, are built from these core fault models. For instance, the data fault model is used by FT_link (see below) to corrupt the contents of message packets routed by the link. The basic fault models or the default fault models provided with a class can be specialized by the user to create more specific fault models. These fault models can be derived from low-level simulations or from measurements of existing systems. For instance, Choi [10] simulates a processor at the gate-level and executes a workload while injecting transient faults. The results of the faults on the behavior of the workload and the failure mode are stored in a fault dictionary. The fault dictionary can then serve as the basis for the processor’s system-level fault model. Each time a process is aborted due to a transient fault in a server, one of the failure modes can be selected randomly and used to model the process’s failure mode.\n3.2.4 Fault injector\n\nThe fault injector is a fundamental object of DEPEND. It encapsulates the mechanism for injecting faults. To use the injector, a user specifies the number of components, the time to fault distribution for each component, and the fault subroutine which specifies the fault model. The distributions supported are constant time (mostly used for debugging), exponential, hyperexponential and Weibull. The object also allows user specified distributions. When initialized, the injector samples from a random number generator to determine the earliest time to fault, sleeps until that time and calls the fault subroutine.\n\nInitially, the injector used conditional failure distributions to determine the time to next fault, under the assumption that a set of components have independent, identically distributed failure distributions. For instance, for a system with two components using a gracefully degrading sparing policy, the time to failure of the second component, $X$, given that the first component failed at time $t$ is given by $Pr[X < x|X > t]$. For a Weibull time to fault distribution with rate parameter $\\lambda$ and shape parameter $\\alpha$, the conditional distribution is:\n\n$$Pr[X < x|X > t] = 1 - exp^{\\lambda((x+t)^{\\alpha}-t^{\\alpha})}$$\n\nThis approach has several drawbacks. For non-exponential distributions, the conditional distributions become complex and cumbersome as repaired components are re-integrated into the system or cold spares are activated. The conditional distributions depend on the sparing policy. As a result, additional information regarding sparing policies has to be specified. The routines used to generate random samples are more compute bound. Generating a random sample using the inverse transform method for equation 3.1 requires and additional subtraction and an extra call to the math library’s power() function than for a Weibull distribution. For large simulation runs, where thousands of faults are injected, the time spent on these additional calls becomes significant.\n\nThe current version of the injector uses a table-based approach. An entry is kept for each component, specifying its condition (OK, Failed), injection status (Injection off, Injection on), time to fault distribution, and time to next fault. The algorithm used to determine which component to inject is:\n\nInitialize (performed one time)\n\ndo for all components\nif (component is OK & On)\n compute and store time to fault\nelse\n time to fault is \\infty\nend if\nend do\n\nMain body\n\ndo forever\n find minimum time to fault among components\n sleep (minimum time to fault - current time)\n if (sleep not aborted)\n call fault subroutine\n set time to fault of this component to \\infty\n end if\nend do\n\nAny time a component is repaired or turned on, its time to fault is computed and entered in the table. The injector is then awakened so that it takes the new component's fault time into account.\n\nThe table-based approach is versatile. The time to fault distributions of the components do not have to be identical and any user specified distribution can be supported. For example, the full \"bathtub\" reliability curve can be model with DEPEND. The table-based approach automatically takes the age of each component into account without using conditional probability distributions and averts the problem with modeling local and global times found in most analytical tools [71].\n\nDEPEND provides a workload dependent injection facility to model the workload/failure dependency observed in [7, 31]. It can be used to test systems under stress conditions. To implement a workload dependent injection strategy, a statistical clustering algorithm is first used to identify high-density regions of the workload. These regions (or states) are used to specify a state transition diagram that characterizes the workload [29]. Associated with each state is a visit counter which counts the number of visits to that state and a fault rate, \\lambda, which the system experiences in that state. The user provides a workload function which the injector polls periodically to identify the workload state and to update its visit counter. For\nexample, the workload function may be the utilization of a processor or it may be any other function that provides a measure between 0 (low workload) and 1 (high workload). Based on an \\textit{injection \\_interval} specified by the user, the information from the state transition diagram is used to estimate a weighted average failure arrival rate (\\textit{Wgt \\_lambda}) as follows:\n\n\\[\nWgt \\_\\lambda = \\sum_{i=1}^{N} \\text{visit \\_ratio}_i \\times \\lambda_i\n\\]\n\nwhere:\n\n- \\( N \\) is the number of states\n\n\\[\n\\text{visit \\_ratio}_i = \\frac{\\text{counter for state}_i}{\\text{total visits to all states}}\n\\]\n\nOnce \\( Wgt \\_\\lambda \\) is determined, it is used to compute the probability of a failure injection (\\( P \\_\\text{inject}(t) \\)) over the last interval \\( t \\) (\\( = \\text{injection \\_interval} \\)) as follows:\n\n\\[\nP \\_\\text{inject}(t) = 1 - e^{-Wgt \\_\\lambda \\times t}\n\\]\n\nThe fault injector illustrates what we mean by “providing a simulation framework”. The injector provides the basic algorithms and mechanisms needed to inject faults allowing the user to concentrate on the application specific aspects, the fault model and the simulation of a fault. Furthermore, the modular, object-oriented approach allows the user to easily experiment with different time to fault distributions, fault models and workload functions. Other DEPEND objects are similarly designed to provide the functionality that are commonly needed without restricting the applicability of the object.\n\n### 3.2.5 Fault-tolerant server\n\nThe server class, which is typically used to model CPUs and other processors, is an example of a complex class (Figure 3.3) that is built from several elementary classes. It uses a fault injector class to inject faults, the active \\_elem class to model the behavior of a server, and other classes to compile and output fault statistics. It inherits methods from active \\_elem to simulate the acquisition, the use and the release of a server and to provide several service disciplines including, first come first serve (FCFS), round-robin and pre-emptive round-robin.\nThe server offers three sparing modes: the no spare mode, the graceful degradation mode, and the standby cold sparing mode. In the graceful degradation mode, all the spares operate on incoming requests. The entire server fails when all the spares become faulty. In the standby sparing mode, only the primary server operates on requests. When it fails, a reconfiguration takes place and a healthy spare becomes the primary server. The entire server continues to function as long as there is at least one healthy server. The number of spares and the type of sparing policy is user selected.\n\nThe server provides three default fault types: permanent faults, transient faults and user defined faults. Transient faults last for a specified period of time, after which the server returns to a healthy state where it can be used again. When a transient or permanent fault is injected in a server, the server fault model is used to dequeue pending requests and place the server in a hung state. Other fault models can be simulated by specifying user defined faults. To simulate user defined faults, the server invokes a pre-specified fault method, written by the user, that can simulate any fault action a user requires.\n\nThe user can customize the behavior of a server by specifying, among other things, the reconfiguration time, repair coverage and the fault arrival rate. The user can also override the default repair and fault behavior of the server by specifying user written methods to be invoked when a fault or repair event occurs.\n3.2.6 Fault-tolerant communication link\n\nAnother complex class is the link shown in figure 3.4. It is designed to simulate various types of communication links. It consists of a redundant set of communication links with redundant connections from the links to the ports. The link is built from several classes. Instances of the server class are used to model the ports and the links. An instance of the injector class is used to inject faults. The rest of the link class consists of additional software to model the behavior of a communication medium. The link transfers messages between specified ports. Once a message reaches its destination port, it is queued until a process dequeues the message by invoking the receive() method and providing the port number. To initialize a link, the user specifies: the number of redundant links and redundant connections to the links, the number of ports, the time required to send data via the links and the types of faults to be injected. The class offers automatic retry. Messages sent back and forth contain checksums. If a checksum error is detected by a receiving port, a negative acknowledgment is sent triggering a retransmission of that message. The number of retransmissions is user specified. Several default fault models.\n\nFigure 3.4: The Fault-Tolerant Communication Link.\n\nincluding faulty link, faulty port, lost message and corrupted message are offered. The server fault model is used to simulate a faulty link and faulty ports. A lost message is modeled by failing to send the message to its destination. Messages are corrupted using the data fault model. If a link or port is faulty or if a message is lost, the message does not reach its destination. The sender times out waiting for an acknowledgment and then retransmits the message. Like the server object, these default fault models can be overridden by supplying user written fault\nmodels. All the redundancy and fault-tolerant features described are switch selectable so the user has a range of options and can select from a simple link with no fault-tolerance to a link with all the fault-tolerance capabilities described.\n\n### 3.2.7 Programming environment\n\nThe C++ object-oriented language is used to specify a DEPEND simulation model. The C++ language was chosen as the user interface to DEPEND for several reasons. First, it means not having to learn an esoteric simulation language; only knowledge of C++ is necessary. Furthermore, the entire C++ programming environment is available to the user. DEPEND enhances C++ by offering simulation facilities not available through regular C++ constructs. The user can use actual C++ or C programs as a part of the simulation model. This makes it possible to test proto-type software algorithms within DEPEND. C++'s strong type checking makes it easier to write large simulations efficiently with fewer bugs than other languages. Finally, C++ produces efficient code, and the C++/UNIX environment is widely available.\n\nFigures 3.5 and 3.6 show a simple, example program that illustrates the programming environment and some of DEPEND's features. The program models two processes that communicate via a fault-tolerant communication link. The link is declared in line 2 to consist of 2 links, using the graceful degradation sparing mode. There are two ports connected to the link and each port has an additional spare port. The `create()` statement in routines `sim()` and `receiver()` distinguish them from ordinary C++ subroutines. `sim()` and `receiver()` are light-weight co-routines that execute in a pseudo parallel environment. Each time the `create()` statement is executed an instance of the co-routine is created.\n\nThe main co-routine initializes the link. Lines 8 through 13 specify the cost of sending a message, the time to send acknowledgments and that automatic retry is desired. Lines 14-17 specify the percent of messages lost and corrupted and they also specify the range of bytes (from the beginning of the message) that can be corrupted and the mask to be used. If these two types of faults are not sufficient, the user can opt to specify his or her own fault routine by removing lines 16 and 17 and including line 18 (\"//\" is a C++ comment delimiter). Lines 19-22 specify the failure rates and distributions of the ports and the links. By default, permanent faults are\n\n---\n\n1 The program is written in \"pseudo\" C++ for simplicity and ease of understanding.\nFigure 3.5: A simple example program using DEPEND – the main co-routine.\n30) void receiver(int port.id)\n31) {\n32) create(\"recv\"); // this is a co-routine - not a subroutine\n33) int stat, finished = 0;\n34) while (!finished &\n35) do computations ...\n36) ... put results into msg ...\n37) // send (to, from, msg, size )\n38) ln.send((port.id+1)%NUM, port.id, &msg, sizeof(msg));\n39) int reply = ln.receive(id, &msg[id], stat);\n40) if (stat) {\n41) ... received message without error ...\n42) } else {\n43) ... message as error - take remedial action ...\n44) ...\n45) cnt--;\n46) done.set();\n47) }\n48) /* optional fault routine to do specific fault injections */\n49) void my_fault.func(int &rnsg)\n50) {\n51) ... code to corrupt fields in the message ...\n52) } /*\n\nFigure 3.6: A simple example program using DEPEND - the co-routine.\n\ninjected into the ports and links because a fault type has not been specified. If transient faults or user defined faults are injected, repair times, coverage and user defined fault subroutines for link and port faults can be specified.\n\nThe main co-routine creates two of the receiver() co-routine (line 26) and then goes to sleep waiting for the event done to be set before printing the performance (e.g., throughput, response time etc.) and fault (e.g., MTTF, availability, fault and repair times) reports.\n\nThe general structure of the receiver() co-routines is shown in lines 30 through 46. Each co-routine performs some computation, puts results in a message and then sends it to the tandem co-routine. Each co-routine then waits for a return message, performs additional computations and repeats the entire process until all computations are complete or until the communication link fails (i.e., both links are failed or 1 port has failed). The last co-routine to complete wakes up the main co-routine by setting the done event.\n\nThe detail of the simulation model depends on the user. For the computations (line 34, 35, etc.), the user may choose to simply forward the simulation clock and the data in the messages may be fake, meaningless values, or the user may execute actual code and send real data back and forth, making it possible to test actual programs such as algorithm-based fault-tolerant\nprograms, communication protocols and the like. Such an approach was used to determine the fault sensitivity and failure behavior of two load balancing heuristics operating in a distributed system [20].\n\nThe simple example in Figures 3.5 and 3.6 illustrates several basic features of DEPEND. DEPEND provides the framework and the general behavior of the fault-tolerant communication link. The specific behavior is controlled by the user by providing key parameters, specifying options and by furnishing fault subroutines. The user is relieved from simulating the operations of the simulation medium, the ports, the checksumming logic, the automatic retry logic and the injection of faults to the links, ports and messages. Several methods are available to interact with the class and react to important events such as link and port failures. The example shows two methods: a polling function that returns the status of the link (cond_ok(), line 33) and a status variable returned by the class (stat, line 37). In addition to various other polling functions such as functions to determine the status of the ports, the number of messages that have been corrupted and the overhead of sending acknowledgments, there are signals that are set any time failures and repairs occur. Co-routines can sleep until these signals are set and then wakeup and perform specific tasks.\n\nThe example also demonstrates that the impact of different number of spares, different fault arrival rates and distributions and repair coverage can be easily modeled by simply changing a few parameters. A larger, common-bus system consisting of several ports and receiver() routines operating on these ports can be quickly modeled by increasing the number of ports (line 2) and appropriately increasing NUM (line 1). Distributed algorithms can be tested for correctness and to determine their reaction to faults in the communication medium. Other architectures, such as the hypercube, can also be modeled by creating several instances of the link class, one for each link in the cube. By modifying the link declaration, a comparative performability study can be conducted to determine whether the cold sparing or the graceful degradation sparing mode is best suited for a particular application.\n\n3.3 Comparison\n\nTable 3.3 compares the features of several simulation-based system level dependability analysis tools. Rainbow Net and Metasan are purely probabilistic tools. NEST and REACT allow both\nfunctional and probabilistic simulation, and NEST can execute actual routing algorithms. However, neither tool provides facilities to inject process or data faults. Only DEPEND provides an environment to represent application software at an abstract level and use it to perform application specific system analysis in the early design phase when actual code does not exist. Furthermore none of the tools provide acceleration techniques to reduce simulation time explosion.\n\n<table>\n<thead>\n<tr>\n<th>Tool</th>\n<th>Simulation</th>\n<th>Execute Code</th>\n<th>Software Model</th>\n<th>Process Faults</th>\n<th>Data Faults</th>\n<th>Simulation Acceleration</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>NEST</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>RAINBOW NET</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>METASAN</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>REACT</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>DEPEND</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**Table 3.3:** Comparison of the features of several simulation tools.\nChapter 4\n\nTool Capabilities\n\nThis goal of this chapter is to answer the following questions with two examples. Given the large number of analytical tools and petri-net based simulation tools, what is the need for functional (behavioral) simulation tools for system level dependability analysis? What additional information and capabilities can they provide over analytical tools and fault-injection environments?\n\n4.1 Behavioral Modeling\n\nAnalytical and Petri-net tools only use probabilistic modeling to represent system behavior. In essence, these tools pre-define a system's fault behavior with probabilities and distributions. Because DEPEND also allows behavioral modeling, the fault behavior of a system does not have to be pre-defined. Rather, with DEPEND, the fault behavior can be determined from the simulated system. This section presents a study conducted with DEPEND to illustrate this claim.\n\nA distributed system using a centralized, prediction-based load balancing heuristic is evaluated under various types of faults. The heuristic has been shown to be very effective in reducing the mean response times of the processes under normal operating conditions [26, 20]. The question is how will it perform if the system is subjected to faults? Will the load balancing heuristic make the system less robust? Here the measure of robustness is the mean response time seen by the processes. To answer these questions, DEPEND is used to simulate a distributed system.\nBecause actual code can be executed within DEPEND, the complete load balancing heuristic, written in C++, is executed upon the simulated system.\n\nThe distributed system was simulated using one link class to represent the communication channel and several servers to represent the nodes in the system (Figure 4.1). Processes arrive at node 0 where the load balancing heuristic assigns it to a node estimated to provide the lowest response time. The assignment decision is based on the resources the process is predicted to use and the current assignment of processes to the nodes. This information is maintained in a database in node 0 (Figure 4.2a). When a process completes, its actual resources used is sent, via a status message, to node 0 where it is used to update the process's resource usage history and delete its entry from the process assignment table (Figure 4.2b). Each process is represented by its CPU and I/O requirements. A trace file obtained from measuring the CPU and I/O used by processes executing on a VAX 11/780 (running 4.3BSD UNIX) over a period of one week is the source of the processes. Details about the heuristic can be found in [20].\n\nThe load balancing heuristic is started and processes are fed into the system. Meanwhile, the default fault models in the link and server classes are used to corrupt fields in the status messages, destroy status messages and fail node 0 and erase its database. These faults corrupt or destroy the database and ultimately impair the assignment decisions made by the load balancing heuristic. The mean response times of the processes are measured to determine the impact of the faults.\n\nIf a purely probabilistic modeling tool were used for this study, the user would have to pre-specify:\na. Scheduling Node's Database\n\n<table>\n<thead>\n<tr>\n<th>Processes</th>\n<th>Previous CPU & I/O Usage History</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ls</td>\n<td></td>\n</tr>\n<tr>\n<td>grep</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nstate transition diagram maintains past resource usage of each process and is used to predict future resource usage.\n\n<table>\n<thead>\n<tr>\n<th>Process assignment Table</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Node 0</td>\n</tr>\n<tr>\n<td>cc 0.2 / 100</td>\n</tr>\n<tr>\n<td>wc 0.001 / 500</td>\n</tr>\n<tr>\n<td>Id 0.03 / 800</td>\n</tr>\n</tbody>\n</table>\n\nProcesses assigned to each node and their predicted resource usage is stored in the table and used to determine where to place the next process that arrives.\n\nb. Status Message\n\n- List of Completed Processes\n\n process: make\n cpu: 1.5\n iO: 210\n\n- Corrupt\n\nStatus message sent by all nodes to node 0. Contains list of all processes that have completed and the actual resources they used.\n\nFigure 4.2: Database maintained by Node 0 and the status messages it receives.\n• the probability that a fault will corrupt the database.\n\n• how each fault will corrupt the database.\n\n• which portions of the database will be corrupted.\n\n• quantify the extent of corruption.\n\n• quantify how each corruption will impair the placement decision made by the load-balancing software\n\nNeedless to say, these factors are extremely difficult to obtain without a thorough prior fault injection study and they pre-define the fault behavior of the system. Because DEPEND executes the actual software, these parameters are the results of (and not inputs to) the fault-injection experiment. Only the fault arrival rates and the types of faults injected need to be specified. Thus, DEPEND can identify the failure mechanisms, obtain failure probabilities, and quantize the effect of faults. It can be used to select the key features that must be modeled and help to determine and specify both the structure of, and the parameters to analytical models.\n\nOnly a summary of the results of the fault injection experiments are presented in this section. Detailed results can be found in [21]. The fault injection experiments show that unless errors are injected into the node 0 in rapid, sustained bursts the impact on response time is minimal. This finding indicates that the database is regenerated quickly after each fault and there is no need to save a backup copy. The impact on response time when status messages are corrupted is shown in Figure 4.3. Interestingly, as the percent of messages corrupted increases beyond a certain point (about 10%), the increase in response time reaches a plateau. Once more than 10% of the messages are injected, the database becomes so corrupted that the assignments are made randomly and further corruption has little impact. This behavior shows that the heuristic is robust and there is no need for additional, expensive fault-tolerant mechanisms.\n\nA single distinguishing advantage of behavioral modeling over probabilistic modeling is accentuated in the results obtained when status messages are destroyed. Figure 4.4 (the curve labeled ‘before’) shows that the degradation in response time continues to increase without reaching a plateau. Upon close examination, the increasing poor performance was found to be caused by an implementation detail of the load balancing heuristic. Once the heuristic was modified, the erratic increase in the response time ceased. Thus by using behavioral modeling, it\nwas possible to not only quantize the impact of the various faults, determine whether additional fault-tolerance mechanisms are needed if the system is operated in an adverse environment, it was also possible to verify the heuristic and identify a design feature that makes it susceptible to a specific fault type. Not only are such studies beyond the range of analytical tools, to the authors’ knowledge, this experiment would be difficult to conduct with software fault injection tools like FERRARI [36] and FIAT [18] because they cannot evaluate software running on distributed systems.\n\n4.2 Modeling Real Fault Scenarios\n\nDEPEND uses a combination of behavioral and probabilistic modeling to simulate many realistic fault scenarios. In this section, a simple example is used to illustrate how DEPEND models latent errors that can substantially degrade system reliability. Latent errors can remain undetected in a system for long periods of time and are a potential hazard [8]. A measurement\nFigure 4.4: Impact of destroyed status update messages – before and after design change.\n\nA study of a VAX 11/780 [9] has shown the mean latency of an error can be in the order of minutes ($\\mu = 44\\text{min.}, \\sigma = 29\\text{min.}$) during peak hours and to several hours ($\\mu = 8\\text{hrs.}, \\sigma = 4\\text{hrs.}$) during off-times.\n\nModeling latent errors is difficult with Markov models for several reasons. First, the state space of the Markov model can be large for even small systems if each latent error and its location within a component is represented. Second, simplifying assumptions such as independent repair processes must be eliminated in order to accurately evaluate the impact of latent errors. For example, in a self-repairing system like the Tandem Integrity S2 (detailed description can be found in Chapter 5), the healthy processors reconfigure or repair a failed processor. If latent errors are detected in the healthy processors during a repair, the system fails. Modeling this inter-component dependence typically requires that the entire CTMC, its failure and repair process, be evaluated together thus potentially leading to large, stiff models. In [16], the authors present a novel decomposition technique to avoid such large, stiff models. With their approach, the repair coverage is evaluated in isolation and then ‘adjusted’ to account for the\nFigure 4.5: The error injection process that models error latency.\n\nThe probability of a second, independent error in another component. The example below extends this analysis to also evaluate the impact of near-coincident errors due to latent errors in a repairing CPU. To do this, the example models the inherent dependencies that exist among the system components.\n\nFigure 4.6: The repair process that considers the state of the other CPUs in the system.\n\nFigure 4.5 illustrates how latent errors are injected into a system with three processors. DEPEND uses a chronologically sorted queue to maintain the latent errors injected into the system. Among the information associated with each latent error include the time at which the error is injected, its location (the component and memory address), and its latency period. Typically, the errors are detected when their latency period expires. However, the errors can be detected earlier by the repair process. Fault injection experiments of the Tandem Integrity S2 have shown that latent errors in the repairing processor are detected with high probability.\n<table>\n<thead>\n<tr>\n<th>Description</th>\n<th>Value assigned</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Error Arrival Rate, $\\lambda_1$</td>\n<td>0.01388</td>\n</tr>\n<tr>\n<td>Repair Rate, $\\mu$</td>\n<td>30.0</td>\n</tr>\n<tr>\n<td>Percent Transient error, $\\tau$</td>\n<td>0.99</td>\n</tr>\n<tr>\n<td>Repair coverage, $\\beta$</td>\n<td>0.98</td>\n</tr>\n<tr>\n<td>Latent error in system space, $\\epsilon$</td>\n<td>0.05</td>\n</tr>\n<tr>\n<td>Latency for system space, exponential with mean</td>\n<td>15.0</td>\n</tr>\n<tr>\n<td>Latency for application space, exponential with means</td>\n<td>1, 2, 4, 6 & 8</td>\n</tr>\n<tr>\n<td>Prob. Failure due to latent errors in repairing CPU, $\\gamma$</td>\n<td>0.1</td>\n</tr>\n</tbody>\n</table>\n\n**Table 4.1:** The parameters used. All times are in hours.\n\nduring repair and reconfiguration because much of the system is exercised during a repair. Figure 4.6 is a flowchart of the repair process that models this phenomenon. It is invoked each time a latent error is activated. Note that the repair process models near-coincident errors caused by a second, independent error in another processor (box 1). The dynamic determination of the repair coverage which depends on whether there are latent errors in the repairing processor is shown in boxes 2 and 3. To reiterate, by storing latent errors in a queue, DEPEND can dynamically model the actual activation time of latent errors which is dependent on: 1) the component the error is located in, 2) the location within a component, 3) the failure rate of the components in the system, and 4) the system's repair scheme.\n\nThe example is evaluated under three different conditions. First, permanent and transient errors with no latency are injected (M1). Second, near-coincident errors due to a second, independent error in another processor is modeled but error latency is not considered (M2). The decomposition technique in [16] model this second condition. Third, the simulation model described above is evaluated. It includes the conditions in M2, and it also considers near-coincident errors caused by latent errors (M3). The specific parameters of the models are listed in Table 4.1. Figure 4.7 shows a 33% decrease in MTTF when latent errors and their impact on system reliability is taken into account. The result emphasizes the importance of modeling real phenomenon such as latency, and it demonstrates that by so doing, more precise evaluation of fault tolerant mechanisms and repair schemes are possible. Later, in Chapter 7, the \"staggered machine failure\" phenomenon found to be caused by correlated errors [73] is mimicked by injecting correlated errors with different latency times. This more faithful model\nis found to produce MTTF figures that are an order of magnitude larger than those produced with traditional models that assume correlated errors are detected simultaneously.\n\n![MTTF Comparison Graph]\n\nFigure 4.7: Comparison of system MTTF for the three models.\n\n4.3 Discussion\n\nThis Chapter uses two examples to highlight the benefits of using DEPEND during the intermediate stages of system design. With analytical tools and petri-net tools a system’s fault behavior must be pre-defined. DEPEND’s integrated fault injection and functional simulation environment allows detailed modeling of system behavior and fault injections that help determine the system’s fault behavior. The first example demonstrates how software behavior under hardware faults can be studied and how DEPEND can also be used to verify the software and identify design features that make it susceptible to particular fault types. The second example illustrates how accurate modeling of realistic fault scenarios and the ability to consider the inter-component dependencies provide significantly different MTBF measures than those ob-\ntained when these issues are not considered. The ability to perform these sorts of studies in the early design stages is crucial to ensuring that a system meets its dependability specifications.\nChapter 5\n\nA Case Study\n\nThis chapter describes the Tandem Integrity S2 fault-tolerant system. It also presents the simulation model of an S2 like system developed with DEPEND. The primary reason for selecting the Tandem Integrity S2 as the target system is that we have a hybrid injection and measurement environment [75] for an actual Tandem Integrity S2 machine. With this hybrid environment, injection experiments on the actual machine are conducted and used to validate the simulation methods and the models developed. A brief description of the hybrid environment and the setup used to conduct the validation experiments can be found in chapter 6.\n\n5.1 The Tandem Integrity S2 Architecture\n\nThe Tandem Integrity S2 fault-tolerant system [34] is shown in figure 5.1. It is a triple modular redundant system (TMR). Each CPU is a MIPS R3000 RISC processor with an on-chip virtual memory mechanism and a separate clock. The processors execute the same instruction stream simultaneously. The processors are synchronized and their requests are checked by the voter when global memory is accessed, I/O is performed, or 2047 cycles have elapsed. If there is a discrepancy during voting, the processor in disagreement is shut down. The faulty processor performs a power-on self-test (POST), and if successful, the system is halted and the contents of the good processors are copied to it. The POST takes approximately 70 seconds and the re-integration takes approximately 2.0 seconds for a system with 8 Mbytes of local memory.\n\nThe local memories in the Integrity S2 do not have parity or ECC circuitry. The Integrity S2 relies on memory scrubbing to correct transient memory errors. The TMRC contains the\nTable 5.1: Measured global memory re-integration times with varying machine idle percentages\n\n<table>\n<thead>\n<tr>\n<th>Percent of Time CPU is Idle</th>\n<th>Re-integration Time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>99%</td>\n<td>30 sec.</td>\n</tr>\n<tr>\n<td>59%</td>\n<td>2 min. 25 sec.</td>\n</tr>\n<tr>\n<td>37%</td>\n<td>3 min. 46 sec.</td>\n</tr>\n<tr>\n<td>27%</td>\n<td>4 min. and 5 sec.</td>\n</tr>\n<tr>\n<td>16%</td>\n<td>4 min. and 40 sec.</td>\n</tr>\n<tr>\n<td>0%</td>\n<td>5 min. and 29 sec.</td>\n</tr>\n</tbody>\n</table>\n\nvoter and up to 128MB of global memory. The primary function of the TMRC is to vote upon the transactions sent by the CPUs. The global memories are protected by parity. When a parity error is detected by the TMRC, the backup memory takes over. A global memory is re-integrated in the background, interleaved with ordinary processing. The re-integration time is load dependent. Table 5.1 contains the measured re-integration times from a system with 32MB of global memory. Global memory re-integration has lower priority than CPU re-integration and is aborted and restarted in case of a CPU re-integration.\nTo develop an accurate simulation model of a Tandem Integrity S2 like system, several key characteristics of the Tandem Integrity S2 system are simulated. These include:\n\n1. the loose synchronization policy of the Integrity system. The fact that the processors idle at the voters to synchronize and the exact time needed by the voting operation are accounted for in the model.\n\n2. the CPU (with its local memory) and the global memory structure that is unique to the Integrity system.\n\n3. the functional behavior of the error-detection mechanisms of the CPU and global memory structure.\n\n4. the CPU off-line POST and the on-line re-integration process and the global memory background re-integration process that are unique to the Tandem Integrity.\n\n5. the behavior of the Tandem Integrity when a CPU and global memory re-integration occurs simultaneously (prioritized re-integration).\n\nThese details of the system architecture and how it reacts to faults were determined by studying its layouts, descriptions and manuals, discussing the matter with its designers and conducting several fault injection studies (in addition to the validation experiments mentioned below). Simultaneous injections into various components of the system helped to uncover interesting characteristics of the system that were subsequently incorporated into the Integrity S2 simulation model.\n\nThe simulation model of the Tandem Integrity S2, developed with DEPEND, is shown in figure 5.2. The blocks on the right are the DEPEND classes used in the simulation model. The block on the left summarizes the program written to create the simulation model and control the operations of each of the components.\n\nThe NMR class in the DEPEND library is the primary object used in the simulation. The NMR class simulates dual self-checking, triple-modular redundant and N-modular redundant systems. The servers idle until they receive a task to process. They then execute for a specified time period and feed their results to the voter. The voter waits for all the servers and then\nexecutes a voting algorithm. A timeout condition is used to prevent hanging in cases where a server fails to report to the voter. The NMR class provides two voting algorithms: *bit stream* voting and *error based* voting. The *bit stream* voting scheme performs a bit by bit comparison of the data deposited by the servers. The *error based* algorithm flags a server’s result as being faulty if an error has been injected into the server. This option was used in this simulation because the processors were not given real data to process. The NMR shuts down the servers with faulty results. Automatic repair schemes are not provided, but functions can be called to repair the individual servers. This feature is used to simulate the automatic re-integration feature of the Tandem Integrity S2. The NMR’s fault injector injects latent and correlated errors.\n\nThe processing core of the Integrity S2 is simulated with a NMR class containing 3 servers. Each server simulates a processor board containing a CPU and a local memory. The NMR’s injector is used to inject errors into both the processor and the local memory.\nThe two global memory boards are simulated with a NMR with 2 servers. Every 2047 cycles, when the processors synchronize, the global memory's error based voting function is explicitly invoked by the control program to check each server and shut down any that has an active error. This simulates the actual operation of the Integrity S2 system because parity errors in the global memory are detected when the processors synchronize at the voter to access global memory.\n\nThe control program in figure 5.2 is the only part that is written by the user. It declares instances of the two DEPEND objects and initializes and customizes them. Initialization consists of specifying the error arrival distribution, the error arrival rate, the error latency distribution and so on. Then each object is \"started\" causing them to automatically perform tasks based on the parameters specified. All actions are automatically logged and the user can call functions to obtain a detailed report of every fault or repair. In addition, statistics such as availability, MTBF, the number of faults injected, the mean time between repair and the repair coverage are available.\n\nThe control program simulates the execution of 2047 instructions and the voting process. If any detectable errors are found in any of the components during voting, the components are shutdown. The status of the system is checked to determine whether it has failed (i.e. two CPUs or both global memory boards have failed). If the system has failed, it is rebooted and the simulation restarts. If the system has not failed, a background re-integration process is started for any component that was shutdown earlier by the voter. Finally, the control program checks to see if re-integrations initiated in an earlier cycle has completed. If so, they are handled based on the component type (CPU or global memory) as described in the previous section. Though not shown in figure 5.2, the memory scrubbing process is also simulated. Although the simulation can produce many results, the one we are most concerned with is the mean time between system failures (MTBF).\n\nTo summarize, this chapter describes the Tandem Integrity S2 architecture and presents the overall simulation model developed with DEPEND. The next two chapters describe specific aspects of the simulation model such as the approach used to model software behavior under hardware faults and the acceleration techniques used to execute the simulation and produce statistically valid results.\nChapter 6\n\nSoftware Behavior Under Hardware Faults\n\nThe impact of software on system dependability is a primary concern because software is a major component of a system. One aspect is software reliability, which is concerned with design errors in the software. Another aspect, and the focus of this chapter is the behavior and the effect of software on hardware faults. In the early design stages of a system, a designer has a general idea of the structure and the underlying algorithm of the application software, or has access to the software that will be ported to the new system. An effective design strategy at this early stage is to evaluate the system while executing an abstract representation of the application software. This can provide key application dependent parameters that impact system dependability. It permits meaningful application specific evaluation and trade-off analysis of function and system level detection and recovery mechanisms.\n\nIn this chapter, we present a simulation-based software model that uses a probabilistic control flow graph to represent a program at an abstract level. The model is executed on a simulated system to obtain application specific error latency distributions and evaluate two functional error detection mechanisms. Error latency distributions obtained from the model are validated by comparing them with those obtained from running the actual programs on the Tandem Integrity S2 system. The impact of program control flow on error latency times is studied, a model of the detection process of a RISC-based system is developed and the need for application specific analysis of functional detection schemes is demonstrated.\nMany studies have evaluated the behavior of software under hardware faults [1, 11, 14, 36, 44, 48, 18, 75]. Actual programs are executed on simulated or real processors in which errors are injected. These studies require an actual system or a detailed model of the hardware architecture. Tools like FIAT and FERRARI verify and study software systems by injecting software-implemented faults into actual programs. Laprie [39] uses a Markov model to evaluate the reliability of software systems during their operational life. The focus of the work is on software design errors. In [64], a stochastic model of error propagation is developed with a digraph that represents the interconnections between the hardware and software models. The propagation times are based on random variables with general distributions. In [51], a control flow graph automatically generated from syntactic analysis of a program, is used to estimate execution times. DEPEND [24] and REACT [12] provide a simulation-based fault injection environment to analyze the dependability of hardware architectures. As such, there are no mechanisms to study, at the early design phase, software behavior under hardware faults.\n\nThe software model presented runs within the DEPEND environment and extends DEPEND's ability to study software issues in the early design stage [25]. The high-level abstraction greatly reduces simulation time explosion and permits hundreds of error injections within seconds. Large observation periods are possible and allow collection of detection latency times that are in the order of minutes. Such large detection latencies are typical of real programs. Collecting them allows evaluation of detection schemes under realistic conditions. The contribution of this work is a method to:\n\n1. Create a high-level abstract representation of application software that can be used to obtain application specific parameters that affect the dependability of a system.\n\n2. Evaluate function and system level detection and recovery schemes within the context of application programs.\n\n3. Study the impact of program control flow on one parameter, the error latency distribution.\n\n4. Develop a model of the detection process of a RISC-based processor.\n\n5. Provide feedback early in the design phase.\n6.1 Model Overview\n\nThe software model environment is shown in Figure 6.1. The model consists of programs that are represented by probabilistic control flow graphs, $G$, and a virtual memory system, $M$, within which the programs execute. Contention for resources is modeled using the first-come-first-served or round-robin scheduling discipline. Errors are injected into the physical memory space.\n\n![Diagram of software model execution environment]\n\n**Figure 6.1:** The complete software model execution environment.\n\nThe distinguishing feature of the software model is the virtual memory system $M$ and the link between $G$ and $M$. The virtual memory provides two functions. First, it permits simultaneous execution of several programs allowing evaluation of their combined impact. Second, it allows these programs to share pages in memory. Interprogram communication, and hence propagation of errors among programs, is modeled with shared pages. In fact, the shared memory primitive can be used to model various communication paradigms. In [42], the authors give a convincing argument for the claim that \"variable sharing\" is a close reflection of com-\nputer hardware and it is a primitive upon which all other realizable distributed models can be described.\n\nThe error occurrence process is modeled by injecting errors into the physical memory and allowing the simulated execution of \\( G \\), to discover the error. Manifestation of transient hardware faults are modeled as memory errors. A similar approach was taken in [44], in which the authors model all control flow errors as memory errors. The model is realistic for faults in the memory subsystem, however, it can also be applied to several types of faults in the processor. For instance, a fault in the ALU can propagate, eventually manifesting as incorrect data written to memory. Similarly, errors in the bus can cause incorrect data to be written to memory or written to the wrong location. Errors in memory mapped registers and I/O devices can also be represented by memory errors.\n\nThe user provides a control flow graph of an algorithm, the location of the memory accessed by each node and the total virtual memory used by the graph. The memory access pattern is derived from the graph. The model is hierarchical allowing designers to refine their abstract program models as more information is available. The software model simulates the execution of the graph on the underlying hardware. Outputs of the model include detection latency times, error propagation times, the probability of error propagation, and detection coverages. The software model is intended for use in the early design stages when an actual system does not exist and details of the applications are not known. It is not meant to replace fault injection studies of existing systems.\n\n6.2 Model Description\n\nThe software model \\( SW \\) is defined as\n\n\\[\nSW = (M, (G, S, Ez)^+, I)^1\n\\]\n\nwhere:\n\n- \\( M \\) is the virtual memory system.\n- \\( G \\) is a probabilistic control flow graph (PCFG).\n\n\\(^1\\)The unary operator \\( ^+ \\) means \"one or more instances of.\"\n• \\( S \\) is the subspace in \\( M \\), allocated to \\( G \\).\n\n• \\( Ex \\) is the execution environment given by:\n\n\\[\nEx = \\begin{cases} \nE_{\\text{no \\_ error}} & \\text{Simulates execution of } G \\text{ in a multiprogramming environment.} \\\\\nE_{\\text{text \\_ error}} & \\text{Executes } G \\text{ and simulates detection of errors in the text space of } G. \\\\\nE_{\\text{text \\_ data}} & \\text{Executes } G \\text{ and simulates detection of errors in the data space of } G. \\\\\nE_{\\text{propagate}} & \\text{Executes } G \\text{ and simulates detection and propagation of errors.}\n\\end{cases}\n\\]\n\n• \\( I \\) is an injector which injects errors into \\( M \\).\n\n### 6.2.1 The Memory System\n\nA paged virtual memory system is simulated and is defined as \\( M = (V_m, P_m) \\), where, \\( V_m \\) is the virtual memory and \\( P_m \\) is the physical memory. A virtual memory system allows more than one \\( G \\) to execute simultaneously and share pages. The functions that operate on \\( M \\) are:\n\n- **access memory**(PID, \\( v_{\\text{beg}}, v_{\\text{end}} \\)) – Maps the virtual block \\(< v_{\\text{beg}}, v_{\\text{end}} >\\) of a PCFG indicated by PID to a physical block \\(< p_{\\text{beg}}, p_{\\text{end}} >\\) in \\( P_m \\). The address of the first error encountered in the range \\(< p_{\\text{beg}}, p_{\\text{end}} >\\) is returned. If there are no errors, -1 is returned.\n\n- **inject error**(PID, \\( v_a \\)) – The virtual address \\( v_a \\) is mapped to a physical address, \\( p_a \\), in \\( P_m \\). A bit is flipped and location \\( p_a \\) is marked as corrupted.\n\n- **inject error**(\\( p_a \\)) – A bit in the word addressed by \\( p_a \\) is flipped and \\( p_a \\) is marked as corrupted.\n\n- **erase error**(PID, \\( v_a \\)) – The virtual address \\( v_a \\) is mapped to a physical address, \\( p_a \\), in \\( P_m \\). The word is corrected and \\( p_a \\) is marked as uncorrupted.\n\n- **erase error**(\\( p_a \\)) – The word addressed by \\( p_a \\) is corrected and marked as uncorrupted.\n\nFunction **access memory** is used by \\( Ex \\) to detect errors in the memory accessed by a PCFG. Functions **inject error** and **erase error** are used by the injector to introduce and correct errors in the physical memory, \\( P_m \\).\n6.2.2 The Probabilistic Control Flow Graph\n\n$G$ is a probabilistic control flow graph, $G = (N, E)$, where $N$ is the set of nodes and $E$ is the set of edges.\n\n**Definition 3.1:** The node set $N = \\{n_1, n_2, ..., n_k\\}$ where $n_i$ is an abstract definition of a program segment consisting of:\n\n- **Required:**\n \n - **name**\n - name or identification of the node.\n \n - **text space**\n - location of node’s text in virtual memory, denoted by $<t_{\\text{beg}}, t_{\\text{end}}>$, the address of the first and last words.\n \n - **exec time**\n - number of cycles to execute the node.\n \n - **$\\rho_t$**\n - probability of detecting an error in the text space on the first encounter.\n \n - **function**\n - function performed by the block (Read, Write, Read/Write, IO, Err_correct, Err_detect, Checkpoint)\n\n- **Optional:**\n\n - **data space**\n - location of data blocks processed by the node denoted by $<d_{\\text{beg}1}, d_{\\text{end}1}, ..., d_{\\text{beg}k}, d_{\\text{end}k}>$ where $<d_{\\text{beg}i}, d_{\\text{end}i}>$ is the address of the first and last words of data block $i$. Data can be located in shared memory space.\n \n - **$\\rho_d$**\n - probability of detecting an error in data space.\n \n - **$\\rho_{prop}$**\n - probability of propagating an error in data space.\n\nThe optional parameters are needed only if the $E_{\\text{test.data}}$ or the $E_{\\text{propagate}}$ execution environment is used.\n\n**Definition 3.2:** The edge set $E = \\{e_1, e_2, ..., e_k\\}$ where $e_i$ is a directed edge defined as $e_i = ((n_i, n_j), a_i, m_i)$:\n\n- $(n_i, n_j)$ is an ordered pair of any two nodes in $N$ with $n_i$ as the tail and $n_j$ as the head of the directed edge,\n• $\\alpha_i$ is the probability of traversing the edge,\n\n• $m_i$ is a count of the number of times the edge is to be traversed.\n\nDefinition 3.3: A simple edge $e_i$ is defined such that $n_j$ is not an ancestor of $n_i$, $n_j \\neq n_i$, $\\alpha_i > 0$, and $m_i = 0$.\n\nDefinition 3.4: A loopback edge $e_i$ is defined such that $n_j$ is an ancestor of $n_i$ or $n_j = n_i$, $\\alpha_i = 0$, and $m_i > 0$.\n\nDefinition 3.5: The set $\\xi_p \\subseteq E$ is the set of directed edges from node $n_p$ such that\n\n$$\\sum_{i=1}^{\\xi_p} \\alpha_i = 1, \\ \\forall: e_i \\in \\xi_p$$\n\n6.2.3 The Memory Subspace\n\n$S$ is the subspace of the total text, data and shared space in virtual memory allocated to $G$ and is given by:\n\n$$S = (<S_b(text), S_e(text)>, <S_b(data), S_e(data)>, <S_b(shared), S_e(shared)>)$$\n\nwhere,\n\n• $S_b(x)$ = address of the first word of space $x$ in virtual memory.\n\n• $S_e(x)$ = address of the last word of space $x$ in virtual memory.\n\n6.2.4 The Execution Environment\n\nA discrete-event simulator [60, 43, 24] is used to execute $G$ in a simulated multiprogramming environment. $Ex$ can be one of the following paradigms.\n\n6.2.4.1 Execution without error detection\n\n$Ex_{no\\text{-error}}$ models the probabilistic execution of $G$ and is the basis upon which other execution paradigms are built.\nInput: `cycle_time`, `IOserver.ID`, `CPUserver.ID`\n\nFunction:\n- Assign PID to PCFG\n- Allocate text, data, and shared memory space in `M`\n- Traverse the PCFG\n - I = top most node in PCFG\n - while (I <> terminal node)\n - `texterror.addr` = `memory_access(PID, text space)`\n - if (data space specified)\n - `dataerror.addr` = `memory_access(PID, data space)`\n - S1: `server.time = exec time \\times cycle.time`\n - if (function = IO)\n - reserve(`IOserver.ID`)\n - hold(`server.time`)\n - release(`IOserver.ID`)\n - else\n - reserve(`CPUserver.ID`)\n - hold(`server.time`)\n - release(`CPUserver.ID`)\n - S2: I = `get_next_node()`\n - end while\n\nwhere,\n- `reserve()` & simulate the queueing activity at a server.\n- `release()`\n- `hold()` increments the system clock.\n\n`get_next_node()`\n- if (`\\xi_7 = \\{e_l, e_s\\}`, where `e_l` is a loopback edge and `e_s` is a simple edge) then\n - if (`m_l > 0`) then\n - decrement `m_l`\n - `node.addr = head(e_l)`\n - else\n - `node.addr = head(e_s)`\nelse if ( $\\xi_j = \\{e_1, e_2, ..., e_j\\}$, and $\\xi_j$ contains no loopback edges) then\n\nselect $e_i \\in \\xi_j$ with probability $\\alpha_i$\n\nnode_addr = head($e_i$)\n\nreturn(node_addr)\n\n6.2.4.2 Execution with detection of text errors\n\n$E_{text\\_error}$ is an extension of $E_{no\\_error}$ which models the probabilistic detection of errors present in the text space. It requires three additional inputs:\n\n**Additional input:** detect\\_function, record\\_error, $\\nu$\n\nwhere,\n\n- detect\\_function models the probabilistic detection process (see below).\n- record\\_error records pertinent statistics, such as the time of detection.\n- $\\nu$ parameter used by the detection function, $0 \\leq \\nu \\leq 1$.\n\nStatements S1 and S2 of $E_{no\\_error}$ are replaced with the following:\n\n**S1:**\n\n```plaintext\nerror_detected = detect\\_function(\n texterror\\_addr, \\nu)\n\nif (error_detected)\n server_time = \\frac{\\text{texterror\\_addr} - \\text{txbeg}_i}{\\text{txend}_i - \\text{txbeg}_i + 1}\n \\times \\text{exec\\_time}_i \\times \\text{cycle\\_time}\n\nelse\n server_time = \\text{exec\\_time}_i \\times \\text{cycle\\_time}\n```\n\n**S2:**\n\n```plaintext\nif(error_detected)\n record\\_error()\n\nuse server for the remaining time\n\nI = get\\_next\\_node()\n```\nIn S1 above, the time to detection (server_time) is computed using a linear relationship based on the location of the error within the text space. The detection function returns a **FALSE** if the text_error_addr is -1. Otherwise it models error detection as follows:\n\n**Detect Function:**\n\n```plaintext\nincrement err_pass\n\nγ = U(0,1) -- a Uniform distribution\n\nif (ρ, · ν(err_pass-1) < γ AND err_pass < LIMIT)\n return TRUE\nelse\n return FALSE\n```\n\nwhere,\n\n- **err_pass** is the number of times the specific error is encountered.\n- **LIMIT** is the maximum number of encounters within which the error must be detected.\n\nThe detection function decreases the probability of detection exponentially for ν < 1, as the number of encounters increases. The total probability of detecting an error, D, within K encounters is:\n\n\\[\nD = \\sum_{\\kappa=1}^{K} D_\\kappa\n\\]\n\nwhere,\n\n\\[\nD_\\kappa = \\begin{cases} \n\\rho, \\nu^{\\kappa-1}(1 - D_{\\kappa-1}), & \\kappa > 1 \\\\\n\\rho, & \\kappa = 1\n\\end{cases}\n\\]\n\nThe software model is designed to simulate and evaluate functional detection schemes. The detection function presented here models the low level detection mechanism found in most processors. Such mechanisms include mathematical exceptions (e.g. division by zero), bus errors caused by invalid address or access types, and address error caused when an unaligned word is fetched or stored. Later in this chapter, we show that the detection function accurately captures the behavior of the low level error detection process for the programs modeled.\n6.2.4.3 Execution with detection of text and data errors\n\n$Ex_{text-data}$ is an extension of $Ex_{text-error}$. Identical service time calculations and detection functions are used to simulate the detection of errors in the data space of a node. If the function of the node is Write, then errors encountered in the data space are overwritten with probability $\\rho_d$.\n\n6.2.4.4 Execution with error propagation\n\n$Ex_{propagate}$ is an extension of $Ex_{text-data}$ which simulates the propagation of errors. If an error is not detected, then with probability $\\rho_{prop}$, it is propagated based on the function of the node at which the error has occurred.\n\nAn error in the text space is assumed to cause a Read node to read the wrong data and a Write node to write data to the wrong location. A Read node with an error causes $m$ (an input parameter) errors to be injected into the data space. This models the phenomenon that a wrong word was read and used for computation thus propagating the error. For a Write node, $2m$ errors are injected. One error is injected because the wrong location is overwritten, and another because the correct location is not updated\\(^2\\).\n\nAn error in the data space of a node causes $m$ errors to be injected into the data space if the node’s function is a Read. If the function of the node is Write, the error in the data space is corrected.\n\nIf a node’s data space has more than one data block, the block injected is selected randomly. The parameter $m$ is typically 1. Since the data space of one node can overlap with that of another, errors can propagate between nodes and within the memory space of a PCFG. If a PCFG shares pages with other PCFGs, errors can propagate between them.\n\n6.2.5 The Injector\n\nThe injector injects errors into the physical memory, $P_m$, using the functions described in Section 3.2.1. The injector can be specified to inject one or many errors. If many errors are to be injected, the user specifies one of the three error arrival distributions: constant, exponential\n\n\\(^2\\)Propagation for a Read/Write node combines the effect modeled for Read and Write. To keep the paper concise, a detailed description is not provided.\nor Weibull. The range of locations to be injected must also be specified. The words injected\nare selected randomly from this range.\n\n6.2.6 Specification Language\n\nA simple program and the language used to specify a PCFG of the program are illustrated in Figure 6.2. The \"memory{}\" construct specifies the virtual space required by the text, data and shared segments. The \"bind{}\" construct binds constants to identifiers. The structure of the program is defined with the \"node{}\" construct. A node can be a simple node containing items listed in definition 3.1. It can also be a \"meta\" node consisting of one or more simple and meta nodes and one \"flow{}\" construct that defines the control flow within that meta node. In the figure, node init's function is Write. Its exec time is $19 \\times 1000$ cycles, its text space is $<1001, 1018>$ and it has one data block $<0, 1000>$. \n\nFigure 6.2: Example program and corresponding PCFG.\nThe level of abstraction used will depend on the nature of the experiment and the information available about the program. As more information is known, it can be added by converting simple nodes to meta nodes. In this example, each node represents a set of program statements. Some nodes are more \"abstract\" than others. For instance, node init represents the entire \"for loop\" used to initialize the array, whereas the loops in sort() are modeled in more detail. For this level of abstraction, a node's text space can be determined based on the number of instructions it represents. For a RISC processor, where the instructions are of fixed length, the size can be estimated based on the statement to instruction ratio. The number of cycles per node is 1 to 1.4 times the number of instructions. Once the PCFG is specified, it is compiled to create a binary file that is executed by Ex.\n\n6.3 Model Application\n\nOne application of the software model is illustrated. It is used to obtain error latency distributions of two different programs and evaluate two memory scrubbing schemes. The error latency times obtained are validated with measured latencies from an actual system. The experiments also validate the detection function introduced in the previous section.\n\n6.3.1 Application Programs\n\nTwo programs are represented with the software model. The first is a Gaussian elimination program with partial pivoting and back substitution. This program was chosen because it is representative of a large class of numerical and statistical applications. The Gaussian elimination program (Gauss executes indefinitely. Each iteration takes 35.6 seconds and consists of filling a 300-by-300 matrix with randomly generated numbers, solving the matrix and printing the result. The program contains 280 lines of C code and was modeled with a PCFG consisting of 23 nodes. The second program is an insertion sort (Sort). Unlike Gauss, it manipulates integers and does not use the floating point co-processor. Sort repeatedly sorts a randomly generated array of 7000 numbers which requires 30 seconds for each iteration. The program contains 200 lines of code and is represented with a PCFG with 11 nodes. Both PCFGs are\n\nTypically, the level of abstraction is much higher than shown here, but this serves well as a simple illustration.\nexecuted with the $E_{text\\_error}$ paradigm. Several instances of the Gauss PCFG are executed simultaneously to demonstrate the software model's ability to execute more than one PCFG.\n\n6.3.2 Experiment Setup\n\nThe software model was initialized with $P_m = 8$MB of memory. One to 16 instances of a PCFG are executed simultaneously. A procedure that sweeps through $P_m$ every hour was added to simulate the scrubber. Each experiment run consists of the following steps:\n\n1. Start the PCFG(s).\n2. Randomly select a PCFG and a word within the PCFG's virtual memory space to be injected.\n3. Inject an error – flip a bit of the selected word.\n4. Execute the PCFG(s) until the error is detected or the observation period has expired.\n5. Record the detection time and goto step 2.\n\nThe error is assumed to be caused by a transient fault and is repaired by rewriting the corrupted word. There are two possible outcomes of an injection: 1) a PCFG detects the error, or 2) the scrubber detects the error. Several terms used throughout this section are now defined.\n\n**Definition 5.1:** An active error, $e_a$, is an error that is detected by the program (i.e. detected by the process of program execution) assuming there is no scrubber.\n\n**Definition 5.2:** The program detection latency is the time from injection to the time the error is detected by the program.\n\n**Definition 5.3:** The scrubber detection latency is the time from injection to the time the error is corrected by the scrubber.\n\n6.3.3 Validation Environment\n\nA Tandem Integrity S2, instrumented with a fault injection and a monitoring device, was used to verify the detection times obtained from the software model. The original C version of the application programs were executed while injecting errors into their text space and measuring the detection times. Figure 6.3 shows the hybrid monitoring environment used to conduct the\nexperiments. A detailed description of the environment can be found in [75, 76]. The hybrid environment takes advantage of the Integrity S2’s ability to re-integrate a failed component of a subsystem on-the-fly. The environment is automated and can execute for days repeatedly injecting errors and collecting measurements. A Tektronix DAS 9200 digital logic analyzer is used to monitor the bus activity on the CPU that is injected with errors. A finite state machine is used to specify the data that is to be collected, such as the times when an injection occurs, the corrupted location is read or written, an exception is raised, and when POST is initiated.\n\nFigure 6.3: An injection environment using hybrid monitoring.\n\nA DAS control program running on a Sun SparcII workstation accepts start, stop and data upload commands from the injection program, translates them, and relays them to the DAS. The injection program runs on the Tandem Integrity S2 machine and injects errors into the text region (the region containing the machine instructions) of a target application. Injecting an error consists of randomly selecting a word, and randomly corrupting one bit of the word residing in the memory of CPUB. If the word resides in the cache, it is deleted to ensure that the corrupted version of the word is used.\n\nFigure 6.4 shows the program used to inject errors and collect data. Each error injected has one of three possible outcomes:\n\n1. The error is detected by the MIPS R3000 (e.g. bus error, address error, arithmetic exception) on CPUB. In this case, CPUB sends an interrupt to the voter. The voter, not receiving interrupts from the other CPUs, shuts down CPUB.\n\n2. The error is detected by the voter. This can happen in two ways. First, all CPUs access global memory, perform I/O or are forced to synchronize at the voter. At this point, the\n1) Start one or more target application program(s).\n2) Start the DAS controller and request it to start the DAS.\n3) Randomly select\n the target application to inject\n the address of the word to be corrupted\n the mask to use.\n4) Inform the DAS of the address of the word corrupted.\n5) Inject the error into the word (flip a single bit).\n6) Wait a specified time or until CPUB is shutdown.\n meanwhile, the DAS records reads, writes, exceptions, POST etc.\n7) If CPUB was not shut down\n shut down CPUB.\n8) Initiate the POST and re-integration process.\n this cleans out any effect of the injection.\n9) Request the DAS controller to upload the data collected by the DAS.\n10) Goto step 3.\n\n**Figure 6.4:** Program used to inject errors and obtain measurements.\n\nvoter detects a discrepancy in the command or the data submitted by CPUB. Second, the injection causes only CPUB to erroneously access global memory or perform I/O. The voter detects the discrepancy and shuts down CPUB.\n\n3. The error is not detected by either detection scheme and is eventually corrected by the memory scrubber.\n\nThe behavior of the detection process and the measurements obtained should not be construed to be purely characteristic of the Tandem Integrity S2 because it uses the error detection mechanism of the MIPS R3000—a commercially available RISC processor. However, because of the additional detection circuitry of the Integrity S2, the error detection coverage will be larger and the error latency times will be smaller.\n\n**6.3.4 Program Detection Latency**\n\nExperiments are initially conducted with the Gauss PCFG to determine if the high level abstraction can provide program detection latency times similar to those observed by the real program executing on the Integrity S2. Three different detection models, obtained by changing the parameters of the detection function (see Equation 6.1), are used. The specific parameters and the names of the detection models are listed in Table 6.1. Parameter $\\rho_I$ was selected so\nTable 6.1: Parameters for the three low level error detection models.\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>$\\rho_t$</th>\n<th>$\\nu$</th>\n<th>LIMIT</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SIM1</td>\n<td>0.67</td>\n<td>1.0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>SIM2</td>\n<td>0.425</td>\n<td>1.0</td>\n<td>2</td>\n</tr>\n<tr>\n<td>EXP</td>\n<td>0.589</td>\n<td>$1/3$</td>\n<td>2</td>\n</tr>\n</tbody>\n</table>\n\nthat $D$ (Equation 6.1) is 0.67\\(^4\\), and it is assumed to be the same for all nodes in the PCFG. SIM1 detects errors on the first encounter only. SIM2 detects errors on second encounters but it uses the same value of $\\rho_t$ on each encounter because $\\nu$ is one. EXP reduces $\\rho_t$ exponentially with each encounter. There are two components to program detection latency: the *access time* and the *detection time*. The *access time* is the time from injection to the time the corrupted location is first accessed by the program. The *detection time* is the time from the first access of the corrupted location to the time the error is detected. In the model, the time to traverse the PCFG until the corrupted location is accessed is the access times. The detection model is used to capture the detection time and the probability of detection. Since the access times are orders of magnitude greater than the detection times, errors that are detected immediately after being accessed are assumed to be detected in zero time. Detection models SIM2 and EXP are designed to capture the cases where the detection times are large.\n\nOne thousand errors are injected into an executing PCFG to obtain program detection latency times. Figure 6.5 shows the cumulative distribution functions (CDF) of the measured and simulated program detection latency. The figure also contains the CDFs obtained from using two distributions that estimate the spatial distribution of the memory accesses [47]. One is the uniform distribution where all addresses are accessed with equal probability. The other is a ramp distribution where the probability of accessing an address increases as the order of the address increases. That is, high-order addresses are more likely to be accessed than low-order addresses. The graph shows that the uniform and ramp functions, which do not model the control flow of the program, fail to capture the spatial locality exhibited by the program. In the measured CDF over half the detection times are less than a second whereas the 50th percentile\n\n\\(^4\\) $D = 0.67$ was determined from measurements, however, later it is shown that $D$ (which is a function of $\\rho_t$) is not the dominant factor in determining latency times.\nfor Ramp and Uniform is approximately 18 seconds. The three functions which model the program's control flow captures the program detection latency distribution remarkably well.\n\nFigure 6.6b is a histogram of the measured error latency times for Gauss. The spike near the origin results because of the structure of the program and because most errors, when encountered, are detected within milliseconds. Most of the time in Gauss is spent in loops where a set of instructions are executed repeatedly. Errors injected in the body of a loop containing the program counter (PC) will normally have small access times. These errors account for more than 50% of all the errors. Errors injected outside a loop containing the PC will have access times that are at least as large as the time needed for one iteration of the loop (Figure 6.7). The actual access time will depend on the number of times the loop will be executed. These errors account for much of the tail in Figure 6.6b.\n\nA close scrutiny of the measured data shows that many errors are not detected immediately after they are accessed. Figure 6.8 is a probability distribution function of the detection time for Gauss. Though a large percent are detected within a few microseconds, a good segment (10%) have detection times that are greater than 100 milliseconds. Furthermore, Figure 6.9 shows the frequency count of the number of multiple read accesses of the corrupted instructions.\nFigure 6.6: Histogram of the program detection latency in seconds, for 1 program.\n\nFigure 6.7: Access time depends on location of the PC and the error.\nprior to detection. The cause for this behavior is probably due to data dependencies. For instance, if the instruction \\texttt{bgt r5, 0x4000} is corrupted and becomes \\texttt{bgt r7, 0x4000}, the error may not be detected if the contents of register r7 is greater than zero. On a later access, the value of r7 may be less than zero, thus potentially causing an error. The other reason is that the error propagates and is eventually detected while executing some other instruction. The software model does not directly model this later phenomenon. However, it models the multiple read phenomenon with error detection models which detect errors on a second, third or more access. The time to re-access the corrupted location is determined by traversing the PCFG and is the detection time. Note that the probability of detection tends to reduce exponentially with increasing number of read accesses (Figure 6.9). Of the detection models, only EXP mimics this behavior. SIM1 detects errors only on the first access. SIM2 overestimates the number of errors detected because it does not reduce the probability of detection with increasing accesses. The value of $\\nu = 0.33$ for EXP was obtained experimentally. Repeated trials with various values were tried and a value of 0.33 was found to produce the most accurate representation of the measured behavior. Comparison of Figure 6.6a and 6.6b, shows that EXP captures the error latency distribution very well. It even captures the tail of the latency distribution. Results of a statistical verification of the detection models are shown in Table 6.2. The table lists the mean and standard deviation of the error latency distribution and the sum of the square of the\nresiduals, $R$,\n\n$$R = \\sum (y_i - \\hat{y}_i)^2$$\n\nwhere,\n\n- $y_i$ is the $i$th entry from the measured CDF\n- $\\hat{y}_i$ is the $i$th entry from the simulated CDF\n\nfor all detection models and for the Ramp and Uniform methods. Of all the models, EXP produces $R$ values that are 3 to 350 times smaller.\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Mean</th>\n<th>Std.</th>\n<th>$R$</th>\n<th>Normalized $R$ w.r.t. EXP</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SIM1</td>\n<td>6.9</td>\n<td>10.2</td>\n<td>0.066</td>\n<td>3.00</td>\n</tr>\n<tr>\n<td>SIM2</td>\n<td>11.7</td>\n<td>17.36</td>\n<td>0.345</td>\n<td>15.68</td>\n</tr>\n<tr>\n<td>EXP</td>\n<td>9.1</td>\n<td>12.74</td>\n<td>0.022</td>\n<td>1.0</td>\n</tr>\n<tr>\n<td>MEASURED</td>\n<td>8.8</td>\n<td>12.55</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Uniform</td>\n<td>37.64</td>\n<td>34.68</td>\n<td>7.58</td>\n<td>344.55</td>\n</tr>\n<tr>\n<td>Ramp</td>\n<td>37.13</td>\n<td>39.73</td>\n<td>5.68</td>\n<td>258.18</td>\n</tr>\n</tbody>\n</table>\n\n**Table 6.2:** Statistics of the measured and simulated program detection latency for the Gaussian elimination program.\nThe software model was used to execute two PCFGs to obtain their combined detection latency times. Figure 6.10 contains the measured and simulated latency times of two copies of the Gaussian elimination program executing simultaneously. The two means are similar and demonstrates that the model can predict the change in latency times due to the increased contention at the CPU.\n\n6.3.4.1 Applicability of the Model\n\nThe previous subsection demonstrates that the software model can be used to determine the program detection latency time for the Gaussian elimination program. The question is can this same model be applied to different programs? One issue is the parameter $\\rho_t$. It varies with the system and is very dependent on the structure of the program. For example, programs with many branches that are seldom traversed will tend to have a smaller value for $\\rho_t$. Though the PCFG of a program can be used to estimate $\\rho_t$, it is useful to determine the sensitivity of the results of the model with respect to $\\rho_t$. If the model is highly sensitive to the estimated $\\rho_t$, it will not be generally useful. Another issue is the detection model. It is not clear that the same detection model will hold for all program types.\n\nTo determine the sensitivity of the results to $\\rho_t$, the Gaussian elimination PCFG was executed with various values of $\\rho_t$. Table 6.3 contains the mean and standard deviation of the program’s detection latency and the $R$-values for varying values of $\\rho_t$. The EXP detection\nTable 6.3: Sensitivity of the mean detection latency time to varying values of $\\rho_t$ (LIMIT = 5).\n\n<table>\n<thead>\n<tr>\n<th>$\\rho_t$</th>\n<th>Mean</th>\n<th>Std. Dev.</th>\n<th>$R$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0.2</td>\n<td>12.42</td>\n<td>21.7</td>\n<td>0.071</td>\n</tr>\n<tr>\n<td>0.4</td>\n<td>11.40</td>\n<td>19.6</td>\n<td>0.047</td>\n</tr>\n<tr>\n<td>0.6</td>\n<td>10.02</td>\n<td>16.79</td>\n<td>0.021</td>\n</tr>\n<tr>\n<td>0.8</td>\n<td>8.83</td>\n<td>14.14</td>\n<td>0.014</td>\n</tr>\n<tr>\n<td>1.0</td>\n<td>7.41</td>\n<td>10.4</td>\n<td>0.018</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.4: Parameters for the low level error detection models.\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>$\\rho_t$</th>\n<th>$\\nu$</th>\n<th>LIMIT</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SIM1</td>\n<td>0.60</td>\n<td>1.0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>SIM2</td>\n<td>0.26</td>\n<td>1.0</td>\n<td>3</td>\n</tr>\n<tr>\n<td>EXP</td>\n<td>0.42</td>\n<td>1/3</td>\n<td>3</td>\n</tr>\n</tbody>\n</table>\n\nmodel with LIMIT set to 5 was used. Very large values for LIMIT tend to skew the mean and produce the worst case results. The table shows that the relationship between $\\rho_t$ and the mean latency is linear. The $R$-value also displays an inverse linear relationship and indicates that the distribution generated by the model fits the measured distribution well. For all values of $\\rho_t$ except 0.2, the $R$-value is less than that produced with SIM1 and SIM2 (Table 6.2).\n\nTo determine whether the detection model developed for Gauss can be applied to other programs, it is used to model an insertion sort program. The sort program was selected because it operates on integers, does not use the floating point co-processor, and hence is quite different from Gauss. An arbitrary value of $D = 0.6$ is used for all the nodes in the sort's PCFG. For comparison purposes, detection models SIM1 and SIM2 are also used. The parameters for all three detection models are listed in Table 6.4. Table 6.5 lists the mean and standard deviation of the error latency distribution and the $R$ values for each detection model, and Figure 6.11 contains the measured and simulated cumulative distribution functions. Again, EXP produced relatively more accurate results both with respect to the mean and the overall latency distribution. But more importantly, the Table and the Figure indicate that the model can be generally applied to other programs. Figure 6.12, which shows the measured frequency of multiple reads before detection, explains why EXP works well with sort. Sort displays a behavior similar to that seen with Gauss. Based on only two programs, one cannot state as\nTable 6.5: Statistics of the measured and simulated program detection latency for Sort.\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Mean</th>\n<th>Std.</th>\n<th>$R$</th>\n<th>Normalized $R$ w.r.t. EXP</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SIM1</td>\n<td>9.6</td>\n<td>11.72</td>\n<td>0.073</td>\n<td>1.20</td>\n</tr>\n<tr>\n<td>SIM2</td>\n<td>11.1</td>\n<td>17.12</td>\n<td>0.128</td>\n<td>2.13</td>\n</tr>\n<tr>\n<td>EXP</td>\n<td>10.42</td>\n<td>14.05</td>\n<td>0.061</td>\n<td>1.0</td>\n</tr>\n<tr>\n<td>MEASURED</td>\n<td>10.67</td>\n<td>11.93</td>\n<td>-</td>\n<td>-</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.5: Statistics of the measured and simulated program detection latency for Sort.\n\nFigure 6.11: Measured and simulated cumulative detection latency distribution functions.\n\nfact that all programs will display such behavior thus making the EXP detection model widely applicable. However, given that the two programs are very different in structure and in the types of data they process, one can conjecture that for RISC machines, similar behavior will be seen across a large number of programs. We say this because with RISC's limited instruction set, the instruction mix for different programs are remarkably similar. In [76], the author lists the frequency of occurrence of each instruction of the Gaussian elimination program and a program that finds anagrams in a large string of characters. The instruction mix for these very different programs are quite similar.\n\nThe next subsection will use the Gaussian elimination PCFG to analyze two scrubbing mechanisms.\n6.3.5 Coverage of the Memory Scrubber\n\nThis section defines and computes the active coverage of the scrubber. The scrubber coverage, $SC$, is:\n\n$$SC = Pr[e_a]Pr[S_l < P_l] + (1 - Pr[e_a])$$\n\nThe scrubber's active coverage is $Pr[S_l < P_l]$, and is the probability that the scrubber will detect an active error before the program. $S_l$ is a random variable denoting the detection latency of the scrubber. $P_l$ is a random variable denoting the detection latency of the program.\n\nEmphasis is placed on the active coverage because active errors not caught by the scrubber cause a processor board to be shutdown followed by a lengthy POST and re-integration period. This time is a “window of vulnerability” within which a second error (whether active or not) will cause the entire system to fail. Increasing the active coverage of the scrubber will reduce the probability of processor board failures and increase the reliability and availability of the system.\n\nThe latency distribution of the scrubber, $f_{S_l}(s)$, can be shown to be uniformly distributed, $f_{S_l}(s) = 1/T$, $0 \\leq s \\leq T$, where $T$ is the time required to complete one sweep through the memory. If $f_{P_l}(p)$ is the distribution of the program's detection latency, then the joint distribution\nTable 6.6: The active coverage of the scrubber.\n\n<table>\n<thead>\n<tr>\n<th>No. Programs</th>\n<th>( Pr[S_t < P_t] )</th>\n<th>Simulation</th>\n<th>( E[P_t]/T )</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>0.0025</td>\n<td>0.00246</td>\n<td></td>\n</tr>\n<tr>\n<td>2</td>\n<td>0.005</td>\n<td>0.0048</td>\n<td></td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.009</td>\n<td>0.0087</td>\n<td></td>\n</tr>\n<tr>\n<td>8</td>\n<td>0.016</td>\n<td>0.0165</td>\n<td></td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.032</td>\n<td>0.0325</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nof the two detection latencies is \\( f_{SP}(s, p) = f_{Pt}(p)/T \\), by stochastic independence and:\n\n\\[\nPr[S_t < P_t] = \\int_{p=0}^{T} \\int_{s=0}^{p} f_{SP}(s, p) \\, ds \\, dp + \\int_{p=T}^{\\infty} \\int_{s=0}^{T} f_{SP}(s, p) \\, ds \\, dp\n\\]\n\nFor \\( T \\) much larger than the mean program detection latency time, the approximate active coverage is:\n\n\\[\nPr[S_t < P_t] \\approx \\frac{E[P_t]}{T}\n\\]\n\nOne hundred thousand errors were injected to determine the active coverage of the scrubber for \\( T = 3600 \\) seconds. Table 6.6 contains the results obtained with simulation and with Equation 6.3. Equation 6.3 provides accurate active coverage values for large \\( T \\). Hypothesis testing was used to show that the means in column 2 and 3 are statistically identical. By the Central Limit Theorem, a normal distribution was assumed. Table 6.6 shows that the active coverage is extremely small. It improves with increasing number of programs because the combined program detection latency times increase.\n\nThe coverage of the scrubber can be improved by using two scrubbers: one to scrub only unused memory while another scrubs the allocated pages in memory. This heuristic can be implemented easily because the memory system keeps track of allocated and unallocated pages. The overhead of the original scrubbing scheme is:\n\n\\[\nOVHD_{old} = Nk/T\n\\]\n\nwhere, \\( N \\) is the number of 32-byte blocks in the memory and \\( k \\) is the overhead for scrubbing one block. The overhead per hour, for \\( T = 3600 \\) seconds is approximately 1.5 seconds. The\noverhead of the new scrubbing scheme is:\n\n$$OVHD_{new} = k(N_u/T_u + N_a/T_a)$$ (6.4)\n\nwhere, \\(N_u\\) is the number of unallocated 32-byte blocks, \\(N_a\\) is the number of allocated blocks, and \\(N = N_u + N_a\\). \\(T_u\\) and \\(T_a\\) are the scrubber sweep times for the unallocated and allocated pages, respectively. Table 6.7 contains the active coverage of the new scrubber for various overheads, with \\(T_u = 4T\\). \\(T_a\\) is determined from Equation 6.4 for a specified overhead. The executable image of one Gaussian elimination program is 32KB (\\(N_a = 1K\\) blocks). The new scrubber improves the active coverage by one or two orders of magnitude without increasing the overhead. However, since \\(T_u\\) is four times slower than \\(T\\), the impact of the two scrubbers on system dependability should be evaluated before one is selected.\n\nSince the dominant factor of the new scrubber is \\(T_a\\), Equation 6.2 can provide an approximate active coverage if \\(f_{P_1}(p)\\) is known. A statistical package was used to fit the measured program detection latency shown in Figure 6.6b with a 2-phase hyperexponential distribution, \\(HYPER(\\alpha_1, \\lambda_1, \\alpha_2, \\lambda_2)\\). The fitted curve is \\(HYPER(0.5, 0.045, 0.5, 5.435)\\) with an \\(r^2\\) value of 0.99. Using the 2-phase hyperexponential and substituting \\(T_a\\) for \\(T\\) in equation 6.2, the active coverage is:\n\n$$Pr[S_t < P_t] = \\alpha_1(\\frac{1}{T_a\\lambda_1} - \\frac{e^{-\\lambda_1T_s}}{T\\lambda_1}) + \\alpha_2(\\frac{1}{T\\lambda_2} - \\frac{e^{-\\lambda_2T}}{T\\lambda_2})$$ (6.5)\n\nTable 6.8 contains the \\(T_a\\) values and the coverage estimated with the above equation. The results match those shown in column 2 of Table 6.7 well and verify Equation 6.5.\n\nTo show the impact of using simple estimations of application behavior, we compute the active coverage using the ramp function. We also compute the active coverage assuming \\(f_{P_1}(p)\\) is exponentially distributed with a mean of 8.8 seconds (the measured mean for 1 program).\nTable 6.8: The estimated active coverage of the new scrubber for one program using a fitted \\( f_R(p) \\).\n\n<table>\n<thead>\n<tr>\n<th>( OVHD_{\\text{new}} / ) ( OVHD_{\\text{old}} )</th>\n<th>( T_a ) (sec.)</th>\n<th>Estimated Active Coverage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>19.62</td>\n<td>0.34</td>\n</tr>\n<tr>\n<td>2</td>\n<td>8.41</td>\n<td>0.43</td>\n</tr>\n<tr>\n<td>4</td>\n<td>3.93</td>\n<td>0.48</td>\n</tr>\n<tr>\n<td>8</td>\n<td>1.90</td>\n<td>0.53</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.935</td>\n<td>0.59</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.9: Active coverage of the new scrubber using ramp and an exponential detection latency distribution.\n\n<table>\n<thead>\n<tr>\n<th>( OVHD_{\\text{new}} / ) ( OVHD_{\\text{old}} )</th>\n<th>Ramp</th>\n<th>Exponential</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Cvrg.</td>\n<td>% Error</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0.70</td>\n<td>112.1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>0.85</td>\n<td>107.3</td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.93</td>\n<td>106.6</td>\n</tr>\n<tr>\n<td>8</td>\n<td>0.97</td>\n<td>90.2</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.99</td>\n<td>62.3</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.9 contains the coverages obtained. The error column compares the difference in coverage with those obtained using the software model (column 2 of table 6.7). The error is due to an overestimation of the number of large detection latency times. Figure 6.5 shows that over half of the measured detection times are less than a second, whereas the 50th percentile for ramp is approximately 18 seconds. The coverages are very misleading. Furthermore, they can produce extremely optimistic dependability figures causing the designers to falsely assume that dependability specifications are being met. These results emphasize the importance of application dependent evaluation - especially when studying application specific systems.\n\n6.4 Summary\n\nIn this chapter, we introduced a software model that provides a framework to evaluate the behavior and effect of software on hardware faults. The model represents application programs by decomposing them into graph models consisting of a set of nodes, a set of edges that prob-\nabilistically determine the flow from node to node, and a mapping of the nodes to memory. The software model simulates the execution of the programs while errors are injected into their memory space. The result provides application dependent parameters such as detection and propagation times. The model is especially useful in the early design stages because it allows designers to make application dependent evaluation of function and system level error detection and recovery schemes. One use of the model was illustrated with a case study. The model was used to obtain error detection latency times of the Gauss and sort programs running on a Tandem Integrity S2 system and evaluate the coverage of two memory scrubbing schemes. The applicability of the model for different programs was evaluated by studying its sensitivity to the detection parameter $\\rho_t$. The EXP detection model was shown to be applicable to both Gauss and Sort which use different instruction sets. We feel that this model is generally applicable to most compute bound programs running on RISC processors. Error detection latency times obtained with the model were validated with measurements from an actual Integrity S2 system. Formulae which were derived to estimate application dependent active coverage values of the scrubbing schemes were verified with the software model. The application dependent coverage values obtained with the model were compared with those obtained via traditional schemes that assume uniform or ramp memory access patterns. For our program, some coverage values obtained using the traditional approach were found to be 100% larger than those obtained with the software model. This result emphasizes the need for application dependent evaluation - especially when evaluating the dependability of application specific systems.\nChapter 7\n\nSimulation Acceleration\n\nThe previous chapter evaluates the impact of application software running on a single processor. The question is how can the study be extended to perform application specific dependability analysis of the entire system? A naive approach that models the execution of each PCFG over a simulated period of several years would require astronomically large execution times. Clearly, acceleration techniques are necessary to speedup the simulation. This is especially the case for functional simulation tools such as DEPEND because one of its advantages is the ability to simulate system functionality with detailed algorithms. How you evaluate detailed simulations of systems for extended periods of time is the focus of this chapter.\n\nThis chapter presents acceleration techniques used to reduce simulation execution time while still allowing detailed analysis of a system. A combination of hierarchical, time acceleration, and hybrid simulation is used. The overall approach is discussed and then illustrated in stages. The results of each stage are then validated, either with measurements from the Integrity S2 or with simulations that do not use the acceleration technique. The automated environment that allows the user to employ this acceleration facility is described in Appendix A.\n\n7.1 Acceleration Approach\n\nThe acceleration technique uses a combination of three schemes to provide simulation speedup. It uses hierarchical simulation, a time acceleration algorithm, and hybrid simulation. Because the terms hierarchical simulation and hybrid simulation have been widely used to mean different things, we now define how the terms are used in this thesis. By hierarchical simulation, we mean\nthat the same simulation approach is used to model a system at different levels of abstraction. Results from a detailed model are used by a more abstract model thus tying the two together. With *hybrid simulation* the level of abstraction remains the same but a combination of two or more techniques are used to solve the simulation model. In DEPEND, a functional simulation is either combined with a Monte Carlo simulation [40, 28] or with a Markov or Semi-Markov model [70]. Existing Markov analysis tools are used to solve the Markov model. While many define Monte Carlo simulation to be *any* kind of simulation that uses random numbers, we differentiate between functional simulation and Monte Carlo simulation. In the latter approach, the passage of time does not play a substantive role [40].\n\nThe general framework of the acceleration technique is illustrated in Figure 7.1. Portions of the system are first analyzed with detailed functional simulation models. Key characteristics of the models are extracted and stored as statistical models. A statistical model can be a point statistic such as a mean or a median, an entire distribution such as the program detection latency distribution, or it can be a table. A fault dictionary is an example of a table. A fault dictionary may consist of a list of possible gate-level faults and for each fault contain all possible failure modes and their probabilities. The statistical models are used by more abstract functional simulation models to represent the behavior of the detailed model. As Figure 7.1 shows, the hierarchical approach can be used repeatedly to ascend to higher levels of abstraction. Simulation speedup is achieved because the events in the detailed model are not simulated but are replaced with its statistical model. This allows the abstract model to simulate more of the system while maintaining reasonable execution times.\n\nThe time acceleration technique is intimately entwined with the hierarchical simulation approach. It is based on the notion that a statistical model provides information about a future event. For instance, if the statistical model is a *program detection latency* distribution, then the time at which an error will be detected, \\( t + z \\), can be determined by sampling from the distribution at time, \\( t \\), when the error is injected. Using this information, the time acceleration technique can leap to a point just before time \\( t + z \\) and begin to simulate the detailed behavior of a system. Once the error is detected and its effect has subsided, the time acceleration mechanism can leap forward to the next error detection (Figure 7.2). This approach can significantly speedup simulation time, especially if the events representing the detailed behavior occur in nanoseconds while error latency times are in seconds.\nThe foundation of the hybrid simulation approach is based on the notion of variable aggregation and decomposability [13]. With this technique, a large complex model is broken down into simpler submodels. The submodels are analyzed individually and their results are combined to derive the solution of the entire system. So long as the interactions among the subsystems are weak, this approach provides valid results. Figure 7.3 illustrates how this approach is readily adapted for dependability evaluation. A model of a system is broken down into two submodels: the failure occurrence submodel and the repair submodel. Each submodel is modeled with a functional simulation – which can itself use hierarchical simulation and time acceleration. The submodel is executed to extract statistical models (e.g. a failure distribution) that represent its behavior. The statistical models are then used to drive a Continuous Time Markov Chain (CTMC) or a simple Monte Carlo simulation of the failure and repair process of the entire system. The approach is not limited to any number or type of submodels. As Figure 7.1 shows.\n\nFigure 7.1: The framework of the acceleration technique.\nall three approaches can be combined to cater to the specific needs of the user. The automation of the acceleration technique is discussed in Appendix A.\n\nThere has been extensive investigation into importance sampling to reduce simulation time [41, 50, 62, 72]. Importance sampling is a statistical approach that increases the probability of failure occurrences to reduce the time required for the simulation to converge. The results produced by the simulation are then \"unskewed\" by multiplying by a factor that takes into account the increased failure probability. These heuristics are easiest to apply to Monte Carlo simulations as opposed to functional simulations, and their estimation of stationary measures (e.g. MTTF and availability) are mostly restricted to regenerative models. Hybrid techniques have been used in the past. Schwetman [59] applies this technique to analyze a multiprogramming computing center. A simulation models the arrival and activation of jobs and calculates the percentage of time spent at each multiprogramming level. A central-server queueing network is used to model the processing subsystem for each of the multiprogramming levels. The hybrid model is 18 to 200 times faster than a pure simulation model because it does not simulate the system processor in which events occur in the order of milliseconds. In other words, speed up is achieved by replacing the time consuming segment of the model with an approximate analytical model. The most prominent example of the use of hybrid techniques in reliability analysis is the HARP tool [4]. HARP decomposes a model into a fault occurrence/repair model (FORM) and one or more fault/error-handling models (FEHM). The FEHMs are simulated with an extended stochastic Petri Net (ESPN) to obtain instantaneous coverage probabilities.\nThese probabilities are then automatically incorporated into the FORM model, represented by a CTMC, and solved to obtain system reliability measures.\n\nOur acceleration technique differs from the others in that it does not rely solely on analytical models to achieve speedup. Schwetman replaces the time consuming portion of the simulation with an analytical approximation. HARP imposes a Markov or semi-Markov fault occurrence process which can only use instantaneous coverage probabilities. These techniques are not widely applicable. Our acceleration technique is more widely applicable and concurs with the design philosophy of DEPEND. The acceleration approach can be used with functional simulation. It is not limited to statistical models consisting of single point statistics but is designed to collect distributions and tables. Later in the chapter, we show that this can be crucial to the results obtained. Since the approach breaks down an entire functional simulation model into smaller submodels, importance sampling techniques that may be impossible to apply to the entire model may be readily applied to the submodels. Finally, this is the first automated, general-purpose acceleration technique provided with a simulation tool.\n\nIn the rest of the chapter, the details of the acceleration approach is illustrated in stages. The results at each stage are verified with measurements.\n7.2 Stage 1: Hierarchical Simulation and Time Acceleration\n\nTo perform application specific analysis of the Tandem Integrity S2 system, the software simulation model described in chapter 6 and the hardware simulation model described in chapter 5 are combined using hierarchical simulation and time acceleration. The software model is used to provide the application specific error latency distribution. The hardware model provides an error occurrence model that takes advantage of the empirical distribution to speedup simulation. Together, the approach is used to study the effectiveness of the scrubbing scheme and the availability and MTBF of the Tandem Integrity S2 system running a specific application.\n\nThe complete error occurrence process modeled by the hardware simulation, for just two CPUs, is illustrated in Figure 7.4. A similar process is used to inject errors into the global memory. As shown in the figure, the error arrival times are exponentially distributed with a mean of \\( \\lambda \\) hours. The error occurrence process can model correlated errors that affect more than one component, active errors that are detected within 2047 cycles and latent errors that remain undetected in the system for periods exceeding 2047 cycles. For each error injected, probabilistic branches are used to determine whether it is a correlated (affecting more than 1 component) or a single error, and whether it is active or latent. The probabilities are specified at run time. The hardware simulation model uses the approach described in chapter 4 to represent latent errors. It uses a chronologically sorted queue to maintain the latent errors injected into the system. Among the information associated with each latent error include the time at which the error is injected, its location (the component and memory address), and its latency period. Typically, the errors are detected when their latency period expires. However, the errors can also be corrected by the scrubber or detected during a repair. Different scrubbing algorithms, the location in which the errors are injected, and component failure frequency changes the activation times of a latent error. Storing the latent errors in a queue allows dynamic determination of whether a latent error is detected or corrected and the time of detection or correction.\n\nThe latency period of each error is determined from an empirical program detection latency distribution. This distribution is obtained from the software model. The steps in the hierarchical simulation approach are as follows:\n\n- Execute software model with one or more PCFGs.\nFigure 7.4: The error occurrence process for 2 CPUs.\n\n- Store the program detection latency distribution. This is the statistical model that represents the error detection process of the programs.\n\n- Execute the hardware simulation model with the error occurrence process described above. Sample from the empirical program detection latency distribution to determine the latency period of each error.\n\nSpeedup is achieved because the time consuming low level simulation of the detection process of each error is replaced with a distribution. Further speedup is achieved using time acceleration. Time acceleration takes advantage of the fact that the detection time of each latent error is known apriori. The time acceleration algorithm works as follows:\n\n* In addition, all active errors and latent errors are corrected during component re-integration. This also affects the actual per component failure rate.\n1. Poll the processors and global memory to determine time of earliest event among them. There are three possible events:\n • An error's latency period expires.\n • Scrubber corrects an error.\n • Re-integration begins.\n2. Leap forward in time to earliest event.\n3. Simulate system activity at nanosecond granularity until event occurs.\n\nThe DEPEND objects used to simulate the processor and global memory contain methods that provide the time and type of the earliest event to facilitate the time acceleration algorithm.\n\n7.2.1 Validation of the First Stage\n\nTo validate the combined functional simulation model developed using hierarchical simulation and time acceleration, the results from the simulation are compared with those from a fault injection experiment on the Integrity S2. The hybrid monitoring environment described in chapter 6 is used to conduct the fault injection experiments. Two Gauss programs are used as the target applications. Figure 7.5 shows the injection program that was executed to obtain the measured mean time between failures (MTBF) for the Integrity S2. The injection experiment was conducted for 28 hours during which 414 errors were injected. The mean time between failure (MTBF) and the number of undetected, latent errors present in CPUB just prior to shutdown \\(^1\\) was collected. The experiment was then repeated with the functional simulation model just described. The simulation injection scenario is identical to that outlined in Figure 7.5. As in the hybrid monitoring system, the simulation model injected errors only into CPUB. The model was executed for a simulated time period of 500,000 seconds (5.78 days) with an exponential error arrival rate with a mean of 3 minutes. Figure 7.6 shows the measured and simulated CPU shutdown distributions and their means, medians, standard deviations and the sample counts. The means, medians and the standard deviations are statistically identical.\n\n\\(^1\\)This is simply a count of the number of errors injected prior to a CPU shutdown. So if four errors are injected before a shutdown, it is assumed that there are three undetected errors in the CPU prior to a shutdown.\n1) Start the two Gaussian elimination workload programs.\n2) Start the DAS controller and request it to start the DAS.\n3) Randomly select\n the program to inject\n the address of the word to be corrupted\n the mask to use.\n4) Inform the DAS of the address of the word corrupted.\n5) Inject the error into the word (flip a single bit).\n6) Determine time of next error, $t (\\exp(\\lambda = 3\\text{minutes})).$\n7) Wait for CPU shutdown or until $t - \\text{whichever comes first}.$\n8) If (CPU is shutdown before $t$ elapses)\n re-integrate the CPU\n sleep until $t$ elapses\n9) Goto step 3.\n\n**Figure 7.5:** Injection program used to measure the MTBF.\n\nComparing the distributions, the general shape of both distributions is similar in spite of the fact that the measured distribution has 5 times fewer samples. A closer look at the two distributions reveal that many of the peaks in the measured distribution can also be found in the distribution obtained from simulation. For example, the simulated distribution captures the peaks which occur between 640 and 960 seconds and between 960 and 1280 seconds. Figure 7.7 contains the measured and simulated distributions of the number of undetected, latent errors in the CPU at the time of a shutdown. The distribution obtained from the simulation model tracks the one obtained from measurement very well. We feel this close correspondence between the measured and simulated results validates the high fidelity of the simulation model using hierarchical and time acceleration techniques.\n\n### 7.3 Stage 2: Hybrid Simulation\n\nThis section describes the hybrid approach that combines analytical and simulation techniques to reduce the execution time of the functional simulation model described in the previous section. In spite of the use of hierarchical simulation and time acceleration, the simulation execution time can be in the order of days. Certain parameter settings (e.g. frequent scrubbing coupled with large detection latency times) erases most errors injected thus requiring the simulation of a very large number of errors for each system failure. To make matters worse, the\nsystem must be run for extended periods of time to collect enough system failure events to obtain statistically valid results. If the MTBF of a system is 10 years, it may need to be simulated for 300 to 500 years to obtain valid results. Features of the model such as the deterministic scrubbing scheme, modeling the location of each error and the inter-dependence between the system components (see chapter 4), and the non-exponential error latency distributions make this model very difficult, if not impossible, to model accurately with analytical methods. Importance sampling techniques cannot be used because they cannot accurately calculate the steady state MTBF (Mean Time Between Failures) for non-regenerative processes [50].\n\nThe hybrid approach breaks up the simulation model into the failure occurrence and repair submodels. To simplify the example, we will forego developing the repair submodel by assuming that repair coverage is 100% and repair times have an exponential distribution. The failure submodel is the error occurrence portion of the functional simulation model described in the previous section (see Figure 7.4). The functional simulation model is executed for a short time to collect component inter-failure times – the time period between successive failures. This is feasible because the component failure rate is significantly faster than the system failure rate, and so a large number of samples can be collected in a short period of time. The measured failure distributions and the repair distributions are then used with CTMC and Monte Carlo simulations which model the failure/repair process of the entire system. The detailed steps of the approach are illustrated in Figure 7.8.\n7.3.1 Markov modeling\n\nIn order to use a CTMC, the measured failure distributions are first fitted with an exponential polynomial. A statistical analysis package, SAS [57], is used for curve fitting. The chi-square and Kolmogorov-Smirnov tests [70] are used to verify the goodness of the fit at the 0.01 significance level. The CTMC models used for the failure/repair process will depend on the fitted polynomials. If they are simple exponentials, the result is the CTMC model shown in Figure 7.9.\n\nIn the model, 0c0g is the initial state where zero processors and zero global memory boards have failed. In state 1c1g, 1 processor and 1 global memory board has failed etc. State F is the absorbing system failure state. The rates $\\lambda_\\chi$ and $\\lambda_\\gamma$ are the empirical failure rates for the processors and the global memory, respectively. Exponential repair times with means (1/$\\mu_\\chi$ and 1/$\\mu_\\gamma$) equal to the constant repair times of the system are used in the model. This CTMC can be solved with any existing analytical tool to obtain the system MTBF. The models in this paper are solved using SHARPE [54].\n\n7.3.2 Monte Carlo simulation\n\nWith Monte Carlo simulation [28], the empirical failure distributions can be used directly without any fitting. Monte Carlo simulation is useful when the empirical distributions cannot\nbe fitted to an analytical distribution, when the state space of the CTMC model is too large to be solved with current numerical methods and when the distributions are not exponential. Monte Carlo simulation was used to simulate the Markov model in Figure 7.9. The failure times of the components are sampled from the empirical failure distributions using an inverse-transform method [40]. The constant repair times used in the functional simulation are used with the Monte Carlo simulation also. To further reduce the execution times of the Monte Carlo simulations, a variance reduction technique called antithetic variates was employed [28, 40].\n\nThe success of the hybrid approach for this application depends on, 1) the degree of interaction between the failure process and the repair process, and 2) on whether the failure distributions adequately represent the failure process. The repair process has minimal impact on the failure process. Therefore, the primary issue is whether the distributions collected adequately represent the actual failure process.\n7.3.3 Validation of the Hybrid Approach\n\nThree experiments are conducted using the hybrid approaches to verify their efficiency and validate their accuracy. The results obtained using the hybrid techniques are compared with results obtained from executing the functional simulation model described in the previous section. Parameters are chosen so that the execution times of the functional simulation times are reasonable. To further speedup the functional simulation model, the empirical latency distribution is replaced with a normal distribution. This was done because sampling from an empirical distribution is relatively expensive requiring a binary search of the entire distribution file for each sample produced.\n\nIn the first experiment, a normally distributed error latency with a mean of 44 minutes and a standard deviation of 29 minutes ($N(44, 29)\\text{min.}$) was used. Two percent of the errors injected were correlated, and memory scrubbing was not activated. The second experiment uses the same parameters, except hourly scrubbing is activated. The third experiment evaluates the functional model with two different latency distributions. The first is $N(44, 29)$ minutes and the second is $N(36, 18)$ hours. Correlated errors are not injected and scrubbing is turned off. All three experiments assume two minutes are required for global memory reintegration, 2 seconds for CPU reintegration and 70 seconds for POST.\n\nThe functional simulation program was retrofitted to extract the inter-failure times of the processors and the global memories. Figure 7.10 shows how CPU inter-failure times are col-\ncollected. Inter-failure times for the global memory are collected in an identical fashion. Note that the failure distributions are collected without distinguishing between the specific components. This approach was used for two reasons. First, it captures the occurrence of near-coincident failures between components. Second, it significantly reduces the state space of the Markov model in Figure 7.14 because there is no need to distinguish between the individual CPUs and memory units.\n\nFor the first experiment, the functional simulation was executed once for a simulated period of 300 years. The program took 40 minutes to complete on a Sun SparcI workstation. Fifty thousand global memory, and 42891 processor inter-failure times were collected using the method illustrated in figure 7.10. Histograms with a range from 0 to 18000 minutes (0 to 12.5 days) were used to group the samples. For the processors, 369 out of 42891 points (0.86%) fell outside this range and were discarded as outliers. For the global memory, 24 out of 50000 (0.06%) were outliers. These points were discarded to simplify the histogramming and curve fitting process. Removing these points should have little or no bearing on the system MTBF, because the impact of a few, large inter-failure times is negligible.\n\nFor the second experiment, the event-driven simulation was executed for 700 years and took approximately 100 minutes to complete. Approximately twenty thousand (20606) global memory and 17,585 CPU inter-error arrival times were collected. The sample data was grouped using histograms with a range from 0 to 575 hours (0 to 24.3 days). Between one and two percent\n\n\\begin{figure}\n\\centering\n\\includegraphics{figure7.10}\n\\caption{Inter-failure times extracted from an execution of the functional simulation.}\n\\end{figure}\nof the sample points fell outside the 575 hour range. For the third experiment one simulation run was executed for a period of 300 years for each error latency distribution.\n\nThe empirical failure density functions \\( f(x) \\) for the processors and memory, for the first experiment, are shown in Figure 7.11. The spikes near the Y-axis are caused by near-coincident errors. The failure density functions for the second experiment are almost identical and are not shown. The only difference is that the spike near the Y-axis is not as pronounced. Hence, in spite of frequent, hourly scrubbing, latent, correlated errors substantially reduce inter-failure times thereby increasing the number of system failures. The empirical failure probability density functions \\( f(x) \\) for the two latency distributions used in the third experiment are shown in Figure 7.12. The functions with the larger latency are particularly interesting. The unique shapes arise because a larger number of the latent errors are corrected when the system crashes or the board in which they reside is re-integrated. Note that the spike characteristic of correlated errors is not visible.\n\nA two-phase hyperexponential distribution \\( \\text{HYPER} (\\alpha_1, \\lambda_1, \\alpha_2, \\lambda_2) \\) [70] was found to fit the measured failure distributions collected from the first two experiments. The probability density function for a two-phase hyperexponential random variable, denoted by\n\n\\[\nf(x) = \\alpha_1 \\lambda_1 e^{-\\lambda_1 t} + \\alpha_2 \\lambda_2 e^{-\\lambda_2 t}\n\\] \n\n(7.1)\nFigure 7.12: Failure density functions for the two error latencies (Experiment 3).\nTable 7.1: Empirical pdfs fitted with hypoexponential pdfs.\n\nFor the first experiment, the fitted hyperexponential failure distributions of the global memories and the processors are $\\text{HYPER}(0.987, 0.00043, 0.013, 0.023)$ and $\\text{HYPER}(0.972, 0.000268, 0.028, 0.027)$, respectively. The fit was tested using both the Chi-square test and the Kolmogorov-Smirnov test at the 0.01 significance level. Graphs of the fitted curves are also shown in Figure 7.11. They are not visible, because they are almost perfectly superimposed on top of the measured curves. The fitted failure distributions for the second experiment are $\\text{HYPER}(0.9936, 0.00013, 0.0064, 0.09)$ and $\\text{HYPER}(0.9849, 0.00017, 0.0151, 0.095)$, for the global memories and the processors. These also passed the Chi-square and the Kolmogorov-Smirnov test at the 0.01 significance level.\n\nIn the third experiment, both a 2-stage hypoexponential and a simple exponential distribution was used for the case with the small error latency distribution. Both resulted in good fits according to the Kolmogorov-Smirnov test and so the simpler exponential distribution is used to represent the failure distribution. The specific fitted distributions are $\\text{EXP}(0.000260)$ and $\\text{EXP}(0.000414)$ for the CPU and the global memory failure distributions, respectively. The failure distributions for the case with the large error latencies could not be fitted with the exponential distribution. The nature of the Markov model for hypoexponential failure distributions required that the single processor and global memory failure distributions be collected. The functional simulation model was re-executed to collect the failure distributions of a single processor and a single global memory board. To collect enough sample points, the simulation was executed for 1200 years. The resulting failure distributions were fitted with 2-, 3- and 4-phase hypoexponential distributions [70]. The pdf for an $r$-phase hypoexponential random variable,\n\n<table>\n<thead>\n<tr>\n<th>Number of Phases</th>\n<th>HYPO($\\lambda_1, \\ldots, \\lambda_r$)</th>\n<th>CPU</th>\n<th>Memory</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2</td>\n<td>0.000128, 0.00273</td>\n<td>0.00299, 0.00301</td>\n<td></td>\n</tr>\n<tr>\n<td>3</td>\n<td>0.000735, 0.000129, 0.0006695</td>\n<td>0.0005367, 0.000535, 0.000611</td>\n<td></td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.0000998, 0.00001181, 0.001010, 0.001546</td>\n<td>0.000481, 0.000539, 0.001326, 0.001342</td>\n<td></td>\n</tr>\n</tbody>\n</table>\ndenoted by \\( \\text{HYPO}(\\lambda_1, \\lambda_2, \\ldots, \\lambda_r) \\) is:\n\n\\[\nf(z) = \\sum_{i=1}^{r} a_i \\lambda_i e^{-\\lambda_i z}\n\\]\n\n(7.2)\n\nwhere\n\n\\[\na_i = \\prod_{j=1, j \\neq i}^{r} \\frac{\\lambda_j}{\\lambda_j - \\lambda_i}\n\\]\n\n(7.3)\n\nThe specific fitted hypoexponential distributions for the single memory and the single processor failure distribution are shown in table 7.1. Only the 4-phased hypoexponential distributions produced a good fit, according to the Kolmogorov-Smirnov test. The empirical failure distributions and the fitted distributions are shown in figure 7.13.\n\nOnce the empirical failure distributions have been collected and fitted they are used with Monte Carlo and Markov models to analyze the entire system.\n\n### 7.3.3.1 Results from Experiments 1 and 2\n\nThe hyperexponential failure distributions for experiments 1 and 2 make the failure process semi-Markov. Using a conversion technique [70], it can be converted to the Markov model shown in Figure 7.14. The Monte Carlo simulation, however, can still simulate the model in Figure 7.9 using hyperexponential sojourn times.\n\nTable 7.2 shows the times taken and the results produced by the original functional simulation and the hybrid approaches. For experiment 1, the functional simulation program, simulated a period of 80 years for each run. For experiment 2, it simulated 120 years in each run. All\nthe results produced by the hybrid models fall within the 99% confidence interval of the results produced with the original functional simulation. The largest deviation between the hybrid models and the functional simulation model is 6.04%. The data in Table 7.2 demonstrates a substantial reduction in execution time in favor of the hybrid models. Even taking into account the time required to generate the empirical distribution, there is more than a 36 time speedup for experiment 2. The actual speedup will vary depending on the parameters of the model and can be much larger.\n\nFigure 7.14: CTMC that models the system with hyperexponential failure distributions.\nTable 7.2: System MTBF obtained with the pure simulation and hybrid approaches.\n\n7.3.3.2 Results from Experiment 3\n\nFor the case with the small error latency distribution (\\(N(44, 29)\\) minutes), the Markov model shown in Figure 7.9 is used to determine the system reliability. The results obtained with the hybrid techniques and the functional simulation are compared in Table 7.3.\n\n<table>\n<thead>\n<tr>\n<th>Method</th>\n<th>Error Latency</th>\n<th>Failure Distribution Type</th>\n<th>99% Confidence Interval (MTBF in years)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Simulation</td>\n<td>(N(44) min., 29 min.)</td>\n<td>-</td>\n<td>7.48 8.28 9.27</td>\n</tr>\n<tr>\n<td></td>\n<td>(N(36) hrs., 18 hrs.)</td>\n<td>-</td>\n<td>14.38 15.68 17.24</td>\n</tr>\n<tr>\n<td>Markov</td>\n<td>(N(44) min., 29 min.)</td>\n<td>Exponential</td>\n<td>- 8.75 -</td>\n</tr>\n<tr>\n<td></td>\n<td>(N(36) hrs., 18 hrs.)</td>\n<td>2-phase HYPO</td>\n<td>- 13.93 -</td>\n</tr>\n</tbody>\n</table>\n\nTable 7.3: System MTBF for the two error latencies (Experiment 3).\n\nThe general stochastic petri net (GSPN) description of the system that models a 2-phase hypoexponential failure distribution is shown in Figure 7.15. Since by definition a 2-phase hypoexponential distribution is the sum of 2 independent exponential distributions, the hypoexponential failure distribution is modeled by adding an extra \\(failing\\) state between the \\(OK\\) and \\(failed\\) states. The GSPN description can be easily extended to model 3- and 4-phase hypoexponential failure distributions by increasing the number of \\(failing\\) states to represent the additional phases. A Markov model equivalent to the GSPN model in Figure 7.15 has 54 states if the failure states are not coalesced. For the TMR system with 3-phase hypoexponential failure distributions, the equivalent Markov model contains nearly 200 states and for the system with 4-phase hypoexponential distributions, the Markov model contains over 500 states. The Sharpe tool was used to solve all three GSPN models. However, due to the rapid growth in the\nnumber of states of the equivalent Markov models, Sharpe was unable to solve the models for the 3- and 4-phase hypoexponential failure distributions. The result obtained with the 2-phase hypoexponential failure distributions is shown in Table 7.3. The result does not fall within the 99% confidence interval because the fitted 2-phase hypoexponential distributions fail to capture the spike and they exaggerate the probability of having small inter-failure times.\n\nThe Monte Carlo program simulates the Markov model in Figure 7.9. Because individual processor and memory failure distributions are not needed, the empirical distributions shown in Figure 7.12 are input to the program. The MTBF figure generated by the Monte Carlo program is 14.8 years and falls within the 99% confidence interval produced by the original simulation.\n\nIn the past, researchers have used point statistics rather than distributions for their statistical models. For detailed functional simulation models of this nature and of the type described in chapter 4, single point statistics may not be representative of the behavior of teh detailed model it replaces. For experiment 1, if the mean inter-failure times are used (implying an exponential distribution) the MTBF is 4.21 years. This is more than double the actual MTBF. This demonstrates the need to consider an entire distribution because it demonstrates that various distributions with identical means can produce significantly different results.\n\nOnce the measured failure distributions have been collected, the hybrid models can be used to evaluate alternative configurations without reverting back to the original functional\n<table>\n<thead>\n<tr>\n<th>Method</th>\n<th>Repair Min.</th>\n<th>99% Conf. Int. MTBF yrs.</th>\n<th>Time</th>\n<th>No. Runs</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<tr>\n<td>Sim.</td>\n<td>5.0</td>\n<td>0.99</td>\n<td>6.75 hrs.</td>\n<td>30</td>\n</tr>\n<tr>\n<td></td>\n<td>10.0</td>\n<td>0.59</td>\n<td>6.75 hrs.</td>\n<td>30</td>\n</tr>\n<tr>\n<td>Monte Carlo</td>\n<td>5.0</td>\n<td>1.09</td>\n<td>30 sec.</td>\n<td>5000</td>\n</tr>\n<tr>\n<td></td>\n<td>10.0</td>\n<td>0.616</td>\n<td>18 sec.</td>\n<td>5000</td>\n</tr>\n<tr>\n<td>Markov Model</td>\n<td>5.0</td>\n<td>-</td>\n<td>8 sec.</td>\n<td>-</td>\n</tr>\n<tr>\n<td></td>\n<td>10.0</td>\n<td>0.60</td>\n<td>8 sec.</td>\n<td>-</td>\n</tr>\n</tbody>\n</table>\n\nTable 7.4: System MTBF for various memory re-integration times.\n\nsimulation. The impact of architectural changes that do not alter the failure distribution, such as different re-integration times, can be evaluated rapidly. Table 7.4 contains results where the global memory re-integration times of 5 minutes and 10 minutes are used. Results obtained directly with the functional simulation are also shown to verify that the hybrid approaches produce valid results.\n\n### 7.4 Discussion\n\nThis chapter presented the acceleration approach provided by DEPEND. The approach, consisting of an unique combination of hierarchical simulation, time acceleration and hybrid simulation, was illustrated in stages. The system evaluated was the Tandem Integrity S2 system. Results of each stage were validated with either measurements from an Integrity S2 or from a functional simulation that does not use the acceleration technique. The results demonstrate that the acceleration technique can produce accurate results at a fraction of the cost. How the approach is automated within DEPEND is described in Appendix A.\n\nThe acceleration approach replaces processes, which are difficult to model analytically and expensive to simulate, with statistical models. For the Integrity S2 application, the statistical models used were failure distributions. However, for different applications, other statistical models may be used. The acceleration approach is particularly attractive if a system is analyzed extensively. Then, the overhead of extracting and fitting distributions can be amortized over the time needed to run various experiments and study alternative configurations. Using hierarchical and hybrid simulation, it is possible to represent a complex, functional simulation (Figures 5.2 & 7.4) with a much simpler, abstract model (Figure 7.9). It is easier to apply variance reduction\ntechniques to this model than the original simulation program. Finally, for extremely large, complex systems, where the complexity of the submodels are significant, this approach can be used recursively on the submodels as well. This chapter illustrated how the approach can be used to include the impact of software under hardware faults when analyzing the entire system. This same approach may be a viable way of including the impact of chip-level design when evaluating system reliability measures.\nChapter 8\n\nAnalysis of the TMR-based System\n\nThe major issues in simulation-based dependability analysis have been discussed and our solutions for them have been presented in the previous chapters. This chapter uses the DEPEND tool, the simulation models described in chapters 5 and 6 along with the acceleration techniques presented in chapter 7 to analyze a Tandem Integrity S2-like machine. The purpose of the study is to investigate issues which include: correlated errors, accurate modeling of correlated errors, latent errors, inter-component dependencies during automatic repair, memory scrubbing heuristics, application specific analysis of scrubbing schemes, impact of repair times, impact of different configurations, and isolation of dependability bottlenecks. The study is conducted in phases to isolate and analyze the impact of factors such as correlation and error latency. In addition, studies that evaluate the combined impact of several of the factors are also conducted. The goal of the study is to determine what error conditions are especially detrimental and what architectural features are especially susceptible to the types of errors injected. This comprehensive study illustrates many of the capabilities of DEPEND in a realistic setting.\n\n8.1 Assumptions and Parameters Used in the Simulations\n\nFor the most part, the studies use a standard set of failure rates, latency distributions and architectural configurations. This section describes the parameters and the assumptions made. When other parameters are used, it will be explicitly stated.\n\nThe error arrival means are based on findings from a measurement-based analysis of real error data collected from a DEC VAXcluster multicomputer system[68]. Tang found that the\nmean time between CPU errors \\(1/\\lambda_{CPU}\\) in the system was 265.8 hours with a standard deviation of 497.6 hours. The mean time between memory errors \\(1/\\lambda_{Memory}\\) was 27.0 hours with a standard deviation of 150.4 hours. The combined error arrival rate is approximately 1 every 24 hours. Of this combined rate, approximately 62% of the errors are injected into the global memory and 38% are injected into the processor board containing the CPUs and the local memories. These numbers are based on the size of the memories (8Mbytes of local memory per board and 32Mbytes of global memory per board) and the contribution of the CPU error arrival rate to the combined error arrival rate. Of course, one cannot assert that the error rate of the Tandem Integrity S2 is similar to that of the VAXcluster. Since the studies are not concerned with absolute reliability figures but rather with the trends and changes to system reliability due to various conditions, this does not pose a problem. An exponential distributed error arrival rate is assumed.\n\nSeveral different error latency distributions are used in the studies. The latency distributions obtained in chapter 6 are used when studying different memory scrubbing schemes and to perform application specific analysis of the system. Otherwise, exponentially distributed error latency distributions with various means are used to analyze trends in system reliability as the latency gradually increases or decreases. Normally distributed latency distributions are also used. In some studies, very large latencies are used and are based on findings from a measurement study of the VAX 11/780 by Chillarege [9]. Chillarege found that error latency is workload dependent. Errors injected at midnight, when the workload was low, had a mean latency of 8 hours with a standard deviation of approximately 4 hours. Errors injected at noon, when the machine was used heavily, had a mean latency of approximately 44 minutes and a standard deviation of 29 minutes. These measured error latencies are approximated by normal distributions with the means and standard deviations just mentioned.\n\nAll errors, including undetected latent errors, residing in a processor or in a global memory are assumed to be corrected when the component undergoes a re-integration, the system is rebooted or when scrubbing takes place – regardless of the number of latent errors residing in the system. Therefore, not all the errors injected are detected and the actual error arrival distribution of detected errors depends on the scrubbing rate, the component re-integration rate, the error latency and the injection rate. Because error latencies and global memory re-integration times are workload dependent, various system workloads are implicitly modeled.\nby varying these parameters. Finally, since we are primarily concerned with transient errors, permanent errors are not injected and the MTBFs presented do not reflect their impact on system reliability. The voters are assumed to be error free. For most studies, the repair coverage, the probability that a failed component will be successfully re-integrated into the system after an error is detected, is assumed to be 1 so long as a second error is not detected before the re-integration is completed.\n\nExcept where explicitly stated, the simulations are executed with a POST time of 60 seconds, a global memory re-integration time of 2 minutes and with memory scrubbing turned off. The mean time between failures (MTBF) is calculated by dividing the simulation period by the average number of system failures. The confidence level for the results shown is 95% for an interval with a relative half-width of 5%. The MTBF figures presented in this paper should not be construed to reflect the MTBF figures of an actual Tandem Integrity $2$ system because the error arrival rate which has a direct bearing on this measure, was not obtained from measurements of the Tandem Integrity $2$.\n\n8.2 Impact of Latent Errors\n\nIn this section, several experiments are conducted to determine the impact of latent errors on the MTBF of the system. Although there have been many studies to measure fault and error latency [9, 45, 63, 66, 74] and most researchers conjecture that latency degrades system reliability, there are very few studies that have actually tried to quantify and determine the impact of latency on the system. In [66], the authors study the effect of latency (which they define to be the sum of fault and error latency) on a TMR flight control system. They derive the probability of system failure as the probability of a second failure that produces the same erroneous output as an earlier, latent error. With both errors triggering at the same time, the voter is fooled and the error escapes and affects the flight control system. A gate-level simulation of one of the processors was injected with faults to determine parameters used in the derivation. Their results show that unless the latency is very large, the effect of latency on system reliability is very small.\n\nIn this study, we analyze the impact of the accumulation of latent errors in the system. If there are a large number of latent errors in the processor boards, is the probability of a\nnear-coincident error increased? The study also considers the inter-dependencies due to latent errors. In the Integrity S2, a latent error in a healthy CPU that is detected during re-integration will cause the system to fail. Latent errors can also propagate creating more errors, however, this effect is not considered in this study.\n\nIn the first experiment, the effect of an accumulation of latent errors is investigated. Errors are injected into the system at a rate of one error a day. Exponential and normal latency distributions with various means are tried to determine if there is a trend in system MTBF. For the normal distributions, the standard deviation is always half the mean. Table 8.1 presents the results of the simulation. The MTBF for the case in which the latency is zero is 6.76 (±0.32) years. The table indicates that the MTBFs for all the latency distributions produce results similar to the case when there is no error latency. This is due to two factors. First, because the error latency is much smaller than the error arrival rate, there is not a substantial accumulation of errors. Second, the detection of any error in a processor and the ensuing re-integration erases all other latent errors in the processor thus further reducing the accumulation of latent errors. The table also shows that the specific distribution of the latency times, whether normal or exponential, does not affect system MTBF.\n\nTo increase the accumulation of latent errors, two system\\(^1\\) error arrival rates are tried: one error every 30 minutes and one error every 5 minutes. The effect on system MTBF, for exponential latency distribution times, is shown in Table 8.2. Detailed analysis of the simulation output files shows that the number of accumulated error in a processor or global memory increases, however, it still fails to reduce system MTBF. On the contrary, the system\n\n\\(\\text{Table 8.1: System MTBF for two latency distributions with various means.}\\)\n\n<table>\n<thead>\n<tr>\n<th>Mean (min.)</th>\n<th>Exponential</th>\n<th>Normal</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2</td>\n<td>6.9 ±0.33</td>\n<td>6.4 ±0.32</td>\n</tr>\n<tr>\n<td>4</td>\n<td>6.56 ±0.32</td>\n<td>6.83 ±0.34</td>\n</tr>\n<tr>\n<td>8</td>\n<td>7.1 ±0.35</td>\n<td>7.0 ±0.35</td>\n</tr>\n<tr>\n<td>16</td>\n<td>7.04 ±0.34</td>\n<td>6.77 ±0.34</td>\n</tr>\n<tr>\n<td>32</td>\n<td>7.08 ±0.34</td>\n<td>6.87 ±0.35</td>\n</tr>\n<tr>\n<td>64</td>\n<td>6.64 ±0.33</td>\n<td>7.05 ±0.36</td>\n</tr>\n</tbody>\n</table>\n\n\\(^1\\)This is the number of errors injected into the system and not into each component.\n<table>\n<thead>\n<tr>\n<th>Mean Latency in minutes</th>\n<th>System MTBF in years $\\lambda = 1/30\\text{min.}$</th>\n<th>$\\lambda = 1/5\\text{min.}$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>0.0031 $\\pm$ 0.00016</td>\n<td>0.0001 $\\pm$ 0.00001</td>\n</tr>\n<tr>\n<td>2</td>\n<td>0.0034 $\\pm$ 0.00018</td>\n<td>0.0001 $\\pm$ 0.00001</td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.0033 $\\pm$ 0.00017</td>\n<td>0.0002 $\\pm$ 0.00001</td>\n</tr>\n<tr>\n<td>8</td>\n<td>0.0037 $\\pm$ 0.00018</td>\n<td>0.0002 $\\pm$ 0.00001</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.0041 $\\pm$ 0.00021</td>\n<td>0.0003 $\\pm$ 0.00002</td>\n</tr>\n<tr>\n<td>32</td>\n<td>0.0052 $\\pm$ 0.00026</td>\n<td>0.0004 $\\pm$ 0.00002</td>\n</tr>\n<tr>\n<td>64</td>\n<td>0.0068 $\\pm$ 0.00036</td>\n<td>0.0007 $\\pm$ 0.00004</td>\n</tr>\n</tbody>\n</table>\n\nTable 8.2: System MTBF for two fast error arrival rates.\n\nMTBF increases with larger latency times indicating that the accumulation of errors alone is not detrimental to system reliability. The increase in the MTBF occurs because the latency times are of the same order of magnitude as the error arrival rate and hence they increase the mean time between error detections noticeably.\n\nThese results indicate that the accumulation of latent errors, in and of itself, does not cause near coincident errors. However, the study was made under two assumptions. First, re-integration coverage is 100% and second, re-integration coverage does not depend on the state of the other components in the system. That is, there is no intercomponent dependence (see chapter 4). In reality, in the Integrity S2, the remaining healthy processors in the system control the re-integration of the faulty processor. During re-integration, the entire content of the two healthy processors is copied to the faulty one. If during that time, there is a discrepancy in the contents of the two healthy processors, the system fails. The same holds for the global memory boards. To model this scenario, the simulation model fails during re-integration if any healthy component contains a latent error. Table 8.3 contains the results for various different exponentially distributed latency times. The error arrival rate is one error a day. The results very clearly indicate the adverse impact of latent errors on system MTBF. Even with a mean latency time of just 2 minutes, and a system error arrival rate of 1 per day (which means, an error is injected into a processor once every 8 days, and into a global memory board once every 3.2 days) system MTBF is slashed by more than 50 percent. As the latency times increase, the MTBF is further degraded.\n\nTo summarize, the accumulation of latent errors does not cause near coincident errors. Rather, it is a combination of error latency times, system activity and repair policy that cause\nnear coincident errors that adversely impair system reliability. A system like the Integrity S2 is especially vulnerable to latent errors because its on-line re-integration scheme requires that the entire contents of the healthy boards be copied to the newly re-integrated board. Thus any latent error, in any segment of either healthy board, is guaranteed to cause system failure. Other systems with different repair policies may not be as sensitive to latent errors. To properly evaluate and quantify the impact of latent errors, it is imperative that system activity such as repair policies be incorporated into the model.\n\n### 8.3 Impact of Correlated Errors\n\nTMR systems have been shown to be extremely effective against single, independent errors. In this experiment, correlated errors are injected to determine their impact on system reliability. Inter-component dependence is not modeled in the first two experiments. In the first experiment, errors with zero latency are injected, and of these, 2% are correlated errors (see Figure 7.4). The modeling is similar to the ‘partial coverage’ technique commonly used with analytical models. The system MTBF was found to be 0.129 (± 0.006) years. Comparing this to an MTBF of 6.76 years (determined when latency is zero and there is no correlation) we see that even a very small fraction of correlated errors causes an order magnitude reduction in the MTBF. However, measurement studies [67, 73] show that correlated failures do not occur simultaneously as modeled here.\n\nCorrelated errors with latency are used to mimic the phenomenon of “staggered machine failures” found to be caused by correlated errors [73]. Table 8.4 shows the system MTBF for two\n\n<table>\n<thead>\n<tr>\n<th>Mean Latency in minutes</th>\n<th>System MTBF in years</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>6.7 ±0.32</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3.14 ±0.16</td>\n</tr>\n<tr>\n<td>4</td>\n<td>2.09 ±0.11</td>\n</tr>\n<tr>\n<td>8</td>\n<td>1.3 ±0.07</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.75 ±0.04</td>\n</tr>\n<tr>\n<td>32</td>\n<td>0.40 ±0.02</td>\n</tr>\n<tr>\n<td>64</td>\n<td>0.32 ±0.01</td>\n</tr>\n</tbody>\n</table>\n\nTable 8.3: System MTBF with inter-component dependence.\nTable 8.4: System MTBF for two latency distributions with various means.\n\n<table>\n<thead>\n<tr>\n<th>Mean (min.)</th>\n<th>Normal $C_X = 0.5$</th>\n<th>Exponential, $C_X = 1$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2</td>\n<td>0.158 ±0.008</td>\n<td>0.216 ±0.006</td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.245 ±0.012</td>\n<td>0.334 ±0.011</td>\n</tr>\n<tr>\n<td>8</td>\n<td>0.453 ±0.023</td>\n<td>0.560 ±0.016</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.825 ±0.041</td>\n<td>0.960 ±0.048</td>\n</tr>\n<tr>\n<td>32</td>\n<td>1.46 ±0.073</td>\n<td>1.67 ±0.083</td>\n</tr>\n<tr>\n<td>64</td>\n<td>2.46 ±0.123</td>\n<td>2.71 ±0.129</td>\n</tr>\n<tr>\n<td>120</td>\n<td>3.65 ±0.182</td>\n<td>3.97 ±0.201</td>\n</tr>\n<tr>\n<td>240</td>\n<td>5.05 ±0.252</td>\n<td>5.36 ±0.266</td>\n</tr>\n<tr>\n<td>480</td>\n<td>6.61 ±0.333</td>\n<td>6.59 ±0.333</td>\n</tr>\n<tr>\n<td>2160</td>\n<td>13.2 ±0.683</td>\n<td>12.06 ±0.6</td>\n</tr>\n</tbody>\n</table>\n\nlatency distributions, exponential and normal, with various means. The standard deviation of the normal distributions were set to 1/2 of the mean. The most important result shown in the table is that when error latency is considered, the degradation in the MTBF due to correlation is not as significant and may not be orders of magnitude less. For instance, when the mean of the latency distribution is 32 minutes, the MTBF is nearly 13 times larger than the case when error latency is not considered. For really large latency times exceeding 16 minutes, there is no longer an order degradation reduction in the MTBF, and for very large latency times, there is an increase in the MTBF. The table also shows an inverse relationship between the degradation in the MTBF and the mean of the latency distribution.\n\nThe results in Table 8.4 also show that the normal latency distribution produces smaller MTBF figures. The difference in the MTBF between the two types of distributions is statistically significant for means up to 32 minutes, and in cases are 25% smaller. To determine whether this phenomenon is a characteristic of the normal distribution or due to the fact that the coefficient of variation ($C = \\sigma/\\mu$) is smaller than that of the exponential distribution, the experiment was repeated with different $C$ values. Table 8.5 contains the results. Recall that the coefficient of variation for the exponential distribution is always 1. The results in Table 8.5 show that increasing $C$ increases the system MTBF. It also shows that even when the $C$ of the normal distribution is the same as that of the exponential distribution, its MTBF figures are, for the most part, statistically different, and in this case larger. The reason is that the\n### Table 8.5: System MTBF for the normal latency distributions with varying $C_x$ values.\n\n<table>\n<thead>\n<tr>\n<th>Mean (min.)</th>\n<th>$C_x = 0.5$</th>\n<th>$C_x = 1.0$</th>\n<th>$C_x = 2.0$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2</td>\n<td>0.158 ± 0.008</td>\n<td>0.211 ± 0.011</td>\n<td>0.328 ± 0.016</td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.245 ± 0.012</td>\n<td>0.368 ± 0.018</td>\n<td>0.5832 ± 0.029</td>\n</tr>\n<tr>\n<td>8</td>\n<td>0.453 ± 0.023</td>\n<td>0.649 ± 0.032</td>\n<td>1.0691 ± 0.0538</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.825 ± 0.041</td>\n<td>1.26 ± 0.063</td>\n<td>1.8015 ± 0.09</td>\n</tr>\n<tr>\n<td>32</td>\n<td>1.46 ± 0.073</td>\n<td>2.09 ± 0.104</td>\n<td>2.8108 ± 0.139</td>\n</tr>\n<tr>\n<td>64</td>\n<td>2.46 ± 0.123</td>\n<td>3.38 ± 0.169</td>\n<td>4.0841 ± 0.203</td>\n</tr>\n</tbody>\n</table>\n\n### Table 8.6: System MTBF for the exponential and normal latency distributions with inter-component dependence.\n\n<table>\n<thead>\n<tr>\n<th>Mean (min.)</th>\n<th>Exponential, $C_x = 1$</th>\n<th>Normal $C_x = 1.0$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2</td>\n<td>0.126 ± 0.006</td>\n<td>0.128 ± 0.006</td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.124 ± 0.006</td>\n<td>0.124 ± 0.006</td>\n</tr>\n<tr>\n<td>8</td>\n<td>0.115 ± 0.006</td>\n<td>0.114 ± 0.006</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.11 ± 0.005</td>\n<td>0.106 ± 0.005</td>\n</tr>\n<tr>\n<td>32</td>\n<td>0.099 ± 0.005</td>\n<td>0.094 ± 0.005</td>\n</tr>\n<tr>\n<td>64</td>\n<td>0.081 ± 0.004</td>\n<td>0.073 ± 0.004</td>\n</tr>\n</tbody>\n</table>\n\nThe exponential distribution has a larger density of latency times below the mean, thus there is an increased probability that two correlated errors will be detected near coincidentally.\n\nThe results of both tables seem to indicate that the larger the latency the better. In fact, in Table 8.4 the system MTBF is nearly doubled (from the case with zero latency) for latency times with a mean of 36 hours. However, recall these experiments do not consider inter-component dependence. Table 8.6 shows the MTBF figures obtained when inter-component dependence is considered. Now it becomes clear that for this architecture, the smaller the latency the better the system MTBF.\n\nTo summarize, the experiments conducted reveal that simple analytical models that fail to consider error latency exaggerate the impact of correlated errors. If latency is considered, the impact of correlated errors is noticeably less, and it becomes negligible if the latency is very large. In the previous section where correlated errors were not injected, there was no statistically significant difference in the MTBF results produced with the normal and exponential.\ntial distributions (see Table 8.1). In this section, for means less than 64 minutes, the latency distribution produce statistically different MTBF figures. Between the exponential and normal distributions, if they both have the same $C_X$ value, the exponential distribution produces smaller MTBF figures. Furthermore, the larger the $C_X$, the larger the MTBF. What this means to the designer is that if the latency times are very small, correlated errors are more likely to have an adverse impact. If the latency times are very large, correlation is not as important an issue. Typically, however, latency distributions are mixed with a large number of errors with small latency times and a few with very large latency times. The latency times obtained in chapter 6 follows this behavior. With such distributions, their will not be a pronounced increase in the MTBF as the mean of the latency distribution is increased. Furthermore, correlation will noticeably degrade system MTBF.\n\n8.4 Evaluation of Memory Scrubbing\n\nRecall that the Tandem Integrity S2 relies on memory scrubbing to correct latent faults in the CPU and Global memory boards. In this section, experiments are conducted to determine the effectiveness of the existing scrubber. In chapter 6, the software environment was used to determine the application specific coverage of the existing scrubber and that of a proposed \"dual\" scrubber, for a single processor. In this section, the hierarchical approach, described in chapter 7, is used to extend the application specific analysis to consider the whole system and perform a more complete analysis of the two scrubbing schemes.\n\nMemory scrubbing has been evaluated analytically in [55]. The authors assume that all words in memory are accessed with equal probability and access times are exponentially distributed. They provide an exact upper and lower bound on the MTBF for exponentially distributed scrubbing and an approximate upper bound for deterministic scrubbing. Deterministic scrubbing is shown to provide MTBF's that are twice as large. The approach is very useful when evaluating a single memory system under the assumption of uniform memory access. In our simulation-based study, we consider several memory boards, their different repair times, error latency, inter-component dependence inherent in the architecture and the effect of a specific application running on the system, when evaluating the MTBF. Furthermore, with the simulation-based approach we are also able to provide coverages of the scrubbers. Some of\nthese aspects can be included in a CTMC model. To understand how much can be accurately captured, a general stochastic Petri-net tool was used to model just the three processors and the memory scrubbing scheme. Issues such as application specific analysis and intercomponent dependence were not addressed. The Petri-net model shown in Figure 8.1 resulted in a 2000 state CTMC for $n = 6$, the maximum number of accumulated latent errors in a board. Table\n\n\n\n**Figure 8.1:** Petri-net model of the three CPUs with memory scrubbing.\n\n8.7 shows the MTBF figures obtained with the Petri-net model, a DEPEND simulation model, and the relative difference of the Petri-net model. The large difference in the results of the Petri-net model are due to its inability to model the deterministic progression of the scrubber through the memory and because it assumes an exponential scrubbing rate which does not bound the scrubbing interval to 60 minutes. The DEPEND simulation, however, models the location at which each error is injected, the location of the scrubber at the time of each injection and the exact time the scrubber takes to detect and correct each error. A 5-stage Erlang distribution was used to replace the exponential scrubbing distribution, but this provided only a small improvement in the results at a cost of increasing the number of states to 10,000. Interestingly, because the percent difference varies with the latency, the designer can never be sure how close the model results are to the real values. This example shows that a CTMC can be used to provide a rough estimate of a deterministic process. It also justifies the need for a simulation-based study which can provide more accurate results, permit the use of\nnon-exponential distributions, represent dependency caused by latency, and allow application specific analysis. What follows is a step by step analysis of the existing single and a new dual scrubber.\n\n<table>\n<thead>\n<tr>\n<th>Mean Latency (min.)</th>\n<th>MTTF (yrs.)</th>\n<th>Percent Difference</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>DEPEND</td>\n<td>Petri-net</td>\n</tr>\n<tr>\n<td>2</td>\n<td>6.002</td>\n<td>6.46</td>\n</tr>\n<tr>\n<td>4</td>\n<td>6.54</td>\n<td>6.80</td>\n</tr>\n<tr>\n<td>8</td>\n<td>7.59</td>\n<td>7.47</td>\n</tr>\n<tr>\n<td>16</td>\n<td>11.05</td>\n<td>8.9</td>\n</tr>\n<tr>\n<td>32</td>\n<td>20.21</td>\n<td>12.07</td>\n</tr>\n<tr>\n<td>64</td>\n<td>45.19</td>\n<td>19.75</td>\n</tr>\n<tr>\n<td>128</td>\n<td>141.05</td>\n<td>40.34</td>\n</tr>\n</tbody>\n</table>\n\nTable 8.7: Comparison of MTBF obtained with DEPEND and the Petri-net model.\n\nThe effectiveness of the scrubber is intimately tied to the error latency distribution. Figure 8.2 shows the MTBF of the system, with and without scrubbing, for exponentially distributed latency times with various means. The scrubber sweeps through the entire memory every\n\nFigure 8.2: System MTBF for various latency distributions (Hourly Scrubbing).\nMean Latency Scrubber Coverage\n\n<table>\n<thead>\n<tr>\n<th>Mean Latency in minutes</th>\n<th>Scrubber Coverage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2</td>\n<td>0.033</td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.066</td>\n</tr>\n<tr>\n<td>8</td>\n<td>0.132</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.258</td>\n</tr>\n<tr>\n<td>32</td>\n<td>0.45</td>\n</tr>\n<tr>\n<td>64</td>\n<td>0.65</td>\n</tr>\n</tbody>\n</table>\n\nTable 8.8: Scrubber coverage for various exponential error latency distributions.\n\nAs the mean of the latency distribution increases, the coverage of the scrubber increases rapidly (Table 8.8). For small latency distributions with means of 2 to 4 minutes, the scrubber improves the MTBF by only 7% from the base case with no scrubber. But for means of 32 and 64 minutes, the scrubber increases the MTBF by 232% and 827%, respectively. Hence the scrubber is most effective against errors with large latency times. These errors mostly reside in unused or seldomly used parts of memory. Errors within actively used parts of memory are typically detected by the process of execution and causes the board containing the error to be shutdown. The ineffectiveness of the scrubber against small error latencies was also found in [76] in which the author used memory traces and simulation to estimate the scrubber's coverage.\n\nNext we simulate the intercomponent dependence caused by latent errors is to test the effectiveness of the scrubber. Figure 8.3 shows the MTBF of the system, with and without scrubbing. Without the scrubber, the system MTBF degrades monotonically as the mean of the latency distribution increases. Even with a small mean of 2 minutes there is more than a 50% degradation in the MTBF (3.14 years) when intercomponent dependence is modeled. With hourly scrubbing, the MTBF increases to 3.47 years, and with a scrubbing cycle time of 30 minutes, the MTBF reaches only 3.56 years. As the figure shows, except for the case with a mean latency of 128 minutes and a 30 minute scrubbing cycle time, intercomponent dependence caused by latency reduces the system MTBF significantly. It also illustrates that memory scrubbing, at realistic cycle times that do not impose a noticeable performance overhead, are quite ineffective against this phenomenon. The MTBF curves in the figure, for all three scrubbing periods, do\n\n---\n\n2 The smaller the latency time, the smaller the probability of a system failure due to intercomponent dependence caused by latency.\nnot decrease monotonically. This is due to the trade-off between small and large latency times. Though errors with small latencies are less likely to be corrected by the scrubber they are also less likely to cause a near-coincident errors due to intercomponent dependence. Errors with large latency are more likely to cause near-coincident errors, but are more likely to be detected and corrected by the scrubber. The minimum MTBF occurs for a mean latency that is half the scrubber's cycle time. For example, the smallest MTBF for the scrubber with a 30 minute cycle time occurs for the latency distribution with a mean of 16 minutes. This information is very useful to the designers because if they have some general idea of the latency distribution of the system, they can avoid using a scrubbing period at its minimum effectiveness point.\n\nIn chapter 6, an abstract representation of the Gauss program was executed to obtain detection latency times and to evaluate two scrubbing schemes. The analysis focussed on the coverage of the existing and the newly proposed 'dual' scrubbing scheme with respect to active errors that are detected by the process of program execution. In the experiments that follow,\nthe analysis of the scrubbers is also extended to consider the rest of the memory and the overall impact they have on system MTBF. Without such a complete analysis it is difficult to determine which scheme is more effective in improving system reliability. As it is not possible to directly perform the detailed evaluation in chapter 6 while also considering the rest of the system, the hierarchical approach described in chapter 7 is used for this extended analysis. Executing several instances of the Gauss PCFGs on the three processors while also modeling all the scrubbers, the global memory system and the re-integration process will require astronomically large simulation times. Instead, the execution of the PCFGs is replaced with their collected detection latency times. For the experiments, the CPU memory is logically divided into two segments: the application space and the system space. The size of the application space is a multiple of the of the size of the memory image of the actual Gaussian elimination program times the number of Gauss programs assumed to be executing. The detection latency of the errors injected into the application space is sampled from the collected empirical latency distribution file. For instance, to model the execution of four Gauss programs, the latency distribution collected when four Gauss PCFGs were executed is used in this simulation. The CPU memory's system space and the global memory are injected with errors having exponentially distributed latency times with a mean of 16 minutes. Both the single scrubber and the dual scrubber are tested under this configuration. The ratio of the overheads of the dual scrubber (see Equation 6.4) versus the single scrubber used are 1, 2, 4, 8, and 16. Recall that the dual scrubber has two scrubbers. One scrubs system space and the other scrubs the application space. By making the system space scrubber operate at a rate four times slower than the single scrubber, it is possible to scrub the application space frequently and still maintain an overhead ratio of 1. The other overhead ratios are obtained by further speeding up the rate of the application scrubber. The question is what happens to system MTBF with this scrubbing configuration?\n\nFigure 8.4 plots the application specific MTBFs obtained with the single scrubber and the dual scrubber for 1, 4 and 16 simultaneous executions of the Gauss program. The percent of the CPU memory allocated to the application space and the mean of the empirical distribution which represent the execution of the programs are listed in Table 8.9. The results show that the single scrubber provides similar or better MTBF figures than the dual scrubber. Table 8.10, which shows the coverage of the single scrubber and the dual scrubber with an overhead ratio of 1, indicates why this is the case. Even though the application scrubber's coverage is\nFigure 8.4: System MTBF obtained with the single and dual scrubbing schemes.\n\nTable 8.9: Parameters of the experiment.\nvery high, the overall coverage of the dual scrubbing scheme is low because most of the errors are injected into system space, where the scrubbing occurs with a cycle time of 4 hours. As a result, the single scrubber’s coverage is on average four times higher.\n\nNext, we arbitrarily increase the size of the application space to see how the scrubbers perform. Application space sizes that are 5, 10, 20, 30, 40 and 50 percent of the total CPU memory are tried. The empirical latency distribution obtained for 4 Gauss programs is used for all errors injected into the application space. Table 8.11 contains the MTBF figures obtained for the two scrubbing schemes. In spite of increasing the application space, there is no statistically significant improvement in the MTBF figures obtained with the dual scrubbers. This is because as the size of the application space increases, the scrubbing frequency of the application space scrubber must be reduced to maintain reasonable overheads. Hence, as the application space increases, the coverage of its scrubber decreases thus offsetting any gains.\n\nSince the introduction of the Integrity S2, the memory configuration has changed to improve the performance of the machine. The newer Integrity S2 machines come with larger CPU memory and smaller global memory. The experiments in which we vary the application memory space size is repeated with a configuration where the CPU memory size is 64Mbytes and the\n\n<table>\n<thead>\n<tr>\n<th>No. Programs</th>\n<th>Dual Scrubber (Ovhd. = 1)</th>\n<th>Single Scrubber</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Appl. Space Coverage</td>\n<td>Sys. Space Coverage</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0.33</td>\n<td>0.066</td>\n</tr>\n<tr>\n<td>4</td>\n<td>0.32</td>\n<td>0.067</td>\n</tr>\n<tr>\n<td>16</td>\n<td>0.31</td>\n<td>0.066</td>\n</tr>\n</tbody>\n</table>\n\n**Table 8.10:** Coverage of the two scrubbing schemes.\n\n<table>\n<thead>\n<tr>\n<th>Scrubber</th>\n<th>Application Space (Percent of CPU memory)</th>\n<th>System MTBF in years</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>5%</td>\n<td>10%</td>\n</tr>\n<tr>\n<td>Single</td>\n<td>12.19</td>\n<td>12.01</td>\n</tr>\n<tr>\n<td>Dual (Ovhd. = 1)</td>\n<td>11.54</td>\n<td>12.34</td>\n</tr>\n<tr>\n<td>Dual (Ovhd. = 2)</td>\n<td>11.8</td>\n<td>12.37</td>\n</tr>\n<tr>\n<td>Dual (Ovhd. = 4)</td>\n<td>11.63</td>\n<td>11.95</td>\n</tr>\n</tbody>\n</table>\n\n**Table 8.11:** System MTBF obtained for various application memory space sizes.\nTable 8.12: System MTBF obtained for various application memory space sizes with the new memory configuration.\n\n<table>\n<thead>\n<tr>\n<th>Scrubber</th>\n<th>Application Space (Percent of CPU memory)</th>\n<th>System MTBF in years</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>5%</td>\n<td>10%</td>\n</tr>\n<tr>\n<td>Single</td>\n<td>13.79</td>\n<td>12.15</td>\n</tr>\n<tr>\n<td>Dual (Ovhd. = 1)</td>\n<td>8.8</td>\n<td>8.97</td>\n</tr>\n<tr>\n<td>Dual (Ovhd. = 2)</td>\n<td>8.8</td>\n<td>8.87</td>\n</tr>\n<tr>\n<td>Dual (Ovhd. = 4)</td>\n<td>9.03</td>\n<td>9.15</td>\n</tr>\n</tbody>\n</table>\n\nTable 8.12: System MTBF obtained for various application memory space sizes with the new memory configuration.\n\nGlobal memory size is 16Mbytes. The error arrival rate is kept fixed (for comparative reasons) but the percent of errors injected into the CPU memory has increased to 85% due to its larger size. Table 8.12 lists the MTBF figures obtained with the new memory configuration. With a larger percent of errors injected into the CPU, the difference between the two scrubbers is even more apparent. Here, the dual scrubber produces MTBF values that are up to 25% lower.\n\nTo summarize, the evaluation of memory scrubbing shows that it is only effective if the error latency is large. For mean latency times exceeding 30 minutes, hourly scrubbing can improve the MTBF by over 200%. Increasing the frequency of the scrubber can improve its coverage of errors with smaller latency times but at a cost of high performance overhead. Furthermore, as shown in chapter 6, increasing the scrubbing frequency beyond a certain point provides diminishing increase in the coverage. The scrubbing scheme was found to be very ineffective against near-coincident errors caused by error latency. However, if the latency times are very large, the scrubber provides reasonable improvement in the MTBF. When the possibility of near-coincident errors caused by latency is modeled, the MTBF curves no longer increase monotonically with an increase in the mean of the latency times (compare Figures 8.2 and 8.3). The experiments show that the minimum MTBF point for the scrubber occurs as the mean latency time approaches half the scrubber's cycle time.\n\nThe entire memory will not display the same detection distribution because it varies with time and with the frequency and nature of use. To model applications exercising the memory, detection latency times obtained from detailed simulations in chapter 6 are used. Portions of the CPU memory, the application space, allocated to the applications are injected with latency times sampled from these empirical distributions. This configuration was then used to evaluate\nthe existing single and the proposed dual scrubbers from a system perspective. The nature of\nthe Integrity S2's re-integration mechanism makes the dual scrubber ineffective relative to the\nsingle scrubber. This is in spite of the fact that it provides orders of magnitude improvement\nin coverage for the application space. The problem is twofold. First, the application space is\nsmall compared to the rest of the memory. Second, to limit the overhead of the dual scrub-\nber, the rest of the memory is scrubbed at a much slower rate than the existing scrubber. By\nslowing down the scrubbing of the rest of the memory, the system becomes more vulnerable\nto near-coincident errors. This extended analysis of the scrubbing schemes, possible with the\nhierarchical technique, made it possible to perform a complete analysis of the scrubbers and\nquantify their coverage and the system MTBF figures they would produce. With this informa-\ntion, it was realized that the dual scrubber, which seemed so promising with respect to just the\napplication, reduces the dependability of this system as a whole.\n\n8.5 Impact of Repair Times\n\nThe Integrity S2 is designed to tolerate single faults. For such systems, the time needed to\nrepair a faulty component is referred to as its window of vulnerability. If a second fault arrives\nwithin this window, the system fails. The CPU re-integration time consists of 60 seconds\nto perform a power-on self-test (POST) and 1.5 seconds to re-integrate the CPU. The re-\nintegration time cannot be easily reduced but the POST time can be cut by using different self-\nchecking programs. Since most errors are caused by transient faults, reliability can be improved\nby performing a perfunctory check that takes a few seconds and immediately initiating a re-\nintegration. If another error is detected in the same board shortly thereafter, a more thorough\nPOST program can be executed to check for permanent defects. The re-integration time for\nthe global memory varies with workload, but it can be reduced by increasing the priority of\nthe re-integration process. In this section, simulations are conducted with various POST times\nand global memory re-integration times to quantify their impact on system MTBF. Specifically,\nPOST times of 10, 20, 30, 40, 50 and 60 seconds and the global memory re-integrations times\nof 1, 2, 5 and 10 minutes are used in the simulations. Memory scrubbing is not activated and\na exponential error latency distribution with a mean of 16 minutes is used.\nThe simulations are first executed with the original memory configuration (8MBytes of CPU memory and 32Mbytes of global memory). With this configuration, where most of the errors are injected into the larger global memory, the global memory time is the dominant factor. Figure 8.5a shows that the system MTBF decreases monotonically as the global memory re-integration time is increased. Since the global memory is re-integrated on the fly, its re-integration time varies depending on the workload on the system (see Table 5.1). Figure 8.5a can also be interpreted to reflect the system MTBF for varying workloads. As the workload increases, the reliability of the system decreases. Figure 8.5b illustrates what little impact changing the CPU time has on system MTBF. This is especially the case as the global memory re-integration time is increased. Clearly, for this memory configuration, the global memory re-integration time is the bottleneck.\n\nThe experiments are repeated in which the inter-component dependence due to latency is modeled. The system MTBF for mean latency times of 16 and 8 minutes are listed in Table 8.13. Note that when the dependence is modeled, varying the global memory re-integration time does not have as significant an effect on system MTBF. This is because, for the Integrity S2, each latent error injected into the system creates a window of vulnerability. For instance, if a latent error $X$ is injected into CPUA, an error detected in the two other CPUs before $X$ is corrected will cause a system failure. So each latent error creates a window of vulnerability.\nTable 8.13: System MTBF with modeling of near-coincident errors.\n\nIf the error latency is large, they more so than the POST and global memory re-integration times, become the dominant factor that determine system reliability.\n\nThe first experiment was repeated with the new memory configuration in which each CPU contains 64Mbytes and each global memory has 16Mbytes. For ease of comparison, the error arrival rate was not varied, however, the ratio of errors injected into the CPU and global memory were changed to reflect their change in relative sizes. With this configuration, 85% of the errors are injected into the CPUs. Figure 8.6 shows that now the CPU POST time is the more dominant factor. Varying the global memory re-integration time does not have as dramatic an affect as seen in Figure 8.5a. Comparing Figures 8.5b and 8.6b, one sees that the system is more reliable with the new configuration. Given two systems with the same amount of total memory (CPU and global memory), the system which has apportioned more memory to the CPUs will have a higher reliability. This is because CPU re-integration takes less time and is not done in the background. Of course, global memory re-integration can be performed at a high priority like the CPU, but since the system also performs better when the local CPU memory is large it makes more sense to re-apportion the memory. Part of the reason for the higher performance is that access time to the local memory is smaller and there is no synchronization overhead to be paid.\n\nTo summarize, reducing the global memory re-integration time and the CPU POST time can improve system MTBF. Which re-integration time to reduce depends on the system configuration, with the component with the highest error arrival rate being the reliability bottleneck. Since CPU re-integration times are smaller than global memory re-integration times, apportioning more memory to the CPUs improves system reliability. It also improves its performance. Experiments in which inter-component dependence caused by latency is modeled show that\nerror latency creates a window of vulnerability for this architecture, and this has the most\ndominant affect on system reliability. When modeling inter-component dependence, reducing\nCPU and global memory re-integration times does not noticeably improve system MTBF.\nChapter 9\n\nConclusion\n\nThe contribution of this thesis is the development of a methodology for functional simulation-based system level dependability analysis of fault-tolerant computer systems. Simulation-based approaches have mostly been used at lower levels, for example at the gate level where the functionality of the basic components are simple and their interconnections and inter-dependencies are well defined. At the system level, simulation-based approaches have been either Petri-net based extensions of analytical tools or have been designed to analyze only a small set of architectures. Our proposed methodology is unique in that it addresses many of the difficulties and issues that have limited the applicability and utility of these existing simulation-based approaches. The proposed methodology is designed to be generally applicable to a wide variety of architectures and can model various fault conditions. It permits detailed functional modeling of architectural features such as sparing policies, repair schemes, routing algorithms as well as other fault-tolerant mechanisms. The approach permits actual execution of application software for more realistic modeling. In addition, it allows the abstract representation of software algorithms when actual code does not exist. Through this abstraction it is possible to study the behavior and effect of the software on hardware faults and perform application specific analysis of system level fault-tolerant mechanisms in the early design phase. Finally, unlike any other existing simulation-based approach, an acceleration technique is proposed and implemented that makes it possible to study fault-tolerant systems for extended periods of time.\n\nThe effectiveness of any methodology is best determined when actually implemented and tested. The methodology has been incorporated into a software tool called DEPEND. Since\nits development, the tool has been used (and is being used) to analyze the Tandem Integrity S2 system, the CM-5 Connection Machine, a distributed system executing a load balancing algorithm, the computing element of the Hubble Telescope, a proto-type switching system developed by Raynet, the Parsytec distributed computer being developed in conjunction with the European Esprit Project and the Data Management System of the Space Station. In addition, the tool has been ported to Tandem Inc., Thinking Machines, Raytheon Company, IBM Federal Systems, NASA Langley, and NASA Ames for the purposes of evaluation and use in studying prototype designs.\n\nThe section below summarizes the main facets of the methodology and the experiments used to illustrate and validate the features of DEPEND. The thesis ends with a section that suggests possible extensions of this work.\n\n9.1 Summary\n\nIssues that impede the development of a general-purpose, functional simulation-based system level dependability analysis tool include:\n\n- Modeling a large variety of components.\n- Coping with the large fault model domain.\n- Reducing model development time and model complexity.\n- Incorporating software behavior under faults.\n- Reducing simulation time explosion.\n\n9.1.1 The Approach\n\nModern software engineering techniques, and in particular the object-oriented design paradigm are used to tackle the first three issues. Two somewhat competing criteria of modular decomposition and composition along with inheritance and reusability are used to develop a structured class hierarchy. This hierarchy provides a skeletal framework that can be readily customized to create detailed simulation models of a wide variety of fault-tolerant architectures for fault injection and dependability studies. The key idea was to encapsulate general mechanisms in\nA set of fundamental objects and through inheritance and clientship allow them to drive other objects that simulate the architecture specific behavior. Thus a set of fundamental objects was developed that facilitates and automates the development of simulation models. In addition, a default set of objects that model many common architectures was created to further simplify the development of simulation models. These fundamental and architecture specific objects can in turn be inherited and developed to create still more elaborate objects.\n\nFour basic fault models are provided which can be used to simulate specific fault behaviors: status faults, process faults, server faults and data faults. A fault injector is used to inject faults based on commonly used distributions: exponential, Weibull and constant. In addition, user specified empirical distributions are also supported. The injector uses a fast table-based injector to keep track of all components, their status and the time of their next injection. It also automatically takes component aging into account and averts the problem of modeling local and global times found in most analytical tools. A workload-based injection scheme has also been developed. It varies the rate of injection based on the load on the system and permits modeling of the workload/failure relationship found by other researchers.\n\nTwo examples are used to highlight the benefits of the functional simulation tool. Unlike analytical and Petri-net tools, a system's fault behavior does not have to be pre-defined with a set of probabilities. Rather, using detailed modeling of the architecture and its system software, the failure modes of the system can be determined using the tool. In one example, actual system software is executed and a particular design feature that made it very susceptible to a particular fault type was identified.\n\n### 9.1.2 Software Modeling\n\nDEPEND addresses the need to study the effect of software under hardware faults and to perform application specific analysis. This is especially important to designers because the effectiveness of many system level detection and fault tolerance mechanisms depend on the class of applications running on the system. DEPEND allows the execution of actual software on a simulated hardware platform, and it provides a software model that can be used to evaluate the behavior and the effect of software on hardware faults. The model represents application programs by decomposing them into graph models consisting of a set of nodes, a set of edges that probabilistically determine the flow from node to node, and a mapping of the nodes to memory.\nThe software model simulates the execution of the programs while errors are injected into their memory space. The result provides application dependent parameters such as detection and propagation times. The model is especially useful in the early design stages because it allows designers to make application dependent evaluation of function and system level error detection and recovery schemes.\n\nOne use of the software model was illustrated with a case study. The model was used to obtain error detection latency times of the **Gauss** and **sort** programs running on a Tandem Integrity S2 system and to evaluate the coverage of two memory scrubbing schemes. The applicability of the model for different programs was evaluated by studying its sensitivity to the detection parameter $p_t$. Several detection equations, which model the low level detection process of a CPU, were derived empirically from studying the behavior of the actual machine under faults. Of these, the **EXP** detection equation was shown to be applicable to both **Gauss** and **Sort** which use widely different sets of instructions. We feel that this detection equation is generally applicable to most compute bound programs running on RISC processors. Error detection latency times obtained with the model were validated with measurements from an actual Integrity S2 system. Formulae which were derived to estimate application dependent active coverage values of the scrubbing schemes were verified with the software model. The application dependent coverage values obtained with the model were compared with those obtained via traditional schemes that assume uniform or ramp memory access patterns. For the **Gauss** program, some coverage values obtained using the traditional approach were found to be more than 100% larger than those obtained with the software model. This result emphasizes the importance of accurate application specific evaluation – especially when evaluating the dependability of application specific systems.\n\n### 9.1.3 Acceleration Technique\n\nUnlike any other simulation-based dependability analysis tool, DEPEND provides an acceleration technique to reduce simulation time explosion. The acceleration technique proposed uses a unique combination of three schemes to provide speed-up. It uses hierarchical simulation, a time acceleration algorithm, and hybrid simulation. First, detailed functional simulations of segments of the system are executed to obtain statistical models that represent and characterize their behavior. These statistical models are then used by higher level simulations that simulate\nand analyze larger segments of the system. Speed-up is achieved with this hierarchical approach through a time acceleration algorithm. The time acceleration algorithm, used by the higher level simulations, samples from the statistical models to determine the time of the next event (represented by the statistical model) \\textit{apriori}. With this \\textit{apriori} knowledge, the simulation leaps forward to a point in time just before the event and resumes detailed simulation. Once the effect of the event has subsided, it leaps forward to the next chronological event. To achieve further speed-up, a hybrid simulation approach is used. Using the notion of variable aggregation and decomposition, the entire dependability simulation is divided into two submodels: the failure occurrence submodel and the repair submodel. Either or both submodels are simulated in detail while statistical models to represent them are collected. Then, the statistical models are used to drive either a Monte Carlo simulation or a Markov or Semi-Markov model to obtain solutions for the entire system. The statistical models are typically distributions such as detection latency distributions or propagation time distributions. But they may also be sets of probabilities such as a fault dictionary used to represent the failure modes of an application software.\n\nThe proposed acceleration technique differs from those used by others in that\n\n- It does not rely solely on analytical techniques to reduce simulation time explosion.\n\n- It is designed to work with detailed functional simulations.\n\n- It is widely applicable and does not impose any particular solution method. As such, it caters to the general design philosophy of DEPEND.\n\n- It can be used in conjunction with other acceleration techniques such as importance sampling.\n\nThe acceleration technique was illustrated with a case study of the Tandem Integrity S2. Using hierarchical simulation and time acceleration techniques, error latency distributions were obtained. These distributions were validated with measured distributions collected from the actual machine. The empirical distributions were then used in a hybrid model of the entire system to obtain system MTBF figures. The results obtained were compared with those from a simulation model that did not use the hybrid acceleration technique. The results from the hybrid model were found to fall within the 99\\% confidence interval of the non-accelerated sim-\nulation. Where the original simulation took 6 to 36 hours to generate results, the hybrid model required only 50 seconds to 7 minutes.\n\n9.1.4 Analysis of the TMR-based System\n\nThe DEPEND tool, including the software environment and the acceleration technique, is used to analyze a TMR system that is based on the design of the Tandem Integrity S2. The purpose of the study was to investigate issues which include: correlated errors, accurate modeling of correlated errors, latent errors, inter-component dependencies during automatic repair, memory scrubbing heuristics, application specific analysis of scrubbing schemes, impact of repair times, impact of different configurations, and isolation of dependability bottlenecks. This study illustrates many of the capabilities of DEPEND in a realistic setting. A few of the findings are now summarized:\n\n- Under the assumptions of the study, the accumulation of latent errors does not, in and of itself, increase the probability of near-coincident errors. But once the inter-component dependence imposed by the Integrity S2's architecture and its re-integration scheme is modeled, error latency can reduce system MTBF by orders of magnitude, with the system MTBF decreasing monotonically with increasing latency times.\n\n- Simple analytical models that fail to consider error latency exaggerate the impact of correlated errors. Correlated errors, modeled in a similar fashion to the 'partial coverage' technique commonly used with analytical tools were shown to reduce system MTBF by orders of magnitude. However, once correlated latent errors were injected to mimic the phenomenon of \"staggered machine failures\" found to be caused by correlated errors [73], the impact of correlation was noticeably less and became negligible when the error latency was very large. Hence, the impact of correlated errors depends on the error latency times associated with the errors.\n\n- The distribution of the latency times for correlated errors has a bearing on system reliability. Errors with exponentially and normally distributed latency times with various means were tried and found to produce statistically significant differences in system MTBF. A normal distribution with the same mean as an exponential distribution, but with a\ncoefficient of variation $C_v = 2$, was found to produce MTBF figures that were nearly double in size. Hence, the specific latency distributions used is important and can produce significantly different results.\n\n- Memory scrubbing was found to be effective only if the error latency is large. For mean latency times of 2 to 4 minutes, hourly scrubbing increases system MTBF by only 7%. For mean latency times exceeding 30 minutes, hourly scrubbing can improve the MTBF by over 200%. The MTBF curve increases monotonically as the mean of the latency distribution increases.\n\n- The scrubbing scheme was also found to be very ineffective against near-coincident errors caused by error latency. However, if the latency times are very large, the scrubber provides reasonable improvement in the MTBF. When the possibility of near-coincident errors caused by latency is simulated, the MTBF curves no longer increase monotonically with an increase in the mean of the latency times. There is a dip in the MTBF curve with the minimum MTBF point occurring at the point where the mean latency time is equal to half the scrubber’s cycle time.\n\n- The acceleration technique was used to perform application specific analysis of the single scrubber and the proposed dual scrubber while executing one or more instances of the Gauss program. The dual scrubber was found to reduce system reliability compared to the single scrubber in spite of the fact that its coverage of errors injected within the application space is orders of magnitude higher. This is a function of the Integrity S2 architecture and its re-integration scheme. On another machine the dual scrubber may improve the reliability.\n\n- Reducing global memory re-integration time and CPU POST time can improve system MTBF. However, simulations show that reducing repair time of only the component with the highest error arrival rate is necessary. Reducing the other component’s repair time has negligible impact on system MTBF. Which re-integration time to reduce depends on the system configuration. With the original configuration which had large global memories, the global memory re-integration time was the dominant factor. With the new configuration containing large local memory, the CPU POST time is the dominant factor.\nExperiments modeling inter-component dependence caused by latency show that error latency creates a window of vulnerability for this architecture, and has the most dominant affect on system reliability. When inter-component dependence is considered, reducing CPU and global memory re-integration times did not noticeably improve system MTBF for the error arrival rate used.\n\n9.2 Future Extensions\n\nThe methodology and design philosophy incorporated into the existing DEPEND simulation tool provides the foundation upon which significant future extensions can be built. Future extensions that will enhance the state-of-the-art in functional simulation-based system level dependability analysis can be divided into three categories: compiler-based enhancements, complete fault injection and debugging environment and graphical interface.\n\nThe current implementation of DEPEND is essentially a super set of C++. It was specifically designed this way because a special compiler did not have to be developed thus allowing rapid implementation and testing of the proposed methodology. However, by designing a specific compiler it is possible to embed intelligence as well as features that will allow the implementation of two major capabilities. Recall that DEPEND is a process based simulation tool. Process based simulation facilitates developing large detailed simulation models but has the drawback of a very large context switch overhead. This is especially true for the Sparc architecture which has a large register file that must be copied out and in for each context switch. Using a special compiler, it is possible to translate a process based simulation model into an event-driven simulation model. This approach will then provide the ease of programming without the context switch overhead. Preliminary analysis with simple models has shown that this approach is very promising and can attain 60 times speedups [3]. As mentioned in chapter 2, the crux of parallel and distributed simulation lies partly in the way in which processes (or co-routines) are assigned to the various processors. Yet, this issue is seldom addressed in the distributed simulation literature. Using a special compiler that is cognizant of the functionality of DEPEND objects, the DEPEND communication paradigms, and also aided by compiler directives, it will be possible to make intelligent placement decisions to substantially reduce the communication messages used by the processors to maintain a synchronized global clock. The compiler's placement decisions\nwill most likely be specific to a synchronization scheme. An existing synchronization scheme, aided by the intelligent placement algorithm may make the approach less application sensitive and thus capable of providing good speedup across a large domain of simulation models.\n\nIn its present state, a DEPEND simulation model can execute actual C++ and C application programs as a part of the simulation and corrupt any data values using the data fault type described in chapter 3. The tool can be made more useful if the entire software image of the application program, its static data space, text space, stack space and its heap space is corruptible. Since random corruption of a program's software image (which is ultimately just a co-routine of DEPEND) can cause the co-routine and hence DEPEND simulation to abort, an approach to capture and handle exceptions is needed. This must be coordinated by another process that operates independently and outside of the DEPEND simulation. C++ provides some exception handling facilities but they are still in their infant stages. Hence, standard operating system signal handling routines will need to be used. While existing tools such as FERRARI [36] and FIAT [18] already provide such an injection capability, implementing it within a simulation environment provides a significant advantage. The application program is executed on a simulated hardware platform rather than an actual one making it possible to test the software on various types of architectures (e.g. single processor, shared memory multiprocessor, distributed system) with minimal effort. For example, an actual operating system can be executed and tested on a single processor initially and then executed on a distributed system, by simply changing the underlying simulated hardware platform. With little additional work the injection environment can be extended to permit debugging. Note that since both the DEPEND simulation model as well as the application programs executed within the simulation environment are just DEPEND processes, both can be debugged and tested under normal operating conditions (that is without fault injection).\n\nA graphical user interface can significantly facilitate the entry of simulation models. Currently, C++ programming is used to develop simulation models. As the system becomes large and complex, faster and more efficient input schemes are necessary so that the models can be developed with minimal effort and within a reasonable period of time. A major issue is how to provide a user friendly data entry environment without losing the power of C++ programming. A key to this problem will be to develop a methodology for explicitly specifying the physical architecture of a system, the component inter-connections and their inter-dependencies. By\ninter-dependencies, we mean information such as what components fail when a given component is shutdown and what components must be healthy in order to initiate a repair of a faulty component. Currently, system interconnections and the physical architecture are specified implicitly via the functionality of the simulation model. Inter-dependencies are specified with “notification functions”, which though powerful are tedious and difficult to use for large complex systems.\n\nAll three areas are fundamental research topics that can substantially enhance the state-of-the-art in functional simulation-based system level dependability analysis and help to make such a tool useful to industry.\nAppendix A\n\nAutomation of the Acceleration Technique\n\nThe object-oriented paradigm facilitates the automation of the acceleration technique described in chapter 7. Some objects used to automate the process are presented and described. Only objects that are used to collect statistical models consisting of distributions are shown. Figure A.1 shows the fundamental class `store_dist` used to collect a distribution. The method `record()` is used to store (collect) samples obtained from a simulation model. The remaining methods return commonly required statistics of the distribution. Method `get_sample()`, randomly samples from the distribution and returns a value. This process involves creating a cumulative distribution, using an inverse mapping [40] and a binary search.\n\nThe `store_dist` class is the fundamental class used to develop statistical model classes consisting of one or more distributions. Figure A.2 shows how it is used to define a class, `stat_model2`, that contains two distributions. The failure and repair submodels are developed from the statistical model classes. The user inherits a class that defines a statistical model they need and then adds a method that contains the functional simulation that models the failure or repair process. Figure A.3 shows the skeletal framework of a derived class that inherits `stat_model2` and defines the failure process. The failure submodel depicted simulates the failure occurrence process and records the failure times of the CPU and global memory. When enough samples have been collected, the `finish()` routine is invoked to wake up any process awaiting its completion. The repair submodel is not shown. It is developed in an identical fashion. That is, it\nclass store_dist {\n store_dist();\n store_dist(int num); // number of samples stored\n void init(int num); // number of samples stored\n void record(double x); // store sample point x\n double mean(); // return mean\n double median(); // return median\n double max(); // return maximum\n double min(); // return minimum\n double std(); // return standard deviation\n double get_sample(); // randomly sample from distribution\n};\n\nFigure A.1: Definition of class used to collect distributions.\n\nclass stat_model2 { \nprivate:\n store_dist x, y; // Each stores a distribution\npublic:\n stat_model2(int numx, int numy); // initialize each collector\n void record(int type, double value); // place value in to x or y based on type\n double mean(int type); // return mean\n double median(int type); // return median\n double max(int type); // return maximum\n double min(int type); // return minimum\n double std(int type); // return standard deviation\n double get_sample(int type); // randomly sample from distribution\n void finish(); // collection is finished - wakes up sleeping processes\n void sleep(); // sleep until collection is done\n};\n\nFigure A.2: Definition of statistical model consisting of two distributions.\nclass failure_model : public stat_model2 {\n void run_failure_model();\n};\n\nvoid failure_model::run_failure_model()\n{\n while(!done) {\n record(cpu, fail_time);\n record(global_memory, fail_time);\n }\n finished();\n}\n\nFigure A.3: Definition of statistical model consisting of two distributions.\n\ninherits a statistical model class and defines the repair submodel.\n\nThe Monte Carlo program which uses the statistical models obtained from the failure and repair submodels is shown in Figure A.4. The program starts each submodel and then sleeps until both have completed. It then executes the Monte Carlo simulation program that models the Markov model in Figure 7.9. Only the logic used to determine the transition from the first state, $0C0G$, is shown.\n\nThe DEPEND objects provide all the mechanism needed to collect and sample from the statistical models and use them in Monte Carlo simulations. The user supplies the definition of the failure and repair submodel and the Monte Carlo program. Though the example shows an example of hybrid simulation, the same objects are used with hierarchical simulation.\nmain()\n{\n failure_model X;\n repair_model Y;\n\n Run each submodel and collect statistical model\n X.run_failure_model();\n Y.run_repair_model();\n X.sleep();\n Y.sleep();\n\n Monte Carlo model of whole system\n state = OCG;\n while(!done) {\n switch(state) {\n case OCG:\n cpufailtime = X.get_sample(cpu);\n gmemfailtime = Y.get_sample(gmem);\n if(cpufailtime < gmemfailtime) {\n state = 1CG;\n time += cpufailtime;\n } else {\n state = 0CG;\n time += gmemfailtime;\n }\n }\n }\n}\n\nFigure A.4: The Monte Carlo program that uses the failure and repair submodel.\nBibliography\n\n\n133\nVita\n\nKumar K. Goswami received his B.S. degree in Computer Science from Embry-Riddle Aeronautical University in 1982. From 1982 to 1984 he was a software engineer in General Electric's Simulation and Control Systems Division. From 1984 to 1986 he was employed by Raytheon's Equipment Division in Sudbury, Massachusetts where he was one of the project leaders responsible for the design of a distributed, fault-tolerant operating system for the AOSP project. He has had summer internships at the Jet Propulsion Laboratory in California and at IBM's T.J. Watson Research Center. He received his M.S. degree in Computer Science from the University of Illinois at Urbana-Champaign in 1988. He is a candidate for the Ph.d in Computer Science at the University of Illinois and is supported by a NASA Graduate Student Researcher's Fellowship. Upon completion of his dissertation, he will join Tandem Computers in Cupertino, California."}}},{"rowIdx":182,"cells":{"id":{"kind":"string","value":"80823481a5ade3f47c783777575866921cfff187"},"text":{"kind":"string","value":"Building Efficient Distributed Systems: A Domain-Specific Language Based Approach\nLaurent Réveillère\n\nTo cite this version:\n\nHAL Id: tel-00814406\nhttps://tel.archives-ouvertes.fr/tel-00814406\nSubmitted on 17 Apr 2013\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.\nHABILITATION À DIRIGER DES RECHERCHES\n\nau titre de l’école doctorale de Mathématiques et Informatique de Bordeaux\n\nprésentée par\nLaurent RÉVEILLÈRE\n\nTitre:\n\nBuilding Efficient Distributed Systems: A Domain-Specific Language Based Approach\n\nDéveloppement de systèmes distribués efficaces: une approche fondée sur les langages métiers\n\nsoutenue le 23 Novembre devant la commission d’examen\n\nPr. Yolande BERBERS Rapporteurs\nPr. Laurence DUCHIEN\nPr. Jan VITEK\nPr. Xavier BLANC Examineurs\nDr. Julia LAWALL\nDr. Christine MORIN\nDr. Gilles MULLER\nSummary\n\nIn recent years, many distributed systems have evolved to cope with the convergence of their domain and computer networks. As an example, Internet telephony has drastically change the face of the telecommunications domain in the last decade by introducing many new services based on Web services and databases. Distributed systems that provide advanced services must be efficient to be able to treat a large number of users and must be robust to face various attacks targeting the service itself or the underlying platform. However, building efficient and robust distributed systems requires an intimate knowledge of the relevant protocols and a substantial understanding of low-level system and network programming, which can be a challenge for many programmers. Nevertheless, the development process of distributed systems still remains rudimentary and requires a high level of low-level expertise.\n\nIn this thesis, we show that domain-specific languages (DSLs) can successfully reduce the level of expertise required to build efficient and robust distributed systems, making service programming in the reach of average developers. We present three contributions in this area. Our first contribution targets the creation of telephony services based on the SIP protocol. We have defined a domain-specific virtual machine for SIP and a DSL named SPL, providing the programmer with high-level notations and abstractions dedicated to telephony service development. The robustness of SPL has been a key factor in expediting service deployment. A variety of services have been written in SPL, demonstrating the usability and ease of programming of the language. Our second contribution is Zebu, a DSL-based approach for the development of network application protocol-handling layers. We have demonstrated, through various experiments, that this approach is a reliable alternative to manual development in the context of protocol-handling layers. Zebu generated code has good performance and has a significantly lower memory footprint than comparable existing manually encoded solutions, while guaranteeing the robustness and performance properties. The third contribution of this thesis is z2z, a generative approach to gateway construction that enables communication between devices that use incompatible protocols. Z2z includes a compiler that checks essential correctness properties, and a runtime system that hides low-level details from the gateway programmer. We have used z2z to automatically generate gateways between various incompatible protocols. The generated gateways run with a low runtime memory footprint, with essentially no runtime overhead.\n<table>\n<thead>\n<tr>\n<th>Contents</th>\n<th>1 Introduction</th>\n<th>2 SPL: a Language-Based Approach for Internet-Telephony Service Creation</th>\n<th>3 Zebu: A Language-Based Approach for Network Protocol Message Processing</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1.1 Domain-specific languages</td>\n<td>1.1 Domain-specific languages</td>\n<td>2.1 Introduction</td>\n<td>3.1 Introduction</td>\n</tr>\n<tr>\n<td>1.2 Context</td>\n<td>1.2 Context</td>\n<td>2.2 SIP Background</td>\n<td>3.2 Protocol-Handling Layer</td>\n</tr>\n<tr>\n<td>1.3 Contributions</td>\n<td>1.3 Contributions</td>\n<td>2.2.1 SIP Services</td>\n<td>3.2.1 Protocol Requirements</td>\n</tr>\n<tr>\n<td>1.4 Outline</td>\n<td>1.4 Outline</td>\n<td>2.2.2 Requirements</td>\n<td>3.2.2 Application Requirements</td>\n</tr>\n<tr>\n<td>2.1 Introduction</td>\n<td>2.1 Introduction</td>\n<td>2.3 SIP Virtual Machine</td>\n<td>3.3 Related Work</td>\n</tr>\n<tr>\n<td>2.2 SIP Background</td>\n<td>2.2 SIP Background</td>\n<td>2.3.1 Operations</td>\n<td>3.4 The Zebu Language</td>\n</tr>\n<tr>\n<td>2.2.1 SIP Services</td>\n<td>2.2.1 SIP Services</td>\n<td>2.3.2 Events</td>\n<td>3.4.1 HTTP-like protocol messages and ABNF</td>\n</tr>\n<tr>\n<td>2.2.2 Requirements</td>\n<td>2.2.2 Requirements</td>\n<td>2.3.3 Sessions</td>\n<td>3.4.2 Protocol-related aspects</td>\n</tr>\n<tr>\n<td>2.3 SIP Virtual Machine</td>\n<td>2.3 SIP Virtual Machine</td>\n<td>2.4 The Session Processing Language</td>\n<td>3.4.3 Application-related aspects</td>\n</tr>\n<tr>\n<td>2.3.1 Operations</td>\n<td>2.3.1 Operations</td>\n<td>2.4.1 Sessions</td>\n<td>3.4.4 Specification verifications</td>\n</tr>\n<tr>\n<td>2.3.2 Events</td>\n<td>2.3.2 Events</td>\n<td>2.4.2 Handlers</td>\n<td>3.5 The Zebu Toolchain</td>\n</tr>\n<tr>\n<td>2.3.3 Sessions</td>\n<td>2.3.3 Sessions</td>\n<td>2.4.3 Intra-Handler Control Flow</td>\n<td>3.5.1 Developing a network application with Zebu</td>\n</tr>\n<tr>\n<td>2.4 The Session Processing Language</td>\n<td>2.4 The Session Processing Language</td>\n<td>2.4.4 Inter-Handler Control Flow</td>\n<td>3.5.2 Message parsing</td>\n</tr>\n<tr>\n<td>2.4.1 Sessions</td>\n<td>2.4.1 Sessions</td>\n<td>2.5 Safety Properties</td>\n<td>3.5.3 Message creation</td>\n</tr>\n<tr>\n<td>2.4.2 Handlers</td>\n<td>2.4.2 Handlers</td>\n<td>2.6 Formal Semantics</td>\n<td>3.5.4 Generating an execution environment for an embedded system</td>\n</tr>\n<tr>\n<td>2.4.3 Intra-Handler Control Flow</td>\n<td>2.4.3 Intra-Handler Control Flow</td>\n<td>2.6.1 Static semantics</td>\n<td></td>\n</tr>\n<tr>\n<td>2.4.4 Inter-Handler Control Flow</td>\n<td>2.4.4 Inter-Handler Control Flow</td>\n<td>2.6.2 Dynamic semantics</td>\n<td></td>\n</tr>\n<tr>\n<td>2.5 Safety Properties</td>\n<td>2.5 Safety Properties</td>\n<td>2.7 Related Work</td>\n<td></td>\n</tr>\n<tr>\n<td>2.6 Formal Semantics</td>\n<td>2.6 Formal Semantics</td>\n<td>2.8 Conclusion</td>\n<td></td>\n</tr>\n<tr>\n<td>2.6.1 Static semantics</td>\n<td>2.6.1 Static semantics</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2.6.2 Dynamic semantics</td>\n<td>2.6.2 Dynamic semantics</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2.6.3 Application verifications</td>\n<td>2.6.3 Application verifications</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2.7 Related Work and Assessment</td>\n<td>2.7 Related Work and Assessment</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2.8 Conclusion</td>\n<td>2.8 Conclusion</td>\n<td></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>\nChapter 1\n\nIntroduction\n\nSince I obtained my PhD in December 2001, I have been working on four research topics: domain-specific language (DSL) engineering, DSLs for building streaming applications, DSLs for building efficient distributed systems, and protocol interoperability. I briefly describe below the main results achieved for each topic.\n\n**Domain-specific language engineering.** I have contributed to the design of a new methodology to develop DSL compilers, centered around the use of generative programming tools. Our approach enables the development of a DSL compiler to be structured on facets that represent dimensions of compilation. Each facet can then be implemented in a modular way, using generative programming tools. These tools enable modeling the high-level nature of DSLs and the richness of the built-in domain-specific information in terms of program generation. The originality of our methodology is that it modularizes the program generation process of a DSL compiler. This work was published at Dagstuhl 2004 [29] and GPCE 2005 [28].\n\n**DSL for building streaming applications.** I have participated in the design of Spidle, a domain-specific language for specifying streaming applications. The development of multimedia streaming applications is becoming an increasingly important software activity. More and more new formats compete to structure the main media types, creating an explosion in format converters. The need for continuous innovation in the multimedia device industry has shifted an increasing part of stream processing from hardware to software, to shorten the time-to-market. However, due to the lack of programming language support, the development of streaming applications tends to be labor-intensive, cumbersome and error-prone. The originality of our language-based approach is that it offers high-level, declarative constructs compared to general purpose languages, and it improves robustness by enabling a variety of verifications to be performed. Compiled Spidle programs have performance that is roughly comparable to compiled equivalent C programs. This work was published at GPCE 2003 [27].\n\n**DSLs for building efficient distributed systems.** I have participated in the design of domain-specific languages that are used as core building blocks in efficient distributed systems. In particular, we designed SPL, a language for creating telephony services based on the SIP protocol. This work was published at ICIN 2006 [18], ICC 2006 [17], IPTCComm 2007 [78], and led to an European patent in 2008 [19]. Subsequently, to ease the development of protocol-handling layers of network applications that use textual HTTP-like application protocols, such as SIP, we have designed the Zebu language. This work was published at SRDS 2007 [21] and TSE 2011 [22]. We have also designed z2z, a generative approach to gateway construction that enables communication between devices that use incompatible protocols. The originality of our approach is that it simplifies gateway construction, a problem that has not been considered by previous frameworks for gateway development. We have shown that gateways generated from z2z are robust and efficient. This work was published at Middleware 2009 [15] and Middleware 2010 [7].\nProtocol interoperability. I have participated in the design of the Starlink framework, a general framework into which runtime generated interoperability logic can be deployed to connect two heterogeneous protocols. The key contribution of Starlink is the ability to create and deploy runtime solutions to interoperability using only high-level models of protocol behavior. This work was published at ICDCS 2011 [12]. We have extended the Starlink framework to model both applications and protocols such that the code to interoperate can be generated dynamically. The originality of our approach lies in the fact that it does not focus on only one of the relevant dimensions (i.e. application or protocol) while making assumptions about the common nature of the other. This work was published at Middleware 2011 [13].\n\nIn this document, I focus on the work I carried out on DSLs for building efficient distributed systems. In the remainder of this chapter, I first present domain-specific languages and describe the context of this work. Then I briefly introduce the main contributions. Finally, I describe the outline of the rest of the document.\n\n1.1 Domain-specific languages\n\nA domain-specific language is a programming or specification language dedicated to a particular domain or problem. A DSL provides appropriate built-in abstractions and notations; it is often small, more declarative than imperative, and less expressive than a general-purpose language. Literally hundreds of DSLs are in existence today. Some are distributed worldwide and used on a daily basis, e.g., SQL, Unix shells, makefiles, etc. DSLs have been used in various domains such as graphics [38], financial products [4], telephone switching systems [49], protocols [24, 95], operating systems [84], device drivers [71], routers in networks [95] and robot languages [8]. As a result of these successes, DSLs have recently received a lot of attention from both the research and industrial communities [30, 48]. The following points explain why DSLs are more attractive than general-purpose languages (GPLs) for a variety of applications.\n\nEasier programming. Because of appropriate abstractions, notations and declarative formulations, a DSL program can more concise and readable than its GPL counterpart. Hence, development time is shortened and maintenance can be improved. As programming focuses on what to compute as opposed to how to compute, and thus the user does not have to be a skilled programmer. Specific optimization strategies can be implemented in the DSL compiler not only to offer performance but also to systematize it.\n\nSystematic re-use. Most GPL programming environments include the ability to abstract common operations into libraries. However, re-use of libraries is left to the programmer. In contrast, a DSL offers guidelines and built-in functionalities which enforce re-use. Additionally, a DSL captures domain expertise, either implicitly by hiding common program patterns in the DSL implementation, or explicitly by exposing appropriate parameterization to the DSL programmer. Thus, the programmer necessarily re-uses library components and domain expertise.\n\nImproved safety. DSLs enable more properties about programs to be automatically checked. In contrast to a GPL, the semantics of a DSL can be restricted to make decidable some properties that are critical to a domain [95]. Detecting errors early in the development process also improves productivity. In addition, as re-use is not only improved but systematized, DSL programs rely on components that are frequently used and thus well tested.\n\nIn practice, the formulation in terms of a DSL suggests an attractive way to architecture software to implement a program family. In the remainder of this document, we present contributions that target program families in the context of distributed systems.\n1.2 Context\n\nDistributed systems often provide advanced services to cope with user expectations. However, building such systems is challenging because they must efficiently process various kinds of network messages, support service development without sacrificing robustness, and allow the composition of heterogeneous independently developed services.\n\nDistributed systems rely on protocols to define the set of rules governing communication between network applications. This communication is managed by the part of the application known as the protocol-handling layer, which enables the manipulation of protocol messages. This layer is a critical component of a network application since it represents the interface between the application and the outside world. It must thus satisfy two constraints: it must be efficient to be able to treat a large number of messages and it must be robust to survive various attacks targeting the application itself or the underlying platform. Nevertheless, the process of developing code for this layer still remains rudimentary and requires a high level of expertise in networking and system programming.\n\nMany distributed systems have evolved to cope with the convergence of their domain and computer networks. As an example, Internet telephony has drastically change the face of telecommunications in the last decade. Telephony over IP enriches the domain of telecommunications with a host of new functionalities such as Web services and databases and makes service creation a key technology enabler. Service creation thus becomes a vast application area, ranging from organizing the telephone communications within a small business to managing calls in telemarketing centers. However, programming these kinds of services requires an intimate knowledge of a variety of protocols and technologies, as well as expertise in system programming, networking, and telephony protocol APIs. These requirements make service engineering an overwhelming challenge for many programmers.\n\nNowadays, independently developed distributed systems often must be composed together to provide advanced services. However, existing systems are highly heterogeneous in their interaction methods making such composition challenging. Applications and systems are developed using a multitude of incompatible protocols that limit interoperability, and thus the practical benefit of systems composition. Protocol standardization should address this issue but has been demonstrably ineffective in practice. Indeed, new competing protocols are frequently introduced to address the needs of new application domains (e.g. sensors, ad-hoc networks, Grid Computing, Cloud Computing, etc.), whereas standardization is slow in comparison. To address this issue, gateways are needed to translate between the various kinds of heterogeneous protocols. Gateway construction, however, requires an intimate knowledge of the relevant protocols and a substantial understanding of low-level network programming, which can be a challenge for many application programmers.\n\n1.3 Contributions\n\nThis thesis presents three contributions to building efficient distributed systems. I briefly introduce them below, before presenting them in detail in the next chapters.\n\nThe SPL Language for Internet-Telephony Service Creation The first contribution presented in this thesis is SPL, an expressive language to ease the development of telephony services without sacrificing safety. SPL relies on a domain-specific virtual machine for SIP (SIP VM) that provides a design framework for service development based around the notion of a session. The design of SPL has resulted from a thorough analysis of the requirements for a language for programming Internet telephony services. Because SPL offers high-level abstractions, it frees the service developer from low-level programming details and complexities of the underlying technologies. SPL guarantees critical properties that cannot be verified in general-purpose languages (GPLs), by introducing domain-specific concepts and semantic restrictions.\n\nAlthough various approaches have been proposed to develop SIP-based telephony services, they are still limited. Indeed, many of these approaches are based on general-purpose programming languages\nChapter 1\n\nsuch as C, Java and C#. Platforms that rely on these languages offer the programmer a powerful but complicated access to advanced functionalities. Although expressive, these approaches cannot enforce the safe execution of a service. To overcome these limitations, some of these platforms introduce restricted scripting languages such as CPL [61] and LESS [100] for service programming. However, services written using these scripting languages are usually limited to coarse-grained processing or a selection of fixed treatments.\n\nTo address these issues, we have proposed a DSL approach for developing telephony services based on a combination of a dedicated virtual machine and a dedicated programming language. We have defined a domain-specific virtual machine, named the SIP VM, that provides a high-level interface, dedicated to service development. This virtual machine is centered around the notion of a session, consisting of a set of events and a state, which structures the development of a telephony service. Furthermore, by abstracting over the platform, the SIP VM enables services to be portable. The SIP virtual machine, combined with common programming patterns found in telephony services, forms the main ingredient in the design of SPL. SPL introduces notations and abstractions that are specific to the domain of telephony services, facilitating the development process and offering expressivity. Indeed, SPL enables a programmer to concentrate on defining what the service logic should do as opposed to dealing with every detail of how to implement it. SPL introduces notations and abstractions that are specific to the domain of SIP telephony services, facilitating the development process and offering expressiveness. The static and dynamic semantics of SPL have been formally specified, enabling a precise definition of SPL’s interaction with the SIP VM.\n\nA variety of services have been written in SPL for our university department. In these experiments, we have demonstrated the usability and ease of programming of SPL. Its robustness has been a key factor in expediting service deployment.\n\nThis work was initiated in collaboration with Charles Consel. In this context, I participated with him in the PhD supervision of Laurent Burgy [20], Fabien Latry [59], and Nicolas Palix [77] who were involved in the SPL project.\n\nThe Zebu Language for Network Protocol Message Processing The second contribution presented in this thesis is Zebu, a language to ease the development of protocol-handling layers of network applications. Zebu has been designed for HTTP-like protocols, which are text-based and line-oriented. Such protocols include SIP, RTSP, and SMTP. HTTP-like protocols are widely used, to provide interoperability between diverse applications and devices, and because the text representation makes debugging easy.\n\nAlthough protocol-handling layers are a critical component of a network application, both in terms of robustness and performance, their development process remains rudimentary. Indeed, it requires a high level of expertise in multiple domains to be able to meet these robustness and performance requirements. In addition, protocols are also often extensible, as illustrated by the SIP protocol which currently has more than 150 proposed extensions. Thus, it is often not sufficient to simply develop one protocol-handling layer for a given protocol and reuse it in all applications. Instead, protocol-handling layers must be continually developed and extended to take into account new protocol variants.\n\nTo address these issues, we have proposed Zebu, a DSL to ease the development of protocol-handling layers. Zebu can generate a parser directly from an RFC specification expressed as ABNF with only a few modifications. Auxiliary constraints on message values can be added as annotations within the ABNF specification provided to Zebu. Because Zebu parsers are based on the protocol specification, they can also validate the message structure, thus improving robustness. In experiments involving messages known to be difficult to parse, we have shown that protocol-handling layers based on Zebu detect 100% of erroneous received messages, as opposed to 25% for existing, widely used, manually developed parsers. Zebu incorporates a number of state-of-the-art strategies for efficiently parsing and crafting messages for HTTP-like protocols, thus relieving the developer of the need to identify and hand-code these strategies. These optimizations address not only run-time performance but also memory usage. Experiments have shown that Zebu-generated protocol code and hand-written code with equivalent levels of robustness have the same performance.\nIntroduction\n\nI have initiated this work and supervised the PhD thesis of Laurent Burgy [20] on this project\n\nThe Z2z framework for Automatic Generation of Network Protocol Gateways The third contribution presented in this thesis is z2z, a generative approach to gateway construction that enables communication between devices that use incompatible protocols. A gateway provides interoperability between two fixed protocols, and thus must be developed separately for every pair of protocols between which interaction is needed. The diversity of protocols that are used in a networked environment implies that this is a substantial development task. To reduce the development effort, indirect bridges translate messages to and from a single fixed intermediary protocol. This approach, however, may limit expressiveness, as some aspects of the relevant protocols may not be compatible with the chosen intermediary protocol.\n\nA gateway must take into account the different degrees of expressiveness of the source and target protocols and the range of communication methods that they use. Each of these issues requires substantial expertise in network programming, and the need to address both of them at once makes gateway development especially difficult.\n\nTo address these issues, we have proposed z2z, a new approach to gateway development. Our approach relies on the use of a domain-specific language (DSL) for describing protocol behaviors, message structures, and the gateway logic. The DSL relies on advanced compilation strategies to hide complex issues from the gateway developer such as asynchronous message responses and the management of dynamically-allocated memory, while remaining in a low-overhead C-based framework. We have implemented a compiler that checks essential correctness properties and automatically produces an efficient gateway implementation. We have implemented a runtime system that addresses a range of protocol requirements, such as unicast or multicast transmission, association of responses to previous requests, and management of sessions.\n\nWe show the applicability of z2z by using it to automatically generate gateways between SIP and RTSP, between SLP and UPnP, and between SMTP and SMTP via HTTP. The gateway specifications are 100-400 lines of z2z code. The generated gateways are at most 150KB of compiled C code and run with a memory footprint of less than 260KB, with essentially no runtime overhead.\n\nI have initiated this work in collaboration with David-Yérom Bromberg who had been recruited as an associate professor at the University of Bordeaux at the beginning of the project. I am currently supervising three PhD students who are involved in the z2z project.\n\n1.4 Outline\n\nThe thesis is organized as follow. Chapter 2 presents the SPL language for Internet-telephony service creation. Chapter 3 presents the Zebu language for network protocol message processing. Chapter 4 presents the z2z framework for networks protocol gateway generation. Finally, Chapter 5 concludes the thesis and gives some directions for future work.\nChapter 2\n\nSPL: a Language-Based Approach for Internet-Telephony Service Creation\n\nThis chapter presents SPL (Session Processing Language) [18, 17, 78, 19], a domain-specific language for creating telephony services. SPL offers domain-specific constructs, abstracting over the intricacies of the underlying technologies. By design, SPL guarantees critical properties that are difficult or impossible to verify when using general-purpose languages. SPL relies on a domain-specific virtual machine, named the SIP VM. This virtual machine introduces a design framework for service development based around the notion of a session. We show that SPL and the SIP VM can be used to develop and deploy real services, demonstrating the practical benefits of our approach.\n\n2.1 Introduction\n\nIn recent years, telephony has increasingly converged with networks and multimedia. This has led to a rapid evolution in the telephony domain. Now that telephony can interact with systems such as databases and Web services, it can offer a host of new functionalities. Meanwhile, telephony services represent a vast application area, ranging from organizing the telephone communications within a small business to telemarketing centers.\n\nAt the forefront of modern telephony is the Session Initiation Protocol (SIP) [89, 88]. SIP is a fast-emerging signaling protocol for Voice over IP (VoIP) and third generation mobile phones. It is standardized by the IETF\\(^1\\) and adopted by the ITU.\\(^2\\) This protocol enables creating, modifying and terminating a communication between parties. Communications include audio/video communications, games, and instant messaging. SIP supports user mobility by giving a user a symbolic address that can be associated with various communication devices. It also provides for user availability; that is, willingness of a callee to accept a dialog. SIP is based on a client-server model. A SIP platform is typically implemented as a distributed system that consists of servers providing the various SIP functionalities. A fast-growing number of SIP platforms is becoming available; some target telephone carriers, others small businesses. A SIP platform can either be located at the core or at the edge of the network.\n\nA variety of approaches have been proposed for developing services targeting SIP-based systems. Many of these approaches are based on general-purpose programming languages such as C, Java and C#. Platforms that rely on these languages offer the programmer a powerful but complicated access to advanced functionalities. Although expressive, these approaches cannot enforce the safe execution of a service. To overcome these limitations, some platforms introduce a restricted scripting language such as CPL [61] and\n\n---\n\n\\(^1\\)IETF: Internet Engineering Task Force.\n\n\\(^2\\)ITU: International Telecommunications Union.\nLESS [100] for service programming. However, services written using these scripting languages are usually limited to coarse-grained processing or dedicated treatments. To combine expressivity and simplicity, some platforms such as the Microsoft Live Communication Server introduce hooks to shift the processing of a SIP message from a restricted scripting language (MSPL [73]) to a powerful API (C#).\n\nRealizing the potential of SIP requires a proliferation of telephony services. Yet, the origins and combined technologies used in the telephony domain make software engineering of telephony services an overwhelming challenge. To develop a service, a programmer must have an extensive expertise in the telephony domain, SIP and related protocols, distributed programming, networking, and SIP APIs. Correct use of all of these features is paramount because telephony is often heavily relied on and a buggy service can make telephony unavailable to a specific user, or even to all the users of a platform.\n\nThis chapter\n\nThis chapter presents SPL, an expressive language to ease the development of telephony services without sacrificing safety. SPL relies on a domain-specific virtual machine for SIP (SIP VM) that provides a design framework for service development based around the notion of a session. The design of SPL has resulted from a thorough analysis of the requirements for a language for programming Internet telephony services. Because SPL offers high-level abstractions, it frees the service developer from low-level programming details and intricacies of underlying technologies. SPL guarantees critical properties that cannot be verified in general-purpose languages (GPLs), by introducing domain-specific concepts and semantic restrictions.\n\nContributions\n\nThe contributions of SPL are as follows.\n\nSIP Virtual Machine. To remedy the shortcomings of existing APIs, we have defined a domain-specific virtual machine, named the SIP VM, that provides a high-level interface, dedicated to service development. This virtual machine is centered around the notion of a session, consisting of a set of events and a state, which structures the development of a telephony service. Furthermore, by abstracting over the platform, the SIP VM enables services to be portable.\n\nSession Processing Language. The SIP virtual machine, combined with common programming patterns found in telephony services, forms the main ingredient in the design of SPL. SPL introduces notations and abstractions that are specific to the domain of telephony services, facilitating the development process and offering expressivity. The syntax of an SPL service reflects the SIP VM session structure. Each kind of session is represented by a block containing the declarations of the variables and handlers associated with the session. Indeed, SPL enables a programmer to concentrate on defining what the service logic should do as opposed to dealing with every detail of how to implement it.\n\nFormalized semantics. SPL introduces notations and abstractions that are specific to the domain of SIP telephony services, facilitating the development process and offering expressiveness. The static and dynamic semantics of SPL have been formally specified, enabling a precise definition of SPL’s interaction with the SIP VM.\n\nOutline\n\nThe rest of this chapter is organized as follows. Section 2.2 presents SIP in more detail and defines requirements for a language dedicated to programming telephony services. Sections 2.3 and 2.4 introduce the SIP\nvirtual machine and SPL. Section 2.5 describes SPL safety properties. Section 2.6 describes the static and\ndynamic semantics of SPL and its relationship with the underlying SIP virtual machine. Section 2.7 dis-\ncusses related work and presents an assessment of our approach. Finally, Section 2.8 concludes the chapter\nwith some final remarks.\n\n2.2 SIP Background\n\nSIP is based on a client-server model. A SIP message can be sent or received by a client. A sent message\nis said to be outgoing; a received message is said to be incoming.\n\nSIP messages SIP is a text-based protocol similar to other recent protocols such as HTTP\\(^3\\) and RTSP.\\(^4\\) A\nSIP message begins with a line indicating whether the message is a request (including a protocol method\nname) or a response (including a return code). A sequence of required and optional headers follows.\nFinally, a SIP message includes a body containing other information relevant to the message.\n\nLogically, SIP is composed of three main entities, depicted in Figure 2.1: a registrar server, a proxy\nserver, and a user agent. A registrar server allows a SIP user to record his current location. A proxy server\ndispatches SIP messages, whether incoming or outgoing, requests or responses. Typically, a SIP platform\nprovides a registrar server and a proxy server in each domain to manage the messages to or from the users\nin a given domain. Additional proxy servers may be present in the network. Finally, a user agent exists\nwithin each communication device, and performs all SIP-related actions on its behalf.\n\n\n\nTo support mobility, a user is assigned a SIP URI (Uniform Resource Identifier), which is a symbolic\naddress, analogous to an e-mail address. When a SIP proxy receives a message for a local URI, it asks the\nlocal registrar server to translate the URI into contact information for a specific user agent. A user must thus\ninform the registrar server of the user agent at which he would like to receive messages. As an example, the\ntop of Figure 2.1 shows that Laura, in the domain labri.fr, has SIP URI sip:laura@labri.fr. When Laura wants to be reachable via her IP phone, she sends a REGISTER request including the phone’s\naddress to the labri.fr registrar server. If the response is the success code OK, subsequent calls to\nLaura will be routed to her IP phone. For another example, at the bottom of Figure 2.1, Bob in domain\ninria.fr has set his current location to be his laptop by communicating its IP address when registering.\n\n\\(^3\\)HTTP is the HyperText Transfer Protocol for transferring World Wide Web documents.\n\\(^4\\)RTSP is the Real Time Streaming Protocol for controlling the delivery of data with real-time properties.\nChapter 2\n\nMaking a call To further present SIP, we describe the main steps involved in making a call, illustrated by Bob calling Laura once they have both registered their current location. To make the call, Bob’s user agent emits an INVITE request including his current location and the callee’s SIP URI, sip:laura@labri.fr. Like an e-mail message, the request is routed through a sequence of proxy servers until it reaches the domain labri.fr. At this point, the labri.fr proxy server queries the registrar server to locate Laura and forwards the request to her IP phone. Upon receipt of the request, Laura’s phone starts ringing. If she picks it up, an OK response, including Laura’s location, is sent back to the caller. Bob then sends an ACK message to Laura to confirm the establishment of the call. At this point a conversation can start. When either Bob or Laura wants to end the conversation, they hang up the phone, causing their user agent to send a BYE request to the other party.\n\nManagement of SIP communications The SIP protocol introduces four concepts used in the management of communications: transaction, dialog, subscription and registration.\n\n- A transaction consists of a request and the response it triggers. For example, a REGISTER request sent to a user agent and its response form a transaction. A SIP message includes headers identifying the transaction it belongs to.\n\n- A dialog is a SIP relationship between two user agents that persists for some time. A dialog is initiated by an INVITE request and confirmed by an ACK request. A SIP message includes a header identifying the dialog it belongs to. A dialog persists until one party sends a BYE request.\n\n- A subscription allows a SIP user to request notification from a remote user agent when a certain event occurs. For example, one may subscribe to a presence event, to be informed when a particular user becomes available. A user interested in an event sends a SUBSCRIBE request to the responsible remote user agent, named the notifier. When the event occurs, the notifier sends a NOTIFY request to the subscriber. A subscription must be refreshed periodically.\n\n- A registration comprises the dialogs created by a user via the information provided to a particular registrar server. A registration persists until the user unregisters or his registration expires.\n\n2.2.1 SIP Services\n\nMost SIP platforms allow users to install services on an additional SIP entity known as a feature server. A service processes incoming and outgoing messages, essentially acting as a router.\n\nWe illustrate the notion of SIP service with our example. Suppose that a service has been installed for Laura that allows only customer calls to reach her IP phone during office hours. When Laura’s proxy server receives the INVITE request from Bob, it invokes the associated feature server to obtain her service. The service is launched by the SIP platform with the INVITE request as input. If Bob’s SIP URI is not part of Laura’s customer list, the service rejects it by returning an error response (e.g., UNAUTHORIZED). If Bob is a customer, the service gives control back to the SIP platform to forward the INVITE request to Laura’s user agent (i.e., her IP phone). Forwarding this request creates a new transaction that ends when the response is received or confirmed. If Laura is already on the phone, her user agent sends a BUSY HERE response back to the service. The service may then redirect the call to her voice mail, creating another transaction.\n\nA SIP service may require that some state be associated with a given transaction, dialog, or registration. For example, Laura’s service uses a customer list, which needs to be maintained while she is registered. The use of such state requires that the proxy server retain enough information to be able to associate relevant SIP messages to an existing transaction, dialog, or registration. The treatment of such messages is said to be stateful. Statefulness has some cost, and consequently very frequently executed services, such as those associated with an entire domain, are typically designed without any transaction, dialog, or registration state.\n2.2.2 Requirements\n\nRequirements for telephony service programming have been already partially identified by Lennox [62]. Based on these results, we have conducted a study of different existing SIP platforms and the paradigm they introduce for developing telephony services [16]. This analysis is based on our experience on designing and implementing domain-specific programming languages (DSLs). As a result, we have revisited Lennox’s requirements for a language dedicated to telephony service creation.\n\n**Accessible** To enable users with limited programming experience and little domain expertise to develop their own services, a language for service creation needs to provide high-level abstractions that protect the programmer from having to be aware of the intricacies of both the platform and the underlying protocols. In doing so, an entire class of errors can be eliminated. The resulting services are easier to read, develop and maintain.\n\n**Robust and safe** The telephony domain imposes stringent safety and robustness requirements. These intervene at two levels: First a telephony service should execute without runtime errors under all circumstances, to ensure continuity of service for other calls. Second, a telephony service should respect the invariants of the underlying protocol. Therefore, a language for service creation needs to fulfill these requirements, either by construction or by enabling domain-specific program analyzes.\n\n**Expressive** Ensuring the safe execution of a service written in a given programming language must not be done at the expense of the expressivity and usability of that language. Service developers should be able to use mainstream general-purpose language features as well as domain-specific language constructs.\n\n2.3 SIP Virtual Machine\n\nAll existing SIP APIs pursue the same goal: offering both in-depth and in-breadth access to the SIP protocol. In practice, this goal has translated into very large and complex APIs. Because these APIs are based on general-purpose languages, the service programmer must write repetitive glue code as the prologue and epilogue of API invocations. APIs also offer little support for structuring services or for managing service data. Finally, SIP APIs are platform-specific and thus do not permit portability.\n\nTo alleviate these problems, we define a domain-specific virtual machine for SIP, named the SIP VM, providing the programmer with a high-level portable interface dedicated to telephony service development. The SIP VM raises the level of abstraction of the SIP protocol to match the needs of telephony service developers. This VM sits within a SIP application server, between the SIP platform and the SIP services. The SIP VM mainly introduces the notions of operations, events, and sessions. We examine each of these components.\n\n2.3.1 Operations\n\nA SIP service typically performs some computation, forwards a SIP request and returns a SIP response. Within these computations, the SIP VM distinguishes signaling operations, which send a SIP message over the network, from non-signaling operations, which perform arithmetic and other local calculations.\n\n**Signaling operations** The SIP VM defines the operation forward to allow a service to forward a request. To use this operation, the service provides not only a pointer to the request, but also the service’s current code pointer and state. When the corresponding response is received, the SIP VM restores the code\npointer and state of the service, thus causing the execution of the service to continue from the point of forwarding the request.\n\nAfter completing the processing of a request, a service has to return a SIP response. Typically, a service returns the response it received after performing a forward operation. However, some services must return a constant SIP response without forwarding any request, and thus must be able to forge responses. For example, a service that implements a block list must return a reject response code (e.g., 486) to any blacklisted caller. The SIP VM thus introduces abstractions and operations to manipulate SIP responses, including operations to forge a SIP response from the current request.\n\nNon-signaling operations The SIP VM also defines non-signaling operations such as arithmetic and boolean operations. These operations allow services to perform various computations. In addition, the SIP VM includes an extension framework to enable a service to call external procedures. Such procedures may be available on the local machine or may be invoked via remote procedure calls.\n\n2.3.2 Events\n\nThe SIP VM defines three kinds of events to which a service can react: verbatim events, refined events and platform events. When a SIP request is received, the VM generates the corresponding event. If the meaning of the SIP request is unambiguous (e.g., ACK), then the request is transmitted as a verbatim event, i.e., as is. Some requests are, however, context sensitive, and require interpretation. For example, the SIP request INVITE either initiates a dialog or, if used in the context of an existing dialog, modifies dialog characteristics. The VM thus refines a SIP INVITE request as either the event INVITE, in the former case, or the event REINVITE in the latter. A platform event notifies a service of events internal to the platform that are relevant to the service logic. For example, the platform event unregister indicates the expiration of a SIP user registration.\n\nTable 2.1 lists the events provided by the SIP VM. The names of verbatim and refined events are noted in uppercase to indicate that they correspond to a SIP message. The corresponding handler code in a service must perform at least one signaling operation. The names of platform events are noted in lowercase to indicate that they do not correspond to a SIP message.\n\n<table>\n<thead>\n<tr>\n<th>Concepts</th>\n<th>Events</th>\n<th>Initial</th>\n<th>Medial</th>\n<th>Final</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Service</td>\n<td>deploy</td>\n<td></td>\n<td></td>\n<td>undeply</td>\n</tr>\n<tr>\n<td>Registration</td>\n<td>REGISTER</td>\n<td>REREGISTER</td>\n<td>unregister</td>\n<td></td>\n</tr>\n<tr>\n<td>Dialog</td>\n<td>INVITE</td>\n<td>CANCEL</td>\n<td>ACK</td>\n<td>BYE</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>REINVITE</td>\n<td>uninvite</td>\n</tr>\n<tr>\n<td>Subscription</td>\n<td>SUBSCRIBE</td>\n<td>RESUBSCRIBE</td>\n<td>NOTIFY</td>\n<td>unsubscribe</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.1: Classification of SIP VM events\n\n2.3.3 Sessions\n\nThe SIP protocol defines a session as a multimedia communication dialog. SIP requests and time-outs enable to create, confirm, modify and terminate a dialog. Therefore, they define a complete lifecycle for a dialog session.\n\nIn the context of the SIP VM, we generalize this notion of a session lifecycle to the context of a subscription, a registration, and a service. A session is thus created when subscribing to an event, registering a user, or deploying a service. It persists until un-subscribing to the event, un-registering the user or undeploying the service. The events generated by the SIP VM correspond to specific points in the lifecycle.\nof the various SIP concepts. The events are thus classified as initial (creation), medial (confirmation and modification) and final (termination), as shown in Table 2.1.\n\nA service typically performs some computations before triggering a signaling action. For example, a load-balancing service for a company would compute the total time each employee has spent answering the telephone to decide who should take the next call. To allow services to manipulate session states throughout their lifecycle, the SIP VM attaches a state to a session. This state is saved and restored by the SIP VM across event notifications.\n\n2.4 The Session Processing Language\n\nBuilding on our experience in developing DSL, we propose a new language, SPL (Session Processing Language), for developing telephony services. This language includes domain-specific constructs and semantics. It is designed around the abstractions furnished by the SIP VM. This section describes the salient features of SPL. The complete grammar of SPL is provided in Appendix A.\n\n2.4.1 Sessions\n\nThe structure of an SPL service reflects the SIP VM session structure. Each kind of session is represented by a block containing the declarations of the variables and handlers associated with the session. Sessions are organized into a hierarchy, with a service session at the root, the registration sessions created within the service session as its children, and dialog and subscription sessions at the leaves. A session at any level has access to all of the variables of its ancestor sessions.\n\nAs an example, Figure 2.2 shows the SPL service sec_calls, that implements a counter service. This service maintains a counter of the calls that have been forwarded to a secretary, whenever the SIP user associated with the service is unable to take the call. The counter is set to 0 when the user registers, incremented when a call is forwarded to the secretary, and logged when the user unregisters. An outermost processing block declares service variables and functions, such as the external function log, followed if needed by handler definitions for deploy and undeploy (absent in our example). A registration block is defined inside the processing block. In our example, the registration block defines the cnt variable, a REGISTER handler, which initializes the counter, and an unregister handler, which logs the counter. Finally, a dialog block is defined inside the registration block. The dialog block only declares an INVITE handler. When an incoming call is rejected by the user, this handler increments the cnt variable, which is defined in the ancestor session (i.e., the registration block).\n\nAs illustrated by the counter service, SPL does not require explicit state manipulation. Specifically, the cnt variable is defined and used as in any programming language. Such a variable results in the creation of a state object; variable manipulations are automatically mapped by SPL into access, save and restore operations.\n\n2.4.2 Handlers\n\nFor each event generated by the SIP VM, an SPL service may define a handler to describe how the service should react to the event. In the case of verbatim and refined events, the handler processes a complete SIP transaction from the request to the final response. Platform events do not correspond to a SIP request. Therefore, the handler for such an event only performs non-signaling operations. A handler may be designated as either incoming or outgoing to provide a specific behavior for messages received or emitted by the user associated with the service, respectively. By default, a handler treats both incoming and outgoing requests.\nThe `INVITE` handler in Figure 2.2 (lines 17-24) illustrates SPL transaction processing for incoming `INVITE` requests. In this example, the `forward` operation (line 18) is used initially to forward an incoming call to the original recipient. This operation yields control to the SIP VM, which resumes the handler when a response is received. This response is then stored in the variable `r` and checked in line 19. SPL offers domain-specific abstractions and operations for such processing of SIP responses: Comparing a response to `/SUCCESS` checks whether the response code of the response is in the range 2xx, while comparing a response to `/ERROR` checks whether the response code of the response is greater than 300. In the example, if the call was not accepted, the original request is redirected to the secretary (line 21) and the new response is returned to the caller. If the call was accepted, the success response that was stored in `r` is returned directly (line 23).\n\nAs a component of a SIP application server, the SIP VM may receive requests at any time. To simplify SPL programming, the SIP VM never invokes a handler during the execution of another handler. Instead, events are queued by the SIP VM until the handler being executed yields control to the SIP VM, either due to a `forward` or a `return` operation. At this point, the SIP VM sends the request or response, respectively, out on the network and treats other pending requests. In the case of a `forward`, when a response arrives, the SIP VM resumes the handler containing the `forward` operation. The execution of a handler is thus atomic between two yield points, i.e., two signaling operations.\n\n### 2.4.3 Intra-Handler Control Flow\n\nHandlers for verbatim or refined control methods typically perform some computation and then forward the SIP request. This forwarding yields control to the SIP platform, which sends the request. In existing SIP APIs, when the response is received, the service code must explicitly correlate the response with the request. Then, some computation must be performed to restore the control flow suspended at the forward point before processing the response.\n\nOne of the goals of SPL is to factorize these tedious and error-prone computations out of the service. In SPL, a handler is written as a single unit that processes a transaction from the request to the response. When a handler needs to forward a message, it uses the `forward` expression, that gives the SIP VM the current code pointer and state. When the corresponding response is received, the SIP VM restores the code.\nSPL: a Language-Based Approach for Internet-Telephony Service Creation\n\n```plaintext\nservice waiting_queue {\n [...] registration {\n [...] dialog {\n [...] response incoming INVITE() {\n response resp = forward;\n if (TO == 'sip:secretary@enseirb.fr') {\n [...] return resp branch secretary;\n } else {\n [...] return resp branch private;\n }\n }\n }\n }\n [...] response incoming ACK() {\n branch secretary {\n // Specific treatment for secretary session\n [...] return branch private { ... }\n }\n }\n}\n```\n\nFigure 2.3: Inter-handler control flow\n\nNotice that forward can be invoked with or without a URI. When no URI is provided, the current request is forwarded to the original destination (i.e., Request-URI as defined in the SIP RFC 3261 [89]).\n\nThe INVITE handler in Figure 2.2 illustrates SPL transaction processing. In this example, an incoming call is forwarded to the user and his response is assigned to the variable r. The response is then checked. If the call was not accepted, the original request is redirected to the secretary and the new response is returned to the caller. If the call was accepted, the success response is returned directly.\n\n2.4.4 Inter-Handler Control Flow\n\nNot only is a session a design thread, but it also represents a thread of control. The SIP protocol describes a coarse-grained session control flow, i.e., in a dialog control may flow from INVITE, to ACK, to BYE. To enhance expressiveness, SPL allows the programmer to refine the control-flow specification via a branch mechanism that passes control information from one handler to the next. This abstraction permits, e.g., classifying a session as either personal or professional, and then introducing a logical personal or professional sub-thread across the remaining handler invocations of the session. As shown in Figure 2.3, the classification is done by adding the name of the branch to the return from the current handler (e.g., line 12) and the threads are implemented in each handler using the branch construct (e.g., lines 22-25).\n\nA branch is chosen for a session when the session is created. The branch is stored in the session state and is used to select the relevant code for each subsequent handler invocation in the session. For a service or registration session, the initial branch is default. On returning, a handler can specify a new branch, which overwrites the current one. When a service or registration handler is invoked, the code corresponding to the current branch is chosen, or the code corresponding to the default branch, if nothing else applies. Dialog and subscription sessions are treated similarly, except that the initial branch is inherited.\nfrom the current branch of the parent registration session and branches accumulate rather than overwrite. On invoking a method, the code corresponding to the branch appearing earliest in the accumulated sequence of branches is selected.\n\nThe branch construct is not only convenient for the programmer, it also increases the amount of information that is available to static verifications of SPL programs. Specifically, as the branch mechanism is a built-in language construct, it enables inter-handler control flow information to be determined accurately, before execution time. If this mechanism were not available, the programmer could simulate the same behavior using flags stored in the session state and conditionals in each handler testing the flag values. In this case, however, the control-flow information represented by the branches would not in general be apparent to the verifications associated with SPL (see e.g., Section 2.6.1), which would result in a less precise analysis.\n\nBranches are illustrated in Figure 2.3 by fragments of a secretary service, written in SPL. When an INVITE request is sent to the secretary SIP URI, the secretary branch is selected (line 12). When the callee is a named person, the private branch is chosen (line 16). When the ACK request is received, the processing depends on whether the call is private or for the hotline. The correct branch is automatically selected.\n\n2.5 Safety Properties\n\nThe telephony domain imposes stringent safety and robustness requirements. A service should not itself incur runtime errors and should respect the underlying protocol. We consider some kinds of errors that can occur when programming SIP services with existing SIP APIs, and show how SPL has been designed either to prevent these errors outright or to enable static verifications that detect these errors in SPL services.\n\n**Erroneous call processing** A SIP service must ultimately perform some signaling action, such that no call is lost. Furthermore, the treatment of each message must be compliant with the SIP RFC 3261 [89]. For example, when a handler successfully forwards a message, it cannot then return an error. For another example, a handler is dedicated to a unique kind of request (e.g., INVITE) and thus cannot forward a message of another kind (e.g., ACK).\n\nIn SPL, signaling actions are associated with explicit keywords, such as forward for forwarding a request and SUCCESS for matching a success response, allowing the SPL verifier to straightforwardly check that every execution path through a handler performs at least one signaling action, and that these signaling actions are coherent with each other. Furthermore, the SPL language prevents changing the method name when forwarding a request; the only argument to forward is the destination, leaving the request structure, and thus the method name, implicit.\n\nA SIP message contains a number of headers, of which some are optional or read-only. Furthermore, as SIP messages are implemented as text, the underlying implementation of all headers is as strings, although a header may have a more intuitive meaning as e.g. an integer or a URI. Errors may include accessing a header that is not present in the current message, trying to modify the value of a read-only header, interpreting a header value as the wrong type of value, or writing the wrong type of value to a header. The SPL language prevents access to a header that is not present, via the use of the when construct that combines both a check for the presence of the header and access to the header value. SPL also provides the with construct for updating header values. In this case, the SPL verifier checks that uses of this construct only mention writable headers. Both constructs allow for headers to be treated as string-typed or to be accessed using more intuitive types; in the latter case the SPL verifier checks the validity of the type coercion.\n\n**Erroneous state and control management** A SIP service typically does some initial processing of a request and then forwards the request to one or more parties. Typical SIP APIs separate this service logic into separate entry points for request and response processing. This strategy breaks up the treatment of a\ngiven method, making it difficult to follow the service logic, and implies that state that is needed across the forwarding of a request must be saved and restored manually, a tedious and error-prone operation. In SPL, request and response processing are contiguous, within a single unit, with a forward operation being no more disruptive to the program structure than an ordinary procedure call. Local variables are implicitly saved and restored across a forward. Furthermore, SPL allows variables to be associated with an entire service, a registration, or a dialog, transparently managing the access to these variables across method invocations, thus ensuring that this data is manipulated in a consistent way.\n\nErroneous resource management SIP APIs based on general-purpose languages do nothing to protect against safety errors that can occur in these languages. For example, APIs do not protect against infinite loops, and APIs based on C do not protect against out-of-bounds accesses to data structures or accesses to freed data. SPL allows only bounded loops by the use of foreach, and includes appropriate checks on data structure accesses, as found in Java. Furthermore, SPL has no mechanism for dynamically allocating data, ensuring that service execution fits within a known memory bound.\n\n2.6 Formal Semantics\n\nWe have formally specified the semantics of SPL, enabling a precise definition of its interaction with the SIP VM. This formal definition serves as a foundation for defining program analyses. In this section, we describe both the static and dynamic semantics of SPL, focusing on the semantics of sessions, method invocations, and forward expressions.\n\n2.6.1 Static semantics\n\nThe purpose of the static semantics of a language is to specify what properties can be inferred about programs in that language, before execution. In the case of SPL, we present a static semantics that focuses on message forwarding. This static semantics can be enriched to consider other static properties, such as type safety.\n\nIn SPL, when a handler needs to forward a message, it uses the forward expression. This forwarding yields control to the SIP VM, which sends the request. When a positive response is received (i.e., a 2xx response code), no additional forwarding of the request is allowed and the response should be returned as the result of the handler. This restriction prevents a service from forwarding a call to someone other than the party who accepted it. We now present an analysis that ensures that this restriction is satisfied for any program written in SPL.\n\nAbstract Syntax\n\nFor conciseness, we focus on a subset of SPL related to forward operations, noted SPL_{fwd}. The abstract syntax of SPL_{fwd} is presented in Figure 2.4. We only consider handlers that return a response value and declarations that introduce variables of type response.\n\nAbstracting an SPL program into its SPL_{fwd} counterpart is straightforward. This is illustrated by the counter service previously shown in Figure 2.2, whose SPL_{fwd} counterpart is displayed in Figure 2.5. In addition, we assume that standard program transformations such as copy propagation and constant propagation are performed to obtain the SPL_{fwd} program.\nChapter 2\n\n\\[ H ::= \\text{response } \\text{DIR}_{opt} \\text{ method_name } \\{ D^* S \\} \\]\n\\[ \\text{DIR}_{opt} ::= \\text{None} | \\text{Some} (\\text{DIR}) \\]\n\\[ \\text{DIR} ::= \\text{incoming} | \\text{outgoing} \\]\n\\[ D ::= \\text{response } x_1 \\]\n\\[ S ::= \\text{id} = \\text{fwd} \\text{ URI}_{opt} | \\text{return } E_R | \\epsilon \\]\n\\[ \\text{cond} (E_B, S_1, S_2) | S_1 ; S_2 \\]\n\\[ \\text{URI}_{opt} ::= \\text{None} | \\text{Some} (\\text{URI}) \\]\n\\[ E_R ::= \\text{id} | \\text{/ERROR} | \\text{/SUCCESS} \\]\n\\[ E_B ::= \\text{id} == E_R \\]\n\\[ \\text{URI} ::= \\text{constant} | \\text{id} \\]\n\nFigure 2.4: Abstract syntax of the \\( SPL_{fwd} \\) language\n\n\\begin{verbatim}\nresponse Some(incoming) INVITE {\n response r;\n r = fwd None;\n cond (r == /ERROR,\n r = fwd Some(...); return r,\n return r)\n}\n\\end{verbatim}\n\nFigure 2.5: INVITE handler of the counter service in \\( SPL_{fwd} \\)\n\nSemantic Rules\n\nThe semantic rules of \\( SPL_{fwd} \\) are described as inference rules with a sequence of premises above a horizontal bar and a judgment below the bar (see Figure 2.6). A judgment of the form \\( \\tau_1 \\vdash^D \\text{decs} : \\tau_2 \\) (rules 2.1 and 2.2) means that the evaluation of the declarations \\( \\text{decs} \\) in the environment \\( \\tau_1 \\) returns a new environment \\( \\tau_2 \\). A judgment of the form \\( \\tau_1 \\vdash^S \\text{stmt} : (\\tau_2, \\Psi) \\) (rules 2.3 to 2.8) means that the evaluation of the statement \\( \\text{stmt} \\) in the context of the environment \\( \\tau_1 \\) returns the new environment \\( \\tau_2 \\) and the boolean value \\( \\Psi \\). This value becomes \\text{false} as soon as an illegal use of \\text{forward} is detected.\n\nA judgment of the form \\( \\vdash^H \\text{response } \\text{dir}' \\text{ method_name } \\{ D S \\} : \\Psi \\) (rule 2.9) means that the evaluation of the handler \\text{response } \\text{dir}' \\text{ method_name } \\{ D S \\} returns the boolean value \\( \\Psi \\). If \\( \\Psi \\) is \\text{false}, the handler contains an illegal use of \\text{forward} and is rejected. If \\( \\Psi \\) is \\text{true}, the handler does not contain an illegal use of \\text{forward} and is accepted.\n\nA judgment of the form \\( \\tau \\vdash^{E_R} \\text{exp} : \\sigma \\) (rules 2.10 to 2.12) means that the evaluation of the expression \\( \\text{exp} \\) in the environment \\( \\tau \\) returns the status \\( \\sigma \\). The status is \\text{success} if the expression is known to return a response code in the 2xx class, \\text{error} if the expression is known to return a response code not in the 2xx class, and \\( \\bot \\) if the response code returned by the expression is not known. These status values form a partial order, with \\( \\bot \\subseteq \\text{success} \\) and \\( \\bot \\subseteq \\text{error} \\). We use this ordering to determine how to merge environments in the static semantics of a conditional (rule 2.7).\n\nFinally, a judgment of the form \\( \\tau \\vdash^{E_B} \\text{bool_exp} : (id, \\sigma) \\) (rule 2.13) means that the evaluation of a boolean expression in the environment \\( \\tau \\) returns a pair of an identifier \\( id \\) and a status value \\( \\sigma \\). The only boolean expressions allowed by \\( SPL_{fwd} \\) are equalities that compare an identifier to a description of a response, and thus evaluating such an expression to true or false gives information about the response code stored in the identifier. The information that can be obtained is then represented as a pair of the identifier \\( id \\) and the corresponding status value \\( \\sigma \\).\n\nThe key points of the analysis are in the treatment of \\text{forward} (rules 2.3 and 2.4) and the treatment of conditionals (rule 2.7). Because the response received from a \\text{forward} is always stored in a variable,\nSPL: a Language-Based Approach for Internet-Telephony Service Creation\n\nthe environment $\\tau$ is essentially a record of the effect of the forwards that have taken place. If there is any variable whose value is success or $\\bot$, then some previous forward has or may have succeeded. In either case (rule 2.3) the forward is illegal and false is returned. Only if every variable has the value error (rule 2.4), do we know that all previous forwards have failed and the current forward is allowed. In both rules, the environment is updated by binding the identifier $id$ to $\\bot$, to indicate that the result of its forward has not been tested, and thus might be success. Finally, testing of the result of a forward takes place in a cond statement (rule 2.7), and uses rules 2.10 to 2.13. In rule 2.7, the “then” branch, $S_1$, is analyzed with respect to an environment reflecting the fact that the test is true, and the “false” branch, $S_2$, is analyzed with respect to an environment reflecting the fact that the test is false. The latter environment is constructed using the operator $\\neg$, defined as $\\neg$success = error, $\\neg$error = success and $\\neg\\bot = \\bot$. The treatment of the statements $S_1$ and $S_2$ yields the two new environments $\\tau_1$ and $\\tau_2$. Because either may be available at execution time, the static semantics merges them using the operator $\\uplus$: $\\tau \\times \\tau \\rightarrow \\tau$, defined as follows:\n\n$$\\tau_1 \\uplus \\tau_2 = \\{ (x, \\sigma_1 \\cap \\sigma_2) \\mid (x, \\sigma_1) \\in \\tau_1 \\land (x, \\sigma_2) \\in \\tau_2 \\}$$\n\nThis operator ensures that if the response for some forward is unknown in either branch, or is considered to have different values in the two branches, then the value of the corresponding variable becomes $\\bot$. \n\nFigure 2.6: The static semantics of SPLfwd\n2.6.2 Dynamic semantics\n\nThe purpose of a dynamic semantics is to specify what happens when a program is executed. We now present the dynamic semantics of SPL, examining the relationship between the language constructs and the underlying virtual machine. For conciseness, we ignore the branch construct. The complete dynamic semantics of SPL can be found here [77].\n\nSessions \nSPL is designed around the concept of a session, encapsulating a set of variables and handlers. To identify sessions uniquely, each session is associated with a unique label. To describe the position of a session in the hierarchy, a session is furthermore associated with an address, which is a sequence of the labels of the session and its ancestors. Information about a session is stored in a global state $\\sigma$, mapping an address to a tuple containing some status information about the session, a session environment mapping the session variables to their values, and a list of the addresses of the sub-sessions:\n\n$$\\sigma \\in \\text{state} = \\text{address} \\to \\text{status} \\times \\text{env} \\times \\text{address list}$$\n\nThe semantics of SPL uses the following set of functions that manipulate sessions: create_session, prepare_method_invocation, continue_session, and end_session.\n\nThe function create_session extends the global state with an entry for a new session and has the following type,\n\n$$\\text{create_session} : \\text{program} \\times \\text{state} \\times \\text{address} \\times \\text{method_name} \\to \\text{state}$$\n\nThe entry’s status information includes a flag true indicating that the session is live and a reference count 0 indicating that no handler is currently executing in the session. The entry’s session environment is obtained by evaluating the session variable declarations in an environment binding the session variables of the ancestor sessions. Finally, the entry’s list of sub-sessions is empty. The result is a new global state.\n\nOnce a session has been created, methods can be invoked within the session. Method invocation is initiated using the function prepare_method_invocation, of type:\n\n$$\\text{prepare_method_invocation} : \\text{program} \\times \\text{state} \\times \\text{address} \\times \\text{method_name} \\times \\text{direction} \\to \\text{decl list} \\times \\text{stmt} \\times \\text{env list} \\times \\text{state}$$\n\nThis function extracts the declarations and body associated with the method, retrieves the sequence of session environments associated with the session and its ancestors, and increments the reference count, indicating that a handler is executing in the session. The declarations, body, and session environments are returned, with a new global state.\n\nExecution of handler code manipulates the sequence of session environments of the current session and its ancestors, as obtained by prepare_method_invocation. When execution of the handler code completes, these environments must be reinserted into the global state, which is done by the function continue_session, having the following type:\n\n$$\\text{continue_session} : \\text{program} \\times \\text{state} \\times \\text{address} \\times \\text{env list} \\to \\text{state}$$\n\nThe behavior of this function depends on whether the session is still live. If so, continue_session updates the global state with the new session environments and decrements the reference count, indicating that execution of the current handler has completed. If the session is no longer live, continue_session additionally calls end_session to determine whether the session should be destroyed.\n\nDue to the sharing of state between handlers and between sessions, the most complex part of session management is session termination. Termination of a session is requested either when execution of certain handlers returns an error code or upon invocation of a final method (see Table 2.1). Nevertheless, it is not always desirable to destroy the session immediately. One issue is that handlers of the current session or its sub-sessions may be waiting for responses. For example, a dialog session can be waiting for a response to\nA REINVITE request sent by one party when it receives a BYE request sent by the other party. When the REINVITE response arrives, some code may be executed by the REINVITE handler, which may refer to the session variables. Thus, a session is only destroyed when its reference count is 0, indicating that no handler is executing in the session. Another issue is that in some cases, a session may end from the point of view of SIP, but should persist at the SPL level. An example is a registration session, which terminates at the SIP level either on an explicit request or on expiration of a timer. Registration, however, is not necessary for existing dialogs or subscriptions to continue, and these dialogs or subscriptions may refer to the registration variables. Final methods are thus classified as persistent, meaning that the session no longer accepts sub-sessions but is not destroyed until all sub-sessions terminate, or non-persistent, meaning that the session and all sub-sessions terminate immediately, subject to the reference count constraint. For example, the method unregister for registrations is persistent, while the method undeploy, for services, is non-persistent to allow a system administrator to take down the system in a timely manner. Session termination is managed by the function end_session, which is invoked by continue_session whenever the session is not live.\n\nMethod invocation The semantics of SPL terms is described using a continuation-based abstract machine [1]. Execution in this machine is specified as a sequence of configurations, starting with a configuration representing the receipt of a message and ending with a configuration representing the returning of some information to the SIP VM. Intermediate configurations represent the execution of a term or the invocation of a continuation. A continuation is analogous to the stack used in the standard implementation of a procedural language. Whenever the semantics begins the execution of a term, it adds a frame to the continuation storing all of the information required to continue execution from the point of that term. This approach makes each configuration self-contained, and is used in the semantics of forward. The configurations used in the small step semantics of method invocation are as follows, where \\( \\phi \\) is the service code, \\( \\sigma \\) is a pair of the destination of the request and an environment containing bindings derived from the message headers of the request and \\( s \\) is a continuation:\n\n- Method invocation: \\( \\phi, \\sigma \\models (method\\_name(address), direction, uri) \\)\n- Method continuation: \\( (\\sigma, address), (envs, uri, local\\_env) \\models s, resp \\)\n- Handler body: \\( (\\sigma, address), envs, uri, s \\models decls, stmt \\)\n- Handler statement: \\( (\\sigma, address), (envs, uri, local\\_env), s \\models stmt \\)\n- Return to the SIP VM: \\( resp, \\sigma \\)\n\nThe semantic rules are described as inference rules, with a sequence of premises above a horizontal bar, and the current configuration and the next configuration in the execution sequence below the bar, separated by an arrow. We focus on dialog methods. The treatment of other kinds of methods is similar.\n\nAn initial INVITE method creates a new dialog session:\n\n\\[\n\\begin{align*}\n\\text{create\\_session}(&\\phi, \\sigma, address, undialog) = \\sigma' \\\\\n\\text{prepare\\_method\\_invocation}(&\\phi, \\sigma', \\text{INVITE}, direction) = (\\text{decls}, stmt, envs, \\sigma'') \\\\\n\\phi, \\sigma &\\models (\\text{INVITE(address), direction, uri}) \\Rightarrow (\\sigma'', address), envs, uri, (\\text{INV } \\phi) \\models \\text{decls, stmt} \\\\\n\\text{continue\\_session}(&\\phi, \\sigma, address, envs) = \\sigma' \\\\\n(\\sigma, address), (envs, envs) &\\models (\\text{INV } \\phi), /SUCCESS/resp \\Rightarrow /SUCCESS/resp, \\sigma' \\\\\n\\text{set\\_persistence}(&\\sigma, address, false) = \\sigma' \\\\\n\\text{continue\\_session}(&\\phi, \\sigma', address, envs) = \\sigma'' \\\\\n(\\sigma, address), (envs, envs) &\\models (\\text{INV } \\phi), /ERROR/resp \\Rightarrow /ERROR/resp, \\sigma''\n\\end{align*}\n\\]\nThe first rule initiates the method invocation by creating the session and extracting the handler code and relevant session environments. The rule produces (bottom line) a configuration causing execution of the handler code. The continuation in this new configuration is labeled INV, indicating that after executing the handler body, some work should be done that is specific to an INVITE method. The second and third rules describe the invocation of this continuation. In the second rule, the result of the handler is a success code, in which case it only remains to update the global state using continue_session. In the third rule, the result of the handler is an error code, in which case set_persistence is called to indicate that the session is no longer live and that its termination should be nonpersistent (indicated by false). These changes to the session status cause the subsequent call to continue_session to call end_session to destroy the session.\n\nInvocation of a medial or final dialog method is similar, except without the use of create_session. At the end of a medial method, the session always continues, and thus the continuation rule for a medial method is analogous to the /SUCCESS rule for the INV continuation. At the end of a final method, the session always terminates, and thus the continuation rule for a final method is analogous to the /ERROR rule for the INV continuation. While the termination of a session due to an error code in an initial method is always nonpersistent, the termination of a session due to invocation of a final method depends on the persistence associated with the method itself. The third argument to set_persistence is thus adjusted accordingly.\n\nMethod body Evaluation of the body of a handler starts by creating an environment with the values of local variables, as described by the following rule.\n\n\\[\n\\begin{align*}\n\\langle \\text{envs}, \\text{uri}, \\emptyset \\rangle \\vdash d & : \\text{local}\\_env \\\\\n\\rho & = \\langle \\text{envs}, \\text{uri}, \\text{local}\\_env \\rangle \\\\\n\\tau, \\text{envs}, \\text{uri}, \\emptyset & \\vdash d, \\text{stmt} \\Rightarrow \\tau, \\rho, \\emptyset, s\n\\end{align*}\n\\]\n\nExpressions We consider a simplified set of expressions, as shown Figure 2.4, in which there is only identifiers, constants, and one binary operator for equality testing. The semantics of expression uses the following configurations:\n\n- Expression: \\( \\langle \\sigma, \\text{address} \\rangle, \\langle \\text{envs}, \\text{uri}, \\text{local}\\_env \\rangle, s \\vdash \\text{exp} \\)\n- Expression continuation: \\( \\langle \\sigma, \\text{address} \\rangle, \\langle \\text{envs}, \\text{uri}, \\text{local}\\_env \\rangle \\vdash s, \\text{value} \\)\n\nvalue is an arbitrary value.\n\nEquality is associated with two continuations: \\((\\text{EQ1 exp}_2)\\) and \\((\\text{EQ2 v}_1)\\). The first continuation stores the second expression to evaluate. The second continuation stores the result of the evaluation of the first expression, so as to compare it with the result of the evaluation of the second expression. The semantic rules for expression are as follows:\n\n\\[\n\\begin{align*}\n\\tau, \\rho, s \\vdash x & \\Rightarrow \\tau, \\rho, s \\vdash s(x) \\\\\n\\tau, \\rho, s \\vdash \\text{cst} & \\Rightarrow \\tau, \\rho, (\\text{EQ1 exp}_2) :: s \\vdash \\text{exp}_1 \\\\\n\\tau, \\rho \\vdash (\\text{EQ1 exp}_2) :: s & \\Rightarrow \\tau, \\rho, (\\text{EQ2 v}_1) :: s \\vdash \\text{exp}_2 \\\\\n\\tau, \\rho \\vdash (\\text{EQ2 v}_1) :: s, v_2 & \\Rightarrow \\tau, \\rho, v_1 == v_2\n\\end{align*}\n\\]\nStatements The semantics of statements uses the following configuration:\n\n\\[(\\sigma, \\text{address}), (\\text{envs}, \\text{uri}, \\text{local}_\\text{env}) \\models_s s, \\text{resp}_\\bot\\]\n\nIn this configuration, \\(\\text{resp}_\\bot\\) is either a response or \\(\\bot\\) when no response is returned as it is the case for statements other than \\text{return} and \\text{forward}. The following semantic rules use \\text{SEQ}, \\text{RETURN}, \\text{FORWARD} and \\text{COND} to denote the continuations for sequence, return, forward and conditional statements.\n\n\\[\n\\tau, \\rho, s \\models_i S_1 ; S_2 \\Rightarrow \\tau, \\rho, (\\text{SEQ} \\ S_2) :: s \\models_i S_1\n\\]\n\n\\[\n\\tau, \\rho, s \\models_i \\text{return exp} \\Rightarrow \\tau, \\rho, (\\text{RETURN}) :: s \\models_i \\text{exp}\n\\]\n\n\\[\n\\tau, \\rho, s \\models_i \\text{cond} (E, S_1, S_2) \\Rightarrow \\tau, \\rho, (\\text{COND} \\ S_1 \\ S_2) :: s \\models_i \\text{exp}\n\\]\n\n\\[\n\\tau, \\rho \\models_i (\\text{COND} \\ S_1 \\ S_2) :: s, \\text{true} \\Rightarrow \\tau, \\rho, s \\models_i S_1\n\\]\n\n\\[\n\\tau, \\rho \\models_i (\\text{COND} \\ S_1 \\ S_2) :: s, \\text{false} \\Rightarrow \\tau, \\rho, s \\models_i S_2\n\\]\n\n\\[\n\\tau, \\rho \\models_i (\\text{RETURN}) :: s, \\text{resp} \\Rightarrow \\tau, \\rho \\models_i s, \\text{resp}\n\\]\n\n\\[\n\\tau, \\rho \\models_i (\\text{SEQ} \\ S_2) :: s, \\bot \\Rightarrow \\tau, \\rho, s \\models_i S_2\n\\]\n\nA statement can reinvoke the underlying machine via a \\text{forward} operation. For this, we have to bring \\(\\rho\\) up to date with respect to the changes that have occured in \\text{envs}. When control returns to the semantics, we similary have to obtain the new \\text{envs}. For these operations, we have to keep the environments separated. In the following, we consider only the case where \\text{forward} has no arguments, as illustrated in line 18 of Figure 2.2. The rules for the other case are similar.\n\n\\[\n\\text{update}_\\text{envs}(\\sigma, \\text{address}, \\text{envs}) = \\sigma'\n\\]\n\n\\[\n(\\sigma, \\text{address}), (\\text{envs}, \\text{uri}, \\text{local}_\\text{env}), s \\models_x x = \\text{forward}\n\\]\n\n\\[\n\\Rightarrow \\text{forward}(\\text{uri}, (\\text{FORWARD} \\ \\text{address} \\ \\text{uri} \\ \\text{local}_\\text{env}) :: (\\text{ASSIGN} \\ x) :: s), \\sigma'\n\\]\n\n\\[\n\\text{lookup}_\\text{envs}(\\sigma, \\text{address}) = \\text{envs}\n\\]\n\n\\[\n\\text{forward}_\\text{response}(\\text{resp}, (\\text{FORWARD} \\ \\text{address} \\ \\text{uri} \\ \\text{local}_\\text{env}) :: s), \\sigma\n\\]\n\n\\[\n\\Rightarrow (\\sigma, \\text{address}), (\\text{envs}, \\text{uri}, \\text{local}_\\text{env}) \\models_s s, \\text{resp}\n\\]\n\n\\[\n\\tau, \\rho \\models_s (\\text{ASSIGN} \\ x) :: s, v \\Rightarrow \\tau, \\text{update}(x, v, \\rho) \\models_s s, \\bot\n\\]\n\nThe first rule initiates the forwarding operation. This rule uses \\text{update}_\\text{envs} to update the global state with the current values of the session variables. Then, it calls the function \\text{forward} to pass the current continuation \\(s\\), as well as the address of the session and the values of local variables, to the SIP VM, which forwards the message. The second rule describes what happens when the response arrives, as indicated by the presence of a \\text{forward}_\\text{response} configuration. In this case, the SIP VM passes the response and the continuation used when calling \\text{forward} back to SPL, which reconstructs the environment and applies the continuation to the response in order to continue the handler execution. The last rule updates the value of \\(x\\) in the environment \\(\\rho\\) with the result of the previous forward operation and continues the execution of the handler.\n2.7 Related Work and Assessment\n\nVarious approaches have been proposed to develop SIP-based telephony services. The SIP Express Router platform [52] relies on a restricted configuration language to define the message routing logic. Its API also offers hooks to extend the core platform with modules written in C. However, analyzing such modules to ensure that a service respects the SIP protocol automaton can be very challenging. The Microsoft Live Communications Server [73] introduces a dedicated language for coarse-grained dispatch of SIP messages. Services that require advanced functionalities can shift the processing of a message to a C# program that can access the platform through a powerful API. Consequently, programmers must choose between expressiveness and simplicity. JAIN SIP [74] and SIP Servlet [53] are the standard Java interfaces to a SIP signaling stack. They provide a powerful solution for developing SIP services. However, programmers still have to deal with details of the protocol.\n\nHigh level scripting languages such as CPL [61], LESS [100] and CCXML [97] have emerged for developing SIP services. Some approaches have been proposed to verify properties of services written in these languages. For example, detection of interaction between features has been explored in the context of CPL [76, 102] and LESS [101]. However, none of these languages has been formally defined. Therefore, language implementations and verifications rely on informal specification found in the available documentation, making them subject to variation.\n\nThe formal definition of SPL serves not only as documentation but also as a foundation for implementing the language and its run time. Our first prototype implementation of the SPL interpreter was implemented in OCaml by a single developer in about one week. This implementation is a straightforward mapping of the dynamic semantics, where each inference rule is translated into an OCaml function. The complete semantics of SPL consists of about 100 inference rules. Our implementation of the SPL interpreter written in OCaml is very close in size. In addition to this first prototype, a developer has used the SPL semantics as a reference to implement a Java version. While being much more verbose, the Java version only required two weeks to develop. The implementation of the SIP VM presented in Section 2.3 has been developed in Java and is based on a JAIN-SIP stack [37].\n\nThe prototype implementation of the SIP VM and the SPL interpreter have been integrated to the SIP-based telephony system of our university, and various services have been written in SPL. In addition to traditional services such as black listing or conditional redirections, SPL has proved its usability to define advanced services. For example, an SPL service has been deployed that allows a secretary to manage incoming calls, using a waiting queue, depending on a shared agenda, availability of the personnel, and information about the call such as the name of the caller, if known. In these experiments, SPL has demonstrated its usability and ease of programming. In addition, our implementations based on the formal semantics described in Section 2.6 have proved their robustness while showing no significant performance penalty.\n\n2.8 Conclusion\n\nIn this chapter, we have presented a domain-specific virtual machine for SIP, providing the programmer with a high-level interface dedicated to telephony service development. This SIP VM is centered around the notion of a session that structures the development of a service. Additionally, we have introduced a DSL named SPL that offers high-level notations and abstractions for service development. This language hides the subtleties of SIP platforms, making programs more concise than their GPL counterparts, without sacrificing expressivity.\n\nSeveral languages have been proposed to make SIP-based service creation easier and faster. However, they are only defined informally, which makes it difficult for developers to understand the subtleties of the language or to implement the language and run-time systems. In contrast, SPL is formally defined, making explicit in a high-level way an expertise in SIP-based telephony service creation and a model for run-time systems. In our experience, this repository of knowledge has proved to be extremely valuable for\nporting SPL from OCaml to Java. Furthermore, formalizing SPL has made it possible to thoroughly cover both language and run-time design issues, prior to implementing the language. The static and dynamic semantics of SPL enable a precise definition of its interaction with the SIP VM. The formal definition of the SIP VM and SPL is a foundation for defining program analyses and serves as a documentation for both service programmers and platform developers.\n\nA variety of services have been written in SPL for our university department. In these experiments, SPL has demonstrated its usability and ease of programming. Its robustness has been a key factor in expediting service deployment.\nChapter 3\n\nZebu: A Language-Based Approach for Network Protocol Message Processing\n\nThis chapter presents Zebu [21, 22], a domain-specific language to ease the development of protocol-handling layers. Zebu specifies the protocol-handling layer of network applications that use textual HTTP-like application protocols. The Zebu language is based on the ABNF formalism used for protocols specifications and enables fine tuning the protocol-handling layer according to the needs of a particular application. We demonstrate, through various experiments, that this approach is a reliable alternative to manual development in the context of protocol-handling layers. We show that Zebu generated code has good performance and has a significantly lower memory footprint than comparable existing manually encoded solutions.\n\n3.1 Introduction\n\nIn the Internet era, many applications, ranging from instant messaging clients and multimedia players to HTTP servers and proxies, involve processing network protocol messages. This processing is performed by the protocol-handling layer of a network application, which must both parse messages as they are received from the network and craft new messages to be sent onwards. As the protocol-handling layer represents the front line of interaction between the application and the outside world, its correctness is critical; any bugs can leave the application open to attack [85]. In the context of in-network applications such as proxies, where achieving high throughput is essential, both message parsing and the crafting of new messages must be very efficient.\n\nIn this chapter, we concentrate on protocol-handling layers for HTTP-like protocols. These protocols are text-based and line-oriented, and include the Session Initiation Protocol (SIP) [89], for telephony over IP, the Real Time Streaming Protocol (RTSP), for negotiating multimedia parameters, and the Single Mail Transfer Protocol (SMTP) [83], for email transfer over the Internet. HTTP-like protocols are widely used, to provide interoperability between diverse applications and devices, and because the text representation makes debugging easy. For example, more than 150 extensions to the SIP protocol have been proposed. Thus, it is often not sufficient to simply develop one protocol-handling layer for a given protocol and reuse it in all applications. Instead, protocol-handling layers must be continually developed and extended to take into account new protocol variants.\n\nImplementing a correct and efficient protocol-handling layer for an HTTP-like protocol, however, is a difficult task. The message structure for such a protocol is typically defined in a “Requests for Comments” (RFC), using an extended form of BNF with English text specifying various properties of the message values. A BNF specification amounts to a state machine, which for efficiency is often implemented in an unstructured way using gotos, as exemplified by the SIP and RTSP parsers considered in our evaluation.\nChapter 3\n\n(Section 3.7). The resulting code is thus error-prone and hard to maintain, e.g., when a protocol extension needs to be supported. Because of the need to maximize throughput, performance is also a significant issue. One common approach to improve performance is to process message fragments only as they are needed, allowing the parser to skip fragments that are not needed for a given application. For example, a router normally only uses the message elements that describe the message destination [58]. However, when the skipped fields turn out to be needed in specific situations, complex parsing code may end up scattered throughout the application. Finally, HTTP-like protocols are increasingly used in embedded systems, to enable interoperability with other devices and to allow the reuse of existing network tools [56, 60, 94]. In addition to the need for efficient performance, embedded systems typically bring tight space constraints.\n\nIn the compiler construction community, parsers have long been constructed using automated parser generators such as yacc [54]. Nevertheless, such tools are not suitable for generating parsers for use in a protocol-handling layer, as the grammars provided in RFCs are often not context free, due to additional constraints present in the RFC text, and such tools provide no support for deferring the parsing of some message fragments. Thus, protocol-handling layers have traditionally been implemented by hand. This situation, however, is becoming increasingly impractical, given the variety and complexity of protocols and their extensions. Incorrect or inefficient parsing makes an application vulnerable to denial of service attacks, as illustrated by the “leading slash” vulnerability found in the Flash HTTP Web server [85].\n\nThis chapter\n\nIn this chapter, we propose to address the issues of correctness and efficiency of network protocol message processing code using a parser-generator-based approach. For this, we present a domain-specific language, Zebu, for describing HTTP-like text-based protocol message formats and related processing constraints. Zebu amounts to an annotated version of ABNF1 (Augmented BNF [34]), the variant of BNF used in RFCs. Using Zebu, developing a textual protocol network parser consists of copying the ABNF grammar found in the protocol specification and then adding some annotations to tailor the parser to application needs. Zebu complements ABNF with annotations indicating which message fields should be stored in the data structures provided to the application, and other semantic information. Fields can be declared as lazy, which gives the application control over the time when the field is parsed. A Zebu specification is processed by a compiler that translates the ABNF rules into regular expressions implemented using the PCRE library [50]. The result of this compilation is a set of stub functions that are to be used by an application to process network messages. Based on the annotations, this compiler implements domain-specific optimizations to reduce the memory usage of a Zebu-based application. Besides efficiency, Zebu also addresses robustness, as the compiler performs many consistency checks, and can generate parsing stubs that validate the message structure.\n\nContributions\n\nThe contributions of Zebu are as follows:\n\nEase of use. Zebu can generate a parser directly from an RFC ABNF specification, with only a few modifications to distinguish between requests and responses and to highlight certain parser entry points. Auxiliary constraints on message values, such as the bounds on integer values or constraints on the relationship between the values of multiple fields, as are typically found in the RFC text, can be added as annotations within the ABNF specification provided to Zebu.\n\nEase of integration with applications. Annotations can be added to the ABNF specification to indicate the message elements that are of interest to a given application. The Zebu compiler generates stubs that\n\n---\n\n1Currently, the implementation of Zebu relies on the PCRE library [50], implying that the ABNF must be limited to what can be expressed using regular expressions (see Section 3.4.4).\nprovide direct access to this information. Further annotations can be used to specify the types to be used for specific message element values, allowing these stub functions to convert these values from their string representation in the message to the data type that is most convenient for the application. This conversion also performs any entailed data consistency checks (e.g., a value specified to be a 16 bit integer is checked to have a value that fits within 16 bits). Finally, Zebu provides facilities for easing the integration of a protocol-handling layer into an embedded system.\n\n**Robustness.** Because Zebu parsers are based directly on the ABNF, they can be very robust. In experiments involving messages known to be difficult to parse, we show that protocol-handling layers based on Zebu detect 100% of erroneous received messages as opposed to 25% for existing, widely used, manually developed parsers.\n\n**Efficiency.** Zebu incorporates a number of state-of-the-art strategies for efficiently parsing and crafting messages for HTTP-like protocols, thus relieving the developer of the need to identify and hand code these strategies. These optimizations address not only run-time performance but also memory usage. Experiments have shown that Zebu-generated protocol code and hand-written code with equivalent levels of robustness have the same performance.\n\n**Outline**\n\nThe rest of this chapter is organized as follows. Section 3.2 provides some insights about network applications, their structure and the kind of programming they entail. Section 3.3 presents some previous work on improving the protocol-handling layer development process. Sections 3.4 and 3.5 describe the Zebu language, its implementation, and its integration into the development of a network application. The rest of the chapter assesses Zebu in terms of robustness and performance. Finally, Section 3.8 concludes the chapter with some final remarks.\n\n### 3.2 Protocol-Handling Layer\n\nWe focus on network processing at the application level, and more specifically on its lowest part, which we refer to as the protocol-handling layer. This layer enables communication between applications through application-centric protocols. It must take into account both the constraints of the protocol, which determine the message structure, and the requirements of the application, which determine how the message elements will be used. Typically, the protocol-handling layer amounts to 15-25% of the application code size and consumes 25% of the total message processing time [32, 31, 98]. This layer must thus be robust, efficient and maintainable/extensible. Combined with the inherent complexity of network protocol message formats, these three issues make the development of the protocol-handling layer very difficult.\n\n#### 3.2.1 Protocol Requirements\n\nThe protocol defines the structure of messages, and thus the definition of the message parser and the facilities for crafting new messages. The parser must receive incoming messages from the network, check their validity, and make the various message elements available to the application. The facilities for crafting new messages must in turn receive the data to transmit from the application and convert it to a format that respects the message structure defined by the protocol.\n\nIn developing a parser, the main difficulty is the large gap between the high level formalism, ABNF, used to specify protocols and the corresponding low-level code implemented by developers, typically in C, for efficiency. This gap is illustrated in Figure 3.1, which represents the ABNF grammar of one crucial SIP\nmessage element, the Via header, and Figure 3.2, which represents the corresponding code extracted from the SIP Express Router (SER) [58]. SER is a SIP proxy whose protocol-handling layer is considered as the reference in terms of protocol support, both in terms of robustness and efficiency. The parsing code for the Via header is implemented as a state machine involving 64 switches, 564 cases, 232 breaks and 143 gatos. Although efficient, such low-level code has major potential pitfalls; notably, overlooking a single instruction can corrupt the whole protocol-handling layer and lead to security vulnerabilities. The code is essentially unreadable, and is difficult to maintain and extend.\n\n\n\n```plaintext\nVia = ( \"Via\" / \"v\" ) HCOLON via-parm *(COMMA via-parm)\nvia-param = sent-protocol LWS sent-by *(SEMI via-params)\nvia-params = via-ttl / via-maddr / via-received / via-branch / via-extension\nvia-ttl = \"ttl\" EQUAL ttl\nvia-maddr = \"maddr\" EQUAL host\nvia-received = \"received\" EQUAL\nvia-branch = \"branch\" EQUAL token\nvia-extension = generic-param\nsent-protocol = name SLASH version SLASH transport\nname = \"SIP\" / token\nversion = token\ntransport = \"UDP\" / \"TCP\" / \"TLS\" / \"SCTP\" / other-transport\nsent-by = host [ COLON port ]\nttl = 1*3DIGIT ; 0 to 255\n```\n\n\n\n```plaintext\nfor (tmp=p;tmp<end;tmp++){\n switch(*tmp){\n case ' ': switch(state){\n case FIN_HIDDEN:\n case FIN_ALIAS:\n param->type=state;\n param->name.len=tmp-param->name.s;\n state=L_PARAM;\n goto endofparam;\n case FIN_BRANCH:\n case FIN_TTL:\n case FIN_MADDR:\n case FIN_RECEIVED:\n case FIN_RPORT:\n case FIN_I:\n param->type=state;\n param->name.len=tmp-param->name.s;\n state=L_VALUE;\n goto find_value;\n }...\n```\n\nAn additional difficulty in implementing a parser is that the protocol-handling layer must detect messages that are invalid according to the protocol specification and respect the expected behavior with valid messages. In practice, according to a recommendation from the IETF, protocol-handling layers should accept messages that are almost valid. However, if this permissiveness is not controlled, it can lead to security holes. For instance, one could take control of a machine hosting the virtual PBX Asterisk [92] by sending particular erroneous SIP messages.²\n\nIn developing code for crafting new messages, the main difficulty is that a network message for an HTTP-like protocol consists of a single string amounting to the concatenation of various message elements, not all of which may be provided by the application at the same time. Careful coding is thus required to\n\n²Asterisk SIP DoS vulnerability (empty REGISTER): http://www.securiteam.com/unixfocus/5VP0C0UKUO.html\naccumulate this information as it becomes available and then to use it to construct a complete message, without too much memory allocation and copying. The latter is particularly significant in the case of embedded systems where memory resources may be scarce.\n\n3.2.2 Application Requirements\n\nApplications differ in the means by which they request message elements, the format in which they expect to receive the message data, and the elements of the message they need to be informed about. We examine these application requirements in turn.\n\nThere are basically three ways for an application to interact with the protocol-handling layer: event-driven, black-box and delegate. In an event-driven model, the protocol-handling layer raises events when it has identified a subpart of a message and these events are then caught by the application logic. The application logic must keep track of what has been parsed. The black-box approach considers the protocol-handling layer as an opaque component. The message is only manipulated through a refined view made accessible by stubs. Getter and setter stubs enable getting and modifying information within a message. Composer stubs enable crafting new messages. In this case, the application logic is unaware of the data layout and of what has actually been parsed. The last approach is to provide the application logic with full access to the message representation. The protocol-handling layer waits until it has received the whole message to build a data structure that is then hoisted to the application logic. The application logic then has full access to the message elements.\n\nWhen the protocol-handling layer makes available a message element to the application logic, it can provide the information about the message according to a more or less refined view. A raw presentation is a flat view consisting of the sequence of tokens found in the message. A hierarchical presentation groups the tokens of each message subpart into a separate data structure. Finally, a logical presentation includes some interpretation of the message elements, for instance with each kind of message element being represented by its proper application-level type.\n\nThe information about a message required by the application logic may differ according to the nature of the application being implemented. For instance, a web proxy may only need to look at a few message elements to perform some sanity checks and then at the actual destination to perform its task. On the other hand, a proxy such as Squid [99] that uses caching needs some additional information such as the object associated with the requested resource and some time-stamps. Finally, protocol gateways, translating messages from a source protocol towards a target one, examine only the message elements that can be projected into the target protocol.\n\nIn the case of Zebu, we target applications using the black box approach, to which the parser provides a logical view of the message, and where the parser can be constrained to only parse the fields that are relevant to the application. These choices reduce the programming burden on the application developer, by encapsulating complicated parsing and analysis in the generated code, while eliminating unnecessary work in the parser, thus providing efficiency.\n\n3.3 Related Work\n\nThis section presents some existing approaches that have the goal of easing the development of the protocol-handling layer, while addressing the challenges of robustness, efficiency, maintainability and extensibility.\n\nThe domain-specific language PADS [43] provides a generic approach to easing data processing, targeting semi-structured ad hoc data, such as web server logs. A PADS description is a sequence of type declarations similar to those found in C, plus some semantic constraints on the data. This approach is, however, ill suited for developing network application protocol support. First, the language is very far from the ABNF notation, and thus requires a potentially complex specification translation phase. Notably, some elements of textual protocols, such as URLs, cannot be expressed precisely in terms of standard types and\nChapter 3\n\nthus must be represented using regular expressions. Regular expressions may in practice be substantially more complicated than ABNF, as illustrated later in this chapter with an extract of the regular expression for URLs (Figure 3.10). Furthermore, the main objective of PADS is to be able to process data records of several gigabytes (it was indeed developed to process the logs of an Internet Service Provider); not to react to small, high-throughput messages. Hence, it has a significant performance penalty, as illustrated in Section 3.7.1, that can be neglected when performing complex processing on huge amounts of data but is prohibitive in our context.\n\nPacketTypes [70] is a domain-specific language dedicated to supporting binary protocols. It relies on type analysis to eliminate the need for writing all the low-level C code required for the analysis of received messages, with at least a 15% performance penalty. It does not support textual protocols.\n\nBinpac [79] is a language integrated in the Network Intrusion Detection System (NIDS) Bro [81]. A NIDS verifies each received message to detect malicious ones. The goal of Binpac is to ease this analysis by defining the message structure. Like PADS, Binpac is also based on type descriptions. Hence, a substantial translation phase is again required to use it, including the use of regular expressions, which compromises the safety of the generated parsers. Furthermore, the current implementation of Binpac is tightly-coupled with the Bro implementation preventing its use as an independent tool.\n\nThe GAP A project and its associated language GAP AL [10] also aim to generate application-level protocols analyzers in NIDS. GAPAL is the first language for packet description based on ABNF. Like Zebu, it permits annotating an ABNF specification with types, to specify the kind of value that should be created from a message element, and labels, for referring to the message elements. However, the work on GAPAL does not consider implementation and usability issues, such as limiting the memory usage, providing incremental parsing, or facilitating the creation of new messages. The parsing code is to be used within the GAPA system, and thus no stubs are generated to allow interaction with an arbitrary application. Finally, GAPAL focuses on the parsing of incoming messages, while Zebu also provides features, such as lumps (see Section 3.5.3), for efficient modification of received messages before they are resent over the network. Therefore, Zebu addresses the full spectrum of network message processing, from message parsing to message creation.\n\nMelange [69] is an architecture to implement protocols that integrates formal methods to improve server robustness: 1) ML-like static type systems; 2) model checking to verify the safety of the servers; and 3) generative meta-programming to express high level constraints for domain-specific tasks such as packet parsing and state-machine definition. The compiler generates a parser in OCaml which is both efficient and type-safe. However, this solution is too monolithic to be easily integrated in legacy programs.\n\n3.4 The Zebu Language\n\nTo address the difficulty of implementing protocol-handling layer code, we have developed the domain-specific language Zebu. The main objective of the Zebu language is to allow the developer to specify the message syntax using a high-level notation, while minimizing the need for developer intervention in the complex process of translating this notation to C code. Accordingly, the Zebu language is based on the ABNF notation used in RFCs to specify the syntax of protocol messages. The developer only needs to slightly refactor the ABNF specification to isolate message elements specific to requests or responses. He can also optionally annotate the different message elements that should be exposed to the application. The Zebu compiler then generates a complete protocol-handling layer tailored to the application according to the provided annotations. In this section, we first describe the structure of HTTP-like protocol messages and present the ABNF notation, and then consider how an ABNF specification is converted to a Zebu specification, reflecting both protocol-related and application-related aspects. The complete grammar of Zebu is provided in Appendix B.\n3.4.1 HTTP-like protocol messages and ABNF\n\nA message of a HTTP-like protocol is structured according to a fixed line-based pattern. The first line, known as the command line, identifies the message as either a request or a response. Subsequent lines contain a sequence of message headers. Each header consists of a key followed by a number of field values, which define various properties of the communication. Finally, a message can optionally contain an arbitrary payload. Figure 3.3 shows a simple SIP INVITE request message, which illustrates these features. This fixed message structure underpins the design of the Zebu language.\n\nINVITE sip:bob@biloxi.cs.com SIP/2.0\nVia: SIP/2.0/TCP client.ny.cs.com:5060;branch=z9hG4bK7\nMax-Forwards: 70\nRoute: <sip:ssl.ny.cs.com;lr>\nFrom: Alice <sip:alice@ny.cs.com>;tag=9fxced76sl\nTo: Bob <sip:bob@biloxi.cs.com>\nCall-ID: 3848276228511@ny.cs.com\nCSeq: 1 INVITE\nContact: <sip:alice@ny.cs.com;transport=tcp>\nContent-Type: application/sdp\nContent-Length: 151\nv=0\nos=9212495284099 9212495284099 IN IP4 147.210.177.85\ns=Media Presentation\ne=NONE\nc=IN IP4 0.0.0.0\n\nFigure 3.3: SIP message, adapted from the SIP RFC\n\nFigure 3.4 illustrates how the HTTP-like message structure is expressed in ABNF, for the SIP protocol, focusing on the rules relevant to INVITE requests. The first rule (line 1), expresses the possibility that a message can either be a request or a response. If it is a request, it consists of a request line, followed by a sequence of message headers, followed by a blank line, and then a payload (line 2). Line 3 defines the structure of a request line, comprising not only tokens, as derived by e.g. the nonterminal Method, but also whitespace, as derived by SP and CRLF. Method is defined as an alternation, as indicated by /, of the names of the standard SIP methods, as well as the nonterminal extension-method, allowing for extensions. The name of the INVITE method is specified in line 6, in ASCII. This ensures that INVITE is only recognized in uppercase; other strings such as \"SIP\" in line 5 are case-insensitive. Line 9 defines the CSeq header, which is found in INVITE and other requests. This header consists of the key \"CSeq\", which is case insensitive, immediately followed by a colon, one or more digits, arbitrary whitespace, and a method name. Line 10 defines the To header, which is structured similarly.\n\nFigure 3.4: Selected lines of the SIP ABNF (RFC 3261)\n\nFor many protocols, the ABNF specification does not completely define the message structure. Further constraints on the message structure are found in the accompanying text. Typically, the text in an RFC\ndefines when a header can appear, whether a header is mandatory, and how many times it can appear. For example, the SIP RFC specifies that the Via header can appear multiple times. Header field values may be required to be within a certain range or to have the same value as other message elements. For example, the SIP RFC specifies that the Method field in the CSeq header must be the same as the method specified in the request line. Finally, for message crafting, the RFC can identify which headers are read-only, constant parameters for the whole communication, and thus must be preserved unchanged in new messages.\n\n### 3.4.2 Protocol-related aspects\n\nFigure 3.5 shows a minimal Zebu specification derived from the lines of the SIP ABNF presented in Figure 3.4 (keywords are in bold face). The message block defines the scope of the whole specification. Because some message elements can only occur in either a request or a response, there is one block per message kind: message elements specific to requests are contained in a request block and message elements specific to responses are contained in a response block. The remainder of a Zebu specification is essentially the same as the ABNF specification of the message syntax.\n\n```plaintext\n1 message sip3261 { \n2 request { ; Request only \n3 requestLine = Method SP Request-URI SP SIP-Version \n4 } \n5 response { ; Response only \n6 statusLine = SIP-Version SP Status-Code SP RPhrase \n7 } \n8 Request-URI = SIP-URI / SIPS-URI / absoluteURI \n9 SIP-Version = \"SIP\" */ 1*DIGIT */ 1*DIGIT \n10 INVITEm = %x49.4E.56.49.54.45 ; INVITE in caps \n11 Method = INVITEm / ACKm / OPTIONSm / BYEm \n12 / CANCELm / REGISTERm / extension-method \n13 extension-method = token \n14 header CSeq = 1*DIGIT LWS Method \n15 header To { \"to\" / \"t\" } = \n16 { name-addr / addr-spec } *( SEMI to-param } \n17 }\n```\n\nFigure 3.5: A minimal Zebu specification, based on the SIP ABNF lines in Fig. 3.4\n\nThe refactoring of an ABNF specification into a Zebu specification is quite simple and systematic. The Zebu programmer defines the syntax of a request or response command line, minus the final newline, with the requestLine or statusLine keyword, respectively. Therefore, for instance, in Zebu, the ABNF rule for the Request-Line non-terminal (Figure 3.4, line 3) becomes:\n\n```plaintext\nrequestLine = Method SP Request-URI SP SIP-Version\n```\n\nThe `header` keyword is then added ahead of each header definition. For a header, the key description (the header name) is moved from the right-hand side to the left-hand side, replacing the rule identifier. Hence, the Zebu rule reflects the key/value structure of an header. For instance, the CSeq ABNF rule (Figure 3.4, line 9) is reorganized into the following Zebu rule (Figure 3.5, line 14):\n\n```plaintext\nheader CSeq = 1*DIGIT LWS Method\n```\n\nThe HCOLON delimiter following the key is dropped to reduce clutter, since it appears in this position in all HTTP-like protocols. Zebu can, however, be configured to use another character, such as '=' as a delimiter. Some headers, such as the To SIP header, can be represented by several keys, typically various abbreviated versions. In this case, the name of the header is followed by the set of associated keys between braces, as illustrated in Figure 3.5, line 15. As in ABNF, key names and any other strings specified in a Zebu specification are case-insensitive.\n\n---\n\n3 Zebu targets line-oriented protocols, and thus CRLF is assumed to be newline. This assumption enables efficient line-oriented parsing, as described in Section 3.4.3.\nOnce the minimal Zebu specification is created from the ABNF, annotations can be added to represent the header constraints found in the RFC text, as illustrated in Figure 3.6. These annotations appear between braces at the end of the corresponding grammar rules. Atomic constraints notably include mandatory for a header that must be present (e.g., the To header, Figure 3.6, lines 27–29). More complex constraints can be expressed using C-like conditional expressions. For instance, Figure 3.6, line 4 specifies that the methods specified in the request line and the CSeq header must be identical. Some header constraints are request or response specific. These constraints are specified in the corresponding block. In the SIP specification, the request block (Figure 3.6, lines 2–6) requires, among other constraints that the Max-Forwards header be present, and the request line and CSeq header methods be equal. The response block constraints have been elided.\n\n```\nmessage sip3261 {\n request { Request only\n requestLine = Method:method SP Request-URI:uri SP Version\n header CSeq {CSeq.method == requestLine.method}\n header Max-Forwards (mandatory)\n } [...] }\nresponse { Response only\n statusLine = Version SP Status-Code:code SP RPhrase:rphrase\n [...] }\nstruct Request-URI = SIP-URI / SIPS-URI / absURI {lazy}\nINVITEm = %x49.4E.56.49.54.45 ; INVITE in caps\nenum Method = INVITEm / ACKm / OPTIONSm / BYEm\n / CANCELm / REGISTERm / extension-method\nextension-method = token\n / extension-code\nextension-code = 3DIG\n {extension-code>=100 && extension-code<=699}\nheader Max-Forwards = 1*DIG: number as uint32\nheader To { \"to\" / \"t\" } =\n (name-addr / addr-spec:uri) *( SEMI to-param )\n (mandatory, ReadOnly)\nname-addr = [display-name] LAQUOT addr-spec:uri RAQUOT\nstruct addr-spec = SIP-URI / SIPS-URI / absURI {lazy}\n```\n\nFigure 3.6: Excerpt of a SIP Zebu specification\n\n### 3.4.3 Application-related aspects\n\nOnce having created a basic Zebu specification consisting of the ABNF and associated protocol constraints specification, the developer can further annotate it according to application-specific requirements. Annotations define the message view available to the application, by indicating the message elements that this view should include. Other annotations control the degree to which the generated parser enforces the protocol constraints and the time when message element parsing occurs. Some of these annotations are illustrated in Figure 3.6. These annotations drive the generation of the data structures that contain the message elements, the stub functions and the parser.\n\nAnnotations on the right-hand side of a grammar rule select message elements that will be available to the application and impose type constraints on these elements. To make an element available, the programmer only has to annotate it with a colon and the name of a field in the associated data structure that should store the element’s value. The field is then created by the Zebu compiler in the data structure containing the element. For instance, on line 3 of Figure 3.6, the Zebu programmer indicates that the application requires the method and the URI of the request line. Hence, the data structure representing the request line will\ncontain two string fields: `method` and `uri`. When there are no further annotations, the parser stores in these fields the starting position of the corresponding element within the message and its length. In some cases, however, it is also useful to control the type of the parsed value. This can be specified using the notation `as` followed by the name of the desired type. For example, in Figure 3.6 line 25, the `number` field of the CSeq header is specified to represent an unsigned integer of 32 bits (`uint32`). A type constraint not only enables representing an element as a type other than string, but also constrains its value by run-time assertions. The use of both kinds of annotations allows the generated data structures to be tailored to the requirements of the application logic rather than being strictly derived from the protocol syntax, as in other approaches [70, 69]. This reduces memory usage and simplifies the application logic’s access to the message elements.\n\nAnnotations on the left-hand side of a grammar rule define the type to be used to represent the value generated from parsing a message according to the rule. The programmer annotates those non-terminals that should have specific base types or that should correspond to individual data structures. The `struct` annotation creates a C structure for the associated rule. This structure contains all the annotated fields obtained by derivation from this rule. Such an annotation can be seen in Figure 3.6, line 31. For each occurrence of `addr-spec` in the message, a dedicated data structure is created. The `enum` annotation, on the other hand, indicates that the only information required is the choice of alternative, and no information is required about the sub-components of these alternatives. Hence, the `Method` rule (line 16) is an enumeration of the possible methods. Annotating this rule as an enumeration enables efficient differentiation on the request based on the method name. Finally, the `union` annotation is provided for non-terminal alternatives. As for C unions, it combines several heterogeneous types into one type. Unions are implemented as C unions, with an additional tag identifying the union element.\n\nThe application logic does not directly manipulate the data structures declared by the Zebu specification and used in the protocol-handling layer. Instead, it accesses these data structures by stub functions generated by the compiler; examples are shown in Figure 3.7. Several kinds of stub functions exist: initializing, parsing, testing and data retrieving. The `init` function initializes data structure messages. `parse` is the parsing entry point and `parse_headers` triggers the header parsing. `isRequest` and `isResponse` are test stubs used to obtain higher-level information from the parsing such as the message kind. `get_RequestLine` is an example of a stub to retrieve data; it gets data representing the request line.\n\n```c\nsip3261 init();\nvoid parse(sip3261, char *, int);\nvoid parse_headers(sip3261, E_Headers);\nvoid parse_addr_spec(T_Lazy_addr_spec);\nT_bool isRequest(sip3261);\nT_bool isResponse(sip3261);\nT_Str Option_Str_getVal(T_Option_Str);\nT_RequestLine get_RequestLine(sip3261);\nT_StatusLine get_StatusLine(sip3261);\nT_Method getMethod(T_RequestLine);\nT_MethodEnum Method_getType(T_Method);\nT_Str Method_getValue(T_Method);\nT_Lazy_addr_spec header_From_getUri(T_header_From);\nT_addr_spec Lazy_Addr_spec_getParsed(T_Lazy_addr_spec);\nT_Option_Str Addr_spec_gethost(T_addr_spec);\n```\n\nFigure 3.7: Zebu compiler generated stubs\n\nInspired by the very efficient SER SIP parser [58], the parsing functions generated by the Zebu compiler implement a two-layer parsing strategy. A coarse-grained generic parser browses the message line by line until identifying a required high-level message element, such as the command line, a particular header or the message body. When the required high-level message element is identified, the generic parser pauses and a parser dedicated to this element starts its execution. Once this dedicated parsing completes, the coarse-grained parser may resume to continue the parsing, if more information about the message is needed. The dedicated parsers must respect both the ABNF specification and the constraints expressed in the Zebu annotations. The parsers store the message elements in the generated data structures while verifying the\nconstraints. The value of the named elements can then be accessed using the stub functions prefixed with `get`.\n\nWhen the parsing of a message element is complex, and the information about this message element is only required in some situations, the parsing can be made incremental (or lazy). The Zebu annotation `lazy` specifies that a particular message element is parsed only when requested by the application. Examples are shown in Figure 3.6 with `Request-URI` and `addr-spec`. Incremental parsing avoids the parsing of a complex message element if the information it contains is not needed. Hence, the depth of nested structures in the message view is adjusted to application needs. Concretely, for an element that is to be incrementally parsed, the parser dedicated to the relevant command line or header only records in a data structure the starting position and the length of the element. The application can later call a stub function to initiate the actual parsing.\n\nIn addition to the stubs that control the parsing, the Zebu compiler also generates message modification stubs to be used by the application. These stubs are generated for each annotated element to update its value. However, the protocol specification may indicate that some message elements must not be modified. The `ReadOnly` keyword specifies this constraint. When an element is `ReadOnly`, no modification stub is generated, preventing any modification.\n\n### 3.4.4 Specification verifications\n\nBecause a Zebu specification amounts to an ABNF specification from an RFC augmented with constraints and typing information, the Zebu compiler checks the consistency of the ABNF specification itself, and as well as the relationship between the ABNF and the constraints and type information.\n\nWriting an ABNF specification can be difficult and there are currently no dedicated tools, such as editors, that verify the consistency of such a specification. While errors in the ABNF are unlikely in the RFCs of mature, widely used protocols, they may occur in specifications of new protocols or of protocol extensions. The Zebu compiler thus checks that the ABNF specification satisfies the following critical structural properties:\n\n- **No Redefinitions** A specification rule can only be defined once. A rule can be extended using the `/=` operator, but must not be redefined using the `=` operator.\n- **No Omissions** A rule that is referenced must be defined.\n\nIn addition, Zebu imposes the following constraint, due to its use of regular expressions in the parsing process.\n\n- **No Cycle** Because the Zebu-generated parsing code is based on regular expressions, an ABNF specification must not contain any cycles, i.e., it should not be possible to derive a rule from itself after some successive derivations. Although support for cycles in the ABNF is required for exact parsing of some specific constructs, such as SIP comments, this limitation of the current implementation of the Zebu compiler does not prevent the processing of such information. Indeed, this kind of ABNF rule can typically be rewritten to eliminate the cycle at some loss of completeness, by encoding recursion up to a fixed depth, or at some loss of precision, by replacing a cycle by a repetition.\n\nThe Zebu compiler furthermore checks the following properties of the structure and type constraints.\n\n- **Structure Constraints** Structure constraints expressed between curly brackets must be consistent. For instance, two elements constrained to be equal must present the same annotations to ensure the data types representing these elements are identical. Moreover, constraints specific to requests cannot refer to elements specific to responses, and vice versa.\n• Typing Constraints The message view specification must be correctly typed with regards to the message grammar. More precisely, the type annotation must respect the potential values of the message elements. For instance, a non-terminal can be annotated as an integer only if it can be derived as a number.\n\n3.5 The Zebu Toolchain\n\nWe now turn to the implementation of Zebu. We first give an overview of how to develop a network application using Zebu. We then present some of the optimizations implemented by the Zebu compiler, to allow it to generate code both for message parsing and message creation that is efficient and has low memory requirements. Finally, we consider the specific problem of integrating Zebu code into an embedded system, where the support for various operating system features essential for networking may be non-standard.\n\n3.5.1 Developing a network application with Zebu\n\nFig. 3.8 illustrates the process of developing a network application using Zebu. The developer must first write the Zebu specification based on the protocol ABNF and the associated constraints. He can annotate the specification to indicate the parts of the message that the application needs to manipulate. He then gives the specification to the Zebu compiler, which first verifies it to detect potential inconsistencies and then generates the protocol-handling layer consisting of the data structures defined by the message view annotations and a parser to process messages and fill these data structures accordingly. This compiler amounts to 7,250 lines of OCaml code and 1,200 lines of C code, and targets C code. The protocol-handling layer also contains the compiler-generated stubs allowing the application to read and write message data. These stubs reflect the data structures specified by the provided annotations. The developer then defines the application as an ordinary C program and uses the stubs defined in the Zebu-generated protocol-handling layer to access the information related to the message content.\n\nFig. 3.9 illustrates the implementation of a Zebu-based application that extracts the caller host when the request is an INVITE. This kind of task is typically performed by a NIDS to track down particular message patterns. Initially, the application calls the stub functions isRequest to determine whether the message is a request and then RequestLine_getMethod and Method_getType to determine if the command line method is an INVITE (lines 5-6). The test compares the command line method to the E_INVITE constant representing the INVITE alternation in the Method rule (line 6). If the method is INVITE, the application then calls parse_headers to trigger the parsing of the From header (Fig. 3.9, line 8), which is incremental. The get_header_From and header_From_getUri stubs then extract the header URI (line 10).\n\nLine 31 of the Zebu SIP specification (Fig. 3.6) indicates that parsing the URI must be incremental. Consequently, the parse_addr_spec function is used to actually parse it (line 11) and Addr_spec_getParsed is used to get the parsed value (line 13). After checking that the URI is defined (line 14), its value is extracted using Option_Str_getVal (line 16).\n\n3.5.2 Message parsing\n\nZebu message parsing is based on regular expressions and is implemented using the Perl Compatible Regular Expressions (PCRE) [50] library. The parsing process is twofold. First, message validation checks the message format against the protocol grammar specification. Then, message rendering extracts some selected fragments and copies these fragments into data structures dedicated to the application. As HTTP-like messages can be complex, a straightforward implementation of these operations can be time-consuming and memory-intensive, which is often not acceptable for these very frequently performed operations. We thus present the optimizations we have implemented for these two steps.\n**Message Validation** By default, the message validation code generated by the Zebu compiler strictly conforms to the protocol specification. The parser only accepts valid messages while rejecting all others. Hence, the robustness of the protocol-handling layer is guaranteed, but at the expense of performance and code size [21]. For instance, 50% of the code generated in the default case for the SIP protocol is devoted to message validation. For the arm9 architecture, this amounts to 86 kB of compiled code. However, if the application is used in a closed and secure environment, communicating only with trusted entities, this strict validation can be unnecessary. Thus, the developer can choose partial validation, in which case only annotated elements are validated. Moreover, the developer can annotate an element with `nocheck` if the application uses the element without requiring its validation or is able to postpone this validation.\n\nWhen validation is not required, the message text still needs to be inspected to detect the beginning of the next annotated element. We have developed an algorithm to reduce the number of states in the part of the parsing automaton dedicated to non-validated message elements. This algorithm first identifies tokens that precede an annotated element but cannot be part of this element. These are considered as *bounds* that must be reached before the desired element. The states representing non-annotated elements except for these tokens are then merged, which can drastically reduce the automaton size.\n\nAs an example, if we have annotated `Request-URI` with `nocheck` (Fig. 3.6), the parser must only find the beginning and end of the URI value. Since the `Request-URI` subfield is followed by a space character and since a space cannot occur within a URI, several states of the parsing automaton dedicated to the URI are merged to collect only non-space characters. Fig. 3.10a illustrates a fragment of the regular expression generated by the Zebu compiler from the automaton with full validation for `Request-URI`. The complete regular expression represents 12784 characters. The complete regular expression after reduction is shown Fig. 3.10b and illustrates the reduction factor obtained.\n\n---\n\n**Figure 3.8: Zebu network application development process**\n\n- **Specification**\n - Verification\n - Code Generation\n- **Application Logic**\n- **Protocol-Handling Layer**\n- **Code Generation**\n- **Network Application**\n- **Application Execution**\n\n---\n\n**Zebu: A Language-Based Approach for Network Protocol Message Processing**\n\n---\n\n39\nFigure 3.9: Excerpt of a SIP statistics application based on Zebu\n\nMessage Rendering A Zebu specification contains annotations defining the data structures representing messages. The stubs generated by the Zebu compiler copy elements from the message into local data structures. However, the application often uses the raw value of an element, as a string. In this case, copying into intermediate data structures can be avoided. Indeed, the only difference between the raw element value in the message and the value required by the application is a `\\0` character at the end. If a message element is not immediately followed (without a separator) by another requested element, the stub can swap the character immediately after this message element with a `\\0`. Instead of pointing to a fresh buffer filled with the element value, the data structure keeps a reference towards the actual position of the element in the message.\n\nThis strategy, however, corrupts the original message, which may be needed to retransmit the message or create a new one. To be able to reconstruct the original message, the stub also stores the swapped character. This technique is known as character-swapping and is notably implemented in Lex [63]. Using this technique, no memory allocation and no copying are required.\n\n3.5.3 Message creation\n\nUsually, a protocol support library provides the developer with a set of functions to create, initialize and modify message fragments [41]. Because the size of the message fragments resulting from the message modifications cannot be determined statically, the provided functions typically operate on a multi-layered memory representation, with nested structures pointing to each message element. Once all the modifications have been performed, the application translates these data structures into a textual message. The generated message is then stored in a fresh buffer that can be sent when requested by the application.\nHowever, this approach requires many memory copies and many intermediate data structures due to the multi-layering.\n\nThe code generated by the Zebu compiler does not create a multi-layered data structure that reflects the message structure, but instead maintains a flat string representation and only collects the information related to the message modifications. Concretely, the Zebu compiler provides functions to create a new message or to copy an existing one, and functions to update the various elements of a message. These updating functions do not actually modify the message, but instead store modifications as lumps. A lump is a data structure that describes the modification to perform: the modification, where it must be applied and what is its effect on the message size. All the lumps are stored in a linked list sorted according to the modification position. Several kinds of lumps are provided: adding, updating and removing a complete header and adding, updating and removing a message element. The use of lumps minimizes the creation and allocation of intermediate data structures to represent the effects of the modifications.\n\nLumps are applied to a message only when it is about to be sent. At this time, a new buffer is allocated; its size corresponds to the original message size offset by the effect of the accumulated modifications. The beginning of the original message is copied into this new buffer until reaching the position of the first lump. The modification described by the lump is then applied. This process iterates over the whole lump list until the end of the new message. Finally, the application can store this buffer to update it later, if the same message or a sufficiently close one must later be sent.\n\n3.5.4 Generating an execution environment for an embedded system\n\nThe code generated by the Zebu compiler cooperates with an underlying run-time support that provides low-level functionalities such as sockets, multi-threading and memory allocation. The support available for these functionalities depends on the operating system. As operating systems for embedded systems typically provide fewer functionalities than general-purpose operating systems, integrating a Zebu-based application into an embedded system can be cumbersome. Moreover, some embedded operating systems, such as FreeRTOS, require the application to be part of the operating system implementation.\n\nTo overcome these problems, we have developed a generator of run-time support, ZebuRTGen, depicted in Fig. 3.11, which generates a runtime system for a particular embedded system according to the requirements of the application code and the code generated by the Zebu compiler. So far, we have implemented two back-ends for ZebuRTGen, one for Linux and one for FreeRTOS. These back-ends consist of generic components that can be customized according to the protocol specification.\n\nOne example of the included generic components and their customization is a socket server with TCP and UDP support. In the case of a session-oriented protocol, such as TCP, the end of a message occurs when the transport session ends. However, such information is not available with a datagram-oriented transport protocol such as UDP. Consequently, the socket server must process received messages to determine if the end of message has been reached. In this case, the protocol specification defines how to detect the message end. For instance, the SIP protocol relies on the Content-Length header to specify the body length. ZebuRTGen customizes the socket server with the code generated by the Zebu compiler to detect this header and deduce the total message size.\n\n3.6 Robustness\n\nBecause message processing code represents the interface between a network application and the outside world, it must be robust. Indeed, the consequences of faulty protocol-support can be dramatic, ranging from crashing the application to providing an opportunity for an attacker to remotely take control of the platform. Several security alerts show that errors in protocol support can survive for a long time without being detected. For instance, through four successive versions of the Helix Streaming Server, errors in the\nparsing of a URI enabled an attacker to execute arbitrary code in the server.\\footnote{http://www.service.real.com/help/faq/security/bufferoverrun12192002.html}\n\nIn this section, we assess the impact of using Zebu on the robustness of the protocol support of network applications. We first present the analysis technique, inspired by mutation analysis\\cite{36}, used to evaluate the robustness of message parsers. This technique measures how well a parser covers a specification by sending it various messages, which may or may not be valid. Messages are constructed according to a set of mutation operators derived from message patterns extracted from an RFC that lists potentially problematic messages\\cite{91}.\n\n### 3.6.1 Mutation analysis\n\nThe concept of mutation analysis\\cite{36} was introduced at the end of the 1970s to test program viability. The main principle of this approach is to mutate a correct program by injecting a fault into it. Mutations are not applied randomly but follow a set of mutation rules. These rules are generally deduced from frequent programming errors\\cite{2}.\n\nA mutation analysis is parameterized by a fault class. A fault class provides a set of operators, called mutation operators, that model one or more faults in the identified fault class. A single mutation operator is applied to a single entity in the program to be tested, transforming the program into an almost identical faulty program, known as a mutant. Once generated, a mutant is applied to a test suite. If, for any test, the result of the mutant differs from the result of the original program, the mutant is said to be killed. The percentage of dead mutants defines how well the program is covered by the test suite.\nIn our study, we measure the coverage of the properties verified during the message validation phase. To provide uninterrupted service, a robust network application must accept all messages that are valid according to the specification. A robust network application must also reject (or at least detect) all invalid messages to avoid corrupting its internal state. Our technique differs from the original mutation analysis in how mutation operators are applied. In our case, the operators are not applied to the program but to the input messages to validate the program’s parsing behavior. A set of original valid messages is modified according to mutation rules to identify the consequences that ensue from the introduction of an error.\n\n### 3.6.2 Mutation rules\n\nIn our study, the protocol support of a network application is subjected to a set of deliberately pernicious messages to validate its behavior. We have based our analysis on a set of mutation rules derived from RFC 4475 [91], which defines a test suite for use in certifying implementations of the SIP protocol. We have focused on messages or patterns targeting parsers. The RFC 4475 identifies a dozen message kinds that are valid but potentially problematic and about twenty invalid messages. Many of these messages, however, can be generated by the application of the same mutation operator. We have thus identified four mutation operators that render a message invalid and three that transform it into a pernicious but valid one. These mutation operators are specific to HTTP-like protocols.\n\n**Mutation operators producing invalid messages**\n\nBased on the RFC 4475, we have defined a set of mutation operators attacking characters, character sequences, integer values and literals, as specified in the protocol grammars. Applying these operators results in mutants embodying a wide range of errors.\n\n**Character Mutations** A message element is a sequence of characters picked from a corresponding character set. The mutation operator inserts a character that is not in this character set. A mutated character is inserted at the beginning or at the end of a message element, or at an arbitrary position within the message element. Thus, for each character outside of the message element’s character set, three mutants are produced.\n\n**Sequence Mutations** A message element is defined by both the character set and the number of repetitions allowed for the character set. The number of repetitions defines indirectly the minimal and maximal length of a string. For instance, the response code in HTTP must be three digits long; otherwise, the message is invalid. We thus define a mutation operator that uses valid characters but an invalid number of repetitions. One mutant is generated with a number of characters below the lower bound and another with a number of characters above the upper bound.\n\n**Integer Mutations** We distinguish the case when the character set is exclusively made of digits, because many applications parse numbers differently than words. One mutation operator inserts alphabetical characters into numbers. Another mutation operator creates a string that represents a value that is outside the associated bounds. Such bounds are usually informally defined in the text accompanying the specification.\n\n**Literal Mutations** An element is called a literal when it can take the form of any string found in an enumeration. The mutation operator derives mutants by merging a string of this enumeration with an arbitrary character. This mutation tests whether the parser simply looks for a particular pattern within the string to be parsed.\nMutation operators producing valid messages\n\nProducing valid messages that can potentially corrupt parsers can be difficult. Actually, most of the parsers tested process most valid messages in an appropriate way. Thus, we focus on some subtleties that appear in specifications and that have been found to cause errors in the considered protocol support.\n\nProtected Characters In many cases, some special characters can appear within a message element when preceded by some protective character. The implementation of this protection is often defective. To test this feature, we introduce protected special characters within message elements, the most basic example being a protected space, i.e. a back-slash followed by a space.\n\nElement Length Many errors stem from the bad handling of array lengths and more generally of buffers. Indeed, the arrays used to store the various elements extracted from a message are often statically allocated with a small size, introducing the possibility of buffer overflows. We introduce a mutation operator that checks that the parser respects the constraints on element length. This operator pads elements to verify that the parser can handle long elements that are within the maximal length defined in the specification.\n\nExtensions Some message elements are defined according to a set of alternatives that allow for extensions. The mutation operator creates values respecting the extension clause that are close to one of the enumerated alternatives. For instance, one mutant uses an existing alternative as a prefix. Indeed, in some parsers that we have studied, as soon as an alternative is detected as a prefix, the parser considers it to be complete even if some trailing characters remain. The trailing characters are then considered to be part of another message element.\n\n3.6.3 Experiments\n\nOur objective is to assess the impact of using Zebu on the robustness of parsers for HTTP-like protocols. We evaluate this robustness by comparing the behavior of Zebu-based parsers to existing SIP and RTSP parsers. We stress the parsers with invalid messages and with valid but potentially problematic messages.\n\nWe compare the SIP Zebu-based parser with the parser provided by the Osip library [75] and the one found in the SER proxy server [58]. We compare the RTSP Zebu-based parser with the parser provided by the LiveMedia library [65] and the one found in the multimedia streaming server VLC [96]. Figure 3.12 summarizes the sizes of the various considered parsers, all written in C, as well as the sizes of the original ABNF specifications and Zebu specifications. The SIP Zebu specification contains twelve times fewer lines of code than the SER parser, which is recognized as a reference in the SIP community. In the case of RTSP, the ratio is smaller, mainly because the considered parsers are very simple. This table shows also that the Zebu specifications are around 50% larger than corresponding ABNF specifications. This is in part because ABNF specifications are potentially incomplete since they may refer to other ABNF specifications (e.g. the URLs in HTTP), and in part because the structural constraints integrated in a Zebu specification can require a significant number of added lines.\n\n<table>\n<thead>\n<tr>\n<th>Protocol</th>\n<th>ABNF Size</th>\n<th>Zebu Specification Size</th>\n<th>Parser</th>\n<th>Parser Size</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SIP</td>\n<td>≈ 700</td>\n<td>1081</td>\n<td>oSIP</td>\n<td>11982</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>SER</td>\n<td>13277</td>\n</tr>\n<tr>\n<td>RTSP</td>\n<td>≈ 200</td>\n<td>330</td>\n<td>VLC</td>\n<td>≈ 1200</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>LiveMedia</td>\n<td>≈ 1000</td>\n</tr>\n</tbody>\n</table>\n\nFigure 3.12: Line numbers for the grammars and various parsers of SIP and RTSP\nExperimental Methodology\n\nTo assess the robustness of the generated parsers, we have implemented several versions of a small application that focuses on the command line and mandatory headers of SIP and RTSP messages. This application logs some particular message elements for statistical purposes. The Zebu-based applications, Zebu-SIP and Zebu-RTSP, consist of a few lines of C code calling the stub functions generated by the Zebu compiler (Figure 3.7). The Zebu-generated parsers used for these experiments conduct a strict analysis of a message with total validation of its elements.\n\nWe have implemented the same logging application in a SER proxy. SER provides two levels of programmability. A first level is introduced through a dedicated configuration language. This language provides high level constructs to access the various elements of a message; these constructs rely on low-level functions implemented in the core of the server. The second level is available by leveraging a module system to create functions with direct access to messages. These functions can then be exported to the configuration language. We have chosen to implement the SER version using the configuration language to benefit from the existing parsing functions. The other versions, oSIP, VLC and LiveMedia, are written in C using the various functions provided by their integrated parsers.\n\nIn each version, we have instrumented the protocol support to record its behavior when receiving a message. Notably, we monitor the various error flags that may be raised when a message is detected to be invalid.\n\nInvalid Messages\n\nAs shown in Figure 3.13, the manually developed parsers considered do not detect more than 28% of the invalid messages. This gap stems in part from a certain flexibility of these parsers with respect to the specification. Flexibility is indeed generally recommended in protocol specifications, which argue that borderline messages should be accepted to avoid isolating applications that are not 100% compliant with the specification. However, the support for flexibility is often not very well controlled and consequently some invalid message classes are wrongly handled. The parser of the Videolan streaming server is extremely lax in its parsing. Only 0.1% of the transmitted messages were detected as invalid by its protocol support. Examining the code shows that it is very simplistic. On the other hand, the strict Zebu-generated parsers detect 100% of the invalid mutated messages of our test suite. This result is made possible by generating complete and strict parsers.\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Invalid Messages</th>\n<th>Detected Messages</th>\n<th>% Detected Messages</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>oSIP</td>\n<td>5976</td>\n<td>1020</td>\n<td>17.1%</td>\n</tr>\n<tr>\n<td>SER</td>\n<td>1512</td>\n<td>1512</td>\n<td>100.0%</td>\n</tr>\n<tr>\n<td>Zebu-SIP</td>\n<td>5976</td>\n<td>100.0%</td>\n<td>100.0%</td>\n</tr>\n<tr>\n<td>VLC</td>\n<td>2730</td>\n<td>4</td>\n<td>0.1%</td>\n</tr>\n<tr>\n<td>LiveMedia</td>\n<td>748</td>\n<td>748</td>\n<td>100.0%</td>\n</tr>\n<tr>\n<td>Zebu-RTSP</td>\n<td>2730</td>\n<td>100.0%</td>\n<td>100.0%</td>\n</tr>\n</tbody>\n</table>\n\nFigure 3.13: Parser coverage for invalid SIP and RTSP messages\n\nOur experiments also triggered a bug in the SER proxy server. This server keeps track of all the erroneous Via headers. When receiving a large number of invalid messages, this collection failed, entailing a segmentation fault. This error, now corrected, was present during a year (from version 0.8.14 of July 2004 to version 0.9.3 of September 2005).\n\nValid Messages\n\nFigure 3.14 shows that the manually-developed parsers reject some valid messages. These messages are of course unusual but rejecting valid messages demonstrates that the flexibility introduced in these parsers is not really controlled. Worse, some valid requests crash the oSIP library parser. The SIP Zebu-generated\nparser rejects no valid message. Hence, the Zebu-generated parser detects all invalid messages while rejecting no valid messages of our test suite.\n\n<table>\n<thead>\n<tr>\n<th>Protocol</th>\n<th>Valid Messages</th>\n<th>Rejected Messages</th>\n<th>% Rejected Messages</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SIP</td>\n<td>Zebu-SIP</td>\n<td>0</td>\n<td>0.0%</td>\n</tr>\n<tr>\n<td></td>\n<td>gSIP</td>\n<td>549</td>\n<td>2.1%</td>\n</tr>\n<tr>\n<td>SER</td>\n<td>2</td>\n<td>0.4%</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nFigure 3.14: Parser coverage for valid SIP messages\n\nWe have run the same experiments for the RTSP protocol. None of the considered parsers rejects a message. This is not surprising because the manually-developed parsers are very lax.\n\n3.7 Performance\n\nAll of the messages received by and sent from a network application go through the protocol-handling layer. Consequently, the performance of the protocol-handling layer greatly affects the performance of the application. In this section, we assess the performance overhead induced when using Zebu, by comparing the performance of Zebu generated code with the performance of manually-developed code. We compare our approach to the de facto standard for each considered protocol. Then, we evaluate the memory consumption of the code generated by the Zebu toolchain. This evaluation should be considered as a study of the feasibility of deploying Zebu-based network applications on embedded systems in real conditions and consequently the feasibility of using HTTP-like protocols in this context.\n\n3.7.1 Processing time\n\nWe first present a micro-benchmark on HTTP, and then exhibit the results for the SIP-based application presented in the previous section. In both cases, these results are obtained with real messages. In our experiments, a client application replays a real trace, extracting and sending each message of this trace as fast as possible to stress a server application. We have instrumented the code of the various applications to measure the parsing time for each received message. For these experiments, the client is hosted by an Athlon Mobile (1.6GHz) and the server by a Pentium 4 (2.66GHz).\n\nHTTP Micro-Benchmarks\n\nIn order to evaluate the processing time of one message by the Zebu-generated HTTP support, we developed an application that records the domain name contained in the \\texttt{HOST} header. The HTTP Zebu specification amounts to 500 lines and entails the generation of 2400 lines of C code. The application consists of only 27 lines of C code. We have compared our Zebu implementation to an implementation based on PADS and to an implementation based on the Apache Web server.\n\nThe application based on PADS relies on the code generated from the HTTP PADS specification provided with the PADS compiler. This specification (approximately 2000 lines) consists of an ordered set of PADS type rules and regular expressions. The application consists of 50 lines of C code, most of which is devoted to initializing the runtime environment.\n\nThe application based on the Apache web server is implemented in the web server’s configuration file. This file enables fine tuning the behavior of the server through functions exported by the module system. Each module is dedicated to a particular feature, such as XML support or authentication. The module we are interested in is \\texttt{mod_setenvif}, which enables defining parsing functions based on regular expressions for each message header. To implement our application we have added 9 lines to the original configuration file. These lines filter messages to record only those that contain a \\texttt{HOST} header and extract the requested information.\nThe Zebu-generated parser performing complete message validation requires 170,000 cycles on average to parse a message while the PADS-generated parser requires 2,600,000 cycles on average. The parsing in the Apache server requires only 24,000 cycles but it concentrates only on the HOST header; the other headers are only referenced by a pointer without any further analysis.\n\n<table>\n<thead>\n<tr>\n<th>Request</th>\n<th>Cycles</th>\n<th>Ratio</th>\n<th>Cycles</th>\n<th>Ratio</th>\n<th>Cycles</th>\n<th>Ratio</th>\n<th>Cycles</th>\n<th>Ratio</th>\n<th>Cycles</th>\n<th>Ratio</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ACK</td>\n<td>22,640</td>\n<td>12%</td>\n<td>22,690</td>\n<td>2%</td>\n<td>377,298</td>\n<td>481%</td>\n<td>52,156</td>\n<td>59%</td>\n<td>74,468</td>\n<td>106%</td>\n</tr>\n<tr>\n<td>BYE</td>\n<td>22,540</td>\n<td>12%</td>\n<td>16,068</td>\n<td>10%</td>\n<td>522,156</td>\n<td>983%</td>\n<td>74,468</td>\n<td>106%</td>\n<td>33,960</td>\n<td>100%</td>\n</tr>\n<tr>\n<td>CANCEL</td>\n<td>22,732</td>\n<td>12%</td>\n<td>52,996</td>\n<td>46%</td>\n<td>356,036</td>\n<td>676%</td>\n<td>84,512</td>\n<td>70%</td>\n<td>49,680</td>\n<td>100%</td>\n</tr>\n<tr>\n<td>INVITE</td>\n<td>24,866</td>\n<td>14%</td>\n<td>379,530</td>\n<td>93%</td>\n<td>525,524</td>\n<td>653%</td>\n<td>81,610</td>\n<td>102%</td>\n<td>80,456</td>\n<td>100%</td>\n</tr>\n<tr>\n<td>OPTIONS</td>\n<td>25,872</td>\n<td>15%</td>\n<td>24,176</td>\n<td>16%</td>\n<td>339,016</td>\n<td>478%</td>\n<td>76,144</td>\n<td>107%</td>\n<td>70,908</td>\n<td>100%</td>\n</tr>\n<tr>\n<td>REGISTER</td>\n<td>31,016</td>\n<td>20%</td>\n<td>31,096</td>\n<td>20%</td>\n<td>465,978</td>\n<td>751%</td>\n<td>65,672</td>\n<td>106%</td>\n<td>62,028</td>\n<td>100%</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Response</th>\n<th>Cycles</th>\n<th>Ratio</th>\n<th>Cycles</th>\n<th>Ratio</th>\n<th>Cycles</th>\n<th>Ratio</th>\n<th>Cycles</th>\n<th>Ratio</th>\n<th>Cycles</th>\n<th>Ratio</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<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ACK</td>\n<td>35,608</td>\n<td>151%</td>\n<td>35,716</td>\n<td>152%</td>\n<td>505,312</td>\n<td>2150%</td>\n<td>31,806</td>\n<td>135%</td>\n<td>23,508</td>\n<td>100%</td>\n</tr>\n<tr>\n<td>BYE</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>CANCEL</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>INVITE</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>OPTIONS</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>REGISTER</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 3.15: Performance of the logging application on a trace of 3000 real SIP Messages (ratio with Zebu-minimal)\n\nSIP Evaluation\n\nIn order to evaluate the performance in a SIP context, we have re-used the application described in Section 3.6.3. We have collected the SIP traffic exchanged at the University of Bordeaux during one day, amounting to 3000 messages. The Zebu-based implementations, Zebu-SIP and Zebu-SIP-minimal, each represent 27 lines of C code relying on two protocol-handling layers that differ in their strictness. Zebu-SIP performs complete validation of each received message as in Section 3.6.3, while the new version Zebu-SIP-minimal validates only the annotated message elements. To assess our results, we have reused the versions of the application based on SER and oSIP described in Section 3.6.3.\n\nSER is implemented in SER by 12 lines of the SER configuration language, leveraging the ability to switch to an arbitrary shell script to extract the information from a message using a regular expression. This time, we have also implemented SER-module, a version relying on a dedicated module implemented using 150 lines of C code. The version based on oSIP consists of 40 lines of C code. The results of this evaluation are summarized in Figure 3.15 and compared to the performance of Zebu-SIP-minimal.\n\nThe parsing performed by SER-module is particularly efficient, up to 3 times faster than when using Zebu-SIP-minimal for requests. For responses, the parsing performed by SER-module is 50% slower than when using Zebu-SIP-minimal. The main reason is that SER is dedicated to message routing and thus always processes some message elements, such as the Via header, that are crucial for routing but are useless in our context. As soon as it recognizes a response, the Zebu-generated parser does not process the rest of the message. Zebu can thus provide better performance by generating a parser dedicated to a particular application, while guaranteeing its robustness, which can be compromised using SER modules. SER modules have full access to the internal data structures of the server which is a major threat to the server when these modules are erroneous.\n\nThe SER version is 217 times slower for INVITE messages mainly because of the context switch induced by the shell script call. This call is only performed when an INVITE message is identified.\n\nThe parsing performed by oSIP is between 5 and 10 times slower than Zebu-SIP-minimal for requests and around 20 times slower for responses. In both cases, the oSIP library parses the six mandatory headers and stores for each header a pointer to its starting position.\n\n3.7.2 Memory usage\n\nThe previous experiments have shown that a Zebu-based approach is a good alternative to using existing frameworks in terms of both robustness and performance. In this section, we evaluate the memory requirements of the Zebu-based approach, and assess whether the generated parsers can be used in embedded systems.\nChapter 3\n\nOur Experiments\n\nOur experiments focus on a building surveillance application deployed in our test environment. This application enables a SIP phone to control and receive images from an IP camera. The camera only supports the RTSP protocol for negotiating multimedia parameters and the HTTP protocol for operating commands such as moving or zooming. New code cannot be loaded into the camera. Thus, to allow a SIP phone to interact with the camera, we had to create a gateway to convert SIP messages into RTSP or HTTP, according to the requested command. This gateway involves both parsing incoming messages and constructing SIP, RTSP and HTTP messages. Our experiments focus on the gateway implementation as an embedded system, as would be necessary in a real building automation context.\n\nWe have deployed our gateway on two kinds of embedded systems: an Eukrea CPUAT91 board with an ARM9 and 32 MB of SDRAM with Linux 2.6.20 installed, and an ATMEI EVK1100 development kit based on an AVR32 micro-controller with 32 MB of RAM with FreeRTOS installed. The SIP client used to control the camera is a slightly modified version of linphone [64].\n\nFigure 3.16 illustrates the various components involved in our application. A SIP client sends an INVITE message to the gateway to request video streaming from the camera. The gateway extracts some information, such as the caller identifier, from the SIP message and integrates it into a newly-crafted RTSP message that is then sent to the camera. Once the communication is established, the gateway is no longer concerned, and the multimedia flow is transmitted directly from the camera to the SIP client via the RTP protocol.\n\nTo control the various functionalities provided by the camera, such as zooming and moving, we have extended the SIP protocol with new methods and headers representing these features. For instance, in order to command the camera to zoom, we introduce a new SIP method ZOOM and a new header Zone that describes which part of the captured scene should be in focus and the zoom factor. Figure 3.17 shows the lines that must be added to the Zebu specification to support this extension in the gateway. At the same time, we have extended the SIP client to support these extensions. Thus, a SIP phone running this extended client can receive images from the camera and control its movement. When the gateway receives a SIP message defined according to a new extension, it extracts some information to build the corresponding HTTP request and sends it to the camera. Conversely, it converts the HTTP response returned by the camera into a SIP response.\n\nWe have implemented four versions of the gateway on the CPUAT91 board: two based on Zebu, one based on the eXosip library [41] and one based on the Sofia-SIP library [87]. We have also implemented two versions using the EVK1100 development kit using our FreeRTOS back-end. One Zebu based version performs full validation while the other only validates annotated elements.\nStatic Memory Requirements\n\nFirst, we consider the static memory requirements of the gateway compiled for the ARM9 based board. These memory requirements comprise those of the Linux kernel, the protocol-handling layer, and the application itself. The Linux kernel using a minimal root filesystem requires 1.8 MB. Figure 3.18 shows the size of the protocol-handling layer for each version. With full validation, the Zebu generated code uses only 35% of the memory needed by eXosip and 11% of what is needed by Sofia-SIP. With no validation, the gap is wider, with the Zebu generated code using only 13% of what is needed by eXosip and 4% of what is needed for Sofia-SIP.\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Zebu</th>\n<th>eXosip</th>\n<th>Sofia-SIP</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Complete Validation</td>\n<td>139</td>\n<td>53</td>\n<td>400</td>\n</tr>\n<tr>\n<td>No Validation</td>\n<td>1300</td>\n<td>400</td>\n<td>1 300</td>\n</tr>\n</tbody>\n</table>\n\nFigure 3.18: Size, in kB, of the protocol support compiled for ARM9\n\nWe now consider the static memory requirements of the gateway when compiled for the AVR32-based EVK1100 board based on an AVR32. For our experiments, we have used ZebuRTGen with the FreeRTOS back-end to generate a complete application integrated in the operating system. Figure 3.19 shows that the ROM requirements are contained within the 512 kB available on the board. The static RAM requirements amount to only a tiny part of the 32 MB available.\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>ROM</th>\n<th>RAM</th>\n<th>Total</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Complete Validation</td>\n<td>234.7</td>\n<td>64</td>\n<td>298.7</td>\n</tr>\n<tr>\n<td>No Validation</td>\n<td>150.6</td>\n<td>64</td>\n<td>214.6</td>\n</tr>\n</tbody>\n</table>\n\nFigure 3.19: Memory usage for the complete gateway on the Eukrea board (in kB)\n\nDynamic Memory Requirements\n\nIn order to evaluate the dynamic memory requirements of our gateway, we consider a set of fixed actions. First, the client sends an INVITE request to the gateway. Once the connection is established, the client sends a sequence of ZOOM requests to modify the zoom factor and the considered zone, and then closes the connection. In order to measure the memory consumption, we have used the exmap-console tool [40].\n\nFigure 3.20 shows the maximum amount of memory used to execute the INVITE/ZOOM/BYE sequence for each version of the gateway. The memory consumption only depends on the message currently processed, as no state is kept in the gateway. The Virtual Memory column indicates the address space allocated for the gateway, while the Physical Memory indicates the amount of physical memory actually used by the gateway. The implementations based on Zebu require only 40% of the virtual memory required by manually-developed protocol support. Furthermore, complete validation only adds 15% of required physical memory. Zebu implementations consume between 51% and 59% of the memory consumed by eXosip and 35% and 41% of the memory consumed by Sofia-SIP.\n\nWe furthermore observe that the memory reduction does not affect the performance. Figure 3.21 shows the parsing time for an INVITE SIP request initiating the communication with the gateway. This message\nrepresents the worst case for parsing because it includes several complex elements required to establish the communication. With complete validation, the parsing takes around 3500 µ-seconds, which is two times slower than Sofia-SIP. However, without validation, the Zebu parsing competes with Sofia-SIP and is twice as fast as eXosip.\n\nFinally, we analyze the physical memory and virtual memory consumption of each layer of the gateway. The gateway can be divided into three distinct layers: (1) the runtime environment, which comprises the commodity functions used by the application, (2) the protocol-handling layer and (3) the application. The runtime environment and protocol-handling layer are specific to each implementation. Figure 3.22 shows the peak memory consumption for each of the implementations.\n\nIf we focus on the protocol-handling layer, Sofia-SIP is the fastest but consumes the most memory with 1.1 MB of virtual memory and 640 kB of physical memory. This represents 85% of the total memory consumption for the Sofia-SIP gateway. The Sofia-SIP parser creates many data structures. Each header is copied into a fresh buffer, then parsed and the parser stores each element in a fresh data structure. Its message modification strategy is also flexible but has high memory usage.\n\nThe protocol handling layer of the eXosip-based implementation requires far less memory but still consumes 72% of the total memory consumption of the gateway. EXosip is a wrapper around oSIP providing higher-level constructs. Notably, eXosip conceals the SIP transactional model with dedicated data structures. However, eXosip reuses the parsing phase of oSIP which is quite similar to that of Sofia-SIP. The only difference is in the message creation and modification which avoid useless copies. A Zebu based implementation with complete validation requires less than the half of the virtual memory required by eXosip and less than the eighth of the physical memory.\n\n### 3.8 Conclusion\n\nIn this chapter, we have presented the Zebu domain-specific language, which has the goal of easing the development of network application protocol-handling layers while guaranteeing the robustness and performance properties. The Zebu language is based on the ABNF formalism used for protocols specifications.\nand enables fine tuning the protocol-handling layer according to the needs of a particular application. The programming effort is reduced by staying close to the original protocol specification, consequently reducing the opportunity for errors. Moreover, Zebu allows extending, in an easy and safe way, a protocol underlying an application to integrate particular needs. The various experiments presented in this chapter have demonstrated that this approach is a reliable alternative to manual development in the context of protocol-handling layers. Zebu generated code has good performance and has a significantly lower memory footprint than comparable existing manually encoded solutions.\nChapter 4\n\nZ2z: Automatic Generation of Network Protocol Gateways\n\nThis chapter presents z2z [15, 7], a generative approach to gateway construction based on a domain-specific language for describing protocol behaviors, message structures, and the gateway logic. Z2z includes a compiler that checks essential correctness properties and produces efficient code. We have used z2z to develop a number of gateways, including SIP to RTSP, SLP to UPnP, and SMTP to SMTP via HTTP. Our evaluation of these gateways shows that z2z enables communication between incompatible devices without increasing the overall resource usage or response time.\n\n4.1 Introduction\n\nThe home of tomorrow is almost here, with a plethora of networked devices embedded in appliances, such as telephones, televisions, thermostats, and lamps, making it possible to develop applications that control many basic household functions. Unfortunately, however, the different functionalities of these various appliances, as well as market factors, mean that the code embedded in these devices communicates via a multitude of incompatible protocols: SIP for telephones, RTSP for televisions, X2D for thermostats, and X10 for lamps. This range of protocols drastically limits interoperability, and thus the practical benefit of home automation.\n\nTo provide interoperability, one solution would be to modify the code, to take new protocols into account. However, the code in devices is often proprietary, preventing any modification of the processing of protocol messages. Even if the source code is available, it may not be possible to install a new implementation into the device. Therefore, gateways have been used to translate between the various kinds of protocols that are used in existing appliances.\n\nDeveloping a gateway, however, is challenging, requiring not only knowledge of the protocols involved, but also a substantial understanding of low-level network programming. Furthermore, there can be significant mismatches between the expressiveness of various protocols: some are binary while others are text-based, some send messages in unicast while other use multicast, some are synchronous while others are asynchronous, and a single request in one protocol may correspond to a series of requests and responses in another. Mixing this complex translation logic, which may for example involve hand coding of callback functions or continuations in the case of asynchronous responses, with equally complex networking code makes implementing a gateway by hand laborious and error prone. Enterprise Service Buses [25] have been proposed to reduce this burden by making it possible to translate messages to and from a single fixed intermediary protocol. Nevertheless, the translation logic must still be implemented by hand. Because each pair of protocols may exhibit widely differing properties, the gateway code is often not easily reusable.\nChapter 4\n\nThis chapter\n\nWe propose a generative language-based approach, z2z, to simplify gateway construction. Z2z is supported by a runtime system that hides low-level details from the gateway programmer, and a compiler that checks essential correctness properties and produces efficient code. Our contributions are:\n\n- We propose a new approach to gateway development. Our approach relies on the use of a domain-specific language (DSL) for describing protocol behaviors, message structures, and the gateway logic.\n- The DSL relies on advanced compilation strategies to hide complex issues from the gateway developer such as asynchronous message responses and the management of dynamically-allocated memory, while remaining in a low-overhead C-based framework.\n- We have implemented a compiler that checks essential correctness properties and automatically produces an efficient implementation of a gateway.\n- We have implemented a runtime system that addresses a range of protocol requirements, such as unicast vs. multicast transmission, association of responses to previous requests, and management of sessions.\n- We show the applicability of z2z by using it to automatically generate a number of gateways: between SIP and RTSP, between SLP and UPnP, and between SMTP and SMTP via HTTP. On a 200 MHz ARM9 processor, the generated gateways have a runtime memory footprint of less than 260KB, with essentially no runtime overhead as compared to native service access.\n\nOutline\n\nThe rest of this chapter is organized as follows. Section 4.2 presents the range of issues that arise in implementing a gateway, as illustrated by a variety of case studies. Section 4.3 describes the z2z gateway architecture and introduces a DSL for describing protocol behaviors, message structures, and the gateway logic. Section 4.4 describes the dynamic semantics of z2z and its interaction with the runtime system. Section 4.5 describes the compiler and runtime system that support this language. Section 4.6 describes the model checker provided by z2z for verifying protocol correctness. Section 4.7 demonstrates the efficiency and scalability of z2z gateways. Section 4.8 discusses related work. Finally, Section 4.9 concludes the chapter with some final remarks.\n\n4.2 Issues in Developing Gateways\n\nA gateway must take into account the different degrees of expressiveness of the source and target protocols and the range of communication methods that they use. Each of these issues requires substantial expertise in network programming, and the need to address both of them at once makes gateway development especially difficult. We illustrate these points using examples that involve a wide range of protocols.\n\nMismatched protocol expressiveness. The types of messages provided by a protocol are determined by the kinds of exchanges that are relevant to the targeted application domain. Thus, different protocols may provide message types that express information at different granularities. To account for such mismatches, a gateway must potentially translate a single request from the source device into multiple requests for the target device, or save information in a response from the target device for use in constructing multiple responses for the source device.\n\nThe SIP/RTSP gateway shown in Figure 4.1 illustrates the case where the requests accepted by the target device are finer grained than the requests generated by the source device. This gateway has been used in\nthe SIP-based building-automation test infrastructure at the University of Bordeaux. It allows a SIP based telephony client to be used to receive images from an Axis IP-camera. This camera is a closed system that accepts only RTSP for negotiating the parameters of the video session. Once the communication is established, the gateway is no longer involved, and the video is streamed directly from the camera to the SIP client using RTP [82]. Because SIP and RTSP were introduced for different application domains, there are significant differences in the means they provide for establishing a connection. Thus, as shown in Figure 4.1, for a single SIP INVITE message, the gateway must extract and rearrange the information available into multiple RTSP messages.\n\n\n\nThe SMTP/HTTP and HTTP/SMTP gateways shown in Figure 4.2 illustrate the case where information must be saved from a target response for use in constructing multiple responses for the source device. These gateways are used in a tunneling application that enables SMTP messages to be exchanged between two end-points over HTTP, as is useful when the port used by SMTP is closed somewhere between the source and the destination. The first gateway encapsulates an SMTP request into an HTTP message and sends it asynchronously using UDP to the second gateway, which extracts relevant information to generate the corresponding SMTP request. The response is sent back similarly.\n\n\n\nBecause at the client end and at the service end all SMTP messages have to flow within the same TCP stream, the HTTP/SMTP gateway needs to know which TCP connection to reuse when an HTTP request is received. To address this issue, the gateway generates a unique identifier when opening the TCP connection with the destination SMTP server and includes this identifier within the HTTP response. The first gateway then includes this identifier in all subsequent HTTP requests, enabling the second gateway to retrieve the connection to use. To implement this, the first gateway needs to manage a state within a session to store the identifier returned in the first response in order to be able to find it for the subsequent requests.\n\n---\n\n**Heterogeneous communication methods.** Protocols differ significantly in how they interact with the network. Requests may be multicast or unicast, responses may be synchronous or asynchronous, and network communication may be managed using a range of transport protocols, most commonly TCP or UDP.\n\nThe gateway between SLP and UPnP shown in Figure 4.3 involves a variety of these communication methods. Such a gateway may be used in a service discovery environment that provides mechanisms for dynamically discovering available services in a network. For example, a washing machine may search for a loudspeaker service and use it to play a sound once the washing is complete. In this scenario, the washing machine includes a SLP (Service Location Protocol) user agent and the speaker uses a UPnP (Universal Plug and Play) service agent to advertise its location and audio characteristics. UPnP is a wrapper for SSDP [46] and HTTP [42], which are used at different stages of the service discovery process.\n\n\n\nFrom a multicast SLP SrvRQST service discovery request, the SLP/UPnP gateway extracts appropriate information, such as the service type, and sends a multicast SSDP SEARCH request. If a service is found, the UPnP service agent asynchronously returns a unicast SSDP response containing the URL of the service description to the gateway. Then, the gateway extracts the URL and sends a unicast HTTP GET request to it to retrieve the service description as an XML document. Finally, the gateway extracts information from the XML document and creates an SLP SrvRPLY response, which it returns to the SLP client. This gateway must thus manage both multicast and unicast requests, and synchronous and asynchronous responses. Mixing the translation logic with these underlying protocol details complicates the development of the gateway code.\n\n**4.3 Specifying a Gateway Using Z2z**\n\nAs illustrated in Section 4.2, a gateway receives a single request from the source device, translates it into one or a series of requests for one or more target devices, and then returns a response to the source device. It may additionally need to save some state when the source protocol has a notion of session that is different from that used by the target protocol, or when the interaction with the target device(s) produces some information that is needed by subsequent source requests.\n\nOur case studies show that there are two main challenges to developing such a gateway: (1) manipulating messages and maintaining session state, to deal with the problem of mismatched protocol expressiveness, and (2) managing the interaction with the network, to deal with the problem of heterogeneous communication methods. In z2z, these are addressed through the combination of a DSL that allows the gateway developer to describe the translation between two or more protocols in a high-level way, and a runtime system that provides network interaction and data management facilities specific to the domain of...\ngateway development. We describe the DSL in this section, and present the architecture of the runtime system in the next section. The complete grammar of z2z is provided in Appendix C.\n\n4.3.1 Overview of the z2z language\n\nTo create a gateway, the developer must provide three kinds of information: 1) how each protocol interacts with the network, 2) how messages are structured, and 3) the translation logic. To allow each kind of information to be expressed in a simple way, z2z provides a specific kind of module for each of them: protocol specification (PS) modules for defining the characteristics of protocols, message specification (MS) modules for describing the structure of protocol messages, and a message translation (MT) module for defining how to translate messages between protocols. These modules are implemented using the z2z DSL, which hides the complexities of network programming and allows specifying the relevant operations in a clear and easily verifiable way.\n\nAs illustrated in Section 4.2, a gateway may involve any number of protocols. Thus, a gateway specification may contain multiple protocol specification modules and message specification modules, according to the number of protocols and message types involved. A gateway specification always contains a single message translation module. Figure 4.4 shows the architecture of the SIP/RTSP gateway in terms of its use of these modules. We now present these modules in more detail, using this gateway as an example.\n\n\n\n4.3.2 Protocol specification module\n\nThe protocol specification module defines the properties of a protocol that a gateway should use when sending or receiving requests or responses. As illustrated in Figure 4.5 for the SIP protocol, this module declares the following information.\n\n**Attributes.** Protocols vary in their interaction with the network, in terms of the transport protocol used, whether requests are sent by unicast or by multicast, and whether responses are received synchronously or asynchronously. The attributes block of the protocol specification module indicates which combination is desired. Based on this information, the runtime system provides appropriate services. For example, SIP relies on UDP (transport attribute, line 4), sends requests in unicast (mode attribute, line 5), and receives responses asynchronously. If the transmission mode is asynchronous, the protocol specification must also include a flow block (line 26) describing how to match requests to responses. The transport attribute can also be equal to TCP to indicate that a new TCP connection needs to be created for each request and to TCP alive to specify that multiple requests must be sent inside the same TCP connection.\nRequests and responses. The entry point of a gateway is the reception of a request. On receiving a request, the gateway dispatches it to the appropriate handler in the message translation module. For each kind of request that should be handled by the gateway, the request block indicates the name of the handler (invite, bye, and ack, for SIP), whether the request should be acknowledged by a response (response if a response is allowed and void if no response is needed), and a predicate, typically defined in terms of the fields of the request, indicating whether a request should be sent to the given handler. Similarly, the response block (lines 14-17) defines classes of responses.\n\nSending. A protocol typically defines certain basic information that all messages must contain. Rather than requiring the developer to specify this information in each handler, this information is specified in a sending block for requests when the protocol is used as the target protocol and for responses when it is used as the source protocol of the gateway. The sending block for requests is parameterized by only the request, while the sending block for responses is parameterized by both the previous incoming request and the response, allowing elements of the response to be initialized according to information stored in the request. For example, the SIP sending block for responses copies the cseq and callid fields from the request to the response (lines 22-23). When information need to be accumulated over the treatment of several messages, the protocol specification module may declare global variables.\n\nFlow and session_flow. When a target protocol sends responses asynchronously, an incoming response must be associated with a previous request, to restart the associated handler. The flow block (line 26), specifies the message elements that determine this association. In SIP, a request and its matching response have the same sequence number (cseq) and call id (callid). A session_flow block (line 27) similarly specifies how to recognize messages associated with a session.\n\nThe information in the protocol specification module impacts operations that are typically scattered throughout the gateway. In providing the protocol specification module as a language abstraction, we have identified the elements of the protocol definition that are relevant to gateway construction and collected them into one easily understandable unit. Furthermore, creating a protocol specification module is lightweight, involving primarily selecting properties rather than implementing their support, making it easy to incorporate many different kinds of protocols into a single gateway, as illustrated by the SLP/UPnP gateway described in Section 4.2.\nAutomata. Finite state machine models are typically used to describe the expected interactions (possible sequences of requests and responses) of the protocol. The automata block (lines 29-49) of the protocol specification module defines the state machines of a client (sending request) and a server (receiving requests) according to the protocol. For example, the automata block shown from lines 29 to 49 describes the state machine of the INVITE server transaction, i.e., the sequence of possible messages upon the reception of an INVITE request (line 32).\n\n4.3.3 Message specification module\n\nA network message is organized as a sequence of text lines, or of bits, for a binary protocol, containing both fixed elements and elements specific to a given message. A gateway must extract relevant elements from the received request and use them to create one or more requests according to the target protocol(s). Similarly, it must extract relevant elements from the received responses and ultimately create a response according to the source protocol. Extracting values from a message represented as a sequence of text or binary characters is unwieldy, and creating messages is even more complex, because the element values may become available at different times, making it difficult to predict the message size and layout.\n\nIn z2z, the message specification module contains a description of the messages that can be received and created by a gateway. Based on this description, the z2z compiler generates code for accessing message elements made available by an externally developed parser and inserting message elements into a created message. There is one message specification module per protocol relevant to the gateway, including both the source and target protocols, as represented by the protocol specification modules, and one per any higher level message type that can be embedded in the requests and responses. For example, the SIP/RTSP camera gateway uses not only SIP and RTSP message specification modules but also message specification modules for SDP Media and SDP, which are not associated with protocol specification modules, as SDP Media and SDP messages are embedded into SIP requests and responses.\n\nA message specification module provides a message view describing the relevant elements of incoming messages and templates for creating new messages. The set of elements is typically specific to the purpose of the gateway, not generic to the protocol, and thus the message specification module is separate from the protocol specification module. We illustrate the declarations of the message view and the templates in the SIP message specification module used in our camera gateway.\n\nMessage view A message view describes the information derived from received messages that is useful to the gateway. It thus represents the interface between the gateway and the message parser. Z2z does not itself provide facilities for creating message parsers, but instead makes it possible to plug in one of the many existing network message parsers\\(^2\\) or to construct one by hand or using a parser generator targeting network protocols, such as Zebu [21].\n\nBecause SIP is the source protocol of the camera gateway, its message view describes the information contained in a SIP request. An excerpt of the declaration of this view is shown in Figure 4.6a. It consists of a sequence of field declarations, analogous to the declaration of a C-language structure. A field declaration indicates whether the field is mandatory or optional, whether it is public or private, its type, and its name. A field is mandatory if the protocol RFC specifies that it is always present, and optional otherwise. A field is public if it can be read by the gateway logic, and private if it can only be read by the protocol specification. The type of a field is either integer, fragment, or a list of one of these types. A field of type fragment is represented as a string, but the gateway logic can cause it to be parsed as a message of another protocol, such as SDP or SDP Media, in our example.\n\n\\(^2\\)oSIP: http://www.gnu.org/software/osip\nLivemedia: http://www.livemediacast.net/about/library.cfm\nZ2z maintains messages to be created as a pair of a template view and a template. The template language is adapted from that of Repleo [5]. A message is created in the message translation module by making a new copy of the template view, and initializing its fields, in any order. At a send or return operation in the message translation module, the template representing the message is flushed, filling its holes with the corresponding values from the view.\n\nBecause SIP is the source protocol of our camera gateway, its templates describe the information needed to create SIP responses. Typically, there are multiple response templates for each method, with one template for each relevant success and failure condition. Figure 4.6b shows the template for a response indicating the success of an INVITE request. The implements keyword (line 15) is used to describe the class of responses the message created by the template belongs to. The possible classes of requests and responses are defined in the protocol specification module, see Section 4.3.2.\n\nFigure 4.6: SIP message specification for the camera gateway\n\n**Templates**\n\nZ2z maintains messages to be created as a pair of a template view and a template. The template language is adapted from that of Repleo [5]. A message is created in the message translation module by making a new copy of the template view, and initializing its fields, in any order. At a send or return operation in the message translation module, the template representing the message is flushed, filling its holes with the corresponding values from the view.\n\nBecause SIP is the source protocol of our camera gateway, its templates describe the information needed to create SIP responses. Typically, there are multiple response templates for each method, with one template for each relevant success and failure condition. Figure 4.6b shows the template for a response indicating the success of an INVITE request. The implements keyword (line 15) is used to describe the class of responses the message created by the template belongs to. The possible classes of requests and responses are defined in the protocol specification module, see Section 4.3.2.\n\nBecause SIP is the source protocol of our camera gateway, its templates describe the information needed to create SIP responses. Typically, there are multiple response templates for each method, with one template for each relevant success and failure condition. Figure 4.6b shows the template for a response indicating the success of an INVITE request. The implements keyword (line 15) is used to describe the class of responses the message created by the template belongs to. The possible classes of requests and responses are defined in the protocol specification module, see Section 4.3.2.\n\n```\nread { \nmandatory private int cseq;\nmandatory private fragment callid;\nmandatory private fragment to;\nmandatory private fragment from;\nmandatory private fragment method;\noptional private fragment to_tag;\noptional private int cseqss;\nmandatory public fragment uri, body;\nmandatory public fragment from_host;\n}\n```\n\n```\nresponse template Invite-ok implements C2xx { \n magic = \"foo\";\n newline = \"\\r\\n\";\n private fragment from, to, callid, via, contact;\n private int cseq, content_length;\n public fragment body, to_tag;\n -- foo \n SIP/2.0 200 OK\n Via: <%via%>\n [ ... ]\n Content-Length: <%content_length%>\n <%body%>\n -- foo }\n```\n\nA template declaration has three parts: the structural declarations (lines 16-17), the template view (lines 18-20), and the template text (lines 21-28). The structural declarations indicate a string, magic, marking the start and end of the template text, and the line separator, newline, specified by the protocol RFC. The template view is analogous to the message view, except that the keywords mandatory and optional are omitted, as all fields are mandatory to create a message. The private fields are filled in by the sending block of the protocol specification. The public fields are filled in by the message translation module. Finally, the template text has the form of a message as specified by the protocol RFC, with holes delimited by <% and >%. These holes refer to the fields of the template view, and are instantiated with the values of these fields when the template is flushed. Binary templates, as needed for SLP messages in our service discovery gateway (Section 4.2), can be defined, using the keyword binary.\n\n### 4.3.4 Message translation module\n\nThe message translation module expresses the message translation logic, which is the heart of the gateway. This module consists of a set of handlers, one for each kind of relevant incoming request, as indicated by the protocol specification module. Handlers are written using a C-like notation augmented with domain-specific operators for manipulating and constructing messages, for sending requests and returning responses, and for session management. Figure 4.7 shows the invite handler for the camera gateway.\n\n**Manipulating message data** A handler is parameterized by a view of the corresponding request. The information in the view can be extracted using the standard structure field access notation (line 13). If a view element is designated as being optional in the message specification module, it must be tested using empty to determine whether its value is available before it is used (line 22). A view element of type fragment can be cast to a message type, using the usual type cast notation. In line 23, for example, the body of the request is cast to an SDP message, which is then manipulated according to its view (line 24).\nZ2z: Automatic Generation of Network Protocol Gateways\n\nA handler creates a message by invoking the name of the corresponding template (line 17). Keyword arguments can be used to initialize the various fields (lines 17-18) or the fields can be filled in incrementally (lines 54-56). A created message is maintained as a viewer during the execution of the handler and flushed to a network message at the point of a send or return operation.\n\nSending requests and returning responses A request is sent using the operator send, as illustrated in line 38. If the protocol specification module for the corresponding target protocol indicates that a response is expected, then execution pauses until a response is received, and the response is the result of the send operation. If the protocol specification indicates that no response is expected, send returns immediately. There is no need for the developer to break the handler up into a collection of callback functions to receive asynchronous responses, as is required in most other languages used for gateway programming. Instead, the difference between synchronous and asynchronous responses is handled by the z2z compiler, as described in Section 4.5. This strategy makes it easy to handle the case where the gateway must translate a single request from the source device into multiple requests for the target device, requiring multiple send operations.\n\nIf the protocol specification module indicates a return type for a handler, then the handler must return a response. This is done using return (line 59), which takes as argument a message and terminates execution of the handler. A provisional response, as is needed in SIP to notify the source device that a message is being treated, can be returned using return (line 17). This operator asynchronously returns the specified message, and handler execution continues.\n\nSession management A session is a state that is maintained over a series of messages. If the protocol specification module for the source protocol declares how messages should be mapped to sessions (session_flow), then the message translation module may declare variables associated with a session outside of any handler. The camera gateway, for example, declares the session variable session_id in line 1. The message translation module initializes a session using session_start() (line 45). Once the session has started any modification made to these variables persists across requests within the ses-\nsion, until the session is ended using \\texttt{session\\_end()}. At this point, all session memory is freed. The SMTP/HTTP/SMTP gateways described in Section 4.2 similarly use sessions to maintain the TCP connection identifier across multiple requests.\n\n### 4.4 Formal Semantics\n\nWe have formally specified the semantics of the message translation module of z2z, enabling a precise definition of the message translation logic and its interaction with the runtime system. In this section, we describe the dynamic semantics of a subset of z2z.\n\n#### 4.4.1 Abstract Syntax\n\nFor conciseness, we focus on a subset of the message translation module of z2z related to operations for sending requests and returning responses, noted \\texttt{MTL\\_send}. The abstract syntax of \\texttt{MTL\\_send} is presented in Figure 4.8. We consider a handler that describes the translation of a message specified by a host \\(a\\) using some protocol \\(A\\) to a host \\(b\\) using some protocol \\(B\\). We assume that the handler returns a response to host \\(a\\). We now describe the relationship between a z2z handler and its \\texttt{MTL\\_send} counterpart.\n\n```plaintext\nhandler ::= method(A request id) { decl* stmt* }\ndecl ::= type id;\ntype ::= ftype | A response | B request | B response\nftype ::= int | fragment | P message | ftype list\nstmt ::= id1 = send(id2, sync);\n return id1 | preturn id1;\n rearm;\n id1 = new(id2);\n id = expr;\n fill(id1, id2, expr);\n if (expr) stmt1 else stmt2\n while (expr) stmt\n { stmt* }\nsync ::= sync | async\nexpr ::= \"...\" | integer | id\n | access(id1, id2)\n | empty(id1, id2)\n | expr1 == expr2 | expr1 + expr2 | expr1 - expr2\n```\n\nFigure 4.8: Abstract syntax of the \\texttt{MTL\\_send} language\n\n**Sending a request.** The send operation of z2z takes as parameter a request to be sent to host \\(b\\) and may receive a response from \\(b\\) as a return value. We assume in the following that \\texttt{send} always returns a value. The first parameter of \\texttt{send} is an identifier of type \\(B\\) request and refers to the message to be sent to host \\(b\\). In addition, we introduce a second parameter to \\texttt{send} to indicate whether the message send is synchronous (\\texttt{sync}) or asynchronous (\\texttt{async}). The choice of a synchronous or asynchronous send is in practice determined by the protocol (see Section 4.3.2). If the second argument to \\texttt{send} is \\texttt{sync}, then the gateway blocks until the response arrives. Otherwise, the thread treating the current message pauses until the response is received.\n Returning a response. The return operator takes as its only argument an identifier \\( id \\) of type A response. The thread treating the current message returns \\( id \\) to host \\( a \\) and aborts. The preturn operator behaves like return except that the thread treating the current message returns \\( id \\) to host \\( a \\) but does not pause, block or abort. In addition to these operators, the rearm operator restarts the most recently started handler. This is used on receiving intermediate responses in an asynchronous protocol, i.e. the same kinds of responses that are generated using preturn.\n\nManipulating message data. In z2z, a message is created by invoking the name of the corresponding template. Keyword arguments can be used to initialize the various fields, or the fields can be filled in incrementally. In MTLsend, a message is created by the new operator that takes as argument an identifier \\( id_2 \\) of type B request, A response or P message. The statement creates a copy of the request or response template that is ready to be instantiated using the operator fill. The first argument of fill is an identifier of type B request, A response, or P message, previously initialized to the result of calling new. The second argument indicates a field name within this request, response, or message, and the last argument must be a value that is appropriate to be placed in this field.\n\nAs described in Section 4.3.4, an optional view element in z2z must be tested using empty to determine whether its value is available before it is used. The empty operator in MTLsend takes two arguments: an identifier of type A request, B response, or P message and an identifier indicating a field name within this request, response, or message.\n\nControl flow constructions and expressions. MTLsend reuses z2z constructions for iterations, conditionals and sequences. In z2z, however, iterations are restricted to the use of the foreach statement in order to prevent infinite loops. In MTLsend, foreach is translated into while. MTLsend expressions are similar to z2z expressions. For conciseness, we focus only on three binary operators: ==, +, and -. The z2z language also supports the unary and binary operators !, !=, &&, ||, >=, >, <, and <=. Because send does not occur in expressions but only occurs at the statement level, the issue of synchronicity only affects the semantics of statements and of terms that contain statements as subterms, i.e. handlers.\n\nAbstracting the message translation module of z2z. Transforming a z2z handler into its MTLsend counterpart is straightforward. This is illustrated by the BYE handler of the SIP/RTSP camera gateway shown in Figure 4.9-a and its MTLsend counterpart is displayed in 4.9-b.\n\nFigure 4.9: BYE handler of the camera gateway service in z2z and its MTLsend counterpart\n4.4.2 Dynamic Semantics\n\nThe small step semantics of $MTL_{send}$ terms is described using a continuation-based abstract machine [1], similar to that used by the semantics of SPL presented in Chapter 2. Execution in this machine is specified as a sequence of configurations, starting with a configuration representing the receipt of a message and ending with a configuration representing the returning of some information to the runtime system. Intermediate configurations represent the execution of a term or the invocation of a continuation. Whenever the semantics begins the execution of a term, it adds a frame to the continuation storing all of the information required to continue execution from the point of that term. This approach makes each configuration self-contained, and is used in the semantics of asynchronous send.\n\nThe values are booleans, fragments, messages, requests and responses. $null$ is both a request, a response, and a message. We assume that the runtime system provides the following functions:\n\n- $send\\_sync : B \\text{ request} \\rightarrow B \\text{ response}$\n- $send\\_async : B \\text{ request} \\rightarrow cont \\rightarrow \\text{ cont} \\rightarrow \\text{ env} \\rightarrow \\text{ id} \\rightarrow \\text{ unit}$\n- $return : A \\text{ response} \\rightarrow \\text{ unit}$\n- $preturn : A \\text{ response} \\rightarrow \\text{ unit}$\n- $new : (A \\text{ response} + B \\text{ request} + P \\text{ message}) \\rightarrow (A \\text{ response} + B \\text{ request} + P \\text{ message})$\n- $fill : (A \\text{ response} + B \\text{ request} + P \\text{ message}) \\rightarrow \\text{ id} \\rightarrow \\text{ fragment} \\rightarrow \\text{ unit}$\n- $access : (A \\text{ response} + B \\text{ request} + P \\text{ message}) \\rightarrow \\text{ id} \\rightarrow \\text{ fragment}$\n- $empty : (A \\text{ response} + B \\text{ request} + P \\text{ message}) \\rightarrow \\text{ id} \\rightarrow \\text{ bool}$\n\nThe configurations used in the semantics are as follows, where $\\rho$ is an environment mapping variables to values, $v$ is a value other than $null$, and $\\kappa_{in}$ and $\\kappa$ are continuations, which are a list of statements. The continuation $\\kappa_{in}$ refers to the complete list of statements defining a handler and is used to restart the semantics while processing a rearm statement.\n\n- $\\text{handlers: } v \\models_{\\rho} \\text{ handler}$\n- $\\text{Declarations: } \\rho \\models_{\\rho} \\text{ declaration } \\Rightarrow \\rho'$\n- $\\text{Expression: } \\rho \\models_{\\rho} \\text{ expression } \\Rightarrow v$\n- $\\text{Statements: } \\rho, \\kappa_{in}, \\kappa \\models_{\\kappa} \\text{ stmt}$\n- $\\text{Continuations: } \\rho, \\kappa_{in} \\models_{\\kappa} \\kappa$\n\nThe semantic rules are described as inference rules, with a sequence of premises above a horizontal bar, and the current configuration and the next configuration, if any, in the execution sequence below the bar, separated by an arrow ($\\Rightarrow$).\n\n**Handlers:**\n\n\\[\n\\begin{align*}\n\\rho_0 &= [id \\mapsto v] & \\rho_0 \\models_{\\rho} \\text{ decl}_1 & \\Rightarrow \\rho_1 & \\ldots & \\rho_{n-1} \\models_{\\kappa} \\text{ decl}_n & \\Rightarrow \\rho_n \\\\\n\\models_{\\rho} \\text{ method } & (\\text{A request } id) \\{ \\text{ decl}_1 \\ldots \\text{ decl}_n & \\text{ stmt}_1 \\ldots \\text{ stmt}_m \\} \\\\\n& \\Rightarrow \\rho_{n-1}, (\\text{stmt}_1, \\ldots, \\text{stmt}_m), \\langle \\rangle \\models_{\\kappa} (\\text{stmt}_1, \\ldots, \\text{stmt}_m)\n\\end{align*}\n\\]\nDeclarations\nThe semantics of declarations is defined as below. Each rule \\(\\rho[id \\mapsto \\text{null}]\\) adds to the environment \\(\\rho\\) an entry for the identifier \\(id\\) with an undefined value.\n\n\\[\n\\rho \\vdash \\text{fragment } id \\Rightarrow \\rho[id \\mapsto \\text{null}] \\\\\n\\rho \\vdash \\text{A response } id \\Rightarrow \\rho[id \\mapsto \\text{null}] \\quad \\rho \\vdash \\text{P message } id \\Rightarrow \\rho[id \\mapsto \\text{null}] \\\\\n\\rho \\vdash \\text{B request } id \\Rightarrow \\rho[id \\mapsto \\text{null}] \\quad \\rho \\vdash \\text{B response } id \\Rightarrow \\rho[id \\mapsto \\text{null}]\n\\]\n\nExpressions\nIn the following semantic rules for expressions, we consider only the equality binary operator. Rules for other binary operators are similar and are standard since the environment \\(\\rho\\) cannot be modified in an expression.\n\n\\[\n\\rho \\vdash \".\" \\Rightarrow \".\" \\quad \\rho \\vdash id \\Rightarrow \\rho(id) \\quad \\rho \\vdash \\text{empty}(id_1, id_2) \\Rightarrow \\text{empty}(\\rho(id_1), \\rho(id_2))\n\\]\n\n\\[\n\\rho \\vdash \\text{access}(id_1, id_2) \\Rightarrow \\text{access}(v_1, v_2) \\quad \\rho \\vdash \\text{expr}_1 \\Rightarrow v_1 \\quad \\rho \\vdash \\text{expr}_2 \\Rightarrow v_2\n\\]\n\n\\[\n\\rho \\vdash \\text{return}\\, v \\Rightarrow \\rho(id) \\quad \\rho \\vdash \\text{return}\\, id \\Rightarrow \\rho(id)\n\\]\n\n\\[\n\\rho \\vdash \\text{rearm} \\Rightarrow \\rho, \\kappa_{in} \\quad \\rho, \\kappa_{in} \\vdash \\text{new}(id_2) \\Rightarrow \\rho[id_1 \\mapsto \\text{new}(id_2)], \\kappa_{in} \\vdash \\kappa\n\\]\n\nStatements The semantics of statements is defined below. Following a call to \\text{send\\_async}(r, \\kappa_{in}, \\kappa, id)\\), a response \\(v\\) should ultimately be received. At this point, the runtime system creates the configuration \\(\\rho[id \\mapsto v], \\kappa_{in} \\vdash \\kappa\\) and restarts the semantics. The rule for \\text{rearm} restarts the semantics at the entry point of the handler using the current environment \\(\\rho\\). This is done using the continuation \\(\\kappa_{in}\\) that represents the body of the handler, and which is passed through each statement rule.\n\n\\[\n\\rho, \\kappa_{in}, \\kappa \\vdash \\text{send\\_async}(v) = v' \\quad \\rho, \\kappa_{in}, \\kappa \\vdash \\text{send\\_async}(v, \\kappa_{in}, \\kappa, id_1) \\Rightarrow \\text{send}(id_2, \\text{async})\n\\]\n\n\\[\n\\rho, \\kappa_{in}, \\kappa \\vdash \\text{return}\\, v \\Rightarrow \\rho(id) \\quad \\rho, \\kappa_{in}, \\kappa \\vdash \\text{return}\\, id \\Rightarrow \\rho(id)\n\\]\n\n\\[\n\\rho, \\kappa_{in}, \\kappa \\vdash \\text{rearm} \\Rightarrow \\rho, \\kappa_{in} \\quad \\rho, \\kappa_{in} \\vdash \\text{new}(id_2) \\Rightarrow \\rho[id_1 \\mapsto \\text{new}(id_2)], \\kappa_{in} \\vdash \\kappa\n\\]\n\n\\[\n\\rho \\vdash \\text{expr} \\Rightarrow v' \\quad \\text{fill}(\\rho(id), \\rho(fld), v') \\Rightarrow \\rho, \\kappa_{in} \\vdash \\kappa \\quad \\rho \\vdash \\text{expr} \\Rightarrow v \\quad \\rho, \\kappa_{in} \\vdash \\text{id} = \\text{expr} \\Rightarrow \\rho[id \\mapsto v], \\kappa_{in} \\vdash \\kappa\n\\]\nChapter 4\n\n\\[ \\rho \\models \\text{expr} \\Rightarrow \\text{true} \\]\n\n\\[ \\rho, \\kappa_{in}, \\kappa \\models \\text{if} (\\text{expr}) \\text{ stmt}_1 \\text{ else stmt}_2 \\Rightarrow \\rho, \\kappa_{in}, \\kappa \\models \\text{stmt}_1 \\]\n\n\\[ \\rho \\models \\text{expr} \\Rightarrow \\text{false} \\]\n\n\\[ \\rho, \\kappa_{in}, \\kappa \\models \\text{if} (\\text{expr}) \\text{ stmt}_1 \\text{ else stmt}_2 \\Rightarrow \\rho, \\kappa_{in}, \\kappa \\models \\text{stmt}_2 \\]\n\n\\[ \\rho \\models \\text{while} (\\text{expr}) \\text{ stmt} \\Rightarrow \\rho, \\kappa_{in} \\models \\text{stmt} \\]\n\n\\[ \\rho, \\kappa_{in}, \\kappa \\models \\text{while} (\\text{expr}) \\text{ stmt} \\Rightarrow \\rho, \\kappa_{in} \\models \\text{stmt} :: \\kappa \\models \\text{stmt} \\]\n\n4.5 Implementation\n\nOur implementation of the z2z gateway generator comprises a compiler for the z2z language and a runtime system. From the z2z specification of a gateway, the z2z compiler generates C code that can then be compiled using a standard C compiler and linked with the runtime system. The generated code is portable enough to run on devices ranging from desktop computers to constrained devices such as PDAs or home appliances. The runtime system defines various utility functions and amounts to about 7500 lines of C code. The z2z compiler is around 10500 lines of OCaml code. The compiler can be used offline to produce the gateway code and therefore is not required to be present on the gateway device. We first describe the verifications performed by the compiler, then present the main challenges in code generation, and finally present the runtime system.\n\n4.5.1 Verifications\n\nThe z2z compiler performs consistency checks, dataflow analyses and model checking to detect erroneous specifications and to ensure the generation of safe gateway code. These analyses are based on the formal semantics of z2z presented in Section 4.4.\n\nConsistency checks. As was shown in Figure 4.4, there are various dependencies between the modules making up a z2z gateway. The z2z compiler performs a number of consistency checks to ensure that the information declared in one module is used elsewhere according to its declaration. The main inter-module dependencies are derived from the request and sending blocks of the protocol specification and the types and visibilities of the elements of the message views. The request block associated with the source protocol declares how to dispatch incoming requests to the appropriate handlers and whether a response is expected from these handlers. The z2z compiler checks that the message translation module defines a handler for each kind of message that should be handled by the gateway and that each handler has an appropriate return type. The sending block of a protocol specification module initializes some fields for all requests or responses sent using that protocol. The compiler checks that every template view defined in the corresponding message specification module includes all of these fields. Finally, the message specification module indicates for each field of a view the type of value that the field can contain and whether the field can be accessed by the message translation module (public) or only by the protocol\nspecification module (private). The z2z compiler checks that the fields are only used in the allowed module and that every access or update has the declared type.\n\n**Dataflow analyses.** The z2z compiler performs a dataflow analysis within the message translation module to ensure that values are well-defined when they are used. The principal issues are in the use of optional message fields, session variables, and created messages. A message specification module may declare some message fields as optional, indicating that they may be uninitialized. The z2z compiler enforces that any reference to such a field is preceded by an empty check. Session variables cannot be used before a `session_start` operation or after a `session_end` operation. The z2z compiler checks that references to these variables do not occur outside these boundaries. Finally, the z2z compiler checks that all public fields of a template are initialized before the template is passed to `send` and that all execution paths through the `sending` block of the corresponding protocol specification module initialize all private fields.\n\n**Model checking.** The z2z compiler checks that the gateway returns responses and send requests according to the state machines of the source and target protocols that describe the sequences of messages that can be received and send. In addition, the z2z compiler enforces the valid usage of sessions and of the TCP protocol. Section 4.6 describes in details the model checker provided by z2z for verifying protocol correctness.\n\n### 4.5.2 Code generation\n\nThe main challenges in generating code from a z2z specification are the implementation of the `send` operation, the implementation of the variables used by the message translation module, and the implementation of memory management.\n\n**The `send` operation.** The handlers of a z2z message translation module are specified as sequential functions, with `send` having the syntax of a function call that may return a value. If the target protocol returns responses synchronously, the z2z compiler does indeed implement `send` as an ordinary function call. If the target protocol returns responses asynchronously, however, this treatment is not sufficient. In this case, the implementation of `send` does not return a value, but must instead receive as an argument information about the rest of the handler so that the handler can be restarted when a response becomes available. The standard solution is to decompose the code into a collection of callback functions, which are tedious, error-prone, and unintuitive to write by hand. Fortunately, it has been observed that such callback functions amount to continuations, which can be created systematically [55]. The z2z compiler thus splits each handler at the point of each `send` to create a collection of functions, of which the first represents the entry point of the handler and the rest represent some continuation.\n\nFigure 4.10 illustrates the splitting of a handler performed by the z2z compiler when the target protocol of a `send` returns responses asynchronously. This code contains three `send` operations, one on line 6 and the others in each of the if branches (lines 12 and 18). The continuation function for the `send` on line s1 contains the code in the region labeled (2). The continuation function for the `send` on line s2 contains the code in region (3) and the one for the `send` on line s3 contains the code in region (4). As shown, the latter two continuation functions explicitly contain only the code within the corresponding if branch. The execution of the handler must, however, continue to the code following the if statement, which is in the continuation of both `send` operations. To reduce the code size, the z2z compiler factorizes the code after the if statement into a separate continuation function, labeled (5), which is invoked by both (3) and (4) after executing the if branch code [93].\n\n**Variables.** Splitting a handler into a set of disjoint continuation functions in the asynchronous case complicates the implementation of the handler's local variables when these variables are used across `sends`\nand thus by multiple continuations. The z2z compiler identifies handler variables whose values must be maintained across asynchronous sends, and implements them as elements of an environment structure that such a send passes to the runtime system. The runtime system stores this environment, and passes it back to the stored continuation function when the corresponding response is received.\n\nSession variables are similarly always implemented in an environment structure, as by design they must be maintained across multiple invocations of the message translation module. Between handler invocations, the runtime system stores this environment with the other information about the session.\n\n**Dynamic memory management.** Template constructors dynamically allocate memory, analogous to Java’s `new` operation. This memory may be referenced from arbitrary local and session variables of the message translation module, and must be freed when no longer useful. Had we translated z2z into a garbage collected language such as Java, then we could rely on the garbage collector to free this memory. We have, however, used C, to avoid the overhead of including a fully-featured runtime system such as the JVM. To avoid the risk of dangling pointers, the z2z compiler generates code to manage reference counts [26]. An alternative, for future work, is to use a garbage collector for C code [9].\n\n### 4.5.3 Runtime system\n\nThe z2z runtime system implements a network server capable of simultaneously handling many messages, that may rely on various protocols. The server is parameterized by the information specific to each protocol, as provided in the corresponding protocol specification module (Section 4.3.2). When a message is received, the runtime system invokes the corresponding parser to construct a message view as defined in the message specification module. The runtime system then executes the code generated from the message translation module for the handler corresponding to the incoming request. The runtime system also provides various utility functions to send requests synchronously or asynchronously, to save and restore environments, to manage sessions, and to perform various other operations.\nReceiving network messages The z2z runtime system is designed to efficiently juggle many incoming requests simultaneously. It is multithreaded, based on the use of a single main thread and a pool of worker threads. The main thread detects an incoming connection, and then assigns the processing of this connection to an available worker thread. The pool of worker threads avoids the high overhead that would be entailed by spawning a new thread per connection, and thus contributes to the overall efficiency of the approach. It furthermore avoids the mutex contention that would be incurred by the use of global shared variables. The z2z developer does not need to be aware of these details.\n\nReceiving messages via TCP poses further challenges. In this case, a stream of messages arrives within a single connection. Depending on the protocol, substantial computation may be required to isolate the individual messages within a stream. Z2z does not itself provide facilities for creating stream-oriented message parser but instead makes it possible to plug in externally developed code. To avoid dropping messages, the main thread assigns two worker threads to a TCP connection. One, the producer, receives data from the incoming TCP stream and separates it into messages, while the other, the consumer, applies the gateway logic. These threads communicate via shared memory. When the producer has extracted a message from the incoming stream, it sends a signal to the consumer, which then reads the message in the shared memory and processes it. On completion, it sends a signal to the producer. This approach allows the main thread to multiplex I/O on a set of server sockets to provide gateway service to multiple devices.\n\nNetwork protocol gateways furthermore must manage multiple concurrent connections between many devices. This adds significantly to the complexity of the gateway implementation. For example, to communicate with a device that uses SMTP, multiple requests must be sent inside the same TCP connection, while for a RTSP device each request requires the creation of a new TCP connection (see Section 4.3.2). The z2z runtime system hides these details from the gateway developer. As illustrated by the HTTP/SMTP example, the runtime system must keep open the TCP connection used to send SMTP requests even if incoming requests are responded to asynchronously. However, in this case, subsequent incoming requests are not related to each other and the runtime system needs to know which TCP connection to use. To address this issue, the runtime system maintains a table of current active TCP connections and provides references to them, so that they can be retrieved later. The runtime system can also seamlessly switch from IPv4 to IPv6, send messages in unicast or multicast, and use UDP or one or many TCP connections, as specified by attributes in the protocol specification module, without requiring any additional programming from the gateway developer.\n\nProcessing a message When a thread is assigned the processing of a message, it executes the message parser of the corresponding protocol to construct a message view, as described in Section 4.3.3. Then, it calls the dispatch function, generated by the z2z compiler from the PS module, to select the handler to execute. If a handler sends requests asynchronously, the runtime system explicitly suspends the control flow and saves the current continuation, handler state, and session state in a global shared memory. The local memory allocated for the current thread is freed and the thread returns to the main pool. When a response is received by the main thread, the runtime system assigns its processing to an available worker thread, restores the corresponding states and continuation, and continues the execution of the handler.\n\n4.6 Model Checking\n\nAs described in Section 4.5.1, the z2z compiler statically performs a number of consistency checks such that a handler accepts only requests from the source protocol. In addition, z2z includes a model checker to check that the gateway returns responses and send requests according to the state machines of the source and target protocols. The z2z model checker also enforces the valid usage of sessions and of the TCP protocol. To this end, the model checker constructs an automaton from the z2z code of the gateway that models the exchange of messages between the gateway and the source and target devices. Automata indicating the constraints on the source and target protocols are also constructed from the z2z protocol specifications. These automata are then combined, along other automata describing the correct usage of sessions and TCP.\nto check correctness properties of the gateway. In the remainder of this section, we describe how these automata are constructed and the checking process.\n\n### 4.6.1 Modeling MTL code\n\nFor conciseness, we consider a simplified MTL language (see Figure 4.11) consisting of the send and return statements as well as session_start and session_end statements for session initiating and ending. The treatment of other kinds of statements such as operations on TCP connections is similar. In this language, expr in an arbitrary expression. SV(expr) returns the set of session variables in expr. In a send or return statement, L is a list of all of the kinds of messages that may be sent or returned. This information is not explicit in the source code, but is made available by the MTL compiler at the AST level.\n\n\\[\nstmt ::= \\begin{cases} \n\\text{send}(L) \\\\\n\\text{return}(L) \\\\\n\\text{session}\\_\\text{start}() \\\\\n\\text{session}\\_\\text{end}() \\\\\n\\text{if} (\\text{expr}) \\ stmt_1 \\ \\text{else} \\ stmt_2 \\\\\n\\{ \\ stmt_1 \\ stmt_2 \\ }\n\\end{cases}\n\\]\n\nFigure 4.11: Simplified MTL language\n\nA node in the automaton modeling a MTL handler is defined by a name and a list of pairs of a message type (or epsilon) and a destination node. The possible messages are shown in Figure 4.12.\n\n<table>\n<thead>\n<tr>\n<th>Interaction between the client and the gateway</th>\n<th>Accept(message_name)</th>\n<th>Return(message_name)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Interaction between the gateway and a server</td>\n<td>Send(message_name)</td>\n<td>Receive(message_name + ε)</td>\n</tr>\n<tr>\n<td>Sessions</td>\n<td>SessionStart</td>\n<td>SessionEnd</td>\n</tr>\n<tr>\n<td>TCP</td>\n<td>TCPConnect</td>\n<td>TCPGetConnection</td>\n</tr>\n<tr>\n<td></td>\n<td>TCPUseConnection</td>\n<td>TCPClose</td>\n</tr>\n</tbody>\n</table>\n\nFigure 4.12: Possible messages in MTL automaton\n\nThe rules for constructing an automaton from a MTL handler are described as inference rules with a sequence of premises above a horizontal bar and a judgment below the bar (see Figure 4.13). These rules use the following functions for constructing an automaton. The function create_node() creates a node in the automaton. The function connect(start,end,l) adds to the node start an edge labelled l that leads to the node end.\n\nThe construction of an automaton for a statement $S$ is defined in terms of a judgment $out \\vdash^S S \\rightarrow (start, end)$, where start is the start node of the automaton associated with $S$ and end is the unique end node. The construction of an automaton for an expression $E$ is defined in terms of a judgment $\\vdash^E E \\rightarrow (start, end)$, where start is the start node of the automaton associated with $E$ and end is the unique end node.\nFigure 4.13: Rules for creating an automaton from MTL code\n\nnode. For a complete handler $H$ for method $h$, the automaton with start node $start$ is constructed according to the following rule:\n\n\\[\n\\begin{align*}\n\\text{start} & = \\text{create}_\\text{node}() \\quad \\text{middle} = \\text{create}_\\text{node}() \\quad \\text{end} = \\text{create}_\\text{node}() \\\\\n\\forall l \\in L : \\text{connect}(\\text{start}, \\text{middle}, \\text{Send}(l)) & \\quad \\text{connect}(\\text{middle}, \\text{end}, \\text{Receive}(\\epsilon)) \\\\\n\\text{out} & \\vdash^S \\text{send}(L) \\rightarrow \\text{start}, \\text{end} \\\\\n\\text{start} & = \\text{create}_\\text{node}() \\quad \\text{end} = \\text{create}_\\text{node}() \\\\\n\\forall l \\in L : \\text{connect}(\\text{start}, \\text{out}, \\text{Return}(l)) & \\\\\n\\text{out} & \\vdash^S \\text{return}(L) \\rightarrow \\text{start}, \\text{end} \\\\\n\\text{start} & = \\text{create}_\\text{node}() \\quad \\text{end} = \\text{create}_\\text{node}() \\\\\n\\text{connect}(\\text{start}, \\text{end}, \\text{SessionStart}) & \\\\\n\\text{out} & \\vdash^S \\text{session}_\\text{start}() \\rightarrow \\text{start}, \\text{end} \\\\\n\\text{start} & = \\text{create}_\\text{node}() \\quad \\text{end} = \\text{create}_\\text{node}() \\\\\n\\text{connect}(\\text{start}, \\text{end}, \\text{SessionEnd}) & \\\\\n\\text{out} & \\vdash^S \\text{session}_\\text{end}() \\rightarrow \\text{start}, \\text{end} \\\\\n\\text{start} & = \\text{create}_\\text{node}() \\quad \\text{end} = \\text{create}_\\text{node}() \\\\\n\\text{connect}(\\text{end}_1, \\text{start}_1, \\epsilon) & \\\\\n\\text{connect}(\\text{end}_2, \\text{start}_2, \\epsilon) & \\\\\n\\text{out} & \\vdash^S \\text{stmt}_1 \\rightarrow \\text{start}_1, \\text{end}_1 \\\\\n\\text{out} & \\vdash^S \\text{stmt}_2 \\rightarrow \\text{start}_2, \\text{end}_2 \\\\\n\\text{out} & \\vdash^S \\{ \\text{stmt}_1 \\mid \\text{stmt}_2 \\} \\rightarrow \\text{start}_1, \\text{end}_2 \\\\\n\\text{start} & = \\text{create}_\\text{node}() \\quad \\text{end} = \\text{create}_\\text{node}() \\\\\n\\text{SV}(\\text{expr}) = \\emptyset & \\\\\n\\text{connect}(\\text{start}, \\text{end}, \\epsilon) \\\\\n\\text{out} & \\vdash^E \\text{expr} \\rightarrow \\text{start}, \\text{end} \\\\\n\\text{start} & = \\text{create}_\\text{node}() \\quad \\text{end} = \\text{create}_\\text{node}() \\\\\n\\text{SV}(\\text{expr}) \\neq \\emptyset & \\\\\n\\text{connect}(\\text{start}, \\text{end}, \\text{SessionAccess}) \\\\\n\\text{out} & \\vdash^E \\text{expr} \\rightarrow \\text{start}, \\text{end} \\\\\n\\end{align*}\n\\]\n\n\\[\\text{H} \\rightarrow \\text{start}\\]\n\n4.6.2 Modeling protocols\n\nWe consider the case of a gateway $G$ from a source protocol $P_s$ to a target protocol $P_t$. For each of $P_s$ and $P_t$ we have an automaton $A_{P_s}$ and an automaton $A_{P_t}$, respectively, indicating the constraints on the messages that they are able to receive and their behaviors on these messages. These automata are described in the protocol specification module, as described in Section 4.3.2. For each message $m$ recognized by $P_s$, the gateway has a handler $G_m$. These handlers are connected within and infinite loop. That is, the automaton $A_G$ for the gateway can be viewed as being represented by the regular expression $(G_{m_1} \\mid \\ldots \\mid G_{m_n})^*$. The messages exchanged by the source and target protocols and the gateway are as follows:\nIn addition to the automata $A_{Ps}$ and $A_{Pt}$, the z2z model checker uses an automaton $A_{sessions}$ representing the valid usage of sessions. The z2z model checker also uses an automaton $A_{tcp}$ representing the valid usage of the TCP protocol. These automata do not depend on the specification of the gateway, and are therefore provided by the z2z model checker as built-in information.\n\n### 4.6.3 Algorithm\n\nAlthough the MTL automaton contains all edges, we need to specialize it for the needs of individual checks. The model checking algorithm relies on several operators for adjusting the set of edges in an automaton. We represent an automaton abstractly as a collection of nodes $N$ and a collection of directed edges $E = N \\times L \\times N$, where $(n_1, l, n_2)$ is an edge from node $n_1$ to node $n_2$ with label $l$. The operators are then defined on an automaton $(N, E)$ as follows:\n\n- $\\text{augment}_\\text{aut}((N, E), L) = (N, E \\cup \\{(n, l, n) \\mid n \\in N \\land l \\in L\\})$. This function is used to extend an automaton such that it allows any number of transitions for any message $l$ in $L$ at any state $n$ in $N$.\n\n- $\\text{determinize}((N, E), L)$. This function creates a deterministic version of $(N \\cup \\{\\text{sink}\\}, E \\cup \\{(n, l, \\text{sink}) \\mid n \\in N \\land l \\in L\\})$. The argument $L$ is used here to extend the set of edge labels of the automaton so that it can be combined with another automaton with the larger set of edge labels.\n\n- $\\text{filter}_\\text{aut}((N, E), \\phi, L) = \\text{determinize}(N, \\{(n_1, l, n_2) \\mid (n_1, l, n_2) \\in E \\land \\phi(l))_1, L\\}$. This function is used to limit an automaton to edges whose labels satisfy the property $\\phi$. The elements of $L$ are assumed to satisfy this property. We provide four filters as described below\n\n$$\n\\begin{align*}\n\\phi_{Ps}(l) &= l \\in \\{\\text{Accept, Return}\\} \\\\\n\\phi_{Pt}(l) &= l \\in \\{\\text{Send, Receive}\\} \\\\\n\\phi_{session}(l) &= l \\in \\{\\text{SessionStart, SessionAccess, SessionEnd}\\} \\\\\n\\phi_{tcp}(l) &= l \\in \\{\\text{TCPConnect, TCPGetConnection, TCPUseConnection, TCPClose}\\}\n\\end{align*}\n$$\n\n### Verification setup\n\nThe verification process takes three automata as arguments: $A_{Ps}$ for the source protocol, $A_{G}$ for the gateway, and $A_{Pt}$ for the target protocol (we assume only one target protocol for conciseness). The verification process also refers to the automata $A_{sessions}$ and $A_{tcp}$ shown previously.\nThe first step is to replace all \\texttt{Receive} messages in the \\( A_P \\) by \\texttt{Receive}(\\( \\varepsilon \\)) messages that do not specify the type of message received. This is due to the fact that MTL provides no support for making the type of message received apparent.\n\nThe next step is to collect the various kinds of edge labels in the various automata:\n\n- **left\\_edges**: The edges in \\( A_P \\).\n - These are \\texttt{Accept} and \\texttt{Return} edge labels.\n- **mtl\\_edges**: The edges in the \\( A_G \\) except the \\texttt{Accept} edges.\n - These are \\texttt{Return}, \\texttt{Send} and \\texttt{Receive}(\\( \\varepsilon \\)) edge labels, and the various session and TCP edge labels.\n- **right\\_edges**: The edges in \\( A_T \\).\n - These are \\texttt{Send} and \\texttt{Receive}(\\( \\varepsilon \\)) edge labels.\n- **session\\_edges**: The edges in \\( A_{sessions} \\).\n - These are \\texttt{SessionStart}, \\texttt{SessionEnd}, and \\texttt{SessionAccess}.\n- **TCP\\_edges**: The edges in \\( A_{tcp} \\).\n - These are \\texttt{TCPConnect}, \\texttt{TCPClose}, \\texttt{TCPGetConnection}, and \\texttt{TCPUseConnection}.\n\n**Gateway automaton**\n\nThe MTL code consists of a set of handlers, with no indication of the order in which they may be executed. This order is instead determined by the source protocol. To restrict the gateway automaton to the sequences of messages that can be received from the source protocol, we essentially want to intersect the source protocol automaton with the gateway automaton. A straightforward intersection, however, will fail, because the gateway automaton contains the edges for the interaction with the target protocol and possibly with sessions and TCP, that are not in the source protocol automaton. Nevertheless, we would like to preserve these edges in the result of the intersection, so that this automaton can be checked against the target protocol automaton, the session automaton, and the TCP automaton. As the source protocol has no preference about when and how many of these extra edges appear, we simply use \\texttt{augment\\_aut} to add a reflexive edge for each of them at every node.\n\nFurthermore, the gateway might be incorrect and generate some \\texttt{Return}s that are not allowed by the source protocol. If we were to intersect the source protocol automaton with the gateway automaton, these \\texttt{Return} edges would disappear. Thus before performing the intersection, we additionally use \\texttt{augment\\_aut} to create a version of the source protocol automaton with a reflexive edge for each \\texttt{Return} at every node.\n\nIn summary, we compute \\( A^\\lor_P = \\texttt{augment\\_aut}(A_P, \\text{mtl\\_edges}) \\). Then, we compute \\( A^\\lor_G = A^\\lor_P \\cap A_G \\), the intersection of \\( A^\\lor_P \\) with the gateway protocol automaton. The only effect of this intersection is to chain the handlers of the gateway automaton according to what is allowed by the source protocol automaton.\n\n**Checking compatibility**\n\nFinally, our goal is to check whether the restricted gateway automaton \\( A^\\lor_G \\) is compatible with all of the other automata. By compatible, we mean a subset: the gateway automaton should produce some of the message sequences that are allowed, but need not produce all of them, and should not produce message sequences that are not allowed. The desired relationships are as follows, where \\( A \\preceq B \\) means that \\( A \\) is compatible with \\( B \\):\n\n\\[\n\\begin{align*}\nA^\\lor_G & \\preceq A_P & \\text{Subsets of expected Returns} \\\\\nA^\\lor_G & \\preceq A_T & \\text{Subsets of expected Sends} \\\\\nA^\\lor_P & \\preceq A_{sessions} & \\text{Subsets of expected operation sequences} \\\\\nA^\\lor_P & \\preceq A_{tcp} & \\text{Subsets of expected operation sequences}\n\\end{align*}\n\\]\n\n| Table 4.1: Relationships between automata |\n\nIn each of the multidirectional cases (source protocol vs. gateway and gateway vs. target protocol), one direction is forced to be an equality, so it is sufficient to do a subset check in the other direction. Note that in the case of the target\nprotocol, this property follows directly from the fact that we have replaced all of the \\texttt{Receive} edges by \\texttt{Receive}(\\epsilon) in the verification setup phase. In the \\texttt{Accept} case, equality on acceptation is forced by the \\texttt{z2z} compiler. In the \\texttt{Receive} case, if the sends are correct, the \\texttt{z2z} compiler forces the receives to be correct.\n\nIn each case, to check compatibility of \\( A_{PS} \\) with an automaton \\( A \\in \\{ A_{PS}, A_{Pt}, A_{sessions}, A_{tcp} \\} \\), we first use \\texttt{filter\\_aut} to restrict \\( A_{PS} \\) to the kinds of edges that are found in \\( A \\). The filter \\( \\phi _{PS} \\) is used for comparison with the source protocol automaton, \\( \\phi _{session} \\) for comparison with the session automaton, and \\( \\phi _{tcp} \\) for comparison with the TCP automaton. The resulting filtered automaton is defined on exactly the same set of edges that are used to define the automaton \\( A \\) with which it is being compared. Finally, we check that the resulting filtered automaton is a subset of \\( A \\).\n\nThe subset check \\( A \\subseteq B \\) is implemented as \\( A \\cap \\overline{B} \\), where \\( \\overline{B} \\) is the complement of \\( B \\). The result of this intersection, if not empty, describes the automaton of failures. We select one of the smaller paths produced by this automaton and display it to the user as a counter example, describing a rule violation.\n\n### 4.7 Evaluation\n\nTo assess our approach, we have implemented the SIP/RTSP, SLP/UPnP, SMTP/HTTP and HTTP/SMTP gateways described in the case studies of Section 4.2. We have implemented our gateways on a Single Board Computer (SBC) to represent the kind of limited but inexpensive or energy-efficient devices that are found in PDAs, mobile devices and home appliances. We use a Eukräa CPUAT91 card\\(^3\\) based on a 200 MHz ARM9 processor. The SBC has 32MB of SDRAM, 8MB of flash memory, an Ethernet controller, and runs a minimal Linux 2.6.20 kernel. For the SIP/RTSP experiment, we use the open-source Linphone video-phone client\\(^4\\) and an Axis RTSP camera. For the SLP/UPnP experiment, we use a handcrafted SLP client based on the INDISS framework\\(^5\\) and a UPnP service provided by CyberLink.\\(^5\\) For the SMTP/HTTP/SMTP experiment, we use the multi-threaded SMTP test client and server distributed with Postfix\\(^6\\) to stress the generated gateways.\n\nThe gateway size is shown in Figure 4.14.\n\n\n\nFigure 4.14 shows the size of the various specifications that must be provided to generate each gateway. A protocol specification module is independent of the targeted gateway and thus can be shared by all gateways relevant to the protocol. The message translation module for the SLP/UPnP gateway is particularly simple, being only 5 lines of code. Indeed, the complete \\texttt{z2z} specification for this gateway is less than 100 lines of code. As described in Section 4.3.3, the message specification module must provide a parser for incoming messages. For our experiments, we have implemented simple parsers for each message type, amounting to at most 488 lines of C code. Each of the generated gateways does not exceed, in the worst case, 150KB of compiled C code, including 80KB for the runtime system.\n\n---\n\n\\(^3\\)Eukräa. http://www.eukrea.com/\n\n\\(^4\\)Linphone: http://www.linphone.org/\n\n\\(^5\\)CyberLink: http://www.cybergarage.org/net/upnp/java/\n\n74\nFigure 4.15: Native service vs. z2z (ms)\n\nFigure 4.15 shows the response time for the SIP/RTSP, SLP/UPnP, and SMTP/HTTP/SMTP gateways, as well as the native protocol communication costs. In each case, at the client side we measure the time from sending an initial request to receiving a successful response. These experiments were performed using the loopback interface to remove network latency. As illustrated in Figure 4.15(a), the z2z implementation of the SIP/RTSP gateway does not introduce any overhead as compared to an ideal case of zero-cost message translation, since its response time is less than the sum of the response times for SIP and RTSP separately. Indeed, as illustrated in Figure 4.7, RTSP requests are sent before the completion of the SIP INVITE handler leading to an interweaving of SIP and RTSP transactions. The response time for the SLP/UPnP gateway is a little more than that of SLP and UPnP separately. The cost of the z2z gateway is due in part to the polling done by the main thread in the case of asynchronous responses, as described in Section 4.5.3. This strategy introduces some time overhead, but reduces memory requirements. The response time for UPnP, furthermore, depends heavily on the stack that is used. If we use a Siemens stack\\(^6\\) rather than the CyberLink stack, the native UPnP time rises to 593ms, substantially higher than the gateway cost.\n\nFigure 4.15(b) shows the performance of the gateways generated in order to tunnel SMTP traffic into HTTP. We consider three types of tunnel according to the nature of transport layer protocol being used to exchange either asynchronously (i.e. UDP or TCP non-alive) or synchronously (i.e. TCP alive) messages between the two tunnel endpoints. When sending one e-mail, with a size from 1KB up to 10 KB, passing through a HTTP tunnel roughly increases the native response time by a factor of 5, whatever tunnel is considered. This overhead comes primarily from the mailing process. According to the SMTP RFC5321, sending an e-mail involves sending at least 5 SMTP commands and acknowledgements, of at most 512 bytes each, and splitting the mail content in order to send chunks of at most 998 bytes. Commands, acknowledgements, and data chunks are packets that need to be encapsulated into the HTTP message and de-encapsulated on both sides of the HTTP tunnel. Increasing the number of packets being encapsulated at tunnel end-points inherently increases the response time. Our experimental results show that sending a sequence of 10 emails increases the response times at most by 43 as compared to a native implementation in the worst case. However, when the mail is sent in parallel (10 clients), response times only increase by a factor of at most 10. The latter result highlights the efficiency of the parallelism provided by our generated gateways. Furthermore, note that the SMTP test server simply throws away the messages received from network without processing them, whereas the tunnel end-points must process them, therefore increasing the response time. The native response time obtained with a real deployed SMTP server such as Postfix [51] may be up to 18x slower than the SMTP test server, which is much closer to the response times obtained via the generated gateways.\n\nFinally, Figure 4.16 shows the amount of dynamic memory used during the lifetime of each of our generated gateways. The memory footprint is directly related to the network input/output traffic. When idle, the memory consumption is low and does not exceed 2KB for the considered gateways. At peak time, both the SIP/RTSP and SLP/UPnP gateways consume at most 14KB, as shown in Figs. 4.16(a) and 4.16(b). Comparatively, the SMTP/HTTP/SMTP gateways based on TCP use only at most 60KB to process one hundred KB mails sent by 10 simultaneous clients. However, the\n\n\\(^6\\)Siemens UPnP: http://www.plug-n-play-technologies.com/\nmemory consumption of the UDP-based gateway may reach up to 159KB-260KB, as shown in Figure 4.16(c). This overhead is inherent in the use of UDP, as a dedicated 1500 byte buffer is allocated for each incoming UDP packet. TCP, on the other hand, enables reading variable-size messages into a stream.\n\n4.8 Related Work\n\nOther approaches to interoperability. The middlewares ReMMoC [47], RUNES [33], MUSDAC [86], and BASE [6] for use in networked devices allow the device code to be developed independently of the underlying protocol. Plug-ins then select the most appropriate communication protocol according to the context. Many applications, however, have not been developed using such middleware systems and cannot be modified because their source code is not available.\n\nBridges provide interoperability without code modification. Direct bridges, such as RMI-IIOP7 and IIOP-.NET,8 provide interoperability between two fixed protocols. A direct bridge must thus be developed separately for every pair of protocols between which interaction is needed. The diversity of protocols that are used in a networked home implies that this is a substantial development task. Indirect bridges such as Enterprise Service Buses (ESBs) [25], translate messages to and from a single fixed intermediary protocol. This approach reduces the development effort, but may limit expressiveness, as some aspects of the relevant protocols may not be compatible with the chosen intermediary protocol. INDISS [14] and NEMESYS [11] also use a single intermediary protocol, but one that is specific to the protocols between which interoperability is desired. Still, none of these approaches addresses the problem of implementing the bridge, which requires a thorough knowledge of the protocols involved and low-level network programming. This makes it difficult to quickly integrate devices that use an unsupported protocol into a home environment.\n\nZ2z can be used in the context of either direct or indirect bridges. Our approach targets the weak point of both: the difficulty of bridge development. We propose a high-level interface definition language that abstracts away from network details, makes relevant protocol properties explicit, provides static verification at the specification level, and automatically generates low-level code.\n\n7RMI-IIOP: http://java.sun.com/products/rmi-iiop/\n8IIOP-.NET: http://iiop-net.sourceforge.net/index.html\nCompilation. Z2z uses a number of advanced compilation techniques to be able to provide a high-level notation while still generating safe and efficient code. Krishnamurthi et al. [55] pioneered the use of continuations to overcome the asynchrony common in web programming. Our implementation of continuations in C code is based on that presented by Friedman et al. [45]. Our dataflow analysis uses standard techniques [3], adapted to the operations of the z2z DSL. Finally, reference counting has long been used to replace garbage collection [26].\n\n4.9 Conclusion\n\nIn this chapter, we have presented a generative language-based approach, z2z to simplify gateway construction, a problem that has not been considered by previous frameworks for gateway development. Z2z is supported by a runtime system that hides low-level networking intricacies and a compiler that checks essential correctness properties and produces efficient code. We have used z2z to automatically generate gateways between SIP and RTSP, between SLP and UPnP, and between SMTP and SMTP via HTTP. The gateway specifications are 100-400 lines of z2z code while the generated gateways are at most 150KB of compiled C code and run with a runtime memory footprint of less than 260KB, with essentially no runtime overhead.\nChapter 5\n\nConclusion\n\nThis chapter concludes the thesis. We start by a brief summary of the contributions presented in the document and then give some directions for future work.\n\n5.1 Summary of contributions\n\nIn this thesis, we have shown that domain-specific languages (DSLs) can successfully reduce the level of expertise required to build efficient and robust distributed systems, putting service programming within the reach of average developers. We have presented three contributions in this area.\n\nThe first contribution is a DSL-based approach for creating telephony services based on the SIP protocol. We have defined a domain-specific virtual machine for SIP, providing the programmer with a high-level interface dedicated to telephony service development. Additionally, we have introduced a DSL named SPL that offers high-level notations and abstractions for service development. A variety of services have been written in SPL, demonstrating the usability and ease of programming of the language. Its robustness has been a key factor in expediting service deployment.\n\nThe second contribution is Zebu, a DSL-based approach for the development of network application protocol-handling layers. We have demonstrated, through various experiments, that this approach is a reliable alternative to manual development. Zebu-generated code has good performance and has a significantly lower memory footprint than comparable existing manually encoded solutions, while guaranteeing robustness and performance.\n\nThe third contribution is z2z, a generative approach to gateway construction that enables communication between devices that use incompatible protocols. Z2z includes a compiler that checks essential correctness properties, and a runtime system that hides low-level details from the gateway programmer. We have used z2z to automatically generate gateways between various incompatible protocols. The generated gateways run with a low runtime memory footprint, and with essentially no runtime overhead.\n\n5.2 Future Work\n\nIn the remainder of this section, we present some directions for future work, some of which is already in progress.\n\nA reconfigurable multi-protocol and multi-radio gateway Recent years have seen a phenomenal growth in various networking devices ranging from sensors to mobile devices. This has been combined with the advances in wireless networking technologies such as Bluetooth, Radio-Frequency Identification (RFID), Ultra-wideband (UWB), and WiFi. These changes are promoting the deployment of a worldwide Internet of Things (IoT). Any computing units that embed short range mobile transceivers should able to interact directly with each other at anytime, anywhere through an always-on connectivity. In this context, the Internet can be viewed as one backbone network that interconnects a huge collection of small separate networks. Examples of such separate networks include sensor networks, vehicular networks, MANETs, and internal networks of corporations.\nUn fortunately, however, the devices used in these domains are highly heterogeneous in terms of both hardware and software. Traditionally, because of substantial resource constraints (battery, memory, CPU, etc.), these devices provide only a limited set of wireless networking technologies and support few application protocols. As described in Chapter 4, z2z addresses the protocol incompatibility issue by automatically generating gateways. Nevertheless, z2z-based gateways rely on the wireless networking capabilities of host devices, preventing them from communicating with devices that use unsupported technologies. Over the last decade, software defined radio (SDR) has gained an increasing interest, as new radio standards are deployed without substantially supplanting existing ones [35]. With the unique combination of size and power efficiency of reconfigurable hardware platforms such as FPGAs, SDR becomes an appealing approach. SDR is easy to reconfigure since most of the key components in the communication system, including the physical layer, are pushed into software. In addition, FPGAs are increasingly used in embedded devices to provide good performance while consuming low resources.\n\nWe plan to extend z2z by enabling gateways deployed in appliances with constrained resources such as telephones or set top boxes to be dynamically updated according to the devices currently present in their environment. We are currently investigating the use of FPGAs to provide software defined radio capabilities and a fine grained usage of the limited appliance resources. We will also investigate the design of a reconfigurable communication middleware to provide secure and robust dynamic reconfiguration capabilities to the underlying reconfigurable hardware platform.\n\nEfficient event-based multicore programming for system services\n\nThe advent of multicore hardware is today a reality. Nevertheless, current systems and applications are unable to fully exploit these new architectures: performance is stalling, even though the number of cores is rising. This inability to exploit the available processing power is inhibiting the development of innovative, demanding software services. This is particularly true for operating system kernels and system services, which are known to be complex to develop and optimize. In fact, efficiently exploiting multicore architectures is one of the main research and industrial challenges of the coming years.\n\nOne of the main reasons why current system software does not take full advantage of multicore architectures is that it is mostly designed using the traditional, thread-based programming model. System services that were developed using the thread-based model and that were achieving very good performance on monocore architectures, often fail to yield good performance on multicore architectures. The inter-thread synchronization code used to manage concurrent accesses to shared data structures is very complex and error-prone [39, 44, 66, 67, 68, 80]: traditional locking-based techniques can induce bugs such as priority inversions, deadlocks, or even livelocks. To avoid these problems, developers often design programs that use coarse grain synchronization, which limits parallelism. While on monocore architectures, this limit on parallelism is often hidden due to the low pressure of coarse-grained, pseudo-parallel executions, this is no longer the case on multicore architectures. Due to the use of coarse-grained parallelism, services do not fully exploit all the cores available.\n\nEvent-based programming is a promising approach for parallel programming as it significantly reduces the need to write complex synchronization code. Most event-driven runtimes, however, have been designed for monocore architectures. The challenge in a multi-core setting is to provide atomic execution of event handlers, free from interference with event handlers running on other cores. Event coloring, in which event handlers are annotated to indicate bad interactions with other handlers, is a promising approach to address this problem, but has not yet been successfully implemented in an efficient manner.\n\nWe plan to introduce optimizations into an event-coloring event-based runtime, to make it possible for applications to scale linearly with the number of cores. Optimizations to be considered include improving the use of caches, to reduce the usage of synchronization code. Our goal is to propose a DSL that will be used for programming system services and will drive the optimization of the event-based runtime. To the best of our knowledge, there exist very few DSLs related to this context [57, 23].\n\nDSLs as a software architecture for future system services\n\nAccording to Moore’s Law, the number of transistors on a chip roughly doubles every two years. This prediction has proved to be uncannily accurate, and is expected to continue for at least several years. To take full advantage of the gains allowed by this trend, processor makers favor multi-core chip designs in almost all application domains, from high performance computers to embedded systems. Indeed, some vendors have already announce smartphones with quad core processors. Similarly, numerous other hardware components (i.e., memory, screen, network) are expected to provide in the near future capabilities well beyond what they do today.\n\nThis phenomenal growth of various device technologies is promoting the deployment of advanced end user services whose needs are difficult to anticipate. However, the development of these services will require that the service programmer have extensive expertise in many fields. As demonstrated by the contributions presented in this thesis, we\nargue that a DSL-based software architecture is a candidate of choice for the development of system services of the future.\n\nAs system services are becoming more and more complicated to develop, they may require to use several DSLs, each being designed for a particular subproblem. However, the proliferation of different languages may increase the difficulty of their integration in a complex system and thus limit the practical benefits of DSLs. We think that one of the most challenging directions for future work is to address this issue of DSL composition for system services. DSL composition has been already investigated [72, 90], mainly in the context of embedded DSLs. However, to the best of our knowledge, there exist very few approaches for composing DSLs in the context of system services. Based on our experience in developing DSLs for distributed systems, we plan to investigate this research area.\nBibliography\n\n\nBIBLIOGRAPHY\n\n\nAppendix A\n\nThe SPL Language\n\nThis chapter presents the syntax of the SPL language using a BNF-like notation. **typewriter font** is used for keywords. **italic font** is used for nonterminals. Parentheses are used for grouping. A superscript * denotes 0 or more occurrences of the preceding item. A superscript + denotes 1 or more occurrences of the preceding item. A superscript ? indicates that the preceding item is optional. Identifiers (ident) and various other base type terms (char-val, num-val, etc.) are left unspecified.\n\nA.0.1 Lexical Conventions\n\n**SPL Comments** Comments are C-like comments. They start with the characters / * and end with the characters */. C++ comments style can also be used; all characters from the two characters // until the end of the line are considered as part of a comment. Comments are treated as blanks.\n\n**Identifiers.** An identifier is a sequence of letters, digits and _ (the underscore character) starting with a letter or an underscore. A letter can be any of the 52 lowercase and uppercase letters from the ASCII character set. The current implementation places no limit on the number of characters in an identifier.\n\n\\[\n\\text{ident} ::= (\\text{letter} \\mid \\_)(\\text{letter} \\mid \\text{digit} \\mid \\_)*\n\\]\n\\[\n\\text{letter} ::= \\text{A..Z} \\mid \\text{a..z}\n\\]\n\\[\n\\text{digit} ::= 0..9\n\\]\n\nThere are several kinds of identifiers:\n- **ident** which defines identifiers (for variables, functions, branches and service name)\n- **headerId** which defines SIP headers in the RFC fashion, with a colon at the end of the header name\n- **eventIdent** which defines SIP events in the RFC fashion, as an alphanumeric sequence of characters with possibly some \\'\\.' inside when template event packages are used\n- **uriScheme** which is defined as scheme in RFC 3261\n\n**Header Names** A header name is a sequence of letters, digits and \\- (the minus character) starting with a letter and ending with a colon. A letter can be any of the 52 lowercase and uppercase letters from the ASCII character set. The current implementation places no limit on the number of characters of a header name.\n\n\\[\n\\text{headerId} ::= \\#\\text{letter} \\mid \\text{digit} \\mid \\_ \\mid \\! \\mid \\% \\mid \\* \\mid - \\mid + \\mid \\' \\mid \\```\\)\" \n\\]\n\n**Event Identifiers** An event identifier is a sequence of letters, digits and special characters as defined in RFC 3265. A letter can be any of the 52 lowercase and uppercase letters from the ASCII character set. The current implementation places no limit on the number of characters of an event identifier.\nAppendix A\n\n\\[\neventIdent ::= \\text{event-package} (\\text{. event-template})^* \\\\\nevent-package ::= \\text{token-nodot} \\\\\nevent-template ::= \\text{token-nodot} \\\\\ntoken-nodot ::= (\\text{letter | digit | _ | ! | % | * | - | + | ’ | ‘ | ~})^+\n\\]\n\n**Integer Literals** An integer literal is a sequence of one or more digits. Integer literals are in decimal (radix 10).\n\n\\[\ninteger ::= 0 | (1..9 \\text{ digit}^*)\n\\]\n\n**Prefix and Infix Operator** The following tokens are the SPL operators:\n\n\\[\n\\begin{align*}\n= & + & - & \\ast & / & \\&\\& \\\\\n== & \\neq & < & > & >= & || \\\\\n<= & ! & \\text{match} & \\text{notmatch}\n\\end{align*}\n\\]\n\n**Keywords** The identifiers below are reserved keywords:\n\n\\[\n\\begin{align*}\n\\text{BODY} & \\quad \\text{bool} & \\quad \\text{branch} & \\quad \\text{break} & \\quad \\text{by}\n\\text{cancel} & \\quad \\text{case} & \\quad \\text{continue} & \\quad \\text{default} & \\quad \\text{deploy}\n\\text{dialog} & \\quad \\text{else} & \\quad \\text{event} & \\quad \\text{extern} & \\quad \\text{false}\n\\text{FIFO} & \\quad \\text{foreach} & \\quad \\text{forward} & \\quad \\text{http} & \\quad \\text{https}\n\\text{if} & \\quad \\text{in} & \\quad \\text{incoming} & \\quad \\text{int} & \\quad \\text{LIFO}\n\\text{mailto} & \\quad \\text{match} & \\quad \\text{notmatch} & \\quad \\text{outgoing} & \\quad \\text{parallel}\n\\text{pop} & \\quad \\text{processing} & \\quad \\text{push} & \\quad \\text{reason} & \\quad \\text{registration}\n\\text{request} & \\quad \\text{requestURI} & \\quad \\text{response} & \\quad \\text{return} & \\quad \\text{select}\n\\text{service} & \\quad \\text{sip} & \\quad \\text{sips} & \\quad \\text{string} & \\quad \\text{this}\n\\text{time} & \\quad \\text{true} & \\quad \\text{type} & \\quad \\text{undeploy} & \\quad \\text{uninvite}\n\\text{unregister} & \\quad \\text{unsubscribe} & \\quad \\text{uri} & \\quad \\text{void} & \\quad \\text{when}\n\\text{with}\n\\end{align*}\n\\]\n\nThe following character sequences are also reserved.\n\n\\[\n\\{ \\} \\ [ \\] \\ ( \\) \\ < \\ > \\ |\n\\]\n\n\\[\n= \\ : \\ , \\ .\n\\]\n\n**Ambiguities** Lexical ambiguities are resolved according to the “longest match” rule: when a character sequence can be decomposed into tokens in several different ways, the resulting decomposition is the one with the longest first token.\n\n## A.1 SPL Program\n\nA SPL program consists of a service name and a service construct. When a method declaration does not specify an explicit direction, it applies to both incoming and outgoing. SIP method names, as defined by the rule SIPmethod are treated as SPL keywords.\nThe SPL Language\n\nprogram ::= service ident {service}\n\nservice ::= processing {declarations? session*}\n\nsession ::= registration {declarations? session*}\n\nmethod ::= typExp direction? methodName (arg? ) {stmt+}\n\nbranch ::= branch ident { stmt* }\n\nstatement ::= { stmt* }\n\ndirection ::= incoming | outgoing\n\nmethodName ::= SIPmethod\n\nSIPmethod ::= INVITE | ACK | BYE | CANCEL | OPTIONS | MESSAGE\n\n| NOTIFY | PUBLISH | REGISTER | SUBSCRIBE\n\n| REINVITE | REREGISTER | RESUBSCRIBE\n\nctrlMethod ::= deploy | undeploy\n\nA.2 Type Expressions\n\nSPL type expressions are defined as follows.\n\ntypExp ::= simpleType\n\n| modifier? simpleType<integer>\n\n| ident\n\nsimpleType ::= void | bool | int | request | response\n\n| string | time | uri\n\nmodifier ::= LIFO | FIFO\n\nA.3 Function Call\n\nA function call is defined as follows.\n\nfunctionCall ::= ident (expList?)\n\nexpList ::= exp ( , exp)*\n\nA.4 Known URI Kinds\n\nStandard URI kinds are treated as reserved keywords. Otherwise, the URI scheme is defined according to RFC 3261.\n\nuriKind ::= http | https | mailto | sip | sips\n\n| uriScheme\n\nuriScheme ::= letter (letter | digit | - | + | .)*\n\nA.5 Declarations\n\nDeclarations are defined as follows.\nA.6 Statements\n\nStatements are defined as follows.\n\n\\[\n\\text{compound} ::= \\quad \\text{stmt} \\\\\n\\quad \\quad \\quad \\quad (\\text{stmt}^+) \\\\\n\\text{stmt} ::= \\quad \\text{place} = \\text{exp} \\\\\n\\quad \\quad \\quad \\quad \\text{declaration} \\\\\n\\quad \\quad \\quad \\quad \\text{return} \\text{exp}^+ (\\text{branch} \\text{ident})^+ \\\\\n\\quad \\quad \\quad \\quad \\text{if} (\\text{exp}) \\text{compound} \\\\\n\\quad \\quad \\quad \\quad \\text{if} (\\text{exp}) \\text{compound} \\text{else} \\text{compound} \\\\\n\\quad \\quad \\quad \\quad \\text{when} \\text{exp} (\\text{when-headers}) \\text{compound} \\\\\n\\quad \\quad \\quad \\quad \\text{when} \\text{exp} (\\text{when-headers}) \\text{compound} \\text{else} \\text{compound} \\\\\n\\quad \\quad \\quad \\quad \\text{exp} \\text{with} \\{ \\text{messageField}, \\text{messageField}\\}^+ \\\\\n\\quad \\quad \\quad \\quad \\text{foreach} (\\text{ident} \\text{in} \\text{exp}) \\text{compound} \\\\\n\\quad \\quad \\quad \\quad \\text{select} (\\text{exp}) \\{ \\text{selectCase}^+ \\text{selectDefault}^+ \\} \\\\\n\\quad \\quad \\quad \\quad \\text{functionCall} \\\\\n\\quad \\quad \\quad \\quad \\text{continue} \\\\\n\\quad \\quad \\quad \\quad \\text{break} \\\\\n\\quad \\quad \\quad \\quad \\text{push} \\text{place} \\text{exp} \\\\\n\\text{when-headers} ::= \\quad \\text{when-header}, \\text{when-header}^+\n\\text{when-header} ::= \\quad \\text{headerId} \\text{typExp} \\text{ident} (<- \\text{const})^+\n\\text{selectCase} ::= \\quad \\text{case} \\text{orList}: (\\text{stmt})^+\n\\text{selectDefault} ::= \\quad \\text{default}: (\\text{stmt})^+\n\\text{orList} ::= \\quad \\text{const} | \\text{const}^+\n\\text{place} ::= \\quad \\text{ident}, \\text{ident}^+ \\\\\n\\quad \\quad \\quad \\quad \\text{sipHeader}\n\\]\n\nA.7 Message Modification\n\nThe with construct allows modification of the field values of a request or response. The this constant refers to the the current processed request.\n\n\\[\n\\text{messageField} ::= \\quad \\text{reason}=\\text{exp} \\\\\n\\quad \\quad \\quad \\quad \\text{headerId} \\text{exp}\n\\]\n\nA.8 Expressions\n\nExpressions are defined as follows.\nThe SPL Language\n\nexp ::= ident(.ident)*\n | constant\n | sipHeader\n | unop exp\n | exp binop exp\n | (parallel)? forward (exp)?\n | with\n | (exp)\n | reason\n | BODY\n | requestURI\n | this\n | pop place\n | functionCall\n\nunop ::= ! -\n\nbinop ::= + | - | * | / | < | > | -= | !- | -= | >= | & & | ||\n\nconstant ::= true | false\n | integer | \"string\" | uri | sequence | response\n\nsequence ::= <constant (, constant)>\n | <>\n\nuri ::= 'uriKind:uriString'\n\nA.9 SIP Headers\n\nSIP headers defined as mandatory in at least one method according to RFC 3261 and RFC 3265 are treated as SPL keywords.\n\nsipHeader ::= CALL_ID | CONTACT | CSEQ | EVENT | FROM | MAX_FORWARDS\n | SUBSCRIPTION_STATE | TO | VIA\n\nA.10 Constant Responses\n\nResponses are defined according to RFC 3261 and RFC 3265 and are treated as SPL keywords.\n\n93\nresponse ::= /ERRORresponseError\n | /SUCCESSresponseSuccess\nresponseSuccess ::= /OK\n | /ACCEPTED\nresponseError ::= /CLIENTclientErr\n | /GLOBALglobalErr\n | /REDIRECTION redirectionErr\n | /SERVERserverErr\nredirectionErr ::= /ALTERNATIVE_SERVICE\n | /MOVED_PERMANENTLY\n | /MOVED_TEMPORARILY\n | /MULTIPLE_CHOICES\n | /USE_PROXY\nclientErr ::= /ADDRESS_INCOMPLETE\n | /AMBIGUOUS\n | /BAD_EXTENSION\n | /BUSY_HERE\n | /CALL_OR_TRANSACTION_DOES_NOT_EXIST\n | /EXTENSION_REQUIRED\n | /FORBIDDEN\n | /GONE\n | /INTERVAL_TOO_BRIEF\n | /LOOP_DETECTED\n | /METHOD_NOT_ALLOWED\n | /NOT_ACCEPTABLE_HERE\n | /NOT_ACCEPTABLE\n | /NOT_FOUND\n | /PAYMENT_REQUIRED\n | /PROXY_AUTHENTICATION_REQUIRED\n | /REQUESTURI_TOO_LONG\n | /REQUEST_ENTITY_TOO_LARGE\n | /REQUEST_PENDING\n | /REQUEST_TERMINATED\n | /REQUEST_TIMEOUT\n | /TEMPORARILY_UNAVAILABLE\n | /TOO_MANY_HOPS\n | /UNAUTHORIZED\n | /UNDECIPHERABLE\n | /UNSUPPORTED_MEDIA_TYPE\n | /UNSUPPORTED_URI_SCHEME\nserverErr ::= /BAD_GATEWAY\n | /MESSAGE_TOO_LARGE\n | /NOT_IMPLEMENTED\n | /SERVER_INTERNAL_ERROR\n | /SERVER_TIMEOUT\n | /SERVICE_UNAVAILABLE\n | /VERSION_NOT_SUPPORTED\nglobalErr ::= /BUSY_EVERYWHERE\n | /DECLINE\n | /DOES_NOT_EXIST_ANYWHERE\n | /NOT_ACCEPTABLE\nAppendix B\n\nThe Zebu Language\n\nThe syntax of the Zebu language is given in Figures B.1 to B.2 using a BNF-like notation. typewriter font is used for keywords. italic font is used for nonterminals. Parentheses are used for grouping. A superscript * denotes 0 or more occurrences of the preceding item. A superscript + denotes 1 or more occurrences of the preceding item. A superscript ? indicates that the preceding item is optional. Identifiers (ident) and various other base type terms (char-val, num-val, etc.) are left unspecified. Comments, as in ABNF, begin with ; and cannot appear within an element, but only at the end of a line.\n\nB.1 Protocol-Handling Layer Specification\n\nFigure B.1 describes the BNF syntax of a message specification. A specification begins with the keyword message, which is followed by an identifier indicating the name of the protocol considered. This identifier is then followed by one or more Zebu rule definitions (message-body).\n\nRequest/Response Blocks\n\nThe request (response) block of a Zebu specification surrounds rules and constraints specific to requests (resp. responses). The requestLine rule represents the first line of a request. The statusLine rule represents the same for a response. Header rules that appear in such a block represent headers that can appear only in either a request or response.\n\nHeader Definitions\n\nA header declaration begins with the keyword header, which is followed by an ident indicating the name of the header considered. Lines whose beginning match the rule name are thus parsed as this particular kind of header. Alternative names can be provided between braces.\n\nRegular Rule Definitions\n\nRegular rule definitions are used to represent classic ABNF rules. A rule definition consists of a rule name followed by -. An alternation of successive elements then defines the rule body.\n\nLayout Member\n\nEach grammar element can be annotated by a : followed by an identifier, making the element available in the data structure representing a message. Optionally, a type attribute can be added both to cast the parsed element to a type other than string and to set constraints on it value.\nAppendix B\n\nFigure B.1: Zebu BNF Syntax\n\nAttributes\n\nAttributes can be added to grammar rules to indicate constraints or optimisation opportunities. Currently, four attributes are supported. **ReadOnly**, **mandatory** and **multiple** can only be applied to header rules. **ReadOnly** prevents modifications of an header that is supposed to be constant throughout the processing. **mandatory** indicates that the annotated header must be present in every message. Finally, **multiple** specifies that the header can appear several times in one message. The **lazy** attribute enables incremental parsing for any rule. The parsing described by these rules is only done when requested by the application.\n\nFigure B.2: Attributes Specification\n\nB.2 Constraints\n\nA Zebu programmer can add various structural constraints, based on the natural language text, alongside the original ABNF protocol specification. Two kinds of constraints exist: value constraints and presence constraints. A **value constraint** express value dependencies; the value of an element is constrained by the value of another element. A **presence constraint** expresss presence dependencies; a header can become mandatory according to the presence or the value of some other message elements.\nThe Zebu Language\n\n| constraint | ::= valueConstraint |\n| | | presenceConstraint |\n| valueConstraint | ::= elementId op rhs |\n| presenceConstraint | ::= headerName mandatory when elementId op rhs |\n| rhs | ::= elementId |\n| | | char-val | num-val | bin-val |\n| | | dec-val | hex-val | prose-val |\n| elementId | ::= ident( , ident)* |\n| op | ::= = | != | > | < |\n\nFigure B.3: Constraints Specification\nAppendix C\n\nThe z2z Language\n\nThe z2z language provides three kinds of modules: protocol specification modules for defining the characteristics of protocols, message specification modules for describing the structure of protocol messages, and a message translation module for defining how to translate messages between protocols. We now present the concrete syntax of these modules in more detail using a BNF-like notation. Typewriter font is used for keywords. Italic font is used for non-terminals. Parentheses are used for grouping. A superscript * denotes 0 or more occurrences of the preceding item. A superscript + denotes 1 or more occurrences of the preceding item. A superscript ? indicates that the preceding item is optional. Identifiers (ident) and various other base type terms (char-val, num-val, etc.) are left unspecified.\n\nC.1 Protocol specification module\n\nThe protocol specification (PS) module defines the properties of a protocol that a gateway should use when sending or receiving requests or responses. A PS module begins with the protocol keyword, which is followed by an identifier indicating the name of the protocol considered. This identifier is then followed by one or more declarations and block rule definitions. The grammar for the PS module is as follows, where a statement statement_baseMT refers to a statement from the MT module, as defined in Section C.3.2.\n\n\\[\n\\begin{align*}\n\\text{protocol} &::= \\text{extern_fun}_{\\text{MT}^*} \\text{ protocol ident} \\{ \\text{decl}^* \\text{ block}^* \\} \\\\\n\\text{decl} &::= \\text{fftype ident} ; \\\\\n\\text{fftype} &::= \\text{int} \\mid \\text{fragment} \\mid \\text{fftype list} \\\\\n\\text{block} &::= \\text{start} \\{ \\text{statement}_{\\text{baseMT}^+} \\} \\\\\n& \\quad \\mid \\text{request ident} \\{ (\\text{msgtypedef };)^* \\} \\\\\n& \\quad \\mid \\text{response} \\{ (\\text{response_msg};)^* \\} \\\\\n& \\quad \\mid \\text{flow} = \\{ \\text{ident} (, \\text{ident })^* \\} \\\\\n& \\quad \\mid \\text{session_flow} = \\{ \\text{ident} (, \\text{ident })^* \\} \\\\\n& \\quad \\mid \\text{sending request ident} \\{ \\text{statement}_{\\text{baseMT}^+} \\} \\\\\n& \\quad \\mid \\text{sending response ident} \\{ \\text{request ident} \\} \\{ \\text{statement}_{\\text{baseMT}^+} \\} \\\\\n& \\quad \\mid \\text{attributes} \\{ (\\text{attribute };)^* \\} \\\\\n& \\quad \\mid \\text{tcp} \\{ \\text{tcp_prototype} \\} \\\\\n& \\quad \\mid \\text{automata} \\text{ side} \\{ \\text{automaton}^+ \\} \\\\\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\ntcp\\text{-prototype} &::= \\text{rtype tcp_connect} () ;\n\\end{align*}\n\\]\n\nC.1.1 Attribute block\n\nThe attributes block indicates the type of interaction with the network, in terms of the transport protocol used, whether requests are sent by unicast or by multicast, and whether responses are received synchronously or asynchronously.\nAppendix C\n\nattribute ::= transport = proto / integer\n| mode = mode\n| mode = mode / (multicast | unicast)\n| group = ipv4address\nproto ::= udp | tcp | tcp alive\nmode ::= sync | async\n\nC.1.2 Requests and responses\n\nThe request block declares how to map messages to handlers. Similarly, the response block defines classes of\nresponses. The expression expressionMT refers to an expression from the MT module, as defined in Section C.3.3.\n\nmsgtypedef ::= rtype ident when expressionMT\nresponse_msg ::= ident\n| ident = ident (| ident)*\nrtype ::= void | response\n\nC.1.3 Automata\n\nThe automata block defines the state machines of a client (sending request) and a server (receiving requests) according\nto the protocol.\n\nautomaton ::= automaton ident { (transition ; )+ }\nside ::= client | server\ntransition ::= lstate : ? ident (| ? ident)* -> state\n| lstate : ! ident (| ! ident)* -> state\n| lstate : epsilon -> state\n| lstate\nlstate ::= ident\n| start ident\n| final ident\nstate ::= ident | ident . ident\n\nC.2 Message specification module\n\nThe message specification (MS) module contains a description of the messages that can be received and created by\na gateway. A message specification module provides a message view describing the relevant elements of incoming\nmessages and templates for creating new messages.\n\nmsg ::= message ident { message_view template+ }\n\nC.2.1 Message view\n\nA message view describes the information derived from received messages that is useful to the gateway.\n\nmessage_view ::= read { message_place* }\nmessage_place ::= qualifier visibility ty ident ;\nqualifier ::= mandatory | optional\nvisibility ::= public | private\nty ::= int | int8 | int16 | fragment | ty list\nC.2.2 Templates\n\nA template describes the information needed to create new messages. A template has three parts: the structural declarations, the template view, and the template text.\n\n\\[\n\\text{template} ::= \\text{request binary? template reqty ident implements template_def} \\\\\n| \\text{binary? template ident implements template_def} \\\\\n| \\text{response binary? template ident implements template_def} \\\\\n| \\text{message binary? template ident implements template_def}\n\\]\n\n\\[\n\\text{implements} ::= (\\text{implements ident})\n\\]\n\n\\[\n\\text{reqty} ::= \\text{void} | \\text{response}\n\\]\n\n\\[\n\\text{template_def} ::= \\{ \\text{attribute* template_place*} \\}\n\\]\n\n\\[\n\\text{attribute} ::= \\text{magic = string ;} \\\\\n| \\text{newline = \\n | \\r | \\r\\n ;}\n\\]\n\n\\[\n\\text{template_place} ::= \\text{visibility ty ident} \\\\\n| \\text{visibility ty ident = (string | integer)}\n\\]\n\nC.3 Message translation module\n\nThe message translation (MT) module expresses the message translation logic of the gateway. This module consists of a set of handlers, one for each kind of relevant incoming request, as indicated by the protocol specification module.\n\n\\[\n\\text{program} ::= \\text{top_decl* mthd*}\n\\]\n\n\\[\n\\text{top_decl} ::= \\text{extern_fun} \\\\\n| \\text{decl}\n\\]\n\n\\[\n\\text{mthd} ::= \\text{rtype ident ( ident_reqty request ident ) \\{ decl* statement* \\}} \\\\\n| (\\text{void} | \\text{response}) \\text{ident_source\\_tcp\\_connect ( ) \\{ decl* statement* \\}} \\\\\n| \\text{void ident_source\\_tcp\\_close ( ) \\{ decl* statement* \\}}\n\\]\n\n\\[\n\\text{rtype} ::= \\text{void} \\\\\n| \\text{idensource response}\n\\]\n\n\\[\n\\text{extern_fun} ::= \\text{extern (int | void)? ident ( funty (, funty)* )? ;}\n\\]\n\n\\[\n\\text{funtty} ::= \\text{int | char * | ...}\n\\]\n\nC.3.1 Declarations\n\nA variable may be local to a handler, or may be declared outside of any handler if it it associated with a session. In the remainder of this section, \\text{idensource} refers to the name of the source protocol, \\text{identarget} to the name of one of the target protocol, \\text{identprotocol} to any other protocol name, and \\text{identfunction} to the name of a function.\n\n\\[\n\\text{decl} ::= ty \\text{decl_ident (, decl_ident)* ;}\n\\]\n\n\\[\n\\text{decl_ident} ::= \\text{ident (= expression)}\n\\]\n\n\\[\n\\text{ty} ::= \\text{ftype | bool} \\\\\n| \\text{idensource response | identtarget response} \\\\\n| \\text{identrequest} \\\\\n| \\text{identprotocol message}\n\\]\n\n\\[\n\\text{ftype} ::= \\text{int | fragment | eftype list}\n\\]\n\n\\[\n\\text{eftype} ::= \\text{int | fragment | identprotocol message} \\\\\n| \\text{eftype list}\n\\]\n\nC.3.2 Statements\n\nThe grammar of statements is as follows:\nAppendix C\n\nstatement ::= statement_base\n | ident = send ( nident ) ;\n | send ( nident ) ;\n | return ;\n | return nident ;\n | pretoken nident ;\n | session_start ( ) ;\n | session_end ( ) ;\n | rearm ;\n | ident = IDENT_TCP_CONNECT ( ) ;\n | IDENT_TCP_CONNECT ( ) ;\n | IDENT_TCP_CLOSE ( ) ;\n | foreach ( ftype ident = ident ) statement\n | break ;\n | ident TARGET_tcp_connect ( expression , expression ) ;\n\nstatement_base ::= ident = expression ;\n | ident , ident = expression ;\n | if ( expression ) statement ( else statement )\n | { statement }?\n | ident function ( ( expression ( , expression )∗ ) )\n\nnident ::= ident\n | ident , ident ( keyword_args )\n | ident ( keyword_args )\n\nnaexpression ::= expression\n | ident , ident ( keyword_args )\n | ident ( keyword_args )\n\ntoken ::= string\n | true | false\n | integer\n | ident | ident , ident\n | expression binop expression\n | ( expression )\n | ! expression\n | cons ( expression , ident )\n | head ( ident )\n | tail ( ident )\n | null ( ident )\n | empty ( ident , ident )\n | ident function ( ( expression ( , expression )∗ ) )\n | IDENT_TCP_CONNECT ( )\n | IDENT_TCP_CLOSE ( expression )\n\nbinop ::= == | != | >= | <= | > | >= | + | - | & & | ||"}}},{"rowIdx":183,"cells":{"id":{"kind":"string","value":"834f15f63b2a6b3d138e975f50bc85cd96f615eb"},"text":{"kind":"string","value":"Notice\n\nHewlett-Packard makes no warranty of any kind with regard to this material, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. Hewlett-Packard shall not be liable for errors contained herein or for incidental or consequential damages in connection with the furnishing, performance, or use of this material.\n\nHewlett-Packard assumes no responsibility for the use or reliability of its software on equipment that is not furnished by Hewlett-Packard.\n\n© Copyright 1990, Hewlett-Packard Company.\n\nThis document contains proprietary information, which is protected by copyright. All rights are reserved. No part of this document may be photocopied, reproduced or translated to another language without the prior written consent of Hewlett-Packard Company. The information contained in this document is subject to change without notice.\n\nUNIX is a registered trademark of AT&T in the U.S.A. and in other countries.\n\nTorx is a registered trademark of Camcar Division of Textron, Inc.\n\nHewlett-Packard Company\nLogic Systems Division\n8245 North Union Boulevard\nColorado Springs, CO 80920, U.S.A.\n\nRESTRICTED RIGHTS LEGEND Use, duplication, or disclosure by the U.S. Government is subject to restrictions set forth in subparagraph (C) (1) (ii) of the Rights in Technical Data and Computer Software Clause at DFARS 252.227-7013. Hewlett-Packard Company, 3000 Hanover Street, Palo Alto, CA 94304\nPrinting History\n\nNew editions are complete revisions of the manual. The date on the title page changes only when a new edition is published.\n\nEdition 1 64000-97000, November 1990\nUsing This Manual\n\nThis manual discusses concepts associated with emulation and analysis. Separate chapters are devoted to discussions of emulation monitors and the process of mapping memory.\n\nThis manual will be useful to a designer who has been using an emulator and/or analyzer and would like a greater understanding of these tools. This manual will also be useful to the person who is new to emulation and analysis and would like to gain a quick perspective on these tools.\nNotes\n## Contents\n\n1 **Introduction To Emulation**\n - What Is An Emulator? ........................................... 1-1\n - What Is The Purpose Of An Emulator? ...................... 1-4\n - Can An Emulator Help Me Before My Target System Is Ready To Run? ............................................... 1-5\n - Physical Description Of An Emulator ...................... 1-5\n - What Are The Steps In Using An Emulator? .............. 1-6\n - What Tasks Are Done By An Emulator? .................... 1-7\n - What Is Happening While My Program Is Running In Emulation? ................................................. 1-9\n - While Execution Is In The Target Program .......... 1-9\n - While Execution Is In The Monitor Program ........ 1-10\n - How Does An Emulator Affect My Program? .............. 1-11\n - Real-Time Mode ............................................ 1-11\n - Non-Real-Time Mode ...................................... 1-11\n - How Does An Emulator Affect My Target System? .... 1-12\n - Can An Emulator Run Interactively With Other Emulation/Analysis Systems, And With External Analyzers? 1-13\n\n2 **Comparing In-Circuit And Out-Of-Circuit Emulation**\n - Out-Of-Circuit Emulation .................................. 2-1\n - Things You Can Do Using Out-Of-Circuit Emulation .... 2-2\n - In-Circuit Emulation ......................................... 2-3\n - Things You Can Do In-Circuit That You Can't Do Out-Of-Circuit ..................................................... 2-4\n\n3 **The Emulation Monitor**\n - What Is A Monitor? ........................................... 3-1\n - What Does A Monitor Do? ................................... 3-2\n - The Break Function Of The Emulation Monitor ........ 3-3\n - Where Is The Monitor? ....................................... 3-3\n - Background Monitors ...................................... 3-4\n - Advantages Of Background Monitors ................. 3-4\n - Disadvantages Of Background Monitors ............ 3-4\n4 The Emulation Configuration\n\nWhat Is An Emulation Configuration File? ................. 4-1\nModifying The Emulation Configuration File ............. 4-2\nView The Configuration File And Its Present Answers ... 4-3\nThe Configuration File To Use When Starting Your Target System ........................................ 4-3\n\n5 Memory Mapping\n\nHow The Two Maps Depend On Each Other .............. 5-3\nWhat Do You Do When You Map Memory .................. 5-3\nExample Emulation Memory Map ......................... 5-3\nManaging The Emulation Memory Hardware .............. 5-4\nEmulation Memory Architecture .......................... 5-4\nExample Linker Load Map ................................ 5-6\nSpecial Considerations For The Emulation Memory Map .. 5-7\nSelecting The Best Memory Hardware To Use .......... 5-7\nDividing Memory Into Blocks ............................. 5-7\nThree Kinds Of Memory In The Emulation Memory Map ........................................... 5-8\nMapping A Foreground Monitor ............................ 5-10\nDeleting Map Entries ..................................... 5-10\nOverlay ...................................................... 5-10\nAdditional Characterizations Available In Some Emulators 5-11\nProblem When Specifying Certain Address Ranges .... 5-11\n\n6 Command Files\n\nWhat Is A Command File? ................................. 6-2\nHow Are Command Files Useful? ......................... 6-2\nMethods Used To Create Command Files ................. 6-4\nAutomatic Creation Of A Command File While You Use The Emulator/Analyzer .......................... 6-4\nThings To Correct During The Edit ...................... 6-4\nLogging To Enlarge An Existing Command file .......... 6-5\nLogging Calls To Other Command Files ................ 6-5\nLogging Commands That Spawn New Processes ........ 6-5\nUsing An Editor To Create Command Files ................ 6-5\nEditing An Existing Command File ....................... 6-6\nHow To Execute A Command File ......................... 6-7\nExecuting A Command File Alone ......................... 6-7\nUsing A Script And Command File Together ............ 6-7\n\nContents-3\n9 How An On-Chip Cache Affects An Analyzer\n How Does A Cache Affect Analysis? ............... 9-1\n Disabling And Enabling The Cache .................. 9-2\n\n10 Prestore Trace Measurements\n How Is A Prestore Trace Useful? .................... 10-3\n Setting Up The Analyzer To Make A Prestore Trace .. 10-3\n Store Qualification ................................ 10-3\n Prestore Qualification ............................... 10-4\n Reading Prestore Trace Lists ....................... 10-4\n\n11 Tracing Processors That Prefetch Instructions And Use An\n Instruction Pipeline\n What Is Meant By Prefetching And Pipeline? ........ 11-1\n Reading Prefetch/Pipeline Trace Lists ............. 11-2\n Unused Prefetches .................................. 11-4\n How To Avoid Triggering, Enabling, Or Disabling On Unused\n Prefetches ........................................... 11-5\n\n12 What To Do If Your Emulator Doesn't Work\n Debugging The Connection To The Target System .... 12-1\n Hardware Problems .................................. 12-1\n Electrical Problems .................................. 12-2\n Architectural Problems ............................... 12-2\n Make Sure The Emulation Configuration Is Correct .. 12-3\n Use The Emulation Bus Analyzer ...................... 12-3\n Use Status Messages .................................. 12-4\n Run Performance Verification (PV) .................... 12-4\n If All Else Fails .................................... 12-5\n\nGlossary\n\nIndex\nIllustrations\n\nFigure 1-1. Developing Software On An Editor . . . . . . 1-2\nFigure 1-2. Creating Absolute Files . . . . . . . . . . 1-3\nFigure 1-3. Running In Emulation . . . . . . . . . . 1-3\n\nFigure 2-1. Out-Of-Circuit Emulation . . . . . . . . . . 2-2\nFigure 2-2. In-Circuit Emulation . . . . . . . . . . . . 2-3\n\nFigure 3-1. Typical Processor Exception Vector\nTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-10\nFigure 3-2. Emulation Monitor, Typical Block\nDiagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-15\n\nFigure 5-1. Simplified Emulation Memory Map . . . . . 5-3\nFigure 5-2. Emulation Memory Architecture . . . . . . . 5-5\nFigure 5-3. Simplified Linker Memory Map Content . . . 5-6\n\nFigure 10-1. Making The Prestore Trace\nMeasurement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10-1\nFigure 10-2. Making A Prestore Trace List . . . . . . . . 10-2\n\nFigure 11-1. Pipeline Diagram Of The 68020 . . . . . . . 11-2\nFigure 11-2. Trace List Showing Pipeline And\nPrefetch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11-3\nIntroduction To Emulation\n\nThis chapter answers the following questions:\n\n- What is an emulator?\n- What is the purpose of an emulator?\n- Can an emulator help me before my target system is ready to run?\n- Physical description of an emulator.\n- What are the steps in using an emulator?\n- What tasks are done by an emulator?\n- What is happening while my program is running in emulation?\n- How does the emulator affect my program?\n- How does the emulator affect my target system?\n- Can an emulator run interactively with other emulation/analysis systems, and with external analyzers?\n\n**What Is An Emulator?**\n\nAn emulator is part of an environment in which hardware and software are developed and integrated to create products that depend on embedded microprocessors. To understand an emulator, you need to understand the microprocessor development...\nenvironment (also called development system). Then you will understand how an emulator fits into a development system. A development system will have a workstation (a terminal in a network, or a personal computer).\n\nA development system has an editor (figure 1). An editor is a software module that allows you to create and modify files by typing them on the keyboard of your workstation. You use the editor to create the text files (also called source files) of program code you intend to run in your target system (the product you are developing).\n\nA development system has a compiler and/or assembler and a linker (figure 2). These are software modules that read source files and create corresponding files of machine code that can be executed by target-system hardware. You use these modules to generate the object files that perform the tasks implemented in the text files you created in your editor.\n\nThese object files contain your actual binary code which directly controls your target microprocessor. However, it isn't until the linker module creates an absolute file from the object file, that the file can be loaded into the emulation and/or target-system memory.\nFinally, you have an emulator (figure 3). An emulator is the interface between your workstation and the product you are developing (called the target system). An emulator provides the mechanism that loads the executable (or absolute) file you created into the target system. An emulator is the linkage that allows you to run and stop program execution in your target system. An emulator lets you view (on your workstation display) the changing conditions within the target-system microprocessor as each of the instructions in your program is executed.\n\nAn emulator is connected to a target system by removing the microprocessor from the target system and plugging in the emulator probe cable in its place. Differences between the\nemulator and the target microprocessor are usually transparent to the target system.\n\nYou control what the emulator does by entering commands on your keyboard. The emulator has all the capabilities of the target system processor, and a lot more. An emulator can load the absolute files into hardware memory in your target system. If your target system does not have the hardware memory needed to contain your program, your emulator can provide memory hardware; your target processor can address code in emulation memory and execute it as easily as if it were in the target system.\n\nYour emulator gives you control over the running of your absolute files in the target system microprocessor. You can start execution at any instruction address you desire in your program.\n\nYour emulator can show you how your target system processes your code. Your emulator can show you how your code affects registers and other components in your target processor. If your emulator has an internal analyzer associated with it, the analyzer can record the series of states that were executed so you can see the details of how your target system processed the program you wrote. In this way, your emulator helps you understand the results of running your target program in your target system.\n\n---\n\n**What Is The Purpose Of An Emulator?**\n\nThe purpose of an emulator is to help you develop and integrate target system hardware and software. You can use an emulator to ensure that your target system hardware and software work together. The emulator can be used by itself, or it can be used with other test equipment (other emulators, analyzers, debuggers) to debug and integrate your target system hardware and software. In order to meet its purpose, the emulator must have excellent transparency, that is, it must look like the target microprocessor from the point of view of your target system hardware. Refer to the glossary in this manual for details of characteristics that are considered when designing for transparency.\nCan An Emulator Help Me Before My Target System Is Ready To Run?\n\nYes it can. You can run your emulator even though it’s not connected to a target system. An emulator can make a lot of hardware available to substitute for your target system hardware. An emulator has memory (called emulation memory) that you can load your absolute files into before your target system memory is available. You can run your program from emulation memory just as if the program was loaded into target system memory.\n\nMany emulators can supply other hardware to substitute for hardware that is not yet available in your target system. The keyboard of your workstation may be used as a substitute for a keyboard you intend to include in your target system. The display of your workstation may substitute for a display you intend to have in your target system. Other equipment (printers, etc) can often be simulated by your emulator so that you can test code you are developing to communicate with the other equipment even before the target system printers, etc., are available.\n\nPhysical Description Of An Emulator\n\nA typical emulator will include:\n\n- An emulation probe. The probe replaces the processor in your target system. The probe plugs into your target system microprocessor socket. Remove the microprocessor from your target system and plug in the emulation probe in its place. To your target system, the emulation probe appears to be the processor you just removed. For details, refer to the discussion of transparency in the glossary of this manual.\n\n- An emulation probe cable. This cable carries control signals and processor information back and forth between the emulation probe and the emulator control and memory hardware.\nThe emulator control and memory hardware. This circuitry controls operation of the processor, and provides emulation memory in which you can store part or all of your absolute file.\n\nAn emulation bus analyzer (also called internal analyzer). This analyzer is usually installed in the same frame with the emulator control and memory hardware. The analyzer stores a record of the details of state executions in the emulator and target system. Your workstation can display a trace list of these state executions (or inverse-assemble them into opcodes and operands to show you the instructions that were executed) so you can see how the target system processed each instruction in your absolute file.\n\nWhat Are The Steps In Using An Emulator?\n\nThere are three steps in the emulation process.\n\n1. Prepare The Software\n\n Create your program. Assemble or compile the program and link the assembled or compiled modules. This obtains an absolute file that performs the tasks in the program you created, but in a form that can be executed by your target microprocessor. These are the steps shown in figures 1-1 and 1-2.\n\n2. Prepare The Emulator\n\n Install your emulator hardware (emulator control board, emulation memory, analyzer, etc). Then connect your emulator probe to the target system. This connection is optional; it depends on whether or not you need to perform tests in target-system hardware. (Refer to the discussion of in-circuit/out-of-circuit emulation in a separate chapter in this manual). Finally, on your workstation, answer a series of questions that define the details of the configuration of your emulator; invoke this\nA series of questions using a keyboard command (such as \"modify configuration\").\n\n3. Run Your Target Software Using The Emulator\n\nUse the emulator to load your absolute file into memory hardware. Then use the features of the emulator to execute your absolute code and see how your program runs in your target processor. While using the emulator, you can display the contents of the registers and/or memory to help you debug your hardware and software. This is shown in figure 1-3.\n\n<table>\n<thead>\n<tr>\n<th>What Tasks Are Done By An Emulator?</th>\n<th>The following paragraphs describe tasks that are normally performed by an emulator under control of the emulator user.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>• Program Loading. An emulator can load emulation memory or target system memory with the absolute file you developed using an editor, compiler, assembler, and linker.</td>\n<td></td>\n</tr>\n<tr>\n<td>• Run/Stop Controls. An emulator can run your programs, starting from any address in memory. A program running in your target system can be stopped by the emulator at any point you select, and then resumed again at the point where it was stopped. Execution can also be stopped by resetting the microprocessor.</td>\n<td></td>\n</tr>\n<tr>\n<td>• Reset Support. The emulator can be reset from the emulation system under your control; or your target system can reset the emulation processor.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nIntroduction To Emulation 1-7\n- Memory Display/Modification. An emulator can display the code contained at addresses in target system memory or emulation memory. You can use an emulator to modify the code present at these memory addresses, if desired.\n\n- Global and Local Symbols Display. An emulator can show you the names of all the global and local symbols you defined in your program, along with the memory addresses where code associated with those symbols is located.\n\n- Internal Resource Display/Modification. An emulator can display the present values in the internal resources of the emulation processor, such as registers, and modify those values, if desired. This includes modifying the program counter so you can control where the emulator starts a program run. An emulator can also display or modify the contents of a memory-management unit (MMU register), if your target processor includes memory management.\n\n- Analysis (in some systems, analyzer boards are optional). An analyzer can record the states that appeared on the emulation processor bus. The analyzer can show you a list of those states as a trace list of instructions and data flow.\n\n- Program Stepping. An emulator can execute your program one instruction at a time (or a selected number of instructions at a time). After each execution, the emulator will stop so you can see how the internal machine states changed.\n\n- Memory Mapping. An emulator can place your absolute code in emulation memory or in target system memory, or it can place portions of your code in each memory.\n\n- Memory Characterization. An emulator can cause emulation memory to behave as ROM or RAM (even though all emulation memory is RAM). This allows you to test code that will eventually reside in ROM without having to use ROM hardware.\nBreakpoint Generation. Breakpoints are temporary instruction codes that you can have an emulator place in your program code to halt execution or perform desired tasks after a particular event occurs. You can use your emulator to set breakpoints that are recognized on the occurrence of a selected machine state or on the occurrence of any state within a range of states. Breakpoints cause the emulator to halt program execution when the program reads from or writes to a memory location, or after the program executes an instruction at a specified memory location.\n\nClock Source Selection. An emulator generates an internal clock that you can use for program execution before your target-system clock is available. You may need to include wait states in your program code if the clock is too fast for some of the hardware in your target system, such as memory or I/O ports.\n\nModify I/O Ports. An emulator can read from and write to external devices.\n\n---\n\n**What Is Happening While My Program Is Running In Emulation?**\n\nThe emulator performs different tasks, depending on whether it is executing your target program, or it is executing its monitor program. (A monitor program is the set of software routines that provide the features of the emulator, such as read/write target memory, display/modify registers, and control execution of the target program. Monitor concepts are discussed in a separate chapter in this manual.)\n\n**While Execution Is In The Target Program**\n\nDuring execution of your target program, the emulation processor (acting as the target processor) generates an address for each bus cycle. If the generated address is mapped to target system memory, the emulator enables the data path buffers between the emulation processor and your target system. If the generated address is mapped to emulation memory, the emulator enables the data path...\nbuffers between the emulation processor and the emulation bus. This way, the emulator makes sure that each address generated by the emulation processor arrives at the appropriate memory hardware.\n\nAs your program runs, the analyzer records the activity on the emulation bus. Activity of the emulation processor is always available to the emulation bus analyzer, regardless of whether an address is located in the target system or in emulation memory. If you set up the analyzer to store state flow, your terminal can display a list of the states in the order that they appeared on the bus.\n\nMany emulator functions are done by breaking (transferring execution to the routines in the emulation monitor). One monitor routine stores the values of the emulation processor registers. These values can be reloaded later if you want to resume execution of your target program at the point where the break occurred.\n\nIn the monitor, the emulation processor executes a tight loop while it waits for a command from you. You can display the register values that were saved at the time when the \"break\" occurred, display the present content of code in emulation memory or target-system memory, load new program code, single-step through the target program instructions, or perform a variety of other tasks, depending on the capabilities of the routines that make up the monitor. When you have finished making the tests and measurements that are provided by monitor routines, you can exit the monitor and resume execution of your target program, if desired.\nHow Does An Emulator Affect My Program?\n\nAn emulator does not alter your program, but the operating mode of the emulator may affect the way your program runs. There are two operating modes of an emulator: real-time mode, and non-real-time mode.\n\nReal-Time Mode\n\nIn real-time mode, the emulator runs your program without interfering with its execution. Real-time mode is the mode to use if you have circuitry that can be damaged by an inadvertent break during execution of your target code. The only way to break execution when in real-time mode is for you to enter a BREAK command on the command line and press the RETURN key.\n\nWhenever the emulator is executing any routine in the monitor program, it is not executing in real-time mode. The following is a list of features that cannot be performed when the emulator is in real-time mode because these require execution of one or more routines in the monitor program. Depending on which emulator you are using, there may be additional features that cannot be performed when the emulator is in real-time mode:\n\n- Target memory accesses -- display, copy, load, modify, and store.\n- Register accesses -- display, copy, and modify.\n- Software breakpoints -- set and reset.\n\nThe features above can be accessed even if the emulator is configured for real-time mode if you first issue a BREAK command. In the case of a software breakpoint, you can set a breakpoint and then run your program in real-time mode. When the software breakpoint instruction is executed, the monitor will be entered. Of course, your mode will no longer be real-time when this happens.\n\nNon-Real-Time Mode\n\nIn non-real-time mode, the emulator can break program execution and begin executing a monitor routine in response to a variety of internal program conditions (such as an attempted write to ROM), as well as a BREAK command from you. The non-real-time mode\nHow Does An Emulator Affect My Target System?\n\nWhen an emulator is designed, every effort is made to make the emulator transparent to the target system. Even so, an emulator is not the processor it replaces. It will usually have some parameters that are different from those of the target processor. The following is a series of items you should consider when using an emulator in place of your target-system microprocessor.\n\nConsider mechanical accessibility of the target processor. It may be necessary to place the circuit board containing the microprocessor on an extender board to gain access to the processor connection. Some circuits may not work properly if the circuit board is extended from its motherboard connection.\n\nConsider interference with nearby components. Other components close to the processor may interfere with installation of the emulator probe cable. With older processors, you could install extender sockets between the processor socket and the emulator to overcome this problem, but with today's clock speeds, extender sockets may cause unreliable operation due to their effects on impedance or crosstalk.\n\nConsider the processor timing specifications. It's important that your target system avoids violating any of the timing specifications of the microprocessor that will be emulated. Even if the microprocessor will work in circuits that violate some of its timing specifications, the emulator may become erratic or not be able to work at all because of these timing violations.\n\nConsider delays. Some processor cycles, such as memory accesses may not have the full memory access timing cycle available when the emulator is connected. This is because of signal delays caused by the emulation probe cable and the buffers for the cable drivers/receivers. In these cases, you might replace your standard memory hardware with faster hardware in your prototype design.\nConsider power and ground circuits. If your target-system prototype is a wire-wrapped design with little or no power and ground facilities, it may not work well with an emulator. This is because emulators use high-current drivers to maintain the integrity of the signals in the emulation probe cable. The high currents can cause voltage pulses to develop in unpredictable points in such a wire-wrapped circuit. These voltage pulses may exceed the thresholds of some of your target-system components.\n\nConsider circuitry that needs to be refreshed. If your target system includes a watch-dog timer that must be updated periodically, you may need to disable it in order to prevent it from shutting down your target system when the emulator is executing routines in a background monitor.\n\n---\n\n**Can An Emulator Run Interactively With Other Emulation/Analysis Systems, And With External Analyzers?**\n\nBy using intermodule connections to connect control board assemblies together, emulation and analysis hardware can interact with other emulators and/or analyzers. Interaction allows you to develop systems that use two or more microprocessors together or that need more analyzer channels than are available in a single analyzer. Things you can do by using interaction include:\n\n- Starting two or more measurements at the same time.\n\n- Using conditions found by one analyzer to control measurements taken by another analyzer.\n\n- Starting execution of a program when a measurement starts.\n1-14 Introduction To Emulation\nComparing In-Circuit And Out-Of-Circuit Emulation\n\nEmulators can be used for both out-of-circuit emulation and in-circuit emulation. Simply stated, in-circuit emulation is when you have your emulator connected into your target system, and you are using the emulator to run your target code in your target hardware. Out-of-circuit emulation is when you have your emulation probe disconnected from any target hardware. Using out-of-circuit emulation, you run your target code on the emulation processor, storing it in emulation memory, and using the facilities of your emulation system to substitute for the hardware of your target system.\n\nOut-Of-Circuit Emulation\n\nFigure 2-1 shows an emulator used to perform out-of-circuit emulation. Normally, out-of-circuit emulation is used to develop software before the target-system hardware is available. The out-of-circuit emulator allows you to run your code on your target processor; the emulator contains the target processor (also called the emulation processor). When you have written a program, you can store it in emulation memory, and the emulation processor can fetch its instructions and write its data to locations in emulation memory.\nThings You Can Do Using Out-Of-Circuit Emulation\n\nThe most obvious thing you can do is start developing and testing your code before the target system hardware exists. The following paragraphs list some emulator features that allow you to do this code development.\n\nThe emulator has memory. You can use it to store your code before there is any target memory available.\n\nMany emulators have simulated I/O. It can simulate the behavior of keyboards, displays, printers, etc. With simulated I/O, you can test the code that the processor will execute when it services these I/O devices, even before you have the I/O devices available.\n\nFigure 2-1. Out-Of-Circuit Emulation\nIn-Circuit Emulation\n\nFigure 2-2 shows an emulator being used to perform in-circuit emulation. Using in-circuit emulation, you can develop and test your target system hardware. You can also test your code in the actual environment where you intend for your code to run.\n\nYour target system operates as though its normal microprocessor is installed, but the emulator gives you control over that processor so you can control program execution.\n\nWith in-circuit emulation, you can load the program you have created into address space that exists on your target system. If your target system is not yet complete, you can load part of your program code in target system memory, and the rest of your code in emulation memory (where emulation memory simply provides space that will ultimately reside in your target system).\n\nFigure 2-2. In-Circuit Emulation\nThings You Can Do In-Circuit That You Can’t Do Out-Of-Circuit\n\nWhen you have target system hardware available and connect your emulation probe into it, you can load your target program into your target-system memory and test the behavior of your target hardware when it tries to execute the instructions.\n\nYou can use the \"display/modify memory\" features of the emulator to send patterns to addresses in your target hardware and then read the contents of those addresses. In this way, the emulator can help you determine that your target system components are wired correctly.\n\nYou can also eliminate the differences that may exist between the behavior of your target devices and the emulation system that simulated those devices.\n\n- There may be differences in the response of emulation memory compared with the response of your target memory hardware.\n\n- There may be differences between the way your I/O devices operate and the way the emulator simulated those I/O devices.\n\n- There may be differences in the way your interrupting devices operate and the way you might have simulated an interrupt while operating out-of-circuit.\n\nAs soon as your target hardware is available, you will probably want to develop your product using in-circuit emulation.\nThe Emulation Monitor\n\nWhat Is A Monitor? A monitor is a group of software routines that provide the features of the emulator. The following is a list of features that are normally provided by routines in the monitor:\n\n- Read/write target memory.\n- Display/modify registers or flags in the emulation processor.\n- Display/modify contents of memory.\n- Control execution of the target program.\n- Execute a target program to a predetermined point, and then halt. (This is useful when you want to begin a test at a point deep within the target program.)\n- Break from target program (see The Break Function Of The Emulation Monitor later in this chapter).\n- Reset into monitor.\n- Single step (execute one program instruction each time a \"step\" key is pressed).\nWhat Does A Monitor Do?\n\nMany emulator functions are achieved by transferring control from your target program to one of the routines in the emulation monitor. Whenever the monitor program is entered, it saves the values of the emulation processor registers. You can immediately display and examine the register information (the values of the emulation processor registers immediately before entry into the monitor).\n\nThe monitor routines perform the emulator functions you request, such as displaying target system memory. When you display target system memory, the monitor program executes instructions in the emulation processor to read target memory locations and return their contents to the emulator.\n\nCaution\n\nDAMAGE TO TARGET SYSTEM HARDWARE. When the emulator detects an illegal condition, such as when the emulation processor tries to write to guarded memory, or when you request a memory access that uses a monitor routine (such as \"display memory\"), the emulator stops executing your target code and begins executing code in the monitor. Be careful if you have circuitry that may be damaged if the emulator stops executing your target code at a critical point. You may need to restrict the emulator to real-time mode to prevent it from transferring control (breaking) to the emulation monitor. In real-time mode, you can only break to the monitor by entering the \"break\" command and pressing the Return key.\nThe Break Function Of The Emulation Monitor\n\nThe most common method used to transfer control (break) to the monitor program is by assertion of the microprocessor’s non-maskable interrupt pin. However, other techniques may be used, depending on the architecture of the target microprocessor. When a break condition is detected, the emulator asserts the non-maskable interrupt of the emulation processor to stop execution of the target program and begin execution in the emulation monitor. The following conditions can cause a break to be generated:\n\n- An illegal memory reference (such as an attempt to read guarded memory space).\n- A bus condition that the internal analyzer detects (such as a bus error).\n- A request by the target software (such as a software breakpoint).\n- Typing \"break\" from the keyboard, and pressing RETURN.\n\nWhere Is The Monitor?\n\nThe monitor may be located in background or foreground memory space, or both background and foreground. Background memory is memory that is separate (and isolated) from the memory addressed when running the target program; you may have an instruction beginning at address 1000H in foreground memory and an unrelated instruction at address 1000H in background memory. Foreground memory is the memory space directly addressable by the target processor; it is the address space that is shared by the target program, I/O ports, etc., of the target system. Most emulators place the monitor in either background or foreground memory space. Some emulators place part of the monitor in background and the rest in foreground. Background and foreground monitors are discussed in the following paragraphs.\nBackground Monitors\n\nIf the monitor is in background, it operates in a memory space that is not directly accessible to your target system. This memory space is called \"background\" memory, from which the name \"background monitor\" is derived. The emulation system controls processor access to the background memory.\n\nAdvantages Of Background Monitors\n\nBackground monitors have two main advantages:\n\n1. A background monitor is easy to use. It is available at power up. You don't have to spend any time learning how the monitor routines work. Emulators equipped with background monitors are easier to use than those with foreground monitors when testing and debugging hardware at the early stages of a design project, before target-system code is written, or before all of the target system memory space is defined or operational.\n\n2. Background monitor routines don't consume any of the address space of your target system.\n\nDisadvantages Of Background Monitors\n\nBackground monitors have two main disadvantages:\n\n1. When a processor is executing code within background memory, its ability to detect and handle target system interrupts is severely limited. Therefore, interrupts may be ignored and refresh cycles needed by DRAM's, etc., may not be generated. If a watchdog timer is operating in your system to check on system updating processes, the watchdog timer will not be updated as necessary, and therefore, it may shutdown or reset your target system. Real-time servicing of keyboards, displays, etc., will not occur as long as the emulation processor is executing in background space.\n2. The routines within background monitors cannot be accessed or modified. If you’d like to add a feature to your emulator for better support of your target system, or if you’d like to change the way a monitor routine works with your target system, there’s no way to do it.\n\n**Foreground Monitors**\n\nForeground monitors are supplied as source files. They are written in the assembly language of the processor they emulate. You can edit the monitor source file, if desired. Then you must assemble the monitor program, link it, and load it in emulation memory. It is important to load the foreground monitor into emulation memory because this permits the emulation processor and the rest of the emulation hardware to communicate properly.\n\n**Advantages Of Foreground Monitors**\n\nForeground monitors have at least three primary advantages over background monitors:\n\n1. A foreground monitor can continue to service the needs of a target system (i.e., interrupts, memory refresh, etc.) while the monitor routines are executing. By making appropriate modifications to your foreground monitor, your emulator will be able to service real-time events, such as interrupts and watchdog timers in the target system while the emulator is executing your monitor code. For most multitasking, interrupt-intensive applications, you will need a foreground monitor.\n\n2. You can modify the monitor routines to meet the needs of your target system. You can customize the way your emulator handles instructions. You can assign different priorities to your target system interrupts. You can modify the monitor program in cases where operation of a monitor routine conflicts with operation in your target system.\n3. You can write routines to perform special tasks for your target system and then call your routines by using the structure of the monitor. For example, you might call a routine you have written that allows your target system to modify the values in coprocessor registers (if your target system uses a coprocessor).\n\n**Disadvantages Of Foreground Monitors**\n\nThe disadvantage of a foreground monitor is that you need to assemble it, link it, and load it in emulation memory before you can use it. If you want to customize the monitor for your target application, you will have to understand how the monitor works. Also, you’ll have to sacrifice a portion of your target processor’s addressable memory space to contain the foreground monitor code. This may not be much of a problem when developing code for a 32-bit processor, but it can cause significant problems when developing target systems that use 8-bit processors with 64K of address space.\n\n---\n\n**Some Emulators Have Both A Background And Foreground Monitor**\n\nWhen an emulator has both a background and foreground monitor, the support provided by each monitor may be different. For example, full support of emulation may be supplied by the background monitor, and interrupt handling and custom coprocessor support may be provided by the foreground monitor.\n\nIf your emulator has both a background and foreground monitor, the following paragraphs will help you decide when to use each one.\n\n**When To Use The Background Monitor**\n\nUse the background monitor during the early stages of hardware development, before the target system interrupt, bus error, and other asynchronous capabilities are available. The background monitor is the ideal environment to make the first operational tests. Because designers of a background monitor make no assumptions about the status of the target system, you can execute simple tests even without any components, except the emulator probe plugged into the target system. Using an emulator with a\nbackground monitor, you can write a standard checkerboard bit pattern to various data, address, and control lines to verify that they're wired correctly. When you start adding RAM or I/O chips to your target hardware, you can use the display/modify target memory features to send test bits and read the results.\n\nAn emulator with a background monitor can also run some simple test programs. For example, you can create an infinite loop to write alternating \"ones\" and \"zeros\" to a memory address. Then, with an oscilloscope, you can probe various points in your target hardware to check for ringing on power and ground lines, violations of setup and hold times on read/write devices, and crosstalk between lines.\n\nUse the foreground monitor when the background monitor no longer supports development of your target system. For example, if your target system uses dynamic RAM, the data in the dynamic RAM will be lost when the background monitor is entered because no refresh cycles will be generated. If your target system includes I/O buffers that communicate with the host computer, communication will cease because the interrupt/handshake cycles needed by the host-based I/O drivers cannot be generated when execution is in background memory.\n\nIf the design of the target system hardware is nearly complete and the target memory system is stable and reliable, it's time to use the foreground monitor. An emulator is more transparent when it is used with a foreground monitor. Interrupts, bus errors, and other exceptions can be handled by the target system software as if the emulator were not present. All emulation and analysis functions are available. You can customize the monitor program to fit your application. Target-specific messages can be added and displayed on the emulation terminal. Display and modification of coprocessor registers (if present) can be done by adding the necessary code to the foreground monitor program.\n\nOne example of development that would need a foreground monitor is development of target system interrupt service routines (ISR's). Because interrupts do not affect the operation of monitor routines, you can analyze the execution of your ISR's with an internal analyzer while using your emulator (with foreground monitor) to watch data move between I/O and memory addresses.\nYou can also single step through one ISR routine while other ISR’s continuously generate interrupts. An interrupt of higher priority can always take control from an interrupt of lower priority. By changing the relative priority levels of the ISR’s, you can single-step through an ISR that you have given a low priority and watch the higher priority ISR’s periodically take control.\n\nFor The Emulator With No Foreground Monitor\n\nThe rest of the chapter discusses information needed by users of emulators with foreground monitors. If your emulator does not have a foreground monitor, you don’t need to read any more of this chapter.\n\nCustomizing The Emulation Foreground Monitor\n\nThe source file for a foreground monitor is thoroughly commented so you can understand its routines and make desired modifications. A flowchart of a typical emulation monitor is given in this chapter.\n\nCaution\n\nPOSSIBLE LOSS OF WORK SESSION! SYSTEM MAY BECOME UNUSABLE. Do not let the routines you customize in the emulation monitor exit the monitor. The monitor has a defined exit routine that reloads appropriate values in registers, etc. It must be used. Exiting the monitor by any other path may cause the entire system to become unusable. Do not modify routines in the monitor unless changes are recommended and instructions are outlined in your monitor source file. Incorrect changes in some sections of a foreground monitor may cause emulation features to stop working.\nCaution\n\nLOSS OF ORIGINAL MONITOR SOURCE PROGRAM!\nDo not modify the original source file for the foreground monitor. Copy the monitor source file to your own subdirectory and make modifications only to your copy.\n\nSome emulation monitor source files are shipped with \"read-only\" permissions. If your monitor was shipped this way, you will need to execute \"chmod 666 < monitor file name> \" on your copy before you modify it. After modifying your foreground monitor, reassemble it and relink it.\n\nHow Monitors Are Structured\n\nAn emulation monitor is made up of the following major sections:\n\n1. Processor exception vector table.\n2. Entry points into the monitor.\n3. Emulation command scanner.\n\nEach of these sections is discussed in the following paragraphs.\n\nFigure 3-2 is an example flow chart of a typical emulation monitor. This flow chart does not show the processor exception vector table. The processor exception vector table for this example flow chart has uncommented six entry vectors.\n\nProcessor Exception Vector Table\n\nThe emulation monitor (figure 3-1) is entered through processor exceptions. The emulation monitor program contains instructions that load the processor exception vector table with the addresses of the routines that handle the various exceptions.\nFigure 3-1. Typical Processor Exception Vector Table\nActivating Processor Exception Vectors\n\nEmulation monitor programs are normally shipped from the factory with all of the exception vectors (except RESET and MONITOR SINGLE STEP) contained in comment fields. This is done to allow you to supply the addresses for your own exception handler routines, if you have written any. If you have not written any exception handlers, remove the comment delimiters (*) from those provided in the processor exception vector table. This enables the emulator to use the processor exception vector table provided with your monitor program.\n\nIf your target application has its own RESET handler, you can modify the reset vector address in the processor exception vector table to point to the routine in your target code. You will also need to disable the reset-to-monitor function by answering \"no\" to the appropriate emulation configuration question.\n\nOften, the portion of the monitor containing the processor exception vector table is not relocatable, as is the rest of the monitor. If the processor exception vector table of your monitor must reside in a specific address space, be sure to map the appropriate block of memory to emulation RAM (or to target-system ROM, if permitted by your emulator).\n\nModifying The Processor Exception Vector Table\n\nUse your editor to remove the comment delimiters (*) from the start of each line of code that you want to be active in your processor exception vector table. Lines that begin with comment delimiters will be ignored during execution.\n\nEnd out of your edit session, making sure that you save your changes.\n\nBy removing the comment delimiters, you have made the exception vector table usable. The processor exception vector table points to addresses of the appropriate emulation monitor entry point routines.\nEntry Points Into The Monitor\n\nEmulation monitor entry points are input routines for the various entry paths into the monitor code. The following paragraphs describe typical monitor entry and input handler routines.\n\n**Break_Entry**\n\nThis is the entry point taken when you use the Break command to transfer control from your target program to the monitor program. When a break to BREAK_ENTRY occurs, the program counter and status register of your emulation processor are saved on the stack, as is normally done when an exception occurs. The emulation monitor proceeds to the monitor loop where it waits for a command from the keyboard.\n\nDuring the time that the monitor is in use, the emulation processor may move code into target memory, or perform some other task that affects the state of the emulation processor. By storing the entry values of the emulation processor, these same values can be restored later so that execution can be returned to the point where it was interrupted in the target program when you have finished using the monitor functions.\n\n**Bus_Error_Entry and User_Entry**\n\nThese entry points are taken when the emulation processor detects either a bus error or an address error exception. The only difference between these entries and the BREAK_ENTRY described above is that some additional words required to understand these exceptions are saved in variables.\n\n**Software_Breakpoint_Entry**\n\nThis entry point is taken when a software breakpoint is processed. You might use a software breakpoint when you want to begin single-stepping through your target code after several target-system processes have begun. You can set the software breakpoint at an address in your code following startup of these activities.\n\nThe emulator processes a software breakpoint by removing and storing the instruction that resides at the selected address and replacing it with a BKPT instruction. When the BKPT is found, execution enters the monitor loop and waits for a keyboard command.\ncommand. At the same time, the emulator discards the BKPT instruction and restores the previous instruction that was at that address. Note that you can’t set a software breakpoint at any address mapped to target ROM.\n\n**Reset_Entry**\n\nThis entry point is taken when the emulation processor executes the reset exception. RESET_ENTRY returns the stack pointer to the first address in the stack, and sets all of the emulation processor’s registers to default values. Then the monitor loop is entered, and the emulator waits to detect a new command.\n\n**Exception_Entry**\n\nA set of exception entry points allow the emulator to display status messages for the exception vectors after reset. These exception vectors are provided for your convenience, and may be deleted or modified. For more information on the exception vector entry points, refer to the paragraph in this chapter titled “Modifying The Exception Vector Table”.\n\n**Emulation Command Scanner**\n\nCommand scanning is done in the monitor loop, an idle loop that continuously tests for the existence of a keyboard command. When a keyboard command is found, the corresponding command routine is executed. Depending on which keyboard command was issued, execution may end with a return to the monitor loop to await further commands, or the state of the system may be restored to its pre-break condition, and execution may resume where it left when the break was detected.\n\n**Command Execution Modules**\n\nThe following paragraphs describe typical emulation command execution modules that reside in a monitor.\n\n**Are_You_There?**\n\nAn are_you_there routine is used by the emulator to determine whether the emulation processor is executing in the monitor or in the target system code. The are_you_there routine can also pass an\nASCII message to be displayed on the status line of the emulation display, such as, \"Running in monitor.\"\n\nExit_Mon\n\nThis is the path to use when exiting the monitor. An exit_mon routine will reload the processor registers from the variables that were stored when the monitor was entered. The program will then exit the monitor and resume execution of the target system code.\n\nCopy\n\nThe copy routine moves data between the monitor and target-system memory. This command is used to modify and display target-system memory.\n\n---\n\n**Monitor Routines You May Want To Modify**\n\nThe following paragraphs describe examples of modifications you may want to make to a monitor program. Not all of these selections are available in every foreground monitor.\n\n**Read/Write Target Memory Space**\n\nYou may want to change the size of the monitor transfer buffer. Some foreground monitors allow you to change the size of this buffer to obtain increased performance during target-system accesses. Monitors that allow these changes will precede the global symbol for the buffer size (typically called MON_XFR_BUF) with suggested values and value limits.\n\n**Display/Modify Registers Of A Coprocessor**\n\nYou may have written a routine to load values into coprocessor registers. The monitor offers an easy way to identify the location of that routine so it will be executed by the emulator when you want to load the registers. The monitor source file will show a modification you can make so that the emulator will execute your routine when desired.\nFigure 3-2. Emulation Monitor, Typical Block Diagram\nBus-Error/Address-Error Storage\nYou may want to modify your monitor so that it will save additional information about the state of the emulator when a bus error or address error occurs.\n\nMessages Displayed On The STATUS Line\nYou may want to change the words of an existing message, or create some new messages to be displayed on the status line.\n\nSimulated Interrupts For Out-Of-Circuit Emulation\nSome monitors allow you to set up parameters so you can force the emulation processor to branch to your interrupt-handler routine and run it during execution of your target program.\n\nException Vectors, Selecting Your Own\nThe monitor program may contain a list of exception vectors that are preceded by comment delimiters. If you would like to enable any or all of these exception vectors, simply edit your copy of the monitor source file to remove the comment delimiters.\n\nMonitor Routines You Should Not Modify\nNormally, you should never modify the monitor routines that provide the following features for the emulator:\n\n- Display/modify registers of emulation processor\n- Execute your target program\n- Break into monitor from target program\n- Reset into monitor\n- Single-step program instructions\n- Break away from target program\nThe emulation foreground monitor must be assembled and linked before it can be used by the emulation system. Depending on the emulator you are using, there may be special constraints imposed on your foreground monitor. Below is a list of some of things you should consider before linking your emulation foreground monitor:\n\nSome emulators allow you to link the foreground monitor with your target code to form a single executable module. Linking the monitor separate from the target code is preferred. Linking monitor programs separately is more work initially, but with separate linking, the monitor can be loaded efficiently during the configuration process.\n\nSome emulators specify that the foreground monitor must be linked as a separate module and loaded first into memory before you can even load your target code. In these systems, one of the monitor routines performs the task of loading your target program.\n\nIn some systems, you tell your emulator the address of the foreground monitor by answering a single configuration question. With this information, the system can figure out everything else it needs to know to use the monitor routines.\n\nIn some systems, the processor exception vector table must be placed in a specific address range, but the remaining routines of the monitor can be placed in any address range you desire.\n\nIn one emulator, the foreground monitor must be placed entirely within a specific address range, and the foreground monitor for that emulator cannot be modified.\nLoading The Emulation Monitor\n\nBy using options to the \"load\" command, you can load the monitor into emulation memory, and then load your target system code into target system memory. Load the emulation monitor code first.\n\nMost foreground monitors reside in RAM space in emulation memory hardware. Prepare your load map so the emulation memory hardware containing the foreground monitor will be part of the same logical address space that contains the target program code. This way, the target processor will be able to run monitor code in the same space as its own target code (servicing interrupts and providing refresh cycles), even though the hardware that contains the monitor code is emulation hardware, not target-system hardware.\n\nMemory Requirements For Emulation Foreground Monitors\n\nThe size of the relocatable portion of a foreground monitor differs from one emulator to another. You can determine the size of your emulation monitor if you look at the MODULE SUMMARY section of its linker listing file.\n\nWhen you load your foreground monitor into memory, start the monitor on the first address in a new memory block. The emulation system divides the available memory hardware into blocks of equal size. Some emulators allow you to specify the size of the blocks desired (typically from 256 bytes per block to 4K bytes per block). Other emulators divide all memory into one block size (typically 256 bytes per block).\n\nForeground monitors should reside in RAM space in emulation memory. The emulator cannot always access target-system memory, but it can always access emulation memory. Some emulators have additional requirements (such as function codes) for the kind of memory where they reside. Refer to your emulator User’s Guide for specific requirements for your monitor.\n\n3-18 Monitor Concepts\nSome portions of the foreground monitor may need to be mapped to specific address ranges, such as the processor exception vector table of certain monitors. Sometimes the entire foreground monitor must be located in a specified range of address space. These restrictions vary from one emulator to another and may not apply to the foreground monitor you are using.\n\nEmulators for processors that use memory management units (MMU) may need the monitor located in address space where logical address = physical address so that monitor routines are not affected by translations made by the MMU.\nThe Emulation Configuration\n\nWhat Is An Emulation Configuration File?\n\nThe emulation configuration file is a file containing a series of questions and answers that define the kind of support to be provided by the emulator. Many aspects of the way your emulator operates are governed by its configuration file. An emulation configuration file is supplied with a set of default answers to its questions. You can select different answers to these questions, if desired.\n\nLoading the configuration file is one of the first things you do when you gain access to your emulator. The configuration file sets up the operating mode you desire. Aspects of emulator operation that are usually governed by its configuration file include:\n\n- How your emulator handles various conditions it may encounter during your tests.\n- How your emulator manages the memory hardware it has available.\n- How resources are shared between your emulator and your target system.\n- How the emulator and target system interact.\n- Which operations are enabled in the emulation environment.\n\nEmulators are supplied with default configuration files that answer the questions in ways that are typical for most applications. You can modify the configuration file to match the needs of your target system by invoking the series of emulation configuration questions and providing your own answers to the questions when they appear on your workstation. After modifying the emulation configuration...\nfile, you can save it under a filename of your own. Then you can load your new configuration file instead of the default configuration file each time you enter emulation (example: load configuration myconfig RETURN).\n\nThe following conditions are typically managed by the emulation configuration file:\n\n- Selecting real-time or non-real-time emulation mode.\n- Enabling breaks to the emulation monitor.\n- Selecting whether to reset into the emulation monitor or to use the user reset exception vector.\n- Configuring the foreground and background monitors.\n- Setting the software breakpoint instruction.\n- Configuring custom coprocessor functions.\n- Configuring memory.\n- Configuring the emulator probe.\n- Configuring simulated I/O and simulated interrupts.\n\nModifying The Emulation Configuration File\n\nTo modify the emulation configuration file, invoke the file from within emulation by entering a command such as:\n\nmodify configuration Return\n\nThe first question in the series of questions will appear on the screen of your terminal. When you answer it, the next question will appear. Each question is displayed with its present answer. You can continue to use the present answer to a question (present setup\n\n4-2 Emulation Configuration\nfor that aspect of the configuration) by pressing the Return key. Optional answers to each configuration question can be selected by pressing an appropriate softkey or by typing in the desired answer on the command line, and then pressing Return.\n\nNote\n\nIf you need to back up to a question you already answered, press the RECALL softkey. Each time you press RECALL, the emulator will back up one configuration question.\n\n---\n\n**View The Configuration File And Its Present Answers**\n\nAn incorrect configuration file may cause improper operation of your emulator. Review the entire configuration file to make sure all of the questions are answered correctly. If you are not sure how to answer a particular question, refer to your emulator user's guide for details of the consequences of selecting each answer to a particular configuration question.\n\nEnter the command \"`!more < configfilename> .EA`\" to view the entire configuration file, along with its present answers.\n\n---\n\n**The Configuration File To Use When Starting Your Target System**\n\nTarget systems that can operate with the target microprocessor instead of the emulation pod should be able to start without difficulty when you load the default configuration file that was supplied with your emulator. Use the default configuration file whenever you start a new emulation session. The default configuration file enables all of the target system signals, maps all memory as target RAM, and specifies that the emulation monitor is not loaded. Verification of proper operation should be made using the emulation bus analyzer and indications from the target system. When you first connect the emulator to the target system, correct any failures you find using a minimum emulation configuration, no emulation memory or emulation monitor. Once\nthe default configuration works properly, you can add emulation memory and an emulation monitor.\nMemory Mapping\n\nThis chapter discusses how to map memory for an emulation session. When you map memory, you identify the memory hardware that will be used during the emulation session, and you specify the absolute code modules that will reside in that hardware. To support these specifications, two maps are required. The use of each map is described below:\n\nUsing the emulation memory map (part of the emulation configuration file):\n\n- You specify the size of each block of contiguous address space. The range of addressable memory of your target system will be divided into blocks of the sizes you specify (down to the minimum block size your emulator will support). Some emulators allow you specify their minimum block size.\n\n- You characterize the hardware that will support each block of contiguous address space. You might identify the first block of addresses as ROM space. The next block of addresses may reside in RAM hardware. Some emulation memory maps allow additional characterization, depending on the capabilities of the target processor.\n\n- You identify the location of the memory hardware that supports each address block. One block of addresses might reside in emulation memory. Another block of addresses may reside in hardware on the target system.\n\nUsing the linker load map:\n\n- You identify the code modules (by name) that will reside in each of the address blocks.\nThe way the emulator uses the emulation memory map is:\n\n- The emulator manages each block of addresses separately. Emulators limit the number of separate blocks they can manage. You need to select a block size that avoids exceeding this limit. Usually this limit is equal to the number of spaces available for entries on the emulation memory map.\n\n- The emulator will allow reads and writes to addresses in blocks you’ve characterized as RAM space, but it will not allow writes to addresses in blocks you’ve characterized as ROM space.\n\n- The emulator will turn on one set of address buffers if the present address is part of a block that resides in the target system. The emulator will turn on a different set of address buffers if the present address is part of a block that resides in the emulation memory.\n\n- The emulator interface software uses the linker load map when it loads the target code into memory. It loads each of the target modules into the address space you specified in this map.\n\n- Any block of memory addresses can be specified as guarded space (meaning these addresses don’t exist. An attempt to read or write to guarded memory space is an illegal condition). The emulator will try to break to the emulation monitor if your target program tries to access guarded memory. This can be used to halt a runaway program.\nHow The Two Maps Depend On Each Other\n\nThe purpose of the following discussion is to introduce the emulation memory map and the linker load map, and show you how these two maps work together to load your target program into memory hardware.\n\nWhat Do You Do When You Map Memory\n\nUsing the emulation memory map, you allocate and characterize memory space available in your hardware. The linker load map is where you specify which code module is going to reside in the memory address space available. Each of these maps is described separately in the following paragraphs.\n\nExample Emulation Memory Map\n\nFigure 5-1 shows a simplified emulation memory map. The exact format of the emulation memory map in your emulator may be different, but it will carry the same kind of information as shown in figure 5-1.\n\nThe emulation memory map shows a list of address ranges. Beside each address range, the emulation memory map shows whether the memory hardware that will support that range is located in the emulator or in the target system. Finally, it shows whether that hardware is to be treated as RAM or ROM.\n\n<table>\n<thead>\n<tr>\n<th>Entry</th>\n<th>address range</th>\n<th>location/description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>0 - FF</td>\n<td>EMUL/ROM</td>\n</tr>\n<tr>\n<td>2</td>\n<td>100 - 1FF</td>\n<td>TARGET/RAM</td>\n</tr>\n<tr>\n<td>3</td>\n<td>1000 - 11FF</td>\n<td>EMUL/RAM</td>\n</tr>\n<tr>\n<td>4</td>\n<td>1200 - 12FF</td>\n<td>EMUL/RAM</td>\n</tr>\n<tr>\n<td>5</td>\n<td>2000 - 23FF</td>\n<td>TARGET/ROM</td>\n</tr>\n</tbody>\n</table>\n\nFigure 5-1. Simplified Emulation Memory Map\nManaging The Emulation Memory Hardware\n\nIn figure 5-1, some emulation memory is specified as ROM space, and some as RAM space. All of the hardware on the emulation memory board is RAM hardware, but your map specification will control the way the emulator manages access to the memory. If you specify an entry as RAM space, the emulator will allow reads from and writes to that space during runs of your target program. If you specify an entry as ROM space, the emulator will allow reads from that space during a run of your target program, but not allow writes to that space. If a write is attempted to space you’ve mapped as ROM space, the emulator will signal that an illegal condition has occurred.\n\nEmulation Memory Architecture\n\nFigure 5-2 is a simplified schematic showing the logical architecture of the emulation memory board assembly. The memory mapper hardware is set up to support each entry in the emulation memory map (figure 5-1 in this example). Each entry is explained below:\n\nEntry 1 in the emulation memory map is the 256-byte range of addresses from 0 through 0FFH. For this example, it has been mapped as Emulation ROM. When the mapper hardware receives any address in this range, it performs an address translation to map the address into the appropriate space in emulation RAM. It also causes the attribute memory to supply the appropriate control signals to the emulation run control so that the emulation cycle will be treated as an access to ROM (no write transactions allowed) and as a read from the emulation memory.\n\nEntry 2 in the emulation memory map is the 256-byte range of addresses from 100 to 1FFH. It is target ROM. The mapper hardware will not perform an address translation. The attribute memory will send the signal \"target ROM\" to the emulation run control. The emulation run control will turn on the appropriate buffers to send the address to hardware in the target system. The emulator will manage each address according to its rules for accesses to ROM space.\n\nEntries 3 and 4 are mapped to emulation memory. The mapper hardware will perform the appropriate address translations to map each of the addresses to the appropriate spaces in emulation RAM. The attribute memory will send the appropriate signals to the\nemulation run control so that each address cycle will be managed as an access to RAM (as specified in the emulation memory map).\n\nEntry 5 in the emulation memory map is a 1-Kbyte range of address space in target ROM. Again, the mapper performs no address translation. The attribute memory sends the code for \"target ROM\" to the emulation run control, and it sends the address to target-system hardware. The emulator manages each address according to its rules for accesses to ROM space.\n\nFigure 5-2. Emulation Memory Architecture\nThe preceding discussion explains why emulation memory is expensive. It has to be faster than target memory to allow time for the translations that must be performed by the mapper. If the target memory must respond in 80 nsec, then the emulation memory must typically respond in 35 to 40 nsec.\n\nFigure 5-3 shows an example linker load map. This map specifies the addresses where each module of your target code will be loaded in memory. Many linker load maps show only the address of the first byte of code of each module. This example assumes that module 1 will be no larger than the 256-byte space available in entry 1 on the emulation memory board (figure 5-2). Module 3 will be no larger than the target memory space allocated to entry 5 on the emulation memory map (figure 5-1). The monitor is no larger than the 512-byte space made available in entry 3 of the emulation memory map.\n\nNote that the mapper can use any block of emulation memory hardware to support any range of addresses. This flexibility is not available when mapping target memory. The addresses supported in target hardware depend on how you wired your target system.\n\nThe linker load map must be in agreement with the emulation memory map. If you set up the linker load map to place a code module at addresses 1000H through 10ffH, then you need to make sure your emulation memory map allocated memory hardware to support that address range. If you decide to place data within an\n\n<table>\n<thead>\n<tr>\n<th>Code Module Name</th>\n<th>Load Address</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Module 1</td>\n<td>0000</td>\n</tr>\n<tr>\n<td>Module 2</td>\n<td>0100</td>\n</tr>\n<tr>\n<td>Module 3</td>\n<td>2000</td>\n</tr>\n<tr>\n<td>Monitor</td>\n<td>1000</td>\n</tr>\n<tr>\n<td>Module 4</td>\n<td>1200</td>\n</tr>\n</tbody>\n</table>\n\nFigure 5-3. Simplified Linker Memory Map Content\naddress range, and your program is intended to write to that data space, then you need to specify that address range as RAM space in your emulation memory map.\n\n**Note**\n\nFor complex programs, it may be helpful to have a copy of your linker load map when you are setting up your emulation memory map. You can use it to make sure you provide hardware for every software module in your linker load map.\n\n---\n\n**Special Considerations For The Emulation Memory Map**\n\nThe following considerations apply when filling out most emulation memory maps.\n\n**Selecting The Best Memory Hardware To Use**\n\nAs soon as target system memory becomes available, you should include its address space in the emulation memory map so you can load your program into it and use it for project development. Normally, target system memory hardware will have response characteristics that are different from the response characteristics of the emulation memory hardware.\n\n**Dividing Memory Into Blocks**\n\nA single address block (entry on the emulation memory map) can be as small as a single page. (The page size used in the example in this chapter is 256 bytes.) An address block can also be as large as the entire memory space available.\n\nEach address block can have one memory characterization. An emulator cannot manage two different memory characteristics within one block of addresses (it can’t treat one-half of an address block as ROM and the other half of the same address block as RAM).\nThe ability to select from a variety of choices for page sizes can be useful in emulators that limit the number of separate entries that can be maintained in an emulation memory map. The page size you specify will apply to all memory in the map.\n\nBy specifying a particular block size (having one or more pages), you determine how many separate address spaces must be managed by the emulator. Each address in a block of address space will be treated as though it resides in the type of hardware you specify for the block: RAM or ROM.\n\nWhen you enter a specification on your emulation memory map, the emulation mapper will assign at least one page of hardware addresses to support that specification. This is true, even if there is only one or two bytes in the code module that will occupy that block. The emulator cannot allocate memory space smaller than the page size you specify.\n\nThe emulator, can manage three kinds of hardware: RAM, ROM, and guarded.\n\n- **RAM space** is any memory address space that allows random access for both read and write transactions by the emulation processor.\n\n- **ROM space** is any memory address space that allows random access for read transactions, but no access for write transactions. If the emulation processor (processor in the probe that replaces the target processor) tries to write to space you’ve characterized as ROM, the emulator will detect this event as an illegal transaction, and place a warning message on the status line of the display. Note that the emulation control board can write your program into ROM space. Only the emulation processor (in the emulation probe) is prevented from writing to memory you’ve characterized as ROM space.\n\n- **Guarded space** is any memory address space you are not using (whether or not memory hardware is available to\nsupport that space). Address space characterized as \"guarded\" should never be accessed by the emulation processor. This designation normally identifies non-existent space. If the emulation processor ever tries to read from or write to memory space that is characterized as guarded, the emulation control board will detect this as an illegal event and place a warning message on the status line of your display. (Note that no emulation memory hardware is required to support any address space designated as guarded space.)\n\nOne of the questions in the emulation-configuration set of questions asks if you want the emulator to break from your target program and begin executing in the monitor if the target program attempts to write to an address you've characterized as ROM space. If you answer yes, any attempt to write to ROM will cause a break to the monitor. If you answer no, the write instruction will have no effect on the execution of your target program. In either case, the content of emulation ROM space will not change. The content of ROM space in your target system may or may not change, depending on the design of your target system.\n\nCaution\n\nIn some target systems, there is risk involved with electing to break to the monitor on an attempted write to ROM. If you have some target-system activity that should not be abandoned until it is complete, (such as a moving hydraulic arm that could over-travel if your target program suddenly jumped to the monitor) you might want to answer \"no\" to the configuration question that asks, \"break on write to ROM?\". (If using a foreground monitor, you might overcome this problem by modifying your monitor program.)\n\nYou can set up the emulation bus analyzer (if available) to trace the activity preceding and following an attempted write to ROM. This can be done by setting the trigger to occur on any address in the range you’ve specified as ROM space, and then specifying that the trigger be in the center of the trace memory.\nIf you have activated the monitor and are using non-real-time mode, an attempted access to guarded memory will cause execution to break from your target program to the monitor.\n\nAny address ranges not mapped when the mapping session is terminated are assigned the memory default. The default attribute can be target RAM, target ROM, or guarded. Unless otherwise specified, the system defaults all unmapped address space to guarded.\n\nMapping A Foreground Monitor\n\nMost foreground monitors can be mapped to any address space having the RAM attribute as long as it is located in emulation memory hardware. A few foreground monitors require special considerations when mapping memory (such as placing them in a specified range of addresses).\n\nDeleting Map Entries\n\nSome emulation memory maps will not allow you to delete all of the map entries. They may reserve one range of addresses for a processor-specific usage, such as an exception-vector table for a foreground monitor.\n\nOverlay\n\nIf you want a block of hardware memory to respond to two or more address ranges, use the overlay capability in the emulation memory map. When you overlay one address range onto another, you can characterize the emulation memory differently for each address range, if desired.\n\nA typical use of the overlay feature would map a single 256-byte block to support two address ranges: 1000H thru 10FFH as ROM, and 1800H thru 18FFH as RAM. When the emulation processor addresses any location from 1000H to 10FFH, the emulator will allow reads but not writes. When the emulation processor addresses any location from 1800H through 18FFH, the emulator will allow both reads and writes. Therefore, the emulation processor could overwrite the content at any address in the 256-byte block if it addressed it using its 18XX address, but could not write to it at all if it addressed the same memory hardware using its 10XX address.\n\nYou can only specify memory overlay using emulation memory hardware, not hardware on your target system, but you can map a\nblock of memory space in your target system and then overlay it with a block of emulation memory hardware. The range of your overlay specification must be the same size as the range it is overlaying.\n\nSome emulators allow you to specify a wide variety of attributes that can be included when characterizing blocks of memory. Your emulation memory map may allow you to include one or more of the following descriptions to further characterize your memory hardware:\n\n- program code/data code\n- processor function codes\n- synchronous or asynchronous cycles\n- 8-bit, 16-bit, or 32-bit data widths\n- emulation memory whose cycles are interlocked with target system memory\n- cache disables to turn of a processors cache when execution is in a particular address range\n\nProblem When Specifying Certain Address Ranges\n\nThe problem discussed in this paragraph generates the message, \"ERROR: Lower address in range greater than upper address.\" It results from the way an emulator processes the highest address in an address range specification. For most range specifications, the emulator accepts your specification as you enter it. The problem occurs when the highest address in an address range is the lowest address of an address block (e.g. xxxx00h). In this case, the emulator rounds down the address by one byte (e.g. xxxxffh).\n\nIf you attempt to specify an address range by using the same value for both the start and end addresses, and the address you choose is the first address in a new memory block (map 100h thru 100h emulation ram), the emulator will round down the ending address. When rounded down, the ending address (0FFH) is lower than the starting address (100H).\nNotes\n\n5-12 Mapping Memory\nCommand Files\n\nThis chapter provides the following information about command files:\n\n- what is a command file?\n- how are command files useful?\n- methods used to create command files\n- editing an existing command file\n- how to execute a command file\n- conventions for naming command files\n- nesting and chaining command files\n- making a command file fit into a script\n- executing scripts automatically upon login\n- things to remember when using command files\n- what to do if your command file doesn’t work\nThis chapter does not provide details of how to make a command file execute in every kind of system. For example, you can quote strings of characters to be passed as parameters during execution of your command file. Some systems allow you to use several different characters for quoting characters. Other systems allow you to use only quotation marks for quoting characters. You'll have to refer to your system user's guides and/or reference manuals to find out which quoting characters you can use in command files for your system.\n\n### What Is A Command File?\n\nA command file is simply a file that contains commands. When you type the name of the command file on your interface, the commands are pulled one at a time from the file and executed in your system. Command files are useful because they allow you to create a setup or test that involves several command entries, and then perform that setup or test any time you want by simply typing the name of the command file on the command line and pressing the RETURN key.\n\nCommand files are similar to HP-UX scripts. The difference is that the commands in your command file must be native to the interface you are using. Also, command files must not have execute permissions.\n\n### How Are Command Files Useful?\n\nCommand files minimize the need to type on the keyboard, and they speed up the process of emulation because each new command is entered as soon as the system is ready to accept it.\n\nYou can use command files to duplicate measurements. For example, every time you want to assemble, link, load, and run a program, you can type the name of a command file that contains the appropriate assemble, link, load, and run commands. All of the steps will be executed automatically.\nThe following is a list of tasks that are easy to implement in a command file:\n\n1. Compile, assemble, and link programs.\n\n2. Enter emulation and do emulator tasks.\n\n3. Invoke an external analyzer (State, Timing, or Software Performance), and perform analysis tasks, such as:\n \na. Specify trigger conditions.\n \nb. Trace.\n \nc. Copy trace list to printer.\n\n4. To run an emulation and analysis session, you enter a series of commands that gain access to emulation, load the different memories with your absolute code, run your code from selected addresses, and trace program execution using selected trigger states and storage qualifications. The commands you enter to perform these actions can be placed in a command file under a name you select.\n\n All you have to do to repeat the same session later is type the name of the command file on the command line. The system will execute the commands in the order they appear in your command file.\n\nWhen you configure the emulator for an application, you answer a series of configuration questions. These questions and the answers you give are stored in a command file generated by the emulator.\nThere are two methods to create command files: (1) automatic creation by recording the commands you use during a test, and (2) opening a file and typing in a series of command lines. Both methods are described in the following paragraphs.\n\n**Automatic Creation Of A Command File While You Use The Emulator/Analyzer**\n\nYou can have the emulation system keep a record of the commands you execute while performing a test. (This is called \"logging commands to a file\"). In this way, you can concentrate on running your test without having to think about command files. When you finish your test, turn off the logging process. The file may be edited to view or alter the command list. Creation of a command file by logging commands ensures that the syntax of the commands is correct.\n\nTo turn on the process of logging commands, some interfaces let you enter a command such as:\n\n```\nlog_commands to < filename> RETURN\n```\n\nOnce you have done this, all of the commands you use will be put into a file whose name is the `< filename>` you specified in the command. Each command will be saved on a separate line.\n\nWhen you finish your tests, enter the command to stop the logging process. Some interfaces use the command:\n\n```\nlog_commands off RETURN\n```\n\nThe command file is in your present working directory, ready for edit.\n\n**Things To Correct During The Edit**\n\nIf you ended your session with the \"end\" command, that command will be the last command in your log file. You will probably want to delete this command. For other editing considerations, refer to the paragraph titled, \"Editing An Existing Command File\", later in this chapter.\nLogging To Enlarge An Existing Command file\n\nIf you already have a command file with the same name as the file you are logging commands to, your new commands will be appended to the previous command file. To avoid this, accompany your \"log_commands\" entry with \"noappend\". When you specify noappend, the previous log file will be overwritten (if you have permission to write to the file).\n\nLogging Calls To Other Command Files\n\nIf you call an existing command file to perform some activity while you have the \"log_commands\" process turned on, the logging process will turn off while the called file executes. Only the call to the command file will be logged, not the commands within the called file.\n\nLogging Commands That Spawn New Processes\n\nYou cannot log commands that spawn new processes. For example, \"!vi\" in the command file will invoke the \"vi\" editor, but will not log any of the \"vi\" editor commands. When the \"vi\" editor is terminated, commands will again be logged to your file.\n\nYou can log single shell commands, such as \"!ls\" or \"!asm -o sample.s > sample.o\".\n\nUsing An Editor To Create Command Files\n\nYou can use the Softkey Driven Editor or any HP-UX editor to create command files. The syntax diagrams in your emulation and analysis user's or reference manuals will be helpful when composing your command lines. Proceed as follows:\n\n1. Invoke the editor you want to use to create the command file.\n\n2. Type in the desired commands. Make sure the commands you type are in the form that appear on the command line, not the abbreviations that appear on some of the softkeys. Also, make sure you use the correct command syntax.\nBefore you can use an existing command file, it may need to be edited. Edit the command file just as you would edit any other file:\n\nScroll through the text. If you ended the log process by using the \"end\" command, the last line of your file will be \"end\". Delete this command.\n\nEdit out any lines containing \"!sh\" in a command file. Otherwise, your command file will become suspended until you press <CNTL> d. After pressing <CNTL> d, your command file will resume.\n\nEdit out any control characters in command files.\n\nDo not make command files executable. One difference between command files and HP-UX scripts is that scripts must have the file permissions set to \"executable\" before you can use them. Command files must not have execute permissions.\nHow To Execute A Command File\n\nTo execute a command file, you must be in an emulation/analysis session. You cannot start a command file from a shell prompt. However, you can create a shell script (an HP-UX file of commands that can be invoked from the HP-UX shell) that gains access to your emulation/analysis session, and then run a command file once that access has been obtained. You can also create an HP-UX script that enters an emulation/analysis session and then performs the actions of an embedded command file to complete a series of emulation and analysis tasks. These methods of execution are discussed in the following paragraphs.\n\nExecuting A Command File Alone\n\nThe most simple case of executing a command file is to type in the commands that gain access to your emulation/analysis system interface, and then type the name of the command file.\n\nUsing A Script And Command File Together\n\nThis case is a little more complicated because you must create two files. This case provides greater benefits because it reduces the number of commands you need to type in when performing your test. To do this:\n\n1. Make a command file.\n\n2. Make a script whose last entry accesses the emulation/analysis interface where you want to start your command file. Make the script executable (chmod +x <script_name>).\n\n3. Type the name of your script at the system prompt.\n\n4. Type the name of your command file when your script finishes executing and the desired interface is on screen.\n### Conventions For Naming Command Files\n\nA command file name can have up to 14 characters. A name with more than 14 characters will be truncated. If your command file name begins with an alpha character, simply type the command file name and press RETURN to execute the file.\n\n**Startup8 RETURN**\n\nA command file name can begin with a number (e.g. 35test). When the first character of a command file name is a number, you must precede the invocation with a backslash.\n\n**\\35test RETURN**\n\nCharacters after the first in a command file name can be alpha or numeric. Most characters can be used in a command file name, except `# | > < ; ( ) /` and `\\`.\n\n### Nesting And Chaining Command Files\n\nNesting command files means calling a command file from within another command file. You can nest command files up to 50 levels deep.\n\n#### Nesting Command Files\n\nA command file call is similar to a subroutine call.\n\nWhen a command file calls another command file, the calling command file must supply any parameters needed by the called command file. Otherwise, execution will stop. Once execution has started, you will not be prompted for missing parameters.\n\n#### Chaining Command Files\n\nCommand files are said to be chained when the last line of a command file calls another command file. You can chain as many command files as you like. Chaining command files is preferred to nesting because nesting command files is not supported on some host systems.\nExecuting Scripts Automatically Upon Login\n\nYou can set up a script to execute automatically when you log in to the system. To do this:\n\n1. Make the script executable.\n\n2. Execute the script to make sure no errors occur. Fix any errors that occur. Then proceed.\n\n3. Invoke your .profile file in an editor.\n\n4. Add the script name to a line in your .profile file.\n\n5. Save the .profile file, and exit the editor.\n\n6. Log off the system. Log on again to verify that the script executes correctly.\n\nThings To Remember When Using Command Files\n\nThe following general information will help you use command files effectively:\n\n1. A command file that is started in an emulation/analysis session will continue to execute until an end-of-file is found, or until a syntax error occurs.\n\n2. You can stop a command file by pressing < CNTL> c or the BREAK key.\n\n3. Command files can contain shell variables if they begin with \"$\" and use an identifier. An identifier is a sequence of letters, digits, or underscores beginning with a letter or underscore. The identifier may be enclosed by braces \"{}\" or entered directly following the \"$\" symbol. Braces must be used when the identifier is followed by a letter, digit, or underscore that is not part of its name.\n\n For example, assume a directory named /users/softkeys and a shell variable \"S\" whose value is \"soft\". By specifying the\ndirectory as \"/users/${S}keys\" , the correct result\n(/users/softkeys) is obtained. However, if you specify the\ndirectory as \"/users/${SSkeys\" , the host will look for the value\nof \"Skeys\".\n\n4. You can examine the current values of all shell variables\ndefined in your environment with the command \"env\".\nPositional shell variables, such as $1, $2, and so on, are not\nsupported. Special shell variables, such as $@, $*, are also\nnot supported.\n\n5. Command file lines can be longer than one screen width.\nBreak long command lines by ending the line with a\nbackslash (\\). A line terminated by \"\\\" is concatenated with\nthe line that follows it. This continues until a line is found\nthat does not end with a backslash. A line constructed in\nthis manner is recognized and executed as one single\ncommand line. If the last line in a command file is\nterminated by \"\\\", it appears on the command line but is\nnot executed. Normally, the line feed is recognized as the\ncommand terminator.\n\n6. Commands in shell scripts can also be longer than one\nscreen width. Do this by quoting the command. The HP\n64000-UX environment recognizes three quoting\ncharacters for shell commands: double quotes (\"), single\nquotes ('), and the backslash symbol (\\).\n\nFor example, the following three lines are treated as a\nsingle shell command. The two hidden line feeds are\nignored because they are inside the two single quotes ('):\n\n !awk '/$/ { blanks++ }'\n END { print blanks }\n\n 'an_unix_file\n\n7. An HP-UX hosted linker may not work if it is invoked\nfrom a command file and has no argument specified. The\nlinker looks for input from the keyboard. It cannot read\nthe input from the command file.\n8. Do not set the execute permission of a command file. If permission is set (`chmod + x commandfile`), the command file will not work.\n\n---\n\n**If The Command File Does Not Work Properly**\n\nCommand files execute properly when they have no syntactical or semantic errors. If an error is found, execution of the command file stops, and a message is displayed.\n\nCommand file execution will stop if:\n\n1. The command file contains a syntax error.\n2. An error is detected by the application program.\n3. You press `<CNTL>`c or the BREAK key.\nCoordinated Measurements Through CMB And IMB\n\nHigh-speed communication is used to coordinate triggering, enabling and disabling of functions, and synchronization of execute and halt between two or more emulators and/or analyzers involved in a measurement. The coordinating signals pass through the CMB and/or IMB listed below:\n\n- CMB (The Coordinated Measurement Bus).\n- IMB (The InterModule Bus).\n\nThese two buses have differences, but the functions they perform are the same.\n\nDifferences include:\n\n- The number of lines and types of signals carried.\n- An emulator on CMB must use a background monitor.\n An emulator on IMB can use either a background or foreground monitor.\n- You can interconnect a great many emulator/analyzer sets with CMB and only a few with IMB.\n- The maximum overall length of the bus cable depends on which bus you are using.\n- When using the CMB, external analyzers, such as the HP 1630 Logic Analyzer, can provide control signals to other emulator/analyzers on the bus. With the IMB, analyzers outside the card cage can only receive signals from the bus, not supply signals to the bus.\n- When using the CMB, an analyzer outside the card cage can cause all emulators on the bus to break to their monitor programs. No such capability is offered on the IMB.\nThe CMB and IMB interconnect certain measurement functions so that activity in all of the participating emulators and analyzers can respond to the same control sources. Coordination offered when using the measurement buses includes:\n\n- Synchronized runs of your target program.\n- All analyzers accept the present state as their trigger when a designated analyzer recognizes its trigger event.\n- One emulator on the bus can stop execution of your target program and break to its monitor program when an event is recognized by an analyzer in a different emulator/analyzer set.\n\n**IMB Information**\n\nThe IMB is a 6-conductor cable that interconnects control signals for emulation and analysis through a special IMB plug at the top of all control boards. The coordinating signals on the IMB are described in the following paragraphs:\n\n**Master Enable**\n\nAll analyzers that are to participate in a coordinated measurement receive this signal. This is the execute/continue signal. When it is true, it enables all analyzers that receive it. When it is false, it disables the analyzers. There can only be one driver for the master enable line: either the execute/continue function (the default configuration), or one of the analyzers assigned to participate in the measurement.\n\nThe purpose of the master enable line is to synchronize measurement start in all analyzers. At measurement start (execute key pressed or true state from designated master enable driver), each analyzer tries to start. The master enable line remains false until all analyzers are ready. Then it switches true, releasing all analyzers to start together.\n\nWhen the master enable line is driven by one of the analyzers, it can alternate between true and false during a measurement to exclude unwanted activity from the coordinated measurement. When an analyzer receives this line from another analyzer, all of its analysis functions are disabled during disable periods.\n\n**7-2 Coordinated Measurements Through CMB And IMB**\n**Emulation_start** \nThe purpose of the emulation_start command is to couple an analyzer into a measurement with other emulators and analyzers that do not have, or are not using, any other IMB lines. When the analyzer you coupled is driving the emulation_start line or driving/receiving any other IMB line, it will start before any emulators in the coordinated measurement.\n\n**Trigger enable** \nThe trigger-enable line carries a logic level. When it is true, it enables the receiving analyzers to recognize their internal triggers, if they occur. When it is false, it disables trigger recognition in the receiving analyzers. The trigger enable line can alternate between true and false during a measurement to allow the controlling analyzer to window the activity where trigger recognition can occur. If no analyzer is designated to drive this line, it will default to the true state.\n\n**Trigger** \nThe trigger line carries a transition from false to true. When the trigger line switches from false to true during a measurement, it remains true for the rest of the measurement. An analyzer can drive the trigger transition when it recognizes its trigger specification. An analyzer can receive the trigger transition from another analyzer on the bus. A receiving analyzer will identify the present state as its trigger state when the trigger line switches true. The trigger line can have more than one designated driver. When more than one driver is designated, the first driver to recognize its trigger becomes the trigger source for the measurement in process.\n\n**Storage Enable** \nThe storage enable line carries a logic level. An analyzer can drive this line, controlling when the receiving analyzers can store information. If an analyzer receives this line, it will store states that meet its store specification when this line is true. The analyzer that controls this line can switch it between true and false during a measurement to window activity that can be stored. If no analyzer is designated to drive this line, it defaults to the true state.\n\n**Delay Clock** \nThe delay clock line carries a stream of clock pulses. Certain analyzers can generate this stream of clocks. Other analyzers (such as timing analyzers) can receive these clocks and use them to count delays when taking their measurements (delay by numbers of clocks).\n\n*Coordinated Measurements Through CMB And IMB 7-3*\nCMB Information\n\nThe CMB consists of three bi-directional signal lines. These lines are available through a connector on the exterior of the card cage. The signals that coordinate measurements on the CMB are:\n\n- CMB Trigger line\n- READY line\n- EXECUTE line\n\nEmulators and analyzers that coordinate measurements over the CMB offer commands you can use to:\n\n- Enable and disable interaction on the READY line.\n- Allow EXECUTE to start running your target program in emulation.\n- Drive or received the CMB trigger line by any unit on the CMB.\n\nNote\n\nThe CMB trigger line also goes true briefly following receipt of an EXECUTE signal. Because of the short-duration true state on the CMB trigger line, do not use it to trigger external instruments if the EXECUTE function is also being used.\n\nCMB Trigger Line\n\nThe CMB Trigger line is low true. It can be used directly as a break source to the emulator, or it can be used indirectly as a break source through the internal trigger lines. When used as a break source, the driving function must be cleared before the emulator can resume running.\n\nCMB READY Line\n\nThe CMB READY line is high true. It is open collector and performs ANDing of the ready state of all enabled emulators on the CMB. Each emulator on the CMB releases this line when it is ready to run. This line goes true when all enabled emulators are ready to run, providing a synchronized start. When CMB is\n\n7-4 Coordinated Measurements Through CMB And IMB\nenabled, each emulator is required to break if CMB READY goes false, and will wait for CMB READY to go true before returning to the run state. When an enabled emulator breaks to the monitor, it will drive CMB READY false. The emulator that drives CMB READY false holds it false until it is ready to resume running the target program. When the emulator is reset, it also drives CMB READY false.\n\nCMB EXECUTE Line\n\nThe CMB EXECUTE line is low true. Any emulator or analyzer on the CMB can drive this line. It serves as a global interrupt, and is accepted by analyzers and emulators.\n\nBNC Internal-To-External Connection\n\nThe BNC input on the card cage can either supply the analyzer trigger to external equipment, or receive an analyzer arm, an analyzer trigger, or an emulator break request from external equipment.\n\nCMB Interaction With External Analyzers\n\nYou can make measurements that include an external logic analyzer or oscilloscope connected to the CMB bus through a connector on the card cage (some card cages use BNC connectors, others have special connectors for this purpose). The lines on the CMB are bi-directional so you can use them to drive an external device, or receive arming or triggering signals from an external device.\n\nThrough command choices, you can specify which of the emulators and analyzers will drive and receive the trigger signals. This allows flexible interconnections between the emulation and analysis systems installed in the card cage and analyzers outside the card cage that are connected through CMB or BNC ports.\n7-6 Coordinated Measurements Through CMB And IMB\nAn analyzer is an instrument that captures signal activity synchronously with a clock signal. An analyzer can display a history of the signal activity over the period of the measurement. If the period of the measurement was greater than the capacity of the analyzer memory, the most recent signal activity will be shown. There are several types of analyzers used with emulators. These types are described below.\n\n**Types Of Analyzers**\n\n**Emulation Bus Analyzer**\n\nAn emulation bus analyzer captures bus cycle information from the address, data, and status buses of an emulation processor in sync with the emulation processor clock. The states captured show a history of activity on the emulation processor bus. This history can be presented as a list of states expressed in numerical values (hexadecimal, binary, etc), or it can be inverse assembled into a list similar to an assembly language program listing.\n\n**External Analyzer**\n\nAn external analyzer captures activity on signal nodes that are external to the buses of the emulation processor. To use an external analyzer, you connect the external analyzer probe cable to signal nodes in your target system. The external analyzer probe cable is a set of signal lines, each with an individual probe connection. External analyzers can make state measurements and/or timing measurements, as described below.\n**External State Analyzer**\n\nAn external state analyzer can use the same clock as the emulation bus analyzer so that the states at the signal nodes can correspond to the states captured by the emulation bus analyzer.\n\n**External Timing Analyzer**\n\nAn external timing analyzer can record logic levels at the nodes you selected at each occurrence of a sampling clock within the analyzer. You select a clock rate that provides the measurement resolution desired. The clock rate must be faster than the data rate to prevent the analyzer from detecting a glitch on the occurrence of a single data bit. (A glitch is both a positive and a negative transition occurring between any two sampling clocks.)\n\n**Basis Branch Analyzer**\n\nThis is a testing method that determines the extent to which branches are executed during runs of your target program. The measurement tells you if each possible path of the branch was executed during the test. You can use this type of analyzer to ensure that your tests do a thorough job of program testing. This analyzer identifies branches that are not completely tested so you can write new tests to verify paths not taken. HP offers its HP Branch Validator to make basis branch analysis tests.\n\n**Coverage Analyzer**\n\nA coverage analyzer measures the percent of memory accessed by a target program. A coverage analyzer reserves one bit in its memory for each byte of HP emulation memory. When a byte of emulation memory is accessed (written to or read from), the corresponding bit in the memory of the coverage analyzer is set. After a test, the coverage analyzer can show you the memory locations that were accessed.\n\n**Software Performance Analyzer**\n\nA software performance analyzer measures performance characteristics of code modules. You can use software performance measurements to compare code modules with each other to see how much execution time and state activity each one uses in your program. These measurements help you identify code modules that need to have their performance optimized.\nActivity measurements record information about memory activity and program activity to tell how much execution time is spent and how many states are executed by each function and variable defined in the program under test. Activity measurements are also used to compare these functions and variables with one another to determine their relative use of time and states. Duration measurements record the time spent executing selected functions and procedures. You can use duration measurements to determine the average time it takes to execute a program module, and detect events when the duration of a module is abnormally different from its average duration.\n\n<table>\n<thead>\n<tr>\n<th>Specifications</th>\n<th>Needed To Set Up A State Analyzer</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Analysis</strong></td>\n<td>Analysis functions may include trigger, storage, and count directives. The analyzer can capture a number of states in its memory, depending on the capacity of its memory. These states will include address, data, and conditions of the status bits.</td>\n</tr>\n<tr>\n<td><strong>Trigger</strong></td>\n<td>A trigger is a point of reference within the trace memory. It may be some unique state and you want to see the activity that led up to its occurrence. It may be some starting event and you want to observe the activity that follows after its occurrence. If your measurement is not keyed on the capture of some significant event, specify a trigger of any_state.</td>\n</tr>\n<tr>\n<td><strong>Store</strong></td>\n<td>The store function sets up the analyzer to store states of interest in its trace memory. The default of the store specification (any_state) sets up the analyzer to store every state, regardless of its content. When you are interested in analyzing the activity associated with a particular address range, you can store-qualify just that address range, and the analyzer will store only states executed within that address range. If you want to observe a series of writes to a variable, you can store-qualify write transactions to the address of the variable, and the analyzer will store only those write states.</td>\n</tr>\n<tr>\n<td><strong>Count</strong></td>\n<td>The count function measures periods of time or numbers of state transactions between states stored in memory. You can set up the</td>\n</tr>\n</tbody>\n</table>\nanalyser count function to count occurrences of a selected event during the trace, such as counting how many times a variable is read between each of the writes to the variable during a trace. The analyser can also be set up to count elapsed time, such as counting the time spent executing within a particular function during a run of your target program.\n\n**Special Considerations**\n\nChapter 9 of this manual discusses the way your measurements may be affected by operation of an internal cache (for processors equipped with a cache). Chapter 11 discusses difficulties you may have, and ways to overcome those difficulties, when analyzing the trace lists obtained from processors that prefetch instructions and use an instruction pipeline. Chapter 10 discusses a special measurement that some analyzers can make to help you find the cause of problems that may appear during execution of your target program.\nHow An On-Chip Cache Affects An Analyzer\n\nWhat Is An On-Chip Cache?\n\nAn on-chip cache is an area of memory that is used to store recently used instructions and/or data on a microprocessor. Some microprocessors are equipped with caches for instructions only, while others have caches for both instructions and data. The purpose of an on-chip cache is always the same - to improve efficiency of program execution by the microprocessor.\n\nBy keeping recently used instructions and/or data in an on-chip cache, a microprocessor can access these items if they are used again without having to initiate external bus cycles. When the microprocessor fetches an instruction or accesses some data, it checks to see if that instruction or data is already in the cache, and if it is, the microprocessor loads it from the cache and does not perform any external bus cycles.\n\nHow Does A Cache Affect Analysis?\n\nAn emulation bus analyzer can only trace activity that appears on external processor buses. When the microprocessor is operating with its cache(s) enabled, analysis of processor activity is limited because no bus cycles are performed to fetch items already in the on-chip cache. Therefore, transactions involving the cache will either be incomplete or will not appear at all in trace lists.\nDisabling And Enabling The Cache\n\nUsually, you will want to disable the on-chip cache of a microprocessor when tracing execution of a program. In this way, all of the instructions executed by the microprocessor will be fetched on the processor memory bus and can be captured in the analyzer trace. Typically, emulators built for microprocessors that have on-chip caches will have a selection within the emulation configuration that you can use to disable or enable the cache(s).\n\nSometimes you may want to perform analysis with the cache(s) enabled. This will be the case when you want to measure speed of execution because on-chip caches can greatly increase the speed of execution of some programs.\nPrestore Trace Measurements\n\nThe word \"prestore\" sounds like something is being stored before it happens. Obviously, that's not possible. What's 'prestore\" really mean? Prestore is a measurement mode that lets the analyzer capture the last occurrence of some event every time a new state is stored in the trace memory (you might prestore the last write instruction before data is written to a selected variable). Here’s how prestore works.\n\nTo make a prestore measurement, the trace memory of the analyzer is divided in half. One half of the memory stores states that meet the store qualification. The other half of the memory stores states that meet the prestore qualification.\n\nFigure 10-1 shows imaginary men working inside your analyzer to make prestore measurements. Each state that enters the analyzer\nis examined by Store Man. He looks to see if the state meets the store qualification you set up before the trace began. If the state meets the store qualification, it is stored in the trace memory, as is described later. If the state doesn’t meet the store qualification, the state is passed to Prestore Man. Prestore Man examines the state to see if it meets the prestore qualification. If it does, Prestore Man places the state behind his ear and throws away any state that he had been holding there before. If it doesn’t meet the prestore qualification, he throws the state in the bit bucket.\n\nThis process continues, with Store Man looking at each state, and then passing the state on to Prestore Man. Finally, a state comes in that meets Store Man’s qualification. He places that state in the store memory. When this happens, Prestore Man places the state he has behind his ear into the prestore memory.\n\nEach time Store Man places a state in store memory and Prestore Man places the last state he held behind his ear in prestore memory, then a new measurement begins. If the first state examined by Store Man meets the store qualification, no prestore state will be stored. Therefore, no prestore state will be shown in the trace list preceding it.\n\nWhen the trace is complete and you call for a trace list, the content in store memory and prestore memory are arranged as shown in figure 10-2.\n\n<table>\n<thead>\n<tr>\n<th>TRACe LIST</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PSTORE</td>\n</tr>\n<tr>\n<td>+0001</td>\n</tr>\n<tr>\n<td>PSTORE</td>\n</tr>\n<tr>\n<td>+0002</td>\n</tr>\n<tr>\n<td>PSTORE</td>\n</tr>\n<tr>\n<td>+0003</td>\n</tr>\n</tbody>\n</table>\n\nFigure 10-2. Making A Prestore Trace List\nHow Is A Prestore Trace Useful?\n\nA prestore trace is useful when some error is being made to a point in your program, and there are several possible sources of the error. For example, assume there are several program modules that write to a variable, and sometime during execution of your program, that variable is getting bad data written to it. Using a prestore measurement, you can find out which module is writing the bad data. You can store-qualify writes to the variable. Using prestore, you can capture the instructions that caused those writes to occur.\n\nThe prestore measurement is used to answer such questions as, \"Who is writing to this variable?\", and \"Which modules are calling this module?\"\n\nThe information available in a prestore trace list can also be found by reading a default trace list, but you might have to read many thousands of trace list lines to find the number of transactions of interest that are shown on just one screen of a prestore trace list.\n\nSetting Up The Analyzer To Make A Prestore Trace\n\nWhen you set up the analyzer to make a prestore trace, you store-qualify some event of interest, and then prestore-qualify a related event.\n\nStore Qualification\n\nYou might store-qualify events such as:\n\n1. Store the entry to a selected code module.\n\n2. Store the address of a variable.\n\n3. Store an interrupt request.\n\nSeveral different events can be store-qualified during a single prestore trace. This lets you test for the causes of several different errors in the same trace.\n**Prestore Qualification**\n\nIn the prestore memory, you qualify a kind of action that affects the store-qualified event. This may be:\n\n1. Store calls to a code module.\n\n2. Store fetches of instructions. (These can show which module accessed a variable, or where code was executing when the event was stored).\n\nHere, again, several kinds of transactions can be prestore-qualified during a trace.\n\n**Reading Prestore Trace Lists**\n\nWhen the prestore trace list is displayed, it will be a list of trace memory line numbers, preceded by prestore events. The trace memory line numbers will identify the store-qualified states, and the \"pstore\" lines preceding them will show the last prestore-qualified state that was captured before the stored event.\n\nWith a specification such as \"STORE_ON a= 4000H\", and \"prestore on program read\", you’ll get a trace list that shows all the accesses to address 4000H. Preceding each access to 4000H, the list will show the most recent program read instruction.\n\n```\n+0001 00004000 ............ (last program read before +0002)\npstore ........ ............ (last program read before +0003)\n+0002 00004000 ............ (last program read before +0004)\npstore ........ ............ (last program read before +0005)\n+0003 00004000 ............ (last program read before +0006)\npstore ........ ............ (last program read before +0007)\n```\n\n**Note**\n\nIt’s possible to see a prestore trace list with no \"pstore\" events. Because each state is examined to see if it meets the store qualification first, prestore memory will never save any states if \"prestore\" and \"store\" both have the same qualification (or if prestore has a more specific qualification than store). Make sure your prestore and store qualifications are exclusive.\n\n---\n\n10-4 Prestore Measurement Concepts\nThis chapter discusses the difficulties you encounter when making traces of activity generated by microprocessors that prefetch instructions and use an instruction pipeline. This chapter shows steps you can take to overcome the problems when you are taking a trace, and it shows you how to simplify the task of reading trace lists of processor activity.\n\n**What Is Meant By Prefetching And Pipeline?**\n\nFigure 11-1 shows the instruction pipeline used in a Motorola 68020 microprocessor. While pipelines vary from one processor to another, figure 11-1 can be used to understand the concept.\n\nA processor is said to be prefetching instructions, when it fetches the instructions before it is ready to execute them. A processor will prefetch instructions from the instruction cache if the instructions are resident there and the instruction cache is active, or it will prefetch the instructions from external memory.\n\nA pipeline is made up of two or more stages that store, decode, and execute instructions simultaneously as they move through the pipeline. This increases the performance of the processor because several instructions can be at different stages of the pipeline at any time, but it makes analysis of processor activity difficult. An analyzer captures states from processor buses, and there may be a delay of several cycles between the time an instruction is fetched (the instruction appears on the bus) and the time it is executed (the resulting operand cycles appear on the bus).\nWe are used to reading a trace list that shows an instruction followed by the activity resulting from the execution of that instruction. We don’t see that order in trace lists made from microprocessors that prefetch instructions and use a pipeline. Instead, we may see an instruction fetch, then activity generated by execution of instructions that were fetched earlier, then prefetches of instructions to be executed in the future, and finally, the execution of the instruction of interest (denoted by its operand cycles).\n\nFigure 11-2 shows the difficulty of reading trace lists made from processors that prefetch instructions and use an instruction pipeline. It was made by tracing activity of a Motorola 68020 microprocessor. While addressing schemes, etc., vary from one processor to another, figure 11-2 does demonstrate the difficulty of\n\n11-2 Prefetch and Pipeline\nreading the trace lists. Trace memory line number +0004 contains an instruction. It requires an add to be performed. Notice that the resulting operand cycles of the add instruction are not performed until trace memory line numbers +0007 and +0008. The activity on lines +0005 and +0006 have nothing to do with the instruction on line +0004. They are simply instruction prefetches that were pushed into the pipeline after the instruction on line +0004 was fetched, and before it was executed.\n\n---\n\n**Figure 11-2. Trace List Showing Pipeline And Prefetch**\nUnused Prefetches\n\nSometimes, instructions are prefetched and placed in the pipeline, and never executed at all. For example, this may happen when there is a branch instruction at the end of a function, just before the entry to a new function. When the program nears the end of the function that has the branch instruction, the processor prefetches the entry to the next function (because of its close location in memory). When the branch instruction is executed, the next function is not entered, but instead, execution jumps back to some point specified by the present function. When the processor branches, it flushes the content of its pipeline and begins execution at the \"branch-to\" address.\n\nThe problem the analyzer has with this operation is that it records the fetch of the entry to the new function when it appears on the processor bus. If your trace specification calls for some analyzer response when this entry address appears (trigger, etc.), then the analyzer will react as specified, even though that new function may not be active.\n\nFigure 11-2 also shows an unused prefetch on line +0006. The \"MOVE.L\" instruction was prefetched by the processor and placed in the pipeline, but it was never executed. That’s because the instruction that was prefetched before it was a JSR. When the JSR was executed, it caused the program to jump to a new address and flush the MOVE.L instruction from the pipeline. (Note that the MOVE.L instruction contains asterisks in the trace list because the end of the instruction was not prefetched before the JSR was executed, and the pipeline was flushed.)\n\nCertain HP analyzers are able to perform trace list dequeuing. Dequeued trace lists do not show unused prefetches. They are much easier to read because they show logical processor activity instead of bus cycle executions.\nHow To Avoid Triggering, Enabling, Or Disabling On Unused Prefetches\n\nThe entry address to the next function is always prefetched at the exit of the function immediately before it in memory (assuming no padding exists between the two functions). To avoid triggering a trace or enabling/disabling a measurement window on an unused prefetch of a function-entry address, you can use a specification such as \"trigger_on <functionname> + 6\" in your trace command. The \"+ 6\" specification is enough if you are tracing a Motorola 68020. If tracing a different processor (such as an Intel 80386), you may need to select a different offset. Select a value that ensures that you won't trigger or enable/disable a measurement window on an unused prefetch of the entry to your function. If you use this method for enabling and disabling, you will miss the first few words of the function entry, but these words may only be stack-frame initialization instructions.\n\nThe latest versions of Hewlett-Packard \"C\" Compilers for processors that prefetch instructions have a \"debug\" option that inserts padding between each of the functions (padding is a series of no-op instructions inserted ahead of each function name). The no-ops are prefetched at the end of the preceding function so the specification of \"<functionname> + 6\" is not necessary. When using one of these compilers, you can define your specifications to be met on the address of the function entry, without concern that the function-entry address might appear in an unused prefetch.\n\nThe exit address may also appear in an unused prefetch. If it does, a measurement window you've specified may be ended prematurely, even though the function on which you enabled is still active. For debugging purposes, you may wish to add some no-op instructions (any instructions that do not affect the functional results) at the end of your function, just preceding the exit instruction. In this way, the no-ops will be prefetched instead of the exit instruction, and you will be able to obtain a full-length enable period in your measurement window.\n\nIn an example program used for demonstrating certain Hewlett-Packard emulators and analyzers, there are two places where program instructions named \"rts_fetch = 0\" have been added. These no-op instructions are only activated when the example program is compiled on other than a Hewlett-Packard\ncompiler that offers the debug options. These instructions were placed at the end of the functions to overcome a problem that occurred when the microprocessor prefetched the exit address of the function and caused the analyzer to prematurely end a measurement-enable period. These no-op instructions moved the exit addresses far enough away so that they were no longer prefetched before the nearby branch instructions were executed. Before \"rts_prefetch = 0\" was used, some activity generated during execution of the function was missed because the measurement window that enabled on that function would disable when the exit address appeared in an unused prefetch.\nWhat To Do If Your Emulator Doesn’t Work\n\nThis chapter discusses things you can try if you are having trouble with your emulator.\n\nDebugging The Connection To The Target System\n\nWhen your emulator is connected to a target system, emulator operation is complicated by the hardware of the target system and the probe and cable assembly. The following paragraphs will help you find solutions to problems that may occur when an emulator is connected into your target-system hardware.\n\nHardware Problems\n\nIf you need to place a target-system board assembly on an extender board to gain access to the target processor connector, the extender board may cause problems. With the clock rates of some processors exceeding 20 MHz, and with some processors using burst mode, the delay caused by the extender-board hardware may be too great for proper operation of the target system with the emulator. Try to find a way to access the processor socket without using an extender board.\n\nIf you have circuit components mounted close to your target microprocessor, you may need to use stacked sockets to allow proper connection of the emulation probe. Stacked sockets can affect the impedance and ground pathways at the processor pins, degrading the performance of your target system.\nElectrical Problems\n\nBe careful to design your target system hardware to operate within the timing specifications of the components you are using. Some target systems will operate even when part of their components are operating outside of their timing specifications. In these target systems, the same components may fail to operate once the emulation probe is connected. Timing problems of this sort may appear as improper accesses to emulation memory and target-system memory, as well as failures during DMA cycles.\n\nThe emulator may increase the time required to access memory because of the delays associated with sending a signal through the emulation probe cable, and turning on the cable buffers. If you suspect this may be a problem you are having, consider replacing the memory hardware in your target system with faster hardware that can compensate for this delay.\n\nWire-wrapped prototype hardware in a target system may be difficult to interface with an emulator. This is especially true if that hardware is poorly grounded. The emulation probe uses high-current drivers for its signal lines to maintain the integrity of its signals. These high currents can create voltage pulses within wire-wrapped circuitry; some of these voltage pulses may even exceed the switching thresholds of components in your target system.\n\nSometimes the problem discussed above can be solved by creation of a damping socket (processor socket with resistors connected in some of the critical signal lines). Usually resistor values between 10 and 100 ohms are used. Twenty-two ohms is a good starting value. In many cases, damping sockets have provided great improvements in the way a target system operates with an emulator.\n\nArchitectural Problems\n\nSome target systems fail only in one or two modes when an emulator is connected. These failures may be due to certain target-system circuitry that is only active during these operating modes. Consider the case of a target system that uses a watch-dog timer that must be refreshed periodically or else it will shut down the system. In target systems using circuitry like this, you may solve the problem by simply disabling this kind of circuit during emulation.\nMake Sure The Emulation Configuration Is Correct\n\nAn incorrect configuration file can cause improper operation. Review the entire configuration file and make sure all of the questions are answered correctly for your target system. If you are not sure how to answer a particular question, refer to your emulator user’s guide for details of your configuration file and information about the target system interface. Enter the command \"/more < your_configfile_name> .EA\" to view the entire configuration file, along with its present selections.\n\nTarget systems that can operate with the target processor but not the emulation processor should be able to start with the default configuration file. This is the configuration file that was shipped with your emulator. The default configuration file enables all of the target system signals, maps all memory as target RAM, and specifies that the emulation foreground monitor is not loaded.\n\nIsolate plug-in failures with the default configuration before attempting to use configurations that include emulation memory or an emulation foreground monitor. Once the default configuration works properly, add emulation memory and the foreground monitor, if applicable.\n\nUse The Emulation Bus Analyzer\n\nThe emulation bus analyzer can be used with any configuration without interfering with the emulation processor. It passively monitors each bus cycle that the processor executes. All of the analyzer data can be displayed without disrupting the emulation process. The analyzer can be used to verify the proper operation of the program being executed and the proper operation of the hardware.\n\nWhen debugging hardware failures with the emulation bus analyzer, start with a \"trace TRIGGER_ON a= anystate\" specification before allowing the processor to run. This will capture all bus cycles starting with the reset address. Pay particular attention to the bus size bit and the data field of the first few cycles. The triggering capability of the analyzer can be used to capture conditions that are the result of a failed interface by using the \"trace TRIGGER_ON < failure_condition> \" specification. These\nconditions are usually incorrect code branches or status conditions such as halt or shutdown.\n\nFailures can sometimes be debugged using the trigger of the emulation bus analyzer to drive external test equipment. Set the emulation bus analyzer to trigger on the bus cycle in error. Use the trigger output with timing analyzers or oscilloscopes to monitor the target system. When observing the data, consider delays. The trigger pulse may actually occur between one and two clock cycles after the end of the bus cycle.\n\n---\n\n**Use Status Messages**\n\nThe user’s manual for your emulator has a complete list of status-line messages and the problems that cause them to appear. Status messages such as \"Write to ROM fc= <code> \"\", \"halted\" and \"slow device fc= <code> \" provide address or status information that you can use as a trigger for making a trace with the analyzer.\n\n---\n\n**Run Performance Verification (PV)**\n\nThe service manual for your HP emulator includes instructions for running performance verification on your emulation system. The PV tests will identify failures in the emulation and analysis hardware, if any.\n\n---\n\n12-4 Troubleshooting An Emulator\nIf All Else Fails\n\nIf the emulator is configured properly, and the target program and foreground monitor are loaded, unexplained behavior may still exist. This is frequently due to foreground monitor interaction with the target software and/or hardware.\n\nIn the software category, check that it is appropriate to disable interrupts while in the foreground monitor. Some systems with delta-time-interrupt structures for real-time clocks, operating system functions, etc., will crash if the delta-time-interrupt is not serviced within a preset time limit. The foreground monitor can be customized to enable or disable interrupts, as required.\n\nIt is possible to \"disable\" the normal target system function of the non-maskable interrupt through vector table modifications, and a small amount of additional foreground monitor code.\n\nEnsure that the program being executed is not accidentally overwriting the foreground monitor or vice versa.\n\nObtain a listing of the foreground monitor and the program being executed, and use the analyzer to verify proper operation of both.\n\nSet the analyzer to trigger on the foreground monitor entry address and set the trigger position to the center of the trace. This will allow you to examine CPU activity before and after entry to the foreground monitor. You can observe the stacking activity of the non-maskable interrupt, as well as emulator generated jam cycles. This will enable you to determine if the foreground monitor is being entered properly.\n\nEnsure that the foreground monitor exits and returns to the normal program properly. Set the analyzer to trigger on the foreground monitor exit address, and observe the unstacking process when a return instruction is executed. Be sure that the stack contents are not corrupted, and that the program returns to the expected location.\n12-6 Troubleshooting An Emulator\nGlossary\n\nabsolute file This file contains machine-readable instructions and/or data. The instructions and/or data are stored at absolute addresses. Absolute files are generated by the compiler/assembler/linker. These files are loaded into memory for execution by the target processor.\n\nanalyzer This is an instrument that captures activity of signals synchronously with a clock signal. An emulation bus analyzer captures emulation bus cycle information. An external analyzer captures activity on signals external to the emulator. Refer to Chapter 8 for a discussion of the types of analyzers.\n\narm condition A condition that reflects the state of a signal external to the analyzer. The arm condition can be used in branch or storage qualifiers. External signals can be from another analyzer or an instrument connected to the CMB or BNC.\n\nassembler A program that translates symbolic instructions into object code.\n\nbackground A memory that parallels the emulation processor’s normal address range. Entry to background can only take place under system control, and cannot be reached via a user’s program.\n\nbackground monitor A set of fixed, general-purpose routines that do not occupy processor address space. A background monitor is designed to support several of the test and measurement capabilities of an emulator in a wide variety of applications. Refer to the chapter on Monitor Concepts in this manual.\n\nBNC connector A connector that provides a means for the emulator to drive/receive a trigger signal to/from an external device (such as a logic analyzer, oscilloscope, or HP 64000-UX system).\nbasis branch analysis This is a testing method that determines the extent to which branches are executed during runs of your target program. These tests are performed by HP's Branch Validator.\n\nbreakpoint A point at which emulator execution breaks from the target program and begins executing in the monitor. (See also Hardware Breakpoint and Software Breakpoint.)\n\ncache control Cache control is an emulator capability that can turn on and turn off the cache of the emulation processor. You might want to turn on the cache to determine how fast your target system will run when the cache is enabled. You will want to turn off the cache when you are making measurements with an internal analyzer so that the analyzer will have access to all of the processor activity on the emulation bus.\n\ncode coverage analysis This form of analysis records every access to every address during a run or your program. It is used to find program portions that have not been tested during exhaustive test procedures.\n\ncode segment See executable segment.\n\ncommand files A file containing a sequence of commands to be executed. Command files are discussed in detail in a chapter of this manual.\n\ncompiler A program that translates high-level language source code into object code, or produces an assembly language program with subsequent translation into object code by an assembler. Compilers typically generate a program listing which may list errors displayed during the translation process.\n\nconfiguration file A file in which configuration information is stored. Typically, configuration files can be modified and reloaded to configure instruments (such as an emulator) or programs (such as the PC Interface).\n\ncontext A context is a measurement window above selected measurement parameters. A context can be set up to limit the scope of a single measurement parameter, such as enabling trigger recognition to occur only when interrupts are pending. A context can be set up to limit the entire analyzer, such as allowing the analyzer to trace only during execution of a selected code module.\ncontrol flow transfer Any change in the normal sequential progress of a program. JMP, CALL, RET, IRET, and INT instructions, as well as exceptions and external interrupts, can cause a change in control flow.\n\ncoordinated measurements These are measurements performed by two or more emulators and/or analyzers in which measurement parameters are shared over an interconnecting bus. This is discussed in detail in the chapter titled, \"Intermodule Buses (IMB And CMB).\"\n\ncoprocessor support Some emulators contain an on-board floating-point processor that provides support for custom coprocessors. In those emulators, you can display and modify the content of custom coprocessor registers.\n\ncount The count function measures periods of time or numbers of state transactions between states stored in memory. You can set up the analyzer count function to count occurrences of a selected event during the trace, such as counting how many times a variable is read between each of the writes to the variable during a trace. The analyzer can also be set up to count elapsed time, such as counting the time spent executing within a particular function during a run of your target program.\n\ncoverage analysis A measure of the percentage of memory accessed by a target program. For each byte of emulation memory, there is one bit of analyzer memory, and it is set when that byte is accessed (written to or read from).\n\ncross trigger The situation in which the trigger condition of one analyzer is used to trigger another analyzer. Signals internal to HP emulation/analysis systems can be used to cross trigger between emulation and external analyzers.\n\ndata communications equipment (DCE). A specific RS-232C hardware interface configuration. Typically, DCE is a modem.\n\ndata segment A segment that contains data (other than immediate data) for an executable segment. A data segment is identified by a specific type code in the descriptor of the segment.\ndequeued instructions A set of instructions and executions presented in the order of execution, which is different from the order captured by the emulation bus analyzer.\n\ndownloading The process of transferring absolute files from a host computer into the emulator.\n\nDTE (Data Terminal Equipment) A specific RS-232C hardware interface configuration. Typically, DTE is a terminal or printer.\n\nemulation/analysis system (subsystem) A set of hardware and software capable of performing emulation functions on a target system that uses a particular microprocessor.\n\nemulation bus The emulation bus contains all of the signals on the pins of the emulation microprocessor.\n\nemulation bus analyzer A component in the emulation system that captures the emulation processor’s address, data, and status information.\n\nemulation command scanner This is a function in the monitor. After the monitor is invoked and processor information is stored, the emulation command scanner is executed. Here, the emulator continuously tests to see if a new command has been issued. The new command may be to perform one of the monitor routines or to exit the monitor and return to execution of a target program.\n\nemulation data base (EDB) Data base used during the first ten years (approximately) of production of HP’s emulation and analysis products. This data base maintained a cross reference between symbols defined in source files and the absolute addresses where the related code was placed in memory. The Emulation Data Base (EDB) has been replaced by the Symbol Retrieval Utility (SRU) in HP’s recent emulation and analysis products.\n\nemulation memory This is memory space that resides in your emulator hardware.\n**emulation memory map** The emulation memory map defines the addresses supported by memory hardware during emulation. You set up this map during the emulation-configuration process. In it, you assign hardware memory in your emulator, and/or in your target system, to support ranges of addresses. In this map, you also define the behavior of the memory so that it will act as RAM hardware or ROM hardware to emulate the type of memory you intend to install in your target system when its design is complete.\n\n**emulation processor** The emulation processor is the processor that replaces the target-system processor during an emulation session. The emulation processor is part of the emulation probe.\n\n**emulator** A tool that replaces the processor in your target system. The goal of the emulator is to operate just like the processor it replaces. The emulator gives information about the bus cycle operation of the processor and allows control over target system execution. Using the emulator, you may view contents of processor registers, target system memory, and I/O resources.\n\n**emulator probe** The cable that connects the emulator to the target system microprocessor socket.\n\n**entry point** An executable-segment offset that identifies the starting point for execution, as when the segment is invoked via a gate.\n\n**error message** Any message placed on the screen of your emulator terminal to notify you of a problem (or potential problem) with your emulator setup or most recent command.\n\n**exception** A processor-detected condition that requires software intervention. Many microprocessors communicate exceptions to software by means of the interrupt mechanism.\n\n**emulation bus analysis** The process of capturing states from the emulation bus, using the emulation processor clock. These states are shown in list form. They show the details of the execution of a target program.\nescape sequence (transparent mode) A keyboard input consisting of a special sequence of characters, beginning with the escape character (1C hexadecimal). This sequence is used to access an emulator while in transparent mode. When using multiple emulators and transparent mode to access the different emulators, each one must be given a unique escape character.\n\nexternal analyzer An analyzer that captures activity on signal nodes external to the emulation processor buses.\n\nexternal timing analyzers These analyzers capture timing information by recording the logic levels at selected nodes at each occurrence of an analyzer clock. The clock rate must be selected so that it is faster than the data rate to avoid detecting a glitch on the occurrence of a single data bit.\n\nexternal analyzer probe A set of signal lines that connect the external analyzer to target-system signals.\n\nexternal clock Any clock other than the clock source of the emulator. Typically, the clock of the target system is used as an external clock for emulation tests and measurements.\n\nflag One of several Booleans maintained by the CPU, including arithmetic flags, control flags, and nested task flag.\n\nforeground The directly addressable memory range of the emulation processor.\n\nforeground monitor Foreground monitors are supplied as source files. They are written in the assembly language of the processors they emulate. You can edit foreground monitors to customize them for support of your target system. Before you can use a foreground monitor, you must assemble it and link it and load it in a portion of your emulation memory. Refer to the chapter on monitor concepts in this manual for further discussion of foreground monitors.\n\nfork Temporary diversion from one program or process to start another program or process.\n\nform The part of the PC Interface screen that allows you to enter data for modifying various parameters.\nfunction codes Some emulators support the use of processor function codes. In these emulators, emulation memory can be mapped to any of the functional address spaces (CPU, supervisor or user, program or data, or undefined). Function codes can be used as additional qualifications when referencing memory.\n\nglitch This is the name assigned to the detection of at least one transition in both directions between any two sampling clock pulses during a timing measurement.\n\nguarded Any memory address space that you are not using (whether or not memory hardware is available to support this address space). This identifies address space that should never be accessed by the emulation processor, either for a write or read transaction. Guarded normally identifies non-existent memory space. If the emulation processor ever tries to read from or write to memory space mapped as guarded, the emulator will detect this event and place an error message on the status line of your display. If you are operating your emulator in a mode that allows breaks to the monitor (a mode other than real-time mode) execution will break from the target program and begin executing the monitor program. If you have an internal analyzer, you may be able to trace activity leading up to an attempted access to guarded memory space. (Note that no emulation hardware memory is used to support an address space designated as guarded space.)\n\nhandshaking A process of receiving and/or sending control characters that indicate a device is ready to receive data, that data has been sent, and that data has been accepted.\n\nhardware breakpoint Hardware breakpoints are generated by the emulation bus analyzer when it recognizes a specific state, or any state in a range of states, you specified. To achieve a hardware breakpoint, the emulation bus analyzer uses the non-maskable interrupt signal to force the emulator to transfer execution to its monitor program.\n\nhost computer A computer to which an HP emulator can be connected. A host computer may run interface programs that control the emulator. Host computers may also be used to develop programs to be downloaded into the emulator.\nhost processor The host processor (also called emulation-control processor) is the processor that controls the emulator, and controls the emulation processor during an emulation session.\n\nhybrid foreground/background monitors Refers to an emulation design that allows the use of background and foreground monitor programs together.\n\nin-circuit/out-of-circuit emulation In-circuit emulation is emulation performed with the emulation processor connected into the target system hardware. In this mode, you can use and test the resources of the target system, such as target-system memory and target-system I/O ports. Out-of-circuit emulation is emulation performed with the emulation processor disconnected from the target system hardware. In this mode, you must use the resources of your emulator, such as emulation memory and simulated I/O.\n\nindex The field of a selector that identifies a slot in a descriptor table.\n\ninitialization See hardware/software initialization.\n\ninstruction pipeline This is a set of logic hardware designed to store and decode a series of instructions that are waiting to be executed in a microprocessor.\n\ninstrumentation card cage The hardware frame and power supply built to accept installation of emulation and analysis board assemblies, and to provide interconnections for boards and interconnections for development stations that control the development hardware.\n\nintermodule bus (IMB) The bus connecting two or more HP emulators/analyzers or connecting an HP 64000-UX emulator/analyzer and an HP IMB/CMB Interface to allow coordinated measurements.\n\ninternal analysis (also called emulation bus analysis) An analysis performed by capturing states executed by the emulation processor and appearing on the emulation bus.\n\ninterrupt This can have at least two meanings: (1) the electrical or logical signal that indicates an event has occurred, and (2) the mechanism by which a computer system responds quickly to events that occur at unpredictable times.\n**interrupt handler** A routine that is invoked by the occurrence of an interrupt.\n\n**inverse assembler** A program that translates absolute code captured by an emulation bus analyzer into assembly language mnemonics.\n\n**labels** A label identifies a data input or set of data inputs to be monitored. You might assign a label called ADDRESS to identify all of the lines connected to the processor address bus. Normally, you will define the logic polarity of the data inputs included in a label, and define the logic thresholds of those data inputs. Not all analyzers allow you to define your own labels.\n\n**linker** A program that combines relocatable object modules into an absolute file which can be loaded into the emulator and executed.\n\n**linker map** The linker map identifies code modules that will be loaded into address space that was made available in the emulation memory map.\n\n**load memory** The name of the activity that places a copy of your target program in the memory available in your emulator or your target system, or both.\n\n**locked exit** One of two methods used to leave the PC Interface and return to a host computer operating system. A locked exit command allows you to exit the PC Interface and re-enter later with the current configuration. (See also Unlocked Exit.)\n\n**logging commands** The process of automatically storing each entered command into a file. This file can later be used as a command file. A chapter in this manual discusses the details of command files.\n\n**logical address range** The range of addresses that store the entire program in a system employing memory management. Logical address range is the same as virtual address range.\n\n**logical address space** The amount of virtual memory that a microprocessor is capable of accessing. Virtual memory techniques (for example, using pages or segments to address memory consisting of a limited amount of high-speed physical memory and a large capacity memory device such as a disc) can\nallow a processor to access more memory than permitted by the size of the address bus.\n\n**macros** Custom made commands that represent a sequence of other commands. Entire sequences of commands defined in macros will be automatically executed when you enter the macro name. Macro nesting is permitted; this allows a macro definition to contain other macros.\n\n**maximum clock speed** This is the fastest clock speed that still allows hardware to operate correctly.\n\n**memory management unit** A memory management unit is used to achieve apparently large addressable memory in a system with limited addressable memory. This is done by placing the target program into a large, usually slow, logical (virtual) memory space. As portions of the program are needed for execution by the target processor, the memory management unit of the processor swaps blocks of code from the slower, logical memory space to the faster, physical memory. The processor fetches its instructions and performs its data writes in physical memory space. When all of the physical memory space is filled and additional code is required for execution, blocks from the existing physical memory space are written back out to the logical memory space where they are stored until they are needed again for future executions.\n\n**memory mapping** This is the process of assigning hardware memory to support addresses occupied by software. For a detailed discussion of this process, refer to the memory mapping concepts chapter in this manual.\n\n**memory mapper term** A number assigned to a specific address range in the memory map. Term numbers are consecutive.\n\n**monitor** The monitor is a collection of routines that perform many of the functions needed in an emulator, such as displaying the content of registers or loading code into memory so that the code can be executed during a test. For a detailed discussion of monitors, refer to the monitor concepts chapter in this manual.\n**monitor program** A program executed by the emulation processor that allows the emulation system control to access target system resources. For example, when you enter a command that requires access to target system resources, the system controller writes a command code to a storage area and breaks the execution of the emulation processor from the target program into the monitor. The monitor program then reads the command from the storage area and executes the processor instructions that access the target system. After the target system resources have been accessed, execution returns to the target program.\n\n**multiprocessing** Using more than one CPU to execute a multi-tasking system.\n\n**multi-tasking** The capability to support more than one task either simultaneously (by using more than one CPU) or virtually simultaneously (by multiplexing one CPU among several tasks).\n\n**non-maskable interrupt (NMI)** An external interrupt presented to the NMI pin of a microprocessor. Interrupts presented on the NMI pin cannot be ignored by the microprocessor, regardless of the present conditions of any interrupt masks in force.\n\n**object module format (OMF)** A standard for the structure of object code files.\n\n**offset** The address of a location within a segment, expressed as a quantity to be added to the base address of the segment.\n\n**operating system** Software that controls the execution of computer programs and the flow of data to and from peripheral devices.\n\n**out-of-circuit emulation** See in-circuit/out-of-circuit emulation.\n\n**overlay** (used when creating an emulation memory map) This parameter allows you to map two or more address ranges to the same physical memory hardware. The two or more address ranges can even have different hardware characteristics: one can be RAM and another can be ROM, if desired.\n**parity setting** The configuration of parity switches. Depending on the configuration of the parity output switch and the parity switch, a parity check bit is added to the end of data to make the sum of the total bits even or odd. A parity check is performed after data has been transferred, and is accomplished by testing a unit of the data for either odd or even parity to determine whether an error has occurred in reading, writing, or transmitting the data.\n\n**path** Also referred to as a directory (for example \\users\\projects).\n\n**pass through mode** See transparent mode.\n\n**PC Interface** A program that runs on the HP Vectra and IBM PC/AT compatible computers. This is a friendly interface used to operate an HP 64700-series emulator.\n\n**performance measurements** Performance measurements are taken to help you improve software performance; they involve measurements of program activity and module duration. Activity measurements record information about memory activity and program activity to tell how much execution time is spent and how many states are executed by each function and variable defined in the program under test. Activity measurements are also used to compare these functions and variables with one another to determine their relative use of time and states. Duration measurements record the time spent executing selected functions and procedures. You can use duration measurements to determine the average time it takes to execute a program module, and detect events when the duration of a module is abnormally different from its average duration.\n\n**performance verification (PV)** A program that tests the emulator to determine whether the emulation and analysis hardware is functioning properly.\n\n**physical address** In an 80286 processor, a 24-bit address, such as that used as a base address, capable of encompassing the entire address space of the 80286. In a system using memory management, physical addresses are addresses where the target processor will fetch its code and perform its address reads and writes. See the discussion called \"memory management unit\" in this glossary for further details.\nphysical address space The amount of real address space that a microprocessor is capable of addressing. A processor’s physical address space can be determined by the number of address lines (for example, a microprocessor with 16 address lines has an address space of 2 to the 16th power, or 64K memory locations.\n\nprefetch The ability of a microprocessor to fetch additional opcodes and operands before the current instruction is finished executing.\n\nprestore This is the capture of prestore-qualified states that precede store-qualified states. Prestore measurements are discussed in detail in a chapter of this manual.\n\nprivilege The right to access certain portions of memory or to execute certain processor instructions.\n\nprivilege level (PL) A measure of privilege. In the 80286 architecture, privilege is measured by integers in the range 0-3, where 0 is the most privileged and 3 the least.\n\nprotection A mechanism that limits or prevents access to areas of memory or to instructions.\n\nRAM space Any memory address space assigned to act as Random-Access Memory space during a run of program on your emulator. Emulation RAM space will allow the emulation processor to read from it or write to it.\n\nranging The term used to describe measurements where any value or address within a range of values or addresses will satisfy the specification. A label is assigned to represent the range of values or addresses (for example, RANGE1 can represent 100H through 1FFH). Then a measurement could be specified to be qualified on any address in RANGE1. If address 104H appeared, it would be qualified because it is within the range of RANGE1. Specifically, it would be shown as RANGE1+ 0004 (assuming you specified that values within RANGE1 would be counted beginning with the lowest value and proceeding to the highest value).\nreal-time vs. non-real-time emulation You can operate your emulator in one of two modes: real-time mode, or non-real-time mode. In real-time mode, you can run your target program continuously at full rated processor speed, but all of the emulation features that interfere with target program execution are disabled. In non-real-time mode, execution of your target program may be interrupted at any time, but the full feature set of your emulator is always available.\n\nMany emulator features are implemented by routines in the monitor. Whenever the emulator is running a monitor routine, it is (of course) not executing your program in real time. When using non-real-time mode, breaks to the monitor may be initiated by commands you enter or by conditions detected by the emulator. When using real-time mode, features implemented by monitor routines are not available.\n\nreal-time execution Refers to the emulator configuration in which commands that temporarily interrupt target program execution (for example, display/modify target memory or processor registers) are not allowed.\n\nReal-time mode capabilities Here is a list of features that are typically available in emulators running in real-time mode:\n\n- run\n- some display commands\n- some modify commands\n- specify\n- execute\n- trace\n- load trace\n- stop_trace\nNon-real-time mode capabilities All of the emulation features available in real-time mode are also available in non-real-time mode. Additionally, the following emulation features are also available:\n\n- target memory accesses - display, copy, load, modify, and store.\n- register accesses - display, copy, and modify.\n- software breakpoints - set and reset.\n\nIn order to use the emulation features listed above when you have real-time mode in effect, you must manually stop the real-time execution by breaking into the emulation monitor; use a keyboard \"break\" command, or a software break.\n\nrelocation Changing the physical location of a segment.\n\nremote configuration The configuration in which an HP emulator is directly connected to a host computer via a single port. Commands are entered (typically from an interface program running on the host computer) and absolute code is downloaded into the emulator through that single port.\n\nROM space Any memory address space assigned to act as Read Only Memory space during a run of program in your emulator. Emulation ROM space will allow the emulation processor to read from it, but not write to it. (Note that you can have your emulator load code you've developed into emulation ROM space. This space only acts as ROM hardware when your emulation processor is running your target program.)\n\nRS-232-C A standard serial interface used to connect computers and peripherals.\nsequencer An analyzer state machine that searches for execution of states in a particular sequence. In some analyzers, a sequencer runs continuously during a trace (find state A, then state B, then state C, then state D, then start over and find state A, then ...). In some analyzers, a sequencer simply runs until a trigger is found; it is used to enable trigger recognition (find state A, then state B, then state C, then the trigger state). Normally a sequencer includes a restart term (find state A, then state B, restart at state A if state Z appears, then find state C, then find state D).\n\nsingle step The execution of one microprocessor instruction. Single-stepping the emulator allows you to view program execution one instruction at a time.\n\nsoftkey interface The host computer interface program used in the HP 64000-UX environment. The softkey interface is a friendly interface used to control HP 64700 emulators.\n\nsoftware breakpoint Software breakpoints are accomplished by removing an instruction from memory and placing it in temporary storage, and then installing in its place a trap instruction that transfers execution to the monitor. When the software breakpoint is executed, the original instruction replaced in memory is restored by the emulator. Software breakpoints are used to stop target program execution at a particular point so that you can view the state of the processor or target system, or begin program execution from a preselected point in the target program.\n\nSome processors, like the 680x0 family, can process software breakpoints quite easily. Others, like the Z80, need hardware to assist in this process. One limitation of the software breakpoint is that you must be able to replace the original instruction you removed as soon as the software breakpoint is executed. Therefore, you can’t set a software breakpoint in target ROM, unless you set up your memory map to overlay the target ROM address with emulation memory.\n\nstandalone configuration The configuration in which a data terminal is used to control the HP 64700-series emulator, and the emulator is not connected to a host computer.\n**stderr** An abbreviation for \"standard error output\". Standard error can be directed to various output devices connected to HP ports.\n\n**state/timing analysis** Refer to analyzer.\n\n**status bus** The set of lines that carry information about microprocessor status.\n\n**stdin** An abbreviation for \"standard input\". Standard input is typically defined as your computer keyboard.\n\n**stdout** An abbreviation for \"standard output\". Standard output can be directed to various output devices connected to HP ports.\n\n**store** The store function sets up the analyzer to store states of interest in the trace memory. The default of the store specification (any_state) sets up the analyzer to store every state, regardless of its content. When you are interested in analyzing the activity associated with a particular address range, you can store-qualify just that address range, and the analyzer will store only states executed within that address range. If you want to observe a series of writes to a variable, you can store-qualify write transactions to the address of the variable, and the analyzer will store only those write states.\n\n**step** Refer to single step.\n\n**segment** A variable-length area of contiguous memory addresses not exceeding 64K bytes.\n\n**symbols** Symbols are used to represent values. For example, you may have assigned the symbol LOOP to identify the first instruction in one of your code modules. The emulator will show you an address associated with the symbol LOOP. This is the memory address that stores the first byte of code in the instruction beside your symbol LOOP. Symbols can also be used to identify data values and states found on status buses, if desired.\n**symbol retrieval utility (SRU)** Data base used by the most current HP emulation and analysis products. This data base maintains a cross reference between symbols defined in source files and the absolute addresses where the related code is placed in memory. It replaces the Emulation Data Base (EDB) which was used in earlier HP emulation and analysis products.\n\nThe SRU allows HP 64000-UX emulation software to read several different file formats. With SRU, an emulator can use HP-MRI IEEE-695 format files and get full symbol support. SRU provides symbol information using the data in the object module format (executable) file.\n\nThe IEEE-695 file format provides a sophisticated view of the executable file and its symbols. This view is more appropriate when dealing with symbols in high level languages (such as C and Ada) than when using assembly language.\n\nThe IEEE-695 file format uses symbol relationships that include the concept of modules. Modules (known as packages in the Ada language) reside at the highest level in the symbol hierarchy. For the C language, the IEEE-695 file format will create a module for each C source file. Modules reside at a higher level than source files; a module \"owns\" the source file and any procedures/globals the source file generates.\n\nThis symbol hierarchy can be seen when using IEEE-695 files and accessing and displaying symbols in emulation. A source file is the child of a module symbol. Local symbols are accessed as children of file name symbols or children of modules symbols, depending on the type of local symbol:\n\n- Local symbols that are line numbers are accessed through the file name symbol.\n- Local symbols that are not line numbers are accessed through the module name.\n\nThe most reliable results will be obtained when using syntax that tells the emulator whether the local symbols reside in the module symbol or in the source file symbol.\n**synchronous execution** The execution of multiple emulator/analyzers at the same time (i.e., multiple emulator start/stop).\n\n**syntax** The way in which expressions are structured in command languages (the order of entries in a command line). Syntax rules determine which forms of command language syntax are grammatically acceptable.\n\n**target system memory** This is memory space that resides within your target system hardware.\n\n**target processor** The target processor is the microprocessor that controls execution in your target system. You remove the target processor and replace it with the emulation probe to perform an emulation session.\n\n**target system** The system under development. The intended product of your development efforts.\n\n**terminal interface** The command interface present inside the HP 64700-series emulators that is used when the emulator is connected to a simple data terminal. This interface provides on-line help, command recall, macros, and other features that provide for easy command entry from a terminal.\n\n**timing diagram** A timing diagram presents the trace memory in a waveform display. The diagram may appear as a graphics diagram on high or medium resolution monitors, and as an ASCII character diagram on standard terminals.\n\n**trace** A measurement that collects a series of states. Each state describes the conditions at several points in a system under test. The series of states shows how conditions changed with time at each of the monitored points.\n\n**trace list** The trace list displays the trace memory contents in list format. The trace memory can be displayed in binary, octal, decimal, and hexadecimal formats, along with a time tag which indicates when the samples were captured.\n\n**trace memory** This is the memory that stores states captured during a trace. This memory is read by the analyzer when it composes trace lists.\ntransparency To perform its function properly, the emulator probe must look like the target microprocessor, from the point of view of your target system hardware. The functions, signal quality, signal timing, loading, drive capacity, and any other processor-specific characteristics must be indistinguishable at the plug-in connector. This is called emulator transparency.\n\n- Functional transparency is the ability of the emulator to function the same as the target processor when the emulator is connected to your target system. Total functional transparency means the emulator can execute your program, generate outputs, and respond to inputs in exactly the same way as the target processor.\n\n- Timing transparency refers to the timing relationships between signals on the pins of the emulation probe and signals on the pins of the target processor. The timing relationships of signals at the emulation probe are designed to be equivalent to, or better than, the timing relationships of signals on the target system microprocessor.\n\n- Electrical transparency refers to the electrical characteristics of pins on the emulation probe compared to pins of the actual target processor. These characteristics include rise and fall times, input loading, output drive capacity, and transmission line considerations. The electrical parameters of the emulation probe pins are designed to be equivalent to, or better than those of the target system microprocessor.\n\ntransparent configuration The configuration in which the emulator is connected between a data terminal and a host computer. When the emulator is in the transparent (pass through) mode, the data terminal acts like a normal terminal connected to the computer. In this configuration, you can develop code on the host computer and download absolute code into the emulator for debugging and testing.\n**transparent mode** The emulator mode in which all characters received on one port will be copied to the other port. This mode allows a data terminal (connected to one emulator port) to access a host computer (connected to the other emulator port) through the emulator.\n\n**trigger** A trigger is a point of reference within the trace memory. It specifies when a trace measurement is to be taken. Trigger also refers to the analyzer signal that becomes active when the trigger condition is found.\n\n**uploading** The transfer of emulation or target system memory content to a host computer.\n\n**unlocked exit** One of two methods used to leave the PC Interface and return to a host computer operating system. An unlocked exit command allows you to exit the PC Interface and re-enter later with the default emulation configuration. (See also Locked Exit.)\n\n**viewport** See window.\n\n**virtual address** An address that consists of a selector and an offset value. The selector chooses a descriptor for a segment; the offset provides an index into the selected segment.\n\n**virtual address space** The set of all possible virtual addresses that a task can access, as defined by the GDT and the task’s LDT. The maximum possible virtual address space for one task is one gigabyte.\n\n**virtual memory** A style of memory management that permits the virtual address space to exceed the physical address space of RAM. With the help of processor features, the operating system simulates the virtual address space by using secondary storage to hold the overflow from RAM.\n\n**wait states** Extra microprocessor clock cycles that increase the total time of a bus cycle. Wait states are typically used when slower memory is implemented.\n**window** A specified rectangular area of virtual space shown on the display in which data can be observed. Note that there are also measurement windows. Don’t confuse measurement windows with multiple display areas on a computer terminal. A measurement window is a period in state flow when analyzer tracing is enabled. Analyzer tracing is disabled during the portion of state flow that is outside the window.\n\n**word count** A field of a gate descriptor that specifies the number of words of parameters to be copied from the calling procedure’s stack to the stack of the called procedure.\nIndex\n\nA absolute files, creating to run in emulation, 1-2\n address error, storing additional information, 3-16\n address rounding down problem, 5-11\n address, special consideration for memory map, 5-7\n addresses directed according to emulator map, 5-2\n analysis, general information and types of, 8-1\n analyzer prestore measurements, 10-1\n analyzer problems with prefetch and pipeline, 11-1\n analyzer setup for a prestore measurement, 10-3\n analyzer, CMB connections to external analyzers, 7-5\n analyzer, emulation bus (or internal) analyzers, 1-6\n analyzer, how it is affected by an on-chip cache, 9-1\n analyzer, how to set up for state measurements, 8-3\n 'are_you_there' execution module in monitor, 3-13\n\nB background memory, definition of, 3-3\n background monitor, definition of, 3-4\n background monitor, when it’s best to use, 3-6\n background monitors, advantages and disadvantages of, 3-4\n BNC connection for external access to CMB, 7-5\n break on write to ROM, when you should be careful of this, 5-9\n break, definition of, 3-3\n break, how it is implemented, 3-3\n break, what causes it?, 3-3\n break_entry into the monitor, 3-12\n breaking defined, 1-10\n bus error, storing additional information about the error, 3-16\n bus_error_entry into the monitor, 3-12\n\nC cable, emulation probe, 1-5\n calling your own exception handlers, 3-11\n calls to a module, prestored, 10-3\n CMB, 7-1\n CMB, how it interacts with external analyzers, 7-5\n command files, 6-1\n command files, chaining files, 6-8\n command files, creating with an editor, 6-5\ncommand files, do not make them executable, 6-6\ncommand files, editing of, 6-4\ncommand files, how to create them, 6-4\ncommand files, how to stop their execution, 6-9\ncommand files, how to use shell variables in, 6-9\ncommand files, if calling other command files, 6-5\ncommand files, if commands spawn new processes, 6-5\ncommand files, if lines are longer than the screen width, 6-10\ncommand files, if linker doesn’t work with them, 6-10\ncommand files, if they don’t work, 6-11\ncommand files, naming conventions, 6-8\ncommand files, nesting files, 6-8\ncommand files, three ways to execute them, 6-7\ncommand files, what to edit, 6-6\nconfiguration file to use with new target system, 4-3\nconfiguration file used for the emulator, 4-1\nconfiguration file, items controlled by, 4-2\nconfiguration file, modifying for emulation, 4-2\nconfiguration file, recalling a former configuration question, 4-3\nconfiguration file, viewing the file and its present answers, 4-3\ncoprocessor register, how to display and modify it, 3-14\ncopy routine in monitor, 3-14\n\nD\ndefault emulation configuration file, 4-1\ndelay clock in IMB, 7-3\ndequueuing trace lists, 11-4\n\nE\neditor used with an emulator, 1-2\nemulation bus analyzer, 1-6\nemulation command scanner in the monitor, 3-13\nemulation configuration file, items governed, 4-2\nemulation configuration file, its purpose, 4-1\nemulation configuration file, how to modify it, 4-2\nemulation data-path buffers, 1-9\nemulation memory mapping, 5-1\nemulation probe, 1-5\nemulation probe cable, 1-5\nemulation process, the three steps of, 1-6\nemulation, basics of, 1-1\nemulation_start line in an IMB bus, 7-3\nemulator directs addresses according to its map, 5-2\nemulator interaction with other equipment, 1-13\nemulator, considerations when in-circuit, 1-12\nemulator, list of tasks it does, 1-7\nemulator, physical description of, 1-5\nemulator, what can it do before you have a target system, 1-5\nemulator, what if it doesn’t work, 12-1\nemulator, what is it?, 1-1\nemulator, what is its purpose?, 1-4\nemulators that use MMU, where to load their monitors, 3-19\nERROR: Lower address greater than upper address, 5-11\nexception vector table, 3-9\nexception vectors, how to activate in a monitor, 3-16\nexception_entry into the monitor, 3-13\nexecute line in CMB bus, 7-5\nexit_monitor routine, 3-14\nexternal analyzers, how they interact on CMB, 7-5\n\nF\nfile, emulation configuration, 4-1\nfiles, command files, 6-1\nforeground memory, definition of, 3-3\nforeground monitor routines you may need to modify, 3-14\nforeground monitor, definition of, 3-5\nforeground monitor, mapping considerations, 5-10\nforeground monitor, read before customizing, 3-8\nforeground monitor, when it’s best to use it, 3-7\nforeground monitors, advantages of, 3-5\nforeground monitors, disadvantages of, 3-6\n\nG\nglossary, Glossary-1\nguarded memory managed in the emulation memory map, 5-8\nguarded memory access, what the emulator does with it, 5-10\n\nH\nhow to read prestore trace lists, 10-4\n\nI\nif you have both a background and foreground monitor, 3-6\nIMB (Intermodule bus), 7-1\nin-circuit emulation described, 2-3\nin-circuit emulation, its uses, 2-3\ninteraction with other emulators, etc., 1-13\ninternal analyzer (also called emulation bus analyzer), 1-16\ninterrupts, how to simulate and control, 3-16\nL\n- limiting number of blocks mapped in emulation, 5-2\n- linker doesn’t work with command file, 6-10\n- linker memory mapping for emulation, 5-1\n- linking the monitor program, 3-17\n- logging commands to command files, 6-4\n\nM\n- map entries, deleting, 5-10\n- mapping a foreground monitor, 5-10\n- mapping memory, shown by example, 5-3\n- master enable line in IMB, 7-2\n- measurement buses for coordinated measurement, 7-1\n- memory characterizations, some additional, 5-11\n- memory hardware, making the best selection, 5-7\n- memory map, special considerations, 5-7\n- memory mapping example, 5-3\n- memory mapping for an emulation session, 5-1\n- memory mapping using the overlay feature, 5-10\n- messages, how to create and call your own, 3-16\n- modifying the emulation configuration file, 4-2\n- monitor break function, definition of, 3-3\n- monitor command-execution modules, 3-13\n- monitor definition, 3-1\n- monitor entry points, 3-12\n- monitor program, considerations when linking, 3-17\n- monitor program, considerations when loading, 3-18\n- monitor program, how to determine its size, 3-18\n- monitor program, memory considerations, 3-18\n- monitor program, where to load in memory, 3-18\n- monitor routine’s emulation command scanner, 3-13\n- monitor routines you may want to modify, 3-14\n- monitor routines you should not modify, 3-16\n- monitor running in emulator, what’s happening, 1-10\n- monitor, how emulator detects execution there, 3-13\n- monitor, how to exit properly, 3-14\n- monitor, what it does, 3-2\n- monitors, how they are structured, 3-9\n\nN\n- non-real-time emulation mode, described, 1-11\n\nO\n- out-of-circuit emulation, its uses, 2-1\n- overlay used in mapping memory, 5-10\npipelines, how they complicate analysis, 11-1\nprefetch and pipeline, definitions of, 11-1\nprefetches, how they complicate analysis, 11-1\nprefetches, how to avoid triggering and enabling on, 11-5\nprefetches, how to recognize unused prefetches, 11-4\nprestore, 10-3\nprestore measurements, how they are made, 10-1\nprestore measurements, how they can be useful, 10-3\nprestore qualifications for measurements, 10-4\nprestore states not shown in trace list, 10-2\nprestore trace list with no 'pstore' events, 10-4\nprestore trace list, how to read, 10-4\nprobe and probe cable, emulation, 1-5\nproblem caused by address rounding down, 5-11\nprocessor exception vector table, 3-9\nprogram running in emulator, what's happening when it does, 1-9\nRAM managed in the emulation memory map, 5-8\nread/write target memory, how to modify, 3-14\nready line in CMB, 7-4\nreal-time emulation mode described, 1-11\nrecalling former configuration file questions, 4-3\nreset_entry into the monitor, 3-13\nROM managed in the emulation memory map, 5-8\nscripts, executing automatically at login, 6-9\nshell script lines longer than screen width, 6-10\nshell variables, how to see their present values, 6-10\nsimulated I/O in emulation, 2-2\nsimulated interrupts, how to set them up, 3-16\nsoftware breakpoints, how to modify in real-time mode, 1-11\nsoftware_breakpoint, how it is processed, 3-12\nsoftware_breakpoint_entry into the monitor, 3-12\nstarting new system - which configuration file to use, 4-3\nstatus line messages, how to call your own, 3-16\nstorage enable in IMB, 7-3\nstore qualifications for prestore measurement, 10-3\nT target system doesn't work with emulator, 12-1\n target system, considerations when connecting to emulator, 1-12\n trace list dequing, 11-4\n trace list from a prestore measurement, 10-2\n trace lists, reading prefetches and pipeline, 11-2\n tracing an attempted write to ROM, 5-9\n trigger enable in IMB, 7-3\n trigger in IMB, 7-3\n trigger line in CMB, 7-4\n troubleshooting your emulator, 12-1\n\nU use of command files, 6-2\n user_entry into the monitor, 3-12\n\nV vector table, processor exception, 3-9\n viewing the entire configuration file and its answers, 4-3\n\nW write to ROM, how to trace the event, 5-9\n write to ROM, what happens in the emulator, 5-9\n write/read target memory, how to modify, 3-14\n writes to a variable prestored, 10-3"}}},{"rowIdx":184,"cells":{"id":{"kind":"string","value":"defbf3102ac78e3625535805378c318f56d75d8b"},"text":{"kind":"string","value":"A Framework For Security-Oriented Distributed Programming\n\nsubmitted by\n\nManuel Reinert\n\non May, 9th, 2012\n\nSupervisor\nDr. Matteo Maffei\n\nAdvisor\nKim Pecina\n\nReviewers\nDr. Matteo Maffei\nProf. Dr. Michael Backes\nEidesstattliche Erklärung\n\nIch erkläre hiermit an Eides statt, dass ich die vorliegende Arbeit selbstständig verfasst und keine anderen als die angegebenen Quellen und Hilfsmittel verwendet habe.\n\nStatement in Lieu of an Oath\n\nI hereby confirm that I have written this thesis on my own and that I have not used any other media or materials than the ones referred to in this thesis.\n\nEinverständniserklärung\n\nIch bin damit einverstanden, dass meine (bestandene) Arbeit in beiden Versionen in die Bibliothek der Informatik aufgenommen und damit veröffentlicht wird.\n\nDeclaration of Consent\n\nI agree to make both versions of my thesis (with a passing grade) accessible to the public by having them added to the library of the Computer Science Department.\n\nSaarbrücken, .......................................................... ..........................................................\n(Datum / Date) (Unterschrift / Signature)\nAcknowledgements\n\nThis thesis would not have been possible without the direct and indirect support of many people, some of whom I would sincerely like to thank here.\n\nFirst of all, I am grateful to Matteo Maffei for giving me the possibility to write my thesis about such an interesting research topic and for his supervision of this work.\n\nMy advisor, Kim Pecina, deserves special recognition for his always highly competent and helpful remarks on my work. His patience and calmness in supporting me make him a very good advisor.\n\nAlso I thank Lara Schneider for reviewing my thesis and giving me helpful comments.\n\nI am deeply grateful to my parents for their support throughout my studies and their unshakable belief in me. They always come up with a good advice and make me reflect my actions.\n\nFinally, I thank Angela for always being there and standing by me, be it in joyful times or in depressing times.\nAbstract\n\nDistributed system development challenges designers and cryptographers more and more. When designing distributed systems, the current state-of-the-art approach is to manually specify the whole system as opposed to use automated techniques. This is a complex and error-prone job, in particular if the system has to support sophisticated security properties. An indicator for this fact is the plenty of attacks on existing cryptographic protocols to enforce advanced security properties in distributed systems.\n\nRecent work by Backes, Maffei, and Pecina presents a framework to automatically synthesize distributed systems that are able to enforce authorization policies and preserve user and data privacy. The central idea is to provide the programmer with a high-level declarative language for specifying the system and the intended security properties, abstracting away from cryptographic details. A compiler takes as input such high-level specifications and automatically produces the corresponding cryptographic implementations. They verify that the resulting systems have the desired security properties.\n\nHowever, authorization and privacy are often not enough. Usually principals want to make sure that other users perform certain actions only a limited number of times. For instance, in e-voting schemes, voters are allowed to vote only once. Such linearity constraints are often implicitly present in the system specification but not expressible in frameworks like the one mentioned above. However, achieving linearity constraints while preserving the privacy of users is difficult since linearity constraints require the identification of a principal and her linkability to the actions that should be limited. If a principal does not reveal her identity, this is hard to achieve.\n\nThis thesis presents a new cryptographic mechanism called service-specific pseudonyms that enables system developers to enforce linearity constraints while preserving the privacy of users. We exemplify their usage and show how to cryptographically implement them via a combination of digital signatures and zero-knowledge proofs. Additionally, we show that service-specific pseudonyms can be integrated smoothly into the existing framework and how to generate code automatically.\n\nWe developed a tool that implements the framework of Backes, Maffei, and Pecina as well as service-specific pseudonyms. This tool enables programmers to specify distributed systems in a high level manner. It comprises two APIs: one to generate, modify and verify proofs and signatures which we need to achieve the required security properties. The other API allows for transmitting data on a distributed network. The user can choose between non-anonymous and anonymous communication primitives.\n\nSeveral case studies and a performance evaluation of our implementation conclude this thesis.\n# Contents\n\n1 Introduction ........................................... 5 \n 1.1 Related Work ........................................... 10 \n 1.2 Outline .................................................. 12 \n\n2 Privacy-Aware Proof-Carrying Authorization ........... 13 \n 2.1 PA-PCA Zero-Knowledge Proof Deduction System .......... 13 \n 2.2 Validity of Formulas ...................................... 15 \n 2.3 Privacy-Aware Evidential DKAL .......................... 17 \n 2.4 Cryptographic Implementation ........................... 20 \n 2.4.1 Bilinear Maps ....................................... 20 \n 2.4.2 Commitment Schemes ................................ 20 \n 2.4.3 Groth-Sahai Zero-Knowledge Proof Scheme ........... 21 \n 2.4.4 Re-randomizable Zero-Knowledge Proofs .............. 21 \n 2.4.5 Automorphic Signatures .............................. 23 \n 2.4.6 Zero-Knowledge Proofs of Signatures ................. 24 \n\n3 Service-Specific Pseudonyms ............................ 27 \n 3.1 Overview ................................................. 27 \n 3.2 Deduction Rules ......................................... 28 \n 3.3 Cryptographic Implementation ........................... 29 \n 3.3.1 Properties of Pseudonyms ........................... 30 \n 3.4 Application of Service-specific Pseudonyms ............. 33 \n\n4 Implementation ........................................... 35 \n 4.1 Proof API ................................................. 35 \n 4.1.1 Overview ............................................ 35 \n 4.1.2 Details ............................................... 38 \n 4.1.3 Optimization ......................................... 41 \n 4.2 Sender API ............................................... 42 \n 4.2.1 JXTA ................................................ 42 \n 4.2.2 Tor .................................................. 45 \n 4.2.3 Functionalities ....................................... 46 \n 4.3 Implementation of the Feedback System ................... 50\nChapter 1\n\nIntroduction\n\nMost of today’s online services like Facebook, Google, or e-commerce, are centralized. Centralized here means that the system operator or the service provider are central authorities that manage the system and store all relevant data. Users have to trust the system operators in handling sensitive data confidentially. But even when they seem to handle sensitive data confidentially, it might be the case that they share it in anonymized form with third parties. For instance, Facebook states explicitly that it shares anonymized user data with third parties in order to personalize the advertisements even better [FbP]. However, Narayanan and Shmatikov [NS09] have shown that it is possible to de-anonymize such anonymized networks with small error rates which causes actual threats to privacy.\n\nIn contrast, decentralization takes another approach. There is no central authority since users are equal participants in a distributed system. Furthermore, data is not stored on a server in a centralized manner but locally on each user’s device. Despite the benefits of decentralization in comparison to centralization (no trusted authority, locally stored data, no bottlenecks), designing and implementing distributed systems with sophisticated security properties is very difficult and error-prone, in particular without a trusted authority. An indicator for this is the number of attacks on existing cryptographic protocols [Dou02, CWC05, LKXR05, SNDW06]. These attacks exploit flaws in the protocol design, which allow attackers residing on the network to break the intended security properties by eavesdropping, polluting the network with malicious files, or changing the content of sent messages. Amongst others, a main reason for this problem is that there does not exist any standard for developing distributed systems with advanced security properties.\n\nFor the development of such a standard technique we focus on three security properties: authorization, privacy, and linearity. Authorization is necessary to ensure that only authorized users gain access to protected resources and that only authenticated users take part in the system; privacy is necessary to ensure that users can hide sensitive data and their identity itself; linearity is necessary to be able to limit the number of\n\n---\n\n1Here, anonymized means that all personal data as well as data related to personal information is deleted.\naccesses to certain resources or services. Before we elaborate on these three requirements in more detail we discuss a general design choice: the aim to get interoperable distributed systems.\n\n**Interoperability.** As today’s systems are most often clusters of services, we want the standard to produce only systems that are interoperable. This property makes systems easily extensible, that is, new services can demand resources that are already used by other services, and can hence be aggregated seamlessly. Systems that offer interoperability among components are also called open-ended. For instance, suppose a patient visits the doctor. Upon this visit the patient receives a certificate stating that she has been at the doctor and that she is ill. This certificate can serve for different purposes which we can see as services. Firstly, the patient can use the certificate to tell her employer that she is ill and wants to stay at home. Secondly, she can go to the pharmacy to order a medicine with the certificate. And thirdly, she can ask her health insurance for sick pay as long as she is ill. So this sole certificate is used by three different services and the system providing this feature is open-ended. It would, however, not have been open-ended if the doctor had to give three different certificates to the patient, knowing in advance the services in which such certificates are used.\n\nIn the remainder of this section we discuss existing techniques to enforce authorization and privacy in distributed systems and we show their limitations.\n\n**Authorization.** In order to manage authorization in distributed systems, the idea is to come up with *authorization policies* that protect the access to sensitive data and let a *reference monitor* check if a principal requesting access to certain data (also called *requester*) has sufficient permissions according to the authorization policy or not. Depending on the complexity of the policy and the number of requests, a bottleneck can arise that may cause, for example, a denial of service, since the reference monitor cannot process all incoming requests in a reasonable amount of time. However, it is much easier for the requester to prove upfront that she has sufficient permissions according to the known authorization policy. The most successful framework to enforce authorization in distributed systems based on this idea is the proof-carrying authorization (PCA) framework introduced by Appel and Felten [AF99]. The idea is to formalize the authorization policy logically and to let a requester construct a formal proof which shows that she has sufficient permissions to access the resource protected by the policy. The task of the reference monitor is just to verify if the incoming proof is correct and access is grant depending on these verifications. In order to build authorization policies Appel and Felten use a says-modality, which is illustrated below.\n\n**Example 1.1.** Assume that a university professor Prof wants to get feedback from her students for her course after the lecture period. The professor gives every student Stud a certificate of the form\n\n\\[ \\text{Prof says Reg(Stud, } \\ell \\text{ec)} \\] \n\nstating that the professor Prof says that the student Stud is registered for the course \\( \\ell \\text{ec} \\).\nThere is great consent among cryptographers that the says-modality can be implemented via digital signatures. For instance, the above certificate is implemented as a digital signature of the form\n\n\\[\n\\text{Sign}(\\text{Reg}(\\text{Stud}, \\ellec))_{sk_{Prof}}\n\\]\n\nissued by \\(\\text{Prof}\\) on the (bit-string encoding of the) predicate \\(\\text{Reg}(\\text{Stud}, \\ellec)\\) using the secret signing key \\(sk_{Prof}\\).\n\nUsing this says-modality, system developers can easily specify authorization policies in a logical form. For instance, the professor could state that only registered students may provide feedback for her course.\n\n\\textbf{Example 1.2.} The authorization policy stating this requirement is as follows:\n\n\\[\n\\forall x, y, z. \\text{Prof} \\text{ says } \\text{Reg}(x, y) \\land x \\text{ says } \\text{Feedback}(y, z) \\rightarrow \\text{Rate}(y, z).\n\\] \n\n(1.3)\n\nIn more detail, the policy says that for all students \\(x\\), all courses \\(y\\), and all feedbacks \\(z\\), if the professor admitted student \\(x\\) to the course \\(y\\) and \\(x\\) gives the feedback \\(z\\) for course \\(y\\), then this feedback is counted on the rating board.\n\n\\textbf{Authorization and privacy.} Considering our example from above again, we can observe that the students reveal their identity while providing feedback for the lecture. In typical evaluation systems, this is not desirable since several privacy issues can occur. Their consequences are manifold, for instance, a bias in the grading of exams due to a critical feedback, or a bad impression in the professor’s mind. Students should submit their feedback anonymously in order to protect themselves from such consequences. Since \\textsc{PCA} does not preserve any kind of privacy we cannot use it to fix the problem. The reason why it cannot preserve privacy is that digital signatures themselves always reveal the signed message and the signer. But we want to hide both in the case of the student.\n\nTo summarize, we want to build systems that achieve both authorization and privacy at the same time. These two properties are seemingly conflicting since we have to decide whether a person who does not reveal her identity is authorized to perform a certain action or not.\n\nMaffei and Pecina [MP11] present an extension of \\textsc{PCA}, the privacy-aware proof-carrying authorization (\\textsc{PA-PCA}) framework, that gives the desired properties, that is, authorization and privacy at the same time. They establish privacy on the logical side via existential quantification of sensitive data.\n\n\\textbf{Example 1.3.} Every student participating the course has obtained a certificate of the form \\(\\text{Prof} \\text{ says } \\text{Reg}(\\text{Stud}, \\ellec)\\). \\textsc{PA-PCA} enables the student to create a statement of the form\n\n\\[\n\\exists x. \\text{Prof} \\text{ says } \\text{Reg}(x, \\ellec) \\land x \\text{ says } \\text{Feedback}(\\ellec, gr').\n\\] \n\n(1.4)\n\nThe existential quantification hides the identity of the student while convincing the professor that the student was registered. This statement says that there is some student \\(x\\)\nthat is registered for the course by the professor and that this student $x$ evaluates the course with grade $gr$.\n\nExistential quantification preserves the anonymity of the student in this case. We observe that it is very convenient to express any kind of hiding sensitive information via existential quantification. However, the cryptographic implementation of existential quantification turns out to be very challenging. Digital signatures are not applicable since we cannot hide any information inside a signature and still expect the signature verification to succeed. The idea is to use a powerful combination of digital signatures and zero-knowledge proofs of knowledge\\(^2\\) of such signatures. Considering Example 1.3 again, the implementation is a zero-knowledge proof for a statement of the form\n\n$$\\exists s_1, s_2, x. \\text{ver}_{\\text{sig}}(s_1, \\text{vk}_{\\text{Prof}}, \\text{Reg}(x, \\ell \\text{ec})) \\land \\text{ver}_{\\text{sig}}(s_2, x, \\text{Feedback}(\\ell \\text{ec}, gr)).$$\n\nThis statement expresses that there are two signatures $s_1$ and $s_2$ and a student $x$ such that $x$ knows both signatures, $s_1$ is a signature on the predicate $\\text{Reg}(x, \\ell \\text{ec})$ issued by the professor, and $s_2$ is a signature on the predicate $\\text{Feedback}(\\ell \\text{ec}, gr)$ issued by the student.\n\nIn addition to the framework specification, Backes et al. [BMP12] show how to transform their framework into a tool, which automatically synthesizes distributed systems that protect user privacy, the privacy of data, and allows for authorization constraints. They did, however, not build this tool so far.\n\n**Authorization, privacy, and linearity.** Up to now, our evaluation system preserves the student’s privacy and the professor gets only feedback from students that actually attended the lecture. However, students are not restricted in the number of feedbacks they submit. They can essentially submit as many feedbacks as they like biasing the overall evaluation result. We want students to submit at most one feedback for each course they participated in. PA-PCA is not able to solve this problem. A student, once hidden via existential quantification in a feedback, can never be linked to a student in another feedback even if both students are the same person.\n\nTo the best of our knowledge, so far, there does not exist any general purpose solution to develop open-ended systems that enforce authorization policies, user privacy and the privacy of data, and linearity constraints at the same time.\n\nOur solution builds on the concept of service-specific pseudonyms. They behave like pseudonyms, that is, their owner’s identity is protected, and additionally they provide two service-specific properties: uniqueness, that is, every user can have exactly one pseudonym per service, and unlinkability across different services, that is, it is not possible to link actions performed for different services. However, linking actions within a specific service is possible.\n\n\\(^2\\)A zero-knowledge proof combines two seemingly contradictory properties. First, it is a proof of a statement that cannot be forged, i.e., it is impossible, or at least computationally infeasible, to produce a zero-knowledge proof of a wrong statement. Second, a zero-knowledge proof does not reveal any information besides the bare fact that the statement is valid [GMW91]. A non-interactive zero-knowledge proof is a zero-knowledge protocol consisting of one message sent by the prover to the verifier. A zero-knowledge proof of knowledge additionally ensures that the prover knows the witnesses to the given statement.\nExample 1.4. Let $fb$ be the service for which students want to create service-specific pseudonyms. Additionally to the already existing statement, the student concatenates the following pseudonym predicate for the pseudonym $psd$:\n\n$$SSP(psd, vk_{Stud}, fb).$$\n\nInstead of submitting the former statement the student submits the conjunction of the former one and the above predicate, that is,\n\n$$\\exists x. Prof\\ says\\ Reg(x, lec) \\land x\\ says\\ Feedback(lec, gr) \\land SSP(psd, vk_x, fb).$$\n\nThe professor can now check if $psd$ already submitted an evaluation or not. If she already submitted one, then the feedback is rejected. Otherwise the feedback is counted on the rating board and the professor stores the pseudonym for further checks.\n\nOur Contributions. We present a framework that aids system developers and programmers to conveniently synthesize distributed systems with complex security properties. In contrast to the today’s development practice where a system is developed without verification in mind, this framework takes a different approach: the user provides a declarative high-level specification of the desired system including the security and privacy properties as well as the intended data distribution on the network. The high-level specification language abstracts away all cryptographic details, that is, system designers do not need to have expert knowledge in advanced cryptography; they just have to state the desired properties. Concerning the data distribution, they do not specify how data is distributed but they only specify the start and endpoint in the data transmission. An automated compiler translates the specification into an executable distributed system which is guaranteed to have the specified security and privacy properties and that the sending and receiving of data is managed correctly.\n\nWe extend PA-PCA with the novel concept of service-specific pseudonyms. We show how to use them, how to logically characterize them, and how to implement them using the cryptographic primitives that also PA-PCA uses. Finally, we end up with a powerful framework that is able to provide all three desired security properties, that is, authorization, privacy, and linearity.\n\nThe second contribution of this thesis is the practical implementation of the extended PA-PCA framework as a library in Java. This implementation comprises a programming\nlanguage and two APIs: the programming language Asplada\\(^3\\) is a formal specification language: the programmer specifies the logical policies required to fulfill the desired security and privacy properties of the system. Asplada hides all cryptographic details. Asplada code can be incorporated into Java code. Listing 1.1 depicts the implementation of Example 1.3 in Asplada. A compiler translates this meta-code into valid Java code that interacts with the first API; an API that implements the complete PA-PCA framework extended with service-specific pseudonyms. Developers can also use the API without Asplada; they are able to construct and modify proofs and statements operating on logical representations that hide all cryptographic details. The second API provides the network functionalities. It allows users to send data on a distributed network, anonymously or not.\n\nWe can imagine the implementation on three different levels of abstraction. The lowest level is a cryptographic library that implements zero-knowledge proofs and digital signatures. The level in the middle is our proof API that abstracts completely from cryptographic details except for a few functions. The highest level is Asplada where users do not have to mind about cryptography at all.\n\nIn order to show the feasibility of our implementation and the usability of our APIs we carry out several case studies, show their implementation in our APIs, and present a performance evaluation.\n\n### 1.1 Related Work\n\nThe pioneering works on authentication and access control in distributed systems by Abadi et al. [LABW91, ABLP93] paved the way for several languages and logics managing authorization like Aura [JVM\\(+08\\)] and its confidentiality extension AuraConf [Vau11], PCML\\(_5\\) [ADH10], PCAL [CG09], Binder [DeT02], SecPal [BFG07], and F* [SCF\\(+11\\)]. Except for AuraConf, these logics do not include any kind of privacy in their specification. AuraConf enforces privacy via encryption of sensitive data with the public key of the intended reader. This, however, makes it impossible to realize open-ended applications since we cannot reuse encrypted data for principal \\(A\\) in a protocol where the data should be read by \\(B\\).\n\nAu et al. [AKS12] recently introduced BLACR, a system that allows service providers to blacklist misbehaving users so that they cannot access the system anymore while preserving their privacy. In BLACR, the user generates a private key, which gets authenticated by a group manager. In order to access a service, the user generates a ticket (comparable to our pseudonyms) using her private key. This ticket is revealed to the service provider. Service providers maintain reputation lists, that is, blacklists and whitelists containing pairs of tickets and scores. A score is a positive or negative number describing the severity of the misbehavior and it is assigned to a category that represents the accessed service. In reputation lists, negative scores refer to bad behaviors and positive scores characterize good behaviors. In order to access a service, the user has to prove her\n\n\\(^3\\) Automated synthesis of privacy-, linearity- and authorization-aware distributed applications\n1.1 Related Work\n\nreputation to the service provider via a zero-knowledge proof based on $\\Sigma$-protocols. This proof reveals a score-based property of the tickets that the user has generated with her private key and that belong to the service provider’s list. However, the proof hides the tickets, which is crucial to guarantee unlinkability of user actions. The main differences to our approach are the presence of a group manager and the application scenario: in our system, there is no central authority and every service provider can authenticate users on her own, as opposed to BLACR, where a central authority, the group manager, authenticates users; the purpose of BLACR is the anonymity and unlinkability of actions within and across different services, whereas the purpose of our system is to be linkable within a certain service but to be un linkable across different services in order to enforce linearity constraints. Therefore, our system reveals the pseudonym (corresponding to the ticket in BLACR) and the service provider checks if the plain pseudonym is allowed to access the service or not, as opposed to BLACR, in which a user has to construct a proof for a complete list of tickets, showing to have a certain reputation.\n\nLu et al. [LHL+08] show with Pseudo Trust how to generate pseudonyms to achieve anonymity in peer-to-peer systems. Pseudo Trust creates a pseudonym for an identity, based on a one-way hash function together with a well-formedness proof. Pseudonym systems like [WH09, CPHL07] are based on encryption schemes and involve the presence of a trusted third party. However, in all of these systems, it is possible to generate several pseudonyms at a time (this is also true for [ACK+10]).\n\nSchartner and Schaffer [SS05] generate unique pseudonyms via RSA encryptions without relying on a trusted third party. However, they did not study how to integrate pseudonyms and authorization.\n\nMartucci et al. [MRM11] use a trusted third party only to register the real identity. Upon that, users generate pseudonyms on their own. A pseudonym is unique for a given context and a user is linkable for actions performed within this context. Pseudonyms are generated by means of group signatures. The problem with group signatures is that the trusted authority that creates the initial identity is able to extract the signature creator.\n\nAll of the above pseudonym systems fulfill at least a few of the properties that we require for our framework. But most of them rely on a trusted third party which contradicts our approach to have a fully decentralized system. Building pseudonyms via encryptions destroys the aim to synthesize open-ended applications. Finally, most of these systems enable users to generate multiple pseudonyms which contradicts our constraint for linkability within a certain service.\n\nBrickell et al. [BCC04] presented the concept of direct anonymous attestations that offers a pseudonymous-attestation functionality. Users can authenticate their trusted platform module (TPM) with a service provider via a pseudonym. This pseudonym is derived from the TPM’s secret value and a base value chosen by the service provider. A trusted third party, called issuer, signs the secret value. Our design does not rely on trusted third parties and is more flexible since it does not require any special protocol format. This makes it well-suited for open-ended applications since principals can receive certificates from other principals and combine them to realize sophisticated authorization proofs.\n1.2 Outline\n\nThis thesis is organized as follows: Chapter 2 reviews the privacy-aware proof-carrying authorization framework [MP11, BMP12]. In Chapter 3 we present a new protocol called service-specific pseudonyms that solves linearity issues while preserving authorization and privacy properties. We show in Chapter 4 how we implemented our proof and sender APIs and exemplify their usage. We present further case studies and a performance evaluation in Chapter 5 and we conclude this thesis and give directions for further research in Chapter 6. Appendix A presents the zero-knowledge proof system by Groth and Sahai [GS08] and the digital signature scheme by Abe et al. [AFG+10]. Appendix B gives a detailed description of our high-level-language to interact with the proof API.\nChapter 2\n\nPrivacy-Aware Proof-Carrying Authorization\n\nThis chapter presents the privacy-aware proof-carrying authorization (PA-PCA) framework [MP11, BMP12]. We explain the framework in Section 2.1. Section 2.2 considers the validity of formulas constructed by PA-PCA, Section 2.3 explains the extension of the evidential distributed knowledge authorization logic (E-DKAL) to privacy-aware E-DKAL, and finally, Section 2.4 shows how we cryptographically implement the logical framework for the specification of privacy-aware authorization systems.\n\n2.1 PA-PCA Zero-Knowledge Proof Deduction System\n\nIn this section, we formally introduce the privacy-aware proof-carrying authorization framework. Before detailing its components, we introduce the notation and conventions that we use here and throughout this thesis. We let $M$ range over cryptographic messages like signatures or zero-knowledge proofs, $m, n$ over names, that is, bit strings, $x, y, z$ over variables, $u$ over names and variables, $F$ over authorization formulas, and $E$ over quadratic equations in $\\mathbb{Z}_p$. In Table 2.1, $ap$ ranges over all atomic predicates. Atomic predicates can either be signature verifications $\\text{ver}_{\\text{sig}}(u_s, u_k, F)$ or quadratic equations $E$. A signature verification $\\text{ver}_{\\text{sig}}(\\text{sig}, \\text{vk}, F)$ holds if the verification of sig with vk is true and the message signed in sig was $F$. Zero-knowledge statements, ranged over by $S$, are composed of atomic predicates and logical conjunction, disjunction, and existential quantification thereof.\n\nThe functions $[\\cdot] : M \\mapsto F$ and $[\\cdot]_{zk} : S \\mapsto F$ establish the mapping from cryptographic messages to logical formulas.\n\n**Example 2.1.** Let $M = \\text{Sign}(\\text{Reg}([\\text{Stud}, \\ell \\text{ec}])_{\\text{sk}_{\\text{prof}}})$ be the signature from (1.2). Applying the function $[\\cdot]$ to $M$ yields its logical representation from (1.1):\n\n$[M] = \\text{Prof says RegStud, \\ell \\text{ec}}$.\n\nPA-PCA comes with a zero-knowledge proof deduction system depicted in Table 2.2. This system describes which proofs a principal can create, based on proofs and signatures.\nTable 2.1 Cryptographic evidence of authorization formulas.\n\n\\[\n\\begin{align*}\nap & := \\text{versig}(u_s, u_A, F) \\mid E \\\\\nS & := ap \\mid S_1 \\land S_2 \\mid S_1 \\lor S_2 \\mid \\exists x. S\n\\end{align*}\n\\]\n\n\\[\n[M] = \\begin{cases} \n\\text{vk}_A \\text{ says } F & \\text{if } \\text{versig}(M, \\text{vk}_A, F) \\\\\n[S]_{\\text{zk}} & \\text{if } \\text{verZK}(M, S)\n\\end{cases}\n\\]\n\n\\[\n[S]_{\\text{zk}} = \\begin{cases} \nu_k \\text{ says } F & \\text{if } S = \\text{versig}(u_k, F) \\\\\n[S]_{\\text{zk}} \\land [S']_{\\text{zk}} & \\text{if } S = S_1 \\land S_2 \\\\\n[S]_{\\text{zk}} \\lor [S']_{\\text{zk}} & \\text{if } S = S_1 \\lor S_2 \\\\\n\\exists x. [S']_{\\text{zk}} & \\text{if } S = \\exists x. S'\n\\end{cases}\n\\]\n\nTable 2.2 Rules from the PA-PCA zero-knowledge deduction system.\n\n<table>\n<thead>\n<tr>\n<th>Rule</th>\n<th>Premises</th>\n<th>Conclusion</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>I-S-VER</td>\n<td>( M \\in \\Gamma ) \\text{ versig}(M, \\text{vk}, F)</td>\n<td>( \\Gamma \\vdash_{\\text{S}} \\text{versig}(M, \\text{vk}, F) )</td>\n</tr>\n<tr>\n<td>I-S-&</td>\n<td>( \\Gamma \\vdash_{\\text{S}} S_1 ) ( \\Gamma \\vdash_{\\text{S}} S_2 )</td>\n<td>( \\Gamma \\vdash_{\\text{S}} S_1 \\land S_2 )</td>\n</tr>\n<tr>\n<td>I-S-\\lor-1</td>\n<td>( \\Gamma \\vdash_{\\text{S}} S_1 )</td>\n<td>( \\Gamma \\vdash_{\\text{S}} S )</td>\n</tr>\n<tr>\n<td>I-S-\\lor-2</td>\n<td>( \\Gamma \\vdash_{\\text{S}} S_2 )</td>\n<td>( \\Gamma \\vdash_{\\text{S}} S )</td>\n</tr>\n<tr>\n<td>I-ZK-S</td>\n<td>( \\Gamma \\vdash_{\\text{S}} S ) \\text{ verZK}(M, S)</td>\n<td>( \\Gamma \\vdash_{\\text{ZK}} S )</td>\n</tr>\n<tr>\n<td>I-ZK-\\lor-1</td>\n<td>( \\Gamma \\vdash_{\\text{ZK}} \\exists \\bar{x}, S_1 \\land S_2 )</td>\n<td>( \\Gamma \\vdash_{\\text{ZK}} \\exists \\bar{x}, S_1 \\land S_2 )</td>\n</tr>\n<tr>\n<td>E-ZK-\\lor-2</td>\n<td>( \\Gamma \\vdash_{\\text{ZK}} \\exists \\bar{x}, S )</td>\n<td>( \\Gamma \\vdash_{\\text{ZK}} \\exists \\bar{x}, S_1 \\land S_2 )</td>\n</tr>\n</tbody>\n</table>\n\nThere are two judgments: the \\( \\Gamma \\vdash_{\\text{S}} M \\) judgment is used to compose digital signature verification statements in conjunctive and disjunctive form, while the \\( \\Gamma \\vdash_{\\text{ZK}} S \\) judgment is used to hide values, to combine the zero-knowledge statements in conjunctive form, and to split zero-knowledge statements in conjunctive form apart.\n\nA principal can prove signature verification statements for signatures already contained in \\( \\Gamma \\) using rule I-S-VER. She can combine signature verification statements with conjunction (I-S-\\&) and disjunction (I-S-\\lor-1, I-S-\\lor-2). In order to operate no longer on the signature level she can transform the signatures into zero-knowledge proofs using rule I-ZK-S. She can also project the statements of the zero-knowledge proofs in \\( \\Gamma \\) with rule I-ZK-\\lor and can combine these statements using logical conjunction (I-ZK-\\&) and existential quantification (I-ZK-\\exists). Splitting zero-knowledge conjunctions is also possible via rules E-ZK-\\lor-1 and E-ZK-\\lor-2. Notice that we allow for disjunctions only in the judgment \\( \\Gamma \\vdash_{\\text{S}} M \\) since we are not aware of any technique to build a zero-knowledge proof for a disjunction given only one of the proofs as a witness.\nExample 2.2. In order to derive the formula to access the professor’s rating board in (1.4) we assume that \\textit{Stud} has two signatures \\( M_1 \\) and \\( M_2 \\) (contained in \\( \\Gamma \\)) such that \\( \\text{ver}_{\\text{sig}}(M_1, \\text{vk}_{\\text{Prof}}, \\text{Reg}(\\text{Stud}, \\ell ec)) \\) and \\( \\text{ver}_{\\text{sig}}(M_2, \\text{vk}_{\\text{Stud}}, \\text{Feedback}(\\ell ec, gr)) \\) hold. At first, \\textit{Stud} introduces these two signature verifications using rule I-S-Ver. The rule instantiations are depicted in Table 2.3a and 2.3b. Next, \\textit{Stud} combines these two proofs via I-S-\\& and obtains the statement \\( \\text{Prof says Reg(Stud, \\ell ec)} \\wedge \\text{Stud says Feedback(\\ell ec, gr)} \\). This statement is further transformed into a zero-knowledge statement using rule I-ZK-S. As a last step, \\textit{Stud} existentially quantifies her name and obtains the final statement as given in (1.4) using rule I-ZK-\\exists. The complete deduction is depicted in Table 2.3c.\n\n\\begin{table}[h]\n\\centering\n\\caption{Deduction of the statement \\( \\exists x. \\text{Prof says Reg}(x, \\ell ec) \\wedge x \\text{ says Feedback}(\\ell ec, gr) \\) from (1.4).}\n\\begin{tabular}{ll}\n(a) & \\begin{align*}\n\\text{I-S-VER} & \\quad M_1 \\in \\Gamma \\quad \\text{ver}_{\\text{sig}}(M_1, \\text{vk}_{\\text{Prof}}, \\text{Reg}(\\text{Stud}, \\ell ec)) \\\\\n& \\quad \\Gamma \\vdash \\text{ver}_{\\text{sig}}(M_1, \\text{vk}_{\\text{Prof}}, \\text{Reg}(\\text{Stud}, \\ell ec))\n\\end{align*} \\\\\n(b) & \\begin{align*}\n\\text{I-S-VER} & \\quad M_2 \\in \\Gamma \\quad \\text{ver}_{\\text{sig}}(M_2, \\text{vk}_{\\text{Stud}}, \\text{Feedback}(\\text{Stud}, \\ell ec)) \\\\\n& \\quad \\Gamma \\vdash \\text{ver}_{\\text{sig}}(M_2, \\text{vk}_{\\text{Stud}}, \\text{Feedback}(\\ell ec, gr))\n\\end{align*} \\\\\n(c) & \\begin{align*}\n\\text{I-ZK-S} & \\quad \\Gamma \\vdash \\text{ver}_{\\text{sig}}(M_1, \\text{vk}_{\\text{Prof}}, \\text{Reg}(\\text{Stud}, \\ell ec)) \\wedge \\text{ver}_{\\text{sig}}(M_2, \\text{vk}_{\\text{Stud}}, \\text{Feedback}(\\ell ec, gr)) \\\\\n\\text{I-ZK-\\exists} & \\quad \\Gamma \\vdash \\text{ZK} \\exists x. \\text{ver}_{\\text{sig}}(M_1, \\text{vk}_{\\text{Prof}}, \\text{Reg}(x, \\ell ec)) \\wedge \\text{ver}_{\\text{sig}}(M_2, \\text{vk}_{x}, \\text{Feedback}(\\ell ec, gr))\n\\end{align*}\n\\end{tabular}\n\\end{table}\n\n2.2 Validity of Formulas\n\nWe use the rules depicted in Table 2.4 to establish the binding between cryptographic objects and their logical interpretation. Using Ver-Sig, we can prove judgments of the form \\( \\text{vk}_A \\text{ says } F \\) from a signature \\( M \\) on \\( F \\) that successfully verifies using \\( \\text{vk}_A \\). In particular, every signature generated by an honest principal can be verified correctly using this rule.\n\nBefore we explain the rule Ver-ZK, we describe one possible problem of the structure of zero-knowledge statements. The next example shows that not all zero-knowledge statements that we can deduce using the system are meaningful.\n\nExample 2.3. Suppose that a principal receives a proof of the following statement:\n\n\\( \\exists x_m, x_p. \\text{ver}_{\\text{sig}}(x_m, x_p, \\text{Reg}(\\text{Stud}, \\ell ec)). \\) \\hspace{1cm} (2.1)\n\nAt first sight, we would believe that the predicate \\( \\exists x_p. x_p \\text{ says Reg(Stud, \\ell ec)} \\) holds. However, neither the principal creating this signature is revealed, nor is there any proof\nthat \\( x_p \\) is a principal of the system. It is even possible that this proof was created by an attacker that picked a fresh key-pair.\n\nTo overcome this issue we introduce the notion of trustworthy keys. We assume that principals sign only honest verification keys, that is, keys belonging to principals of the system. We call a key \\( \\text{vk} \\) trustworthy if either \\( \\text{vk} \\) is revealed and known to belong to a principal of the system or is signed by a trustworthy key of the system. This notion in mind, we can directly conclude that \\( x_p \\) in (2.1) is not trustworthy whereas \\( x \\) in (1.4) is trustworthy since it is signed by \\( \\text{Prof} \\) who is a well-known principal of the system.\n\nDue to this fact we allow for introducing zero-knowledge statements into the system (cf. rule I-ZK-Ver) only if the statement \\( S \\) is well-formed. Informally, a statement is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\n\nWe do not know which of the disjuncts is true. Therefore, this statement should not be well-formed. In order to fix this problem, we consider formulas in disjunctive normal form; we say that a formula is well-formed if every key is trustworthy. However, disjunction is a problem when defining well-formedness. Consider the proof\n\n\\[ \\exists x_p, x_m. \\text{ver}_{\\text{sig}}(x_m, x_p, F) \\lor \\text{ver}_{\\text{sig}}(x_m, \\text{Stud}, F). \\]\nstatements as explained above would succeed without any problem. Hence, we would believe that such statements are correct although they are not. To illustrate the usage of this rule we derive the validity of the zero-knowledge proof statement constructed in Table 2.3c as follows:\n\n\\[\n\\frac{\\Gamma \\vdash F}{\\Gamma \\vdash \\exists x. \\text{ver} \\text{sig}(M, vk, \\text{Reg}(x, \\ell ec)) \\land \\text{ver} \\text{sig}(M, vk, \\text{Feedback}(\\ell ec, gr))}\n\\]\n\n### 2.3 Privacy-Aware Evidential DKAL\n\n**E-DKAL.** The evidential distributed knowledge authorization logic (E-DKAL) is based on infor logic which addresses the notion of information rather than the validity of formulas. This is a fundamental difference to classical logics. E-DKAL handles information distribution among principals and decides, based on the received information, if access is granted or not. E-DKAL incorporates the so called knows-modality. It expresses which information a certain principal has at disposal. A principal can use information that she knows to deduce more information. Table 2.5 presents selected rules from E-DKAL. As before, \\( \\Gamma \\) denotes a database storing all information that a principal has collected.\n\nRule **Ensue** says that if a principal knows an environment \\( \\Gamma \\) and she can deduce \\( F \\) using information in \\( \\Gamma \\) then she also knows \\( F \\). **P-A** says that if a principal asserts \\( (A : F) \\) some formula \\( F \\), then she knows this formula. **P-S** is used to establish the binding between a signature \\( M \\) and its corresponding logical representation \\( vk_A \\text{ says } F \\): a principal can assert an atomic predicate by writing \\( A : vk_A \\text{ says } F \\); this together with the signature verification, that binds a signature \\( M \\) to this atomic predicate, yields the knowledge of the verified signature \\( M \\). Knowledge can also be combined via **Msg-\\( \\cup \\)**. To wrap up, whenever a principal wants to create a signature signed with her signing key or wants to introduce a formula, she can do so via assertions.\n\nRule **COMM-J** synchronizes the communication between two principals \\( B \\) and \\( A \\) by means of the two communication assertions\n\n\\[\n\\begin{align*}\n\\text{if } F_B & \\text{ then } B \\text{ sends } F \\text{ to } p \\\\\n\\text{if } F_A & \\text{ then } A \\text{ receives } F' \\text{ from } q\n\\end{align*}\n\\]\nTable 2.6 Core Rules of Privacy-aware Evidential DKAL.\n\n<table>\n<thead>\n<tr>\n<th>Rule</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>P-ZK</td>\n<td>$A$ knows $\\Gamma \\vdash_{ZK} S$ $\\text{ver}_{ZK}(M, S)$ then $A$ knows $M$</td>\n</tr>\n<tr>\n<td>Comm-A</td>\n<td>if $F_B$ then $? \\text{ sends } F$ to $p$</td>\n</tr>\n<tr>\n<td></td>\n<td>if $F_A$ then $A \\text{ receives } F'$ from $?$</td>\n</tr>\n</tbody>\n</table>\n\nIn order to use this rule, $B$ must be aware of an instance of $A$’s precondition $F_A$, that is, the substitution $\\eta$ applied to $F_A (F_A \\eta)$, and $A$ must know an instance of $B$’s condition $F_B$, that is, $F_B \\theta$ for some $\\theta$ and $\\eta$. Additionally, $B$ must know to whom he sends his information, that is, it must hold that $p \\eta = A$ and also $A$ must know whom she receives information from, that is, $q \\theta = B$. Furthermore, $[M] = F$ must hold, that is, $B$ has to know the cryptographic evidence $M$ for the formula $F$ that he sends and $A$’s received formula $F'$ must correspond to this $F$ via $\\theta$, that is, $F' \\theta = F$. When this rule is fired, $A$ knows $M$, the cryptographic evidence for $F$. Whenever the condition on which the assertions are fired ($F_A$ and $F_B$) are true, we omit them and simply write $B$ sends $F$ to $p$ and $A$ receives $F'$ from $q$.\n\nExample 2.7. Consider again our feedback example. The professor starts by providing the student with a registration certificate. So we use rule P-S. The professor keeps the assertion $\\text{Prof} : \\text{vk}_{\\text{Prof}} \\text{says Reg}(\\text{Stud}, \\ell ec)$ and a signature on $\\text{Reg}(\\text{Stud}, \\ell ec)$ issued by $\\text{Prof}$. Then $\\text{Prof}$ knows $M_1$. To visualize this we have a look at the rule instantiation:\n\n$$\\text{P-S} \\quad \\text{Prof} : \\text{vk}_{\\text{Prof}} \\text{says Reg}(\\text{Stud}, \\ell ec) \\quad \\text{ver}_{\\text{sig}}(M_1, \\text{vk}_{\\text{Prof}}, \\text{Reg}(\\text{Stud}, \\ell ec)) \\quad \\text{Prof} \\text{ knows } M_1.$$ (2.2)\n\nIn order to share this signature with the student we have two communication assertions\n\n$$\\text{Prof} \\text{ sends } \\text{Prof} \\text{ says } \\text{Reg}(\\text{Stud}, \\ell ec) \\text{ to } \\text{Stud}.$$ (2.3)\n\nand\n\n$$\\text{Stud} \\text{ receives } \\text{Prof} \\text{ says } \\text{Reg}(\\text{Stud}, \\ell ec) \\text{ from } \\text{Prof}.$$ (2.4)\n\nTogether with the knowledge that $\\text{Prof}$ knows $M_1$ from (2.2) we can deduce that $\\text{Stud}$ knows $M_1$ using Comm-J:\n\n$$\\text{Comm-J} \\quad (2.3) \\quad (2.4) \\quad (2.2) \\quad \\text{Stud} \\text{ knows } M_1.$$ (2.5)\n\nNote that both substitutions $\\eta$ and $\\theta$ are the empty substitutions. Now $\\text{Stud}$ can use the new knowledge to construct her zero-knowledge proof for the feedback (cf. Table 2.3).\nPrivacy-aware E-DKAL. So far, E-DKAL is not aware of privacy. One of the reasons is the rule Comm-J because therein, the receiver always knows who the sender is. However, when the sender existentially quantifies her name in the sent statement then she does not want the receiver to know her identity. [BMP12] extend E-DKAL with two rules which solve this problem.\n\nThese two rules are depicted in Table 2.6. Intuitively, P-ZK establishes the binding between zero-knowledge proofs and their corresponding logical representations; it says that if A knows a store Γ, A can prove S from Γ in the PA-PCA deduction system, and the zero-knowledge verification $\\text{ver}_{\\text{ZK}}(M, S)$ holds for the zero-knowledge proof M, then A knows M. The anonymous communication rule Comm-A is analogous to the rule Comm-J with the difference that the receiver does not know the sender. The anonymity is established by replacing the sender’s identity in the assertions with a question mark.\n\nExample 2.8. We are ready to give the full deduction of our feedback example. In order to do that, we need a few statements:\n\n$S_1 = \\exists x. \\text{Prof says } \\text{Reg}(x, \\ell_{ec}) \\land x \\text{ says } \\text{Feedback}(\\ell_{ec}, gr)$\n\n? sends $S_1$ to Prof \\hspace{1cm} (2.6)\n\nProf receives $S_1$ from ? \\hspace{1cm} (2.7)\n\nStud : Stud says Feedback($\\ell_{ec}, gr$) \\hspace{1cm} (2.8)\n\n$\\text{ver}_{\\text{sig}}(M_2, \\text{vkStud}, \\text{Feedback}(\\ell_{ec}, gr))$. \\hspace{1cm} (2.9)\n\nTable 2.7 depicts this deduction. Stud uses rule P-ZK to derive the knowledge of $M_{zk}$ – the cryptographic evidence for $S_1$ – from the previous reception of $M_1$ (cf. (2.5)), the knowledge of $M_2$ which she can establish on her own with P-S using the signature assertion (2.8) and the signature verification (2.9), and the zero-knowledge verification of $M_{zk}$ for the statement $S_1$ which was derived in Table 2.3. After deriving the knowledge of $M_{zk}$ the corresponding zero-knowledge statement $S_1$ is sent to the professor anonymously using rule Comm-A with the communication assertions (2.6) and (2.7).\n\nIt is worthwhile mentioning that the interaction between privacy-aware E-DKAL and the zero-knowledge deduction system is established as follows: every statement provable in the zero-knowledge deduction system can be introduced into privacy-aware E-DKAL using the P-ZK rule. Γ is filled with cryptographic messages a principal knows, deduced by Ensue.\n2.4 Cryptographic Implementation\n\nIn this section we present the zero-knowledge proof system by Groth and Sahai [GS08] and the digital signature scheme by Abe et al. [AFG¹⁰].\n\nMore specifically, after we have presented the necessary notions like bilinear maps (cf. Section 2.4.1) and commitment schemes (cf. Section 2.4.2), we show how to construct zero-knowledge proofs for different kinds of equations in the Groth-Sahai proof scheme (cf. Section 2.4.3). Section 2.4.4 elaborates the fact that Groth-Sahai proofs are re-randomizable [BCC⁺⁰⁹] and explains the benefits for our framework.\n\nIn Section 2.4.5 we present the digital signature scheme by Abe et al. [AFG⁺¹⁰]. They define the notion of automorphic signatures. We use these kind of signatures in our implementation because they enable users to sign verification keys. This property is crucial in order to implement the idea of trustworthy keys.\n\nFinally, in Section 2.4.6 we explain how the two schemes, the Groth-Sahai and the digital signature scheme, can be combined to prove the knowledge of signatures. We use the resulting proofs to implement the PA-PCA framework since we can deploy existential quantification and all other necessary operations on them.\n\n2.4.1 Bilinear Maps\n\nDefinition 2.9 (Bilinear Map). Let $G_1, G_2$ and $G_T$ be cyclic groups of order $n$. Then $e : G_1 \\times G_2 \\to G_T$ is a bilinear map if the following holds for all $a, b \\in \\mathbb{Z}_n$, $X \\in G_1$ and $Y \\in G_2$:\n\n- $e$ is bilinear, that is, $e(aX, bY) = e(aX, Y)^b = e(X, bY)^a = e(X, Y)^{ab}$.\n- $e$ is non-degenerate, that is, if $G$ generates $G_1$ and $H$ generates $G_2$ then $e(G, H)$ generates $G_T$.\n\nIn the following sections we will use an algorithm SetupBM that generates on input $1^k$ (a security parameter) the tuple $(n, G_1, G_2, G_T, e, G, H)$ where $n$ is the order of the groups $G_1, G_2, G_T$, $e$ is the bilinear map, and $G$ and $H$ are the generators of $G_1$ and $G_2$, respectively.\n\n2.4.2 Commitment Schemes\n\nIntuitively, a commitment scheme can do the following: assume that two persons are sitting down opposite each other at a table and one of them writes a message, packs it into an envelope, and seals this envelope before she puts it on the table. The other person can not open the envelope until the sealer allows for opening it. More formally, in a cryptographic commitment scheme, a principal can commit to a value $x$ (corresponding to the message) with randomness $r$. This algorithm produces a commitment $c$ (corresponding to the envelope) which the principal can send to another principal. At a given time, the principal that created the commitment can decide to open it by sending the message $x$ together with the randomness $r$. We call $x$ also the witness and $(x, r)$ also the opening\ninformation in the remainder of this thesis. The principal receiving the commitment can then recompute $c$ from the opening information to check if the commitment corresponds.\n\nIntuitively, a commitment scheme can be hiding, that is, once sealed, the envelope cannot be opened until the sealer allows to, and it can be binding, that is, once sealed, the envelope’s content cannot be changed. More formally, hiding means that a verifier in possession of $c$ cannot gain information about $x$, and binding means that $c$ can only be opened with a unique $x$ and $r$. We refer to [TPL+08] for a formal definition.\n\nHere and throughout the rest of this thesis we denote by $C_x$ the commitment to $x$ and by $\\| C \\|$ the value committed to in $C$.\n\n### 2.4.3 Groth-Sahai Zero-Knowledge Proof Scheme\n\nWe give a brief introduction to the Groth-Sahai [GS08] scheme. Appendix A.1 provides a complete explanation of proof construction and verification together with a correctness proof for the construction.\n\n**Zero-knowledge.** We do not define non-interactive zero-knowledge proofs of knowledge formally since it is only important to know the idea behind this notion. Informally, a non-interactive zero-knowledge proof of knowledge has to fulfill the following requirements: if the proven statement is true, the principal verifying the proof will be convinced of this fact. If the statement is false, a principal verifying the proof will not be convinced of the opposite except with a small probability. If the statement is true, the proof reveals no more than this bare information. As we deal with proofs of knowledge, we require in addition to the previous properties that the one creating the proof also knows the witnesses.\n\nLet $gk = (p, G_1, G_2, G_T, e, G, H)$ be a setup constructed with the SetupBM algorithm where $p$ is a large prime number, $G_1, G_2$, and $G_T$ are cyclic groups of order $p$, $e : G_1 \\times G_2 \\rightarrow G_T$ is a bilinear map, and $G$ and $H$ are the generators of $G_1$ and $G_2$, respectively. Today, $|p| = 224$ is considered to be secure in practice [NIS11].\n\nGiven $gk$, we can construct zero-knowledge proofs\\(^1\\) for solutions for sets of equations like those depicted in Table 2.8, where $A_i, T_1 \\in G_1, B_i, T_2 \\in G_2, a_i, b_i, \\gamma_{ij}, t \\in \\mathbb{Z}_n$ and $t_T \\in G_T$. The variables $X_i \\in G_1, Y_i \\in G_2, x_i, y_i \\in \\mathbb{Z}_n$ are the unknowns or witnesses of the equations. The proofs are formed over commitments to these witnesses in order to achieve zero-knowledge.\n\nIn order to construct the proofs of knowledge which we require for our framework, the implementation uses binding commitments. Appendix A.1 explains this in more detail.\n\n### 2.4.4 Re-randomizable Zero-Knowledge Proofs\n\nThis section shortly explains the intuition behind re-randomizable zero-knowledge proofs [BCC+09]. Appendix A.2 presents a detailed explanation of re-randomization techniques.\n\n\\(^1\\)Groth-Sahai proofs are in general not zero-knowledge but witness-indistinguishable which is weaker than zero-knowledge. However, the equations which we prove have a special form that makes the resulting proofs zero-knowledge.\nTable 2.8 Equations for which we can construct witness-indistinguishability proofs.\n\nPairing product equations (PPE):\n\n\\[\n\\prod_{i=1}^{n} e(A_i, Y_i) \\cdot \\prod_{i=1}^{m} e(B_i, X_i) \\cdot \\prod_{i=1}^{m} \\prod_{j=1}^{n} e(X_i, Y_j)^{\\gamma_{ij}} = t_T\n\\]\n\nMulti-scalar multiplication equation in \\( G_1 \\) (MSM1):\n\n\\[\n\\sum_{i=1}^{n} y_i A_i + \\sum_{i=1}^{m} b_i X_i + \\sum_{i=1}^{m} \\sum_{j=1}^{n} \\gamma_{ij} y_j X_i = T_1\n\\]\n\nMulti-scalar multiplication equation in \\( G_2 \\) (MSM2):\n\n\\[\n\\sum_{i=1}^{n} a_i Y_i + \\sum_{i=1}^{m} x_i B_i + \\sum_{i=1}^{m} \\sum_{j=1}^{n} \\gamma_{ij} x_j Y_i = T_2\n\\]\n\nQuadratic equations in \\( \\mathbb{Z}_n \\) (QE):\n\n\\[\n\\sum_{i=1}^{n} a_i y_i + \\sum_{i=1}^{m} x_i b_i + \\sum_{i=1}^{m} \\sum_{j=1}^{n} \\gamma_{ij} x_i y_j = t\n\\]\n\nRe-randomization has many applications concerning the PA-PCA framework. It allows for selectively changing the randomness inside commitments. However, commitment modification alone is not enough since the zero-knowledge proofs using the commitments do not verify anymore. Therefore, whenever we change the commitments we also have to change the proofs. We show in Appendix A.2.2 how this modification can be done; furthermore, we prove the correctness of this modification (cf. Appendix A.2.4).\n\nExample 2.10. Suppose that there are proofs for two statements \\( A \\) says \\textit{Good}(\\( B \\)) and \\( A \\) says \\textit{Good}(\\( C \\)), which \\( A \\) wants to combine in conjunctive form. Every identity in the statement is represented by a commitment in the proof. Our convention says that commitments referring to the same identity have to be equal in order to link commitments inside a proof. However, it is not necessarily true that the commitment for \\( A \\) in the first statement is equal to the one in the second statement. We have to ensure after conjunction that both commitments are equal. The reason is that we have to link \\( A \\) not only in the statement but also in the proof. This can be established via re-randomization. Suppose that the first commitment for \\( A \\) uses randomness \\( r_1 \\) and the second commitment uses randomness \\( r_2 \\). By re-randomizing the second commitment with randomness \\( r_1 - r_2 \\) we achieve that after re-randomization both commitments are equal. A simple calculation proves this fact: \\( r_2 + (r_1 - r_2) = r_1 \\).\n2.4.5 Automorphic Signatures\n\nAbe et al. [AFG+10] propose a signature algorithm operating on bilinear groups. The message space are all Diffie-Hellman pairs \\( \\{(vG, vH) | v \\in \\mathbb{Z}_p\\} \\). As we want to sign verification keys they need to have the same form \\((sG, sH)\\) so that they fit the message space.\n\nIn the following, we instantiate a digital signature scheme which consists of four algorithms:\n\n**SetupSS**\\((1^k)\\) which takes as input a security parameter \\(1^k\\) and outputs the scheme parameters \\(p_{\\text{sig}}\\).\n\n**KeyGen**\\((p_{\\text{sig}})\\) which takes as input the signature scheme parameters and outputs a key pair \\((sk, vk)\\): \\(sk\\) is the signing key which only the signer is supposed to know and \\(vk\\) is the verification key which should be publicly known in order to verify the signed message.\n\n**Sign**\\((p_{\\text{sig}}, m, sk)\\) which takes as input the signature scheme parameters, the message \\(m\\) to sign, and the signing key \\(sk\\). It outputs a signature \\(\\text{sig}\\).\n\n**VerifySig**\\((p_{\\text{sig}}, \\text{sig}, m, vk)\\) which takes as input the signature scheme parameters, the signature \\(\\text{sig}\\) to verify, the message \\(m\\), and the verification key \\(vk\\). It outputs 1 if \\(\\text{sig}\\) is a valid signature on \\(m\\) verifiable with \\(vk\\), and 0 otherwise.\n\nThe instantiation of this scheme has the following form:\n\n**SetupSS.** Let \\(gk\\) be the setup (generated by **SetupBM**). Additionally, **SetupSS** chooses public parameters \\(pp = (F, K, T)\\) where \\(F, K, \\text{ and } T\\) are randomly drawn from \\(G_1\\). It outputs \\(p_{\\text{sig}} = (gk, pp)\\).\n\n**KeyGen.** On input \\(p_{\\text{sig}} = (gk, pp)\\), **KeyGen** draws a random number \\(x \\in \\mathbb{Z}_p\\) and outputs the key-pair \\((sk, vk)\\) where \\(sk = x\\) and \\(vk = (X, Y) = (xG, xH)\\).\n\n**Sign.** On input \\(p_{\\text{sig}} = (gk, pp)\\), a message \\(m\\) which has the form \\((M, N)\\), and a secret signing key \\(sk = x\\), the signer computes a signature as follows: she chooses random numbers \\(c, r \\in \\mathbb{Z}_p\\) and outputs the tuple \\(\\text{sig} = (A, C, D, R, S)\\) such that\n\n\\[\nA := \\frac{1}{x + c} \\cdot (K + rT + M) \\quad C := cF \\quad D := cH \\quad R := rG \\quad S := rH.\n\\]\n\n**VerifySig.** On input \\(p_{\\text{sig}} = (gk, pp)\\), a signature \\(\\text{sig} = (A, C, D, R, S)\\), a message \\(m = (M, N)\\), and a verification key \\(vk = (X, Y)\\), the verifier checks if the following pairing product equations hold:\n\n\\[\ne(A, Y + D) = e(K + M, H) \\cdot e(T, S)\n\\]\n\n\\[\ne(C, H) = e(F, D) \\quad e(R, H) = e(G, S).\n\\]\n\nIf all of them are true, the verifier outputs 1, otherwise it outputs 0.\nSecurity aspects. Fuchsbauer [Fuc09] proves that this scheme is existentially unforgeable against chosen message attacks. This is the standard notion of security for digital signature schemes.\n\nObservations. On the one hand, we can observe that the only part of the message that occurs in both, signature creation and verification, is $M$; so messages lie in $G_1$. On the other hand, the part of the verification key that is used to verify a signature $\\text{sig}$ is $Y$, the $G_2$ part. This illustrates the simplicity of signing the verification key: we just take the $X$ part as message and the $Y$ part to verify the produced signature.\n\nConsequently, this induces a disconnection of verification key parts since the two parts occur most often separately. An example for this separation is the evaluation step, that is, the statement (1.4) which has the following form before quantification:\n\n$$\\text{Prof says Reg}(\\text{Stud}, \\ell_{ec}) \\land \\text{Stud says Feedback}(\\ell_{ec}, gr).$$\n\nIts zero-knowledge statement, using two signatures $M_1$ and $M_2$ on the two atomic predicates, has the form\n\n$$\\text{ver}_{\\text{sig}}(M_1, \\text{vk}_\\text{Prof}, \\text{Reg}(\\text{Stud}, \\ell_{ec})) \\land \\text{ver}_{\\text{sig}}(M_2, \\text{vk}_\\text{Stud}, \\text{Feedback}(\\ell_{ec}, gr)).$$\n\nHere the student $\\text{Stud}$ occurs with both parts as message in the first conjunct and as verification key in the second conjunct. However, the verifier has no way to establish the connection between the two parts. This is problematic since a verifier can never link two different values to the same key without any hint on the connection.\n\nIn order to overcome this problem we express the connection via an additional pairing product equation\n\n$$e(X, H) = e(G, Y). \\quad (2.11)$$\n\nWe can easily prove that this equation holds by exploiting the properties of the bilinear map:\n\n$$e(X, H) = e(xG, H) = e(G, H)^x = e(G, xH) = e(G, Y).$$\n\nSignatures on vectors of messages. We stated in Chapter 1 that an atomic predicate of the form $\\text{Prof says Reg}(\\text{Stud}, \\ell_{ec})$ is usually implemented via a digital signature on the bit string encoding of the tuple $(\\text{Reg}, \\text{Stud}, \\ell_{ec})$ signed with $\\text{Prof}$’s signing key, that is, $\\text{sign}(\\text{Reg}, \\text{Stud}, \\ell_{ec})_{\\text{sk}_\\text{Prof}}$. This is so far not possible because we can only sign a single message and not a message vector. However, the above scheme is extendable to vectors of messages. We explain the construction and verification of such signatures in Appendix A.3.\n\n2.4.6 Zero-Knowledge Proofs of Signatures\n\nSignatures by themselves are not sufficient in order to provide the user with existential quantification on the logical level since they do not allow for hiding information. In order to realize existential quantification on the cryptographic level, we create for a\n2.4 Cryptographic Implementation\n\ngiven signature a zero-knowledge proof that proves the knowledge of that signature to a verifier. Therein the signature is hidden, but we can decide whether we want to reveal information about certain messages to the verifier.\n\nIn order to prove the knowledge of a signature we have to prove that the verification equations hold. More formally, we have to show that the three pairing product equations in (2.10) are valid. The Groth-Sahai proof scheme is well-suited to prove the knowledge of solutions to pairing product equations. Recall that pairing product equations are of the form\n\n$$\\prod_{i=1}^{n} e(A_i, Y_i) \\cdot \\prod_{i=1}^{m} e(X_i, B_i) = t_T.$$ \n\nWe only need the last part of this equation, namely,\n\n$$\\prod_{i=1}^{m} \\prod_{j=1}^{n} e(X_i, Y_j)^{\\gamma_{ij}} = t_T. \\quad (2.12)$$\n\nWe prove the following equations in the Groth-Sahai proof system:\n\n$$e([C_A], [C_Y]) \\cdot e([C_A], [C_D]) = e([C_X], [C_H]) \\cdot e([C_M], [C_N]) \\cdot e([C_T], [C_S])$$\n\n$$e([C_C], [C_H]) = e([C_F], [C_D])$$\n\n$$e([C_R], [C_H]) = e([C_B], [C_S]).$$\n\nRearranging the terms from the right to the left side, we get the corresponding pairing product equations\n\n$$e([C_A], [C_Y]) \\cdot e([C_A], [C_D]) \\cdot e([C_X], [C_H])^{-1},$$\n\n$$e([C_M], [C_N]) \\cdot e([C_T], [C_S])^{-1} = O$$\n\n$$e([C_C], [C_H]) \\cdot e([C_F], [C_D])^{-1} = O$$\n\n$$e([C_R], [C_H]) \\cdot e([C_B], [C_S])^{-1} = O.$$\n\nThese equations have now the desired form where \\( t_T = O \\). This is necessary to achieve the zero-knowledge property of the computed proof (cf. Appendix A.1). Next, we exemplify how the second equation from above is instantiated correctly:\n\n$$\\hat{X} = \\begin{pmatrix} X_1 \\\\ X_2 \\end{pmatrix} = \\begin{pmatrix} [C_C] \\\\ [C_F] \\end{pmatrix} \\quad \\hat{Y} = \\begin{pmatrix} Y_1 \\\\ Y_2 \\end{pmatrix} = \\begin{pmatrix} [C_H] \\\\ [C_D] \\end{pmatrix} \\quad \\Gamma = \\begin{pmatrix} \\gamma_{11} & \\gamma_{12} \\\\ \\gamma_{21} & \\gamma_{22} \\end{pmatrix} = \\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix}.$$\nwhose commitment is placed at position $i$ we remove the opening information in $O$ at position $i$.\n\nWe stated above that we have to connect verification key parts in case they occur with both parts, as message and as verification key. So we prove additionally (2.11) for each such connection:\n\n$$e([C_X], [C_H]) \\cdot e([C_G], [C_Y])^{-1} = O.$$ \n\nThis completes the implementation of the proof and signature scheme and their combination which we need to give a full implementation of the PA-PCA framework.\nChapter 3\n\nService-Specific Pseudonyms\n\nIn this chapter we present a new cryptographic primitive called service-specific pseudonyms [MPR]. Extended with these pseudonyms, the pool of security properties that PA-PCA provides is enlarged by linearity constraints for sensitive actions. We proceed as follows: Section 3.1 gives an overview. In Section 3.2 we provide the deduction rules that serve as the extension of the PA-PCA framework. In Section 3.3 we show how to cryptographically implement the new primitive and carry out a security proof. Finally, Section 3.4 concludes this chapter by applying service-specific pseudonyms to our example.\n\n3.1 Overview\n\nPA-PCA yields a powerful tool to develop applications that grant access to sensitive resources only to authorized users while offering the possibility to preserve their privacy. However, it lacks the possibility to specify linearity constraints: they are present whenever an action is to be limited in its number of executions. PA-PCA does not have any means to do that since a principal can send a proof for the same action several times. The receiver of the proof will not notice that the arriving proofs originate from the same principals if this principal does not disclose her identity.\n\nMapping these thoughts to the lecture evaluation example, this can cause a biased evaluation since every student can hand in arbitrarily many feedbacks. This is certainly not the intended system behavior that the professor has in mind: every student should only be allowed to submit at most one feedback.\n\nIn order to solve this problem we introduce service-specific pseudonyms (SSP). Intuitively, given a service, a principal can create exactly one pseudonym for it and not more and no two principals can create the same pseudonym (uniqueness). In this way, principals are linkable to their pseudonyms within a given service without disclosing their identity. However, unlinkability is preserved across different services and hence anonymity. More formally, if \\( psd \\) is the service-specific pseudonym of \\( A \\) for a service \\( s \\), then we say that the predicate\n\n\\[\nSSP(psd, \\text{vk}_A, s)\n\\] \n\n(3.1)\nTable 3.1 Cryptographic evidences for the extended system.\n\n\\[\n\\begin{align*}\nap & := \\text{ver}_\\text{sig}(u_s, u_A, F) \\mid \\text{ver}_\\text{ssp}(u_{psd}, u_A, s) \\mid E \\\\\nS & := ap \\mid S_1 \\land S_2 \\mid S_1 \\lor S_2 \\mid \\exists x. S\n\\end{align*}\n\\]\n\n(atomic predicates)\n\n\\[\n[p\\text{sd}] = \\text{SSP}(psd, vk, s) \\quad \\text{if } \\text{ver}_\\text{ssp}(psd, vk, s)\n\\]\n\nTable 3.2 Service-specific pseudonym extensions to privacy-aware E-DKAL and the PA-PCA zero-knowledge deduction system.\n\n<table>\n<thead>\n<tr>\n<th>Rule</th>\n<th>Premise</th>\n<th>Conclusion</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>I-SSP-Ver</td>\n<td>( psd \\in \\Gamma ) \\quad \\text{ver}_\\text{ssp}(psd, vk_A, s)</td>\n<td>( \\Gamma \\vdash_{\\text{ZK}} \\text{ver}_\\text{ssp}(psd, vk_A, s) )</td>\n</tr>\n<tr>\n<td>Ver-SSP</td>\n<td>( psd \\in \\Gamma ) \\quad \\text{ver}_\\text{ssp}(psd, vk_A, s)</td>\n<td>( \\Gamma \\vdash \\text{SSP}(psd, vk_A, s) )</td>\n</tr>\n<tr>\n<td>P-SSP</td>\n<td>( A : \\text{SSP}(psd, vk_A, s) ) \\quad \\text{ver}_\\text{ssp}(psd, vk_A, s)</td>\n<td>( A \\text{ knows } psd )</td>\n</tr>\n</tbody>\n</table>\n\nholds. In order to enforce linearity constraints for a certain service, the service users create a pseudonym for it and send it to the service provider who can check if the pseudonym already accessed the service or not. This is easily achievable by just storing each SSP that accessed the service and check if the incoming SSP is already stored in this list. We can use the SSP predicate like an atomic predicate in the logic, that is, it fits nicely into the existing framework. We implement SSPs cryptographically via a powerful combination of digital signatures and zero-knowledge proofs (cf. Section 2.4.3 and Section 2.4.5).\n\n3.2 Deduction Rules\n\nWe let \\( psd \\) range over pseudonyms and cryptographic evidences thereof, \\( s \\) over services, and we extend atomic predicates by a predicate \\( \\text{ver}_\\text{ssp}(u_{psd}, u_A, s) \\). This predicate is true if and only if \\( psd \\) is an SSP created by \\( A \\) for service \\( s \\). Additionally, the evaluation of \\([ psd ]\\) results in \\( \\text{SSP}(psd, vk_A, s) \\) if and only if the pseudonym verification \\( \\text{ver}_\\text{ssp}(psd, vk_A, s) \\) holds. Table 3.1 shows the extension to the existing cryptographic evidence definitions. The former definitions of \\([ \\cdot ]\\) and \\([ \\cdot ]_{\\text{zk}}\\) stay the same.\n\nThe deduction rules depicted in Table 3.2 fit smoothly into the existing system. There are three rules: P-SSP extends privacy-aware E-DKAL with a rule stating that if \\( A \\) assumes that the predicate \\( \\text{SSP}(psd, vk_A, s) \\) holds and the pseudonym verification \\( \\text{ver}_\\text{ssp}(psd, vk_A, s) \\) evaluates to true, then \\( A \\) knows the SSP \\( psd \\); I-SSP-Ver extends the PA-PCA zero-knowledge deduction system with a rule stating that if the pseudonym verification \\( \\text{ver}_\\text{ssp}(psd, vk_A, s) \\) holds and \\( psd \\) is in the environment \\( \\Gamma \\) then\n\\[ \\Gamma \\vdash_{\\text{ZK}} \\text{ver}_{\\text{ssp}}(psd, vk_A, s). \\] The statement is proven under the judgment \\( \\vdash_{\\text{ZK}} \\) since it is not possible to include SSPs into a disjunction and (as we will see in the next section) the implementation indeed also incorporates zero-knowledge proofs. \\text{Ver-SSP} extends the verification rules. It is analogous to the corresponding rules \\text{Ver-Sig} and \\text{Ver-ZK}.\n\n### 3.3 Cryptographic Implementation\n\nThe cryptographic implementation of service-specific pseudonyms comprises two phases: the interactive registration phase and the non-interactive generation phase. We make use of the Groth-Sahai proof scheme [GS08] and the digital signature scheme by Abe et al. [AFG+10]. This section is based on the corresponding section in [MPR].\n\n#### Registration phase. If \\( A \\) wants to access a service \\( s \\) created by the service provider \\( B \\), then \\( A \\) first retrieves a signature on her verification key \\( vk_A \\) issued by \\( B \\) while revealing her identity. As \\( A \\) discloses her identity, \\( B \\) can verify whether or not to accept the registration; if \\( B \\) accepts, she issues the signature \\( \\text{sig} := \\text{sig}(vk_A)_{sk_B} \\) and sends it to \\( A \\), who uses \\( \\text{sig} \\) in all upcoming interactions for authentication purposes.\n\n#### Generation phase. In general, the service is represented by a publicly known string \\( s \\in \\{0, 1\\}^* \\). This string is hashed directly into \\( G_1 \\) using a hash function \\( h : \\{0, 1\\}^* \\rightarrow G_1 \\) (for instance, using the method of Icart [Ica09]), so that \\( S = h(s) \\). \\( A \\)'s verification key is of the form \\( vk_A = xG \\). This is all we need to construct the pseudonym: we let \\( psd = xS \\).\n\nThe authenticity of the pseudonym \\( psd \\) is established via the verification key \\( vk_A \\) and the corresponding signing key \\( x \\). However, these two values reveal \\( A \\)'s identity. Hence, rather than disclosing both values we let \\( A \\) compute a zero-knowledge proof of knowledge that shows (i) the knowledge of the signature obtained in the registration phase, (ii) the well-formedness of the service-specific pseudonym, that is, the pseudonym is computed correctly, (iii) links the pseudonym to the credential to authenticate the pseudonym, and (iv) hides all values that potentially compromise the anonymity guarantees of the pseudonym. The proof shows the following equations:\n\n\\[\n\\text{verify}_{\\text{ssp}}(C_{\\text{sig}}, C_{vk_A}, C_{vk_B}, C_x, C_G, C_S, C_{psd}) := \\text{ver}_{\\text{sig}}([C_{\\text{sig}}], [C_{vk_A}], [C_{vk_B}]) \\quad (3.2)\n\\wedge [C_x] \\cdot [C_G] = [C_{vk_A}] \\quad (3.3)\n\\wedge [C_x] \\cdot [C_S] = [C_{psd}] \\quad (3.4)\n\\]\n\nThe zero-knowledge proof hides the privacy-relevant values \\( x \\), \\( vk_A \\), and \\( \\text{sig} \\), and opens all other commitments. However, it is also possible to open the commitment for \\( vk_A \\) and hide it not before it is really necessary. This makes the proof even more flexible. Equation (3.2) proves the knowledge of the signature \\( \\text{sig} \\) issued by \\( B \\) on \\( A \\)'s verification key. Equation (3.3) proves that the proof creator is in possession of the secret signing key corresponding to the verification key authorized in (3.2). Equation (3.4) proves the well-formedness of the pseudonym \\( psd \\), that is, that it is correctly computed by a multiplication of the secret signing key \\( x \\) and the hash-value \\( S \\) of service \\( s \\).\n3.3.1 Properties of Pseudonyms\n\nIn this section we prove two properties of service-specific pseudonyms: uniqueness and anonymity. Intuitively, a pseudonym offers uniqueness, if it is unique for a given user and a given service. It provides anonymity if, given the service, the pseudonym, and a list of candidate verification keys, it is impossible to identify the verification key involved in creating that pseudonym. As verification keys are strongly connected to their owner, also the principal corresponding to the verification key cannot be identified. In the following, we assume that the hash function \\( h \\) in our proofs is a random oracle\\(^1\\) that maps arbitrary string from \\( \\{0,1\\}^* \\) into \\( \\mathbb{G}_1 \\) and we let \\( n \\) denote the security parameter.\n\nWe start by defining the notion of a negligible function and negligible probability, and continue by stating basic properties about the distribution of hash values and secret signing keys.\n\n**Definition 3.1 (Negligible function).** A function \\( \\nu \\) is called negligible if for every positive integer \\( c \\) there exists an \\( n_c \\) such that we have for all \\( k > n_c \\) that\n\n\\[\n\\nu(k) < \\frac{1}{k^c}.\n\\]\n\nWe say that a random variable \\( X \\) occurs with negligible (resp. overwhelming) probability if there exists a negligible function \\( \\nu \\) such that for all \\( k \\) we have \\( \\Pr[X] < \\nu(k) \\) (resp. \\( \\Pr[X] > 1 - \\nu(k) \\)).\n\n**Proposition 3.2.** The following probabilities are negligible in \\( n \\):\n\n1. The output of the hash function \\( h : \\{0,1\\}^* \\rightarrow \\mathbb{G}_1 \\) is \\( \\mathcal{O} \\), the neutral element of the group operation of \\( \\mathbb{G}_1 \\).\n2. The output of the hash function \\( h : \\{0,1\\}^* \\rightarrow \\mathbb{G}_1 \\) for polynomially in \\( n \\) many different inputs coincide.\n3. A signing key \\( x \\) is 0.\n4. Any two signing keys from a set of polynomially in \\( n \\) many different inputs coincide.\n\nThe proposition holds since the output of the random oracle implementing \\( h \\) and the signing key are chosen uniformly at random from an exponentially (in \\( n \\)) large set.\n\nBefore defining uniqueness for SSPs, we introduce an auxiliary function, which intuitively links a verification key to the corresponding pseudonym for a given service. It is important to notice that this function cannot be efficiently computed without knowing the secret signing key.\n\n**Definition 3.3.** We define the pseudonym computation function \\( Y : \\mathbb{G}_1 \\times \\mathbb{G}_1 \\rightarrow \\mathbb{G}_1 \\) as \\( Y(xG, S) = xS \\).\n\n\\(^1\\)A random oracle replies to a query with a truly random response and it answers consistently with previously answered queries.\nAs a next step we can define the uniqueness of a pseudonym and then we prove that our construction above fulfills this definition. To prove that our construction fulfills the definition, we note that scalar multiplication of numbers (for instance, signing keys $x$) in $\\mathbb{Z}_p$ with a generator $G$ of a cyclic, prime-order group $G_1$ is bijective. Furthermore, we note that because $G_1$ is a prime-order group, all elements in $G_1$ except the neutral element $O$ are generators of $G_1$.\n\n**Definition 3.4 (Uniqueness of Pseudonyms).** A pseudonym psd is unique if and only if, the following conditions hold with overwhelming probability:\n\n1. for every service $S$ and two honestly generated verification keys $vk_1$ and $vk_2$ we have that $Y(vk_1, S) \\neq Y(vk_2, S)$,\n2. for every service $S$ and verification key $vk$, $Y(vk, S)$ is a unique value,\n3. for every two different service descriptions $s_1$ and $s_2$ and a verification key $vk$ we have that $Y(vk, h(s_1)) \\neq Y(vk, h(s_2))$.\n\n**Theorem 3.5.** Under the random oracle assumption, a pseudonym psd constructed as above is unique.\n\n*Proof.* Condition 1.: for any service $S$ and any two verification keys $vk_1$ and $vk_2$ we have that $Y(vk_1, S) = Y(vk_2, S)$ if and only if $S = O$, the neutral element and only non-generator of $G_1$, or $vk_1 = vk_2$; the two verification keys coincide if and only if the two corresponding, honestly-chosen signing keys coincide. These two events happen only with negligible probability by 1. and 4. of Proposition 3.2, respectively.\n\nCondition 2.: follows immediately since $Y$ is a function.\n\nCondition 3.: for any verification key $vk$ and two different service descriptions $s_1$ and $s_2$, we have $Y(vk, h(s_1)) = Y(vk, h(s_2))$ if and only if $h$ maps $s_1$ and $s_2$ to the same value, or the signing key is 0. These two events occur only with negligible probability by 2. and 3. of Proposition 3.2. \n\nNow we define the anonymity of service-specific pseudonyms and proceed with a proof showing that our construction of pseudonyms fulfills this definition.\n\n**Definition 3.6 (Anonymity of Pseudonyms).** A pseudonym psd provides anonymity if and only if, given a set $S$ of verification keys, any polynomially (in $n$) bounded attacker can determine which verification key $vk \\in S$ was used to compute psd with probability $1/|M| + \\mu$ where $\\mu$ is negligible in $n$.\n\nThe anonymity proof is a reduction to the decisional Diffie-Hellman (DDH) problem. For the sake of completeness, we give all the necessary definitions and assumptions followed by the main theorem.\n\n**Definition 3.7 (DDH and DDH advantage).** Given the tuple $(G, xG, yG, c)$, where $G$ is a generator of $G_1$, and $x, y \\in \\mathbb{Z}_p$ are randomly chosen, the DDH problem is to decide whether $c = xyG$. \n\nThe advantage of an DDH attacker is defined as\n\n$$\\text{Adv}^{\\text{DDH}}(B) = |\\Pr[1 \\leftarrow B(1^n, G, xG, yG, xyG) | b = 1] - \\Pr[1 \\leftarrow B(1^n, G, xG, yG, z) | b = 0]|$$\n\nwhere $z$ is a random value in $G_1$ and $b$ is chosen randomly from $\\{0, 1\\}$.\n\nIntuitively, the advantage describes how much better than pure guessing an adversary can determine which verification key $\\text{vk}$ was involved in computing a pseudonym $\\text{psd}$.\n\n**Assumption 3.8 (Hardness of DDH).** For all attackers $B$ that are polynomially bounded (in $n$), the advantage $\\text{Adv}^{\\text{DDH}}(B)$ is negligible in $n$.\n\nThe values $(G, \\text{vk}, S, \\text{psd})$ form a valid Diffie-Hellman tuple since $\\text{vk} = xG$, $S = rG$ for some random $r$, and $\\text{psd} = xS = xrG$. We now state and prove our main theorem.\n\n**Theorem 3.9.** Under the random oracle and the DDH assumption, service-specific pseudonyms provide anonymity.\n\n**Proof.** Figure 3.1 visualizes the steps of this reduction proof.\n\nLet $\\{\\text{vk}_1, \\ldots, \\text{vk}_k\\}$ be the values obtained by the service provider during the registration of $k$ principals. Suppose there is an attacker $A$ that, on input $\\{\\{\\text{vk}_1, \\ldots, \\text{vk}_k\\}, G, S, \\text{psd}\\}$, outputs $\\ell$ such that $\\text{vk}_\\ell$ and $\\text{psd}$ are associated with probability $1/k + \\eta$ where $\\eta$ is non-negligible. Based on this attacker, we construct an attacker $B$ that breaks a decisional Diffie-Hellman challenge with non-negligible probability.\n\nThe DDH challenger $C$ uniformly at random draws a bit $b \\in \\{0, 1\\}$. Here and throughout the rest of the thesis, we use the notation $x \\in X$ to denote that $x$ is drawn uniformly at random from the set $X$. If $b = 1$, $C$ generates a valid DDH tuple, if $b = 0$, $C$ generates a fake DDH tuple, that is, a tuple where $c = zG$ for a random $z \\in Z_p$. This tuple is sent to attacker $B$.\n\nGiven that DDH challenge $(G, xG, yG, c)$, attacker $B$ must give a perfect simulation to attacker $A$, so that $A$ cannot differentiate between a normal challenge and a challenge constructed by $B$. We note that the value $S$ in our service-specific pseudonym\n3.4 Application of Service-specific Pseudonyms\n\nIn order to illustrate the applicability of the new rules we show how to improve the feedback system in such a way that the professor can limit the number of feedbacks per student. Recall that each course participant Stud has a certificate Prof says Reg(Stud, lee), created by the professor stating that this student is registered for the course. Let fb be\nthe service for which students can create an SSP in the evaluation process. Every student that wants to evaluate the lecture creates a pseudonym \\( psd \\) such that \\( SSP(psd, vk_{Stud}, fb) \\) holds. The conjunction of this pseudonym predicate together with the former feedback statement and an existential quantification of the student's identity yield the proof of the final statement\n\n\\[\n\\exists x. \\text{Prof says } Reg(x, lec) \\land SSP(psd, vk_x, fb) \\land x \\text{ says } Feedback(\\mathit{lec}, gr_x). \\tag{3.7}\n\\]\n\nThe deduction of this proof is depicted in Table 3.3. The professor receives the proof and checks if the pseudonym \\( psd \\), which is directly connected to the existentially quantified student \\( Stud \\), already submitted a feedback; depending on this result she accepts the feedback or not. If it is accepted, the professor adds \\( psd \\) to her list of submitted feedbacks. Upon termination of the evaluation process, the professor publishes the results.\nChapter 4\n\nImplementation\n\nThis chapter presents the implementation of the PA-PCA framework in Java. It comprises two application programming interfaces (API). The first one, presented in Section 4.1, is able to generate, modify, and verify proofs as given by the PA-PCA framework. We discuss the second API in Section 4.2. It provides functionalities to start and maintain a distributed network. Once started, it enables the user to send and receive data to known computers in this network. The user can decide whether she wants to send data anonymously or not. Finally, Section 4.3 illustrates the usage of both APIs by implementing the feedback system from Chapter 2.\n\n4.1 Proof API\n\nThis section is dedicated to present and explain the proof API, that is, the implementation of the PA-PCA framework in Java. Section 4.1.1 overviews the implementation as well as the provided functionality and Section 4.1.2 points out the implementation details of the most important functions.\n\n4.1.1 Overview\n\nWe provide the PA-PCA zero-knowledge deduction system via a Java implementation. Our API enables the user to construct zero-knowledge proofs as given by the deduction trees created with the deduction system. We also provide the programming language Asplada (cf. Appendix B) that makes the interaction with the underlying API much more convenient because it abstracts away all cryptographic details.\n\nBuilding blocks. We need several building blocks in order to implement a useful API. The most important one is a cryptographic library to construct and verify signatures and zero-knowledge proofs. We implemented the signature scheme presented in Section 2.4.5 and the zero-knowledge proofs of signatures presented in Section 2.4.6 based on the jPBC\\(^1\\)\n\n\\(^1\\)jPBC is a library to perform pairing based cryptography operations in Java [DC] which originates from the C library PBC.\nlibrary. The resulting library provides functions to create and verify signatures on single messages, on message pairs, and on message vectors. Each such function takes as input the message(s) to be signed and the signing key, and returns the corresponding signature. The verification function just takes as input the verification key and the signature and returns true if the verification succeeds or false otherwise.\n\nIn order to implement the zero-knowledge proofs of knowledge of signatures we need another library that enables us to create and verify proofs for all the different kinds of equations provable with the Groth-Sahai scheme. For this purpose we use a library which is currently under development. It implements all building blocks for the Groth-Sahai proof scheme like commitments, proof constructions, and proof verifications for the different types of equations. Using this library, we create zero-knowledge proofs of signatures for a single message, for message pairs, and for message vectors. We can easily verify the resulting proofs since they come with a verification function and we can easily hide certain information (messages or identities) by just removing the captured opening information. This opening information is present from the beginning and is only removed if we want to hide identities or messages.\n\nGiven these building blocks, we can now almost start describing our API. However, we should mention that the cryptographic library as it is currently implemented is not aware of identities or string messages. It deals only with elliptic curve elements. In the design of the API and the implementation thereof we have to take care of this. We provide the connection between numbers and meaningful strings in a very easy to understand manner, that is, we connect each signature or zero-knowledge proof to an instance of our Statement class which represents the atomic predicates not in a cryptographic way but in the logical way given by the PA-PCA framework, so that they are understandable.\n\n**Functionalities.** We implemented a method for each of the inference rules depicted in Table 2.2. The class providing all these methods is called ProofObject. It represents a finite conjunction of signatures or zero-knowledge proofs. We say that a ProofObject is on signature level or it is in signature representation if it is composed of signatures; we say that it is on zero-knowledge level or it is in zero-knowledge representation if it is composed of zero-knowledge proofs. Note that a mixture of signatures and zero-knowledge proofs does not exist. In order to instantiate a ProofObject there are two possibilities: we can either use the constructor corresponding to I-S-Ver or the constructor corresponding to I-ZK-Ver. Both of these constructors take a signature (respectively a zero-knowledge proof of a signature) and an atomic predicate as input, and initializes the ProofObject. ProofObject objects instantiated in this way can be modified corresponding to all the inference rules: transformation of signatures to zero-knowledge proofs, conjunction on the signature and on the zero-knowledge proof level, existential quantification, and also conjunction splitting. We also implemented the re-randomization of existing proofs although this is not included in the logic. Furthermore, we implemented existential instantiation of hidden principals or messages which is nothing else than recomputing the commitment followed by a check if the recomputed and the existing commitment correspond. If this is the case, the opening information is attached to the proof.\nFigure 4.1 The interaction of the different building blocks. From top to bottom the level of abstraction decreases. The uppermost layer is Asplada interacting with the ProofObject API. ProofObject uses the cryptographic library below to implement the deduction rules. The cryptographic library uses the lowermost library under development that provides the mathematical zero-knowledge proof calculations.\n\nIn addition to construction and modification of zero-knowledge proofs, our API provides a verification method. This method checks if a given proof is correct, that is, it is constructed validly using the deduction system and not modified in a way that makes it invalid. ProofObject can also transform an instance into a byte array to distribute proofs on the network. The same holds for the other direction, that is, reading a ProofObject from a byte array.\n\nFigure 4.1 visualizes the architecture and the dependency among the components. The programmer has two options: she can either use Asplada to have a very high-level, cryptographically free interface of specifying proofs; or she can work directly on ProofObject to create and verify proofs. This, however, requires a deeper understanding of the API design.\n4.1.2 Details\n\nNow we detail the different functions. We discuss key requirements and means of establishing the connection between identities.\n\n**Construction.** We store the signature (respectively zero-knowledge proof\\(^{\\text{2}}\\)) and the atomic predicate. Additionally, we build up our occurrence map for principals, that is, we store all occurrences of each principal in the zero-knowledge statement specified by the user. Consider our example from before, \\(\\text{Prof says Reg(Stud, \\ell ec)}\\). For this statement we produce three triples \\((\\text{Prof}, 1, 0)\\), \\((\\text{Stud}, 1, 1)\\), and \\((\\ell ec, 1, 2)\\). The first component is the name or identity and the second component indicates in which proof in the conjunction\\(^{\\text{3}}\\) the name is placed (in this case there is only one proof). The third component indicates where the name or identity is placed in the second component’s proof: if the index is 0, we refer to the identity before the says; if the index is different from 0, we refer to the specified position after the says. This map causes conveniences for later book-keeping since we can easily browse through all proofs where a certain principal occurs.\n\n**Transformation of signature into zero-knowledge proof.** This transformation requires a few steps. At first, every signature must be converted into a zero-knowledge proof thereof. In these proofs, we have to be careful considering the commitments of equal identities. As we want to preserve their linkability in the proof, the commitments have to be the same among equal identities. After creating these proofs we have to build the connections described in (2.11) for the separated parts of a principal’s verification key. We sometimes call such a connection a connector proof. These were not required for the signature level since there, no commitments on verification keys are involved.\n\n**Conjunction.** Here we must be very careful. There are several cases which we have to consider: we can only build the conjunction of proofs that are on the same level, that is, either both are in signature representation\\(^{\\text{4}}\\) or both are in zero-knowledge proof representation.\n\n**Signature representation.** We only merge the occurrence maps. The rest is just a concatenation of signatures and atomic predicates.\n\n**ZKP representation (no quantification).** In addition to the above step we have to merge the connections, that is, we have to connect principals occurring both as verification key and as message. For example, if we connect a zero-knowledge proof for \\(A\\) says Good\\((B)\\) and one for \\(B\\) says Good\\((A, C, B)\\) then we have to add a connection between \\(A\\) in the first statement as verification key and in the second statement as message and a connection between \\(B\\)\n\n---\n\n\\(^{\\text{2}}\\)This case never happens whenever we use Asplada.\n\n\\(^{\\text{3}}\\)We do not offer disjunctions. For an explanation see the paragraph “Not implemented so far” on page 41.\n\n\\(^{\\text{4}}\\)Representation means that the finite conjunction is composed either of signatures or of zero-knowledge proofs, but not both.\nin the first statement as message, and in the second statement as verification key. Furthermore, we have to take care of the fact that commitments must be made equal in order to preserve linkability, that is, in the above case we would have to make equal the commitments of $B$ in the first and the second statement for the occurrence as an argument of the predicate. We realize this via re-randomization as already explained in Section 2.4.4.\n\n**ZKP representation (with quantification).** In addition to the previous step we have to take care of the fact that after conjunction there does not exist any connection between a quantified message or principal and any message or principal (quantified or not) in the other conjunct. For instance, assume that we have the statements $\\exists x. \\text{say } Good(B)$ and $\\exists y. \\text{say } Good(C)$. Let the commitments for $x$ in the first statement and $y$ in the second statement be equal (this can have different reasons, for example, that the variables refer to the same identity). When we compose the two statements in conjunctive form there should not be a link between $x$ and $y$ because the two variables can correspond to any identity and do not necessarily refer to the same. We use re-randomization to achieve unlinkability.\n\n**Conjunction elimination.** Here we just remove the specified conjunct from the conjunction. Additionally, we have to remove the connections to every identity occurring in the removed conjunct.\n\n**Existential quantification.** There are two methods to existentially quantify messages and identities. We can either quantify all occurrences of a message or identity or only a selection, that is, a subset of all occurrences. The first case is easier since we only have to change the statement representing the proof, that is, remove the identity and replace it with a meaningless string, and to remove the opening information for the corresponding commitment in the proof itself. However, selectively quantifying means that connections must be removed because we do not want to link quantified variables to unquantified identities. Removing the connections is of no use if we do not also destroy the connection in the commitments. Note that even though we removed the opening information for the selected positions, the commitments are still equal. This does not destroy the connection. Hence, we have to re-randomize the selected positions with a new common randomness followed by building new connections.\n\n**Re-randomization.** We have to take special care for this operation. It takes as input a selection of positions that should be re-randomized. For each such position we have to check if there are connections and delete them after re-randomization. We must also re-connect broken connections in case two positions with the same identity are re-randomized. In practice, the situation is complicated by the fact that we have to treat existentially quantified variables different from identities. If we choose to re-randomize an occurrence of an identity then we have to re-randomize all occurrences since otherwise linkability would break. However, variables can be arbitrarily re-randomized.\nWhenever we re-randomize an identity or variable which has connections to other identities or variables, we have to re-randomize all of these connections. This seems not necessary at first sight. However, the connection verification uses the commitment that is stored in the proof; this commitment has changed because we re-randomized it. As the connection is a zero-knowledge proof we also have to adapt it to the new commitment. So if we do not also re-randomize the connector proof it will not verify anymore. For instance, suppose that we have a proof for the statement $A$ says Good($B$) $\\land$ $B$ says Good($C$). Assume that $B$ is represented by a commitment $c_1$ in the first conjunct and by a commitment $c_2$ in the second conjunct.\n\nThe commitments are different since they are elements of different groups. But there is also a connector proof combining $c_1$ and $c_2$. The commitments are stored in the ProofObject and they are shared by the verification functions of the proof of the statement and the connector proof. So we have to adapt both proofs in order to succeed in the verification step.\n\n**Existential instantiation.** This function requires to know the opening information of the message or identity we want to instantiate since it is inverse to existential quantification. Given the opening information, this method tries to open the commitments at every specified position. There are several things we should note at this position; we can retrieve the opening information of every not yet quantified identity or message. After existential quantification we can instantiate the identity or message using the former retrieved opening information as long as nobody else modified the commitment of the message or identity we want to instantiate. This is due to the fact that changing the commitment also changes the opening information. Like in the former cases we have to take care of the connections. If not all commitments are opened, connections break immediately. In order to fix these disconnections we apply the same idea as for existential quantification.\n\nThis functionality has different applications. For instance, suppose that we combine the lecture evaluation system with a game in which the winner has to show that she is the creator of the feedback in order to receive a prize. The professor has all the proofs for statements of the form $\\exists x. \\text{Prof says Reg}(x, \\text{lec}) \\land x \\text{ says Feedback}(\\text{lec}, \\text{gr})$ at her disposal. She chooses the winner by picking one of these feedbacks and distributes it among all participating students. If the winning student wants to show that she is the originator of the feedback she can do so by instantiating her identity back into the proof and sending the modified proof to the professor. Although this example is not useful in practice, it shows the typical application scenario for this functionality. We refer to Appendix B.2 for a better, but also more complex example.\n\n**Verification.** This method comprises several independent checks which all have to succeed in order to verify a proof. In the case that the ProofObject is on signature level, we simply have to check that each signature in the conjunction verifies correctly with the given verification key. If the ProofObject is on zero-knowledge level, we have to take care of several more dependencies:\n1. Every zero-knowledge proof in the conjunction has to verify.\n2. We recompute for each non-hidden identity or message its commitment and check if the recomputed one is equal to the stored one. This is of course only possible if the identity or message to check is not hidden since otherwise the opening information to recompute the commitment would be missing.\n3. We recompute all connections of identities occurring both as verification key and as message and compare the recomputed map with the one captured in the `ProofObject`.\n4. Given the connections which are based on the statement representation and not on the proofs themselves, we check if equal identities have equal commitments which is crucial to achieve linkability between equal identities within the proof. This implies that we also have to check that identities, messages, or variables that are not equal also have different commitments in order to not link parts of the proof which should not be linked.\n5. We did not mention predicate names so far. Nevertheless, they are important since they give meaning to the atomic predicates. For instance, \\textit{A says Good}(B) has a different meaning than \\textit{A says Bad}(B). In order to check that predicate names have not changed, we take the name and compute its commitment. We check if the recomputed one is equal to the stored one.\n6. We verify each connector proof. In order to do that we need the commitments from the zero-knowledge proofs. At this point we understand why it is crucial to also re-randomize the connector proofs when we re-randomize the other proofs: the connector proofs are directly connected to the zero-knowledge proofs since they share the commitments. Verification succeeds only if the proofs share the same commitment.\n\n\\textbf{Not implemented so far.} So far, we did not implement the logical disjunction because this is highly non-trivial. Proofs that include logical disjunction grow in complexity much faster than those without logical disjunction. We did also not yet incorporate the new protocol SSP into our proof API. We have a version of the SSP implementation that works well but it cannot be used in combination with the current \\texttt{Asplada} version. However, when using by hand we can combine all pieces together which we did in order to get our evaluation results in Chapter 5.\n\n\\subsection*{4.1.3 Optimization}\nWe implemented the complete API in Java. However, we used a wrapper to go from jPBC to classical PBC which makes our resulting programs faster up to 70\\% because PBC is more machine-oriented.\n\nWe also included simple multi-threading: whenever it is possible to compute commitments, proofs, or verifications in parallel, we started multiple threads. For instance, we start a new thread for each of the three pairing product equation proofs for the proof of knowledge of a standard automorphic signature. We apply the same idea for the two\nlevels above, that is, for each of the four standard signature proofs needed to compute a\nproof of a pair signature (cf. Appendix A.3.1), we start a thread doing the job, and we\nstart a new thread for each of the \\( n + 1 \\) proofs of pair signatures needed for a proof of a\nvector signature (cf. Appendix A.3.2).\n\nThere is a more advanced method called batch-verification \\([BFI^{+}10]\\) for verifying\nproofs; the potential speed up for the verification is up to 90\\%. We did, however, not\nimplement this method so far due to complexity.\n\n4.2 Sender API\n\nThis section is dedicated to present the sender API. With this API users can build a\ndistributed network with which they are able to send and receive messages (byte arrays)\neither by revealing their identity or anonymously. The API needs two building blocks\nwhich we describe next. On the one hand we use JXTA \\([JXS]\\) to ensure reliable communi-\ncation which we discuss in Section 4.2.1 and on the other hand we use Tor \\([DMS04]\\) – an\nonion routing network – to ensure anonymous communication (cf. Section 4.2.2). In\nSection 4.2.3 we get around to the functionalities of our API and explain how to use it.\n\n4.2.1 JXTA\n\nJXTA is a project originated by Sun Microsystems in 2001. It comprises several abstract\nprotocol specifications which are independent of any programming language. JXTA is\na virtual overlay network that strongly resembles a distributed hash table like Tapestry\n\\([ZHS^{+}04]\\). It allows its nodes to interact with each other using the protocols it defines.\nWe use JXSE for our implementation, the Java implementation of JXTA. There are\nseveral books about JXTA and JXSE \\([Wil02, Gra02, OTG02]\\) that are not up to date\nanymore. We refer to \\([Ver10]\\), the most recent one, for further reading.\n\nNotions and Protocols. Here we only talk about the protocols and the notions which\nwe need for this thesis. JXTA is built up in three main layers: on the bottom we have the\ncore layer that comprises two protocols, the Peer Resolver Protocol and the Endpoint\nRouting Protocol. The middle layer is called service layer and comprises four protocols,\nthe Peer Discovery Protocol, the Peer Information Protocol, the Pipe Binding Protocol,\nand the Rendezvous Protocol. Applications are developed using the top layer which is\ncalled application layer. It can use the underlying layers as APIs. Before we detail all\nthese protocols we discuss several notions JXTA defines.\n\nPeer. A peer in JXTA is nothing else but a node in the network, that is, any comput-\ning device (computer, PDA, smartphone, etc.) that implements the core JXTA\nprotocols. It has access to at least the core protocols and can interact with other\nnodes in the network if there is a connection. There are several kinds of peers. We\nrefer to Figure 4.2 for an illustration of how a JXTA network can be setup and\nwhich peers can connect to which peers. In order to operate the network we need\nrendezvous peers and relay peers. Rendezvous peers can coalesce with several other\npeers. However, they are not aware of talking to peers located behind a firewall or NAT. Relay peers solve these issues (in this thesis it does not matter how this is done). Basic peers can have at most one direct connection. This connection must be to a rendezvous or relay peer. We can imagine the rendezvous peers as routers in the network whereas basic peers are just clients that need the routers to talk to other clients. A mixture of rendezvous and relay peer is also available.\n\n**Peer Group.** JXTA uses this notion to talk about networks or compositions of peers. There are at least two peer groups in JXTA, that is, the *world peer group* and the *net peer group* to one of which any peer is connected. The world peer group is conceptually located above the net peer group. Peers organize themselves in peer groups to form groups of interest. So we can think of, for example, a group for professors, a group for students, or different groups for different lectures. Peer groups should provide at least the core services to facilitate group communication. We explain the notion of service below.\n\n**Advertisement.** In JXTA every object is described by an advertisement. Advertisements are XML files that comprise information about a particular object. For instance, a peer advertisement includes a unique peer ID, the peer group ID to\nwhich it belongs to, a name, a description and an address to find it on the network. These advertisements are distributed in order to publish information.\n\nPipe. A pipe is a direct connection between two peers. There are different kinds of pipes: unidirectional pipes where only one peer can send and the other can only receive, bidirectional pipes where communication can go in both directions, and multidirectional pipes where communication can go from one to many other peers.\n\nService. JXTA defines core and standard services. These are used to implement the protocols. There are peer services which run on each peer and peer group services that are provided within the peer group. We describe some services which we need for our API.\n\nDiscovery Service. This standard service finds peers in the network. More formally, it does not find the peer itself but its representation, that is, the peer advertisement.\n\nEndpoint Service. This core service provides the functionality of sending data from one peer to another using the specified network transportation protocol, in general either TCP or HTTP.\n\nPeer Info Service. This standard service retrieves the status information of other peers in the network.\n\nPipe Service. This standard service establishes the connection from one peer to another via a pipe.\n\nRendezvous Service. Rendezvous peers operate this standard service in order to manage their job more efficiently, that is, forwarding and processing queries about other peers or services in their peer group.\n\nResolver Service. This core service manages the routing of queries between peers.\n\nAll necessary notions explained, we can now continue by describing the different protocols which JXTA defines.\n\nEndpoint Routing Protocol. This protocol tries to establish a route from a peer $A$ to a peer $B$. In order to do that it maintains a cache of known routes. Given a routing request, it first takes this cache into consideration to find a route. If it does not find a route in the cache it queries neighboring peers for routes to $B$. After receiving the responses it takes the optimal route among all known. If a route is found it uses the endpoint service to send the data from $A$ to $B$.\n\nRendezvous Protocol. In JXSE the rendezvous service as described above is the implementation of this protocol. It is built on top of the endpoint routing protocol and allows to broadcast messages (to send them to all peers in the network) to peers that do not support multicasting. As multicasting is not available it uses the underlying network transportation layer, either HTTP or TCP.\n\nPipe Binding Protocol. This protocol is responsible for establishing the pipe connection between at least two peers. It uses the endpoint routing protocol to send initial\nmessages until a connection is established. The responsibility ends at this point. It is worthwhile mentioning that this protocol always creates a unidirectional pipe where traffic flows only in one direction. Hence, whenever we want to communicate in both directions we have to execute this protocol twice.\n\n**Peer Resolver Protocol.** This protocol is used to query and answer questions between peers. For example, to answer the question if a certain service is available on that peer or not.\n\n**Peer Information Protocol.** This optional protocol is based on the peer resolver protocol. It is used to retrieve information about other peers on the network. JXTA does not describe it more specifically.\n\n**Peer Discovery Protocol.** This protocol is used to retrieve all kinds of resources which are available on the network. By resources we mean advertisements describing those resources. Those can be peers, peer groups, pipes, and many more. We also use it to publish advertisements on the network. We, as a peer, can do this either locally such that other peers have to visit us to fetch advertisements, or remotely such that other peers receive our advertisements.\n\nThe implementation of all these protocols can use any programming language. As our implementation of the sender API uses Java we take JXSE, the Java implementation of JXTA. Due to its high level of abstraction, JXTA is relatively easy to use. However, it takes some time to get used to it, that is, the documentation is not exhaustive and not always helpful. We had to browse through a high amount of forums in order to eliminate certain problems. Occurring failures are often not documented at all and since JXTA is running out known problems are partly unresolved. As our implementation does not need all of the features that JXTA provides we touch only a small part of what is possible in JXTA.\n\n### 4.2.2 Tor\n\nJXTA is sufficient for sending data in a distributed network. However, JXTA does not support sending this data anonymously. In order to provide anonymity in our API, which is crucial to protect the privacy in case a principal hides her identity in a proof, we use Tor [DMS04], the state-of-the-art onion routing network. We do not detail how Tor works; this goes beyond the scope of this thesis since we use it only as a building block. Instead, we give a rough overview. The Tor network comprises many nodes. Some of these nodes are entry or exit nodes of the network and some of them are only internal nodes. If peer $A$ wants to send a message $m$ to peer $B$ over the Tor network the following happens: at first, a route is selected through the Tor network. Let the selected route be $(A, C_1, C_2, \\ldots, C_n, B)$. $A$ tries to obtain a symmetric key with each node $C_1, \\ldots, C_n$ using handshakes. Let these keys be $K_1, K_2, \\ldots, K_n$. Assume that every node $C_1, \\ldots, C_n$\nknows its successor. Then $A$ creates the following encrypted message where we denote by $\\{m\\}_K$ the symmetric encryption of message $m$ using the symmetric encryption key $K$:\n\n$$E = \\{\\ldots \\{m\\}_{K_n} \\ldots \\}_{K_2}_{K_1}.$$ \n\n$A$ sends $E$ to $C_1$ which decrypts the message using the symmetric key that it shares with $A$. As $C_1$ knows that the next node is $C_2$ she forwards the message, which is again an encryption, to $C_2$. This process is repeated until $C_n$ is reached. $C_n$ decrypts the plain message and sends it to the intended destination $B$. Notice that the message $m$ can also be an encryption; specifying the system to send messages in plain is just more flexible. As the global route is not known to the internal nodes, Tor guarantees anonymity. The illustration below shows a route from $A$ to $B$ via $C_1$ and $C_2$.\n\n$$A \\xrightarrow{\\{m\\}_{K_1}} C_1 \\xrightarrow{\\{m\\}_{K_2}} C_2 \\xrightarrow{m} B$$ \n\nIn order to get a connection to a Tor entry node, the user of the API has to use any available Tor client. We recommend to use Vidalia, a Tor client that forwards every packet via a local proxy to the Tor entry node which forwards it again until it reaches its destination. So in order to send data anonymously a user just has to download this client and configure it accordingly. Our API does the rest.\n\n### 4.2.3 Functionalities\n\nFigure 4.3 illustrates the interaction of the sender API with the network. We detail the interaction as well as the usage of the API in the following. The class JxtaSender implements a sender that uses the JXTA network and selectively the Tor network. It implements all necessary methods and manages connections to the JXTA network. We discuss in the following the most important methods to use and on which actions to pay attention to.\n\nJxtaSender($S1, S2, S3, I1, I2, L1, L2$). The constructor for this sender takes several arguments. There is a String $S1$ for the peer ID which can just be left null since then a new identity is created. String $S2$ and $S3$ contain a name and a description. The user should specify two ports to use for outgoing and incoming tcp connections, one for non-anonymous usage ($I1$) and one for anonymous usage ($I2$). JXTA recommends to use ports located between 9700 and 9799. $L1$ and $L2$ are lists containing ip addresses for rendezvous and relay peers located on the internet. These addresses have the following form: tcp://<ip-address>:<port> or tcp://<domain>:<port>. This constructor generates a new peer with the given specification and starts it. Starting means that it connects the peer to one of the specified rendezvous or relay peers. Together with that it starts several observers which take care of incoming advertisements and messages. Once connected, the sender starts to publish information about itself to inform other participants of its presence.\n4.2 Sender API\n\nFigure 4.3 An overview of the sender API. The programmer uses a JxtaSender to send messages selectively over JXTA or Tor. She registers a SenderListener with the JxtaSender in order to receive messages from both networks.\n\nclass User implements SenderListener {\n JxtaSender sender;\n public User() {\n //initialization stuff\n sender.registerListener(this);\n }\n public void anonymousMessageArrived(byte[] m) {\n //some action\n }\n public void messageArrived(byte[] m, URI a) {\n //some action\n }\n public void send(URI a, byte[] m, boolean anonymous) {\n if (anonymous) {\n //send m via Tor to a\n } else {\n //send m via JXTA to a\n }\n }\n}\n\nstop(). This method stops all actions the sender is performing and disconnects it from the JXTA network, more specifically, from the rendezvous or relay peer to which it is connected.\n\ngetConnectedAddresses...(), getConnectedAnonymousAddresses...(). These methods provide information about all known peers in the network. They return maps that contain names and their corresponding addresses on the network. These information are needed to send messages to other peers. Either the name or the address are necessary. As names are not necessarily unique we recommend to always use the unique address to send messages. If this is not desired we recommend to use unique names like e-mail addresses.\n\nsend(URI addr, byte[] m, boolean anonymous). The user calls this method whenever she wants to send a message m to a known connected peer with address addr. This peer does not need to be a direct connection; there can be chains of peers in between. The message is a byte array. This is the most general format that we can imagine and it perfectly fits the ProofObject format since we can transform it\ninto such arrays. The truth value anonymous decides whether the message should be sent over JXTA or anonymously over Tor using Vidalia.\n\n**Receive messages.** In order to receive messages from the JxtaSender, an object using the sender should implement the interface SenderListener and register this object with the sender via the method registerListener(SenderListener). The interface SenderListener defines two methods:\n\nmessageReceived(byte[] message, URI sender). This method is called by the sender whenever a message arrives over the JXTA network. As it is sent via JXTA the sender is known immediately.\n\nanonymousMessageReceived(byte[] message). This method is called whenever the sender receives a message over the Tor network. Due to its anonymity property, the sender cannot be determined.\n\n**Where to find the rendezvous and relay peers?** This question is easy to answer: there does not exist any. Everyone who wants to program a system has to take care of this issue by herself. Nevertheless, it is easy to provide these peers. Depending on the size of the system an increasing number of rendezvous and relay peers should be used. Note that relay peers are only necessary when some peers are located behind firewalls or NATs. The code snippet in Listing 4.1 shows the simple implementation of such a peer. In order to get a real network these peers should also be connected among each other. It does not help to have hundreds of these peers not knowing each other.\n\n**Shortcomings.** Our API is convenient to use since the functionality is mostly limited to the basic sending and receiving operations. However, we cannot provide a library function for every JXTA feature, that is, we use JXTA in such a way that we obtain the information that we need in order to provide our functionalities, and not more. We do not implement any service and somehow abuse JXTA’s features. Nevertheless, getting it work is a difficult task. Especially if it comes to connecting to peers via a socket. There are many failures occurring and exceptions thrown. This made us doubting if those problems could be solved at all. Browsing the web for answers to the question where these failures originated, we concluded that just ignoring them and trying repeatedly is the best way to cope with them. For example, we sometimes get connection timeouts although the corresponding time threshold is set to infinity. We did not find anybody who solved this problem. Our solution is just to try to connect as often as necessary until the connection is established. However, we think that this is a very poor solution. Consequently, it can take a while until a connection is established but it needs not. We did not manage to find out the reasons for this problem: sometimes it occurred when many peers tried to get a connection to one specific peer which is somehow reasonable, but it also sometimes occurred if only two peers tried to interact with each other which is not reasonable.\n\n6 A socket is another kind of pipe that offers a bit more functionality. It can be seen as a bidirectional pipe.\nListing 4.1: A simple implementation of a rendezvous-relay peer.\n\n```java\npublic class RendezvousPeer {\n public static String name = \"Rendezvous 1\";\n public static int tcpPort = 9701;\n public static List<URI> rendezvousSeeds, relaySeeds;\n // these should be filled with some valid addresses of other\n // rendezvous and relay peers\n\n public static void main(String... args) throws IOException,\n PeerGroupException {\n // create a new configuration file that stores necessary\n // information\n File file = new File(new File(\".cache\"), name);\n NetworkManager.RecursiveDelete(file);\n NetworkManager manager = new NetworkManager(NetworkManager.\n ConfigMode.RENDZVOUS_RELAY, name, file.toURI());\n NetworkConfigurator configurator = manager.getConfigurator();\n\n configurator.setTcpInterfaceAddress(InetAddress.getLocalHost().\n getHostAddress());\n\n // configure Tcp traffic appropriately\n configurator.setTcpEnabled(true);\n configurator.setTcpIncoming(true);\n configurator.setTcpOutgoing(true);\n configurator.setTcpPort(tcpPort);\n\n configurator.setUseMulticast(true);\n\n // drive the network manager to the rendezvous and relay peers\n for (URI address : rendezvousSeeds) {\n configurator.addSeedRendezvous(address);\n }\n\n for (URI address : relaySeeds) {\n configurator.addSeedRelay(address);\n }\n\n // start the network and assign the peerGroup and the peerID\n PeerGroup netPeerGroup = manager.startNetwork();\n\n PeerID peerID = IDFactory.newPeerID(netPeerGroup.getPeerGroupID()\n , name.getBytes());\n\n configurator.setPeerID(peerID);\n }\n}\n```\n4.3 Implementation of the Feedback System\n\nIn order to use our APIs we just include them as libraries and use the classes and functions they provide. We provide the interaction between the proof API and the sender API via transformation of ProofObjects to byte arrays and sending these arrays via the sender to the receiver.\n\nWe demonstrate the usage of both APIs by implementing our example from Chapter 2 in Asplada to conveniently interact with the proof API. However, since service-specific pseudonyms are not yet included in the current proof API we implement the example in the state before fixing the problem with multiple feedbacks. We restrict it a bit further: we only show the fundamental creation of proofs and sending these proofs. In order to simplify the sending we need to define several auxiliary methods: the methods defined in Listing 4.2 create a new message that comprises a byte that indicates which kind of message it is and the object itself. The corresponding messageReceived and anonymousMessageReceived methods have to take this into account and process the incoming messages accordingly.\n\nGiven these auxiliary methods, we can now have a deeper look at how we create proofs and how we send them. Recall that the professor has an authorization policy (a slightly modified version of (1.3) that allows for quantifying the student’s identity) stating the fact that only registered students are permitted to give their feedbacks:\n\n\\[\n\\forall y, z. (\\exists x. \\text{Prof says Reg}(x, y) \\land x \\text{ says Feedback}(y, z)) \\rightarrow \\text{Rate}(y, z).\n\\]\n\nListing 4.3 depicts the code for the registration process of the student. She creates a request of the form\n\n\\textit{Stud says Register}(\\ell ec)\n\nand sends it to the professor who processes the request and is asked to let the student be registered or not. In case the professor agrees she sends a confirmation of the form\n\n\\textit{Prof says Reg}(\\textit{Stud}, \\ell ec)\n\nwhich the student verifies to store it for later usage.\n\nAfter the student has received the confirmation she can enter the feedback process depicted in Listing 4.4. The student uses the confirmation to create a proof for her feedback of the form\n\n\\[\n\\exists x. \\text{Prof says Reg}(x, \\ell ec) \\land x \\text{ says Feedback}(\\ell ec, gr)\n\\]\n\nand sends it to the professor. The professor receives this proof and verifies it in order to check if the incoming message passes the authorization policy. If this is the case the professor puts the feedback on the rating board. After the feedback process is finished by every student, the professor can broadcast all feedbacks to the students in order to let them know how the overall quality of the course was.\n\nThis example usage shows how convenient it is to use our APIs in applications. In less than 20 lines of Asplada we specify a system whose classical development could take\n4.3 Implementation of the Feedback System\n\nListing 4.2: The auxiliary methods simplifying sending operations for professor and students.\n\n```java\n// Professor's auxiliary methods\npublic void sendConfirmation(ProofObject P, URI address);\n\npublic void sendFeedBacks(String feedbacks);\n\n// Student's auxiliary methods\npublic void sendFeedback(ProofObject text);\n\npublic void register(ProofObject registration);\n```\n\nages without using any general programming interface. We admit that in order to get a working program we have to invest a little bit more but everything besides the above code snippets is nothing else but book-keeping and management of user interfaces and storage. Our interface makes such developments very fast. Even without Asplada the API to create proofs and modify them is very general and powerful but of course much more technical.\nListing 4.3: The registration process between the student and the professor only described in Asplada and sender operations.\n\n```plaintext\n// If the student presses the register button this action is performed\n/*$ */\nlet S = Stud says Register(Lec)\n$*/\nstudSender.register(S);\n\n// If the professor agrees in registering the student A then a request\n// answer is created which is sent back to A (sender)\n/*$ */\nverify @A says Register(Lec) with P\nlet RequestAnswer = Prof says Reg(A,Lec)\n$*/\nprofSender.sendConfirmation(RequestAnswer, sender);\n\n// The student verifies that P, the confirmation arrived, is correct and\n// stores it for further usage\n/*$ */\nverify @Prof says Reg(Stud,Lec) with P\n$*/\nConfirmation = P;\n```\n4.3 Implementation of the Feedback System\n\nListing 4.4: The feedback process in Asplada and sender operations.\n\n```plaintext\n// The student uses the registration confirmation provided by the\n// professor to create her feedback ExAns which she sends via the\n// sender to the professor.\n\nString Feed = \"my feedback\";\n/*\n let Q = Stud says Feedback(Lec, Feedback)\n let Ans = Confirmation and Q\n let ExAns = exists Stud. Ans\n*/\nstudSender.sendFeedBack(ExAns);\n\n// Upon receiving this feedback as Q the professor verifies it and puts\n// it on the rating board. After all feedbacks arrived she publishes\n// the feedbacks for the students.\n\n$/\nverify exists X. Prof says Reg(X,Lec) \\ X says Feedback(Lec,M) with Q\n$/\nputOnRatingBoard(M.getName());\npublishFeedbacks();\n```\nChapter 5\n\nPerformance Evaluation\n\nWe carry out a performance evaluation for several test cases. This evaluation only affects the proof API and not the sender API since we cannot influence network properties or network qualities. We implemented several case studies to test our proof API for PA-PCA and to test the service-specific pseudonyms presented in Chapter 3. This chapter proceeds as follows: we present a case study on social networks in Section 5.1, one for a health insurance certificate in Section 5.2, and one for an anonymous Like button in Section 5.3. Finally, we present the results of the evaluation in Section 5.4.\n\n5.1 Social Network\n\nWe implemented some of the proofs used in the social network framework provided by Backes et al. [BMP11]. In the following, we explain the functionalities of these proofs together with the statements representing them which we have to create. We assume that if two principals $A$ and $B$ are in a friendship, $A$ has given a certificate to $B$ describing this relation:\n\n$A$ says $\\text{Relation} (\\mathcal{R}, B)$\n\nwhere $\\mathcal{R}$ describes the exact relation between $A$ and $B$.\n\nResource access. There are several functions that allow for accessing resources such as posting on a friend’s wall or viewing a friend’s pictures. Additionally, a principal can specify whether or not a friend of hers is allowed for hiding her identity or not. Therefore we have two\\footnote{In general there are three authentication mechanisms: in addition to the relation and the anonymous authentication there is the pseudonymous authentication. However, our system does not support pseudonyms as given by [BMP11].} authentication protocols that establish the connection to access resources.\n\nRelation authentication. This protocol reveals all information except $B$. Concerning the social network framework, relation authentication reveals in particular the relation tag $\\mathcal{R}$. So if $B$ wants to execute this protocol he has to provide a proof for\nthe following statement:\n\n\\[ \\exists x. \\ A \\text{ says Relation}(R, x) \\]\n\nwhere \\( x \\) was \\( B \\) before quantification. \\( B \\) sends this certificate together with a request for the desired resource to \\( A \\).\n\n**Anonymous authentication.** This protocol hides the relation tag and the identity which makes \\( B \\) anonymous for \\( A \\). Using relation authentication, \\( A \\) could potentially deduce by the relation tag that the quantified \\( x \\) was \\( B \\). For instance, when \\( B \\) is the only friend with relation \\( R \\). Here, \\( B \\) creates a proof for the following statement together with a proof for the desired resource:\n\n\\[ \\exists x, y. \\ A \\text{ says Relation}(x, y). \\]\n\nThe rest of the protocol is the same as above.\n\n**Friend-of-friend.** This protocol is very advanced. Suppose that \\( A \\) is a friend of \\( B \\) and \\( B \\) is also a friend of \\( C \\), but \\( A \\) and \\( C \\) are not in a friendship so far. This is expressed by the following two statements:\n\n\\[\n\\begin{align*}\nA & \\text{ says Relation}(R, B) \\quad (5.1) \\\\\nB & \\text{ says Relation}(R', C). \\quad (5.2)\n\\end{align*}\n\\]\n\nNow \\( C \\) wants to be in a friendship with \\( A \\). The friend-of-friend protocol is able to establish this friendship without the interaction of \\( A \\). The protocol is based on a communication between \\( B \\) and \\( C \\) while \\( C \\) stays anonymous. At first, \\( C \\) formulates a request using the signature in (5.2) and sends it to \\( B \\). This request has the following form:\n\n\\[ \\exists x, y. \\ B \\text{ says Relation}(y, x) \\land x \\text{ says Request}(A). \\]\n\n\\( B \\) receives this request, verifies it, and creates a proof for the following statement:\n\n\\[ \\exists x, y, z. \\ z \\text{ says Relation}(y, x) \\land A \\text{ says Relation}(R, z) \\]\n\nusing the signature in (5.1). In order to achieve unlinkability, \\( B \\) has to re-randomize his identity after quantification. Upon receiving this statement from \\( B \\), \\( C \\) re-instantiates her identity into the statement. She obtains the friendship relation between her and \\( A \\). Note that \\( C \\) does not necessarily know who exactly sent the response since it could be that she requested the friendship from several friends. The final friendship certificate is\n\n\\[ \\exists x, y. \\ A \\text{ says Relation}(R, x) \\land x \\text{ says Relation}(y, C). \\]\n\nThis statement looks and indeed is a transitive connection from \\( A \\) to \\( C \\). The construction of the proof ensures that the person in between is a common friend of \\( A \\) and \\( C \\).\n5.2 Health Insurance Certificates\n\nIf an employee is ill she has to undergo a medical examination. After this medical examination the doctor creates a health insurance certificate. The patient has to forward this certificate to both the employer and the health insurance so that it is okay that she stays away from office. However, the diagnosis should not be revealed to the employer but to the health insurance. Suppose, for instance, that the patient is pregnant. In case the employer knows this fact she could not want to renew the patient’s contract. There are many more cases that cause disadvantages for the patient.\n\nPA-PCA is well-suited to solve these problems. Any licensed doctor has a certificate of the form\n\n\\[ \\text{Hosp says IsDoctor}(B). \\]\n\nThis certificates stands for the approval of a hospital Hosp for the doctor B. A has to meet the following policy of her employer if she is ill and wants to stay at home from office:\n\n\\[ \\forall p, x. \\exists d, y. \\text{Hosp says IsDoctor}(d) \\land d \\text{ says Visit}(p, x, y) \\rightarrow \\text{OkOff}(p). \\]\n\nThis policy says that if there is some approved doctor d who attests the patient p a visit at date x with result y then it is okay for p to stay at home. When A visits the doctor B in case she is ill, B tells her the results res of the examination at date date via a certificate of the form\n\n\\[ \\text{Hosp says IsDoctor}(B) \\land B \\text{ says Visit}(A, \\text{date}, \\text{res}). \\]\n\nThen A existentially quantifies the results and the doctor, and forwards the so obtained certificate\n\n\\[ \\exists d, r. \\text{Hosp says IsDoctor}(d) \\land d \\text{ says Visit}(A, \\text{date}, r) \\] \\hspace{1cm} (5.3)\n\nto her employer. The received proof meets the policy and it is okay for A to stay home. In order to illustrate the beauty of open-endedness once more we can use the doctor’s certificate to get medicine from the pharmacy. So only the results and the patient is necessary but both the doctor and the date are not needed in this scenario. A changes the doctor’s certificate into the following one:\n\n\\[ \\exists d, t. \\text{Hosp says IsDoctor}(d) \\land d \\text{ says Visit}(A, t, \\text{res}). \\]\n\nThen the pharmacy can provide the appropriate medicine for A.\n\n5.3 Anonymous Like Button\n\nWhen we browse the web today, we will find social plugins on most websites. Social plugins are objects integrated into websites such as the Like button from Facebook [Fb] or Google+1, a very similar button in Google+ [GPO]. These social plugins provide several functionalities. For instance, Google+1 informs our friends of pages, videos, or\nany kind of objects equipped with such a button that we like. Additionally, Google somehow includes the results of these button click statistics in its page ranking engine. These plugins are very conveniently to use since one click is sufficient to provide our friends with information about our preferences. However, in order to use these plugins one has to be logged into the system that offers the button. If we want to use Google+1 we have to be logged into Google+. However, whenever we are logged in, all information we provide our friends is also provided to the operator of the system. This entails many privacy issues, for instance, Nic Cubrilovic [Cub] encountered an issue when users log out of Facebook: several cookies, including the one which includes the account number, are kept and hence forwarded every time a user loads a website with Facebook integrated, particularly if there is a Like button on that website. By doing this, Facebook could track users even when they are logged out. This issue seemed to be removed by the end of 2011 but it shows the vulnerabilities of these plugins.\n\nTo overcome these privacy issues we use service-specific pseudonyms. Note that using PA-PCA is not possible since we want users to like an object only once. Hence SSPs are well-suited for this purpose. The operator of the system provides a certificate proving a statement of the form\n\n\\[\n\\text{Operator says Permitted} (\\text{System, A})\n\\]\n\nwhich says that the operator Operator of System approves A to be a participant of it. Whenever Operator places a Like button on a website she creates a new service s. The service is in this case the object for which the button is placed. When A wants to like s she creates a service-specific pseudonym psd and a proof for the statement\n\n\\[\n\\exists x. \\text{Operator says Permitted} (\\text{System, x}) \\land \\text{SSP} (\\text{psd, x, s}) \\land x \\text{ says Like} (\\text{comment}).\n\\]\n\nShe sends the proof to Operator who verifies it and processes the information. It is guaranteed by the uniqueness of the pseudonym psd that every participant can like one particular object only once. Additionally, the SSP does not reveal any information about A except psd which cannot be linked to A.\n\n5.4 Results\n\nWe use a computer with a quad core processor\\(^2\\) and 4 GB of RAM for our experiments. We measured the proof generation and proof verification time as well as the size of the proofs in kilobytes for all our experiments described above.\n\nSecurity Parameter. In order to get a prediction for different application scenarios we run our experiments with different security parameters. These parameters are directly connected to the size of the elliptic curves which we use. These curves are such that the security parameter is half the size of the curve [NIS11]: for example, if our curve has size 224 bits then the security parameter has size 112 bits. Since 2010 a security\n\n\\(^2\\)Intel Core i7-2760QM CPU @ 2.40GHz\n5.4 Results\n\nA parameter of 112 bits is recommended. However, from about 2030 experts recommend to have a security parameter higher than that. Therefore, we also measured the times for a security parameter of 128 bits. To have a glance even further into the future we also evaluated times and sizes for a parameter of 256 bits.\n\n**Discussion.** The results of the case studies described above together with our evaluation system example are depicted in Figure 5.1, Figure 5.2, Figure 5.3, Figure 5.4, and Figure 5.5. Overall, we observe that the graphs are slightly growing and that the shape is in all cases similar. Additionally, the times for a security parameter of 512 bits are only of theoretical interest since they go beyond the scope of today’s computing power and are highly impractical. We just show the results without detailing them. It is just interesting to see what is possible today for requirements which we need to fulfill in perhaps twenty years.\n\nThe results for the complete evaluation process depicted in Figure 5.1 are promising. Note that we have three proof verifications. These three verifications take not more than about 25 seconds for a security parameter of 112 bits. Generation times are even faster with about 10 seconds. The complete proof size is about 230 KB which is reasonable given the continuous spread of broad-band internet connections. Even for a higher security parameter of 128 bits the overall verification time for three verifications lies under 38 seconds and the generation time at about 14 seconds. The proof size does not grow too much and is reasonable with under 275 KB. These times seem to be almost practical in a sense that if we assume that the system does not need to provide real-time evaluations, it is acceptable that a proof takes 10 seconds to be verified. In a lecture with one hundred students this results in a complete verification time of under twenty minutes.\n\nThe results for the authentication process in social networks depicted in Figure 5.2 are very convincing. Generation times of about 4 seconds and verification times of about 7 seconds for a 112 bits security are practical for real systems. Also for the even higher 128 parameter generation times of under 6 and verification times of 10 seconds are not that much higher. Proof sizes of about 133 (resp. 154) KB for 112 (resp. 128) bits security are acceptable.\n\nThe results for the friend-of-friend authentication in Figure 5.3 are not completely convincing. As generation times lie at 10 (resp. 14) seconds and verification times at 23 (resp. 33) seconds for 112 (resp. 128) bits security, this protocol is not suited for chatting. However, posting messages on a wall does not require real-time evaluations. Therefore it depends on the application. Proof sizes which are even below the one for the evaluation system are acceptable.\n\nThe results for the health insurance certificate shown in Figure 5.4 are again auspicious. Proof generation times of 9 (resp. 12) seconds and verification times of 15 (resp. 21) seconds are more practical than the one for the friend-of-friend protocol, particularly because we do not need real-time evaluations in this protocol. Proof sizes of 264 (resp. 306) KB are not disturbing.\n\nFinally, we do not deliver a judgment concerning the results for the anonymous Like button depicted in Figure 5.5. The proof generation times of about 10 (resp. 13) seconds and the verification times of about 15 (resp. 22) seconds are relatively high.\nFigure 5.1 The results for the lecture evaluation system, that is, the complete process including registration and feedback submission. In total we have three verifications. The code for this system is described and discussed in Section 4.3.\n\n(a) Proof and verification times.\n\n(b) Proof size.\n\nFigure 5.2 The results for the authentication process for social networks from Section 5.1. The proof generation and verification times do not differ for both processes, that is, relation authentication and anonymous authentication. However, since the anonymous authentication hides an identity the sizes differ. We do not show both size graphs since the difference is not visible.\n\n(a) Proof and verification times.\n\n(b) Proof size.\n\nProof size rel. auth.\n5.4 Results\n\n**Figure 5.3** The results for social networks friend-of-friend authentication as presented in Section 5.1.\n\n(a) Proof and verification times.\n\n(b) Proof size.\n\n**Figure 5.4** The results for the health insurance certificates in (5.3) as presented in Section 5.2.\n\n(a) Proof and verification times.\n\n(b) Proof size.\n\n**Figure 5.5** The results for the anonymous Like button as described in Section 5.3.\n\n(a) Proof and verification times.\n\n(b) Proof size.\nChapter 6\n\nConclusion\n\nWe have presented a framework to automatically generate executable, security sensitive distributed systems. With this framework developers are enabled to synthesize distributed systems that are capable of managing authorization, protect user privacy and the privacy of data, and enforce linearity constraints on certain actions. The base for our framework is the privacy-aware proof-carrying authorization (PA-PCA) framework [BMP12, MP11] which builds on the proof-carrying authorization (PCA) framework [AF99] and E-DKAL [ABN11, GN08]. This tool provides us already with authorization and privacy. Only linearity is a missing property.\n\nIn this thesis, we have introduced service-specific pseudonyms. We advocate the usage of service-specific pseudonyms in applications which restrict the execution of certain actions to a limited number of times. Due to their implementation, service-specific pseudonyms are unique if the service is fixed; unique means in this context that every principal can generate exactly one pseudonym per service and that no two different principals can generate the same pseudonym for the same service. It turns out that service-specific pseudonyms fit smoothly into the existing PA-PCA system. For this reason, we have extended PA-PCA with service-specific pseudonyms and have ended up with a framework that can synthesize exactly the desired distributed systems.\n\nThis framework is conveniently usable and proven to generate the intended systems. In order to transfer this into practice, we have implemented this framework in Java. We provide the implementation in form of two independently usable libraries (APIs). Taken together, the two libraries provide the functionality of the PA-PCA framework. The first API allows for generating, modifying, and verifying proofs and signatures as given by the PA-PCA framework. Together with this API we deliver the programming language Asplada that establishes a convenient method to interact with the proof API and can be integrated and translated into Java code. The translated Java code consists of calls to the proof API. So the user does not have to be an expert in the API and even more important, she does not have to be an expert in cryptography. The second API establishes sending and receiving operations on a distributed network; developers can choose between non-anonymous sending and anonymous sending.\nWe have demonstrated the expressiveness of our extension to the PA-PCA framework and of our implementation by using our APIs to implement the evaluation system which we have presented in this thesis. Additional to the complete implementation of the evaluation system, we have carried out several other case studies and measured proof generation and verification times as well as proof sizes for these case studies. The results are promising.\n\n**Future Work.** As we have already mentioned in Section 4.1.3 there is a more sophisticated method to implement verification of Groth-Sahai proofs called batch verification technique. This could potentially result in a speed-up of up to 90%.\n\nAnother approach could be to implement the APIs in C. As C is more machine-oriented than Java which runs in its own virtual machine we could potentially gain additional speed-ups. However, the expected improvements from an implementation in C are rather small. Further, C is not platform independent like Java. We cannot just give a jar-file that provides the corresponding library functions. Even the integration of PBC instead of jPBC creates problems concerning platform independency. In order to work the system we need special libraries which need to be compiled specifically for the computer on which the API runs.\n\nThe extension of PA-PCA with SSPs is well-suited to model distributed systems that manage authorization, are aware of privacy of data and user privacy, and can enforce linearity constraints. However, in order to enforce the linearity in the systems, the developer has to take care of this fact in the implementation, whereas authorization and privacy are modeled within the logic of PA-PCA. The logic underlying PA-PCA does not support linearity constraints since it is not linear. A follow-up work could be to change the logic to a linear or at least affine one. This is not trivial since not all parts of the system can be treated linear, like, for instance, authorization policies. A possible starting point is the PhD thesis of Limin Jia [Jia08], which introduces a logic that incorporates both linear and non-linear components.\nBibliography\n\n\nAppendix A\n\nCryptographic Implementation\n\nA.1 Groth-Sahai Zero-Knowledge Proofs\n\nThis section details the Groth-Sahai [GS08]. We start with a few preliminary notions (cf. Section A.1.1), explain how the commitments are computed, and show which components the common reference string comprises (cf. Section A.1.2). Then we present the proof construction (cf. Section A.1.3) followed by the proof verification (cf. Section A.1.4) and the correctness proofs (cf. Section A.1.5).\n\nA.1.1 Preliminaries\n\nDefinition A.1 (R-module). Let \\((R, +, \\cdot)\\) be a commutative ring. \\((A, +)\\) is an \\(R\\)-module if \\((A, +)\\) is an abelian group and for all \\(r, s \\in R\\) and \\(x, y \\in A\\)\n\n\\[\n(r + s)x = rx + sx \\quad r(x + y) = rx + ry \\quad r(sx) = (rs)x \\quad 1x = x\n\\]\n\nhold.\n\nThe abbreviation which we introduce next is generally persistent for any set \\(R\\) and any \\(R\\)-module \\(A\\). But since we are only using \\(\\mathbb{Z}_p\\)-modules we concentrate from now on the special case of \\(\\mathbb{Z}_p\\) modules.\n\nIn order to make the equations in Table 2.8 more readable, we introduce an abbreviation. Let \\(A_1, A_2, A_T\\) be \\(\\mathbb{Z}_p\\)-modules and \\(f : A_1 \\times A_2 \\rightarrow A_T\\) be a bilinear map on those modules. Let \\(\\vec{x} \\in A_1\\) and \\(\\vec{y} \\in A_2\\). We define \\(\\cdot : A_1 \\times A_2 \\rightarrow A_T\\) as\n\n\\[\n\\vec{x} \\cdot \\vec{y} := \\sum_{i=1}^{n} f(x_i, y_i).\n\\] (A.1)\n\nLemma A.2. Let \\(\\vec{x} \\in A_1^n\\), \\(\\vec{y} \\in A_2^n\\), and \\(\\Gamma \\in \\mathbb{Z}_p^{n \\times m}\\). Then we have\n\n\\[\n\\vec{x} \\cdot \\Gamma \\vec{y} = \\Gamma^T \\vec{x} \\cdot \\vec{y}.\n\\]\nProof. Let $\\vec{x} \\in A_1^n$, $\\vec{y} \\in A_2^m$ and $\\Gamma \\in \\mathbb{Z}_p^{n \\times m}$. Then we have\n\\[\n\\vec{x} \\cdot \\Gamma \\vec{y} = \\sum_{i=1}^{n} f \\left( \\sum_{j=1}^{m} \\gamma_{ij} y_j \\right) = \\sum_{i=1}^{n} \\sum_{j=1}^{m} f(x_i, \\gamma_{ij} y_j) = \\sum_{j=1}^{m} \\sum_{i=1}^{n} f(\\gamma_{ij} x_i, y_j) = \\sum_{j=1}^{m} \\Gamma^\\top \\vec{x} \\cdot \\vec{y}.\n\\]\nThis chain of equations holds by exploiting the properties of the bilinear map. □\n\nWith equation (A.1) and Lemma A.2 we can transform the equations in Table 2.8 into those in Table A.1 where all the $A_i, B_i, X_i, Y_i, a_i, b_i, x_i, y_i$ are collected in vectors $\\vec{A}, \\vec{B}, \\vec{X}, \\vec{Y}, \\vec{a}, \\vec{b}, \\vec{x}, \\vec{y}$ and the $\\gamma_{ij}$ are collected in a matrix $\\Gamma$. For the pairing product equation we define $f$ to be the bilinear map $e$, for the multi-scalarmultiplication equations we define $f$ as $f(x, y) = y X$, and for the quadratic equations we define $f$ as $f(x, y) = xy \\mod n$.\n\nTable A.1 The equations in abbreviated form from Table 2.8.\n\n<table>\n<thead>\n<tr>\n<th>Equation Type</th>\n<th>Abbreviation</th>\n<th>Equations</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PPE with $f(x, y) = e(x, y)$</td>\n<td>$\\vec{A} \\cdot \\vec{Y}$</td>\n<td>$(\\vec{A} \\cdot \\vec{Y})(\\vec{A} \\cdot \\vec{B})(\\vec{A} \\cdot \\vec{X} \\cdot \\vec{Y}) = t_T$</td>\n</tr>\n<tr>\n<td>MSM1 with $f(X, Y) = y X$</td>\n<td>$\\vec{A} \\cdot \\vec{Y}$</td>\n<td>$\\vec{A} \\cdot \\vec{Y} + \\vec{x} \\cdot \\vec{b} + \\vec{y} \\cdot \\vec{X} = \\tau_1$</td>\n</tr>\n<tr>\n<td>MSM2 with $f(X, Y) = y X$</td>\n<td>$\\vec{A} \\cdot \\vec{Y}$</td>\n<td>$\\vec{A} \\cdot \\vec{Y} + \\vec{x} \\cdot \\vec{b} + \\vec{y} \\cdot \\vec{X} = \\tau_2$</td>\n</tr>\n<tr>\n<td>QE with $f(x, y) = xy \\mod n$</td>\n<td>$\\vec{A} \\cdot \\vec{Y}$</td>\n<td>$\\vec{a} \\cdot \\vec{y} + \\vec{x} \\cdot \\vec{b} + \\vec{y} \\cdot \\vec{X} = \\tau_3$</td>\n</tr>\n</tbody>\n</table>\n\n### A.1.2 Commitment Computation and the Common Reference String\n\nThe commitment scheme is based on the idea that we have $\\mathbb{Z}_p$-modules $A_1, A_2$, and $A_T$ with a bilinear map $f$; we transform the values of these modules in other $\\mathbb{Z}_p$-modules $B_1, B_2$, and $B_T$ with a bilinear map $F$; we commit in these modules. For the transformation there are the mappings $\\iota_1 : A_1 \\rightarrow B_1, \\iota_2 : A_2 \\rightarrow B_2$, and $\\iota_T : A_T \\rightarrow B_T$ with the corresponding inverse mappings $p_1, p_2$ and $p_T$. The following graph illustrates the possible transformations quickly:\n\n\\[\n\\begin{align*}\nA_1 & \\times A_2 \\xrightarrow{f} A_T \\\\\n\\iota_1 \\uparrow p_1 & \\quad \\iota_2 \\uparrow p_2 \\\\\nB_1 & \\times B_2 \\xrightarrow{F} B_T \\\\\n\\iota_T \\uparrow p_T\n\\end{align*}\n\\]\n\nThe next abbreviation is similar to that in equation (A.1). However, with this one we address multiplications of already transformed values. Let $\\vec{u} \\in B_1^n$, $\\vec{v} \\in B_2^n$, and $F$ be a bilinear map. Then we define $\\bullet : B_1 \\times B_2 \\rightarrow B_T$ as\n\\[\n\\vec{u} \\bullet \\vec{v} = \\sum_{i=1}^{n} F(u_i, v_i)\n\\]\n(A.2)\nThe \\( \\bullet \\) operation has the same property as the \\( \\cdot \\) operation with respect to matrix multiplication, hence:\n\n**Lemma A.3.** Let \\( \\vec{u} \\in \\mathbb{B}_1^n \\), \\( \\vec{v} \\in \\mathbb{B}_2^m \\) and \\( \\Gamma \\in \\mathbb{Z}_p^{n \\times m} \\). Then we have\n\n\\[\n\\vec{u} \\bullet \\Gamma \\vec{v} = \\Gamma^T \\vec{u} \\bullet \\vec{v}.\n\\]\n\n**Proof.** The proof is analogous to the proof of Lemma A.2 but replacing \\( f \\) with \\( F \\), \\( x \\) with \\( u \\) and \\( y \\) with \\( v \\). \\( \\square \\)\n\nRecall that the algorithm \\texttt{SetupBM} produced a setup \\( gk \\) containing the group order, the respective groups \\( G_1 \\), \\( G_2 \\), and \\( G_T \\), the bilinear map \\( e \\), and the group generators \\( G \\) and \\( H \\). Let \\( O \\) be the neutral element for \\( G_1 \\), \\( G_2 \\), and \\( G_T \\). Note that \\( O \\) may be pairwise different between the different groups, but for convenience we just take one notation for all three possibly different neutral elements. Given \\( gk = (p, G_1, G_2, G_T, e, G, H) \\), our proof scheme instantiation sets\n\n\\[\nA_1 = G_1 \\quad A_2 = G_2 \\quad A_T = G_T\n\\]\n\n\\[\nB_1 = G_1^2 \\quad B_2 = G_2^2 \\quad B_T = G_T^4\n\\]\n\nIn order to transform the values from \\( A_i \\) to \\( B_i \\) and from \\( \\mathbb{Z}_p \\) to \\( B_i \\), respectively, we define the mappings\n\n\\[\ni_1 : A_1 \\to B_1 \\quad p_1 : B_1 \\to A_1 \\quad i_2 : A_2 \\to B_2 \\quad p_2 : B_2 \\to A_2\n\\]\n\n\\[\ni_T : A_T \\to B_T \\quad p_T : B_T \\to A_T \\quad i'_1 : \\mathbb{Z}_p \\to B_1 \\quad p'_1 : B_1 \\to \\mathbb{Z}_p\n\\]\n\n\\[\ni'_2 : \\mathbb{Z}_p \\to B_2 \\quad p'_2 : B_2 \\to \\mathbb{Z}_p \\quad i'_T : \\mathbb{Z}_p \\to B_T \\quad p'_T : B_T \\to \\mathbb{Z}_p\n\\]\n\nIn order to define these functions, we need (i) the common reference string (CRS), which has the form \\((u_1,u_2,v_1,v_2)\\) and (ii) the definition of the bilinear map \\( F \\) for the transformed sets. We start by defining the CRS components.\n\nWe define \\( u_1 \\) and \\( v_1 \\) as\n\n\\[\nu_1 := (G, \\alpha G) \\quad v_1 := (H, \\beta H)\n\\]\n\nfor some \\( \\alpha, \\beta \\in \\mathbb{Z}_p \\) where \\( \\in \\mathbb{Z}_p \\) means that the elements on the left-hand-side are chosen uniformly at random.\n\nDepending on the commitment scheme we define \\( u_2 \\) and \\( v_2 \\):\n\n\\[\nu_2 := \\begin{cases} t_1 u_1 & \\text{if binding} \\\\ t_1 u_1 - (O, G) & \\text{if hiding} \\end{cases}\n\\]\n\n\\[\nv_2 := \\begin{cases} t_2 v_1 & \\text{if binding} \\\\ t_2 v_1 - (O, H) & \\text{if hiding} \\end{cases}\n\\]\n\nIf we choose a hiding commitment scheme we will achieve witness-indistinguishability; otherwise the commitment is an El-Gamal encryption. Hence, it is binding since encryptions can only be opened with the corresponding decryption key. Our implementation\ntakes a binding commitment key in order to get proofs of knowledge. Note that in order to encrypt a message, one has to know it in advance; this is an intuitive explanation of proofs of knowledge.\n\nLet $u := u_2 - (\\mathcal{O}, \\mathcal{G})$ and $v := v_2 - (\\mathcal{O}, \\mathcal{H})$. We define $F : \\mathbb{G}_1^2 \\times \\mathbb{G}_2^2 \\rightarrow \\mathbb{G}_T^4$ as follows:\n\n$$F \\left( \\left( \\mathcal{X}_1, \\mathcal{Y}_1 \\right), \\left( \\mathcal{X}_2, \\mathcal{Y}_2 \\right) \\right) = \\left( e(\\mathcal{X}_1, \\mathcal{Y}_1) e(\\mathcal{X}_1, \\mathcal{Y}_2), e(\\mathcal{X}_2, \\mathcal{Y}_1) e(\\mathcal{X}_2, \\mathcal{Y}_2) \\right).$$\n\nNow we are ready to define the above functions. We begin with those needed to compute the commitments.\n\n$$\\iota_1(Z) := (\\mathcal{O}, Z) \\quad p_1(Z_1, Z_2) := Z_2 - \\alpha Z_1$$\n$$\\iota_2(Z) := (\\mathcal{O}, Z) \\quad p_2(Z_1, Z_2) := Z_2 - \\beta Z_1$$\n$$\\iota'_1(z) := zu \\quad p'_1(z_1 \\mathcal{G}, z_2 \\mathcal{G}) := z_2 - \\alpha z_1$$\n$$\\iota'_2(z) := zv \\quad p'_2(z_1 \\mathcal{H}, z_2 \\mathcal{H}) := z_2 - \\beta z_1$$\n\nWe need the other mappings to generate fitting values for the proof construction. The definitions are below.\n\n$$\\nu_T(z) := \\left( \\begin{array}{cc} 1 & 1 \\\\ 1 & z \\end{array} \\right) \\quad p_T(\\left( \\begin{array}{c} z_{11} \\\\ z_{21} \\\\ z_{12} \\\\ z_{22} \\end{array} \\right)) := z_{22} z_{21}^{\\alpha} (z_{21} z_{11}^{\\alpha})^{-\\beta}$$\n$$\\nu'_T(z) := F(\\iota'_1(z), \\iota'_2(z)) = F(u, v)^z \\quad p'_T(z) := \\log_{\\psi(\\mathcal{G}, \\mathcal{H})} (p_T(z))$$\n$$\\nu_T(Z) := F(\\iota_1(Z), \\iota_2(Z)) = F(\\mathcal{O}, Z) \\quad p_T(z) := c^{-1}(p_T(z))$$\n$$\\nu'_T(Z) := F(\\iota'_1(Z), \\iota'_2(1)) = F(\\mathcal{O}, Z, v) \\quad p'_T(z) := c^{-1}(p_T(z))$$\n\nGiven these functions, we can now define how we commit elements from the different groups into the corresponding other groups.\n\n**Commitment to** $\\mathcal{X} \\in \\mathbb{G}_1$. In order to compute the commitment $c$ we pick randomesses $r_1$ and $r_2$ and compute\n\n$$c := \\iota_1(\\mathcal{X}) + r_1 u_1 + r_2 u_2.$$\n\n**Commitment to** $\\mathcal{Y} \\in \\mathbb{G}_2$. In order to compute the commitment $d$ we pick randomesses $s_1$ and $s_2$ and compute\n\n$$d := \\iota_2(\\mathcal{Y}) + s_1 v_1 + s_2 v_2.$$\n\n**Commitment to** $x \\in \\mathbb{Z}_p$. In order to compute a commitment of an exponent $x$ into one of the groups $\\mathbb{G}_1$ or $\\mathbb{G}_2$ we pick randomness $r_1$ or $s_1$, depending on which group we choose and compute either\n\n$$c' := \\iota'_1(x) + r_1 u_1 \\quad \\text{or} \\quad d' := \\iota'_2(x) + s_1 v_1.$$\nA.1.3 Proof Construction\n\nGiven the commitment construction functions and the common reference string, we can now proceed by explaining how we construct the proofs for the different types of equations.\n\nLet $\\vec{X} \\in G^n_1$, $\\vec{Y} \\in G^n_2$, $\\vec{x} \\in \\mathbb{Z}^{n'}_p$, and $\\vec{y} \\in \\mathbb{Z}^{m'}_p$ be the witnesses of the proof. Then, at first, we compute the commitments to the different witnesses. So we define for each of the different $\\iota$ functions the extension to vectors for some $n$-ary vector $\\vec{z}$ as\n\n$$\n\\iota(\\vec{z}) := \\begin{pmatrix}\n\\iota(z_1) \\\\\n\\vdots \\\\\n\\iota(z_n)\n\\end{pmatrix},\n$$\n\nFurthermore, let $\\vec{u} = (u_1, u_2)\\top$ and $\\vec{v} = (v_1, v_2)\\top$. We randomly choose $R \\in \\mathbb{Z}^{n \\times 2}_p$, $S \\in \\mathbb{Z}^{m \\times 2}_p$, and compute\n\n$$\n\\bar{c} := \\iota_1(\\vec{X}) + Ru \\\\\n\\bar{d} := \\iota_2(\\vec{Y}) + Sv.\n$$\n\nNow we can continue with the proof constructions for the different equation types.\n\n**Pairing Product Equations.** For equations of the form $(\\vec{A} \\cdot \\vec{Y})(\\vec{X} \\cdot \\vec{B})(\\vec{X} \\cdot \\Gamma \\vec{Y}) = t_T$ where $\\vec{A} \\in G^n_1$, $\\vec{B} \\in G^n_2$, $\\Gamma \\in \\mathbb{Z}^{n \\times m}_p$, and $t_T \\in G_T$, choose a random matrix $T \\in \\mathbb{Z}^{2 \\times 2}_p$ and compute the pair of vectors $(\\vec{\\pi}, \\vec{\\theta}) \\in G^{2 \\times 2}_2 \\times G^{2 \\times 2}_1$ as\n\n$$\n\\vec{\\pi} := R^\\top \\iota_2(\\vec{B}) + R^\\top \\Gamma \\iota_2(\\vec{Y}) + (R^\\top \\Gamma S - T^\\top) \\vec{u} \\\\\n\\vec{\\theta} := S^\\top \\iota_1(\\vec{A}) + S^\\top \\Gamma^\\top \\iota_1(\\vec{X}) + T \\vec{u}.\n$$\n\n(A.3) (A.4)\n\nIf either of both, $\\vec{X}$ or $\\vec{Y}$ is not present, that is, we have either an equation of the form $\\vec{A} \\cdot \\vec{Y} = t_T$ or $\\vec{X} \\cdot \\vec{B} = t_T$ then we compute either\n\n$$\n\\vec{\\pi} := R^\\top \\iota_2(\\vec{B}) \\text{ or } \\vec{\\theta} := S^\\top \\iota_1(\\vec{A}).\n$$\n\n**Multi-Scalar Multiplication Equations in $G_1$.** For equations of the form $\\vec{A} \\cdot \\vec{y} + \\vec{X} \\cdot \\vec{B} + \\vec{X} \\cdot \\Gamma \\vec{y} = T_1$ where $\\vec{A} \\in G^n_1$, $\\vec{B} \\in \\mathbb{Z}^{n'}_p$, $\\vec{x} \\in \\mathbb{Z}^{n \\times m'}_p$, and $T_1 \\in G_1$, choose a random matrix $T \\in \\mathbb{Z}^{1 \\times 2}_p$ and compute the vector-value pair $(\\vec{\\pi}, \\vec{\\theta}) \\in G^{2 \\times 2}_2 \\times G^{2 \\times 2}_1$ as\n\n$$\n\\vec{\\pi} := R^\\top \\iota_2'(\\vec{B}) + R^\\top \\Gamma \\iota_2'(\\vec{y}) + (R^\\top \\Gamma S - T^\\top) \\vec{v}_1 \\\\\n\\vec{\\theta} := S^\\top \\iota_1(\\vec{A}) + S^\\top \\Gamma^\\top \\iota_1(\\vec{X}) + T \\vec{u}.\n$$\n\n(A.5) (A.6)\nCryptographic Implementation\n\nIf either of both, $\\vec{X}$ or $\\vec{Y}$ is not present, that is, we have either an equation of the form $\\vec{A} \\cdot \\vec{Y} = \\mathcal{T}_1$ or $\\vec{X} \\cdot \\vec{b} = \\mathcal{T}_1$ then we compute either\n\n$$\\vec{\\pi} := R\\top \\iota_2(\\vec{b}) \\quad \\text{or} \\quad \\theta := \\vec{s}\\top \\iota_1(\\vec{A}).$$\n\n**Multi-Scalar Multiplication Equations in $\\mathbb{G}_2$.** For equations of the form $\\vec{a} \\cdot \\vec{Y} + \\vec{X} \\cdot \\vec{b} = \\mathcal{T}_2$ where $\\vec{a} \\in \\mathbb{Z}_p^m$, $\\vec{b} \\in \\mathbb{G}_2^m$, $\\Gamma \\in \\mathbb{Z}_p^{m' \\times m}$, and $\\mathcal{T}_2 \\in \\mathbb{G}_2$, choose a random matrix $\\mathcal{T} \\in \\mathbb{Z}_p^{2 \\times 1}$ and compute the value-vector pair $(\\vec{\\pi}, \\vec{\\theta}) \\in \\mathbb{G}_2^2 \\times \\mathbb{G}_1^2$ as\n\n$$\\vec{\\pi} := r\\top \\iota_2(\\vec{b}) + r\\top \\Gamma \\iota_2(\\vec{Y}) + (r\\top \\Gamma S - \\mathcal{T}\\top)\\vec{v} \\quad \\text{(A.7)}$$\n$$\\vec{\\theta} := S\\top \\iota_1(\\vec{a}) + S\\top \\Gamma \\iota_1(\\vec{x}) + Tu_1. \\quad \\text{(A.8)}$$\n\nIf either of both, $\\vec{x}$ or $\\vec{Y}$ is not present, that is, we have either an equation of the form $\\vec{a} \\cdot \\vec{Y} = \\mathcal{T}_2$ or $\\vec{X} \\cdot \\vec{b} = \\mathcal{T}_2$ then we compute either\n\n$$\\vec{\\pi} := r\\top \\iota_2(\\vec{b}) \\quad \\text{or} \\quad \\vec{\\theta} := S\\top \\iota_1(\\vec{a}).$$\n\n**Quadratic Equations.** For equations of the form $\\vec{a} \\cdot \\vec{Y} + \\vec{x} \\cdot \\vec{b} + \\vec{x} \\cdot \\Gamma \\vec{Y} = t$ where $\\vec{a} \\in \\mathbb{Z}_p^m$, $\\vec{b} \\in \\mathbb{Z}_p^m$, $\\Gamma \\in \\mathbb{Z}_p^{m' \\times m}$, and $t \\in \\mathbb{Z}_p$, choose a random value $\\mathcal{T} \\in \\mathbb{Z}_p$ and compute the value pair $(\\vec{\\pi}, \\vec{\\theta}) \\in \\mathbb{G}_2^2 \\times \\mathbb{G}_1^2$ as\n\n$$\\vec{\\pi} := r\\top \\iota_2(\\vec{b}) + r\\top \\Gamma \\iota_2(\\vec{y}) + (r\\top \\Gamma S - \\mathcal{T}\\top)v_1 \\quad \\text{(A.9)}$$\n$$\\vec{\\theta} := s\\top \\iota_1(\\vec{a}) + s\\top \\Gamma \\iota_1(\\vec{x}) + Tu_1. \\quad \\text{(A.10)}$$\n\nIf either of both, $\\vec{x}$ or $\\vec{Y}$ is not present, that is, we have either an equation of the form $\\vec{a} \\cdot \\vec{Y} = t$ or $\\vec{x} \\cdot \\vec{b} = t$ then we compute either\n\n$$\\vec{\\pi} := r\\top \\iota_2(\\vec{b}) \\quad \\text{or} \\quad \\vec{\\theta} := s\\top \\iota_1(\\vec{a}).$$\n\n### A.1.4 Proof Verification\n\nGiven a constructed proof tuple we verify them according to the equations they are supposed to prove by checking equality for the following equations.\n\n**Pairing Product Equations.** For equations of the form $(\\vec{A} \\cdot \\vec{Y})(\\vec{X} \\cdot \\vec{B})(\\vec{X} \\cdot \\Gamma \\vec{Y}) = \\mathcal{T}_T$ and a given proof tuple $(\\vec{\\pi}, \\vec{\\theta})$ we check that\n\n$$\\iota_1(\\vec{A}) \\bullet \\vec{d} + \\vec{c} \\bullet \\iota_2(\\vec{B}) + \\vec{c} \\bullet \\Gamma \\vec{d} = \\mathcal{T}_T(\\mathcal{T}_T) + \\vec{u} \\bullet \\vec{\\pi} + \\vec{\\theta} \\bullet \\vec{v}. \\quad \\text{(A.11)}$$\n\nIf the left-hand-side is equal to the right-hand-side we say that the proof verifies and otherwise not.\nMulti-Scalar Multiplication Equations in $\\mathbb{G}_1$. For equations of the form $\\vec{A} \\cdot \\vec{y} + \\vec{X} \\cdot \\vec{b} + \\vec{X} \\cdot \\Gamma \\vec{y} = T_1$ and a proof tuple $(\\vec{a}, \\vec{b})$ we check that\n\n$$\\nu_1(\\vec{A}) \\cdot \\vec{a} + \\vec{c} \\cdot \\nu_2(\\vec{b}) + \\vec{c} \\cdot \\Gamma \\vec{d} = \\nu_T(T_1) + \\vec{u} + F(\\theta, \\nu_1). \\quad (A.12)$$\n\nMulti-Scalar Multiplication Equations in $\\mathbb{G}_2$. For equations of the form $\\vec{a} \\cdot \\vec{y} + \\vec{x} \\cdot \\vec{b} + \\vec{x} \\cdot \\Gamma \\vec{y} = T_2$ and a proof tuple $(\\vec{a}, \\vec{b})$ we check that\n\n$$\\nu_1'(\\vec{a}) \\cdot \\vec{a} + \\vec{c} \\cdot \\nu_2'(\\vec{b}) + \\vec{c} \\cdot \\Gamma \\vec{d} = \\nu_T'(T_2) + F(u_1, \\nu) + \\vec{v}. \\quad (A.13)$$\n\nQuadratic Equations. For equations of the form $\\vec{a} \\cdot \\vec{y} + \\vec{x} \\cdot \\vec{b} + \\vec{x} \\cdot \\Gamma \\vec{y} = t$ and a proof tuple $(\\vec{a}, \\vec{b})$ we check that\n\n$$\\nu_1'(\\vec{a}) \\cdot \\vec{a} + \\vec{c} \\cdot \\nu_2'(\\vec{b}) + \\vec{c} \\cdot \\Gamma \\vec{d} = \\nu_T'(t) + F(u_1, \\nu) + F(\\theta, \\nu_1). \\quad (A.14)$$\n\nA.1.5 Correctness Proofs\n\nIn this section we prove that the verification step succeeds if and only if, the proof to verify was computed correctly.\n\n**Lemma A.4.** Let $\\vec{X} \\in \\mathbb{G}_1^m, \\vec{Y} \\in \\mathbb{G}_2^m, R \\in \\mathbb{Z}_p^{n \\times 2}$ and $S \\in \\mathbb{Z}_p^m$ such that they satisfy\n\n$$\\vec{c} = \\nu_1(\\vec{X}) + R\\vec{u} \\quad \\vec{d} = \\nu_2(\\vec{Y}) + S\\vec{v} \\quad (\\vec{A} \\cdot \\vec{Y})(\\vec{X} \\cdot \\vec{B})(\\vec{X} \\cdot \\vec{Y}) = tT.$$\n\nThen we have for all $T \\in \\mathbb{Z}_p^{2 \\times 2}$, $\\vec{a}$ as constructed in (A.3) and $\\vec{b}$ as constructed in (A.4) that the verification equation (A.11) holds.\n\n**Proof.** By the commutative property of the linear and bilinear maps we have for the above equation\n\n$$(\\nu_1(\\vec{A}) \\cdot \\nu_2(\\vec{Y}))((\\nu_1(\\vec{X}) \\cdot \\nu_2(\\vec{B}))(\\nu_1(\\vec{X}) \\cdot \\Gamma \\nu_2(\\vec{Y}))) = \\nu_T(tT).$$\n\nLet $T \\in \\mathbb{Z}_p^{2 \\times 2}$ be a random matrix. Then we have\n\n$$\\nu_1(\\vec{A}) \\cdot \\vec{a} + \\vec{c} \\cdot \\nu_2(\\vec{B}) + \\vec{c} \\cdot \\Gamma \\vec{d}\n= \\nu_1(\\vec{A}) \\cdot ((\\nu_2(\\vec{Y}) + S\\vec{v}) + (\\nu_1(\\vec{X}) + R\\vec{u}) \\cdot \\nu_2(\\vec{B}) + (\\nu_1(\\vec{X}) + R\\vec{u}) \\cdot \\Gamma (\\nu_2(\\vec{Y}) + S\\vec{v})\n= (\\nu_1(\\vec{A}) \\cdot \\nu_2(\\vec{Y}))(\\nu_1(\\vec{X}) \\cdot \\nu_2(\\vec{B}))(\\nu_1(\\vec{X}) \\cdot \\Gamma \\nu_2(\\vec{Y}))) + \\vec{u} \\cdot T \\vec{v} - T\\vec{u} \\cdot \\vec{v}\n= \\nu_T(tT) + \\vec{u} \\cdot (( \\Gamma \\nu_2(\\vec{B}))) + \\Gamma \\nu_2(\\vec{Y}) + R\\vec{u} \\cdot \\Gamma S\\vec{v} + \\nu_1(\\vec{X}) \\cdot \\Gamma S\\vec{v}\n= \\nu_T(tT) + \\vec{u} \\cdot \\left[ (R^T \\nu_2(\\vec{B}) + R^T \\Gamma \\nu_2(\\vec{Y}) + R\\vec{u} \\cdot \\Gamma S\\vec{v} + \\nu_1(\\vec{X}) \\cdot \\Gamma S\\vec{v}) \\right] - \\vec{v}\n= \\nu_T(tT) + \\vec{u} \\cdot \\vec{v} + \\vec{a} \\cdot \\vec{b}.$$\nLemma A.5. Let $\\vec{X} \\in \\mathbb{G}_m^1, \\vec{y} \\in \\mathbb{Z}_p^{m'}, R \\in \\mathbb{Z}_p^{n \\times 2}$ and $\\vec{s} \\in \\mathbb{Z}_p^{m'}$ such that they satisfy\n\\[\n\\vec{c} = \\iota_1(\\vec{X}) + R\\vec{a} \\quad \\vec{d}' = \\iota'_2(\\vec{y}) + \\vec{s}\\vec{v}_1 \\quad \\vec{A} \\cdot \\vec{y} + \\vec{b} + \\vec{X} \\cdot \\vec{y} = T_1.\n\\]\nThen we have for all $T \\in \\mathbb{Z}_p^{1 \\times 2}$, $\\vec{\\pi}$ as constructed in (A.5) and $\\vec{\\theta}$ as constructed in (A.6) that the verification equation (A.12) holds.\n\nProof. The proof is analogous to that of Lemma A.4. \\qed\n\nLemma A.6. Let $\\vec{x} \\in \\mathbb{Z}_p^{m'}, \\vec{Y} \\in \\mathbb{G}_m^2, \\vec{r} \\in \\mathbb{Z}_p^{n \\times 2}$ and $S \\in \\mathbb{Z}_p^{m \\times 2}$ such that they satisfy\n\\[\n\\vec{c}' = \\iota'_1(\\vec{x}) + \\vec{r}\\vec{u}_1 \\quad \\vec{d}' = \\iota_2(\\vec{Y}) + S\\vec{v} \\quad \\vec{a} \\cdot \\vec{Y} + \\vec{x} \\cdot \\vec{b} + \\vec{x} \\cdot \\vec{y} = T_2.\n\\]\nThen we have for all $T \\in \\mathbb{Z}_p^{2 \\times 1}$, $\\vec{\\pi}$ as constructed in (A.7) and $\\vec{\\theta}$ as constructed in (A.8) that the verification equation (A.13) holds.\n\nProof. The proof is analogous to that of Lemma A.4. \\qed\n\nLemma A.7. Let $\\vec{x}, \\vec{r} \\in \\mathbb{Z}_p^{m'}, \\vec{y}, \\vec{s} \\in \\mathbb{Z}_p^{m'}$ such that they satisfy\n\\[\n\\vec{c}' = \\iota'_1(\\vec{x}) + \\vec{r}\\vec{u}_1 \\quad \\vec{d}' = \\iota'_2(\\vec{y}) + \\vec{s}\\vec{v}_1 \\quad \\vec{a} \\cdot \\vec{y} + \\vec{x} \\cdot \\vec{b} + \\vec{x} \\cdot \\vec{y} = t.\n\\]\nThen we have for all $T \\in \\mathbb{Z}_p^{r \\times 1}$, $\\vec{\\pi}$ as constructed in (A.9) and $\\vec{\\theta}$ as constructed in (A.10) that the verification equation (A.14) holds.\n\nProof. The proof is analogous to that of Lemma A.4. \\qed\n\nCorollary A.8. The composition of the Lemmas A.4, A.5, A.6, and A.7 gives the desired correctness result for the Groth-Sahai proof scheme.\n\nA.2 Re-randomization of Zero-Knowledge Proofs\n\nThe construction in this section is inspired by [BCC+09] whereas they use multiplicative notation where we use additive notation. Additionally, we show how to re-randomize all kinds of equations. We proceed as before: we start with the modification of commitments (cf. Section A.2.1), continue with the proof modification (cf. Section A.2.2) followed by the verification of modified proofs (cf. Section A.2.3), and finally, we prove our construction correct (cf. Section A.2.4).\n\nA.2.1 Commitment Modification\n\nGiven witnesses $\\vec{X}$, $\\vec{Y}$, $\\vec{x}$, and $\\vec{y}$, and the corresponding commitments $\\vec{c}$, $\\vec{d}$, $\\vec{c}'$, and $\\vec{d}'$, which satisfy for specific $R$, $S$, $\\vec{r}$, and $\\vec{s}$\n\\[\n\\vec{c} = \\iota_1(\\vec{X}) + R\\vec{a} \\quad \\vec{d} = \\iota_2(\\vec{Y}) + S\\vec{v} \\quad \\vec{c}' = \\iota'_1(\\vec{x}) + \\vec{r}\\vec{u}_1 \\quad \\vec{d}' = \\iota'_2(\\vec{y}) + \\vec{s}\\vec{v}_1\n\\]\nwe re-randomize the commitments in the following way. We pick new randomnesses $R'$, $S'$, $\\vec{r}'$, and $\\vec{s}'$, and compute the adapted commitments\n\\[\n\\vec{c} := \\vec{c} + R'\\vec{u} \\quad \\vec{d} := \\vec{d} + S'\\vec{v} \\quad \\vec{c}' := \\vec{c}' + \\vec{r}'\\vec{u}_1 \\quad \\vec{d}' := \\vec{d}' + \\vec{s}'\\vec{v}_1.\n\\]\nWith these new commitments we can now proceed by adapting the proofs accordingly.\nA.2 Re-randomization of Zero-Knowledge Proofs\n\nA.2.2 Proof Modification\n\nLet \\( \\vec{c}, \\vec{d}, \\tilde{c}, \\) and \\( \\tilde{d} \\) be the adapted commitments as constructed above. Then we re-randomize the proofs constructed in Section A.1.3 as follows.\n\n**Pairing Product Equations.** We choose a random matrix \\( T' \\in \\mathbb{Z}_p^{2 \\times 2} \\) and compute the adapted proof pair \\((\\vec{\\pi}', \\vec{\\theta}')\\) as\n\n\\[\n\\vec{\\pi}' := \\vec{\\pi} + R'\\top \\left[ \\iota_2(\\vec{b}) + \\Gamma \\vec{d} + \\Gamma S' \\vec{v} \\right] - T'\\top \\vec{v},\n\\]\n\n\\[\n\\vec{\\theta}' := \\vec{\\theta} + S'\\top \\left[ \\iota_1(\\vec{A}) + \\Gamma \\top \\vec{c} \\right] + T' \\vec{u}.\n\\]\n\n**Multi-Scalar Multiplication Equations in \\( G_1 \\).** We choose a random matrix \\( T' \\in \\mathbb{Z}_p^{1 \\times 2} \\) and compute the adapted proof pair \\((\\vec{\\pi}', \\vec{\\theta}')\\) as\n\n\\[\n\\vec{\\pi}' := \\vec{\\pi} + R'\\top \\left[ \\iota_2(\\vec{b}) + \\Gamma \\vec{d} + \\Gamma S' \\vec{v}_1 \\right] - T'\\top \\vec{v}_1,\n\\]\n\n\\[\n\\vec{\\theta}' := \\vec{\\theta} + S'\\top \\left[ \\iota_1(\\vec{A}) + \\Gamma \\top \\vec{c} \\right] + T' \\vec{u}_1.\n\\]\n\n**Multi-Scalar Multiplication Equations in \\( G_2 \\).** We choose a random matrix \\( T' \\in \\mathbb{Z}_p^{2 \\times 1} \\) and compute the adapted proof pair \\((\\pi', \\theta')\\) as\n\n\\[\n\\pi' := \\pi + \\vec{r}' \\top \\left[ \\iota_2(\\vec{b}) + \\Gamma \\vec{d} + \\Gamma S' \\vec{v} \\right] - T'\\top \\vec{v},\n\\]\n\n\\[\n\\theta' := \\theta + S'\\top \\left[ \\iota_1(\\vec{a}) + \\Gamma \\top \\vec{c} \\right] + T' \\vec{u}_1.\n\\]\n\n**Quadratic Equations.** We choose a random value \\( T' \\in \\mathbb{Z}_p \\) and compute the adapted proof pair \\((\\pi', \\theta')\\) as\n\n\\[\n\\pi' := \\pi + \\vec{r}' \\top \\left[ \\iota_2(\\vec{b}) + \\Gamma \\vec{d} + \\Gamma S' \\vec{v}_1 \\right] - T' \\vec{v}_1,\n\\]\n\n\\[\n\\theta' := \\theta + S'\\top \\left[ \\iota_1(\\vec{a}) + \\Gamma \\top \\vec{c} \\right] + T' \\vec{u}_1.\n\\]\n\nA.2.3 Verification\n\nIn order to verify that a given proof actually shows the knowledge of a solution to an equation, we apply the Equations (A.11), (A.12), (A.13), and (A.14). We apply them to the adapted commitments and proofs, that is, \\( \\vec{c}, \\vec{d}, \\tilde{c}, \\) and \\( \\tilde{d}, \\) and \\( \\vec{\\pi}', \\pi', \\vec{\\theta}', \\) or \\( \\theta' \\).\n\nA.2.4 Correctness\n\nIn this section, we prove the correctness of the above construction for pairing product equations. The proofs for all other equations are analogous.\nLemma A.9. Let $\\vec{X}, \\vec{Y}, R, S, R'$, and $S'$ such that they satisfy\n\\[ \\vec{c} = \\iota_1(\\vec{X}) + R\\vec{u} + R'\\vec{u} \\quad \\vec{d} = \\iota_2(\\vec{Y}) + S\\vec{v} + S'\\vec{v} \\quad (\\vec{A} \\cdot \\vec{Y})(\\vec{X} \\cdot \\vec{E})(\\vec{X} \\cdot \\vec{F}) = t_T. \\]\nThen, for all $T, \\vec{\\pi}^T$ as constructed in (A.15), and $\\vec{\\theta}^T$ as constructed in (A.16), the verification equation (A.11) is fulfilled.\n\nProof. By the commutative property of the linear and bilinear maps we have for the above equation\n\\[ (\\iota_1(\\vec{A}) \\cdot \\iota_2(\\vec{Y}))(\\iota_1(\\vec{X}) \\cdot \\iota_2(\\vec{B}))(\\iota_1(\\vec{X}) \\cdot \\Gamma \\iota_2(\\vec{Y})) = \\nu_T(t_T). \\]\nLet $T' \\in \\mathbb{Z}_{p^2}^{2 \\times 2}$ be a random matrix. Then we have\n\\[\n\\begin{align*}\n\\nu_1(\\vec{A}) \\cdot \\vec{d} + \\vec{c} \\cdot \\nu_2(\\vec{B}) + \\vec{c} \\cdot \\Gamma \\vec{d} & = \\nu_1(\\vec{A}) \\cdot \\vec{d} + S\\vec{v} + (\\vec{c} + R'\\vec{u}) \\cdot \\nu_2(\\vec{B}) + (\\vec{c} + R'\\vec{u}) \\cdot \\Gamma (\\vec{d} + S'\\vec{v}) \\\\\n& = \\nu_1(\\vec{A}) \\cdot \\vec{d} + \\vec{c} \\cdot \\nu_2(\\vec{B}) + \\vec{c} \\cdot \\Gamma \\vec{d} + T'\\vec{u} \\cdot \\vec{v} - \\vec{u} \\cdot T'^\\top \\vec{v} \\\\\n& + \\nu_1(\\vec{A}) \\cdot S'\\vec{v} + R'\\vec{u} \\cdot \\nu_2(\\vec{B}) + R'\\vec{u} \\cdot \\Gamma \\vec{d} + \\vec{c} \\cdot \\Gamma S'\\vec{v} + R'\\vec{u} \\cdot \\Gamma S'\\vec{v} \\\\\n& = \\nu_T(t_T) + \\vec{u} \\cdot \\vec{\\pi} + \\vec{\\theta} \\cdot \\vec{v} + T'\\vec{u} \\cdot \\vec{v} - \\vec{u} \\cdot T'^\\top \\vec{v} \\\\\n& + \\nu_1(\\vec{A}) \\cdot S'\\vec{v} + R'\\vec{u} \\cdot \\nu_2(\\vec{B}) + R'\\vec{u} \\cdot \\Gamma \\vec{d} + \\vec{c} \\cdot \\Gamma S'\\vec{v} + R'\\vec{u} \\cdot \\Gamma S'\\vec{v} \\\\\n& = \\nu_T(t_T) + \\vec{u} \\cdot \\left( \\vec{\\pi} + R'^\\top \\left[ \\iota_2(\\vec{B}) + \\Gamma \\vec{d} + \\Gamma S'\\vec{v} \\right] - T'^\\top \\vec{v} \\right) \\quad \\substack{\\text{=} \\vec{\\pi}^T \\vec{v} \\\\ \\text{=} \\vec{\\theta}^T \\vec{v}} \\\\\n& + \\left( \\vec{\\theta} + S'^\\top \\left[ \\iota_1(\\vec{A}) + \\Gamma \\vec{c} \\right] + T'^\\top \\vec{u} \\right) \\cdot \\vec{v} \\quad \\substack{\\text{=} \\vec{\\pi}^T \\vec{v} \\\\ \\text{=} \\vec{\\theta}^T \\vec{v}} \\\\\n& = \\nu_T(t_T) + \\vec{u} \\cdot \\vec{\\pi}^T + \\vec{\\theta} \\cdot \\vec{v}. \\quad \\Box\n\\end{align*}\n\\]\n\nA.3 Automorphic Signatures for Message Vectors\n\nWe show how to sign message vectors. This requires two steps. Firstly, in Section A.3.1 we explain how to sign message pairs. Based on that, in Section A.3.2, we show how to sign message vectors.\n\nA.3.1 Automorphic Tuple Signatures\n\nThe idea behind signing message pairs is the following: firstly, we generate an internal key-pair; secondly, we use this key-pair to sign and verify three different combinations of the two messages. More formally, the instantiation of the signature scheme for message pairs is given by the following two algorithms (SetupSS and KeyGen are the same as in Section 2.4.5):\nPairSign\\((p_{\\text{sig}}, m_1, m_2, sk)\\). On input \\(p_{\\text{sig}}\\), two messages \\(m_1\\) and \\(m_2\\), and a secret signing key \\(sk\\), this algorithm performs the following steps:\n\n- It uses KeyGen to generate a fresh key-pair \\((sk_0, vk_0)\\) that is used in the internal signing process.\n- It creates the following four signatures using the algorithm Sign:\n\n\\[\n\\begin{align*}\n\\sigma_1 &= \\text{Sign}(p_{\\text{sig}}, vk_0, sk) \\quad \\text{(A.23)} \\\\\n\\sigma_2 &= \\text{Sign}(p_{\\text{sig}}, m_1, sk_0) \\quad \\text{(A.24)} \\\\\n\\sigma_3 &= \\text{Sign}(p_{\\text{sig}}, m_1 \\cdot m_2, sk_0) \\quad \\text{(A.25)} \\\\\n\\sigma_4 &= \\text{Sign}(p_{\\text{sig}}, m_1 \\cdot m_3^2, sk_0) \\quad \\text{(A.26)}\n\\end{align*}\n\\]\n\n- It outputs the tuple \\(\\sigma = (vk_0, \\sigma_1, \\sigma_2, \\sigma_3, \\sigma_4)\\).\n\nEquation (A.23) represents a signature issued by the creator of the overall signature \\(sk\\) on the freshly generated verification key \\(vk_0\\). Equation (A.24) shows a signature on the first message \\(m_1\\) using the signing key \\(sk_0\\) corresponding to the just authenticated verification key \\(vk_0\\). The same key is used to generate the signatures in Equations (A.25) and (A.26) on two message combinations \\(m_1 \\cdot m_2\\) and \\(m_1 \\cdot m_3^2\\), respectively. Fuchsbauer [Fuc09] proves that these three signatures on linear combinations of \\(m_1\\) and \\(m_2\\) are indeed necessary to protect the scheme against attacks. For instance, the exponents of \\(m_1\\) and \\(m_2\\), respectively, may neither be linearly dependent nor linearly independent if only two such combinations are signed. Also, finding fitting exponents for three such message combinations is not trivial.\n\nPairVerify\\((p_{\\text{sig}}, \\sigma, m_1, m_2, vk)\\). On input \\(p_{\\text{sig}}\\), a signature tuple \\(\\sigma = (vk_0, \\sigma_1, \\sigma_2, \\sigma_3, \\sigma_4)\\), two messages \\(m_1\\) and \\(m_2\\), and a verification key \\(vk\\) this algorithm returns 1 if all of the following signature verifications succeed and 0 otherwise\n\n\\[\n\\begin{align*}\n\\text{VerifySig}(p_{\\text{sig}}, \\sigma_1, vk_0, vk) & \\quad \\text{VerifySig}(p_{\\text{sig}}, \\sigma_2, m_1, vk_0) \\\\\n\\text{VerifySig}(p_{\\text{sig}}, \\sigma_3, m_1 \\cdot m_2, vk_0) & \\quad \\text{VerifySig}(p_{\\text{sig}}, \\sigma_4, m_1 \\cdot m_3^2, vk_0)\n\\end{align*}\n\\]\n\nFuchsbauer [Fuc09] proves that the scheme \\((\\text{SetupSS}, \\text{KeyGen}, \\text{PairSign}, \\text{PairVerify})\\) is secure against chosen-message attacks if the scheme \\((\\text{SetupSS}, \\text{KeyGen}, \\text{Sign}, \\text{VerifySig})\\) is secure. In fact, this is no surprise since the pair scheme depends only on the underlying signature scheme for one message.\n\n### A.3.2 Automorphic Vector Signatures\n\nBased on the transformation above we can now extend our message space to message vectors of length \\(n\\) lying in the message space \\(DH^n\\). Again, SetupSS and KeyGen are the same as in Section 2.4.5. We just instantiate two new algorithms for message vectors which use the pair algorithms. Let \\(I : \\{1, \\ldots, |DH|\\} \\to DH\\) be an efficiently computable injection.\nVectorSign\\((p_{\\text{sig}}, \\mathbf{m}, \\mathbf{sk})\\). On input \\(p_{\\text{sig}}\\), messages \\(\\mathbf{m}\\), and a secret signing key \\(\\mathbf{sk}\\) this algorithm performs the following steps:\n\n- It uses KeyGen to generate a fresh key-pair \\((\\mathbf{sk}_0, \\mathbf{vk}_0)\\) that is used in the internal signing process.\n- It returns the following vector using the algorithm PairSign:\n\n\\[\n\\mathbf{sig} = (\\mathbf{vk}_0, \\text{PairSign}(p_{\\text{sig}}, \\mathbf{vk}_0, I(n), \\mathbf{sk}), \\text{PairSign}(p_{\\text{sig}}, m_1, I(1), \\mathbf{sk}_0), \\ldots, \\text{PairSign}(p_{\\text{sig}}, m_n, I(n), \\mathbf{sk}_0)).\n\\]\n\nJust like in the pair signature scheme, this algorithm first chooses a fresh key-pair and authenticates the internal verification key \\(\\mathbf{vk}_0\\) together with a value indicating the length of the vector. This length parameter is indispensable to make the scheme secure. Otherwise a forgery compromising the length of the message vector would be easily possible. Due to this fact the length parameter \\(I(j)\\) is also included in every message signature for \\(j\\) from 1 to \\(n\\). This protects against forgeries that shuffle the messages.\n\nVectorVerify\\((p_{\\text{sig}}, \\mathbf{sig}, \\mathbf{vk})\\). On input \\(p_{\\text{sig}}\\), a vector signature \\(\\mathbf{sig} = (\\mathbf{vk}_0, \\mathbf{sig}_0, \\mathbf{sig}_1, \\ldots, \\mathbf{sig}_n)\\), and a verification key \\(\\mathbf{vk}\\) this algorithm returns 1 if all of the following verifications succeed and 0 otherwise:\n\n\\[\n\\text{PairVerify}(p_{\\text{sig}}, \\mathbf{sig}_0, \\mathbf{vk}_0, I(n), \\mathbf{vk})\n\\]\n\\[\n\\text{PairVerify}(p_{\\text{sig}}, \\mathbf{sig}_1, m_1, I(1), \\mathbf{vk}_0) \\quad \\cdots \\quad \\text{PairVerify}(p_{\\text{sig}}, \\mathbf{sig}_n, m_n, I(n), \\mathbf{vk}_0).\n\\]\n\nAgain, Fuchsbauer [Fuc09] proves that this scheme is secure if the underlying pair signature scheme is secure. By transitivity, this scheme is secure if the signature scheme \\((\\text{SetupSS}, \\text{KeyGen}, \\text{Sign}, \\text{VerifySig})\\) is secure.\n\nThe ability to sign message vectors is necessary to provide the user with an implementation of the PA-PKA framework that allows for arbitrary predicates. The number of signatures that we have to create for a predicate of length \\(n\\) is given by the following formula:\n\n\\[\n\\#_{\\text{sig}}(n) = 4 \\cdot (n + 1). \\tag{A.27}\n\\]\n\nThis comes from the fact that we have to create \\(n + 1\\) pair signatures for \\(n\\) messages incurring 4 standard signatures each. For instance, the predicate \\textit{Prof says Reg(Stud, \\ell ec)} requires to sign the vector \\((\\text{Reg, Stud, \\ell ec})\\), that is, 3 arguments, resulting in 16 standard signature creations.\n\nConcerning zero-knowledge proofs of signatures, the number of pairing product equations that we have to prove is important rather than the number of signatures. As each proof of a standard signature requires the solution of three pairing product equations, the number of pairing product equations for a vector signature is given by the following formula:\n\n\\[\n\\#_{\\text{Equations}}(n) = 3 \\cdot 4 \\cdot (n + 1) = 12 \\cdot (n + 1). \\tag{A.28}\n\\]\nAppendix B\n\nAsplada – Language Specification\n\nIn order to abstract away cryptography as much as possible, we invented a language to create and manipulate identities and proofs. We call it “language for automated synthesis of privacy-, linearity- and authorization-aware distributed applications” (Asplada). In Section B.1, we explain the syntax and semantics of Asplada, that is, how the syntactic primitives are translated into Java code, and in Section B.2, we present an example to give an impression on its usage convenience.\n\nB.1 Language Description\n\nThe complete syntax for this language is depicted in Table B.1. A general integration of Asplada into Java is easy. We start with /*$, continue with the Asplada block, and finish with $*/. An illustration is depicted in Listing B.1. This way we make the mixed Java-Asplada code again valid Java code since the Asplada block is written like a comment in Java.\n\nIn Asplada, there are primitives to construct and verify proofs as described in Chapter 2. The idea is to go from a logical description of the proof, that is, the deduction tree produced in the PA-PCA zero-knowledge deduction system in step-wise form from top to bottom. The following paragraphs describe the primitives in more detail.\n\nPredicate. If we read an atomic predicate or a zero-knowledge statement, for instance, exists X. A says P(X), we create the corresponding AtomicPredicate object for this\n\n```\n1 //java code\n2 /*$\n3 meta language code\n4 $*/\n5 //java code\n6 //...\n```\nTable B.1 The grammar for Asplada.\n\n| Name ::= (A | ... | Z) (a | ... | z | A | ... | Z | 0 | ... | 9 | ')* |\n| Newline ::= (\\r? \\n)+ |\n| Predicate ::= Exists? Sentence (/\\ Sentence)* |\n| Exists ::= exists Name (, Name)* . |\n| Sentence ::= (? | @)? Name says Name ( Arguments ) |\n| Arguments ::= (? | @)? Name, Arguments |\n| Program ::= Statement+ |\n| Statement ::= (initfields Newline)? |\n| | ((Create | Verify | Split | And | Quantify |\n| | fillfields | Keep | Randomize | Instantiate |\n| | NewName | NewId | Clear | StoreKey | LoadKey)|Newline)+ |\n| Create ::= let Name = Predicate |\n| Verify ::= verify Predicate with Name |\n| Split ::= split Name as ( Name , Name ) |\n| And ::= let Name = Name and Name |\n| Quantify ::= let Name = exists Name . Name |\n| | let Name = exists Name . Predicate from Name |\n| Keep ::= let Name = openinfo for Name in Name |\n| Randomize ::= let Name = randomize Name as Predicate |\n| Instantiate ::= let Name = instantiate Name with Name as Predicate |\n| NewName ::= newName Name | newName Name = Name |\n| | init newName Name | fill newName Name with Name |\n| NewId ::= newId Name | newId Name = Name |\n| | init newId Name | fill newId Name with Name |\n| Clear ::= clear Name |\n| StoreKey ::= store Name at Name |\n| LoadKey ::= load Name from Name |\n| | load Name from Name as Name |\n\npredicate with the issuer A, the predicate name P, and the argument X; A is of type IdKey and X is of type Variable.\n\n**NewName and NewId.** These two primitives create new names and identities, respectively. The user can decide whether she wants to fill the content directly or later on. This is very helpful to program efficiently in object oriented programming languages like Java. There are four types of usage which we detail below:\nnewName A [= B] / newId A [= B]. We create a new instance of class Name or IdKey, respectively. This means that we take the string representation of A, which is essentially 'A', and forward this as an argument to the constructor. In case of an identity, we additionally provide the PKI with a new key pair for A and the constructor uses this key pair. If, additionally, the optional = B is written, we use for the name the content of the String variable B rather than the string representation of A. This flexibilizes instantiating class instances not only with fixed values but also with, for instance, inputs from the network.\n\ninit newName A / init newId A. This primitive defines a new name or identity but not already instantiates it. Such a statement is typically written at those positions where global variables are placed.\n\nfill newName A with B / fill newId A with B. This is the followup of the above initialization primitive. It is typically written in the constructor to fill the previously created name or identity with the String stored in B.\n\nClear. Our implementation of the compiler uses a list of arguments to keep track of already known names and identities. For instance, if A is already defined, there is no need to create it twice. Indeed, there is most often not the intention to duplicate it at all. This works fine as far as there are no function definitions or separate code blocks. Consequently, if there are such blocks, a programmer is willing to define the same name several times without meaning the same name in a global context. The Clear statement helps to manage the recreation of already used name bindings. For instance, the statement clear A removes A from the global argument list and A can be reused in another context.\n\nStoreKey and LoadKey. These primitives provide features to load keys from disk and to store them on disk. store A at B stores the keys of the identity A on disk at the path given in the String variable B.\n\nload A from B [as C] offers the possibility to load formerly stored keys for principals from disk. After execution, the variable A is the identity instantiated with the keys (signing and verification key) stored at B. If the optional as C is also present, the name of A is the string stored in the variable C.\n\nThese functions are useful to keep the state of a program. For instance, most systems are not made for permanent login. Hence, when a user logs out, her keys are stored on disk (or on a secure device).\n\nCreate. With this primitive the user can create atomic predicates. For instance, a statement such as let P = A says Good(B) creates the corresponding atomic predicate A says Good(B) and stores it in P. More specifically, the statement is translated into code that generates a new instance of ProofObject incorporating a zero-knowledge proof of knowledge of the signature sign(Good(B))_{sk,A}. The signature must indeed be created before we can prove the knowledge thereof. Note that only the principal in possession of\nAsplada — Language Specification\n\nAsplada, which is in general only A itself, can construct the signature. P further refers to the constructed proof.\n\nVerify. Given a statement and a ProofObject, this primitive checks that they match each other and that the ProofObject indeed verifies. For example, the compiled version of the statement verify A says Good(B) with P first checks if P verifies. If this verification step succeeds, it proceeds by checking if the predicate to check, in our example A says Good(B), is the one proven by P: to this end we check if both, the given statement and the statement incorporated in P, are equal up to alpha-renaming of quantified variables. If this is the case the execution proceeds. In any case of failure we throw an exception which directly terminates the execution.\n\nSplit. This statement separates a conjunction apart. An instance of this statement has the form split P as (Q1, Q2). At first, note that P has to be a ProofObject instance that proves a conjunction of the form \\( \\bigwedge_{i=1}^{n} \\text{pred}_i \\). P is then split into ProofObject instances Q1 and Q2 such that Q1 proves the conjunction \\( \\bigwedge_{i=1}^{n-1} \\text{pred}_i \\) and Q2 proves the predicate \\( \\text{pred}_n \\).\n\nAnd. This statement creates a conjunction of two given ProofObjects. A statement instance that we expect is of the form let P = Q1 and Q2. The compiled code performs a conjunction of both (possibly also conjunctions) proofs, that is, if Q1 proves a conjunction \\( \\bigwedge_{i=1}^{n} \\text{pred}_i \\) and Q2 proves a conjunction \\( \\bigwedge_{i=1}^{m} \\text{pred}_i \\) then P proves the conjunction \\( \\bigwedge_{i=1}^{n} \\text{pred}_i \\land \\bigwedge_{i=1}^{m} \\text{pred}_i \\) in this order. As P refers to an instance of ProofObject it can be used as such.\n\nQuantify. There are two ways to quantify names or identities in a proof. The first one quantifies all occurrences of the specified name or identity in the statement. The statement is of the form let P = exists A. Q. This quantifies all occurrences of A in Q and copies the result into P. As usual, P can be used further as an instance of ProofObject.\n\nThe second way to quantify is selective quantification. In this version we do not specify an identity to quantify but we specify directly the variable which afterwards points to the positions to quantify. We expect statements of the following form: let P = exists X. X says Good(A) from Q. For instance, assume that Q has the form A says Good(A) which does not make sense in real applications, but for the sake of example. The primitive then compares the given statement with the statement proven by Q and quantifies the found variable at all specified positions.\n\nWe will throw an exception in the case that the input is not a well-formed statement. For instance, if the statement proven by Q is A says Good(A,B) and the given statement is exists X. A says Good(X,X). This is not well-formed since two identities that are not linked so far would be linked afterwards.\n\nKeep. This statement stores the opening information of a given identity for later usage. We expect a statement of the form let OI = openinfo for A in P. Keep is strongly\nconnected to existential instantiation, that is, in order to perform an existential instantiation one has to provide the opening information fetched by \\texttt{Keep}. In the above example, it stores the opening information for the identity \\texttt{A} from the proof \\texttt{P} in the variable \\texttt{OI}. This opening information contains the identity’s witness and randomness. Note that in order to keep opening information one needs a proof in which the identity from which we want to keep the information is not quantified.\n\n\\textbf{Instantiate.} This statement re-instantiates an identity that is quantified in the given proof, provided the corresponding opening information. We expect a statement of the form - by considering the example from above - \\texttt{let P = instantiate Q with OI as A says Good(A,B)} where \\texttt{Q} proves the predicate \\texttt{exists X. A says Good(X,B)}. Upon execution \\texttt{P} contains the proof for the predicate where \\texttt{A} is instantiated back with the use of \\texttt{OI}, the opening information formerly stored using \\texttt{Keep}. In case the given statement does not match the statement proven in \\texttt{Q}, up to existential quantification and alpha-renaming of variables, an exception is thrown. However, if the opening information \\texttt{OI} does not fit the identity that we want to instantiate then nothing happens since the instantiation does not succeed.\n\n\\textbf{Randomize.} This statement re-randomizes a selection of equal variables in a given proof. We expect a statement of the form, again taking the above example, \\texttt{let P = randomize Q as exists X'. A says Good(X',B)} Here both, \\texttt{P} and \\texttt{Q}, are instances of \\texttt{ProofObject} and \\texttt{Q} should prove the statement \\texttt{exists X. A says Good(X,B)}. We select the variables which we intend to re-randomize by marking them with an apostrophe. One can also re-randomize not quantified identities but that does not make sense since nothing will be hidden to observers: the commitment and the opening information will change, but both is revealed anyway. Note that only the apostrophized variables are really re-randomized, so marking them correctly is crucial. One should also keep in mind that a variable, once re-randomized, can never be instantiated back again. This is because the randomness of the kept opening information does not correspond to the one which is used in the re-randomized version. There is also no way to extract the changed randomness from the proof since it is a secret.\n\n\\section*{B.2 Examples}\n\nWe illustrate the convenience of \\texttt{Asplada} by an example. We implement the friend-of-friend protocol presented in Section 5.1. We choose this example since it uses almost every feature that \\texttt{Asplada} provides. We simplify the example to not use the relation predicate but an easier friend predicate that directly represents the relation.\n\n\\textbf{Example B.1.} We briefly recall the protocol specified in PA-PCA. Suppose \\texttt{Bob} is a friend of \\texttt{Alice} and \\texttt{Alice} is also a friend of \\texttt{Charlie}. This means in PA-PCA that we have two statements; one at \\texttt{Bob}'s disposal and one at \\texttt{Alice}'s disposal stating the friendship, namely, \\texttt{Alice says Friend(Bob)} and \\texttt{Charlie says Friend(Alice)}. Now \\texttt{Bob} wants to be also\nFigure B.1 The protocol to establish an indirect friendship without the need of interaction for Charlie. \n\nCharlie says Friend(Alice) \nAlice says Friend(Bob) \n∃x. Alice says Friend(x) ∧ x says Request(Charlie) \n∃x, y. Charlie says Friend(x) ∧ x says Friend(y) \n∃x. Charlie says Friend(x) ∧ x says Friend(Bob) \n\na friend of with Charlie and the protocol is able to establish this friendship without the interaction of Charlie. The protocol is illustrated in Figure B.1.\n\nWe show the statements that we need to construct in order to implement the protocol in our API. These statements are the following:\n\nCharlie says Friend(Alice) \nAlice says Friend(Bob) \n∃x. Alice says Friend(x) ∧ x says Request(Charlie) \n∃x, y. Charlie says Friend(x) ∧ x says Friend(y) \n∃x. Charlie says Friend(x) ∧ x says Friend(Bob)\n\nWe implement these statements in Asplada with the code in Listing B.2. There, we only show the construction of the statements abstracting from the process itself. The statements are created in the same order as above. In order to indicate when a step in the process is finished, we put one line of space after each such step.\nListing B.2: The implementation of the friend-of-friend protocol.\n\n```plaintext\nnewId Alice\nnewId Bob\nnewId Charlie\n\nlet Fca = Charlie says Friend(Alice)\nlet Fab = Alice says Friend(Bob)\n\nlet ReqFirst = Bob says Request(Charlie)\nlet ReqSecond = Fab and ReqFirst\nlet OI = openinfo for Bob in ReqFirst\nlet Request = exists Bob. ReqSecond\n\nverify exists X. Alice says Friend(X) \\ X says Request(Charlie) with Request\nsplit Request as (Fr,Re)\nlet AnswerFirst = Fca and Fr\nlet AnswerTwo = exists Alice. AnswerFirst\nlet Answer = randomize AnswerTwo as exists X',Y. Charlie says Friend(X') \\ X' says Friend(Y)\n\nverify exists X,Y. Charlie says Friend(X) \\ X says Friend(Y) with Answer\nlet Fcb = instantiate Answer with OI as exists X. Charlie says Friend(X) \\ X says Friend(Bob)\n\n$*/\n```"}}},{"rowIdx":185,"cells":{"id":{"kind":"string","value":"5c7334fc29fa063dd7986e883bd840cfcab8d4be"},"text":{"kind":"string","value":"Notice to Customers\n\nAll documentation becomes dated and this manual is no exception. Microchip tools and documentation are constantly evolving to meet customer needs, so some actual dialogs and/or tool descriptions can differ from those in this document. Please refer to our web site (https://www.microchip.com) to obtain the latest documentation available.\n\nDocuments are identified with a “DS” number. This number is located on the bottom of each page, in front of the page number. The numbering convention for the DS number is “DSXXXXX,” where “XXXXX” is the document number and “A” is the revision level of the document.\n\nFor the most up-to-date information on development tools, see the MPLAB® IDE online help. Select the Help menu, and then Topics to open a list of available online help files.\n# Table of Contents\n\nNotice to Customers......................................................................................................................... 1\n\n1. Preface............................................................................................................................................ 4\n 1.1. Conventions Used in This Guide............................................................................................. 4\n 1.2. Recommended Reading............................................................................................................ 5\n 1.3. Document Revision History.................................................................................................. 5\n\n2. Assembler Overview..................................................................................................................... 6\n 2.1. Device Description................................................................................................................ 6\n 2.2. Compatible Development Tools.......................................................................................... 6\n\n3. Assembler Driver............................................................................................................................ 7\n 3.1. Single-step Assembly.......................................................................................................... 7\n 3.2. Multi-step Assembly........................................................................................................... 7\n 3.3. Assembler Option Descriptions........................................................................................ 8\n\n4. MPLAB XC8 Assembly Language.................................................................................................. 19\n 4.1. Assembly Instruction Deviations......................................................................................... 19\n 4.2. Statement Formats............................................................................................................... 22\n 4.3. Characters........................................................................................................................ 23\n 4.4. Comments........................................................................................................................ 23\n 4.5. Constants.......................................................................................................................... 23\n 4.6. Identifiers.......................................................................................................................... 24\n 4.7. Expressions....................................................................................................................... 25\n 4.8. Program Sections............................................................................................................... 26\n 4.9. Assembler Directives......................................................................................................... 27\n\n5. Assembler Features...................................................................................................................... 45\n 5.1. Preprocessor Directives...................................................................................................... 45\n 5.2. Assembler-provided Psects................................................................................................ 46\n 5.3. Default Linker Classes....................................................................................................... 46\n 5.4. Linker-Defined Symbols.................................................................................................... 48\n 5.5. Assembly List Files........................................................................................................... 48\n\n6. Linker........................................................................................................................................ 50\n 6.1. Operation........................................................................................................................... 50\n 6.2. Psects and Relocation....................................................................................................... 56\n 6.3. Map Files.......................................................................................................................... 56\n\n7. Utilities....................................................................................................................................... 61\n 7.1. Archiver/Librarian.............................................................................................................. 61\n 7.2. Hexmate........................................................................................................................... 62\n\nThe Microchip Website.................................................................................................................... 76\n\nProduct Change Notification Service............................................................................................... 76\n\nCustomer Support.......................................................................................................................... 76\n1. Preface\n\n1.1 Conventions Used in This Guide\nThe following conventions may appear in this documentation:\n\nTable 1-1. Documentation Conventions\n\n<table>\n<thead>\n<tr>\n<th>Description</th>\n<th>Represents</th>\n<th>Examples</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Arial font:</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Italic characters</td>\n<td>Referenced books</td>\n<td><em>MPLAB® IDE User’s Guide</em></td>\n</tr>\n<tr>\n<td></td>\n<td>Emphasized text</td>\n<td><em>...is the only compiler...</em></td>\n</tr>\n<tr>\n<td>Initial caps</td>\n<td>A window</td>\n<td>the Output window</td>\n</tr>\n<tr>\n<td></td>\n<td>A dialog</td>\n<td>the Settings dialog</td>\n</tr>\n<tr>\n<td></td>\n<td>A menu selection</td>\n<td>select Enable Programmer</td>\n</tr>\n<tr>\n<td>Quotes</td>\n<td>A field name in a window or dialog</td>\n<td>“Save project before build”</td>\n</tr>\n<tr>\n<td>Underlined, italic text with right angle bracket</td>\n<td>A menu path</td>\n<td><em>File>Save</em></td>\n</tr>\n<tr>\n<td>Bold characters</td>\n<td>A dialog button</td>\n<td>Click OK</td>\n</tr>\n<tr>\n<td></td>\n<td>A tab</td>\n<td>Click the <strong>Power</strong> tab</td>\n</tr>\n<tr>\n<td><strong>N’Rnnnn</strong></td>\n<td>A number in verilog format, where N is the total number of digits, R is the radix and n is a digit.</td>\n<td>4'b0010, 2'hF1</td>\n</tr>\n<tr>\n<td>Text in angle brackets < ></td>\n<td>A key on the keyboard</td>\n<td>Press <Enter>, <F1></td>\n</tr>\n<tr>\n<td>Courier New font:</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Plain Courier New</td>\n<td>Sample source code</td>\n<td>#define START</td>\n</tr>\n<tr>\n<td></td>\n<td>Filenames</td>\n<td>autoexec.bat</td>\n</tr>\n<tr>\n<td></td>\n<td>File paths</td>\n<td>c:\\mcc18\\h</td>\n</tr>\n<tr>\n<td></td>\n<td>Keywords</td>\n<td>_asm, _endasm, static</td>\n</tr>\n<tr>\n<td></td>\n<td>Command-line options</td>\n<td>-Opa+, -Opa-</td>\n</tr>\n<tr>\n<td></td>\n<td>Bit values</td>\n<td>0, 1</td>\n</tr>\n<tr>\n<td></td>\n<td>Constants</td>\n<td>0xFF, ‘A’</td>\n</tr>\n<tr>\n<td>Italic Courier New</td>\n<td>A variable argument</td>\n<td><em>file.c, where file can be any valid filename</em></td>\n</tr>\n<tr>\n<td>Square brackets [ ]</td>\n<td>Optional arguments</td>\n<td>mcc18 [options] file [options]</td>\n</tr>\n<tr>\n<td>Curly brackets and pipe character: { }</td>\n<td>Choice of mutually exclusive arguments; an OR selection</td>\n<td>errorlevel {0</td>\n</tr>\n<tr>\n<td>Ellipses...</td>\n<td>Replaces repeated text</td>\n<td>var_name [, var_name...]</td>\n</tr>\n<tr>\n<td></td>\n<td>Represents code supplied by user</td>\n<td>void main (void) { ... }</td>\n</tr>\n</tbody>\n</table>\n1.2 **Recommended Reading**\n\nThis user’s guide describes the use and features of the MPLAB XC8 PIC Assembler. The following Microchip documents are available and recommended as supplemental reference resources.\n\n**MPLAB® XC8 PIC Assembler Migration Guide**\n\nThis guide is for customers who have MPASM projects and who wish to migrate them to the MPLAB XC8 PIC assembler. It describes the nearest equivalent assembler syntax and directives for MPASM code.\n\n**MPLAB® XC8 PIC Assembler Guide For Embedded Engineers**\n\nThis guide is a getting started guide, describing example projects and commonly used coding sequences used by the MPLAB XC8 PIC assembler. Use this guide if you need to develop new projects using the assembler.\n\n**MPLAB® XC8 C Compiler Release Notes for PIC MCU**\n\nFor the latest information on changes and bug fixes to this assembler, read the Readme file in the docs subdirectory of the MPLAB XC8 installation directory.\n\n**Development Tools Release Notes**\n\nFor the latest information on using other development tools, read the tool-specific Readme files in the docs subdirectory of the MPLAB X IDE installation directory.\n\n1.3 **Document Revision History**\n\n**Revision A (March 2020)**\n\n- Initial release of this document, based on the assembler chapter from the *MPLAB® XC8 C Compiler User’s Guide* (DS5002737).\n2. **Assembler Overview**\n\nThe MPLAB XC8 PIC Assembler is a free-standing cross assembler and linker package, supporting all 8-bit PIC® microcontrollers.\n\n2.1 **Device Description**\n\nThis guide describes the MPLAB XC8 PIC Assembler’s support for all 8-bit Microchip PIC devices with baseline, mid-range, enhanced mid-range and PIC18 cores. The following descriptions indicate the distinctions within those device cores:\n\nThe baseline core uses a 12-bit-wide instruction set and is available in PIC10, PIC12 and PIC16 part numbers.\n\nThe enhanced baseline core also uses a 12-bit instruction set, but this set includes additional instructions. Some of the enhanced baseline chips support interrupts and the additional instructions used by interrupts. These devices are available in PIC12 and PIC16 part numbers.\n\nThe mid-range core uses a 14-bit-wide instruction set that includes more instructions than the baseline core. It has larger data memory banks and program memory pages, as well. It is available in PIC12, PIC14 and PIC16 part numbers.\n\nThe Enhanced mid-range core also uses a 14-bit-wide instruction set but incorporates additional instructions and features. There are both PIC12 and PIC16 part numbers that are based on the Enhanced mid-range core.\n\nThe PIC18 core instruction set is 16 bits wide and features additional instructions and an expanded register set. PIC18 core devices have part numbers that begin with PIC18.\n\nSee [Print-devices](#) for information on finding the full list of devices that are supported by the assembler.\n\n2.2 **Compatible Development Tools**\n\nThe assembler works with many other Microchip tools, including:\n\n- The MPLAB X IDE ([https://www.microchip.com/mplab/mplab-x-ide](https://www.microchip.com/mplab/mplab-x-ide))\n- The MPLAB X Simulator\n- The Command-line MDB Simulator—see the Microchip Debugger (MDB) User’s Guide (DS52102)\n- Demonstration boards and Starter kits that support 8-bit devices\n3. Assembler Driver\n\nThe name of the command-line driver used by the MPLAB XC8 PIC Assembler is **pic-as**.\n\nThis driver can be invoked to perform both assembly and link steps and is the application called by development environments, such as the MPLAB X IDE, to build assembly projects.\n\nThe **pic-as** driver has the following basic command format:\n\n```\npic-as [options] files [libraries]\n```\n\nThroughout this manual, it is assumed that the assembler applications are in your console’s search path or that the full path is specified when executing the application.\n\nIt is customary to declare options (identified by a leading dash “-” or double dash “--”) before the files’ names; however, this is not mandatory.\n\nThe formats of the **options** are supplied in **3.3 Assembler Option Descriptions** along with corresponding descriptions of the options’ function.\n\nThe **files** can be an assortment of assembler source files and precompiled intermediate files. While the order in which these files are listed is not important, it can affect the allocation of code or data and can affect the names of some of the output files.\n\nThe **libraries** is a list of user-defined library files that will be searched by the compiler. The order of these files will determine the order in which they are searched. It is customary to insert the libraries after the list of source files; however, this is not mandatory.\n\n3.1 Single-step Assembly\n\nAssembly of one or more source files can be performed in just one step using the **pic-as** driver.\n\nThe following command will build both the assembly source files, passing these files to the appropriate internal applications, then link the generated code to form the final output.\n\n```\npic-as -mcpu=16F877A main.S mdef.s\n```\n\nThe driver will compile all source files, regardless of whether they have changed since the last build. Development environments (such as MPLAB® X IDE) and make utilities must be employed to achieve incremental builds (see **3.2 Multi-step Assembly**).\n\nUnless otherwise specified, a HEX file and ELF file are produced as the final output. The intermediate files remain after compilation has completed, but most other temporary files are deleted, unless you use the **-save-temps** option (see **3.3.26 Save-temps Option**) which preserves all generated files. Note that some generated files can be in a different directory than your project source files (see also **3.3.21 O: Specify Output File**).\n\n3.2 Multi-step Assembly\n\nA multi-step assembly method can be employed to achieve an incremental build of your project. Make utilities take note of which source files have changed since the last build and only rebuild these files to speed up assembly. From within MPLAB X IDE, you can select an incremental build (Build Project icon), or fully rebuild a project (Clean and Build Project icon).\n\nMake utilities typically call the assembler multiple times: once for each source file to generate an intermediate file and once to perform the link step.\n\nThe option **-c** is used to create an intermediate file. This option stops after the assembler application has executed, and the resulting object output file will have a `.o` extension.\n\nThe intermediate files can then be specified to the driver during the second stage of compilation, when they will be passed to the linker.\nThe first two of the following command lines build an intermediate file for each assembly source file, then these intermediate files are passed to the driver again to be linked in the last command.\n\n```\npic-as -mcpu=16F877A -c main.s\npic-as -mcpu=16F877A -c io.s\npic-as -mcpu=16F877A main.o io.o\n```\n\nAs with any assembler, all the files that constitute the project must be present when performing the second (link) stage of compilation.\n\nYou might also wish to generate intermediate files to construct your own library files. See 7.1 Archiver/Librarian for more information on library creation.\n\n3.3 Assembler Option Descriptions\n\nMost aspects of the build process can be controlled using options passed to the assembler’s command-line driver, `pic-as`.\n\nAll options are case sensitive and are identified by leading single or double dash character, e.g. `-o` or `--version`.\n\nUse the `--help` option to obtain a brief description of accepted options on the command line.\n\nIf you are compiling from within the MPLAB X IDE, it will issue explicit options to the assembler that are based on the selections in the project’s Project Properties dialog. The default project options might be different to the default options used by the assembler when running on the command line, so you should review your IDE properties to ensure that they are acceptable.\n\nThe summary of all available driver options tabulated below is followed by a detailed description of each option.\n\n**Table 3-1. PIC Assembler Driver Options**\n\n<table>\n<thead>\n<tr>\n<th>Option</th>\n<th>Controls</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>-##</code></td>\n<td>Display of application command-lines but with no execution</td>\n</tr>\n<tr>\n<td><code>-c</code></td>\n<td>Generation of an intermediate object file</td>\n</tr>\n<tr>\n<td><code>-mcallgraph=type</code></td>\n<td>The type of callgraph printed in the map file</td>\n</tr>\n<tr>\n<td><code>-mchecksum=specs</code></td>\n<td>The generation and placement of a checksum or hash</td>\n</tr>\n<tr>\n<td><code>-mcpu=device</code></td>\n<td>The target device that code will be built for</td>\n</tr>\n<tr>\n<td><code>-D</code></td>\n<td>Definition of preprocessor symbols</td>\n</tr>\n<tr>\n<td><code>-mdfp=path</code></td>\n<td>Which device family pack to use</td>\n</tr>\n<tr>\n<td><code>-dM</code></td>\n<td>List all defined macros</td>\n</tr>\n<tr>\n<td><code>-m[no-]download</code></td>\n<td>How the final HEX file is conditioned</td>\n</tr>\n<tr>\n<td><code>-E</code></td>\n<td>The generation of preprocessed-only files</td>\n</tr>\n<tr>\n<td><code>--fill=options</code></td>\n<td>Filling of unused memory</td>\n</tr>\n<tr>\n<td><code>-gformat</code></td>\n<td>The type of debugging information generated</td>\n</tr>\n<tr>\n<td><code>-H</code></td>\n<td>List included header files</td>\n</tr>\n<tr>\n<td><code>--help</code></td>\n<td>Display help information only</td>\n</tr>\n<tr>\n<td><code>-I</code></td>\n<td>Directories searched for headers</td>\n</tr>\n<tr>\n<td><code>-misa</code></td>\n<td>Select PIC18 instruction set</td>\n</tr>\n<tr>\n<td><code>-l</code></td>\n<td>Which libraries are scanned</td>\n</tr>\n<tr>\n<td><code>-L</code></td>\n<td>Directories searched for libraries</td>\n</tr>\n</tbody>\n</table>\n### Option\n\nThe `-###` option is similar to `-v`, but the commands are not executed. This option allows you to see the assembler’s command lines without executing the assembler.\n\n#### C: Compile To Intermediate File\n\nThe `-c` option is used to generate an intermediate file for each source file listed on the command line. This option is often used to facilitate multi-step builds using a make utility.\n\n#### Callgraph Option\n\nThe `-mcallgraph=type` option controls what sort of call graph is printed in the map file. The available types are shown in the table.\n\n#### Table 3-2. Callgraph types\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Produces</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>none</td>\n<td>No call graph</td>\n</tr>\n<tr>\n<td>crit</td>\n<td>Only critical paths in the callgraph</td>\n</tr>\n</tbody>\n</table>\nThe callgraph is generated by the linker, primarily for the purposes of allocating memory to objects in the compiled stack. Those routines defining stack objects that are not overlaid with other stack objects and that are hence contributing to the program's data memory usage are considered as being on a critical path.\n\n### 3.3.4 Checksum Option\n\nThe `-mchecksum=specs` option will calculate a hash value (for example checksum or CRC) over the address range specified and stores the result in the hex file at the indicated destination address. The general form of this option is as follows.\n\n```\n-mchecksum=start-end@destination[,specifications]\n```\n\nThe following specifications are appended as a comma-separated list to this option.\n\n#### Table 3-3. Checksum Arguments\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>width=n</td>\n<td>Selects the width of the hash result in bytes for non-Fletcher algorithms, or in bits for SHA algorithms. A negative width will store the result in little-endian byte order; positive widths in big-endian order. Result widths from one to four bytes are permitted, or 256 bits for SHA algorithms.</td>\n</tr>\n<tr>\n<td>offset=nnnn</td>\n<td>Specifies an initial value or offset added to the checksum.</td>\n</tr>\n<tr>\n<td>algorithm=n</td>\n<td>Selects one of the hash algorithms implemented in Hexmate. The selectable algorithms are described in Table 7-3.</td>\n</tr>\n<tr>\n<td>polynomial=nn</td>\n<td>Selects the polynomial value when using CRC algorithms</td>\n</tr>\n<tr>\n<td>code=nn</td>\n<td>Specifies a hexadecimal code that will trail each byte in the result. This can allow each byte of the result to be embedded within an instruction, for example code=34 will embed the result in a <code>retrlw</code> instruction on Mid-range devices.</td>\n</tr>\n<tr>\n<td>revword=n</td>\n<td>Read data in reverse byte order from n-byte wide words. Currently this value can be 0 or 2. A value of 0 disables the reverse-read feature.</td>\n</tr>\n</tbody>\n</table>\n\nThe `start`, `end` and `destination` attributes are, by default, hexadecimal constants. The addresses defining the input range are typically made multiples of the algorithm width. If this is not the case, zero bytes will pad any missing input word locations.\n\nIf an accompanying `--fill` option (3.3.11 Fill Option) has not been specified, unused locations within the specified address range will be automatically filled with 0xFFF for baseline devices, 0x3FFF for mid-range devices, or 0xFFFF for PIC18 devices. This is to remove any unknown values from the calculations and ensure the accuracy of the result.\n\nFor example:\n\n```\n-mchecksum=800-fff@20,width=1,algorithm=2\n```\n\nwill calculate a 1-byte checksum from address 0x800 to 0xff and store this at address 0x20. A 16-bit addition algorithm will be used. Table 3-9 shows the available algorithms and 7.2.2 Hash Functions describes these in detail.\n\n#### Table 3-4. Checksum Algorithm Selection\n\n<table>\n<thead>\n<tr>\n<th>Selector</th>\n<th>Algorithm description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-5</td>\n<td>Reflected cyclic redundancy check (CRC)</td>\n</tr>\n<tr>\n<td>-4</td>\n<td>Subtraction of 32 bit values from initial value</td>\n</tr>\n<tr>\n<td>Selector</td>\n<td>Algorithm description</td>\n</tr>\n<tr>\n<td>---------</td>\n<td>-----------------------------------------------------------</td>\n</tr>\n<tr>\n<td>-3</td>\n<td>Subtraction of 24 bit values from initial value</td>\n</tr>\n<tr>\n<td>-2</td>\n<td>Subtraction of 16 bit values from initial value</td>\n</tr>\n<tr>\n<td>-1</td>\n<td>Subtraction of 8 bit values from initial value</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Addition of 8 bit values from initial value</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Addition of 16 bit values from initial value</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Addition of 24 bit values from initial value</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Addition of 32 bit values from initial value</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Cyclic redundancy check (CRC)</td>\n</tr>\n<tr>\n<td>7</td>\n<td>Fletcher’s checksum (8 bit calculation, 2-byte result width)</td>\n</tr>\n<tr>\n<td>8</td>\n<td>Fletcher’s checksum (16 bit calculation, 4-byte result width)</td>\n</tr>\n<tr>\n<td>10</td>\n<td>SHA-2 (currently only SHA256 is supported)</td>\n</tr>\n</tbody>\n</table>\n\nThe hash calculations are performed by the Hexmate application. The information in this driver option is passed to the Hexmate application when it is executed.\n\n### 3.3.5 Cpu Option\n\nThe `-mcpu=device` option must be used to specify the target device when building. This is the only option that is mandatory.\n\nFor example `-mcpu=18f6722` will select the PIC18F6722 device. To see a list of supported devices that can be used with this option, use the `-mprint-devices` option (3.3.22 Print-devices).\n\n### 3.3.6 D: Define a Macro\n\nThe `-D macro=text` option allows you to define preprocessor macros. For macros to be subsequently processed, the source files must be preprocessed by having them use a .S file extension or by using the `-xassembler-with-cpp` option.\n\nA space may be present between the option and macro name.\n\nWith no `=text` specified in the option, this option defines a preprocessor macro called `macro` that will be considered to have been defined by any preprocessor directive that checks for such a definition (e.g. the `#ifdef` directive) and that will expand to be the value 1 if it is used in a context where it will be replaced. For example, when using the option, `-DMY_MACRO` (or `-D MY_MACRO`) and supplying the following code:\n\n```\n#ifdef MY_MACRO\nmovlw MY_MACRO;\n#else\n```\n\nthe `movlw` instruction will be assembled and the value 1 will be assigned to the W register.\n\nWhen the replacement, `text`, is specified with the option, the macro will subsequently expand to be the replacement specified with the option. So if the above example code was compiled with the option `-DMY_MACRO=0x55`, then the instruction would be assembled as: `movlw 0x55`\n\nAll instances of `-D` on the command line are processed before any `-U` options.\n\n### 3.3.7 dM: Preprocessor Debugging Dumps Option\n\nThe `-dM` option has the preprocessor produce macro definitions that are in effect at the end of preprocessing. This option should be used in conjunction with the `-E` option, and if you want the output directed to a file, use also the `-o` option.\n3.3.8 **Dfp Option**\n\nThe `-mdfp=path` option indicates that device-support for the target device (indicated by the `-mcpu` option) should be obtained from the contents of a Device Family Pack (DFP), where `path` is the path to the `xc8` sub-directory of the DFP.\n\nWhen this option has not been used, the `pic-as` driver will where possible use the device-specific files provided in the assembler distribution.\n\nThe MPLAB X IDE automatically uses this option to inform the assembler of which device-specific information to use. Use this option on the command line if additional DFPs have been obtained for the assembler.\n\nA DFP might contain such items as device-specific header files, configuration bit data and libraries, letting you take advantage of features on new devices without you having to otherwise update the assembler. DFPs never contain executables or provide bug fixes or improvements to any existing tools or standard library functions.\n\nWhen using this option, the preprocessor will search for include files in the `<DFP>/xc8/pic/include/proc` and `<DFP>/xc8/pic/include` directories first, then search the standard search directories.\n\n3.3.9 **Download Option**\n\nThe `-mdownload` option conditions the Intel HEX for use by bootloader. The `-mdownload-hex` option is equivalent in effect.\n\nWhen used, this option will pad data records in the Intel HEX file to 16-byte lengths and will align them on 16-byte boundaries.\n\nThe default operation is to not modify the HEX file and this can be made explicit using the option `-mno-download`. (`-mno-download-hex`)\n\n3.3.10 **E: Preprocess Only**\n\nThe `-E` option is used to generate preprocessed assembly source files (also called modules or translation units).\n\nWhen this option is used, the build sequence will terminate after the preprocessing stage, leaving behind files with the same basename as the corresponding source file and with a `.i` extension.\n\nYou might check the preprocessed source files to ensure that preprocessor macros have expanded to what you think they should. The option can also be used to create assembly source files that do not require any separate header files. This is useful when sending files to a colleague or to obtain technical support without sending all the header files, which can reside in many directories.\n\n3.3.11 **Fill Option**\n\nThe `--fill=options` option allows you to fill unused memory with specified values in a variety of ways.\n\nThis option is functionally identical to Hexmate’s `--fill` option. For more detailed information and advanced controls that can be used with this option, refer to 7.2.1.11 Fill.\n\n3.3.12 **G: Produce Debugging Information Option**\n\nThe `-gformat` option instructs the assembler to produce additional information, which can be used by hardware tools to debug your program.\n\nThe support formats are tabulated below.\n\n**Table 3-5. Supported Debugging File Formats**\n\n<table>\n<thead>\n<tr>\n<th>Format</th>\n<th>Debugging file format</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>-gcoff</code></td>\n<td>COFF</td>\n</tr>\n<tr>\n<td><code>-gdwarf-3</code></td>\n<td>ELF/Dwarf release 3</td>\n</tr>\n<tr>\n<td><code>-ginhx32</code></td>\n<td>Intel HEX with extended linear address records, allowing use of addresses beyond 64kB</td>\n</tr>\n<tr>\n<td><code>-ginhx032</code></td>\n<td>INHX32 with initialization of upper address to zero</td>\n</tr>\n</tbody>\n</table>\n\nBy default, the assembler produces Dwarf release 3 files.\n3.3.13 **H: Print Header Files Option**\nThe `-H` option prints to the console the name of each header file used, in addition to other normal activities.\n\n3.3.14 **Help**\nThe `--help` option displays information on the `pic-as` assembler options, then the driver will terminate.\n\n3.3.15 **I: Specify Include File Search Path Option**\nThe `-I dir` option adds the directory `dir` to the head of the list of directories to be searched for header files. A space may be present between the option and directory name.\n\nThe option can specify either an absolute or relative path and it can be used more than once if multiple additional directories are to be searched, in which case they are scanned from left to right. The standard system directories are searched after scanning the directories specified with this option.\n\nUnder the Windows OS, the use of the directory backslash character may unintentionally form an escape sequence. To specify an include file path that ends with a directory separator character and which is quoted, use `-I \"E:\\\"`, for example, instead of `-I \"E:\\\"`, to avoid the escape sequence `\\`. Note that MPLAB X IDE will quote any include file path you specify in the project properties and that search paths are relative to the output directory, not the project directory.\n\n3.3.16 **Isa Option**\nThe `--isa=set` option allows the instruction set to be specified for PIC18 targets. The default is the standard PIC18 instruction set, a selection that can be made explicit by using `--isa=std`. Alternatively, the PIC18 extended instruction set can be selected by using `--isa=xinst`. When used with a device that does not support the requested instruction set, the option will be ignored and a warning issued.\n\nNote that this option will permit the assembler to check for conformance of the assembly program to the selected instruction set, but it does not instruct the device to operate with the selected instruction set. Use the `XINST` configuration bit to enable this in your device.\n\n3.3.17 **L: Specify Library File Option**\nThe `-l library` option looks for the specified file (with a `.a` extension) and scans this library archive for unresolved symbols when linking.\n\nThe only difference between using an `-l` option (e.g., `-lmylib`) and specifying a file name on the command line (e.g., `mylib.a`) is that the assembler will search for the library specified using `-l` in several directories, as specified by the `-L` option.\n\n3.3.18 **L: Specify Library Search Path Option**\nThe `-L dir` option allows you to specify an additional directory to be searched for library files that have been specified by using the `-l` option. The assembler will automatically search standard library locations, so you only need to use this option if you are linking in your own libraries.\n\n3.3.19 **Max Errors**\nThe `--fmax-errors=n` option sets the maximum number of errors each assembler application, as well as the driver, will display before execution is terminated.\n\nBy default, up to 20 error messages will be displayed by each application before the assembler terminates. The option `--fmax-errors=10`, for example, would ensure the applications terminate after only 10 errors.\n\n3.3.20 **Maxichip Option**\nThe `--maxichip` option tells the assembler to build for a hypothetical device with the same physical core and peripherals as the selected device, but with the maximum allowable memory resources permitted by the device family. You might use this option if your program does not fit in your intended target device and you wish to get an indication of the code or data size reductions needed to be able to program that device.\n\nThe assembler will normally terminate if the selected device runs out of program memory, data memory, or EEPROM. When using this option, the program memory of PIC18 and mid-range devices will be maximized to extend from\naddress 0 to either the bottom of external memory or the maximum address permitted by the PC register, whichever is lower. The program memory of baseline parts is maximized from address 0 to the lower address of the Configuration Words.\n\nThe number of data memory banks is expanded to the maximum number of selectable banks as defined by the BSR register (for PIC18 devices), RP bits in the STATUS register (for mid-range devices), or the bank select bits in the FSR register (for baseline devices). The amount of RAM in each additional bank is equal to the size of the largest contiguous memory area within the physically implemented banks.\n\nIf present on the device, EEPROM is maximized to a size dictated by the number of bits in the EEADR or NVMADR register, as appropriate.\n\nIf required, check the map file (see 6.3 Map Files) to see the size and arrangement of the memory available when using this option with your device.\n\n**Note:** When using the `-mmaxichip` option, you are not building for a real device. The generated code may not load or execute in simulators or the selected device. This option will not allow you to fit extra code into a device.\n\n### 3.3.21 O: Specify Output File\nThe `-o` option specifies the base name and directory of the output file.\n\nThe option `-o main.elf`, for example, will place the generated output in a file called `main.elf`. The name of an existing directory can be specified with the file name, for example `-o build/main.elf`, so that the output file will appear in that directory.\n\nYou cannot use this option to change the type (format) of the output file.\n\nOnly the base name of the file specified with this option has significance. You cannot use this option to change the extension of an output file.\n\n### 3.3.22 Print-devices\nThe `-mprint-devices` option displays a list of devices the assembler supports.\n\nThe names listed are those devices that can be used with the `-mcpu` option. This option will only show those devices that were officially supported when the assembler was released. Additional devices that might be available via device family packs (DFPs) will not be shown in this list.\n\nThe assembler will terminate after the device list has been printed.\n\n### 3.3.23 Ram Option\nThe `-mram=ranges` option is used to adjust the data memory that is specified for the target device. Without this option, all the on-chip RAM implemented by the device is available, thus this option only needs be used if there are special memory requirements. Specifying additional memory that is not in the target device might result in a successful compilation, but can lead to code failures at runtime.\n\nFor example, to specify an additional range of memory to that already present on-chip, use:\n\n```\n-mram=default,+100-1ff\n```\n\nThis will add the range from 100h to 1ffh to the on-chip memory. To only use an external range and ignore any on-chip memory, use:\n\n```\n-mram=0-ff\n```\n\nThis option can also be used to reserve memory ranges already defined as on-chip memory in the relevant chipinfo file. To do this, supply a range prefixed with a minus character, ``, for example:\n\n```\n-mram=default,-100-103\n```\n\nwill use all the defined on-chip memory, but not use the addresses in the range from 100h to 103h for allocation of RAM objects.\nThis option will adjust the memory ranges used by linker classes (see 6.1.1 A: Define Linker Class). Any objects contained in a psect that do not use the classes affected by this option might be linked outside the valid memory specified by this option.\n\n3.3.24 Reserve Option\n\nThe \\texttt{-mreserve=ranges} option allows you to reserve memory normally used by the program. This option has the general form:\n\n\\begin{verbatim}\n-mreserve=space@start:end\n\\end{verbatim}\n\nwhere \\texttt{space} can be either of \\texttt{ram} or \\texttt{rom}, denoting the data and program memory spaces, respectively; and \\texttt{start} and \\texttt{end} are addresses, denoting the range to be excluded. For example, \\texttt{-mreserve=ram@0x100:0x101} will reserve two bytes starting at address 100h from the data memory.\n\nThis option performs a similar task to the \\texttt{-mram} and \\texttt{-mrom} options, but it cannot be used to add additional memory to that available for the program.\n\n3.3.25 Rom Option\n\nThe \\texttt{-mrom=ranges} option is used to change the default program memory that is specified for the target device. Without this option, all the on-chip program memory implemented by the device is available, thus this option only needs be used if there are special memory requirements. Specifying additional memory that is not in the target device might result in a successful compilation, but can lead to code failures at runtime.\n\nFor example, to specify an additional range of memory to that on-chip, use:\n\n\\begin{verbatim}\n-mrom=default,+100-2ff\n\\end{verbatim}\n\nThis will add the range from 100h to 2ffh to the on-chip memory. To only use an external range and ignore any on-chip memory, use:\n\n\\begin{verbatim}\n-mrom=100-2ff\n\\end{verbatim}\n\nThis option can also be used to reserve memory ranges already defined as on-chip memory in the chip configuration file. To do this supply a range prefixed with a minus character, -, for example:\n\n\\begin{verbatim}\n-mrom=default,-100-1ff\n\\end{verbatim}\n\nwill use all the defined on-chip memory, but not use the addresses in the range from 100h to 1ffh for allocation of ROM objects.\n\nThis option will adjust the memory ranges used by linker classes (see 6.1.1 A: Define Linker Class). Any code or objects contained in a psect that do not use the classes affected by this option might be linked outside the valid memory specified by this option.\n\nNote that some psects must be linked above a threshold address, most notably some psects that hold \\texttt{const}-qualified data. Using this option to remove the upper memory ranges can make it impossible to place these psects.\n\n3.3.26 Save-temps Option\n\nThe \\texttt{-save-temps} option instructs the assembler to keep temporary files after compilation has finished.\n\nThe intermediate files will be placed in the current directory and have a name based on the corresponding source file. Thus, compiling \\texttt{foo.s} with \\texttt{-save-temps} would produce the \\texttt{foo.o} object file.\n\nThe \\texttt{-save-temps=cwd} option is equivalent to \\texttt{-save-temps}.\n\nThe \\texttt{-save-temps=obj} form of this option is similar to \\texttt{-save-temps}, but if the \\texttt{-o} option is specified, the temporary files are placed in the same directory as the output object file. If the \\texttt{-o} option is not specified, the \\texttt{-save-temps=obj} switch behaves like \\texttt{-save-temps}. \n3.3.27 Serial Option\n\nThe `-mserial=options` option allows a hexadecimal code to be stored at a particular address in program memory. A typical task for this option might be to position a serial number in program memory.\n\nThe byte-width of data to store is determined by the byte-width of the hexcode parameter in the option. For example, to store a one-byte value, 0, at program memory address 1000h, use `-mserial=00@1000`. To store the same value as a four byte quantity use `-mserial=00000000@1000`.\n\nThis option is functionally identical to Hexmate's `-serial` option. For more detailed information and advanced controls that can be used with this option (refer to 7.2.1.20 Serial).\n\n3.3.28 Summary Option\n\nThe `-msummary=type` option selects the type of information that is included in the summary that is displayed once the build is complete. By default, or if the `mem` type is selected, a memory summary with the total memory usage for all memory spaces is shown.\n\nA psect summary can be shown by enabling the `psect` type. This shows individual psects after they have been grouped by the linker and the memory ranges they cover. Table 4-20 shows what summary types are available. The default output printed corresponds to the `mem` setting.\n\nSHA hashes for the generated hex file can also be shown using this option. These can be used to quickly determine if anything in the hex file has changed from a previous build.\n\nTable 3-6. Summary Types\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Shows</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>psect</td>\n<td>A summary of psect names and the addresses where they were linked will be shown.</td>\n</tr>\n<tr>\n<td>mem</td>\n<td>A concise summary of memory used will be shown (default).</td>\n</tr>\n<tr>\n<td>class</td>\n<td>A summary of all classes in each memory space will be shown.</td>\n</tr>\n<tr>\n<td>hex</td>\n<td>A summary of addresses and HEX files that make up the final output file will be shown.</td>\n</tr>\n<tr>\n<td>file</td>\n<td>Summary information will be shown on screen and saved to a file.</td>\n</tr>\n<tr>\n<td>shal</td>\n<td>A SHA1 hash for the hex file.</td>\n</tr>\n<tr>\n<td>sha256</td>\n<td>A SHA256 hash for the hex file.</td>\n</tr>\n<tr>\n<td>xml</td>\n<td>Summary information will be shown on the screen, and usage information for the main memory spaces will be saved in an XML file.</td>\n</tr>\n<tr>\n<td>xmlfull</td>\n<td>Summary information will be shown on the screen, and usage information for all memory spaces will be saved in an XML file.</td>\n</tr>\n</tbody>\n</table>\n\nIf specified, the XML files contain information about memory spaces on the selected device, consisting of the space's name, addressable unit, size, amount used and amount free.\n\n3.3.29 U: Undefine Macros\n\nThe `-Umacro` option undefines the macro `macro`.\n\nAny macro defined using `-D` will be undefined by this option. All `-U` options are evaluated after all `-D` options.\n\n3.3.30 V: Verbose Compilation\n\nThe `-v` option specifies verbose compilation.\n\nWhen this option is used, the name and path of the internal assembler applications will be displayed as they are executed, followed by the command-line arguments that each application was passed.\n\nYou might use this option to confirm that your driver options have been processed as you expect, or to see which internal application is issuing a warning or error.\n3.3.31 Version\nThe `--version` option prints assembler version information then exits.\n\n3.3.32 W: Disable all Warnings Option\nThe `-w` option inhibits all warning messages, and thus should be used with caution.\n\n3.3.33 Wa: Pass Option To The Assembler Option\nThe `-Wa,option` option passes its option argument directly to the assembler. If `option` contains commas, it is split into multiple options at the commas. For example `-Wa,-a` will request that the assembler produce an assembly list file.\n\n3.3.34 Warn Option\nThe `-mwarn=level` option is used to set the warning level threshold. Allowable warning levels range from -9 to 9. The warning level determines how pedantic the assembler is about dubious type conversions and constructs. Each warning has a designated warning level; the higher the warning level, the more important the warning message. If the warning message’s warning level exceeds the set threshold, the warning is printed. The default warning level threshold is 0 and will allow all normal warning messages.\n\nUse this option with care as some warning messages indicate code that is likely to fail during execution, or compromise portability.\n\n3.3.35 Wp: Pass Option To The Preprocessor Option\nThe `-Wp,option` option passes `option` to the preprocessor, where it will be interpreted as a preprocessor option. If `option` contains commas, it is split into multiple options at the commas.\n\n3.3.36 WL: Pass Option To The Linker Option\nThe `-Wl,option` option passes `option` to the linker where it will be interpreted as a linker option. If `option` contains commas, it is split into multiple options at the commas.\n\n3.3.37 X: Specify Source Language Option\nThe `-xl` `language` option allows you to specify that the source files that follow are written in the specified language, regardless of the extension they use.\n\nThe languages allowed by the PIC Assembler are tabulated below.\n\n<table>\n<thead>\n<tr>\n<th>Language</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>assembler</td>\n<td>Assembly source code</td>\n</tr>\n<tr>\n<td>assembler-with-cpp</td>\n<td>Assembly source code that must be preprocessed</td>\n</tr>\n</tbody>\n</table>\n\nFor example, the command:\n\n```\npic-as -mcpu=18f4520 -xassembler-with-cpp init.s\n```\n\nwill tell the assembler to run the preprocessor over the assembly source file, even though the `init.s` file name does not use a `.S` extension.\n\n3.3.38 Xassembler Option\nThe `-Xassembler` `option` option passes `option` to the assembler, where it will be interpreted as an assembler option. You can use this to supply system-specific assembler options that the assembler does not know how to recognize or that can't be parsed by the `-wa` option.\n3.3.39 Xpreprocessor Option\nThe `-Xpreprocessor` option passes `option` to the preprocessor, where it will be interpreted as a preprocessor option. You can use this to supply system-specific preprocessor options that the assembler does not know how to recognize.\n\n3.3.40 Xlinker Option\nThe `-Xlinker` option passes `option` to the linker where it will be interpreted as a linker option. You can use this to supply system-specific linker options that the assembler does not know how to recognize.\n4. MPLAB XC8 Assembly Language\n\nInformation about the source language accepted by the macro assemblers is described in this section.\n\nAll opcode mnemonics and operand syntax are specific to the target device, and you should consult your device data sheet. Additional mnemonics, deviations from the instruction set, and assembler directives are documented in this section.\n\n4.1 Assembly Instruction Deviations\n\nThe MPLAB XC8 assembler can use a slightly modified form of assembly language to that specified by the Microchip data sheets. This form is generally easier to read, but the form specified on the data sheet can also be used. The following information details allowable deviations to the instruction format as well as pseudo instructions that can be used in addition to the device instruction set.\n\n4.1.1 Destination And Access Operands\n\nTo specify the destination for byte-orientated file register instructions, you may use the operands from either style shown in Table 4-1. The wreg destination indicates that the instruction result will be written to the W register and the file register destination indicates that the result will be written to the register specified by the instruction's file register operand. This operand is usually represented by \\( w \\) in the device data sheet.\n\nTable 4-1. Destination Operand Styles\n\n<table>\n<thead>\n<tr>\n<th>Style</th>\n<th>Wreg destination</th>\n<th>File register destination</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>XC8</td>\n<td>( w )</td>\n<td>( f )</td>\n</tr>\n<tr>\n<td>MPASM</td>\n<td>( 0 )</td>\n<td>( 1 )</td>\n</tr>\n</tbody>\n</table>\n\nFor example (ignoring bank selection and address masking for this example):\n\n```\naddwf foo, w ;add wreg to foo, leaving the result in wreg\naddwf foo, f ;add wreg to foo, updating the content of foo\naddwf foo, 0 ;add wreg to foo, leaving the result in wreg\naddwf foo, 1 ;add wreg to foo, updating the content of foo\n```\n\nIt is highly recommended that the destination operand is always specified with those instructions where it is needed. If the destination operand is omitted, the destination is assumed to be the file register.\n\nTo specify the RAM access bit for PIC18 devices, you may use operands from either style shown in Table 4-2. Banked access indicates that the file register address specified in the instruction is just an offset into the currently selected bank. Unbanked access indicates that the file register address is an offset into the Access bank, or common memory.\n\nTable 4-2. RAM Access Operand Styles\n\n<table>\n<thead>\n<tr>\n<th>Style</th>\n<th>Banked access</th>\n<th>Unbanked access</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>XC8</td>\n<td>( b )</td>\n<td>( c ) or ( a )</td>\n</tr>\n<tr>\n<td>MPASM</td>\n<td>( l )</td>\n<td>( 0 )</td>\n</tr>\n</tbody>\n</table>\n\nThis operand is usually represented by \\( a \\) in the device data sheet.\n\nAlternatively, an instruction operand can be preceded by the characters \"\\( c: \\)\" to indicate that the address resides in the Access bank. For example:\n\n```\naddwf bar, f, c ;add wreg to bar in common memory\naddwf bar, f, a ;add wreg to bar in common memory\naddwf bar, l, 0 ;add wreg to bar in common memory\naddwf bar, f, b ;add wreg to bar in banked memory\n```\nIt is recommended that you always specify the RAM access operand or the common memory prefix. If these are not present, the instruction address is absolute and the address is within the upper half of the access bank (which dictates that the address must not be masked), the instruction will use the access bank RAM. In all other situations, the instruction will access banked memory.\n\nIf you use the XC8 style, the destination operand and the RAM access operand can be listed in any order for PIC18 instructions. For example, the following two instructions are identical:\n\n```\naddwf foo,f,c\naddwf foo,c,f\n```\n\nAlways be consistent in the use of operand style for each instruction, and preferably, that style should remain consistent through the program. For example, the instruction `addwf bar,1,c` is illegal.\n\nFor example, the following instructions show the W register being moved to first, an absolute location; and then to an address represented by an identifier. Bank selection and masking has been used in this example. The PIC18 opcodes for these instructions, assuming that the address assigned to `foo` is 0x516 and to `bar` is 0x55, are shown below.\n\n```\n6EE5 movwf 0FE5h ;write to access bank location 0xFE5\n6E55 movwf bar,c ;write to access bank location 0x55\n0105 BANKSEL(foo) ;set up BSR to access foo\n6F16 movwf BANKMASK(foo),b ;write to foo (banked)\n6F16 movwf BANKMASK(foo) ;defaults to banked access\n```\n\nNotice that the first two instruction opcodes have the RAM access bit (bit 8 of the op-code) cleared, but that the bit is set in the last two instructions.\n\n### 4.1.2 Bank And Page Selection\n\nThe `BANKSEL()` pseudo instruction can be used to generate instructions to select the bank of the operand specified. The operand should be the symbol or address of an object that resides in the data memory.\n\nDepending on the target device, the generated code will either contain one or more bit instructions to set/clear bits in the appropriate register, or use a `movlb` instruction (in the case of enhanced mid-range or PIC18 devices). As this pseudo instruction can expand to more than one instruction on mid-range or baseline parts, it should not immediately follow a `btfsx` instruction on those devices.\n\nFor example:\n\n```\nmovlw 20\nBANKSEL(_foobar) ;select bank for next file instruction\nmovwf BANKMASK(_foobar) ;write data and mask address\n```\n\nIn the same way, the `PAGESEL()` pseudo instruction can be used to generate code to select the page of the address operand. For the current page, you can use the location counter, $, as the operand.\n\nDepending on the target device, the generated code will either contain one or more instructions to set/clear bits in the appropriate register, or use a `movlp` instruction in the case of enhanced mid-range PIC devices. As the directive could expand to more than one instruction, it should not immediately follow a `btfsx` instruction.\n\nFor example:\n\n```\nfcall _getInput\nPAGESEL $ ;select this page\n```\n\nThis directive is accepted when compiling for PIC18 targets but has no effect and does not generate any code. Support is purely to allow easy migration across the 8-bit devices.\n\n### 4.1.3 Address Masking\n\nA file register address used with most instructions should be masked to remove the bank information from the address. Failure to do this might result in a linker fixup error.\nAll MPLAB XC8 assembly identifiers represent a full address. This address includes the bank information for the object it represents. Virtually all instructions in the 8-bit PIC instruction sets that take a file register operand expect this operand value to be an offset into the currently selected bank. As the device families have different bank sizes, the width of this offset is different for each family.\n\nThe BANKMASK() macro can be used with identifier or address operands. The macro ANDs out the bank information in the address using a suitable mask. It is available once you include <xc.inc>. Use of this macro increases assembly code portability across Microchip devices, since it adjusts the mask to suit the bank size of the target device. An example of this macro is given in 4.1.2 Bank And Page Selection.\n\nDo not use this macro with any instruction that expects its operand to be a full address, such as the PIC18’s movff instruction.\n\n4.1.4 Movfw Pseudo Instruction\n\nThe movfw pseudo instruction implemented by MPASM is not implemented in the MPLAB XC8 assemblers. You will need to use the standard PIC instruction that performs an identical function. Note that the MPASM instruction:\n\n```\nmovfw foobar\n```\n\nmaps directly to the standard PIC instruction:\n\n```\nmovf foobar,w\n```\n\n4.1.5 Movff/movffl Instructions\n\nThe movff instruction is a physical device instruction, but for PIC18 devices that have extended data memory, it also serves as a placeholder for the movffl instruction.\n\nFor these devices, when generating output for the movff instruction, the assembler checks the psects that hold the operand symbols. If the psect containing the source operand and the psect containing the destination operand both specify the lowdata psect flag, the instruction is encoded as the two-word movff instruction. If an operand is an absolute address and that address is in the lower 4kB of memory, then that is also considered acceptable for the shorter form of the instruction. In all other situations, the instruction is encoded as a three-word movffl instruction.\n\nNote that assembly list files will always show the movff mnemonic, regardless of how it is encoded. Check the number of op-code words to determine which instruction was encoded.\n\n4.1.6 Interrupt Return Mode\n\nThe retfie PIC18 instruction can be followed by “f” (no comma) to indicate that the shadow registers should be retrieved and copied to their corresponding registers on execution. Without this modifier, the registers are not updated from the shadow registers. This syntax is not relevant for Baseline and Mid-range devices.\n\nThe following examples show both forms and the opcodes they generate.\n\n```\n0011 retfie f ;shadow registers copied\n0010 retfie ;return without copy\n```\n\nThe “0” and “1” operands indicated in the device data sheet can be alternatively used if desired.\n\n4.1.7 Long Jumps And Calls\n\nThe assembler recognizes several mnemonics that expand into regular PIC MCU assembly instructions. The mnemonics are fcall and ljmp.\n\nOn baseline and mid-range parts, these instructions expand into regular call and goto instructions respectively, but also ensure the instructions necessary to set the bits in PCLATH (for mid-range devices) or STATUS (for baseline devices) will be generated, should the destination be in another page of program memory. Page selection instructions can appear immediately before the call or goto, or be generated as part of, and immediately after, a previous fcall/ljmp mnemonic.\n\nOn PIC18 devices, these mnemonics are present purely for compatibility with smaller 8-bit devices and are always expanded as regular PIC18 call and goto instructions.\nThese special mnemonics should be used where possible, as they make assembly code independent of the final position of the routines that are to be executed.\n\nThe following mid-range PIC example shows an `fcall` instruction in the assembly list file. You can see that the `fcall` instruction has expanded to five instructions. In this example, there are two bit instructions that set/clear bits in the PCLATH register. Bits are also set/cleared in this register after the call to reselect the page that was selected before the `fcall`.\n\n```\n 13 0079 3021 movlw 33\n 14 007A 120A 158A 2000 fcall _phantom\n 120A 118A\n 15 007F 3400 retlw 0\n```\n\nSince `fcall` and `ljmp` instructions can expand into more than one instruction, they should never be preceded by an instruction that can skip, e.g., a `btfsc` instruction.\n\nThe `fcall` and `ljmp` instructions assume that the psect that contains them is smaller than a page. Do not use these instructions to transfer control to a label in the current psect if it is larger than a page. The default linker options will not permit code psects to be larger than a page.\n\nOn PIC18 devices, the regular `call` instruction can be followed by a \",f\" to indicate that the W, STATUS and BSR registers should be pushed to their respective shadow registers. This replaces the \",1\" syntax indicated on the device data sheet.\n\n### 4.1.8 Relative Branches\n\nThe PIC18 devices implement conditional relative branch instructions, e.g., `bz`, `bnz`. These instructions have a limited jump range compared to the `goto` instruction.\n\nUnlike the MPLAB XC8 C Compiler, the PIC Assembler will never transform relative branch sequences to increase their range. If you need a relative branch that can reach targets outside the usual instruction range, use a relative branch with the reverse condition over a `goto` instruction. For example, instead of writing:\n\n```\n bz next\n```\n\nwrite something like:\n\n```\n bnz tmp\n goto next\n tmp:\n```\n\n### 4.2 Statement Formats\n\nValid statement formats are shown in Table 4-3.\n\nThe label field is optional and, if present, should contain one identifier. A label can appear on a line of its own, or precede a mnemonic as shown in the second format.\n\nThe third format is only legal with certain assembler directives, such as `MACRO`, `SET` and `EQU`. The name field is mandatory and should contain one identifier.\n\nIf the assembly source file is first processed by the preprocessor, then it can also contain lines that form valid preprocessor directives. See 5.1 Preprocessor Directives for more information on the format for these directives.\n\nThere is no limitation on what column or part of the line in which any part of the statement should appear.\n\n<table>\n<thead>\n<tr>\n<th>Format #</th>\n<th>Field1</th>\n<th>Field2</th>\n<th>Field3</th>\n<th>Field4</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Format 1</td>\n<td>label:</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Format 2</td>\n<td>label:</td>\n<td>mnemonic</td>\n<td>operands</td>\n<td>; comment</td>\n</tr>\n<tr>\n<td>Format 3</td>\n<td>name</td>\n<td>pseudo-op</td>\n<td>operands</td>\n<td>; comment</td>\n</tr>\n</tbody>\n</table>\n4.3 Characters\nThe character set used is standard 7 bit ASCII. Alphabetic case is significant for identifiers, but not mnemonics and reserved words. Tabs are equivalent to spaces.\n\n4.3.1 Delimiters\nAll numbers and identifiers must be delimited by white space, non-alphanumeric characters or the end of a line.\n\n4.3.2 Special Characters\nThere are a few characters that are special in certain contexts. Within a macro body, the character & is used for token concatenation. To use the bitwise & operator within a macro body, escape it by using && instead or use the and form of this operator. In a macro argument list, the angle brackets < and > are used to quote macro arguments.\n\n4.4 Comments\nAn assembly comment is initiated with a semicolon that is not part of a string or character constant.\n\n4.4.1 Special Comment Strings\nAssembly code produced by the MPLAB XC8 C compiler makes use of special comment strings such as ;volatile and ;wreg free. As the MPLAB XC8 PIC Assembler does not employ optimizations, these strings have no effect and do not need to be used with assembly source.\n\n4.5 Constants\n4.5.1 Numeric Constants\nThe assembler performs all arithmetic with signed 32-bit precision.\n\nThe default radix for all numbers is 10. Other radices can be specified by a trailing base specifier, as given in Table 5-2.\n\n<table>\n<thead>\n<tr>\n<th>Table 4-4. Numbers And Bases</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Radix</strong></td>\n</tr>\n<tr>\n<td>Binary</td>\n</tr>\n<tr>\n<td>Octal</td>\n</tr>\n<tr>\n<td>Decimal</td>\n</tr>\n<tr>\n<td>Hexadecimal</td>\n</tr>\n</tbody>\n</table>\n\nHexadecimal numbers must have a leading digit (e.g., 0xffffh) to differentiate them from identifiers. Hexadecimal digits are accepted in either upper or lower case.\n\nNote that a binary constant must have an upper case B following it, as a lower case b is used for temporary (numeric) label backward references.\n4.5.2 **Character Constants And Strings**\n\nA character constant is a single character enclosed in single quotes ' .\n\nMulti-character constants, or strings, are a sequence of characters, not including carriage return or newline characters, enclosed within matching quotes. Either single quotes ' or double quotes \" can be used, but the opening and closing quotes must be the same.\n\n4.6 **Identifiers**\n\nAssembly identifiers are user-defined symbols representing memory locations or numbers. A symbol can contain any number of characters drawn from alphabetics, numerics, as well as special characters: dollar, $; question mark, ?; and underscore, _.\n\nThe first character of an identifier cannot be numeric nor the $ character. The case of alphabetics is significant, e.g., Fred is not the same symbol as fred. Some examples of identifiers are shown here:\n\n<table>\n<thead>\n<tr>\n<th>Identifier</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>An_identifier</td>\n</tr>\n<tr>\n<td>an_identifier</td>\n</tr>\n<tr>\n<td>an_identifier1</td>\n</tr>\n<tr>\n<td>?$12345</td>\n</tr>\n</tbody>\n</table>\n\nAn identifier cannot be one of the assembler directives, keywords, or psect flags.\n\n4.6.1 **Significance Of Identifiers**\n\nUsers of other assemblers that attempt to implement forms of data typing for identifiers should note that this assembler attaches no significance to any symbol, and places no restrictions or expectations on the usage of a symbol.\n\nThe names of psects (program sections) and ordinary symbols occupy separate, overlapping name spaces, but other than this, the assembler does not care whether a symbol is used to represent bytes, words or sports cars. No special syntax is needed or provided to define the addresses of bits or any other data type, nor will the assembler issue any warnings if a symbol is used in more than one context. The instruction and addressing mode syntax provide all the information necessary for the assembler to generate correct code.\n\n4.6.2 **Assembler-generated Identifiers**\n\nWhere a LOCAL directive is used in a macro block, the assembler will generate a unique symbol to replace each specified identifier in each expansion of that macro. These unique symbols will have the form ??nnnn where nnnn is a 4-digit number. The user should avoid defining symbols with the same form.\n\n4.6.3 **Location Counter**\n\nThe current location within the active program section is accessible via the symbol $. This symbol expands to the address of the currently executing instruction (which is different than the address contained in the program counter (PC) register when executing this instruction). Thus:\n\n```assembly\ngoto $ ;endless loop\n```\n\nwill represent code that will jump to itself and form an endless loop. By using this symbol and an offset, a relative jump destination can be specified.\n\nAny address offset added to $ has the native addressability of the target device. So, for baseline and mid-range devices, the offset is the number of instructions away from the current location, as these devices have word-addressable program memory. For PIC18 instructions, which use byte addressable program memory, the offset to this symbol represents the number of bytes from the current location. As PIC18 instructions must be word aligned, the offset to the location counter should be a multiple of 2. All offsets are rounded down to the nearest multiple of 2.\nFor example:\n\n```\ngoto $+2 ;skip...\nmovlw 8 ;to here for PIC18 devices, or\nmovwf _foo ;to here for baseline and mid-range devices\n```\n\nwill skip the `movlw` instruction on baseline or mid-range devices. On PIC18 devices, `goto $+2` will jump to the following instruction; i.e., act like a `nop` instruction.\n\n### 4.6.4 Register Symbols\n\nCode in assembly modules can gain access to the special function registers by including pre-defined assembly header files. The appropriate file can be included by add the line:\n\n```\n#include <xc.inc>\n```\n\nto the assembler source file and using a `.S` extension with the source filename to ensure it is preprocessed. This header file contains appropriate commands to ensure that the header file specific for the target device is included into the source file.\n\nThese header files contain `EQU` declarations for all byte or multi-byte sized registers and `#define` macros for named bits within byte registers.\n\n### 4.6.5 Symbolic Labels\n\nA label is a symbolic alias that is assigned a value that is equal to the current address within the current psect. Labels are not assigned a value until link time.\n\nA label definition consists of any valid assembly identifier that must be followed by a colon, `:`. The definition can appear on a line by itself or it can be positioned to the left of an instruction or assembler directive. Here are two examples of legitimate labels interspersed with assembly code.\n\n```\nfrank:\nmovlw 1\ngoto fin\nsimon44: clrf _input\n```\n\nHere, the label `frank` will ultimately be assigned the address of the `movlw` instruction and `simon44` the address of the `clrf` instruction. Regardless of how they are defined, the assembler list file produced by the assembler will always show labels on a line by themselves.\n\nLabels can be used (and are preferred) in assembly code, rather than using an absolute address with other instructions. In this way, they can be used as the target location for jump-type instructions or to load an address into a register.\n\nLike variables, labels have scope. By default, they can be used anywhere in the module in which they are defined. They can be used by code located before their definition. To make a label accessible in other modules, use the `GLOBAL` directive (see 4.9.26 Global Directive for more information).\n\n### 4.7 Expressions\n\nThe operands to instructions and directives are comprised of expressions. Expressions can be made up of numbers, identifiers, strings and operators.\n\nOperators can be unary (one operand, e.g., `not`) or binary (two operands, e.g., `+`). The operators allowable in expressions are listed in Table 5-3.\n\nThe usual rules governing the syntax of expressions apply.\n\nThe operators listed can all be freely combined in both constant and relocatable expressions. The linker permits relocation of complex expressions, so the results of expressions involving relocatable identifiers cannot be resolved until link time.\n### Program Sections\n\nProgram sections, or psects, are simply a section of code or data. They are a way of grouping together parts of a program (via the psect's name) even though the source code cannot be physically adjacent in the source file, or even where spread over several modules.\n\nA psect is identified by a name and has several attributes. The **PSECT** assembler directive is used to define a psect. It requires a name argument, which may be followed an comma-separated list of flags which define its attributes. Linker options that can be used to control psect placement in memory are described in **6. Linker**. These options can be accessed from the driver using the **-Wl** driver option (see **3.3.36 WL: Pass Option To The Linker Option**), negating the need for you to run the linker explicitly.\n\nSee the Assembler-provided Psects and Linker Classes section for a list of all psects that can be supplied by the assembler.\n\nUnless defined as **abs** (absolute), psects are relocatable.\n\n---\n\n### Table 4-5. Assembly Operators\n\n<table>\n<thead>\n<tr>\n<th>Operator</th>\n<th>Purpose</th>\n<th>Example</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>*</td>\n<td>multiplication</td>\n<td><code>movlw 4*33,w</code></td>\n</tr>\n<tr>\n<td>+</td>\n<td>addition</td>\n<td><code>bra $+1</code></td>\n</tr>\n<tr>\n<td>-</td>\n<td>subtraction</td>\n<td><code>DB 5-2</code></td>\n</tr>\n<tr>\n<td>/</td>\n<td>division</td>\n<td><code>movlw 100/4</code></td>\n</tr>\n<tr>\n<td>= or eq</td>\n<td>equality</td>\n<td><code>IF inp eq 66</code></td>\n</tr>\n<tr>\n<td>> or gt</td>\n<td>signed greater than</td>\n<td><code>IF inp > 40</code></td>\n</tr>\n<tr>\n<td>>= or ge</td>\n<td>signed greater than or equal to</td>\n<td><code>IF inp ge 66</code></td>\n</tr>\n<tr>\n<td>< or lt</td>\n<td>signed less than</td>\n<td><code>IF inp < 40</code></td>\n</tr>\n<tr>\n<td><= or le</td>\n<td>signed less than or equal to</td>\n<td><code>IF inp le 66</code></td>\n</tr>\n<tr>\n<td><> or ne</td>\n<td>signed not equal to</td>\n<td><code>IF inp <> 40</code></td>\n</tr>\n<tr>\n<td>low</td>\n<td>low byte of operand</td>\n<td><code>movlw low(inp)</code></td>\n</tr>\n<tr>\n<td>high</td>\n<td>high byte of operand</td>\n<td><code>movlw high(1008h)</code></td>\n</tr>\n<tr>\n<td>highword</td>\n<td>high 16 bits of operand</td>\n<td><code>DW highword(inp)</code></td>\n</tr>\n<tr>\n<td>mod</td>\n<td>modulus</td>\n<td><code>movlw 77mod4</code></td>\n</tr>\n<tr>\n<td>& or and</td>\n<td>bitwise AND</td>\n<td><code>clrf inp&0ffh</code></td>\n</tr>\n<tr>\n<td>^</td>\n<td>bitwise XOR (exclusive or)</td>\n<td><code>movf inp^80,w</code></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>bitwise OR</td>\n</tr>\n<tr>\n<td>not</td>\n<td>bitwise complement</td>\n<td><code>movlw not 055h,w</code></td>\n</tr>\n<tr>\n<td><< or shl</td>\n<td>shift left</td>\n<td><code>DB inp>>8</code></td>\n</tr>\n<tr>\n<td>>> or shr</td>\n<td>shift right</td>\n<td><code>movlw inp shr 2,w</code></td>\n</tr>\n<tr>\n<td>rol</td>\n<td>rotate left</td>\n<td><code>DB inp rol 1</code></td>\n</tr>\n<tr>\n<td>ror</td>\n<td>rotate right</td>\n<td><code>DB inp ror 1</code></td>\n</tr>\n<tr>\n<td>float24</td>\n<td>24-bit version of real operand</td>\n<td><code>DW float24(3.3)</code></td>\n</tr>\n<tr>\n<td>nul</td>\n<td>tests if macro argument is null</td>\n<td></td>\n</tr>\n</tbody>\n</table>\nCode or data that is not explicitly placed into a psect using the \\texttt{PSECT} directive will become part of the default (unnamed) psect. As you have no control over where this psect is linked, it is recommended that a \\texttt{PSECT} directive always be placed before the code and objects.\n\nWhen writing assembly code, you can use the psects provided once \\texttt{<xc.inc>} has been included. These have a similar name and function to the sections used by the 8-bit MPASM assembler.\n\nIf you create your own psects, try to associate them with an existing linker class (see \\texttt{5.3 Default Linker Classes} and \\texttt{6.1.2 C: Associate Linker Class To Psect}) otherwise you can need to specify linker options for them to be allocated correctly.\n\nNote, that the length and placement of psects is important. It is easier to write code if all executable code is located in psects that do not cross any device pages boundaries; so, too, if data psects do not cross bank boundaries. The location of psects (where they are linked) must match the assembly code that accesses the psect contents.\n\n### 4.9 Assembler Directives\n\nAssembler directives, or pseudo-ops, are used in a similar way to instruction mnemonics. With the exception of \\texttt{PAGESEL} and \\texttt{BANKSEL}, these directives do not generate instructions. The \\texttt{DB}, \\texttt{DW} and \\texttt{DDW} directives place data bytes into the current psect. The directives are listed in the following sections.\n\n#### Table 4-6. Assembler Directives\n\n<table>\n<thead>\n<tr>\n<th>Directive</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ALIGN</td>\n<td>Aligns output to the specified boundary.</td>\n</tr>\n<tr>\n<td>ASMOPT</td>\n<td>Controls whether subsequent code is optimized by the assembler.</td>\n</tr>\n<tr>\n<td>BANKSEL</td>\n<td>Generates code to select bank of operand.</td>\n</tr>\n<tr>\n<td>CALLSTACK</td>\n<td>Indicates the call stack depth remaining.</td>\n</tr>\n<tr>\n<td>[NO]COND</td>\n<td>Controls inclusion of conditional code in the listing file.</td>\n</tr>\n<tr>\n<td>CONFIG</td>\n<td>Specifies configuration bits.</td>\n</tr>\n<tr>\n<td>DB</td>\n<td>Defines constant byte(s).</td>\n</tr>\n<tr>\n<td>DW</td>\n<td>Defines constant word(s).</td>\n</tr>\n<tr>\n<td>DS</td>\n<td>Reserves storage.</td>\n</tr>\n<tr>\n<td>DABS</td>\n<td>Defines absolute storage.</td>\n</tr>\n<tr>\n<td>DLABS</td>\n<td>Define linear-memory absolute storage.</td>\n</tr>\n<tr>\n<td>DDW</td>\n<td>Defines double-width constant word(s).</td>\n</tr>\n<tr>\n<td>ELSE</td>\n<td>Alternates conditional assembly.</td>\n</tr>\n<tr>\n<td>ELSIF</td>\n<td>Alternates conditional assembly.</td>\n</tr>\n<tr>\n<td>ENDIF</td>\n<td>Ends conditional assembly.</td>\n</tr>\n<tr>\n<td>END</td>\n<td>Ends assembly.</td>\n</tr>\n<tr>\n<td>ENDM</td>\n<td>Ends macro definition.</td>\n</tr>\n<tr>\n<td>EQU</td>\n<td>Defines symbol value.</td>\n</tr>\n<tr>\n<td>ERROR</td>\n<td>Generates a user-defined error.</td>\n</tr>\n<tr>\n<td>[NO]EXPAND</td>\n<td>Controls expansion of assembler macros in the listing file.</td>\n</tr>\n<tr>\n<td>EXTRN</td>\n<td>Links with global symbols defined in other modules.</td>\n</tr>\n<tr>\n<td>FNADDR</td>\n<td>Indicates a routine's address has been taken.</td>\n</tr>\n</tbody>\n</table>\n### Directive and Purpose\n\n<table>\n<thead>\n<tr>\n<th>Directive</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>FNARG</td>\n<td>Indicates calls in a routine's arguments.</td>\n</tr>\n<tr>\n<td>FNBREAK</td>\n<td>Breaks links in the call graph.</td>\n</tr>\n<tr>\n<td>FNCALL</td>\n<td>Indicates call hierarchy.</td>\n</tr>\n<tr>\n<td>FNCONF</td>\n<td>Indicates call stack settings.</td>\n</tr>\n<tr>\n<td>FNINDIR</td>\n<td>Indicates indirect calls made by routines.</td>\n</tr>\n<tr>\n<td>FNSIZE</td>\n<td>Indicates the size of a routines auto and parameter objects.</td>\n</tr>\n<tr>\n<td>FNROOT</td>\n<td>Indicates the root of a call tree.</td>\n</tr>\n<tr>\n<td>GLOBAL</td>\n<td>Makes symbols accessible to other modules or allow reference to other global symbols defined in other modules.</td>\n</tr>\n<tr>\n<td>IF</td>\n<td>Conditional assembly.</td>\n</tr>\n<tr>\n<td>INCLUDE</td>\n<td>Textually includes the content of the specified file.</td>\n</tr>\n<tr>\n<td>IRP</td>\n<td>Repeats a block of code with a list.</td>\n</tr>\n<tr>\n<td>IRPC</td>\n<td>Repeats a block of code with a character list.</td>\n</tr>\n<tr>\n<td>[NO]LIST</td>\n<td>Defines options for listing file.</td>\n</tr>\n<tr>\n<td>LOCAL</td>\n<td>Defines local tabs.</td>\n</tr>\n<tr>\n<td>MACRO</td>\n<td>Macro definition.</td>\n</tr>\n<tr>\n<td>MESSG</td>\n<td>Generates a user-defined advisory message.</td>\n</tr>\n<tr>\n<td>ORG</td>\n<td>Sets location counter within current psect.</td>\n</tr>\n<tr>\n<td>PAGELEN</td>\n<td>Specifies the length of the listing file page.</td>\n</tr>\n<tr>\n<td>PAGESEL</td>\n<td>Generates set/clear instruction to set PCLATH bits for this page.</td>\n</tr>\n<tr>\n<td>PAGewidth</td>\n<td>Specifies the width of the listing file page.</td>\n</tr>\n<tr>\n<td>PROCESSOR</td>\n<td>Defines the particular chip for which this file is to be assembled.</td>\n</tr>\n<tr>\n<td>PSECT</td>\n<td>Declares or resumes program section.</td>\n</tr>\n<tr>\n<td>RADIX</td>\n<td>Specifies radix for numerical constants.</td>\n</tr>\n<tr>\n<td>REPT</td>\n<td>Repeats a block of code n times.</td>\n</tr>\n<tr>\n<td>SET</td>\n<td>Defines or re-defines symbol value.</td>\n</tr>\n<tr>\n<td>SIGNAT</td>\n<td>Defines function signature.</td>\n</tr>\n<tr>\n<td>SUBTITLE</td>\n<td>Specifies the subtitle of the program for the listing file.</td>\n</tr>\n<tr>\n<td>TITLE</td>\n<td>Specifies the title of the program for the listing file.</td>\n</tr>\n</tbody>\n</table>\n\n### 4.9.1 Align Directive\n\nThe **ALIGN** directive aligns whatever is following, data storage or code etc., to the specified offset boundary within the current psect. The boundary is specified as a number of bytes following the directive.\n\nFor example, to align output to a 2-byte (even) address within a psect, the following could be used.\n\n```\nALIGN 2\n```\n\nNote that what follows will only begin on an even absolute address if the psect begins on an even address; i.e., alignment is done within the current psect. See **4.9.40.16 Reloc Flag** for psect alignment.\nThe ALIGN directive can also be used to ensure that a psect's length is a multiple of a certain number. For example, if the above ALIGN directive was placed at the end of a psect, the psect would have a length that was always an even number of bytes long.\n\n### 4.9.2 Asmopt Directive\n\nThe ASMOPT action directive selectively controls the assembler optimizer when processing assembly code. The allowable actions are shown in Table 4-7.\n\n<table>\n<thead>\n<tr>\n<th>Action</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>off</td>\n<td>Disables the assembler optimizer for subsequent code.</td>\n</tr>\n<tr>\n<td>on</td>\n<td>Enables the assembler optimizer for subsequent code.</td>\n</tr>\n<tr>\n<td>pop</td>\n<td>Retrieves the state of the assembler optimization setting.</td>\n</tr>\n<tr>\n<td>push</td>\n<td>Saves the state of the assembler optimization setting.</td>\n</tr>\n</tbody>\n</table>\n\nNo code is modified after an ASMOPT off directive. Following an ASMOPT on directive, the assembler will perform allowable optimizations.\n\nThe ASMOPT push and ASMOPT pop directives allow the state of the assembler optimizer to be saved onto a stack of states and then restored at a later time. They are useful when you need to ensure the optimizers are disabled for a small section of code, but you do not know if the optimizers have previously been disabled.\n\nFor example:\n\n```assembly\nASMOPT PUSH ;store the state of the assembler optimizers\nASMOPT OFF ;optimizations must be off for this sequence\nmovlw 0x55\nmovwf EECON2\nmovlw 0xAA\nmovwf EECON2\nASMOPT POP ;restore state of the optimizers\n```\n\nNote that no optimizations are performed by the MPLAB XC8 PIC Assembler and these controls will be ignored.\n\n### 4.9.3 Banksel Directive\n\nThe BANKSEL directive can be used to generate code to select the data bank of the operand. The operand should be the symbol or address of an object that resides in the data memory (see 4.1.2 Bank And Page Selection).\n\n### 4.9.4 Callstack Directive\n\nThe CALLSTACK depth directive indicates to the assembler the number of call stack levels still available at that particular point in the program.\n\nThis directive is used by the assembler optimizers to determine if transformations like procedural abstraction can take place.\n\nNote that no optimizations are performed by the MPLAB XC8 PIC Assembler and this control will be ignored.\n\n### 4.9.5 Cond Directive\n\nThe COND directive includes conditional code in the assembly listing file. The complementary NOCOND directive will not include conditional code in the listing file.\n\n### 4.9.6 Config Directive\n\nThe config directive allows the configuration bits, or fuses, to be specified in the assembly source file.\n\nThe directive has the following forms:\n\n```assembly\nCONFIG setting = value\nCONFIG register = literal_value\n```\nHere, *setting* is a configuration setting descriptor, e.g., WDT and *value* can be either a textual description of the desired state, e.g., OFF or a numerical value. Numerical values are subject to the same constraints as other numerical constant operands.\n\nThe *register* field is the name of a configuration or id-location register.\n\nThe available *setting*, *register* and *value* fields are documented in the chipinfo file relevant to your device (i.e. pic_chipinfo.html and pic18_chipinfo.html).\n\nOne CONFIG directive can be used to set each configuration setting; alternatively, several comma-separated configuration settings can be specified by the same directive. The directive can be used as many times as required to fully configure the device.\n\nThe following example shows a configuration register being programmed as a whole and programmed using the individual settings contained within that register:\n\n```text\n; PIC18F67K22\n; VREG Sleep Enable bit : Enabled\n; LF-INTOSC Low-power Enable bit : LF-INTOSC in High-power mode during Sleep\n; SOSC Power Selection and mode Configuration bits : High Power SOSC circuit selected\n; Extended Instruction Set : Enabled\nconfig RETEN = ON, INTOSCSEL = HIGH, SOSCSEL = HIGH, XINST = ON\n; Alternatively\nconfig CONFIG1L = 0x5D\n; IDLOC @ 0x200000\nconfig IDLOC0 = 0x15\n```\n\n### 4.9.7 Db Directive\n\nThe **DB** directive is used to initialize storage as bytes. The argument is a comma-separated list of expressions, each of which will be assembled into one byte and assembled into consecutive memory locations.\n\n**Examples:**\n\n```text\nalabel: DB 'X',1,2,3,4,\n```\n\nIf the size of an address unit in the program memory is 2 bytes, as it will be for baseline and mid-range devices (see **4.9.40.4 Delta Flag**), the **DB** pseudo-op will initialize a word with the upper byte set to zero. The above example will define bytes padded to the following words.\n\n```\n0058 0001 0002 0003 0004\n```\n\nHowever, on PIC18 devices (PSECT directive’s delta flag should be 1), no padding will occur and the following data will appear in the HEX file.\n\n```\n58 01 02 03 04\n```\n\n### 4.9.8 Dw Directive\n\nThe **DW** `value_list` directive operates in a similar fashion to **DB**, except that it assembles expressions into 16-bit words. Example:\n\n```text\nDW -1, 3664h, ‘A’\n```\n\n### 4.9.9 Ds Directive\n\nThe **DS** `units` directive reserves, but does not initialize, the specified amount of space. The single argument is the number of address units to be reserved. An address unit is determined by the flags used with the psect that holds the directive.\n\nThis directive is typically used to reserve bytes for RAM-based objects in the data memory (the enclosing psect’s space flag set to 1). If the psect in which the directive resides is a bit psect (the psect’s bit flag was set), the directive reserves the request number of bits. If used in a psect linked into the program memory, it will move the location counter, but not place anything in the HEX file output. Note that on Mid-range and Baseline devices, the size\nof an address unit in the program memory is 2 bytes (see 4.9.40.4 Delta Flag), so the DS pseudo-op will actually reserve words in that instance.\n\nAn object is typically defined by using a label and then the DS directive to reserve locations at the label location.\n\nExamples:\n\n```\nPSECT myVars,space=1,class=BANK2\nalabel:\n DS 23 ;reserve 23 bytes of memory\nPSECT myBits,space=1,bit,class=COMRAM\nxlabel:\n DS 2+3 ;reserve 5 bits of memory\n```\n\n### 4.9.10 Ddw Directive\n\nThe DDW directive operates in a similar fashion to DW, except that it assembles expressions into double-width (32-bit) words. Example:\n\n```\nDDW 'd', 12345678h, 0\n```\n\n### 4.9.11 Dabs Directive\n\nThe DABS directive allows one or more bytes of memory to be reserved at the specified address. The general form of the directive is:\n\n```\nDABS memorySpace, address, bytes [,symbol]\n```\n\nwhere `memorySpace` is a number representing the memory space in which the reservation will take place, `address` is the address at which the reservation will take place and `bytes` is the number of bytes that is to be reserved. The symbol is optional and refers to the name of the object at the address.\n\nUse of symbol in the directive will aid debugging. The symbol is automatically made globally accessible and is equated to the address specified in the directive. For example, the following directive:\n\n```\nDABS 1,0x100,4,foo\n```\n\nis identical to the following directives:\n\n```\nGLOBAL foo\nfoo EQU 0x100\nDABS 1,0x100,4\n```\n\nThis directive differs to the DS directive in that it can be used to reserve memory at any location, not just within the current psect. Indeed, these directives can be placed anywhere in the assembly code and do not contribute to the currently selected psect in any way.\n\nThe memory space number is the same as the number specified with the space flag option to psects (see 4.9.40.18 Space Flag).\n\nThe linker reads this DABS-related information from object files and ensures that the reserved addresses are not used for other memory placement.\n\n### 4.9.12 Dlabs Directive\n\nThe DLABS directive allows one or more bytes of memory to be reserved at the specified linear address on those devices that support linear addressing. The general form of the directive is:\n\n```\nDLABS memorySpace, address, bytes [,symbol]\n```\n\nThe `memorySpace` argument is a number representing the linear memory space. This will be the same number as the banked data space. The `address` is the address at which the reservation will take place. This can be specified as either a linear or banked address. The `bytes` is the number of bytes that is to be reserved. The symbol is optional and refers to the name of the object at the address.\nUse of symbol in the directive will aid debugging. The symbol is automatically made globally accessible and is equated to the linear address specified in the directive. So, for example, the following directive:\n\n```\nDLABS 1,0x120,128,foo\n```\n\nis identical to the following directives:\n\n```\nGLOBAL foo\nfoo EQU 0x2080\nDABS 1,0x120,80\nDABS 1,0x1A0,48\nDABS 1,0x20A0,0\n```\n\nNote that the object spans two banks and that the linear address, 0x2080, has been equated to the symbol instead of the banked address, 0x100.\n\nThis directive differs to the DS directive in that it can be used to reserve memory at any location, not just within the current psect. Indeed, these directives can be placed anywhere in the assembly code and do not contribute to the currently selected psect in any way.\n\nThe memory space number is the same as the number specified with the space flag option to psects (see 4.9.40.18 Space Flag).\n\nThe linker reads this DLABS-related information from object files and ensures that the reserved addresses are not used for other memory placement.\n\n### 4.9.13 End Directive\n\nThe END label directive is optional, but if present should be at the very end of the program. It will terminate the assembly and not even blank lines should follow this directive.\n\nIf an expression is supplied as an argument, that expression will be used to define the entry point of the program. This is stored in a start record in the object file produced by the assembler. Whether this is of any use will depend on the linker.\n\nFor example:\n\n```\nEND start_label ;defines the entry point\n```\n\nor\n\n```\nEND ;do not define entry point\n```\n\n### 4.9.14 Equ Directive\n\nThe EQU pseudo-op defines a symbol and equates its value to an expression. For example\n\n```\nthomas EQU 123h\n```\n\nThe identifier thomas will be given the value 123h. EQU is legal only when the symbol has not previously been defined. See 4.9.43 Set Directive for redefinition of values.\n\nThis directive performs a similar function to the preprocessor’s #define directive (see 5.1 Preprocessor Directives).\n\n### 4.9.15 Error Directive\n\nThe error directive produces a user-defined build-time error message that will halt the assembler. The message to be printed should this directive be executed is specified as a string. Typically this directive will be made conditional, to detect an invalid situation.\n\nFor example:\n\n```\nIF MODE\n call process\nELSE\n```\n4.9.16 Expand Directive\n\nThe `EXPAND` directive shows code generated by macro expansions in the assembler listing file. The complementary `NOEXPAND` directive hides code generated by macro expansions in the assembler listing file.\n\n4.9.17 Extn Directive\n\nThe `EXTRN` identifier pseudo-op is similar to `GLOBAL` (see 4.9.26 Global Directive), but can only be used to link in with global symbols defined in other modules. An error will be triggered if you use `EXTRN` with a symbol that is defined in the same module.\n\n4.9.18 Fnaddr Directive\n\nThe `FNADDR` routine directive tells the linker that a routine has had its address taken, and thus it could be called indirectly. This information is used by the linker when allocating objects to the compiled stack.\n\n4.9.19 Fnarg Directive\n\nThe `FNARG` `routine1,routine2` directive tells the linker that the evaluation of the an argument to the `routine1` routine involves a call to `routine2`, thus the argument memories for the two routines on the compiled stack should not overlap.\n\nFor example\n\n```\nFNARG init,start ;start is called to obtain an argument for init\n```\n\n4.9.20 Fnbreak Directive\n\nThe `FNBREAK` `routine1,routine2` directive is used to break links in the call graph information produced by the linker.\n\nIt states that any calls to `routine1` in trees other than the tree rooted at `routine2` should not be considered when checking for routines that appear in multiple call graphs. Memory for `routine1`'s compiled stack objects will only be assigned in the graph for the routine rooted at `routine2`.\n\n4.9.21 Fncall Directive\n\nThe `FNCALL` `caller,callee` directive tells the linker that a routine has been called by another. This information is used by the linker to prevent any stack-based objects they define from overlapping in the compiled stack.\n\nFor example\n\n```\nFNCALL main,init ;main calls init\n```\n\n4.9.22 Fnconf Directive\n\nThe `FNCONF` `psect,autos,args` directive is used to supply the linker with configuration information for a call graph.\n\nThe first argument is the name of the psect in which the compiled stack should be placed. This is followed by the prefix to be used for auto-type objects and argument-type objects. These prefixes are used with the name of the function that defines the objects.\n\nFor example:\n\n```\nFNCONF rbss,?a,?\n```\n\ntells the linker that the compiled stack should be placed in a psect called `rbss`, and that any auto variable block start with the string `?a` and function argument blocks start with `?`. Thus, a routine called `foo` which defines compiled stack objects using an `FNARG` directive would create two blocks started by the identifiers `?afoo` and `?foo` in the psect called `rbss`. \n4.9.23 **Fnindir Directive**\nThe `FNINDIR`, `signature` directive tells the linker that the named routine has performed an indirect call to a routine which has the indicated signature value. See 4.9.44 **Signat Directive** for information on how to set signature values. The linker will assume the routine could be calling any other routine that has a matching signature value and which has had its address taken. See 4.9.18 **Fnaddr Directive** for information on how to indicate that a function has had its address taken.\n\nFor example, if a routine called `fred` performs an indirect call to a function with a signature value of 8249, use the following directive:\n\n```\nFNINDIR _fred,8249\n```\n\n4.9.24 **Fnroot Directive**\nThe `FNROOT` routine directive tells the linker that `routine` is the root of a call graph. Routines called by this routine are built up using the `FNCALL` directive, see 4.9.21 **Fncall Directive**. Each call graph has unique memory assigned to it for the stack-based objects defined by routines within that graph.\n\n4.9.25 **Fssize Directive**\nThe `FNSIZE`, `autos`, `args` directive informs the linker of the size of the auto variable and argument area associated with `routine`. These values are used by the linker when building the call graph and assigning addresses to the variable and argument areas.\n\nFor example, the directive:\n\n```\nFNSIZE fred, 10, 5\n```\n\nindicates that the routine `fred` needs 10 bytes of auto variables and 5 bytes of arguments. See 4.9.22 **Fnconf Directive** for information how to access these areas of memory.\n\n4.9.26 **Global Directive**\nThe `GLOBAL` `identifier_list` directive declares a list of comma-separated symbols. If the symbols are defined within the current module, they are made public. If the symbols are not defined in the current module, they are made references to public symbols defined in external modules. Thus to use the same symbol in two modules the `GLOBAL` directive must be used at least twice: once in the module that defines the symbol to make that symbol public and again in the module that uses the symbol to link in with the external definition.\n\nFor example:\n\n```\nGLOBAL lab1,lab2,lab3\n```\n\n4.9.27 **If, Elsif, Else And Endif Directives**\nThese directives implement conditional assembly.\n\nThe argument to `IF` and `ELSIF` should be an absolute expression. If it is non-zero, then the code following it up to the next matching `ELSE`, `ELSIF` or `ENDIF` will be assembled. If the expression is zero, then the code up to the next matching `ELSE` or `ENDIF` will not be output. At an `ELSE`, the sense of the conditional compilation will be inverted, while an `ENDIF` will terminate the conditional assembly block. Conditional assembly blocks can be nested.\n\nThese directives do not implement a runtime conditional statement in the same way that the C statement `if` does; they are only evaluated when the code is built. In addition, assembly code in both true and false cases is always scanned and interpreted, but the machine code corresponding to instructions is output only if the condition matches. This implies that assembler directives (e.g., `EQU`) will be processed regardless of the state of the condition expression and should not be used inside an `IF` construct.\n\nFor example:\n\n```\nIF ABC\n goto aardvark\nELSIF DEF\n```\ngoto denver\nELSE\ngoto grapes\nENDIF\nENDIF\n\nIn this example, if ABC is non-zero, the first goto instruction will be assembled but not the second or third. If ABC is zero and DEF is non-zero, the second goto instruction will be assembled but the first and third will not. If both ABC and DEF are zero, the third goto instruction will be assembled.\n\n4.9.28 Include Directive\n\nThe INCLUDE \"filename\" directive causes the specified file to be textually replace this directive. For example:\n\n```\nINCLUDE \"options.inc\"\n```\n\nThe assembler driver does not pass any search paths to the assembler, so if the include file is not located in the current working directory, the file's full path must be specified with the file name.\n\nAssembly source files with a .S extension are preprocessed, thus allowing use of preprocessor directives, such as #include, which is an alternative to the INCLUDE directive.\n\n4.9.29 Irp And Irpc Directives\n\nThe IRP and IRPC directives operate in a similar way to REPT; however, instead of repeating the block a fixed number of times, it is repeated once for each member of an argument list.\n\nIn the case of IRP, the list is a conventional macro argument list. In the case or IRPC, it is each character in one argument. For each repetition, the argument is substituted for one formal parameter.\n\nFor example:\n\n```\nIRP number,4865h,6C6Ch,6F00h\nDW number\nENDM\n```\n\nwould expand to:\n\n```\nDW 4865h\nDW 6C6Ch\nDW 6F00h\n```\n\nNote that you can use local labels and angle brackets in the same manner as with conventional macros.\n\nThe IRPC directive is similar, except it substitutes one character at a time from a string of non-space characters.\n\nFor example:\n\n```\nIRPC char,ABC\nDB 'char'\nENDM\n```\n\nwill expand to:\n\n```\nDB 'A'\nDB 'B'\nDB 'C'\n```\n\n4.9.30 List Directive\n\nThe LIST directive controls whether listing output is produced.\n\nIf the listing was previously turned off using the NOLIST directive, the LIST directive will turn it back on.\n\nAlternatively, the LIST control can include options to control the assembly and the listing. The options are listed in Table 5-9.\nTable 4-8. List Directive Options\n\n<table>\n<thead>\n<tr>\n<th>List Option</th>\n<th>Default</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>c=nnn</td>\n<td>80</td>\n<td>Set the page (i.e., column) width.</td>\n</tr>\n<tr>\n<td>n=nnn</td>\n<td>59</td>\n<td>Set the page length.</td>\n</tr>\n<tr>\n<td>t=ON</td>\n<td>OFF</td>\n<td>OFF</td>\n</tr>\n<tr>\n<td>p=device</td>\n<td>n/a</td>\n<td>Set the device type.</td>\n</tr>\n<tr>\n<td>x=ON</td>\n<td>OFF</td>\n<td>OFF</td>\n</tr>\n</tbody>\n</table>\n\n4.9.31 Local Directive\n\nThe `LOCAL label` directive allows unique labels to be defined for each expansion of a given macro. Any symbols listed after the `LOCAL` directive will have a unique assembler generated symbol substituted for them when the macro is expanded. For example:\n\n```assembly\ndown MACRO count\n LOCAL more\n more: decfsz count\n goto more\nENDM\n```\n\nWhen expanded, will include a unique assembler generated label in place of more. For example:\n\n```assembly\ndown foobar\n```\n\nexpands to:\n\n```assembly\n??0001 decfsz foobar\ngoto ??0001\n```\n\nIf invoked a second time, the label more would expand to `??0002` and multiply defined symbol errors will be averted.\n\n4.9.32 Macro And Endm Directives\n\nThe `MACRO … ENDM` directives provide for the definition of assembly macros, optionally with arguments. See 4.9.14 Equ Directive for simple association of a value with an identifier, or 5.1 Preprocessor Directives for the preprocessor’s `#define` macro directive, which can also work with arguments.\n\nThe `MACRO` directive should be preceded by the macro name and optionally followed by a comma-separated list of formal arguments. When the macro is used, the macro name should be used in the same manner as a machine opcode, followed by a list of arguments to be substituted for the formal parameters.\n\nFor example:\n\n```assembly\n;macro: movlf - Move a literal value into a nominated file register\n;args: arg1 - the literal value to load\n; arg2 - the NAME of the source variable\nmovlf MACRO arg1,arg2\n movlw arg1\n movwf arg2 mod 080h\nENDM\n```\n\nWhen used, this macro will expand to the 2 instructions in the body of the macro, with the formal parameters substituted by the arguments. Thus:\n\n```assembly\nmovlf 2,tempvar\n```\n\nexpands to:\n\n```assembly\nmovlw 2\nmovwf tempvar mod 080h\n```\nThe `&` character can be used to permit the concatenation of macro arguments with other text, but is removed in the actual expansion. For example:\n\n```\nloadPort MACRO port, value\n movlw value\n movwf PORT&port\nENDM\n```\n\nwill load `PORTA` if `port` is `A` when called, etc. The special meaning of the `&` token in macros implies that you cannot use the bitwise `AND` operator, (also represented by `&`), in assembly macros; use the `and` form of this operator instead.\n\nA comment can be suppressed within the expansion of a macro (thus saving space in the macro storage) by opening the comment with a double semicolon, `;;`.\n\nWhen invoking a macro, the argument list must be comma-separated. If it is desired to include a comma (or other delimiter such as a space) in an argument then angle brackets `<` and `>` can be used to quote.\n\nIf an argument is preceded by a percent sign, `%`, that argument will be evaluated as an expression and passed as a decimal number, rather than as a string. This is useful if evaluation of the argument inside the macro body would yield a different result.\n\nThe `nul` operator can be used within a macro to test a macro argument, for example:\n\n```\nIF nul arg3 ;argument was not supplied.\n...\nELSE arg3 ;argument was supplied\n...\nENDIF\n```\n\nSee 4.9.31 Local Directive for use of unique local labels within macros.\n\nBy default, the assembly list file will show macro in an unexpanded format; i.e., as the macro was invoked. Expansion of the macro in the listing file can be shown by using the `EXPAND` assembler directive (see 4.9.16 Expand Directive).\n\n4.9.33 Messg Directive\n\nThe `messg` directive produces a user-defined build-time advisory message. Execution of this directive will not prevent the assembler from building. The message to be printed should this directive be executed is specified as a string. Typically this directive will be made conditional, to detect an invalid situation.\n\nFor example:\n\n```\nIF MODE call process\nELSE\n MESSG \"no mode defined\"\nENDIF\n```\n\n4.9.34 Org Directive\n\nThe `ORG` directive changes the value of the location counter within the current psect. This means that the addresses set with `ORG` are relative to the base address of the psect, which is not determined until link time.\n\n**Note:** The much-abused `ORG` directive does not move the location counter to the absolute address you specify. Only if the psect in which this directive is placed is absolute and overlaid will the location counter be moved to the specified address. To place objects at a particular address, place them in a psect of their own and link this at the required address using the linkers `-P` option (see 6.1.17 P: Position Psect). The `ORG` directive is not commonly required in programs.\n\nThe argument to `ORG` must be either an absolute value, or a value referencing the current psect. In either case, the current location counter is set to the value determined by the argument. It is not possible to move the location counter backward. For example:\n\n```\nORG 100h\n```\nwill move the location counter to the beginning of the current psect plus 100h. The actual location will not be known until link time.\n\nIn order to use the ORG directive to set the location counter to an absolute value, the directive must be used from within an absolute, overlaid psect. For example:\n\n```assembly\nPSECT absdata,abs,ovrld\nORG 50h\n;this is guaranteed to reside at address 50h\n```\n\n## 4.9.35 Page Directive\nThe PAGE directive causes a new page to be started in the listing output. A Control-L (form feed) character will also cause a new page when it is encountered in the source.\n\n### 4.9.36 Pagelen Directive\nThe PAGELEN nnn directive sets the length of the assembly listing to be the number of specified lines.\n\n### 4.9.37 Pagesel Directive\nThe PAGESEL directive can be used to generate code to select the page of the address operand. (see 4.1.2 Bank And Page Selection).\n\n### 4.9.38 Pagewidth Directive\nThe PAGEWIDTH nnn directive sets the width of the assembly listing to be the number of specified characters.\n\n### 4.9.39 Processor Directive\nThe PROCESSOR directive should be used in a module if the assembler source is only applicable to one device. The -mcpu option must always be used when building to specify the target device the code is being built for. If there is a mismatch between the device specified in the directive and in the option, an error will be triggered.\n\nFor example:\n\n```assembly\nPROCESSOR 18F4520\n```\n\n### 4.9.40 Psect Directive\nThe PSECT directive declares or resumes a program section.\n\nThe directive takes as argument a name and, optionally, a comma-separated list of flags. The allowed flags specify attributes of the psect. They are listed in Table 5-5.\n\nThe psect name is in a separate name space to ordinary assembly symbols, so a psect can use the same identifier as an ordinary assembly identifier. However, a psect name cannot be one of the assembler directives, keywords, or psect flags.\n\nOnce a psect has been declared, it can be resumed later by another PSECT directive; however, the flags need not be repeated and will be propagated from the earlier declaration. An error is generated if two PSECT directives for the same psect are encountered with contradictory flags, the exceptions being that the reloc, size and limit flags can be respecified without error.\n\n### Table 4-9. Psect Flags\n\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>abs</td>\n<td>psect is absolute.</td>\n</tr>\n<tr>\n<td>bit</td>\n<td>psect holds bit objects.</td>\n</tr>\n<tr>\n<td>class=name</td>\n<td>Specify class name for psect.</td>\n</tr>\n<tr>\n<td>delta=size</td>\n<td>Size of an addressing unit.</td>\n</tr>\n</tbody>\n</table>\n### 4.9.40.1 Abs Flag\n\nThe abs psect flag defines the current psect as being absolute; i.e., it is to start at location 0. This does not mean that this module’s contribution to the psect will start at 0, since other modules can contribute to the same psect (See also 4.9.40.14 Ovrld Flag).\n\nAn abs-flagged psect is not relocatable and an error will result if a linker option is issued that attempts to place such a psect at any location.\n\n### 4.9.40.2 Bit Flag\n\nThe bit psect flag specifies that a psect holds objects that are 1 bit wide. Such psects will have a scale value of 8, indicating that there are 8 addressable units to each byte of storage and that all addresses associated with this psect will be bit addresses, not byte addresses. Non-unity scale values for psects are indicated in the map file (see 6.3 Map Files).\n\n### 4.9.40.3 Class Flag\n\nThe class psect flag specifies a corresponding linker class name for this psect. A class is a range of addresses in which psects can be placed.\n\nClass names are used to allow local psects to be located at link time, since they cannot always be referred to by their own name in a `-P` linker option (as would be the case if there are more than one local psect with the same name).\nClass names are also useful where psects need only be positioned anywhere within a range of addresses rather than at a specific address. The association of a class with a psect that you have defined typically means that you do not need to supply a custom linker option to place it in memory.\n\nSee 6.1.1 A: Define Linker Class for information on how linker classes are defined.\n\n4.9.40.4 Delta Flag\nThe delta psect flag defines the size of the addressable unit. In other words, the number of data bytes that are associated with each address.\n\nWith PIC Mid-range and Baseline devices, the program memory space is word addressable; so, psects in this space must use a delta of 2. That is to say, each address in program memory requires 2 bytes of data in the HEX file to define their contents. So, addresses in the HEX file will not match addresses in the program memory.\n\nThe data memory space on these devices is byte addressable; so, psects in this space must use a delta of 1. This is the default delta value.\n\nAll memory spaces on PIC18 devices are byte addressable; so a delta of 1 (the default) should be used for all psects on these devices.\n\nThe redefinition of a psect with conflicting delta values can lead to phase errors being issued by the assembler.\n\n4.9.40.5 Global Flag\nThe global psect flag indicates that the linker should concatenate this psect with global psects in other modules and which have the same name.\n\nPsects are considered global by default, unless the local flag is used.\n\n4.9.40.6 Inline Flag\nThis flag is deprecated. Consider, instead, using the optim psect flag.\n\nThe inline psect flag is used by the code generator to tell the assembler that the contents of a psect can be inlined. If this operation is performed, the contents of the inline psect will be copied and used to replace calls to the function defined in the psect.\n\n4.9.40.7 Keep Flag\nThis flag is deprecated. Consider, instead, using the optim psect flag.\n\nThe keep psect flag ensures that the psect is not deleted after any inlining by the assembler optimizer. Psects that are candidates for inlining (see 4.9.40.6 Inline Flag) can be deleted after the inlining takes place.\n\n4.9.40.8 Limit Flag\nThe limit psect flag specifies a limit on the highest address to which a psect can extend. If this limit is exceeded when it is positioned in memory, an error will be generated. This is currently only available when building for PIC18 devices.\n\n4.9.40.9 Local Flag\nA psect defined using the local psect flag will not be combined with other local psects from other modules at link time, even if there are others with the same name. Where there are two local psects in the one module, they reference the same psect. A local psect cannot have the same name as any global psect, even one in another module.\n\nPsects which are local and which are not associated with a linker class (see 4.9.40.3 Class Flag) cannot be linked to an address using the -P linker option, since there could be more than one psect with this name. Typically these psects define a class flag and they are placed anywhere in that class range.\n\n4.9.40.10 Merge Flag\nThis flag is deprecated. Consider, instead, using the optim psect flag.\n\nThe merge psect flag controls how the psect will be merged with others. This flag can be assigned 0, 1, or not specified. When assigned 0, the psect will never be merged by the assembly optimizer during optimizations. If assigned the value 1, the psect can be merged if other psect attributes allow it and the optimizer can see an advantage in doing so. If this flag is not specified, then merging will not take place.\n\nTypically, merging is only performed on code-based psects (text psects).\n4.9.40.11 Noexec Flag\n\nThe noexec psect flag is used to indicate that the psect contains no executable code. This information is only relevant for debugging purposes.\n\n4.9.40.12 Note Flag\n\nThe note psect flag is used by special psects whose content is intended for assembler or debugger tools, and whose content will not be copied to the final program output. When the note flag is specified, several other psect flags are prohibited and their use with the same psect will result in a warning.\n\n4.9.40.13 Optim Flag\n\nThe optim psect flag is used to indicate the optimizations that can be performed on the psect's content, provided such optimizations are permitted and have been enabled.\n\nThis flag has no effect for assembly code built with MPLAB XC8 PIC Assembler, which performs no optimizations. The optimizations are indicated by a colon-separated list of names, shown in Table 5-6. An empty list implies that no optimizations can be performed on the psect.\n\nTable 4-10. Optim Flag Names\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Optimization</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>inline</td>\n<td>Allow the psect content to be inlined.</td>\n</tr>\n<tr>\n<td>jump</td>\n<td>Perform jump-based optimizations.</td>\n</tr>\n<tr>\n<td>merge</td>\n<td>Allow the psect's content to be merged with that of other similar psects (PIC10/12/16 devices only).</td>\n</tr>\n<tr>\n<td>pa</td>\n<td>Perform procedural abstraction.</td>\n</tr>\n<tr>\n<td>peep</td>\n<td>Perform peephole optimizations.</td>\n</tr>\n<tr>\n<td>remove</td>\n<td>Allow the psect to be removed entirely if it is completely inlined.</td>\n</tr>\n<tr>\n<td>split</td>\n<td>Allow the psect to be split into smaller psects if it surpasses size restrictions (PIC10/12/16 devices only).</td>\n</tr>\n<tr>\n<td>empty</td>\n<td>Perform no optimization on this psect.</td>\n</tr>\n</tbody>\n</table>\n\nSo, for example, the psect definition:\n\n```\nPSECT myText,class=CODE,reloc=2,optim=inline:jump:split\n```\n\nallows the assembler optimizer to perform inlining, splitting and jump-type optimizations of the myText psect content if those optimizations are enabled. The definition:\n\n```\nPSECT myText,class=CODE,reloc=2,optim=\n```\n\ndisables all optimizations associated with this psect regardless of the optimizer setting.\n\nThe optim psect flag replaces the use of the separate psect flags: merge, split, inline and keep.\n\n4.9.40.14 Ovrld Flag\n\nThe ovrld psect flag tells the linker that the content of this psect should be overlaid with that from other modules at link time. Normally psects with the same name are concatenated across modules. The contributions to an overlaid psect in the same module are always concatenated.\n\nThis flag in combination with the abs flag (see 4.9.40.1 Abs Flag) defines a truly absolute psect; i.e., a psect within which any symbols defined are absolute.\n\n4.9.40.15 Pure Flag\n\nThe pure psect flag instructs the linker that this psect will not be modified at runtime. So, for example, be placed in ROM. This flag is of limited usefulness since it depends on the linker and target system enforcing it.\n4.9.40.16 Reloc Flag\nThe reloc psect flag allows the specification of a requirement for alignment of the psect on a particular boundary. The boundary specification must be a power of two, for example 2, 8 or 0x40. For example, the flag reloc=100h would specify that this psect must start on an address that is a multiple of 0x100 (e.g., 0x100, 0x400, or 0x500).\n\nPIC18 instructions must be word aligned, so a reloc value of 2 must be used for any PIC18 psect that contains executable code. All other sections, and all sections for all other devices, can typically use the default reloc value of 1.\n\n4.9.40.17 Size Flag\nThe size psect flag allows a maximum size to be specified for the psect, e.g., size=100h. This will be checked by the linker after psects have been combined from all modules.\n\n4.9.40.18 Space Flag\nThe space psect flag is used to differentiate areas of memory that have overlapping addresses, but are distinct. Psects that are positioned in program memory and data memory have a different space value to indicate that the program space address 0, for example, is a different location to the data memory address 0.\n\nThe memory spaces associated with the space flag numbers are shown in Table 5-7.\n\nTable 4-11. Space Flag Numbers\n\n<table>\n<thead>\n<tr>\n<th>Space Flag Number</th>\n<th>Memory Space</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>Program memory, and EEPROM for PIC18 devices</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Data memory</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Reserved</td>\n</tr>\n<tr>\n<td>3</td>\n<td>EEPROM on Mid-range devices</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Configuration bit</td>\n</tr>\n<tr>\n<td>5</td>\n<td>IDLOC</td>\n</tr>\n<tr>\n<td>6</td>\n<td>Note</td>\n</tr>\n</tbody>\n</table>\n\nDevices that have a banked data space do not use different space values to identify each bank. A full address that includes the bank number is used for objects in this space. So, each location can be uniquely identified. For example, a device with a bank size of 0x80 bytes will use address 0 to 0x7F to represent objects in bank 0, and then addresses 0x80 to 0xFF to represent objects in bank 1, etc.\n\n4.9.40.19 Split Flag\nThis flag is deprecated. Consider, instead, using the optim psect flag.\n\nThe split psect flag can be assigned 0, 1, or not specified. When assigned 0, the psect will never be split by the assembly optimizer during optimizations. If assigned the value 1, the psect can be split if other psect attributes allow it and the psect is too large to fit in available memory. If this flag is not specified, then the splitability of this psect is based on whether the psect can be merged, see 4.9.40.10 Merge Flag.\n\n4.9.40.20 With Flag\nThe with psect flag allows a psect to be placed in the same page with another psect. For example the flag with=text will specify that this psect should be placed in the same page as the text psect.\n\nThe term withtotal refers to the sum of the size of each psect that is placed “with” other psects.\n\n4.9.41 Radix Directive\nThe RADIX radix directive controls the radix for numerical constants specified in the assembler source files. The allowable radices are shown in Table 4-12.\nTable 4-12. Radix Operands\n\n<table>\n<thead>\n<tr>\n<th>Radix</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dec</td>\n<td>Decimal constants</td>\n</tr>\n<tr>\n<td>hex</td>\n<td>Hexadecimal constants</td>\n</tr>\n<tr>\n<td>oct</td>\n<td>Octal constants</td>\n</tr>\n</tbody>\n</table>\n\n4.9.42 Rept Directive\n\nThe REPT directive temporarily defines an unnamed macro, then expands it a number of times as determined by its argument.\n\nFor example:\n\n```assembly\nREPT 3\n addwf fred,w\nENDM\n```\n\nwill expand to:\n\n```assembly\naddwf fred,w\naddwf fred,w\naddwf fred,w\n```\n\n(see 4.9.29 Irp And Irpc Directives).\n\n4.9.43 Set Directive\n\nThe SET directive is equivalent to EQU (4.9.14 Equ Directive), except that it allows a symbol to be re-defined without error. For example:\n\n```assembly\nthomas SET 0h\n```\n\nThis directive performs a similar function to the preprocessor's `#define` directive (see 5.1 Preprocessor Directives).\n\n4.9.44 Signat Directive\n\nThe SIGNAT directive is used to associate a 16-bit signature value with a label. At link time, the linker checks that all signatures defined for a particular label are the same. The linker will produce an error if they are not. The SIGNAT directive is used to enforce link time checking of function prototypes and calling conventions.\n\nFor example:\n\n```assembly\nSIGNAT _fred,8192\n```\n\nassociates the signature value 8192 with the symbol _fred. If a different signature value for _fred is present in any object file, the linker will report an error.\n\nOften, this directive is used with assembly language routines that are called from C. The easiest way to determine the signature value used by the MPLAB XC8 C Compiler is to write a C routine with the same prototype as that required for the assembly routine, and check that function’s signature directive argument, as determined by the code generator and as shown in the assembly list file.\n\n4.9.45 Space Directive\n\nThe SPACE `nnn` directive places `nnn` blank lines in the assembly listing output.\n\n4.9.46 Subtitle Directive\n\nThe SUBTITLE \"string\" directive defines a subtitle to appear at the top of every assembly listing page, but under the title. The subtitle should be enclosed in single or double quotes.\n4.9.47 Title Directive\n\nThe TITLE \"string\" directive keyword defines a title that will appear at the top of every assembly listing page. The title should be enclosed in single or double quotes.\n5. **Assembler Features**\nThe PIC Assembler provided access to a C preprocessor and many predefined psects and identifiers that you can use in your programs.\n\n5.1 **Preprocessor Directives**\nMPLAB XC8 accepts several specialized preprocessor directives, in addition to the standard directives. All of these are tabulated below.\n\n<table>\n<thead>\n<tr>\n<th>Directive</th>\n<th>Meaning</th>\n<th>Example</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>#</td>\n<td>Preprocessor null directive, do nothing.</td>\n<td>#</td>\n</tr>\n<tr>\n<td>#define</td>\n<td>Define preprocessor macro.</td>\n<td>#define SIZE (5)</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>#define FLAG</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>#define add(a,b) ((a)+(b))</td>\n</tr>\n<tr>\n<td>#elif</td>\n<td>Short for #else #if.</td>\n<td>see #ifdef</td>\n</tr>\n<tr>\n<td>#else</td>\n<td>Conditionally include source lines.</td>\n<td>see #if</td>\n</tr>\n<tr>\n<td>#endif</td>\n<td>Terminate conditional source inclusion.</td>\n<td>see #if</td>\n</tr>\n<tr>\n<td>#error</td>\n<td>Generate an error message.</td>\n<td>#error Size too big</td>\n</tr>\n<tr>\n<td>#if</td>\n<td>Include source lines if constant expression true.</td>\n<td>#if SIZE < 10</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>c = process(10)</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>#else</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>skip();</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>#endif</td>\n</tr>\n<tr>\n<td>#ifdef</td>\n<td>Include source lines if preprocessor symbol defined.</td>\n<td>#ifdef FLAG</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>do_loop();</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>#elif SIZE == 5</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>skip_loop();</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>#endif</td>\n</tr>\n<tr>\n<td>#ifndef</td>\n<td>Include source lines if preprocessor symbol not defined.</td>\n<td>#ifndef FLAG</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>jump();</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>#endif</td>\n</tr>\n<tr>\n<td>#include</td>\n<td>Include text file into source.</td>\n<td>#include <stdio.h></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>#include “project.h”</td>\n</tr>\n<tr>\n<td>#line</td>\n<td>Specify line number and filename for listing</td>\n<td>#line 3 final</td>\n</tr>\n<tr>\n<td>#nn filename</td>\n<td>(where nn is a number, and filename is the name of the source file) the following content originated from the specified file and line number.</td>\n<td>#20 init.c</td>\n</tr>\n<tr>\n<td>#undef</td>\n<td>Undefines preprocessor symbol.</td>\n<td>#undef FLAG</td>\n</tr>\n<tr>\n<td>#warning</td>\n<td>Generate a warning message.</td>\n<td>#warning Length not set</td>\n</tr>\n</tbody>\n</table>\nMacro expansion using arguments can use the `#` character to convert an argument to a string and the `##` sequence to concatenate arguments. If two expressions are being concatenated, consider using two macros in case either expression requires substitution itself; for example\n\n```c\n#define __paste1(a,b) a##b\n#define __paste(a,b) __paste1(a,b)\n```\n\nThis lets you use the `paste` macro to concatenate two expressions that themselves can require further expansion. Remember, that once a macro identifier has been expanded, it will not be expanded again if it appears after concatenation.\n\n### 5.2 Assembler-provided Psects\n\nThe PIC Assembler provides psect definitions (tabulated below), can be used to hold code and data, if required. These psects are available once you include `<xc.inc>` into your source file and have names that resemble the MPASM directive that creates similar sections in the MPASM assembler. For example, to have instructions placed into the `code` psect, use the following.\n\n```c\n#include <xc.inc>\nPSECT code\n;place instructions here\n```\n\nThe linker class associated with each of these psects and the device families for which they are defined are indicated in the table. The linker classes shown are also already predefined by the PIC Assembler, so you do not need to define them.\n\nYou can instead use psects and linker classes that you define, if required. In situations where a psect must reside at a specific location, you must use a unique psect so that it can be linked independently to others. See 4.9.40 Psect Directive and 6.1.17 P: Position Psect.\n\nTable 5-2. Assembler-provided Psects and Linker Classes\n\n<table>\n<thead>\n<tr>\n<th>Psect name</th>\n<th>Linker class</th>\n<th>Target device families</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>code</td>\n<td>CODE</td>\n<td>All</td>\n<td>To hold executable code</td>\n</tr>\n<tr>\n<td>eedata</td>\n<td>EEDATA</td>\n<td>All</td>\n<td>To hold data in EEPROM</td>\n</tr>\n<tr>\n<td>data</td>\n<td>STRCODE</td>\n<td>Baseline, Mid-range</td>\n<td>To hold data in program memory</td>\n</tr>\n<tr>\n<td>data</td>\n<td>CONST</td>\n<td>PIC18</td>\n<td>To hold data in program memory</td>\n</tr>\n<tr>\n<td>udata</td>\n<td>RAM</td>\n<td>All</td>\n<td>To hold objects allocatable anywhere in GPR</td>\n</tr>\n<tr>\n<td>udata_acs</td>\n<td>COMRAM</td>\n<td>PIC18</td>\n<td>To hold objects allocatable in the Access bank GPR</td>\n</tr>\n<tr>\n<td>udata_bankn</td>\n<td>BANKN</td>\n<td>All</td>\n<td>To hold object allocatable in a particular data memory bank</td>\n</tr>\n<tr>\n<td>udata_shr</td>\n<td>COMMON</td>\n<td>Baseline, Mid-range</td>\n<td>To hold objects allocatable in common memory</td>\n</tr>\n</tbody>\n</table>\n\n### 5.3 Default Linker Classes\n\nThe linker uses classes to represent memory ranges in which psects can be linked.\n\nClasses are defined by linker options (see 6.1.1 A: Define Linker Class). The assembler driver passes a default set of such options to the linker, based on the selected target device.\nPsects are typically allocated free memory from the class they are associated with. The association is made using the class flag with the PSECT directive (see 4.9.40.3 Class Flag). Alternatively, a psect can be explicitly placed into the memory associated with a class using a linker option (see 6.1.17 P: Position Psect).\n\nClasses can represent a single memory range, or multiple ranges. Even if two ranges are contiguous, the address where one range ends and the other begins, forms a boundary, and psects placed in the class can never cross such boundaries. You can create classes that cover the same addresses, but which are divided into different ranges and have different boundaries. This allows you to accommodate psects whose contents makes assumptions about where it or the data it accesses would be located in memory. Memory allocated from one class will also be reserved from other classes that specify the same memory addresses.\n\nTo the linker, there is no significance to a class name or the memory it defines.\n\nMemory can be removed from these classes if using the -mreserve option (see 3.3.24 Reserve Option), or when subtracting memory ranges using the -mram and -mrom options (see 3.3.23 Ram Option and 3.3.25 Rom Option).\n\nOther than reserve memory from classes, never change or remove address boundaries specified by a class.\n\n### 5.3.1 Program Memory Classes\n\nThe following linker classes are defined once you include <xc.inc> and represent program space memory. Not all classes will be present for each device.\n\n- **CODE**\n Consists of ranges that map to the program memory pages on the target device and are used for psects containing executable code. On Baseline devices, it can only be used by code that is accessed via a jump table.\n\n- **ENTRY**\n Is relevant for Baseline device psects containing executable code that is accessed via a call instruction. Calls can only be to the first half of a page on these devices. The class is defined in such a way that it spans a full page, but the psects it holds will be positioned so that they start in the first half of the page. This class is also used in Mid-range devices and will consist of many 0x100 word-long ranges, aligned on a 0x100 boundary.\n\n- **STRING**\n Consists of ranges that are 0x100 words long and aligned on a 0x100 boundary. Thus, it is useful for psects whose contents cannot span a 0x100 word boundary.\n\n- **STRCODE**\n Defines a single memory range that covers the entire program memory. It is useful for psects whose content can appear in any page and can cross page boundaries.\n\n- **CONST**\n Consists of ranges that are 0x100 words long and aligned on a 0x100 boundary. Thus, it is useful for psects whose contents cannot span a 0x100 word boundary.\n\n### 5.3.2 Data Memory Classes\n\nThe following linker classes are defined once you include <xc.inc> and represent data space memory. Not all classes will be present for each device.\n\n- **RAM**\n Consists of ranges that cover all the general purpose RAM memory of the target device, but excluding any common (unbanked) memory. Thus, it is useful for psects that must be placed within any general-purpose RAM bank.\n\n- **BIGRAM**\n Consists of a single memory range that is designed to cover the linear data memory of Enhanced Mid-range devices, or the entire available memory space of PIC18 devices. It is suitable for any psect whose contents are accessed using linear addressing or which does not need to be contained in a single data bank.\n\n- **ABS1**\n Consists of ranges that cover all the general purpose RAM memory of the target device, including any common (unbanked) memory. Thus, it is useful for psects that must be placed in general purpose RAM, but can be placed in any bank or the common memory.\n\n- **BANKx** (where x is a bank number) — each consist of a single range that covers the general purpose RAM in that bank, but excluding any common (unbanked) memory.\nCOMMON Consists of a single memory range that covers the common (unbanked) RAM, if present, for all Mid-range devices.\n\nCOMRAM Consists of a single memory range that covers the common (unbanked) RAM, if present, for all PIC18 devices.\n\nSFRx (where x is a number) — each consists of a single range that covers the SFR memory in bank x. These classes would not typically be used by programmers as they do not represent general purpose RAM.\n\n5.3.3 Miscellaneous Classes\nThe following linker classes are defined once you include <xc.inc> and represent memory for special purposes. Not all classes will be present for each device.\n\nCONFIG Consists of a single range that covers the memory reserved for configuration bit data.\nThis class would not typically be used by programmers as it does not represent general purpose RAM.\n\nIDLOC Consists of a single range that covers the memory reserved for ID location data in the hex file.\nThis class would not typically be used by programmers as it does not represent general purpose RAM.\n\nEEDATA Consists of a single range that covers the EEPROM memory of the target device, if present.\nThis class is used for psects that contain data that is to be programmed into the EEPROM.\n\n5.4 Linker-Defined Symbols\nThe linker defines special symbols that can be used to determine where some sections where linked in memory. These symbols can be used in your code, if required.\n\nThe link address of a section can be obtained from the value of a global symbol with name __Lname (two leading underscores) where name is the name of the section. For example, __LbssBANK0 is the low bound of the bssBANK0 section. The highest address of a section (i.e., the link address plus the size) is represented by the symbol __Hname. If the section has different load and link addresses, the load start address is represented by the symbol __Bname.\n\nSections that are not placed in memory using a -P linker option. See 6.1.17 P: Position Psect are not assigned this type of symbol, and note that section names can change from one device to another.\n\nAssembly code can use these symbol by globally declaring them (noting the two leading underscore characters in the names), for example:\n\nGLOBAL __Lidata\n\n5.5 Assembly List Files\nAn assembly list file is a human-readable listing, showing the opcodes that are present in the final output and the addresses at which they are located.\n\nThe assembler will produce an assembly list file if instructed using the -Wa,-a option. There is an assembly list file produced for each assembly source file.\n\n5.5.1 List File Format\nThe assembly list files arrange the content into columns, with the general form:\n\nline [address] [data]\n\nEach line of the list file has a line number. These numbers relate only to the list file itself and are not associated with the lines numbers in the assembly source file from which the list was generated.\n\nThe address, if present, is the address at which any output will appear in the device. This may be a program or data space address, which is determined by the psect in which the line is part of. Look for the first psect directive above the line in question.\nThe **data**, if present, represents what is associated with the specified address. If this is an instruction opcode, then the mnemonic for that instruction is shown. Lines that represent labels or content in data memory typically do not show the data field, as there is no assembler output corresponding to those lines. The data can also be a comment, which begins with a semicolon, ,, or an assembler directive.\n\nThe following PIC18 example shows a typical list file. Note the `movlw` instruction, whose opcode is 0E50 at address 746E in program memory and which appears on line 51135 of the list file; the DS directive which reserves data space memory at address 100.\n\n```\n51131 PSECT brText,class=CODE,space=0,reloc=2\n51132 ; Clear objects in BANK1\n51133 GLOBAL bank1Data\n51134 00746A EE01 F000 lfsr 0,bank1Data\n51135 00746E 0E50 movlw 80\n51136 007470 clear:\n51137 007470 6AEE clrf postinc0,c\n51138 007472 06E8 decf wreg\n51139 007474 E1FD bnz clear\n51140 007476 0012 return\n51141 007452 PSECT bank1,class=BANK1,space=1,noexec\n51142 bank1Data:\n51143 000100 input:\n51144 000100 DS 2\n```\n\nProvided that the link stage has successfully concluded, the listing file is updated by the linker so that it contains absolute addresses and symbol values. Thus, you can use the assembler list file to determine the position and exact opcodes of instructions. Tick marks \"\"\" in the assembly listing, next to addresses or opcodes, indicate that the linker did not update the list file, most likely due to a build error, or a assembler option that stopped compilation before the link stage. For example, in the following listing:\n\n```\n85 000A' 027F subwf 127,w\n86 000B' 1D03 skipz\n87 000C' 2800' goto u15\n```\n\nThese marks indicate that addresses are just address offsets into their enclosing psect, and that opcodes have not been fixed up. Any address field in the opcode that has not been fixed up is shown with a value of 0.\n\n### 5.5.2 Psect Information\n\nThe assembly list file can be used to determine the name of the psect in which a data object or section of code has been placed.\n\nFor global symbols, you can check the symbol table in the map file which lists the psect name with each symbol. For symbols local to a module, find the definition of the symbol in the list file. For labels, it is the symbol's name followed by a colon, :\n\n```\n5.5.3 Symbol Table\n```\n\nAt the bottom of each assembly list file is a symbol table. This differs from the symbol table presented in the map file (see 6.3.2.6 Symbol Table) in two ways:\n\n- Only symbols associated with the assembly module, from which the list file is produced (as opposed to the entire program) are listed.\n- Local as well as global symbols associated with that module are listed.\n\nEach symbol is listed along with the address it has been assigned.\n6. Linker\n\nThis chapter describes the operation and the usage of the linker.\n\nThe application name of the linker is hlink. In most instances it will not be necessary to invoke the linker directly, as the assembler driver, pic-as, will automatically execute the linker with all the necessary arguments. Using the linker directly is not simple, and should be attempted only by those with a sound knowledge of the requirements of the linking process. If psects are not linked correctly, code failure can result.\n\n6.1 Operation\n\nA command to the linker takes the following form:\n\n```\nlink [options] files\n```\n\nThe options are zero or more case-insensitive linker options, each of which modifies the behavior of the linker in some way. The files is one or more object files and zero or more library files (.a extension).\n\nThe options recognized by the linker are listed in the following paragraphs.\n\n**Table 6-1. Linker Command-line Options**\n\n<table>\n<thead>\n<tr>\n<th>Option</th>\n<th>Effect</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-8</td>\n<td>Use 8086 style segment: offset address form.</td>\n</tr>\n<tr>\n<td>-A<class=low-high,...</td>\n<td>Specify address ranges for a class.</td>\n</tr>\n<tr>\n<td>-Cpsect=class</td>\n<td>Specify a class name for a global psect.</td>\n</tr>\n<tr>\n<td>-Cbaseaddr</td>\n<td>Produce binary output file based at baseaddr.</td>\n</tr>\n<tr>\n<td>-Dclass=delta</td>\n<td>Specify a class delta value.</td>\n</tr>\n<tr>\n<td>-Dsymfile</td>\n<td>Produce old-style symbol file.</td>\n</tr>\n<tr>\n<td>-Eerrfile</td>\n<td>Write error messages to errfile.</td>\n</tr>\n<tr>\n<td>-F</td>\n<td>Produce .o file with only symbol records.</td>\n</tr>\n<tr>\n<td>-G spec</td>\n<td>Specify calculation for segment selectors.</td>\n</tr>\n<tr>\n<td>-H symfile</td>\n<td>Generate symbol file.</td>\n</tr>\n<tr>\n<td>-H+ symfile</td>\n<td>Generate enhanced symbol file.</td>\n</tr>\n<tr>\n<td>-I</td>\n<td>Ignore undefined symbols.</td>\n</tr>\n<tr>\n<td>-J num</td>\n<td>Set maximum number of errors before aborting.</td>\n</tr>\n<tr>\n<td>-K</td>\n<td>Prevent overlaying function parameter and auto areas.</td>\n</tr>\n<tr>\n<td>-L</td>\n<td>Preserve relocation items in .o file.</td>\n</tr>\n<tr>\n<td>-LM</td>\n<td>Preserve segment relocation items in .o file.</td>\n</tr>\n<tr>\n<td>-N</td>\n<td>Sort symbol table in map file by address order.</td>\n</tr>\n<tr>\n<td>-Nc</td>\n<td>Sort symbol table in map file by class address order.</td>\n</tr>\n<tr>\n<td>-Ns</td>\n<td>Sort symbol table in map file by space address order.</td>\n</tr>\n<tr>\n<td>-Mmapfile</td>\n<td>Generate a link map in the named file.</td>\n</tr>\n<tr>\n<td>-O outfile</td>\n<td>Specify name of output file.</td>\n</tr>\n<tr>\n<td>-Pspec</td>\n<td>Specify psect addresses and ordering.</td>\n</tr>\n<tr>\n<td>Option</td>\n<td>Effect</td>\n</tr>\n<tr>\n<td>--------------</td>\n<td>------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>-Qprocessor</td>\n<td>Specify the device type (for cosmetic reasons only).</td>\n</tr>\n<tr>\n<td>-S</td>\n<td>Inhibit listing of symbols in symbol file.</td>\n</tr>\n<tr>\n<td>-Sclass=limit[,bound]</td>\n<td>Specify address limit, and start boundary for a class of psects.</td>\n</tr>\n<tr>\n<td>-Usymbol</td>\n<td>Pre-enter symbol in table as undefined.</td>\n</tr>\n<tr>\n<td>-Vavmap</td>\n<td>Use file avmap to generate an Avocet format symbol file.</td>\n</tr>\n<tr>\n<td>-Wwarnlev</td>\n<td>Set warning level (-9 to 9).</td>\n</tr>\n<tr>\n<td>-Wwidth</td>\n<td>Set map file width (>=10).</td>\n</tr>\n<tr>\n<td>-X</td>\n<td>Remove any local symbols from the symbol file.</td>\n</tr>\n<tr>\n<td>-Z</td>\n<td>Remove trivial local symbols from the symbol file.</td>\n</tr>\n<tr>\n<td>--DISL=list</td>\n<td>Specify disabled messages.</td>\n</tr>\n<tr>\n<td>--EDF=path</td>\n<td>Specify message file location.</td>\n</tr>\n<tr>\n<td>--EMAX=number</td>\n<td>Specify maximum number of errors.</td>\n</tr>\n<tr>\n<td>--NORLF</td>\n<td>Do not relocate list file.</td>\n</tr>\n<tr>\n<td>--VER</td>\n<td>Print version number and stop.</td>\n</tr>\n</tbody>\n</table>\n\nIf the standard input is a file, then this file is assumed to contain the command-line argument. Lines can be broken by leaving a backslash \\ at the end of the preceding line. In this fashion, hlink commands of almost unlimited length can be issued. For example, a link command file called `x.lnk` and containing the following text:\n\n```\n-Z -Ox.o -Mx.map \\ \n-Ptext=0,data=0/,bss,nvram=bss/. \\ \nx.o y.o z.o\n```\n\ncan be passed to the linker by one of the following:\n\n```\nhlink @x.lnk\nhlink < x.lnk\n```\n\nSeveral linker options require memory addresses or sizes to be specified. The syntax for all of these is similar. By default, the number is interpreted as a decimal value. To force interpretation as a HEX number, a trailing \\H, or \\h, should be added. For example, `765FH` will be treated as a HEX number.\n\n### 6.1.1 A: Define Linker Class\n\nThe `-Aclass=low-high` option allows one or more of the address ranges to be assigned a linker class, so that psects can be placed anywhere in this class. Ranges do not need to be contiguous. For example:\n\n```\n-ACODE=1020h-7FFEh,8000h-BFFEh\n```\n\nspecifies that the class called CODE represents the two distinct address ranges shown.\n\nPsects can be placed anywhere in these ranges by using the `-P` option and the class name as the address (see 6.1.17 P: Position Psect), for example:\n\n```\n-PmyText=CODE\n```\n\nAlternatively, any psect that is made part of the CODE class, when it is defined (see 4.9.40.3 Class Flag), will automatically be linked into this range, unless they are explicitly located by another option.\nWhere there are a number of identical, contiguous address ranges, they can be specified with a repeat count following an \\textit{x} character. For example:\n\n\\begin{verbatim}\n-ACODE=0-0FFFFFhx16\n\\end{verbatim}\n\nspecifies that there are 16 contiguous ranges, each 64k bytes in size, starting from address zero. Even though the ranges are contiguous, no psect will straddle a 64k boundary, thus this can result in different psect placement to the case where the option\n\n\\begin{verbatim}\n-ACODE=0-0FFFFFh\n\\end{verbatim}\n\nhad been specified, which does not include boundaries on 64k multiples.\n\nThe \\texttt{-A} option does not specify the memory space associated with the address. Once a psect is allocated to a class, the space value of the psect is then assigned to the class (see 4.9.40.18 Space Flag).\n\n### 6.1.2 C: Associate Linker Class To Psect\n\nThe \\texttt{-Csect=class} option allows a psect to be associated with a specific class. Normally, this is not required on the command line because psect classes are specified in object files (see 4.9.40.3 Class Flag).\n\n### 6.1.3 D: Define Class Delta Value\n\nThe \\texttt{-Dclass=delta} option allows the \\texttt{delta} value for psects that are members of the specified class to be defined. The \\texttt{delta} value should be a number. It represents the number of bytes per addressable unit of objects within the psects. Most psects do not need this option as they are defined with a delta value (see 4.9.40.4 Delta Flag).\n\n### 6.1.4 D: Define Old Style Symbol File\n\nUse the \\texttt{-Dsymfile} option to produce an old-style symbol file. An old-style symbol file is an ASCII file, where each line has the link address of the symbol followed by the symbol name.\n\n### 6.1.5 E: Specify Error File\n\nThe \\texttt{-Eerrfile} option makes the linker write all error messages to the specified file instead of the screen, which is the default standard error destination.\n\n### 6.1.6 F: Produce Symbol-only Object File\n\nNormally the linker will produce an object file that contains both program code and data bytes, and symbol information. Sometimes you want to produce a symbol-only object file that can be used again in a subsequent linker run to supply symbol values. The \\texttt{-F} option suppresses data and code bytes from the output file, leaving only the symbol records.\n\nThis option can be used when part of one project (i.e., a separate build) is to be shared with another, as might be the case with a bootloader and application. The files for one project are compiled using this linker option to produce a symbol-only object file. That file is then linked with the files for the other project.\n\n### 6.1.7 G: Use Alternate Segment Selector\n\nWhen linking programs using segmented, or bank-switched psects, there are two ways the linker can assign segment addresses, or selectors, to each segment. A segment is defined as a contiguous group of psects where each psect in sequence has both its link and load addresses concatenated with the previous psect in the group. The segment address or selector for the segment is the value derived when a segment type relocation is processed by the linker.\n\nBy default the segment selector is generated by dividing the base load address of the segment by the relocation quantum of the segment, which is based on the \\texttt{reloc=} flag value given to psects at the assembler level (see 4.9.40.16 Reloc Flag). The \\texttt{-Gspec} option allows an alternate method for calculating the segment selector. The argument to \\texttt{-G} is a string similar to:\n\n\\begin{verbatim}\nA/10h-4h\n\\end{verbatim}\n\nwhere \\texttt{A} represents the load address of the segment and \\texttt{/} represents division. This means “Take the load address of the psect, divide by 10 HEX, then subtract 4.” This form can be modified by substituting \\texttt{N} for \\texttt{A}, \\texttt{*} for \\texttt{/} (to represent\nmultiplication) and adding, rather than subtracting, a constant. The token \\( N \\) is replaced by the ordinal number of the segment, which is allocated by the linker. For example:\n\n\\[\nN \\times 8 + 4\n\\]\n\nmeans \"take the segment number, multiply by 8, then add 4.\" The result is the segment selector. This particular example would allocate segment selectors in the sequence 4, 12, 20, ... for the number of segments defined.\n\nThe selector of each psect is shown in the map file (see Section 6.4.2.2 \"Psect Information Listed by Module\").\n\n### 6.1.8 H: Generate Symbol File\n\nThe `-H` option instructs the linker to generate a symbol file. The optional argument `symfile` specifies the name of the file to receive the data. The default file name is `l.sym`.\n\n### 6.1.9 H+: Generate Enhanced Symbol File\n\nThe `-H+` option will instruct the linker to generate an enhanced symbol file, which provides, in addition to the standard symbol file, class names associated with each symbol and a segments section which lists each class name and the range of memory it occupies. This format is recommended if the code is to be run in conjunction with a debugger. The optional argument `symfile` specifies a file to receive the symbol file. The default file name is `l.sym`.\n\n### 6.1.10 I: Ignore Undefined Symbols\n\nUsually, failure to resolve a reference to an undefined symbol is a fatal error. Using the `-I` option causes undefined symbols to be treated as warnings, instead.\n\n### 6.1.11 J: Specify Maximum Error Count\n\nThe linker will stop processing object files after a certain number of errors (other than warnings). The default number is 10, but the `-J errcount` option allows this to be altered.\n\n### 6.1.12 L: Allow Load Relocation\n\nWhen the linker produces an output file it does not usually preserve any relocation information, since the file is now absolute. In some circumstances a further \"relocation\" of the program is done at load time. The `-L` option generates, in the output file, one null relocation record for each relocation record in the input.\n\n### 6.1.13 LM: Allow Segment Load Relocation\n\nSimilar to the `-L` option, the `-LM` option preserves relocation records in the output file, but only segment relocations.\n\n### 6.1.14 M: Generate Map File\n\nThe `-M` option causes the linker to generate a link map in the named file, or on the standard output, if the file name is omitted. The format of the map file is illustrated in 6.3 Map Files.\n\n### 6.1.15 N: Specify Symbol Table Sorting\n\nBy default the symbol table in the map file is sorted by name. The `-N` option causes it to be sorted numerically, based on the value of the symbol. The `-Ns` and `-Nc` options work similarly except that the symbols are grouped by either their space value, or class.\n\n### 6.1.16 O: Specify Output Filename\n\nThis option allows specification of an output file name for the object file.\n\n### 6.1.17 P: Position Psect\n\nPsects are linked together and assigned addresses based on information supplied to the linker via `-Pspec` options. The argument to the `-P` option consists of comma-separated sequences with the form:\n\n- `Ppsect=linkaddr+min/loadaddr+min,psect=linkaddr/loadaddr,...`\n\nAll values can be omitted, in which case a default will apply, depending on previous values. The link address of a psect is the address at which it can be accessed at runtime. The load address is the address at which the psect starts\nwithin the output file (HEX or binary file etc.), but it is rarely used by 8-bit PIC devices. The addresses specified can be numerical addresses, the names of other psects, classes, or special tokens.\n\nExamples of the basic and most common forms of this option are:\n\n```\n-Ptext10=02000h\n```\n\nwhich places (links) the starting address of psect text10 at address 0x2000;\n\n```\nPmyData=AUXRAM\n```\n\nwhich places the psect myData anywhere in the range of addresses specified by the linker class AUXRAM (which would need to be defined using the -A option, see 6.1.1 A: Define Linker Class), and\n\n```\nPstartCode=0200h,endCode\n```\n\nwhich places endCode immediately after the end of startCode, which will start at address 0x200.\n\nThe additional variants of this option are rarely needed; but, are described below.\n\nIf a link or load address cannot be allowed to fall below a minimum value, the +min, suffix indicates the minimum address.\n\nIf the link address is a negative number, the psect is linked in reverse order with the top of the psect appearing at the specified address minus one. Psects following a negative address will be placed before the first psect in memory.\n\nIf the load address is omitted entirely, it defaults to the link address. If the slash / character is supplied with no address following, the load address will concatenate with the load address of the previous psect. For example, after processing the option:\n\n```\nPtext=0,data=0/,bss\n```\n\nthe text psect will have a link and load address of 0; data will have a link address of 0 and a load address following that of text. The bss psect will concatenate with data in terms of both link and load addresses.\n\nA load address specified as a dot character, \".\", tells the linker to set the load address to be the same as the link address.\n\nThe final link and load address of psects are shown in the map file (see 6.3.2.2 Psect Information Listed By Module).\n\n### 6.1.18 Q: Specify Device\n\nThe -Qprocessor option allows a device type to be specified. This is purely for information placed in the map file. The argument to this option is a string describing the device. There are no behavioral changes attributable to the device type.\n\n### 6.1.19 S: Omit Symbol Information Form Symbol File\n\nThe -S option prevents symbol information from being included in the symbol file produced by the linker. Segment information is still included.\n\n### 6.1.20 S: Place Upper Address Limit On Class\n\nA class of psects can have an upper address limit associated with it. The following example of the -S classlimit[,bound]= option places a limit on the maximum address of the CODE class of psects to one less than 400h.\n\n```\n-SCLASS=400h\n```\n\nNote that to set an upper limit to a psect, this must be set in assembler code using the psect limit flag. (see 4.9.40.8 Limit Flag).\nIf the `bound` (boundary) argument is used, the class of psects will start on a multiple of the bound address. This example below places the `FARCODE` class of psects at a multiple of 1000h, but with an upper address limit of 6000h.\n\n```\n-SFARCODE=6000h,1000h\n```\n\n### 6.1.21 U: Add Undefined Symbol\n\nThe `-Usymbol` option will enter the specified symbol into the linker’s symbol table as an undefined symbol. This is useful for linking entirely from libraries, or for linking a module from a library where the ordering has been arranged so that by default a later module will be linked.\n\n### 6.1.22 V: Produce Avocet Symbol File\n\nTo produce an Avocet format symbol file, the linker needs to be given a map file using the `-V` option to allow it to map psect names to Avocet memory identifiers. The `avmap` file will normally be supplied with the compiler, or created automatically by the compiler driver as required.\n\n### 6.1.23 W: Specify Warning Level/Map Width\n\nThe `-Wnum` option can be used to set the warning level, in the range -9 to 9, or the width of the map file, for values of `num >= 10`.\n\n`-W9` will suppress all warning messages. `-W0` is the default. Setting the warning level to -9 (`-W-9`) will give the most comprehensive warning messages.\n\n### 6.1.24 X: Omit Local Symbols From Symbol File\n\nLocal symbols can be suppressed from a symbol file with the `-X` option. Global symbols will always appear in the symbol file.\n\n### 6.1.25 Z: Omit Trivial Symbols From Symbol File\n\nSome local symbols are compiler generated and not of interest in debugging. The `-Z` option will suppress from the symbol file all local symbols that have the form of a single alphabetic character, followed by a digit string. The set of letters that can start a trivial symbol is currently \"klfLSu\". The `-Z` option will strip any local symbols starting with one of these letters, and followed by a digit string.\n\n### 6.1.26 Disl\n\nThe `--disl=messages` option is mainly used by the command-line driver, `pic-as`, to disable particular message numbers. It takes a comma-separate list of message numbers that will be disabled during compilation.\n\n### 6.1.27 Edf\n\nThe `--edf=file` option is mainly used by the command-line driver, `pic-as`, to specify the path of the message description file. The default file is located in the `dat` directory in the assembler’s installation directory.\n\n### 6.1.28 Emax\n\nThe `--emax=number` option is mainly used by the command-line driver, `pic-as`, to specify the maximum number of errors that can be encountered before the assembler terminates. The default number is 10 errors.\n\nThis option is applied if compiling using `pic-as`, the command-line driver, and the `-fmax-errors` driver option.\n\n### 6.1.29 Norlf\n\nUse of the `--norlf` option prevents the linker applying fixups to the assembly list file produced by the assembler. This option is normally used by the command line driver, `pic-as`, when performing pre-link stages, but is omitted when performing the final link step so that the list file shows the final absolute addresses.\n\nIf you are attempting to resolve fixup errors, this option should be disabled so as to fix up the assembly list file and allow absolute addresses to be calculated for this file. If the assembler driver detects the presence of a preprocessor macro `__DEBUG`, which is equated to 1, then this option will be disabled when building. This macro is set when choosing a Debug build in MPLAB X IDE. So, always have this option selected if you encounter such errors.\n6.1.30 Ver\n\nThe `--ver` option prints information stating the version and build of the linker. The linker will terminate after processing this option, even if other options and files are present on the command line.\n\n6.2 Psects and Relocation\n\nThe linker can read both relocatable object files (.o extension) and object-file libraries (.a extension). Library files are a collection of object files packaged into a single unit and once unpacked, are processed in the same way as individual object files.\n\nEach object file consists of a number of records. Each record has a type that indicates what sort of information it holds. Some record types hold general information about the target device and its configuration, other records types can hold data; and others, program debugging information.\n\nA lot of the information in object files relates to psects (program sections). Psects are an assembly domain construct and are essentially a block of something, either instructions or data. Everything that contributes to the program is located in a psect. See 4.8 Program Sections for an introductory guide. There is a particular record type that is used to hold the data in psects. The bulk of each object file consists of psect records containing the executable code and some objects.\n\nThe linker performs the following tasks.\n\n- Combining the content of all referenced relocatable object files into one.\n- Relocation of psects contained in the object files into the available device memory.\n- Fixup of symbolic references in content of the psects.\n\nRelocation consists of allocating the psects into the memory of the target device.\n\nThe target device memory specification is passed to the linker by the way of linker options. These options are generated by the command-line driver, `pic-as`. There are no linker scripts or means of specifying options in any source file. The default linker options rarely need adjusting. But they can be changed, if required, with caution, using the driver option `--wl`, (see 3.3.36 WL: Pass Option To The Linker Option).\n\nOnce the psects have been placed at their final memory locations, symbolic references made within the psect can be replaced with absolute values. This is a process called fixup.\n\nThe output of the linker is a single object file. This object file is absolute, since relocation is complete and all code and objects have been assigned an address.\n\n6.3 Map Files\n\nThe map file contains information relating to the memory allocation of psects and the addresses assigned to symbols within those psects.\n\n6.3.1 Map File Generation\n\nIf compilation is being performed via MPLAB X IDE, a map file is generated by default. If you are using the driver from the command line, use the `--wl,-Map` option to request that the map file be produced (see 3.3.36 WL: Pass Option To The Linker Option). Map files are typically assigned the extension .map.\n\nMap files are produced by the linker application. If the build is stopped before the linker is executed, then no map file is produced. A map file is produced, even if the linker generates errors and this partially-complete file can help you track down the cause of these errors. However, if the linker did not run to completion, due to too many errors or a fatal error, the map file will not be created. You can use the `--fmax-errors` driver option to increase the number of errors allowed before the linker exits.\n\n6.3.2 Contents\n\nThe sections in the map file, in order of appearance, are as follows.\n\n- The assembler name and version number.\n- A copy of the command line used to invoke the linker.\n• The version number of the object code in the first file linked.\n• The machine type.\n• A psect summary sorted by the psect’s parent object file.\n• A psect summary sorted by the psect’s CLASS.\n• A segment summary.\n• Unused address ranges summary.\n• The symbol table.\n• Information summary for each function.\n• Information summary for each module.\n\nPortions of an example map file, along with explanatory text, are shown in the following sections.\n\n6.3.2.1 General Information\n\nAt the top of the map file is general information relating to the execution of the linker. When analyzing a program, always confirm the assembler version number shown at the very top of the map file to ensure you are using the assembler you intended to use.\n\nThe device selected with the -mcpu option (see 3.3.5 Cpu Option), or the one selected in your IDE, should appear after the Machine type entry.\n\nThe object code version relates to the file format used by relocatable object files produced by the assembler. Unless either the assembler or linker have been updated independently, this should not be of concern.\n\nA typical map file might begin something like the following cut down example.\n\n```\nLinker command line:\n --edf=/Applications/Microchip/XC8/2.20/dat/en_msgs.txt -cs -h+main.sym -z \\n -Q16F946 -ol.o -Mmain.map -ver=XC8 -ACONST=00h-0FFhx32 \\n -ACODE=00h-07FFhx4 -ASTRCODE=00h-01FFFh -AENTRY=00h-0FFhx32 \\n -ABANK1=0Ah-0EFh -ABANK2=0120h-016Fh -ABANK3=01Ah-01EFh \\n -ARAM=020h-06Fh,0Ah-0EFh,0120h-016Fh,01Ah-01EFh -ASFR0=00h-01Fh \\n -ASFR1=080h-09Fh -ASFR2=0100h-011Fh -ASFR3=0180h-019Fh \\n -preset_vec=00h,initentry,init,init_entry,powerup,CODE,\\n -pconfig=CONFIG -Dconfig=CONFIG2 -AIDLOC=0200h-02003h \\n -pidloc=IDLOC -DIDLOC=2 -AEEDATA=00h-0FFh/02100h -peeprom_data=EEDATA \\n -DEEDATA=2 -DCODE=2 -DSTRCODE=2 -DSTRING=2 -DCONST=2 -DENTRY=2 -k \\n startup.o main.o\n\nObject code version is 3.10\nMachine type is 16F946\n```\n\nThe information following Linker command line: shows all the command-line options and files that were passed to the linker for the last build. Remember, these are linker options, not command-line driver options.\n\nThe linker options are necessarily complex. Fortunately, they rarely need adjusting from their default settings. They are formed by the command-line driver, pic-as, based on the selected target device and the specified driver options. You can often confirm that driver options were valid by looking at the linker options in the map file. For example, if you ask the driver to reserve an area of memory, you should see a change in the linker options used.\n\nIf the default linker options must be changed, this can be done indirectly through the driver using the driver -Wl option (see 3.3.36 WL: Pass Option To The Linker Option). If you use this option, always confirm the change appears correctly in the map file.\n\n6.3.2.2 Psect Information Listed By Module\n\nThe next section in the map file lists those modules that have made a contribution to the output and information regarding the psects that these modules have defined.\n\nThis section is heralded by the line that contains the headings:\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Link</th>\n<th>Load</th>\n<th>Length</th>\n<th>Selector</th>\n<th>Space</th>\n<th>Scale</th>\n</tr>\n</thead>\n</table>\n\n© 2020 Microchip Technology Inc.\nUnder this on the far left is a list of object files (.o extension). Both object files that were generated from source modules and those extracted from object library files (.a extension) are shown. In the latter case, the name of the library file is printed before the object file list.\n\nNext to the object file are the psects (under the Name column) that were linked into the program from that object file. Useful information about that psect is shown in the columns, as follows.\n\nThe linker deals with two kinds of addresses: link and load. Generally speaking, the Link address of a psect is the address by which it is accessed at runtime.\n\nThe Load address, which is often the same as the link address, is the address at which the psect starts within the output file (HEX or binary file etc.). If a psect is used to hold bits, the load address is irrelevant and is used to hold the link address (in bit units) converted into a byte address instead.\n\nThe LENGTH of the psect is shown in the units that are used by that psect.\n\nThe Selector is less commonly used and is of no concern when compiling for PIC devices.\n\nThe Space field is important as it indicates the memory space in which the psect was placed. For Harvard architecture machines, with separate memory spaces (such as the PIC devices), this field must be used in conjunction with the address to specify an exact storage location. A space of 0 indicates the program memory and a space of 1 indicates the data memory (see 4.9.40.18 Space Flag).\n\nThe Scale of a psect indicates the number of address units per byte. This remains blank if the scale is 1 and shows 8 for psects that hold bit objects. The load address of psects that hold bits is used to display the link address converted into units of bytes, rather than the load address (see 4.9.40.2 Bit Flag).\n\nFor example, the following appears in a map file.\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Link</th>\n<th>Load</th>\n<th>Length</th>\n<th>Selector</th>\n<th>Space</th>\n<th>Scale</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ext.o</td>\n<td>text</td>\n<td>3A</td>\n<td>3A</td>\n<td>22</td>\n<td>30</td>\n<td>0</td>\n</tr>\n<tr>\n<td></td>\n<td>bss</td>\n<td>4B</td>\n<td>4B</td>\n<td>10</td>\n<td>4B</td>\n<td>1</td>\n</tr>\n<tr>\n<td></td>\n<td>rbit</td>\n<td>50</td>\n<td>A</td>\n<td>2</td>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\nThis indicates that one of the files that the linker processed was called ext.o.\n\nThis object file contained a text psect, as well as psects called bss and rbit.\n\nThe psect text was linked at address 3A and bss at address 4B. At first glance, this seems to be a problem, given that text is 22 words long. However, they are in different memory areas, as indicated by the space flag (0 for text and 1 for bss), and so they do not even occupy the same memory space.\n\nThe psect rbit contains bit objects, and this can be confirmed by looking at the scale value, which is 8. Again, at first glance it seems that there could be an issue with rbit linked over the top of bss. Their space flags are the same, but since rbit contains bit objects, its link address is in units of bits. The load address field of rbit psect displays the link address converted to byte units, i.e., 50h/8 => Ah.\n\n### 6.3.2.3 Psect Information Listed By Class\n\nThe next section in the map file shows the same psect information but grouped by the psects’ class.\n\nThis section is heralded by the line that contains the headings:\n\n| TOTAL | Name | Link | Load | Length |\n\nUnder this are the class names followed by those psects which belong to this class (see 4.9.40.3 Class Flag). These psects are the same as those listed by module in the above section; there is no new information contained in this section, just a different presentation.\n\n### 6.3.2.4 Segment Listing\n\nThe class listing in the map file is followed by a listing of segments. Typically this section of the map file can be ignored by the user.\n\nA segment is a conceptual grouping of contiguous psects in the same memory space, and is used by the linker as an aid in psect placement. There is no segment assembler directive and segments cannot be controlled in any way.\nThis section is heralded by the line that contains the headings:\n\n| SEGMENTS | Name | Load | Length | Top | Selector | Space | Class |\n\nThe name of a segment is derived from the psect in the contiguous group with the lowest link address. This can lead to confusion with the psect with the same name. Do not read psect information from this section of the map file.\n\nAgain, this section of the map file can be ignored.\n\n6.3.2.5 Unused Address Ranges\nThe last of the memory summaries show the memory that has not been allocated and is still available for use.\n\nThis section follows the heading:\n\n| UNUSED ADDRESS RANGES |\n\nand is followed by a list of classes and the memory that is still available in each class. If there is more than one memory range available in a class, each range is printed on a separate line. Any paging boundaries located within a class are not displayed. But the column Largest block shows the largest contiguous free space (which takes into account any paging in the memory range). If you are looking to see why psects cannot be placed into memory (e.g., cant-find-space type errors) then this is important information to study.\n\nNote that memory can be part of more than one class, thus the total free space is not simply the addition of all the unused ranges.\n\n6.3.2.6 Symbol Table\nThe next section in the map file alphabetically lists the global symbols that the program defines. This section has the heading:\n\n| Symbol Table |\n\nThe symbols listed in this table are:\n\n- Global assembly labels\n- Global `EQU`/`SET` assembler directive labels\n- Linker-defined symbols\n\nAssembly symbols are made global via the `GLOBAL` assembler directive, see 4.9.26 Global Directive for more information.\n\nLinker-defined symbols act like `EQU` directives. However, they are defined by the linker during the link process, and no definition for them appears in any source or intermediate file (see 5.4 Linker-Defined Symbols).\n\nEach symbol is shown with the psect in which it is defined and the value (usually an address) it has been assigned. There is not any information encoded into a symbol to indicate whether it represents code or data – nor in which memory space it resides.\n\nIf the psect of a symbol is shown as (abs), this implies that the symbol is not directly associated with a psect. Such is the case for absolute C variables, or any symbols that are defined using an `EQU` directive in assembly.\n\nNote that a symbol table is also shown in each assembler list file. These differ to that shown in the map file as they also list local symbols and they only show symbols defined in the corresponding module.\n\n6.3.2.7 Function Information\nFollowing the symbol table is information relating to each function in the program. This information is identical to the function information displayed in the assembly list file. However, the information from all functions is collated in the one location.\n\n6.3.2.8 Module Information\nThe final section in the map file shows code usage summaries for each module. Each module in the program will show information similar to the following.\n\n<table>\n<thead>\n<tr>\n<th>Module</th>\n<th>Function</th>\n<th>Class</th>\n<th>Link</th>\n<th>Load</th>\n<th>Size</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>main.c</td>\n<td>init</td>\n<td>CODE</td>\n<td>07D8</td>\n<td>0000</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\nThe module name is listed (main.c in the above example). The special module name shared is used for data objects allocated to program memory and to code that is not specific to any particular module.\n\nNext, the user-defined and library functions defined by each module are listed along with the class in which that psect is located, the psect's link and load address, and its size (shown as bytes for PIC18 devices and words for other 8-bit devices).\n\nAfter the function list is an estimated size of the program memory used by that module.\n7. **Utilities**\n\nThis chapter discusses some of the utility applications that are bundled with the assembler.\n\nThe applications discussed in this chapter are those more commonly used, but you do not typically need to execute them directly. Some of their features are invoked indirectly by the command line driver that is based on the command-line arguments or MPLAB X IDE project property selections.\n\n7.1 **Archiver/Librarian**\n\nThe archiver/librarian program has the function of combining several intermediate files into a single file, known as a library archive file. Library archives are easier to manage and might consume less disk space than the individual files contained in them.\n\nThe archiver can build all library archive types needed by the assembler and can detect the format of existing archives.\n\n7.1.1 **Using the Archiver/Librarian**\n\nThe archiver program is called `xc8-ar` and is used to create and edit library archive files. It has the following basic command format:\n\n```\nxc8-ar [options] file.a [file1.p1 file2.o...]\n```\n\nwhere `file.a` represents the library archive being created or edited.\n\nThe `options` is zero or more options, tabulated below, that control the program.\n\n**Table 7-1. Archiver Command-line Options**\n\n<table>\n<thead>\n<tr>\n<th>Option</th>\n<th>Effect</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-d</td>\n<td>Delete module</td>\n</tr>\n<tr>\n<td>-m</td>\n<td>Re-order modules</td>\n</tr>\n<tr>\n<td>-p</td>\n<td>List modules</td>\n</tr>\n<tr>\n<td>-r</td>\n<td>Replace modules</td>\n</tr>\n<tr>\n<td>-t</td>\n<td>List modules with symbols</td>\n</tr>\n<tr>\n<td>-x</td>\n<td>Extract modules</td>\n</tr>\n<tr>\n<td>--target</td>\n<td>Specify target device</td>\n</tr>\n</tbody>\n</table>\n\nWhen replacing or extracting modules, the names of the modules to be replaced or extracted must be specified. If no names are supplied, all the modules in the archive will be replaced or extracted respectively.\n\nCreating an archive file or adding a file to an existing archive is performed by requesting the archiver to replace the module in the archive. Since the module is not present, it will be appended to the archive. Object and p-code modules can be added to the same archive. The archiver creates library archives with the modules in the order in which they were given on the command line. When updating an archive, the order of the modules is preserved. Any modules added to an archive will be appended to the end.\n\nThe ordering of the modules in an archive is significant to the linker. If an archive contains a module that references a symbol defined in another module in the same archive, the module defining the symbol should come after the module referencing the symbol.\n\nWhen using the `-d` option, the specified modules will be deleted from the archive. In this instance, it is an error not to supply any module names.\n\nThe `-p` option will list the modules within the archive file.\nThe `-m` option takes a list of module names and re-orders the matching modules in the archive file so that they have the same order as the one listed on the command line. Modules that are not listed are left in their existing order, and will appear after the re-ordered modules.\n\nThe `avr-ar` archiver will not work for object files built with only LTO data (i.e built with the `-fno-fat-lto-objects` option). For such object files, use the `avr-gcc-ar` archiver instead.\n\n### 7.1.1 Examples\n\nHere are some examples of usage of the librarian. The following command:\n\n```\nxc8-ar -r myPicLib.a ctime.pl init.pl\n```\n\ncreates a library called `myPicLib.a` that contains the modules `ctime.pl` and `init.pl`\n\nThe following command deletes the object module `a.pl` from the library `lcd.a`:\n\n```\nxc8-ar -d lcd.a a.pl\n```\n\n### 7.2 Hexmate\n\nThe Hexmate utility is a program designed to manipulate Intel HEX files. Hexmate is a post-link stage utility that is automatically invoked by the assembler driver and that provides the facility to:\n\n- Calculate and store variable-length hash values.\n- Fill unused memory locations with known data sequences.\n- Merge multiple Intel HEX files into one output file.\n- Convert INHX32 files to other INHX formats (e.g., INHX8M).\n- Detect specific or partial opcode sequences within a HEX file.\n- Find/replace specific or partial opcode sequences.\n- Provide a map of addresses used in a HEX file.\n- Change or fix the length of data records in a HEX file.\n- Validate checksums within Intel HEX files.\n\nTypical applications for Hexmate might include:\n\n- Merging a bootloader or debug module into a main application at build time.\n- Calculating a checksum or CRC value over a range of program memory and storing its value in program memory or EEPROM.\n- Filling unused memory locations with an instruction to send the program counter to a known location if it gets lost.\n- Storage of a serial number at a fixed address.\n- Storage of a string (e.g., time stamp) at a fixed address.\n- Store initial values at a particular memory address (e.g., initialize EEPROM).\n- Detecting usage of a buggy/restricted instruction.\n- Adjusting HEX file to meet requirements of particular bootloaders.\n\n#### 7.2.1 Hexmate Command Line Options\n\nHexmate is automatically called by the command line driver, `pic-as` to merge any HEX files specified on the command line with the output generated by the source files. Some other hexmate functions can be requested from the driver without running Hexmate explicitly, but full control you may run hexmate on the command line and use the options detailed here.\n\nIf Hexmate is to be run directly, its usage is:\n\n```\nhexmate [specs,]fiile1.hex [.. [specs,]fiileN.hex] [options]\n```\n\nwhere `fiile1.hex` through to `fileN.hex` form a list of input Intel HEX files to merge using Hexmate.\nIf only one HEX file is specified, no merging takes place, but other functionality is specified by additional options. Tabulated below are the command line options that Hexmate accepts.\n\nTable 7-2. Hexmate Command-line Options\n\n<table>\n<thead>\n<tr>\n<th>Option</th>\n<th>Effect</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>--edf</td>\n<td>Specify the message description file.</td>\n</tr>\n<tr>\n<td>--emax</td>\n<td>Set the maximum number of permitted errors before terminating.</td>\n</tr>\n<tr>\n<td>--msgdisable</td>\n<td>Disable messages with the numbers specified.</td>\n</tr>\n<tr>\n<td>--sla</td>\n<td>Set the start linear address for type 5 records.</td>\n</tr>\n<tr>\n<td>--ver</td>\n<td>Display version and build information then quit.</td>\n</tr>\n<tr>\n<td>-addressing</td>\n<td>Set address fields in all hexmate options to use word addressing or other.</td>\n</tr>\n<tr>\n<td>-break</td>\n<td>Break continuous data so that a new record begins at a set address.</td>\n</tr>\n<tr>\n<td>-ck</td>\n<td>Calculate and store a value.</td>\n</tr>\n<tr>\n<td>-fill</td>\n<td>Program unused locations with a known value.</td>\n</tr>\n<tr>\n<td>-find</td>\n<td>Search and notify if a particular code sequence is detected.</td>\n</tr>\n<tr>\n<td>-find...,delete</td>\n<td>Remove the code sequence if it is detected (use with caution).</td>\n</tr>\n<tr>\n<td>-find...,replace</td>\n<td>Replace the code sequence with a new code sequence.</td>\n</tr>\n<tr>\n<td>-format</td>\n<td>Specify maximum data record length or select INHX variant.</td>\n</tr>\n<tr>\n<td>-help</td>\n<td>Show all options or display help message for specific option.</td>\n</tr>\n<tr>\n<td>-logfile</td>\n<td>Save hexmate analysis of output and various results to a file.</td>\n</tr>\n<tr>\n<td>-mask</td>\n<td>Logically AND a memory range with a bitmask.</td>\n</tr>\n<tr>\n<td>-ofile</td>\n<td>Specify the name of the output file.</td>\n</tr>\n<tr>\n<td>-serial</td>\n<td>Store a serial number or code sequence at a fixed address.</td>\n</tr>\n<tr>\n<td>-size</td>\n<td>Report the number of bytes of data contained in the resultant HEX image.</td>\n</tr>\n<tr>\n<td>-string</td>\n<td>Store an ASCII string at a fixed address.</td>\n</tr>\n<tr>\n<td>-strpack</td>\n<td>Store an ASCII string at a fixed address using string packing.</td>\n</tr>\n<tr>\n<td>-w</td>\n<td>Adjust warning sensitivity.</td>\n</tr>\n<tr>\n<td>+</td>\n<td>Prefix to any option to overwrite other data in its address range, if necessary.</td>\n</tr>\n</tbody>\n</table>\n\nIf you are using the driver, `pic-as`, to compile your project (or the IDE), a log file is produced by default. It will have the project's name and the extension `.hxl`.\n\nThe input parameters to Hexmate are now discussed in detail. The format or assumed radix of values associated with options are described with each option. Note that any address fields specified in these options are to be entered as byte addresses, unless specified otherwise in the `-addressing` option.\n\n7.2.1.1 Specifications And Filename\n\nHexmate can process Intel HEX files that use either INHX32 or INHX8M format. Additional specifications can be applied to each HEX file to place restrictions or conditions on how this file should be processed.\n\nIf any specifications are used, they must precede the filename. The list of specifications will then be separated from the filename by a comma.\nA range restriction can be applied with the specification \\(r_{\\text{Start}-\\text{End}}\\), where \\(\\text{Start}\\) and \\(\\text{End}\\) are both assumed to be hexadecimal values. A range restriction will cause only the address data falling within this range to be used. For example:\n\n```\n\\(r100\\text{FF},\\text{myfile.hex}\\)\n```\n\nwill use \\(\\text{myfile.hex}\\) as input, but only process data which is addressed within the range 100h-1FFh (inclusive) from that file.\n\nAn address shift can be applied with the specification \\(s_{\\text{Offset}}\\). If an address shift is used, data read from this HEX file will be shifted (by the offset specified) to a new address when generating the output. The offset can be either positive or negative. For example:\n\n```\n\\(r100\\text{FF}s2000,\\text{myfile.HEX}\\)\n```\n\nwill shift the block of data from 100h-1FFh to the new address range 2100h-21FFh.\n\nBe careful when shifting sections of executable code. Program code should only be shifted if it is position independent.\n\n### 7.2.1.2 Override Prefix\n\nWhen the \\(+\\) operator precedes an argument or input file, the data obtained from that source will be forced into the output file and will overwrite another other data existing at that address range. For example:\n\n```\n\\(\\text{input.HEX} +\\text{-string}@1000=\\text{\"My string\"}\\)\n```\n\nwill have the data specified by the \\(-\\text{STRING}\\) option placed at address 1000; however:\n\n```\n\\(+\\text{input.HEX} -\\text{string}@1000=\\text{\"My string\"}\\)\n```\n\nwill copy the data contained in the hex file at address 1000 into the final output.\n\nOrdinarily, Hexmate will issue an error if two sources try to store differing data at the same location. Using the \\(+\\) operator informs Hexmate that if more than one data source tries to store data to the same address, the one specified with a \\(+\\) prefix will take priority.\n\n### 7.2.1.3 Edf\n\nThe \\(--\\text{edf}=\\text{file}\\) specifies the message description file to use when displaying warning or error messages. The argument should be the full path to the message file. Hexmate contains an internal copy of this file, so the use of this option is not necessary, but you may wish to specify a file with updated contents.\n\nThe message files are located in the \\(\\text{pic/dat}\\) directory in the installation (e.g., the English language file is called \\(\\text{en\\_msgs.txt}\\)).\n\n### 7.2.1.4 Emax\n\nThe \\(--\\text{emax}=\\text{num}\\) option sets the maximum number of errors Hexmate will display before execution is terminated, e.g., \\(--\\text{emax}=25\\). By default, up to 20 error messages will be displayed.\n\n### 7.2.1.5 Msgdisable\n\nThe \\(--\\text{msgdisable}=\\text{number}\\) option allows error, warning or advisory messages to be disabled during execution of Hexmate.\n\nThe option is passed a comma-separated list of message numbers that are to be disabled. Any error message numbers in this list are ignored unless they are followed by an \\(:\\text{off}\\) argument. If the message list is specified as 0, then all warnings are disabled.\n\n### 7.2.1.6 Sla\n\nThe \\(--\\text{sla}=\\text{address}\\) option allows you to specify the linear start address for type 5 records in the HEX output file, e.g., \\(--\\text{sla}=0x10000\\).\n\n### 7.2.1.7 Ver\n\nThe \\(--\\text{ver}\\) option will ask Hexmate to print version and build information and then quit.\n7.2.1.8 **Addressing** \nThis option allows the addressing units of any addresses in Hexmate’s command line options to be changed. \nBy default, all address arguments in Hexmate options expect that values will be entered as byte addresses, as specified in Intel HEX files. In some device architectures, the native addressing format can be something other than byte addressing. In these cases, this option can be used to allow device-orientated addresses to be used with Hexmate’s command-line options. \nThis option takes one parameter that configures the number of bytes contained per address location. For Baseline, Mid-range, and 24-bit PIC devices, an addressing unit of 2 can be used, if desired. For all other devices, you would typically use the default addressing unit of 1 byte.\n\n7.2.1.9 **Break** \nThe `-break` option takes a comma-separated list of addresses. If any of these addresses are encountered in the HEX file, the current data record will conclude and a new data record will recommence from the nominated address. This can be useful to use new data records to force a distinction between functionally different areas of program space. Some HEX file readers depend on this.\n\n7.2.1.10 **Ck** \nThe `-ck` option is for calculating a hash value. The usage of this option is:\n\n```\n-ck=start-end@dest [+offset][wWidth][tCode][gAlgorithm][pPolynomial][rwidth]\n```\n\nwhere:\n- `start` and `end` specify the address range over which the hash will be calculated. If these addresses are not a multiple of the algorithm width, the value zero will be padded into the relevant input word locations that are missing.\n- `dest` is the address where the hash result will be stored. This value cannot be within the range of calculation.\n- `offset` is an optional initial value to be used in the calculations.\n- `Width` is optional and specifies the width of the result. Results can be calculated for byte-widths of 1 to 4 bytes for most algorithms, but it represents the bit width for SHA algorithms. If a positive width is requested, the result will be stored in big-endian byte order. A negative width will cause the result to be stored in little-endian byte order. If the width is left unspecified, the result will be 2 bytes wide and stored in little-endian byte order. This width argument is not used if you have selected any Fletcher algorithm.\n- `Code` is a hexadecimal code that will trail each byte in the result. This can allow each byte of the hash result to be embedded within an instruction, for example `code=34` will embed the result in a `retlw` instruction on Mid-range devices.\n- `Algorithm` is an integer to select which Hexmate hash algorithm to use to calculate the result. A list of selectable algorithms is provided in Table 7-3. If unspecified, the default algorithm used is 8-bit checksum addition (algorithm 1).\n- `Polynomial` is a hexadecimal value which is the polynomial to be used if you have selected a CRC algorithm.\n- `r` is a decimal word width. If this is non-zero, then bytes within each word are read in reverse order when calculating a hash value. At present, the width must be 0 or 2. A zero width disables the reverse-byte feature, as if the `r` suboption was not present. This suboption should be used when using Hexmate to match a CRC produced by a PIC hardware CRC module that use the Scanner module to stream data to it.\n\nAll numerical arguments are assumed to be hexadecimal values, except for the algorithm selector and result width, which are assumed to be decimal values.\n\nA typical example of the use of the checksum option is:\n\n```\n-ck=0-1FFF@2FFE+2100w2g2\n```\n\nThis will calculate a checksum over the range 0 to 0x1FFF and program the checksum result at address 0x2FFE. The checksum value will be offset by 0x2100. The result will be two bytes wide.\nTable 7-3. Hexmate Hash Algorithm Selection\n\n<table>\n<thead>\n<tr>\n<th>Selector</th>\n<th>Algorithm Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-5</td>\n<td>Reflected cyclic redundancy check (CRC).</td>\n</tr>\n<tr>\n<td>-4</td>\n<td>Subtraction of 32 bit values from initial value.</td>\n</tr>\n<tr>\n<td>-3</td>\n<td>Subtraction of 24 bit values from initial value.</td>\n</tr>\n<tr>\n<td>-2</td>\n<td>Subtraction of 16 bit values from initial value.</td>\n</tr>\n<tr>\n<td>-1</td>\n<td>Subtraction of 8 bit values from initial value.</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Addition of 8 bit values from initial value.</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Addition of 16 bit values from initial value.</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Addition of 24 bit values from initial value.</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Addition of 32 bit values from initial value.</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Cyclic redundancy check (CRC).</td>\n</tr>\n<tr>\n<td>7</td>\n<td>Fletcher’s checksum (8 bit calculation, 2-byte result width).</td>\n</tr>\n<tr>\n<td>8</td>\n<td>Fletcher’s checksum (16 bit calculation, 4-byte result width).</td>\n</tr>\n<tr>\n<td>10</td>\n<td>SHA-2 (currently only SHA256 is supported)</td>\n</tr>\n</tbody>\n</table>\n\nSee 7.2.2 Hash Functions for more details about the algorithms that are used to calculate checksums.\n\n7.2.1.11 Fill\n\nThe `fill` option is used for filling unused memory locations with a known value. The usage of this option is:\n\n```\n-fill=[const_width:]fill_expr@address[:end_address]\n```\n\nwhere:\n\n- `const_width` has the form `w^n` and signifies the width (`n` bytes) of each constant in `fill_expr`. If `const_width` is not specified, the default value is two bytes. For example, `-fill=w1:1` with fill every unused byte with the value 0x01.\n- `fill_expr` can use the syntax (where `const` and `increment` are `n`-byte constants):\n - `const` fill memory with a repeating constant; i.e., `-fill=0xBEEF` becomes 0xBEEF, 0xBEEF, 0xBEEF, 0xBEEF.\n - `const+=increment` fill memory with an incrementing constant; i.e., `-fill=0xBEEF+1` becomes 0xBEEF, 0xBEF0, 0xBEF1, 0xBEF2.\n - `const-=increment` fill memory with a decrementing constant; i.e., `-fill=0xBEEF-0x10` becomes 0xBEEF, 0xBEF0, 0xBEF1, 0xBEF2.\n - `const,const,..,const` fill memory with a list of repeating constants; i.e., `-fill=0xDEAD,0xBEEF` becomes 0xDEAD,0xBEFF,0xBEFF,0xBEFF.\n- The options following `fill_expr` result in the following behavior:\n - `@address` fill a specific address with `fill_expr`; i.e., `-fill=0xBEEF@0x1000` puts 0xBEEF at address 1000h. If the fill value is wider than the addressing value specified with `–addressing`, then only part of the fill value is placed in the output. For example, if the addressing is set to 1, the option above will place 0xEF at address 0x1000 and a warning will be issued.\n - `@address:end_address` fill a range of memory with `fill_expr`; i.e., `-fill=0xBEEF@0:0xFF` puts 0xBEEF in unused addresses between 0 and 255. If the address range (multiplied by the `–ADDRESSING` value) is not a multiple of the fill value width, the final location will only use part of the fill value, and a warning will be issued.\n\nThe fill values are word-aligned so they start on an address that is a multiple of the fill width. Should the fill value be an instruction opcode, this alignment ensures that the instruction can be executed correctly. Similarly, if the total\nlength of the fill sequence is larger than 1 (and even if the specified width is 1), the fill sequence is aligned to that total length. For example the following fill option, which specifies 2 bytes of fill sequence and a starting address that is not a multiple of 2:\n\n```\n-fill=w1:0x11,0x22@0x11001:0x1100c\n```\n\nwill result in the following hex record, where the starting address was filled with the second byte of the fill sequence due to this alignment.\n\n```\n:0C100100221122112211221122112211B1\n```\n\nAll constants can be expressed in (unsigned) binary, octal, decimal or hexadecimal, as per normal C syntax, for example, 1234 is a decimal value, 0xFF00 is hexadecimal and FF00 is illegal.\n\n### 7.2.1.12 Find\n\nThe `-find=opcode` option is used to detect and log occurrences of an opcode or partial code sequence. The usage of this option is:\n\n```\n-find=Findcode [mMask]@[Start-End] [/Align][w][t\"Title\"]\n```\n\nwhere:\n\n- `Findcode` is the hexadecimal code sequence to search for. For example, to find a clrf instruction with the opcode 0x01F1, use 01F1 as the sequence. In the HEX file, this will appear as the byte sequence F1 01, that is F1 at hex address 0 and 01 at hex address 1.\n- `Mask` is optional. It specifies a bit mask applied over the `Findcode` value to allow a less restrictive search. It is entered in little endian byte order.\n- `Start` and `End` limit the address range to search.\n- `Align` is optional. It specifies that a code sequence can only match if it begins on an address that is a multiple of this value.\n- `w`, if present, will cause Hexmate to issue a warning whenever the code sequence is detected.\n- `Title` is optional. It allows a title to be given to this code sequence. Defining a title will make log-reports and messages more descriptive and more readable. A title will not affect the actual search results.\n\nAll numerical arguments are assumed to be hexadecimal values.\n\nHere are some examples.\n\nThe option `-find=1234@0-7FFF/2w` will detect the code sequence 1234h when aligned on a 2 (two) byte address boundary, between 0h and 7FFFh. w indicates that a warning will be issued each time this sequence is found.\n\nIn this next example, `-find=1234M0F00@0-7FFF/2wt\"ADDXY\"`, the option is the same as in last example but the code sequence being matched is masked with 000Fh, so Hexmate will search for any of the opcodes 123xh, where x is any digit. If a byte-mask is used, is must be of equal byte-width to the opcode it is applied to. Any messaging or reports generated by Hexmate will refer to this opcode by the name, ADDXY, as this was the title defined for this search.\n\nIf Hexmate is generating a log file, it will contain the results of all searches. `-find` accepts whole bytes of HEX data from 1 to 8 bytes in length. Optionally, `-find` can be used in conjunction with `replace` or `delete` (as described below).\n\n### 7.2.1.13 Find And Delete\n\nIf the `delete` form of the `-find` option is used, any matching sequences will be removed. This function should be used with extreme caution and is not normally recommended for removal of executable code.\n\n### 7.2.1.14 Find and Replace\n\nIf the `replace` form of the `-find` option is used, any matching sequences will be replaced, or partially replaced, with new codes. The usage for this sub-option is:\n\n```\n-find...,replace=Code [mMask]\n```\nwhere:\n\n- Code is a hexadecimal code sequence to replace the sequences that match the -find criteria.\n- Mask is an optional bit mask to specify which bits within Code will replace the code sequence that has been matched. This can be useful if, for example, it is only necessary to modify 4 bits within a 16-bit instruction. The remaining 12 bits can be masked and left unchanged.\n\n7.2.1.15 Format\n\nThe -format option can be used to specify a particular variant of INHX format or adjust maximum record length. The usage of this option is:\n\n```\n-format=Type [,Length]\n```\n\nwhere:\n\n- Type specifies a particular INHX format to generate.\n- Length is optional and sets the maximum number of bytes per data record. A valid length is between 1 and 16 decimal, with 16 being the default.\n\nConsider the case of a bootloader trying to download an INHX32 file, which fails because it cannot process the extended address records that are part of the INHX32 standard. This bootloader can only program data addressed within the range 0 to 64K and any data in the HEX file outside of this range can be safely disregarded. In this case, by generating the HEX file in INHX8M format the operation might succeed. The Hexmate option to do this would be -FORMAT=INHX8M.\n\nNow consider if the same bootloader also required every data record to contain exactly 8 bytes of data. This is possible by combining the -format with -fill options. Appropriate use of -fill can ensure that there are no gaps in the data for the address range being programmed. This will satisfy the minimum data length requirement. To set the maximum length of data records to 8 bytes, just modify the previous option to become -format=INHX8M,8.\n\nThe possible types that are supported by this option are listed in Table 7-4. Note that INHX032 is not an actual INHX format. Selection of this type generates an INHX32 file, but will also initialize the upper address information to zero. This is a requirement of some device programmers.\n\nTable 7-4. Inhx Types\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>INHX8M</td>\n<td>Cannot program addresses beyond 64K.</td>\n</tr>\n<tr>\n<td>INHX32</td>\n<td>Can program addresses beyond 64K with extended linear address records.</td>\n</tr>\n<tr>\n<td>INHX032</td>\n<td>INHX32 with initialization of upper address to zero.</td>\n</tr>\n</tbody>\n</table>\n\n7.2.1.16 Help\n\nUsing -help will list all Hexmate options. Entering another Hexmate option as a parameter of -help will show a detailed help message for the given option. For example:\n\n```\n-help=string\n```\n\nwill show additional help for the -string Hexmate option.\n\n7.2.1.17 Logfile\n\nThe -logfile option saves HEX file statistics to the named file. For example:\n\n```\n-logfile=output.hxl\n```\n\nwill analyze the HEX file that Hexmate is generating and save a report to a file named output.hxl.\n7.2.1.18 **Mask**\n\nUse the `-mask=spec` option to logically AND a memory range with a particular bitmask. This is used to ensure that the unimplemented bits in program words (if any) are left blank. The usage of this option is as follows:\n\n```bash\n-mask=hexcode@start-end\n```\n\nwhere `hexcode` is a value that will be ANDed with data within the `start` to `end` address range. All values are assumed to be hexadecimal. Multibyte mask values can be entered in little endian byte order.\n\n7.2.1.19 **O: Specify Output File**\n\nWhen using the `-o file` option, the generated Intel HEX output will be created in this file. For example:\n\n```bash\n-o program.hex\n```\n\nwill save the resultant output to `program.hex`. The output file can take the same name as one of its input files; but, by doing so, it will replace the input file entirely.\n\n7.2.1.20 **Serial**\n\nThe `-serial=specs` option will store a particular HEX value sequence at a fixed address. The usage of this option is:\n\n```bash\n-serial=Code[/+Increment]@Address[/+Interval]rRepetitions\n```\n\nwhere:\n\n- `Code` is a hexadecimal sequence to store. The first byte specified is stored at the lowest address.\n- `Increment` is optional and allows the value of Code to change by this value with each repetition (if requested).\n- `Address` is the location to store this code, or the first repetition thereof.\n- `Interval` is optional and specifies the address shift per repetition of this code.\n- `Repetitions` is optional and specifies the number of times to repeat this code.\n\nAll numerical arguments are assumed to be hexadecimal values, except for the `Repetitions` argument, which is decimal value by default.\n\nFor example:\n\n```bash\n-serial=000001@EFFE\n```\n\nwill store HEX code 00001h to address EFFEh.\n\nAnother example:\n\n```bash\n-serial=0000+2@1000+10r5\n```\n\nwill store 5 codes, beginning with value 0000 at address 1000h. Subsequent codes will appear at address intervals of +10h and the code value will change in increments of +2h.\n\n7.2.1.21 **Size**\n\nUsing the `-size` option will report the number of bytes of data within the resultant HEX image to standard output. The size will also be recorded in the log file if one has been requested.\n\n7.2.1.22 **String**\n\nThe `-string` option will embed an ASCII string at a fixed address. The usage of this option is:\n\n```bash\n-string@Address[Code]=\"Text\"\n```\n\nwhere:\n\n- `Address` is assumed to be a hexadecimal value representing the address at which the string will be stored.\n- `Code` is optional and allows a byte sequence to trail each byte in the string. This can allow the bytes of the string to be encoded within an instruction.\n• Text is the string to convert to ASCII and embed.\n\nFor example:\n\n```\n-string@1000=“My favorite string”\n```\n\nwill store the ASCII data for the string, My favorite string (including the null character terminator), at address 1000h.\n\nAnd again:\n\n```\n-string@1000t34=“My favorite string”\n```\n\nwill store the same string, trailing every byte in the string with the HEX code 34h.\n\n### 7.2.1.23 Strpack\n\nThe `-strpack=` option performs the same function as `-string`, but with two important differences. First, only the lower seven bits from each character are stored. Pairs of 7-bit characters are then concatenated and stored as a 14-bit word rather than in separate bytes. This is known as string packing. This is usually only useful for devices where program space is addressed as 14-bit words (PIC devices). The second difference is that `-string`'s `t` specifier is not applicable with the `-strpack` option.\n\n### 7.2.2 Hash Functions\n\nA hash value is a small fixed-size value that is calculated from, and used to represent, all the values in an arbitrary-sized block of data. If that data block is copied, a hash recalculated from the new block can be compared to the original hash. Agreement between the two hashes provides a high level of certainty that the copy is valid. There are many hash algorithms. More complex algorithms provide a more robust verification, but could use too many resources when used in an embedded environment.\n\nHexmate can be used to calculate the hash of a program image that is contained in a HEX file built by the MPLAB XC8 PIC Assembler. This hash can be embedded into that HEX file and burned into the target device along with the program image. At runtime, the target device might be able to run a similar hash algorithm over the program image, now stored in its memory. If the stored and calculated hashes are the same, the embedded program can assume that it has a valid program image to execute.\n\nHexmate implements several checksum and cyclic redundancy check algorithms to calculate the hash. If you are using the `pic-as` driver to perform project builds, the driver's `-mchecksum` option will instruct the driver to invoke Hexmate and pass it the appropriate Hexmate options. That same option is available in the MPLAB X IDE. If you are driving Hexmate explicitly, the option to select the algorithm is described in 7.2.1.10. In the discussion of the algorithms below, it is assumed you are using the assembler driver to request a checksum or CRC.\n\nSome consideration is required when program images contain unused memory locations. The driver's `-mchecksum` option automatically requests that Hexmate fill unused memory locations to match unprogrammed device memory. You might need to mimic this action if invoking Hexmate explicitly.\n\nAlthough Hexmate will work with any device, not all devices can read the entire width of their program memory. Mid-range PIC devices also use a 14-bit wide program memory, thus you cannot store a hash larger than a byte directly. For these devices, you would typically use the `code=` argument to the `-mcodeoffset` option, to have each byte of the hash value encapsulated in an instruction.\n\nThe following sections provide examples of the algorithms that can be used to calculate the hash at runtime, but note that these examples are not directly usable with all devices.\n\n### 7.2.3 Addition Algorithms\n\nHexmate has several simple checksum algorithms that sum data values over a range in the program image. These algorithms correspond to the selector values 1, 2, 3 and 4 in the algorithm suboption and read the data in the program image as 1, 2, 3 or 4 byte quantities, respectively. This summation is added to an initial value (offset) that is supplied to the algorithm via the same option. The width to which the final checksum is truncated is also specified by this option and can be 1, 2, 3 or 4 bytes. Hexmate will automatically store the checksum in the HEX file at the address specified in the checksum option.\nThe function shown below can be customized to work with any combination of data size (readType) and checksum width (resultType).\n\n```c\ntypedef unsigned char readType; // size of data values read and summed\ntypedef unsigned int resultType; // size of checksum result\n\n// add to offset n additions of values starting at address data,\n// truncating and returning the result\n// data: the address of the first value to sum\n// n: the number of sums to perform\n// offset: the initial value to which the sum is added\nresultType ck_add(const readType *data, unsigned n, resultType offset)\n{\n resultType chksum;\n chksum = offset;\n while(n--) {\n chksum += *data;\n data++;\n }\n return chksum;\n}\n```\n\nThe readType and resultType type definitions should be adjusted to suit the data read/sum width and checksum result width, respectively. When using MPLAB XC8 and for a size of 1, use a char type; for a size of 4, use a long type, etc., or consider using the exact-width types provided by <stdint.h>. If you never use an offset, that parameter can be removed and chksum assigned 0 before the loop.\n\nHere is how this function might be used when, for example, a 2-byte-wide checksum is to be calculated from the addition of 1-byte-wide values over the address range 0x100 to 0x7fd, starting with an offset of 0x20. The checksum is to be stored at 0x7fe and 0x7ff in little endian format. The following option is specified when building the project. In MPLAB X IDE, only enter the information to the right of the first = in the Checksum field in the Additional options Option category in the XC8 Linker category.\n\n```\n-mchecksum=100-7fd@7fe,offset=20,algorithm=1,width=-2\n```\n\nIn your project, add the following code snippet which calls ck_add() and compare the runtime checksum with that stored by Hexmate at compile time.\n\n```c\nextern const readType ck_range[0x6fe/sizeof(readType)] __at(0x100);\nextern const resultType hexmate __at(0x7fe);\nresultType result;\nresult = ck_add(ck_range, sizeof(ck_range)/sizeof(readType), 0x20);\nif(result != hexmate)\n ck_failure(); // take appropriate action\n```\n\nThis code uses the placeholder array, ck_range, to represent the memory over which the checksum is calculated and the variable hexmate is mapped over the locations where Hexmate will have stored its checksum result. Being extern and absolute, neither of these objects consume additional device memory. Adjust the addresses and sizes of these objects to match the option you pass to Hexmate.\n\nHexmate can calculate a checksum over any address range; however, the test function, ck_add(), assumes that the start and end address of the range being summed are a multiple of the readType width. This is a non-issue if the size of readType is 1. It is recommended that your checksum specification adheres to this assumption, otherwise you will need to modify the test code to perform partial reads of the starting and/or ending data values. This will significantly increase the code complexity.\n\n### 7.2.4 Subtraction Algorithms\n\nHexmate has several checksum algorithms that subtract data values over a range in the program image. These algorithms correspond to the selector values -1, -2, -3, and -4 in the algorithm suboption and read the data in the program image as 1-, 2-, 3- or 4-byte quantities, respectively. In other respects, these algorithms are identical to the addition algorithms described in 7.2.3 Addition Algorithms.\nThe function shown below can be customized to work with any combination of data size (readType) and checksum width (resultType).\n\n```c\ntypedef unsigned char readType; // size of data values read and summed\ntypedef unsigned int resultType; // size of checksum result\n// add to offset n subtractions of values starting at address data,\n// truncating and returning the result\n// data: the address of the first value to subtract\n// n: the number of subtractions to perform\n// offset: the intial value to which the subtraction is added\nresultType ck_sub(const readType *data, unsigned n, resultType offset)\n{\n resultType chksum;\n chksum = offset;\n while(n--) {\n chksum -= *data;\n data++;\n }\n return chksum;\n}\n```\n\nHere is how this function might be used when, for example, a 4-byte-wide checksum is to be calculated from the addition of 2-byte-wide values over the address range 0x0 to 0x7fd, starting with an offset of 0x0. The checksum is to be stored at 0x7fe and 0x7ff in little endian format. The following option is specified when building the project. In MPLAB X IDE, only enter the information to the right of the first = in the Checksum field in the Additional options Option category in the XC8 Linker category.\n\n```\n-mchecksum=0-7fd@7fe,offset=0,algorithm=-2,width=-4\n```\n\nIn your project, add the following code snippet which calls ck_sub() and compare the runtime checksum with that stored by Hexmate at compile time.\n\n```c\nextern const readType ck_range[0x7fe/sizeof(readType)] __at(0x0);\nextern const resultType hexmate __at(0x7fe);\nresultType result;\nresult = ck_sub(ck_range, sizeof(ck_range)/sizeof(readType), 0x0);\nif(result != hexmate)\n ck_failure(); // take appropriate action\n```\n\n### 7.2.5 Fletcher Algorithms\n\nHexmate has several algorithms that implement Fletcher’s checksum. These algorithms are more complex, providing a robustness approaching that of a cyclic redundancy check, but with less computational effort. There are two forms of this algorithm which correspond to the selector values 7 and 8 in the algorithm suboption and which implement a 1-byte calculation and 2-byte result, with a 2-byte calculation and 4-byte result, respectively. Hexmate will automatically store the checksum in the HEX file at the address specified in the checksum option.\n\nThe function shown below performs a 1-byte-wide addition and produces a 2-byte result.\n\n```c\nunsigned int\nfletcher8(const unsigned char * data, unsigned int n )\n{\n unsigned int sum = 0xff, sumB = 0xff;\n unsigned char tlen;\n while (n) {\n tlen = n > 20 ? 20 : n;\n n -= tlen;\n do {\n sumB += sum += *data++;\n } while (--tlen);\n sum = (sum & 0xff) + (sum >> 8);\n sumB = (sumB & 0xff) + (sumB >> 8);\n }\n sum = (sum & 0xff) + (sum >> 8);\n sumB = (sumB & 0xff) + (sumB >> 8);\n return sumB << 8 | sum;\n}\n```\n\nThis code can be called in a manner similar to that shown for the addition algorithms (see 7.2.3 Addition Algorithms).\nThe code for the 2-byte-addition Fletcher algorithm, producing a 4-byte result is shown below.\n\n```c\nunsigned long fletcher16(const unsigned int * data, unsigned n)\n{\n unsigned long sum = 0xffff, sumB = 0xffff;\n unsigned tlen;\n while (n) {\n tlen = n > 359 ? 359 : n;\n n -= tlen;\n do {\n sumB += sum += *data++;\n } while (--tlen);\n sum = (sum & 0xffff) + (sum >> 16);\n sumB = (sumB & 0xffff) + (sumB >> 16);\n }\n sum = (sum & 0xffff) + (sum >> 16);\n sumB = (sumB & 0xffff) + (sumB >> 16);\n return sumB << 16 | sum;\n}\n```\n\n### 7.2.6 CRC Algorithms\n\nHexmate has several algorithms that implement the robust cyclic redundancy checks (CRC). There is a choice of two algorithms that correspond to the selector values 5 and -5 in the algorithm suboption to `mchecksum` and that implement a CRC calculation and reflected CRC calculation, respectively. The reflected algorithm works on the least significant bit of the data first.\n\nThe polynomial to be used and the initial value can be specified in the option. Hexmate will automatically store the CRC result in the HEX file at the address specified in the checksum option.\n\nSome devices implement a CRC module in hardware that can be used to calculate a CRC at runtime. These modules can stream data read from program memory using a Scanner module. To ensure that the order of the bytes processed by Hexmate and the CRC/Scanner module are identical, you must specify a reserve word width of 2 using the suboption `revword=2`. This will read each 2-byte word in the HEX file in order, but process the bytes within those words in reverse order.\n\nThe function shown below can be customized to work with any result width (`resultType`). It calculates a CRC hash value using the polynomial specified by the `POLYNOMIAL` macro.\n\n```c\ntypedef unsigned int resultType;\n#define POLYNOMIAL 0x1021\n#define WIDTH (8 * sizeof(resultType))\n#define MSb ((resultType)1 << (WIDTH - 1))\n\nresultType crc(const unsigned char * data, unsigned n, resultType remainder) {\n unsigned pos;\n unsigned char bitp;\n for (pos = 0; pos != n; pos++) {\n remainder ^= ((resultType)data[pos] << (WIDTH - 8));\n for (bitp = 8; bitp > 0; bitp--) {\n if (remainder & MSb) {\n remainder = (remainder << 1) ^ POLYNOMIAL;\n } else {\n remainder <<= 1;\n }\n }\n }\n return remainder;\n}\n```\n\nThe `resultType` type definition should be adjusted to suit the result width. When using MPLAB XC8 and for a size of 1, use a `char` type; for a size of 4, use a `long` type, etc., or consider using the exact-width types provided by `<stdint.h>`.\n\nHere is how this function might be used when, for example, a 2-byte-wide CRC hash value is to be calculated values over the address range 0x0 to 0xFF, starting with an initial value of 0xFFFF. The result is to be stored at 0x100 and 0x101 in little endian format. The following option is specified when building the project. In MPLAB X IDE, only enter\nthe information to the right of the first = in the Checksum field in the Additional options Option category in the XC8 Linker category.\n\n```\n-mchecksum=0-FF@100,offset=0xFFFF,algorithm=5,width=-2,polynomial=0x1021\n```\n\nIn your project, add the following code snippet which calls `crc()` and compares the runtime hash result with that stored by Hexmate at compile time.\n\n```c\nextern const unsigned char ck_range[0x100] __at(0x0);\nextern const resultType hexmate __at(0x100);\nresultType result;\nresult = crc(ck_range, sizeof(ck_range), 0xFFFF);\nif(result != hexmate){\n // something's not right, take appropriate action\n ck_failure();\n}\n// data verifies okay, continue with the program\n```\n\nThe reflected CRC result can be calculated by reflecting the input data and final result, or by reflecting the polynomial. The functions shown below can be customized to work with any result width (`resultType`). The `crc_reflected_IO()` function calculates a reflected CRC hash value by reflecting the data stream bit positions. Alternatively, the `crc_reflected_poly()` function does not adjust the data stream but reflects instead the polynomial, which in both functions is specified by the `POLYNOMIAL` macro. Both functions use the `reflect()` function to perform bit reflection.\n\n```c\ntypedef unsigned int resultType;\ntypedef unsigned char readType;\ntypedef unsigned int reflectWidth;\n// This is the polynomial used by the CRC-16 algorithm we are using.\n#define POLYNOMIAL 0x1021\n#define WIDTH (8 * sizeof(resultType))\n#define MSb (resultType)1 << (WIDTH - 1)\n#define LSb (1)\n#define REFLECT_DATA(X) ((readType) reflect((X), 8))\n#define REFLECT_REMAINDER(X) (reflect((X), WIDTH))\nreflectWidth reflect(reflectWidth data, unsigned char nBits)\n{\n reflectWidth reflection = 0;\n reflectWidth reflectMask = (reflectWidth)1 << nBits - 1;\n unsigned char bitp;\n for (bitp = 0; bitp != nBits; bitp++) {\n if (data & 0x01) {\n reflection |= reflectMask;\n }\n data >>= 1;\n reflectMask >>= 1;\n }\n return reflection;\n}\nresultType crc_reflected_IO(const unsigned char * data, unsigned n, resultType remainder) {\n unsigned pos;\n unsigned char reflected;\n unsigned char bitp;\n for (pos = 0; pos != n; pos++) {\n reflected = REFLECT_DATA(data[pos]);\n remainder ^= ((resultType)reflected << (WIDTH - 8));\n for (bitp = 8; bitp > 0; bitp--) {\n if (remainder & MSb) {\n remainder = (remainder << 1) ^ POLYNOMIAL;\n } else {\n remainder <<= 1;\n }\n }\n remainder = REFLECT_REMAINDER(remainder);\n return remainder;\n }\n}\n```\nresultType\n\ncrc_reflected_poly(const unsigned char * data, unsigned n, resultType remainder) {\n unsigned pos;\n unsigned char bitp;\n resultType rpoly;\n rpoly = reflect(POLYNOMIAL, WIDTH);\n for (pos = 0; pos != n; pos++) {\n remainder ^= data[pos];\n for (bitp = 8; bitp > 0; bitp--) {\n if (remainder & LSb) {\n remainder = (remainder >> 1) ^ rpoly;\n } else {\n remainder >>= 1;\n }\n }\n }\n return remainder;\n}\n\nHere is how this function might be used when, for example, a 2-byte-wide reflected CRC result is to be calculated over the address range 0x0 to 0xFF, starting with an initial value of 0xFFFF. The result is to be stored at 0x100 and 0x101 in little endian format. The following option is specified when building the project (Note the algorithm selected is negative 5 in this case).\n\n-mchecksum=0-FF@100,offset=0xFFFF,algorithm=-5,width=-2,polynomial=0x1021\n\nIn your project, call either the crc_reflected_IO() or crc_reflected_poly() functions, as shown previously.\nThe Microchip Website\n\nMicrochip provides online support via our website at http://www.microchip.com/. This website is used to make files and information easily available to customers. Some of the content available includes:\n\n- **Product Support** – Data sheets and errata, application notes and sample programs, design resources, user’s guides and hardware support documents, latest software releases and archived software\n- **General Technical Support** – Frequently Asked Questions (FAQs), technical support requests, online discussion groups, Microchip design partner program member listing\n- **Business of Microchip** – Product selector and ordering guides, latest Microchip press releases, listing of seminars and events, listings of Microchip sales offices, distributors and factory representatives\n\nProduct Change Notification Service\n\nMicrochip’s product change notification service helps keep customers current on Microchip products. Subscribers will receive email notification whenever there are changes, updates, revisions or errata related to a specified product family or development tool of interest.\n\nTo register, go to http://www.microchip.com/pcn and follow the registration instructions.\n\nCustomer Support\n\nUsers of Microchip products can receive assistance through several channels:\n\n- Distributor or Representative\n- Local Sales Office\n- Embedded Solutions Engineer (ESE)\n- Technical Support\n\nCustomers should contact their distributor, representative or ESE for support. Local sales offices are also available to help customers. A listing of sales offices and locations is included in this document.\n\nTechnical support is available through the website at: http://www.microchip.com/support\n\nMicrochip Devices Code Protection Feature\n\nNote the following details of the code protection feature on Microchip devices:\n\n- Microchip products meet the specification contained in their particular Microchip Data Sheet.\n- Microchip believes that its family of products is one of the most secure families of its kind on the market today, when used in the intended manner and under normal conditions.\n- There are dishonest and possibly illegal methods used to breach the code protection feature. All of these methods, to our knowledge, require using the Microchip products in a manner outside the operating specifications contained in Microchip’s Data Sheets. Most likely, the person doing so is engaged in theft of intellectual property.\n- Microchip is willing to work with the customer who is concerned about the integrity of their code.\n- Neither Microchip nor any other semiconductor manufacturer can guarantee the security of their code. Code protection does not mean that we are guaranteeing the product as “unbreakable.”\n\nCode protection is constantly evolving. We at Microchip are committed to continuously improving the code protection features of our products. Attempts to break Microchip’s code protection feature may be a violation of the Digital Millennium Copyright Act. If such acts allow unauthorized access to your software or other copyrighted work, you may have a right to sue for relief under that Act.\n\nLegal Notice\n\nInformation contained in this publication regarding device applications and the like is provided only for your convenience and may be superseded by updates. It is your responsibility to ensure that your application meets with\nyour specifications. MICROCHIP MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND WHETHER EXPRESS OR IMPLIED, WRITTEN OR ORAL, STATUTORY OR OTHERWISE, RELATED TO THE INFORMATION, INCLUDING BUT NOT LIMITED TO ITS CONDITION, QUALITY, PERFORMANCE, MERCHANTABILITY OR FITNESS FOR PURPOSE. Microchip disclaims all liability arising from this information and its use. Use of Microchip devices in life support and/or safety applications is entirely at the buyer’s risk, and the buyer agrees to defend, indemnify and hold harmless Microchip from any and all damages, claims, suits, or expenses resulting from such use. No licenses are conveyed, implicitly or otherwise, under any Microchip intellectual property rights unless otherwise stated.\n\nTrademarks\n\nThe Microchip name and logo, the Microchip logo, Adaptec, AnyRate, AVR, AVR logo, AVR Freaks, BestTime, BitCloud, chipKIT, chipKIT logo, CryptoMemory, CryptoRF, dsPIC, FlashFlex, flexPWR, HELDO, IGLOO, JukeBloX, KeeLoq, Kleer, LANCheck, LinkMD, maXStylus, maXTouch, MediaLB, megaAVR, Microsemi, Microsemi logo, MOST, MOST logo, MPLAB, OptoLyzer, PackeTime, PIC, picoPower, PICSTART, PIC32 logo, PolarFire, Prochip Designer, QTouch, SAM-BA, SenGenuity, SpyNIC, SST, SST Logo, SuperFlash, Symmetricom, SyncServer, Tachyon, TempTrackr, TimeSource, tinyAVR, UNI/O, Vectron, and XMEGA are registered trademarks of Microchip Technology Incorporated in the U.S.A. and other countries.\n\nAPT, ClockWorks, The Embedded Control Solutions Company, EtherSynch, FlashTec, Hyper Speed Control, HyperLight Load, InteliMOS, Libero, motorBench, mTouch, Powermite 3, Precision Edge, ProASIC, ProASIC Plus, ProASIC Plus logo, Quiet-Wire, SmartFusion, SyncWorld, Temux, TimeCesium, TimeHub, TimePictra, TimeProvider, Vite, WinPath, and ZL are registered trademarks of Microchip Technology Incorporated in the U.S.A.\n\n\nSQTP is a service mark of Microchip Technology Incorporated in the U.S.A.\n\nThe Adaptec logo, Frequency on Demand, Silicon Storage Technology, and Symmcom are registered trademarks of Microchip Technology Inc. in other countries.\n\nGestIC is a registered trademark of Microchip Technology Germany II GmbH & Co. KG, a subsidiary of Microchip Technology Inc., in other countries.\n\nAll other trademarks mentioned herein are property of their respective companies.\n\n© 2020, Microchip Technology Incorporated, Printed in the U.S.A., All Rights Reserved.\n\nISBN: 978-1-5224-5904-0\n\nQuality Management System\n\nFor information regarding Microchip’s Quality Management Systems, please visit http://www.microchip.com/quality.\n# Worldwide Sales and Service\n\n<table>\n<thead>\n<tr>\n<th>AMERICAS</th>\n<th>ASIA/PACIFIC</th>\n<th>ASIA/PACIFIC</th>\n<th>EUROPE</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Corporate Office</strong></td>\n<td><strong>Australia - Sydney</strong></td>\n<td><strong>India - Bangalore</strong></td>\n<td><strong>Austria - Wels</strong></td>\n</tr>\n<tr>\n<td>2355 West Chandler Blvd.</td>\n<td>Tel: 61-2-9868-6733</td>\n<td>Tel: 91-80-3090-4444</td>\n<td>Tel: 43-7242-2244-39</td>\n</tr>\n<tr>\n<td>Chandler, AZ 85224-6199</td>\n<td>China - Beijing</td>\n<td>India - New Delhi</td>\n<td>Fax: 43-7242-2244-393</td>\n</tr>\n<tr>\n<td>Tel: 480-792-7200</td>\n<td>Tel: 86-10-8569-7000</td>\n<td>India - Pune</td>\n<td><strong>Denmark - Copenhagen</strong></td>\n</tr>\n<tr>\n<td>Fax: 480-792-7277</td>\n<td>China - Chengdu</td>\n<td>Tel: 91-11-4160-8631</td>\n<td>Tel: 45-4485-5910</td>\n</tr>\n<tr>\n<td><strong>Technical Support:</strong></td>\n<td>Tel: 86-28-8665-5511</td>\n<td>India - New Delhi</td>\n<td>Fax: 45-4485-2829</td>\n</tr>\n<tr>\n<td><a href=\"http://www.microchip.com/support\">http://www.microchip.com/support</a></td>\n<td>China - Chongqing</td>\n<td>Tel: 91-10-4212-0141</td>\n<td><strong>Finland - Espoo</strong></td>\n</tr>\n<tr>\n<td><strong>Web Address:</strong></td>\n<td>Tel: 86-23-8980-9588</td>\n<td>Japan - Osaka</td>\n<td>Tel: 358-9-4520-820</td>\n</tr>\n<tr>\n<td><a href=\"http://www.microchip.com\">http://www.microchip.com</a></td>\n<td>China - Dongguan</td>\n<td>Japan - Tokyo</td>\n<td><strong>France - Paris</strong></td>\n</tr>\n<tr>\n<td><strong>Atlanta</strong></td>\n<td>Tel: 86-799-8702-9880</td>\n<td>Tel: 81-3-6880-3770</td>\n<td>Tel: 33-1-69-53-63-20</td>\n</tr>\n<tr>\n<td>Duluth, GA</td>\n<td>China - Guangzhou</td>\n<td>Korea - Daegu</td>\n<td>Fax: 33-1-69-30-90-79</td>\n</tr>\n<tr>\n<td>Tel: 678-957-9614</td>\n<td>Tel: 86-20-8755-8029</td>\n<td>Korea - Seoul</td>\n<td><strong>Germany - Garching</strong></td>\n</tr>\n<tr>\n<td>Fax: 678-957-1455</td>\n<td>China - Hangzhou</td>\n<td>Tel: 82-53-744-4301</td>\n<td>Tel: 49-8931-9700</td>\n</tr>\n<tr>\n<td><strong>Austin, TX</strong></td>\n<td>Tel: 86-571-8792-8115</td>\n<td></td>\n<td><strong>Germany - Haan</strong></td>\n</tr>\n<tr>\n<td>Tel: 512-257-3370</td>\n<td>China - Hong Kong SAR</td>\n<td></td>\n<td>Tel: 49-2129-3766400</td>\n</tr>\n<tr>\n<td>Westborough, MA</td>\n<td>Tel: 852-2943-5100</td>\n<td></td>\n<td><strong>Germany - Heilbronn</strong></td>\n</tr>\n<tr>\n<td>Tel: 774-760-0087</td>\n<td>China - Nanjing</td>\n<td></td>\n<td>Tel: 49-7731-72400</td>\n</tr>\n<tr>\n<td>Fax: 774-760-0088</td>\n<td>Tel: 86-25-8473-2460</td>\n<td></td>\n<td><strong>Germany - Karlsruhe</strong></td>\n</tr>\n<tr>\n<td><strong>Chicago</strong></td>\n<td>China - Qingdao</td>\n<td></td>\n<td>Tel: 49-721-625370</td>\n</tr>\n<tr>\n<td>Itasca, IL</td>\n<td>Tel: 86-532-8502-7355</td>\n<td></td>\n<td><strong>Germany - Munich</strong></td>\n</tr>\n<tr>\n<td>Tel: 630-285-0071</td>\n<td>China - Shanghai</td>\n<td></td>\n<td>Tel: 49-89-627-144-0</td>\n</tr>\n<tr>\n<td>Fax: 630-285-0075</td>\n<td>Tel: 86-21-3326-8000</td>\n<td></td>\n<td>Fax: 49-89-627-144-4</td>\n</tr>\n<tr>\n<td><strong>Dallas</strong></td>\n<td>China - Shenyang</td>\n<td></td>\n<td><strong>Germany - Rosenheim</strong></td>\n</tr>\n<tr>\n<td>Addison, TX</td>\n<td>Tel: 86-24-2334-2829</td>\n<td></td>\n<td>Tel: 49-8031-354-560</td>\n</tr>\n<tr>\n<td>Tel: 972-818-7423</td>\n<td>China - Shenzhen</td>\n<td></td>\n<td><strong>Israel - Ra’anana</strong></td>\n</tr>\n<tr>\n<td>Fax: 972-818-2924</td>\n<td>Tel: 86-755-8864-2200</td>\n<td></td>\n<td>Tel: 972-9-744-7705</td>\n</tr>\n<tr>\n<td><strong>Detroit</strong></td>\n<td>China - Suzhou</td>\n<td></td>\n<td><strong>Italy - Milan</strong></td>\n</tr>\n<tr>\n<td>Novi, MI</td>\n<td>Tel: 86-186-6233-1526</td>\n<td></td>\n<td>Tel: 39-0331-742611</td>\n</tr>\n<tr>\n<td>Tel: 248-848-4000</td>\n<td>China - Wuhan</td>\n<td></td>\n<td>Fax: 39-0331-466781</td>\n</tr>\n<tr>\n<td><strong>Houston, TX</strong></td>\n<td>Tel: 86-27-5980-5300</td>\n<td></td>\n<td><strong>Italy - Padova</strong></td>\n</tr>\n<tr>\n<td>Tel: 281-894-5983</td>\n<td>China - Xian</td>\n<td></td>\n<td>Tel: 39-049-7625286</td>\n</tr>\n<tr>\n<td><strong>Indianapolis</strong></td>\n<td>Tel: 86-29-8833-7252</td>\n<td></td>\n<td><strong>Netherlands - Drunen</strong></td>\n</tr>\n<tr>\n<td>Noblesville, IN</td>\n<td>China - Xiamen</td>\n<td></td>\n<td>Tel: 31-416-690399</td>\n</tr>\n<tr>\n<td>Tel: 317-773-8323</td>\n<td>Tel: 86-992-2388138</td>\n<td></td>\n<td>Fax: 31-416-690340</td>\n</tr>\n<tr>\n<td>Fax: 317-773-5453</td>\n<td>China - Zhuhai</td>\n<td></td>\n<td><strong>Norway - Trondheim</strong></td>\n</tr>\n<tr>\n<td>Tel: 317-536-2380</td>\n<td>Tel: 86-756-3210040</td>\n<td></td>\n<td>Tel: 47-72864388</td>\n</tr>\n<tr>\n<td><strong>Los Angeles</strong></td>\n<td><strong>India</strong></td>\n<td></td>\n<td><strong>Poland - Warsaw</strong></td>\n</tr>\n<tr>\n<td>Mission Viejo, CA</td>\n<td><strong>India</strong></td>\n<td></td>\n<td>Tel: 48-22-3325737</td>\n</tr>\n<tr>\n<td>Tel: 949-462-9523</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td>Romania - Bucharest</td>\n</tr>\n<tr>\n<td>Fax: 949-462-9608</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td>Tel: 40-21-407-87-50</td>\n</tr>\n<tr>\n<td>Tel: 951-273-7800</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td><strong>Spain - Madrid</strong></td>\n</tr>\n<tr>\n<td><strong>Raleigh, NC</strong></td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td>Tel: 34-91-708-08-90</td>\n</tr>\n<tr>\n<td>Tel: 919-844-7510</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td>Fax: 34-91-708-08-91</td>\n</tr>\n<tr>\n<td><strong>New York, NY</strong></td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td><strong>Sweden - Gothenberg</strong></td>\n</tr>\n<tr>\n<td>Tel: 631-435-6000</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td>Tel: 46-31-704-60-40</td>\n</tr>\n<tr>\n<td><strong>San Jose, CA</strong></td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td><strong>Sweden - Stockholm</strong></td>\n</tr>\n<tr>\n<td>Tel: 408-735-9110</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td>Tel: 46-8-5090-4654</td>\n</tr>\n<tr>\n<td>Tel: 408-436-4270</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td><strong>UK - Wokingham</strong></td>\n</tr>\n<tr>\n<td><strong>Canada - Toronto</strong></td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td>Tel: 44-118-921-5800</td>\n</tr>\n<tr>\n<td>Tel: 905-695-1980</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td>Fax: 44-118-921-5820</td>\n</tr>\n<tr>\n<td>Fax: 905-695-2078</td>\n<td><strong>Indonesia</strong></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>"}}},{"rowIdx":186,"cells":{"id":{"kind":"string","value":"36c524c66732d9fd450c6cee54859395a60c77e3"},"text":{"kind":"string","value":"Putting Logic-Based Distributed Systems on Stable Grounds\n\nTom J. Ameloot*, Jan Van den Bussche\nHasselt University & transnational University of Limburg\n\nWilliam R. Marczak\nUniversity of California, Berkeley\n\nPeter Alvaro\nUniversity of California, Santa Cruz\n\nJoseph M. Hellerstein\nUniversity of California, Berkeley\n\nsubmitted 5 September 2012; revised 12 November 2013, 24 April 2015; accepted 16 July 2015\n\nAbstract\n\nIn the Declarative Networking paradigm, Datalog-like languages are used to express distributed computations. Whereas recently formal operational semantics for these languages have been developed, a corresponding declarative semantics has been lacking so far. The challenge is to capture precisely the amount of nondeterminism that is inherent to distributed computations due to concurrency, networking delays, and asynchronous communication. This paper shows how a declarative, model-based semantics can be obtained by simply using the well-known stable model semantics for Datalog with negation. We show that the model-based semantics matches previously proposed formal operational semantics.\n\nKEYWORDS: Dedalus, Datalog, stable model semantics, distributed system, asynchronous communication\n\n1 Introduction\n\nCloud environments have emerged as a modern way to store and manipulate data (Zhang et al. 2010) (Cavage 2013). For our purposes, a cloud is a distributed system that should produce output as the result of some computation. We use the common term “node” as a synonym for an individual computer or server in a network.\n\nIn recent years, logic programming has been proposed as an attractive foundation for distributed and cloud programming, building on work in declarative networking (Loo et al. 2009). The essential idea in declarative networking, is that the programmer uses a high-level declarative language (like Datalog) to specify only what has\n\n* T.J. Ameloot is a Postdoctoral Fellow of the Research Foundation – Flanders (FWO).\nto happen, and not exactly how. For example, the programmer could specify only that certain messages are generated in reply to other messages; the exact technical details to send (and possibly resend) messages over transmission protocols are filled in by some runtime engine. This frees the programmer from thinking in low-level terms that distract from the actual meaning of the specific program at hand. In particular, complex distributed algorithms and protocols can be expressed in relatively few lines of code (Jim 2001; Alvaro et al. 2009; Hellerstein 2010b). Besides the interest in declarative networking, we are also seeing a more general resurgence of Datalog (with negation) (de Moor et al. 2011; Huang et al. 2011). Moreover, issues related to data-oriented distributed computing are receiving attention at database theory conferences (Hellerstein 2010a; Ameloot et al. 2011; Abiteboul et al. 2011; Ameloot and Van den Bussche 2012; Zinn et al. 2012).\n\nOne of the latest languages proposed in declarative networking is Dedalus (Alvaro et al. 2009; Alvaro et al. 2011; Hellerstein 2010b), a Datalog-inspired language that has influenced other recent language designs for distributed and cloud computing such as Webdamlog (Abiteboul et al. 2011) and Bloom (Alvaro et al. 2011).\n\nModel-based semantics In this paper, we describe the meaning of distributed Datalog programs using a model-based semantics. This approach contrasts with most previous work in declarative networking, where the meaning of programs was typically described with an operational semantics (Deutsch et al. 2006; Navarro and Rybalchenko 2009; Grumbach and Wang 2010; Ameloot et al. 2011), with a few exceptions (Lobo et al. 2012; Ma et al. 2013).\n\nThere are several important motivations for a model-based semantics of a distributed program. First, we can better separate the program structure, i.e., the rules, from the (distributed) implementation that may change over time. For example, consider rules that generate messages. These rules can be implemented with asynchronous communication, but how we evaluate them across machines is eventually just a physical performance decision. Said differently, the point of message rules is not to model a physical phenomenon, but rather to admit a wider array of physical implementations than a local evaluation strategy. Model-based interpretations of a program admit all such implementations, and can perhaps suggest some new ones. Second, we can investigate the need for time: we can think about when temporal delay is needed for expressivity, rather than when it is imposed upon us by some implementation detail like physical separation of nodes. In this context we mention the CRON conjecture by Hellerstein, that relates causality on messages to the nature of the computations in which those messages participate (Hellerstein 2010b; Ameloot and den Bussche 2014). We elaborate on causality below.\n\nConcretely, our approach will be to model a distributed program with Datalog under the stable model semantics (Gelfond and Lifschitz 1988), because this semantics is widely used in logic programming. Following the language Dedalus (Alvaro et al. 2009; Alvaro et al. 2011; Hellerstein 2010b), we express the functionality of the distributed program with three kinds of rules: “deductive rules” for local computation, “inductive rules” for persisting memory across local computation steps, and, “asynchronous rules” for representing message sending. The asynchronous rules\nwill nondeterministically choose the arrival times of messages (Krishnamurthy and Naqvi 1988; Saccà and Zaniolo 1990).\n\nHowever, using only the above rules is not sufficient, as this still allows stable models that express undesirable computations, where messages can be sent “into the past”. Therefore, each program is augmented with a set of rules that express causality on the messages. Causality stands for the physical constraint that an effect can only happen after its cause. Applied to message delivery, this intuitively means that a sent message can only be delivered in the future, not in the past. The rules for causality reason from the perspective of the local times of each node, which is a justified approach since there is no common “global clock” in a distributed environment (Attiya and Welch 2004). As a second improvement, we also introduce rules to ensure that only a finite number of messages arrive at each local step of a node, as occurs in a real distributed system. Applying the stable model semantics to the augmented Datalog programs constitutes our modeling of a distributed (Datalog) program.\n\nOn another note, it is already well-known that for finite input domains, the combination of Datalog and stable model semantics allows for expressing all problems in NP (Marek and Truszczynski 1999). However, it is not yet clear what can be represented when infinite input domains are considered. From this perspective, our work demonstrates that the stable model semantics is indeed also suitable for modeling distributed programs, whose execution is unbounded in time. Here, time would be provided as an infinite input.\n\nCorrectness As we have motivated above, our goal is to describe the workings of a distributed system declaratively, so that new insights can emerge from this perspective. Hence, it is important to verify that the model-based semantics really corresponds to the execution of a distributed program.\n\nTo this end, we additionally formalize the execution of a distributed Datalog program by means of an operational semantics (Deutsch et al. 2006; Navarro and Rybalchenko 2009; Grumbach and Wang 2010; Ameloot et al. 2011). This second semantics is defined as a transition system. The transition system is infinite because nodes run indefinitely and keep sending messages. In addition, the transition system is highly nondeterministic, because nodes work concurrently and messages can be delayed.\n\nWe establish rigorously a correspondence between the features of the operational semantics and the features of the proposed model-based semantics. To formulate our result, we describe each operational execution by a structure that we call a trace, which includes for each node in the network the detailed information about the local steps it has performed and about the messages it has sent and received. For our distributed Datalog programs, we show that such operational traces correspond to the set of stable models.\n\nOutline This paper is organized as follows. First, Section 2 discusses related work. Section 3 gives preliminaries. Next, Section 4 represents distributed Datalog programs under the model-based semantics; this section is based on Dedalus, a Datalog-\nlike language. Section 5 justifies the intuitions of the model-based semantics by establishing an equivalence with an operational semantics. Section 6 finishes with the conclusion.\n\n2 Related Work\n\nThe work of Lobo et al. (2012) is closely related to our work. For a Dedalus-inspired language, they give a model-theoretic semantics based on answer set programming, i.e., stable models. To define this semantics, they syntactically translate the rules of their language to Datalog, where all literals are given an explicit location and time variable, to represent the data that each node has during each local time. This translation resembles the model-theoretic semantics for distributed Datalog programs in this paper. To enforce natural execution properties in their semantics, like causality, Lobo et al. specify auxiliary rules in the syntactical translation. The work of Lobo et al. (2012) does not yet mention the connection between the model-theoretic semantics and desired executions of a distributed system, i.e., an operational semantics.\n\nExtending the work of Lobo et al., the work of Ma et al. (2013) formalizes a distributed system as a composition of I/O automata (Lynch 1996). An operational execution of such a system is a sequence of valid transitions, called a trace. Global properties of the system can be analyzed by translating it into a logic program, to which an answer set solver can be applied. Ma et al. mention that operational traces of the system correspond to answer sets of the logic program, and that this provides a formal foundation for the analysis tools based on answer set programming. Thus, the work of Ma et al. (2013) indicates a practical benefit of having a correspondence between a declarative and operational semantics for languages used in declarative networking. As mentioned above, we also establish a similar correspondence in the current paper, for our distributed Datalog programs. We note, however, a few differences between our work and that of Ma et al. First, in the work of Ma et al., the message buffer of a node has a maximum size. In our operational semantics, the buffers are unbounded. Moreover, Ma et al. construct their logic programs for a fixed range of timestamps. In our declarative, model-based semantics, time is given as an infinite input to a Datalog program whose rules are independent of a fixed time range. Lastly, our work devotes much attention to rigorously showing the correspondence between the declarative and operational semantics, whereas this is not elaborated in the work of Ma et al.\n\nAlso in the setting of distributed systems, Interlandi et al. (2013) give a Dedalus-inspired language for describing synchronous systems. In such systems, the nodes of the network proceed in rounds and the messages can not be arbitrarily delayed. During each round, the nodes share the same global clock. Interlandi et al. specify an operational semantics for their language, based on relational transducer networks (Ameloot et al. 2013). They also show that this operational semantics coincides with a model-theoretic semantics of a single holistic Datalog program. It should be noted that Lobo et al. (2012), and the current paper, deal with asynchronous systems, that in general pose a bigger challenge for a distributed program to be correct,\ni.e., the program should remain unaffected by nondeterministic effects caused by message delays.\n\nAn area of artificial intelligence that is closely related to declarative networking is that of programming multi-agent systems in declarative languages. The knowledge of an agent can be expressed by a logic program, which also allows for non-monotone reasoning, and agents update their knowledge by modifying the rules in these logic programs (Leite et al. 2002; Nigam and Leite 2006; Leite and Soares 2007). The language LUPS (Alferes et al. 2002) was designed to specify such dynamic updates to logic programs, and LUPS is also a declarative language itself. After applying a sequence of updates specified in LUPS, the semantics of the resulting logic program can be defined in an inductive way. But an interesting connection to this current work, is that the semantics can also be given by first syntactically translating the original program and its updates into a single normal logic program, after which the stable model semantics is applied (Alferes et al. 2002). It should be noted however that in this second semantics, there is no modeling of causality or the sending of messages.\n\nOf course, logic programming is not the only means for specifying a (distributed) system. For example, in the area of formal methods, logic-based languages like TLA (Lamport 2000a), Z (Woodcock and Davies 1996), and Event-B (Abrial 2010) can be used to specify various distributed algorithms. Specifications written in these languages can also be automatically checked for correctness.\n\nAlthough we work within the established setting of declarative networking (Loo et al. 2009), the scientific debate on the merits of Datalog versus other formalisms for programming distributed systems remains open. It seems desirable to have an analysis of how features of Datalog relate to the features of other languages for formal specification, e.g. (Lamport 2000a; Woodcock and Davies 1996; Abrial 2010), both on the syntactical and the semantical level. However, a deep understanding of the other languages would be needed. Moreover, one may expect that features of Datalog will in general not map naturally to features of the other languages. Hence, we consider such a comparison to be a separate research project, outside the scope of the current paper.\n\n3 Preliminaries\n\n3.1 Database Basics\n\nA database schema \\( \\mathcal{D} \\) is a finite set of pairs \\((R, k)\\) where \\( R \\) is a relation name and \\( k \\in \\mathbb{N} \\) its associated arity. A relation name occurs at most once in a database schema. We often write \\((R, k)\\) as \\( R/k \\).\n\nWe assume some infinite universe \\( \\text{dom} \\) of atomic data values. A fact \\( f \\) is a pair \\((R, \\bar{a})\\), often denoted as \\( R(\\bar{a}) \\), where \\( R \\) is a relation name and \\( \\bar{a} \\) is a tuple of values over \\( \\text{dom} \\). For a fact \\( R(\\bar{a}) \\), we call \\( R \\) the predicate. We say that a fact \\( R(a_1, \\ldots, a_k) \\) is over database schema \\( \\mathcal{D} \\) if \\( R/k \\in \\mathcal{D} \\). A database instance \\( I \\) over \\( \\mathcal{D} \\) is a set of facts over \\( \\mathcal{D} \\). For a subset \\( \\mathcal{D}' \\subseteq \\mathcal{D} \\), we write \\( I|_{\\mathcal{D}'} \\) to denote the subset of facts in\n3.2 Datalog with Negation\n\nWe recall Datalog with negation (Abiteboul et al. 1995), abbreviated Datalog\\(^-\\). We assume the standard database perspective, where a Datalog\\(^-\\) program is evaluated over a given set of facts, i.e., where these facts are not part of the program itself.\n\nLet \\(\\text{var}\\) be a universe of variables, disjoint from \\(\\text{dom}\\). An atom is of the form \\(R(u_1, \\ldots, u_k)\\) where \\(R\\) is a relation name and \\(u_i \\in \\text{var} \\cup \\text{dom}\\) for each \\(i = 1, \\ldots, k\\). We call \\(R\\) the predicate. If an atom contains no data values, we call it constant-free. A literal is an atom or an atom with \"\\(^-\\)\" prepended. A literal that is an atom is called positive and otherwise it is called negative.\n\nIt will be technically convenient to use a slightly unconventional definition of rules. Formally, a Datalog\\(^-\\) rule \\(\\varphi\\) is a triple\n\n\\[\n(\\text{head}_\\varphi, \\text{pos}_\\varphi, \\text{neg}_\\varphi)\n\\]\n\nwhere \\(\\text{head}_\\varphi\\) is an atom; \\(\\text{pos}_\\varphi\\) and \\(\\text{neg}_\\varphi\\) are sets of atoms; and, the variables in \\(\\varphi\\) all occur in \\(\\text{pos}_\\varphi\\). This last condition is called safety. The components \\(\\text{head}_\\varphi, \\text{pos}_\\varphi\\) and \\(\\text{neg}_\\varphi\\) are called respectively the head, the positive body atoms and the negative body atoms. We refer to \\(\\text{pos}_\\varphi \\cup \\text{neg}_\\varphi\\) as the body atoms. Note, \\(\\text{neg}_\\varphi\\) contains just atoms, not negative literals. Every Datalog\\(^-\\) rule \\(\\varphi\\) must have a head, whereas \\(\\text{pos}_\\varphi\\) and \\(\\text{neg}_\\varphi\\) may be empty. If \\(\\text{neg}_\\varphi = \\emptyset\\) then \\(\\varphi\\) is called positive.\n\nA rule \\(\\varphi\\) may be written in the conventional syntax. For instance, if \\(\\text{head}_\\varphi = T(u, v)\\), \\(\\text{pos}_\\varphi = \\{R(u, v)\\}\\) and \\(\\text{neg}_\\varphi = \\{S(v)\\}\\), with \\(u, v \\in \\text{var}\\), then we can write \\(\\varphi\\) as\n\n\\[\nT(u, v) \\leftarrow R(u, v), \\neg S(v).\n\\]\n\nThe specific ordering of literals to the right of the arrow has no significance in this paper.\n\nThe set of variables of \\(\\varphi\\) is denoted \\(\\text{vars}(\\varphi)\\). If \\(\\text{vars}(\\varphi) = \\emptyset\\) then \\(\\varphi\\) is called ground, in which case \\(\\{\\text{head}_\\varphi\\} \\cup \\text{pos}_\\varphi \\cup \\text{neg}_\\varphi\\) is a set of facts.\n\nLet \\(\\mathcal{D}\\) be a database schema. A rule \\(\\varphi\\) is said to be over schema \\(\\mathcal{D}\\) if for each atom \\(R(u_1, \\ldots, u_k) \\in \\{\\text{head}_\\varphi\\} \\cup \\text{pos}_\\varphi \\cup \\text{neg}_\\varphi\\) we have \\(R/k \\in \\mathcal{D}\\). A Datalog\\(^-\\) program \\(P\\) over \\(\\mathcal{D}\\) is a set of (safe) Datalog\\(^-\\) rules over \\(\\mathcal{D}\\). We write \\(\\text{sch}(P)\\) to denote the smallest database schema that \\(P\\) is over; note, \\(\\text{sch}(P)\\) is uniquely defined. We define \\(\\text{idb}(P) \\subseteq \\text{sch}(P)\\) to be the database schema consisting of all relations in rule-heads of \\(P\\). We abbreviate \\(\\text{edb}(P) = \\text{sch}(P) \\setminus \\text{idb}(P)\\).\n\nAny database instance \\(I\\) over \\(\\text{sch}(P)\\) can be given as input to \\(P\\). Note, \\(I\\) may already contain facts over \\(\\text{idb}(P)\\). Let \\(\\varphi \\in P\\). A valuation for \\(\\varphi\\) is a total function \\(V : \\text{vars}(\\varphi) \\to \\text{dom}\\). The application of \\(V\\) to an atom \\(R(u_1, \\ldots, u_k)\\) of \\(\\varphi\\), denoted\n\n\\[1\\] The abbreviation “idb” stands for “intensional database schema” and “edb” stands for “extensional database schema” (Abiteboul et al. 1995).\n\n\\[2\\] The need for this will become clear in Section\\(\\text{\\textsection}\\).\nthan one exists). Not all Datalog programs are syntactically stratifiable. First, let \\( P \\) be the immediate consequence operator that maps each instance \\( I \\) over \\( sch(P) \\) to the instance \\( I' = J \\cup A \\) where \\( A \\) is the set of facts derived by all possible satisfying valuations for the rules of \\( P \\) on \\( J \\).\n\nLet \\( I \\) be an instance over \\( sch(P) \\). Consider the infinite sequence \\( I_0, I_1, I_2, \\ldots \\), inductively defined as follows: \\( I_0 = I \\) and \\( I_i = T_P(I_{i-1}) \\) for each \\( i \\geq 1 \\). The output of \\( P \\) on input \\( I \\), denoted \\( P(I) \\), is defined as \\( \\bigcup_i I_i \\); this is the minimal fixpoint of the \\( T_P \\) operator. Note, \\( I \\subseteq P(I) \\). When \\( I \\) is finite, the fixpoint is finite and can be computed in polynomial time according to data complexity \\( Vardi \\ 1982 \\).\n\n### 3.2.2 Stratified Semantics\n\nWe now recall the stratified semantics for a Datalog\\(^-\\) program \\( P \\) (Abiteboul et al. 1995). As a slight abuse of notation, here we will treat \\( idb(P) \\) as a set of only relation names (without associated arities). First, \\( P \\) is called syntactically stratifiable if there is a function \\( \\sigma : idb(P) \\rightarrow \\{1, \\ldots, |idb(P)|\\} \\) such that for each rule \\( \\varphi \\in P \\), having some head predicate \\( T \\), the following conditions are satisfied:\n\n- \\( \\sigma(R) \\leq \\sigma(T) \\) for each \\( R(\\bar{u}) \\in pos_{\\varphi}|idb(P)| \\);\n- \\( \\sigma(R) < \\sigma(T) \\) for each \\( R(\\bar{u}) \\in neg_{\\varphi}|idb(P)| \\).\n\nFor \\( R \\in idb(P) \\), we call \\( \\sigma(R) \\) the stratum number of \\( R \\). For technical convenience, we may assume that if there is an \\( R \\in idb(P) \\) with \\( \\sigma(R) > 1 \\) then there is an \\( S \\in idb(P) \\) with \\( \\sigma(S) = \\sigma(R) - 1 \\). Intuitively, function \\( \\sigma \\) partitions \\( P \\) into a sequence of semi-positive Datalog\\(^-\\) programs \\( P_1, \\ldots, P_k \\) with \\( k \\leq |idb(P)| \\) such that for each \\( i = 1, \\ldots, k \\), the program \\( P_i \\) contains the rules of \\( P \\) whose head predicate has stratum number \\( i \\). This sequence is called a syntactic stratification of \\( P \\). We can now apply the stratified semantics to \\( P \\): for an input \\( I \\) over \\( sch(P) \\), we first compute the fixpoint \\( P_1(I) \\), then the fixpoint \\( P_2(P_1(I)) \\), etc. The output of \\( P \\) on input \\( I \\), denoted \\( P(I) \\), is defined as \\( P_k(P_{k-1}(\\ldots P_1(I) \\ldots)) \\). It is well known that the output of \\( P \\) does not depend on the chosen syntactic stratification (if more than one exists). Not all Datalog\\(^-\\) programs are syntactically stratifiable.\n3.2.3 Stable Model Semantics\n\nWe now recall the stable model semantics for a Datalog− program \\( P \\) (Gelfond and Lifschitz 1988; Sacca and Zaniolo 1990). Let \\( I \\) be an instance over \\( \\text{sch}(P) \\). Let \\( \\varphi \\in P \\). Let \\( V \\) be a valuation for \\( \\varphi \\) whose image is contained in \\( \\text{adom}(I) \\cup C \\), where \\( C \\) is the set of all constants appearing in \\( P \\). Valuation \\( V \\) does not have to be satisfying for \\( \\varphi \\) on \\( I \\). Together, \\( V \\) and \\( \\varphi \\) give rise to a ground rule \\( \\psi \\), obtained from \\( \\varphi \\) by replacing each \\( u \\in \\text{vars}(\\varphi) \\) with \\( V(u) \\). We call \\( \\psi \\) a ground rule of \\( \\varphi \\) with respect to \\( I \\). Let \\( \\text{ground}(\\varphi, I) \\) denote the set of all ground rules of \\( \\varphi \\) with respect to \\( I \\). The ground program of \\( P \\) on \\( I \\), denoted \\( \\text{ground}(P, I) \\), is defined as \\( \\bigcup_{\\varphi \\in P} \\text{ground}(\\varphi, I) \\). Note, if \\( I = \\emptyset \\), the set \\( \\text{ground}(P, I) \\) contains only rules whose ground atoms are made with \\( C \\), or atoms that are nullary.\n\nLet \\( M \\) be another instance over \\( \\text{sch}(P) \\). We write \\( \\text{ground}_M(P, I) \\) to denote the program obtained from \\( \\text{ground}(P, I) \\) as follows:\n\n1. remove every rule \\( \\psi \\in \\text{ground}(P, I) \\) for which \\( \\text{neg}_{\\psi} \\cap M \\neq \\emptyset \\);\n2. remove the negative (ground) body atoms from all remaining rules.\n\nNote, \\( \\text{ground}_M(P, I) \\) is a positive program. We say that \\( M \\) is a stable model of \\( P \\) on input \\( I \\) if \\( M \\) is the output of \\( \\text{ground}_M(P, I) \\) on input \\( I \\). If so, the semantics of positive Datalog− programs implies \\( I \\subseteq M \\). Not all Datalog− programs have stable models on every input (Gelfond and Lifschitz 1988).\n\n3.3 Network and Distributed Databases\n\nA (computer) network is a nonempty finite set \\( N \\) of nodes, which are values in \\( \\text{dom} \\). Intuitively, \\( N \\) represents the identifiers of compute nodes involved in a distributed system. Communication channels (edges) are not explicitly represented because we allow a node \\( x \\) to send a message to any node \\( y \\), as long as \\( x \\) knows about \\( y \\) by means of input relations or received messages. For general distributed or cluster computing, the delivery of messages is handled by the network layer, which is abstracted away. But (Datalog) programs can also describe the network layer itself (Loo et al. 2009; Hellerstein 2010b), in which case we would restrict attention to programs where nodes only send messages to nodes to which they are explicitly linked; these nodes would again be provided as input.\n\nA distributed database instance \\( H \\) over a network \\( N \\) and a database schema \\( D \\) is a function that maps every node of \\( N \\) to an ordinary finite database instance over \\( D \\). This represents how data over the same schema \\( D \\) is spread over a network.\n\nAs a small example of a distributed database instance, consider the following instance \\( H \\) over a network \\( N = \\{ x, y \\} \\) and a schema \\( D = \\{ R/1, S/1 \\} \\): \\( H(x) = \\{ R(a), S(b) \\} \\) and \\( H(y) = \\{ R(a), S(c) \\} \\). In words: we put facts \\( R(a) \\) and \\( S(b) \\) at node \\( x \\), and we put facts \\( R(a) \\) and \\( S(c) \\) at node \\( y \\). Note that it is possible that the same fact is given to multiple nodes.\n4 Model-Based Semantics\n\nHere we describe a class of distributed Datalog programs that we give a model-based semantics. First, in Section 4.1, we recall the user language Dedalus, that is based on Datalog with annotations, in which the programmer can express the functionality of the distributed program. Next, we discuss how to assign a declarative, model-based semantics to Dedalus programs. This semantics consists of applying the stable model semantics to the Dedalus programs after they are transformed into pure Datalog programs, i.e., without annotations. We introduce some auxiliary notations and symbols in Section 4.2. Next, in Section 4.3, we give a basic transformation of Dedalus programs in order to apply the stable model semantics. However, this basic transformation has some shortcomings, that we iteratively correct in Sections 4.4 and 4.5.\n\n4.1 User Language: Dedalus\n\nOur user language for distributed Datalog programs is Dedalus [Alvaro et al. 2009, Alvaro et al. 2011, Hellerstein 2010b], here presented as Datalog with annotations. Essentially, the language represents updatable memory for the nodes of a network and provides a mechanism for communication between these nodes.\n\n4.1.1 Syntax\n\nLet $\\mathcal{D}$ be a database schema. We write $B\\{\\bar{v}\\}$, where $\\bar{v}$ is a tuple of variables, to denote any sequence $\\beta$ of literals over database schema $\\mathcal{D}$, such that the variables in $\\beta$ are precisely those in the tuple $\\bar{v}$. Let $R(\\bar{u})$ denote any atom over $\\mathcal{D}$. There are three types of Dedalus rules over $\\mathcal{D}$:\n\n- A deductive rule is a normal Datalog rule over $\\mathcal{D}$:\n\n \\[ R(\\bar{u}) \\leftarrow B\\{\\bar{u}, \\bar{v}\\}. \\]\n\n- An inductive rule is of the form\n\n \\[ R(\\bar{u}) \\leftarrow B\\{\\bar{u}, \\bar{v}\\}. \\]\n\n- An asynchronous rule is of the form\n\n \\[ R(\\bar{u}) \\mid y \\leftarrow B\\{\\bar{u}, \\bar{v}, y\\}. \\]\n\nFor asynchronous rules, the annotation ‘$\\mid y$’ with $y \\in \\text{var}$ means that the derived head facts are transferred (“piped”) to the addressee node represented by $y$. Deductive, inductive and asynchronous rules will express respectively local computation, updatable memory, and message sending. As in Section 3.2, a Dedalus rule is called safe if all its variables occur in at least one positive body atom.\n\nWe already provide some intuition of how asynchronous rules operate. There are four conceptual time points involved in the execution of an asynchronous rule: the time when the body is evaluated; the time when the derived fact is sent to the addressee; the time when the fact arrives at the addressee; and, the time when\n\n\\footnote{These annotations correspond to syntaxic sugar in the previous presentations of Dedalus.}\nthe arrived fact becomes visible at the addressee. In the model-based semantics presented later, the first two time points coincide and the last two time points coincide; and, there is no upper bound on the interval between these two pairs, although it will be finite.\n\nNow consider the following definition:\n\n**Definition 4.1**\n\nA Dedalus program over a schema $\\mathcal{D}$ is a set of deductive, inductive and asynchronous Dedalus rules over $\\mathcal{D}$, such that all rules are safe, and the set of deductive rules is syntactically stratifiable.\n\nIn the current work, we will additionally assume that Dedalus programs are constant-free, as is common in the theory of database query languages, and which is not really a limitation, since constants that are important for the program can always be indicated by unary relations in the input.\n\nLet $\\mathcal{P}$ be a Dedalus program. The definitions of $\\text{sch}(\\mathcal{P})$, $\\text{idb}(\\mathcal{P})$, and $\\text{edb}(\\mathcal{P})$ are like for Datalog programs. An input for $\\mathcal{P}$ is a distributed database instance over some network $\\mathcal{N}$ and the schema $\\text{edb}(\\mathcal{P})$.\n\n### 4.1.2 Semantics Sketch\n\nWe sketch the main idea behind the semantics of a Dedalus program $\\mathcal{P}$. We illustrate the semantics in Section 4.1.3.\n\nLet $H$ be an input distributed database instance for $\\mathcal{P}$, over a network $\\mathcal{N}$. The idea is that all nodes $x \\in \\mathcal{N}$ run the same program $\\mathcal{P}$ and use their local input fragment $H(x)$ to do local computation and to send messages. Conceptually, each node of $\\mathcal{N}$ should be thought of as doing local computation steps, indefinitely. During each step, a node reads the following facts: (i) the local input; (ii) some received message facts, generated by asynchronous rules on other nodes or the node itself; and, (iii) the facts derived by inductive rules during the previous step on this same node. Next, the deductive rules are applied to these available facts, to compute a fixpoint $D$ under the stratified semantics.\n\nSubsequently, the asynchronous and inductive rules are fired in parallel on the deductive fixpoint $D$, trying all possible valuations in single-step derivations (i.e., no fixpoint). The asynchronous rules send messages to other nodes or to the same node. Messages arrive after an arbitrary (but finite) delay, where the delay can vary for each message. The inductive rules store facts in the memory of the local node. The effect of an inductive derivation is only visible in the very next step; so, if a fact is to be remembered over multiple steps, it should always be explicitly rederived by inductive rules.\n\n### 4.1.3 Examples\n\nWe consider several examples to demonstrate the three kinds of Dedalus rules, and how they work together. These examples also illustrate the utility of Dedalus when applied to some practical problems. Here, we follow the principle that the output on a node $x$ consists of the facts that are eventually derived during every step of $x$. \nExample 1\n\nIn this example we compute reachable vertices on graph data. Consider the Dedalus program $P$ in Figure 1. We assume the $edb$ relations $R/2$, $start/1$, and $Node/1$. For each node, relation $R$ describes a local graph, and relation $start$ provides certain starting vertices. In any input distributed database instance $H$ over a network $N$, we assume that for each node, relation $Node$ is initialized to contain all nodes of $N$; intuitively, $Node$ can be regarded as an address book for $N$.\n\nNow, the idea is that each node of $N$ will check whether all of its local vertices are reachable from the (distributed) start vertices. Communication is needed to share these start vertices, which is accomplished by the asynchronous rule. The receipt of a start vertex initializes a local relation $marked/1$ at each node; this relation contains reachable vertices. The inductive rule says that all reachable vertices that we know during the current step, are remembered in the next step. This way, the effect of the communication is preserved. Moreover, the third rule, which is deductive, collects all local graph vertices reachable from the currently known reachable vertices. Note, the inductive rule will cause the result of this deductive computation to be also remembered in the next step, although this effect is not really needed here. The last four rules, which are deductive, check that all local vertices are reachable from the start vertices seen so far; if so, a local flag $covered()$ is derived.\n\nIn our semantics, we will enforce that all messages eventually arrive. In such a semantics, eventually a node will produce $covered()$ during each step iff all its local vertices are reachable from the distributed start vertices.\n\nExample 2\n\nIn this example we generate a random ordering of a set through asynchronous delivery of messages. Every node generates a random ordering of a local $edb$ relation $S/1$ that represents an input set. We also assume an $edb$ relation $Id/1$ that contains on each node the identifier of that node; the relation $Id$ allows a node to send a message to itself. The idea is that a node sends all elements of $S$ to itself as messages, and the arbitrary arrival order is used to generate an ordering of the elements.\nordering depends on the execution, and some executions will not lead to orderings if some elements are always jointly delivered.\n\nThe corresponding program is shown in Figure 2. We use relation $M/1$ to send the elements of $S$, as accomplished by the single asynchronous rule. The relations $F/1$ and $N/2$ represent the ordering of $S$ so far, and they are considered as the output of the program; the letters ‘F’ and ‘N’ stand for “first” and “next” respectively. For example, a possible ordering of the set $\\{a, b, c, d\\}$ could be expressed by the following facts: $F(d)$, $N(d, c)$, $N(c, b)$, $N(b, a)$.\n\nInductive rules are responsible for remembering the iteratively updated versions of $F$ and $N$. The other rules are deductive, and they can conceptually be executed in the order in which they are written. The main technical challenge is to only update the ordering when precisely one element of $S$ arrives; otherwise, because we have no choice mechanism, we would accidentally give the same ordinal to two different elements. Checking whether we may update the ordering is accomplished through other auxiliary relations. We use a nullary relation $\\text{started}$ as a flag to know whether we still have to initialize relation $F$ or not.\n\nNote that the program keeps sending all elements of $S$ through the single asynchronous rule. Alternatively, by adapting the program, we could send the elements only once by making sure the asynchronous rule is fired only once (in parallel for all elements of $S$). In that case, as soon as two elements are later delivered together, the ordering will not contain all elements.\n\n\\textit{Example 3}\\n\nThis example is inspired by commit protocols that were expressed in a precursor language of Dedalus (Alvaro et al. 2009). In particular, we implement a two-phase commit protocol where agents, represented by nodes, vote either “yes” or “no” for transaction identifiers. Such a protocol could be part of a bigger system, where transactions are distributed across agents and each agent may only perform the transaction locally if all agents want to do this. A single coordinator node is responsible for combining the votes for each transaction identifier $t$: the coordinator broadcasts “yes” for $t$ if all votes for $t$ are “yes”, and “no” otherwise. Each agent stores the decision of the coordinator.\n\nBecause the agents and the coordinator have different roles, we make two separate Dedalus programs. First, the agent nodes are assigned the following simple Dedalus program, whose relations are explained below:\n\n\\[\n\\begin{align*}\n\\text{vote}(t, x, v) & \\iff \\text{myVote}(t, v), \\text{Id}(x), \\text{coord}(y), \\\\\n\\text{outcome}(t, v) & \\iff \\text{outcome}(t, v).\n\\end{align*}\n\\]\n\nHere, the edb relations are: $\\text{myVote}/2$ that maps each transaction identifier $t$ to a local vote “yes” or “no”, $\\text{Id}/1$ storing the identifier of the agent, and $\\text{coord}/1$.\n\n---\n\n4 In our formal definitions, all nodes execute the same Dedalus program. However, it is easy to simulate two different programs by giving every node the union of both programs, but using a flag to guard the rules of each program. In this example, we can then assume that one node gets a “coordinator” flag as input, and the other nodes get an “agent” flag as input.\nPutting Logic-Based Distributed Systems on Stable Grounds\n\nFigure 2. Dedalus program for Example 2.\n\nstoring the identifier of the coordinator. Also, the relations vote/3 and outcome/2 represent respectively the outgoing votes and the final decision by the coordinator.\n\nSecond, the coordinator node is assigned the Dedalus program shown in Figure 3. The coordinator has the following edb relations: relation T/1 containing all transaction identifiers, relations Y/1 and N/1 containing the constants “yes” and “no” respectively, and relation agents/1 containing all voting agents. The coordinator uses an inductive rule to gradually accumulate all votes for each transaction identifier. Votes can have arbitrary delays, but in our model the delays are always finite. In each computation step, the deductive rules at the coordinator recompute a relation complete that contains the transaction identifiers for which all votes have been received. When a transaction identifier t has at least one “no” vote, the coordinator decides “no” for t, and otherwise the coordinator decides “yes” for t. The final decision is broadcast to all agents. The coordinator adds the transactions with a decision to a log, so the decision will not be broadcast again.\n\n4.2 Auxiliary Notations and Relations\n\nLet P be a Dedalus program. Let R/k ∈ sch(P). We will use facts of the form R(x, s, a1, . . . , ak) to express that fact R(a1, . . . , ak) is present at a node x during its local step s, with s ∈ N, after the deductive rules are executed. We call x the\nvote(t, x, v) ← vote(t, x, v).\nknown(t, x) ← vote(t, x, v).\nmissing(t) ← T(t), agent(x), ¬known(t, x).\ncomplete(t) ← T(t), ¬missing(t).\ndecideNo(t) ← votes(t, x, v), N(v).\ndecideYes(t) ← complete(t), ¬decideNo(t).\noutcome(t, v) | y ← decideNo(t), ¬log(t), N(v), agent(y).\noutcome(t, v) | y ← decideYes(t), ¬log(t), Y(v), agent(y).\nlog(t) • ← complete(t).\nlog(t) • ← log(t).\n\nFigure 3. Dedalus (coordinator) program for Example 3.\n\nlocation specifier and s the timestamp. In order to represent timestamps, we assume \\( \\mathbb{N} \\subseteq \\text{dom} \\).\n\nWe write \\( \\text{sch}(P)^{LT} \\) to denote the database schema obtained from \\( \\text{sch}(P) \\) by incrementing the arity of every relation by two. The two extra components will contain the location specifier and timestamp.\\(^5\\) For an instance \\( I \\) over \\( \\text{sch}(P) \\), \\( x \\in \\text{dom} \\) and \\( s \\in \\mathbb{N} \\), we write \\( I^{x,s} \\) to denote the facts over \\( \\text{sch}(P)^{LT} \\) that are obtained by prepending location specifier \\( x \\) and timestamp \\( s \\) to every fact of \\( I \\). Also, if \\( L \\) is a sequence of literals over \\( \\text{sch}(P) \\), and \\( x, s \\in \\text{var} \\), we write \\( L^{x,s} \\) to denote the sequence of literals over \\( \\text{sch}(P)^{LT} \\) that is obtained by adding location specifier \\( x \\) and timestamp \\( s \\) to the literals in \\( L \\) (negative literals stay negative).\n\nWe also need auxiliary relation names, that are assumed not to be used in \\( \\text{sch}(P) \\); these are listed in Table 1.\\(^6\\) The concrete purpose of these relations will become clear in the following subsections.\n\nWe define the following schema\n\n\\[\n\\mathcal{D}_{\\text{time}} = \\{ \\text{time}/1, \\text{tsucc}/2, </2, \\neq/2 \\}.\n\\]\n\nThe relations ‘<’ and ‘\\( \\neq \\)’ will be written in infix notation in rules. We consider only the following instance over \\( \\mathcal{D}_{\\text{time}} \\):\n\n\\[\nI_{\\text{time}} = \\{ \\text{time}(s), \\text{tsucc}(s, s + 1) \\mid s \\in \\mathbb{N} \\}\n\\cup \\{ (s < t) \\mid s, t \\in \\mathbb{N} : s < t \\}\n\\cup \\{ (s \\neq t) \\mid s, t \\in \\mathbb{N} : s \\neq t \\}.\n\\]\n\nIntuitively, the instance \\( I_{\\text{time}} \\) provides timestamps together with relations to compare them.\n\n\\(^5\\) The abbreviation ‘LT’ stands for “location specifier and timestamp”.\n\n\\(^6\\) In practice, auxiliary relations can be differentiated from those in \\( \\text{sch}(P) \\) by a namespace mechanism.\nTable 1. Relation names not in \\( sch(\\mathcal{P}) \\).\n\n<table>\n<thead>\n<tr>\n<th>Relation Names</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>all</td>\n<td>network</td>\n</tr>\n<tr>\n<td>time, tsucc, (<, \\neq)</td>\n<td>timestamps</td>\n</tr>\n<tr>\n<td>before</td>\n<td>happens-before relation</td>\n</tr>\n<tr>\n<td>( cand_R, \\ chosen_R, \\ other_R ) for each R in ( idb(\\mathcal{P}) )</td>\n<td>messages</td>\n</tr>\n<tr>\n<td>hasSender, isSmaller, hasMax, rcvInf</td>\n<td>only a finite number of messages arrive at each step of a node</td>\n</tr>\n</tbody>\n</table>\n\n### 4.3 Dynamic Choice Transformation\n\nLet \\( \\mathcal{P} \\) be a Dedalus program. We describe the dynamic choice transformation to transform \\( \\mathcal{P} \\) into a pure Datalog \\(^7\\) program \\( pure_{ch}(\\mathcal{P}) \\). The most technical part of the transformation involves the use of dynamic choice to select an arrival timestamp for each message generated by an asynchronous rule. The actual transformation is presented first; next we give the semantics; and, lastly, we discuss how the transformation can be improved.\n\n#### 4.3.1 Transformation\n\nWe incrementally construct \\( pure_{ch}(\\mathcal{P}) \\). In particular, for each rule in \\( \\mathcal{P} \\), we specify what corresponding rule (or rules) should be added to \\( pure_{ch}(\\mathcal{P}) \\). For technical convenience, we assume that rules of \\( \\mathcal{P} \\) always contain at least one positive body atom. This assumption allows us to more elegantly enforce that head variables in rules of \\( pure_{ch}(\\mathcal{P}) \\) also occur in at least one positive body atom. Let \\( x, s, t, t' \\in \\text{var} \\) be distinct variables not yet occurring in rules of \\( \\mathcal{P} \\). We write \\( B\\{\\varphi\\} \\), where \\( \\varphi \\) is a tuple of variables, to denote any sequence \\( \\beta \\) of literals over \\( sch(\\mathcal{P}) \\), such that the variables in \\( \\beta \\) are precisely those in \\( \\varphi \\). Also recall the notations and relation names from Section 4.2.\n\n**Deductive rules** For each deductive rule \\( R(\\bar{u}) \\leftarrow B\\{\\bar{u}, \\varphi\\} \\) in \\( \\mathcal{P} \\), we add to \\( pure_{ch}(\\mathcal{P}) \\) the following rule:\n\n\\[\nR(x, s, \\bar{u}) \\leftarrow B\\{\\bar{u}, \\varphi\\}_{\\uparrow x, s}.\n\\]\n\n\\(^7\\) This assumption is not really a restriction, since a nullary positive body atom is already sufficient.\nThis rule expresses that deductively derived facts at some node \\( x \\) during step \\( s \\) are (immediately) visible within step \\( s \\) of \\( x \\). Note, all atoms in this rule are over \\( \\text{sch}(\\mathcal{P})^{\\mathsf{LT}} \\).\n\n**Inductive rules** For each inductive rule \\( R(\\bar{u}) \\leftarrow \\mathbf{B}(\\bar{u}, \\bar{v}) \\) in \\( \\mathcal{P} \\), we add to \\( \\text{pure}_{\\text{ch}}(\\mathcal{P}) \\) the following rule:\n\n\\[\nR(x, t, \\bar{u}) \\leftarrow \\mathbf{B}(\\bar{u}, \\bar{v})^{\\mathsf{LT}-s}, \\text{tsucc}(s, t).\n\\]\n\nThis rule expresses that inductively derived facts becomes visible in the next step of the same node.\n\n**Asynchronous rules** We use facts of the form \\( \\text{all}(x) \\) to say that \\( x \\) is a node of the network at hand. We use facts of the form \\( \\text{cand}_R(x, s, y, t, \\bar{u}) \\) to express that node \\( x \\) at its step \\( s \\) sends a message \\( R(\\bar{u}) \\) to node \\( y \\), and that \\( t \\) could be the arrival timestamp of this message at \\( y \\). Within this context, we use a fact \\( \\text{chosen}_R(x, s, y, t, \\bar{u}) \\) to say that \\( t \\) is the effective arrival timestamp of this message at \\( y \\). Lastly, a fact \\( \\text{other}_R(x, s, y, t, \\bar{u}) \\) means that \\( t \\) is not the arrival timestamp of the message. Now, for each asynchronous rule\n\n\\[\nR(\\bar{u}) \\mid y \\leftarrow \\mathbf{B}(\\bar{u}, \\bar{v}, y)\n\\]\n\nin \\( \\mathcal{P} \\), letting \\( \\bar{v} \\) be a tuple of new and distinct variables with \\( |\\bar{v}| = |\\bar{u}| \\), we add to \\( \\text{pure}_{\\text{ch}}(\\mathcal{P}) \\) the following rules, for which the intuition is given below:\n\n\\[\ncand_R(x, s, y, t, \\bar{u}) \\leftarrow \\mathbf{B}(\\bar{u}, \\bar{v}, y)^{\\mathsf{LT}-s}, \\text{all}(y), \\text{time}(t).\n\\]\n\n\\[\n\\text{chosen}_R(x, s, y, t, \\bar{v}) \\leftarrow \\text{cand}_R(x, s, y, t, \\bar{u}), \\neg \\text{other}_R(x, s, y, t, \\bar{u}).\n\\]\n\n\\[\n\\text{other}_R(x, s, y, t, \\bar{v}) \\leftarrow \\text{cand}_R(x, s, y, t, \\bar{u}), \\text{chosen}_R(x, s, y, t', \\bar{v}), t \\neq t'.\n\\]\n\n\\[\nR(y, t, \\bar{u}) \\leftarrow \\text{chosen}_R(x, s, y, t, \\bar{u}).\n\\]\n\nRule \\([3]\\) represents the messages that are sent. It evaluates the body of the original asynchronous rule, verifies that the addressee is within the network by using relation \\( \\text{all} \\), and it generates all possible candidate arrival timestamps.\n\nNow remains the matter of actually choosing one arrival timestamp amongst all these candidates. Intuitively, rule \\([4]\\) selects an arrival timestamp for a message with the condition that this timestamp is not yet ignored, as expressed with relation \\( \\text{other}_R \\). Also, looking at rule \\([5]\\), a possible arrival timestamp \\( t \\) becomes ignored if there is already a chosen arrival timestamp \\( t' \\) with \\( t \\neq t' \\). Together, both rules have the effect that exactly one arrival timestamp will be chosen under the stable model semantics. This technical construction is due to Saccà and Zaniolo (1990), who show how to express dynamic choice under the stable model semantics.\n\nRule \\([6]\\) represents the actual arrival of an \\( R \\)-message with the chosen arrival timestamp: the data-tuple in the message becomes part of the addressee’s state for relation \\( R \\). When the addressee reads relation \\( R \\), it thus transparently reads the arrived \\( R \\)-messages.\n\n\\[\\text{'cand' abbreviates \"candidate\".}\\]\nNote, if multiple asynchronous rules in \\( \\mathcal{P} \\) have the same head predicate \\( R \\), only new \\( \\text{cand}_R \\)-rules have to be added because the rules (4)–(6) are general for all \\( R \\)-messages.\n\nNote that if there are asynchronous rules in \\( \\mathcal{P} \\), program \\( \\text{pure}_{\\text{ch}}(\\mathcal{P}) \\) is not syntactically stratifiable if a \\( \\text{cand}_R \\)-rule contains a body atom that (indirectly) negatively depends on \\( R \\). In that case, \\( \\text{pure}_{\\text{ch}}(\\mathcal{P}) \\) might not even be locally stratifiable (Apt and Bol 1994).\n\n### 4.3.2 Semantics\n\nNow we define the semantics of \\( \\text{pure}_{\\text{ch}}(\\mathcal{P}) \\). Let \\( H \\) be an input distributed database instance for \\( \\mathcal{P} \\), over a network \\( \\mathcal{N} \\). Using the notations from Section 4.2, we define \\( \\text{decl}(H) \\) to be the following database instance over the schema \\( \\text{edb}(\\mathcal{P}) \\cup \\{\\text{all}/1\\} \\cup \\mathcal{D}_{\\text{time}} \\):\n\n\\[\n\\text{decl}(H) = \\{ R(x, s, \\bar{a}) \\mid x \\in \\mathcal{N}, s \\in \\mathbb{N}, R(\\bar{a}) \\in H(x) \\} \\\\\n\\cup \\{\\text{all}(x) \\mid x \\in \\mathcal{N}\\} \\cup I_{\\text{time}}.\n\\]\n\nIn words: we make for each node its input facts available at all timestamps; we provide the set of all nodes; and, \\( I_{\\text{time}} \\) provides the timestamps with comparison relations. Note, instance \\( \\text{decl}(H) \\) is infinite because \\( \\mathbb{N} \\) is infinite.\n\nThe stable model semantics for Datalog\\(^{-}\\) programs is reviewed in Section 3.2.3. Consider now the following definition:\n\n**Definition 4.2**\n\nFor an input distributed database instance \\( H \\) for \\( \\mathcal{P} \\), we call any stable model of \\( \\text{pure}_{\\text{ch}}(\\mathcal{P}) \\) on input \\( \\text{decl}(H) \\) a choice-model of \\( \\mathcal{P} \\) on input \\( H \\).\n\n### 4.3.3 Possible Improvement\n\nWe illustrate a shortcoming of the dynamic choice transformation. Consider the Dedalus program \\( \\mathcal{P} \\) in Figure 4. We assume that in each input distributed database, the \\( \\text{edb} \\) relation \\( \\text{Id}/1 \\) contains on each node just the identifier of this node. This way, the node can send messages to itself. Relation \\( T \\) is the intended output relation of \\( \\mathcal{P} \\). The idea is that a node sends \\( A() \\) to itself continuously. When \\( A() \\) arrives, we send \\( B() \\), but we also want to create an output fact \\( T() \\). We only create \\( T() \\) when \\( B() \\) is absent. When \\( B() \\) is received, it is remembered by inductive rules. Now, we see that the delivery of at least one \\( A() \\) is necessary to cause a \\( B() \\) to be sent. This creates the expectation that \\( T() \\) is always created: at least one \\( A() \\) is delivered before any \\( B() \\). This intuition can be formalized as causality (Attiya and Welch 2004) (see also Section 5.2.1).\n\nHowever, this intuition is violated by some choice-models of \\( \\mathcal{P} \\), as we demonstrate.\n\n---\n\n9 Indeed, \\( \\text{cand}_R \\) is used to compute \\( R \\), but \\( R \\) is also used to compute \\( \\text{cand}_R \\), giving a cycle through negation.\n\n10 For simplicity we already include relation \\( < \\) in this definition, although this relation will only be used later.\nnext. Consider the input distributed database instance $H$ over a singleton network \\{z\\} that assigns the fact $\\text{Id}(z)$ to $z$. Now, consider the following choice-model $M$ of $P$ on $H$ \\[ \\text{decl}(H) \\cup M^{\\text{snd}}_A \\cup M^{\\text{rcv}}_A \\cup M^{\\text{snd}}_B \\cup M^{\\text{rcv}}_B, \\]\n\nwhere\n\n\\[\n\\begin{align*}\nM^{\\text{snd}}_A &= \\{\\text{cand}_A(z, s, t) \\mid s, t \\in \\mathbb{N}\\} \\\\\n&\\quad \\cup \\{\\text{chosen}_A(z, s, s+1) \\mid s \\in \\mathbb{N}\\} \\\\\n&\\quad \\cup \\{\\text{other}_A(z, s, t) \\mid s, t \\in \\mathbb{N}, t \\neq s+1\\}; \\\\\nM^{\\text{rcv}}_A &= \\{A(z, s) \\mid s \\in \\mathbb{N}, s \\geq 1\\}; \\\\\nM^{\\text{snd}}_B &= \\{\\text{cand}_B(z, s, t) \\mid s, t \\in \\mathbb{N}, s \\geq 1\\} \\\\\n&\\quad \\cup \\{\\text{chosen}_B(z, 1, 0)\\} \\\\\n&\\quad \\cup \\{\\text{chosen}_B(z, s, s+1) \\mid s \\in \\mathbb{N}, s \\geq 2\\} \\\\\n&\\quad \\cup \\{\\text{other}_B(z, 1, t) \\mid t \\in \\mathbb{N}, t \\neq 0\\} \\\\\n&\\quad \\cup \\{\\text{other}_B(z, s, t) \\mid s, t \\in \\mathbb{N}, s \\geq 2, t \\neq s+1\\}; \\\\\nM^{\\text{rcv}}_B &= \\{B(z, s) \\mid s \\in \\mathbb{N}\\}.\n\\end{align*}\n\\]\n\nIn $M^{\\text{snd}}_B$, note that one $B$-message is sent at timestamp 1 of $z$, and arrives at timestamp 0 of $z$. We immediately see that this message is peculiar: we should not be able to send a message to arrive in the past. Because of the stray message $B()$, the fact $B()$ exists at all timestamps: it arrives at timestamp 0 and is henceforth persisted by the inductive rule for relation $B$; this is modeled by set $M^{\\text{rcv}}_B$. Subsequently, there are no ground rules of the form $T(z, s) \\leftarrow A(z, s)$ with $s \\in \\mathbb{N}$ in the ground program $\\text{ground}_M(C, I)$, where $C = \\text{pure}_{\\text{ch}}(P)$ and $I = \\text{decl}(H)$.\n\nIn the next subsection, we exclude such unintuitive stable models using an extended transformation of Dedalus programs.\n\n\\[\\text{using straightforward arguments, it can indeed be shown that } M \\text{ is a stable model of } \\text{pure}_{\\text{ch}}(P) \\text{ on } \\text{decl}(H).\\]\n4.4 Causality Transformation\n\nLet $\\mathcal{P}$ be a Dedalus program. In this section, we present the causality transformation $\\text{pure}_{ca}(\\mathcal{P})$ that extends $\\text{pure}_{ch}(\\mathcal{P})$ to exclude the unintuitive stable models that we have encountered in the previous subsection. We first present the new transformation, and then we discuss how the transformation can still be improved.\n\n4.4.1 Transformation\n\nWe define $\\text{pure}_{ca}(\\mathcal{P})$ again incrementally. First, we transform deductive and inductive rules just as in $\\text{pure}_{ch}(\\mathcal{P})$.\n\nNext, we use facts of the form $\\text{before}(x, s, y, t)$ to express that local step $s$ of node $x$ happens before local step $t$ of node $y$. Regardless of $\\mathcal{P}$, we always add the following rules to $\\text{pure}_{ca}(\\mathcal{P})$:\n\n$\\text{before}(x, s, x, t) \\leftarrow \\text{all}(x), \\text{tsucc}(s, t)$ \\hspace{1cm} (7)\n\n$\\text{before}(x, s, y, t) \\leftarrow \\text{before}(x, s, z, u), \\text{before}(z, u, y, t)$ \\hspace{1cm} (8)\n\nRule (7) expresses that on every node, a step happens before the next step. Rule (8) makes relation $\\text{before}$ transitive.\n\nNow, for each asynchronous rule\n\n$R(\\bar{u}) | y \\leftarrow B\\{\\bar{u}, \\bar{v}, y\\}$\n\nin $\\mathcal{P}$, we add to $\\text{pure}_{ca}(\\mathcal{P})$ the previous transformation rules (4), (5) and (6) (omitting the $\\text{cand}_R$-rule), and we add the following new rules, where $\\bar{w}$ is a tuple of new variables with $|\\bar{w}| = |\\bar{u}|$, and $x$, $s$, and $t$ are also new variables:\n\n$\\text{cand}_R(x, s, y, t, \\bar{u}) \\leftarrow B\\{\\bar{u}, \\bar{v}, y\\}^{\\bar{w}, x, y, z}, \\text{all}(y), \\text{time}(t), \\neg \\text{before}(y, t, x, s)$ \\hspace{1cm} (9)\n\n$\\text{before}(x, s, y, t) \\leftarrow \\text{chosen}_R(x, s, y, t, \\bar{w})$ \\hspace{1cm} (10)\n\nLike the old rule (3), rule (9) represents the messages that are sent, but now candidate arrival timestamps are restricted by relation $\\text{before}$ to enforce causality. Intuitively, this restriction prevents cycles from occurring in relation $\\text{before}$. This aligns with the semantics of a real distributed system, where the happens-before relation is a strict partial order (Attiya and Welch 2004) (see also Section 5.2.1).\n\nRule (10) adds the causal restriction that the local step of the sender happens before the arrival step of the addressee. Together with the previously introduced rules (7) and (8), this will make sure that when the addressee later causally replies to the sender, the reply — as generated by a rule of the form (9) — will arrive after this first send-step of the sender.\n\nRemark 1\n\nThe new program $\\text{pure}_{ca}(\\mathcal{P})$ excludes unintuitive models like the one in Section 4.3.3. In the context of that particular example, it will be impossible to exhibit a stable model of $\\text{pure}_{ca}(\\mathcal{P})$ in which $B()$ is sent to timestamp 0. Indeed, $B()$ can only be\nsent starting from timestamp 1; timestamp 0 at z (locally) happens before timestamp 1 at z; and, the negative before-literal in rule (9) will prevent sending from timestamp 1 at z to timestamp 0 at z. Also in scenarios where different nodes $x$ and $y$ send messages to each other, when node $x$ replies to a message of node $y$ sent at timestamp $s$ of $y$, node $x$ cannot send the reply to a timestamp $t$ of $y$ with $t < s$.\n\n### 4.4.2 Semantics\n\nThe semantics of the causality transformation is the same as for the dynamic choice transformation:\n\n**Definition 4.3**\n\nFor an input distributed database instance $H$ for $P$, we call any stable model of pure$_{ca}(P)$ on input decl($H$) a causal model of $P$ on input $H$.\n\n### 4.4.3 Possible Improvement\n\nWe illustrate a shortcoming of the causality transformation. Consider the Dedalus program $P$ in Figure 5. We assume that in each input distributed database, the $edb$ relation contact/1 contains intended recipients of messages. Relation $T$ serves as the output relation of $P$. The idea is that a node sends $A()$ to its recipients continuously. When $A()$ arrives, a recipient sets a local flag first(). Later, when a second $A()$ arrives, the recipient creates an output fact $T()$ that we remember by means of inductive rules. Intuitively, we expect that $T()$ is always created because the fact $A()$ is sent infinitely often to a recipient, making this recipient witness the arrival of $A()$ at (hopefully) two distinct moments.\n\nHowever, this intuition is violated by some causal models of $P$. Consider the input distributed database instance $H$ over a network ${x, y}$ that (only) assigns the fact $\\text{contact}(y)$ to $x$. Now, consider the following causal model $M$ of $P$ on $H$: \n\n$$M = \\text{decl}(H) \\cup M_{A}^{\\text{snd}} \\cup M_{A}^{\\text{rcv}} \\cup M_{\\text{before}},$$\n\nwhere \n\n$$M_{A}^{\\text{snd}} = \\{\\text{cand}_A(x, s, y, t) \\mid s, t \\in \\mathbb{N}\\} \\cup \\{\\text{chosen}_A(x, s, y, 0) \\mid s \\in \\mathbb{N}\\} \\cup \\{\\text{other}_A(x, s, y, t) \\mid s, t \\in \\mathbb{N}, t \\neq 0\\};$$\n\n$$M_{A}^{\\text{rcv}} = \\{A(y, 0)\\} \\cup \\{\\text{first}(y, s) \\mid s \\in \\mathbb{N}, s \\geq 1\\};$$\n\n$$M_{\\text{before}} = \\{\\text{before}(x, s, t) \\mid s, t \\in \\mathbb{N}, s < t\\} \\cup \\{\\text{before}(y, s, y, t) \\mid s, t \\in \\mathbb{N}, s < t\\} \\cup \\{\\text{before}(x, s, y, t) \\mid s, t \\in \\mathbb{N}\\}.$$ \n\n\\[12\\] Using straightforward arguments, it can be shown that $M$ is a stable model of pure$_{ca}(P)$ on decl($H$).\nIn this causal model, all instances of message \\( A() \\) that \\( x \\) sends to \\( y \\) arrive at timestamp 0 of \\( y \\). For this reason, node \\( y \\) can not witness two different arrivals of message \\( A() \\). In practice, however, node \\( y \\) can not receive an infinite number of messages during a timestamp, and the deliveries of the \\( A() \\) messages would be spread out more evenly in time. So, in the next subsection, we will additionally exclude such infinite message arrivals, to obtain our final transformation of Dedalus programs.\n\n### 4.5 Causality-Finiteness Transformation\n\nLet \\( \\mathcal{P} \\) be a Dedalus program. As seen in the previous subsection, program \\( \\text{pure}_{ca}(\\mathcal{P}) \\) allows an infinite number of messages to arrive at any step of a node. This does not happen in any real-world distributed system; indeed, no node has to process an infinite number of messages at any given moment. We consider this to be an additional restriction that must be explicitly enforced. To this purpose, we present in this section the causality-finiteness transformation \\( \\text{pure}(\\mathcal{P}) \\) that extends \\( \\text{pure}_{ca}(\\mathcal{P}) \\).\n\nWe will approach this problem as follows. Suppose there are an infinite number of messages that arrive at some node \\( y \\) during its step \\( t \\). Since in a network there are only a finite number of nodes and a node can only send a finite number of messages during each step (the input domain is finite), there must be at least one node \\( x \\) that sends messages to step \\( t \\) of \\( y \\) during an infinite number of steps of \\( x \\). Hence there is no maximum value amongst the corresponding send-timestamps of \\( x \\). Thus, in order to prevent the arrival of an infinite number of messages at step \\( t \\) of \\( y \\), it will be sufficient to demand that there always is such a maximum send-timestamp for every sender. Below, we will implement this strategy with some concrete rules in \\( \\text{pure}(\\mathcal{P}) \\).\n\n#### 4.5.1 Transformation\n\nWe define \\( \\text{pure}(\\mathcal{P}) \\) as \\( \\text{pure}_{ca}(\\mathcal{P}) \\) extended as follows. The additional rules can be thought of as being relative to an addressee and a step of this addressee, represented by the variables \\( y \\) and \\( t \\) respectively.\n\nWe use a fact \\( \\text{rcvInf}(y, t) \\) to express that node \\( y \\) receives an infinite number of messages during its step \\( t \\). First, we add the following rule to \\( \\text{pure}(\\mathcal{P}) \\) for each\n\n\\[ A() \\mid y \\leftarrow \\text{contact}(y). \\]\n\\[ \\text{first}() \\cdot \\leftarrow A(). \\]\n\\[ \\text{first}() \\cdot \\leftarrow \\text{first}(). \\]\n\\[ T() \\leftarrow \\text{first}(), A(). \\]\n\\[ T() \\cdot \\leftarrow T(). \\]\nrelation $\\text{chosen}_R$ that results from the transformation of asynchronous rules in $\\text{pure}_{ca}(\\mathcal{P})$, where $x$, $s$, $y$, and $t$ are variables and $\\overline{a}$ is a tuple of distinct variables disjoint from the previous ones with $|\\overline{a}|$ the arity of relation $R$ in $\\text{sch}(\\mathcal{P})$:\n\n$$\\text{hasSender}(y, t, x, s) \\leftarrow \\text{chosen}_R(x, s, y, t, \\overline{a}), \\neg \\text{rcvInf}(y, t).$$ \\hfill (11)\n\nThis rule intuitively means that as long as addressee $y$ has not received an infinite number of messages during its step $t$, we register the senders and their send-timestamps.\n\nRecall the auxiliary relations defined in Section 4.2. Next, we add to $\\text{pure}(\\mathcal{P})$ the following rules, for which the intuition is provided below:\n\n$$\\text{isSmaller}(y, t, x, s) \\leftarrow \\text{hasSender}(y, t, x, s), \\text{hasSender}(y, t, x, s'), s < s'. \\hfill (12)$$\n\n$$\\text{hasMax}(y, t, x) \\leftarrow \\text{hasSender}(y, t, x, s), \\neg \\text{isSmaller}(y, t, x, s). \\hfill (13)$$\n\n$$\\text{rcvInf}(y, t) \\leftarrow \\text{hasSender}(y, t, x, s), \\neg \\text{hasMax}(y, t, x). \\hfill (14)$$\n\nRule (12) checks for each sender and each of its send-timestamps whether there is a later send-timestamp of that same sender. Rule (13) tries to find a maximum send-timestamp. Finally, rule (14) derives a $\\text{rcvInf}$-fact if no maximum send-timestamp was found for at least one sender.\n\nWe will show in Section 5.3.1 that in any stable model, the above rules make sure that every node receives only a finite number of messages at every step.\n\n### 4.5.2 Semantics\n\nThe semantics of the causality-finiteness transformation is again the same as for the dynamic choice transformation and the causality transformation:\n\n**Definition 4.4**\n\nFor an input distributed database instance $H$ for $\\mathcal{P}$, we call any stable model of $\\text{pure}(\\mathcal{P})$ on input $\\text{decl}(H)$ a causal-finite model of $\\mathcal{P}$ on input $H$.\n\nWe will refer to a causal-finite model also simply as model.\n\n### 5 Correctness\n\nIn Section 4, we have described the computation of a distributed Datalog $\\neg$ program by means of stable models. By using suitable rules, we have excluded some unintuitive stable models. But at this point we are still not sure whether the remaining stable models really correspond to the execution of a distributed system. We fill that gap in this section: we show that each remaining stable model corresponds to an execution of the distributed Datalog $\\neg$ program under an operational semantics, and vice versa. We call such an execution a run, and we will only be concerned with so-called fair runs, where each node is made active infinitely often and all sent messages are eventually delivered.\n\nWe extract from each run $\\mathcal{R}$ a trace, denoted $\\text{trace}(\\mathcal{R})$, which is a set of facts\nthat shows in detail what each node computes during each step. We will make this concrete in the following subsections. But we can already state our main result, as follows:\n\n**Theorem 4**\n\nLet $P$ be a Dedalus program. For each input distributed database instance $H$ for $P$,\n\n(i) for every fair run $R$ of $P$ there is a model $M$ of $P$ such that $\\text{trace}(R) = M|_{\\text{sch}(P)^{\\downarrow \\tau}}$, and\n\n(ii) for every model $M$ of $P$ there is a fair run $R$ of $P$ such that $\\text{trace}(R) = M|_{\\text{sch}(P)^{\\downarrow \\tau}}$.\n\nFirst, Section 5.1 formalizes runs and traces of runs. The proof of item (i) of the theorem is described in Section 5.2. The proof of item (ii), which is the most difficult, is described in Section 5.3. We only describe the crucial reasoning steps of the proofs; the intricate technical details can be found in the online appendix to the paper.\n\n### 5.1 Operational Semantics\n\nIn this section, we give an operational semantics for Dedalus that is in line with earlier formal work on declarative networking (Deutsch et al. 2006; Navarro and Rybalchenko 2009; Grumbach and Wang 2010; Ameloot et al. 2011; Abiteboul et al. 2011).\n\nLet $P$ be a Dedalus program, and let $H$ be an input distributed database instance for $P$, over a network $N$. The essence of the operational semantics is as follows. Every node of $N$ runs program $P$, and a node has access only to its own local state and any received messages. The nodes are made active one by one in some arbitrary order, and this continues an infinite number of times. During each active moment of a node $x$, called a local (computation) step, node $x$ receives message facts and applies its deductive, inductive and asynchronous rules. Concretely, the deductive rules, forming a stratified Datalog$^{-}$ subprogram, are applied to the incoming messages and the previous state of $x$. Next, the inductive rules are applied to the output of the deductive subprogram, and these allow $x$ to store facts in its memory: these facts become visible in the next local step of $x$. Finally, the asynchronous rules are also applied to the output of the deductive subprogram, and these allow $x$ to send facts to the other nodes or to itself. These facts become visible at the addressee after some arbitrary delay, which represents asynchronous communication, as occurs for instance on the Internet. We assume that all messages are eventually delivered (and are thus never lost). We will refer to local steps simply as “steps”.\n\nWe make the above sketch more concrete in the next subsections.\n5.1.1 Configurations\n\nLet $\\mathcal{P}$, $H$, and $\\mathcal{N}$ be as above. A configuration describes the network at a certain point in its evolution. Formally, a configuration of $\\mathcal{P}$ on $H$ is a pair $\\rho = (st, bf)$ where\n\n- $st$ is a function mapping each node of $\\mathcal{N}$ to an instance over $sch(\\mathcal{P})$; and,\n- $bf$ is a function mapping each node of $\\mathcal{N}$ to a set of pairs of the form $(i, f)$, where $i \\in \\mathbb{N}$ and $f$ is a fact over $idb(\\mathcal{P})$.\n\nWe call $st$ and $bf$ the state and (message) buffer respectively. The state says for each node what facts it has stored in its memory, and the message buffer $bf$ says for each node what messages have been sent to it but that are not yet received. The reason for having numbers $i$, called send-tags, attached to facts in the image of $bf$ is merely a technical convenience: these numbers help separate multiple instances of the same fact when it is sent at different moments (to the same addressee), and these send-tags will not be visible to the Dedalus program. For example, if the buffer of a node $x$ simultaneously contains pairs $(3, f)$ and $(7, f)$, this means that $f$ was sent to $x$ during the operational network transitions with indices 3 and 7, and that both particular instances of $f$ are not yet delivered to $x$. This will become more concrete in Section 5.1.3.\n\nThe start configuration of $\\mathcal{P}$ on input $H$, denoted $\\text{start}(\\mathcal{P}, H)$, is the configuration $\\rho = (st, bf)$ defined by $st(x) = H(x)$ and $bf(x) = \\emptyset$ for each $x \\in \\mathcal{N}$. In words: for every node, the state is initialized with its local input fragment in $H$, and there are no sent messages.\n\n5.1.2 Subprograms\n\nWe look at the operations that are executed locally during each step of a node. We have mentioned that the three types of Dedalus rules each have their own purpose in the operational semantics. For this reason, we split the program $\\mathcal{P}$ into three subprograms, that contain respectively the deductive, inductive and asynchronous rules. In Section 5.1.3 we describe how these subprograms are used in the operational semantics.\n\n- First, we define $\\text{deduc}_\\mathcal{P}$ to be the Datalog program consisting of precisely all deductive rules of $\\mathcal{P}$.\n- Secondly, we define $\\text{induc}_\\mathcal{P}$ to be the Datalog program consisting of all inductive rules of $\\mathcal{P}$ after the annotation ‘•’ in their head is removed.\n- Thirdly, we define $\\text{async}_\\mathcal{P}$ to be the Datalog program consisting of precisely all rules\n\n$$T(y, \\bar{u}) \\leftarrow B\\{\\bar{u}, y\\}$$\n\nwhere\n\n$$T(\\bar{u}) \\mid y \\leftarrow B\\{\\bar{u}, y\\}$$\n\nis an asynchronous rule of $\\mathcal{P}$. So, we basically put the variable $y$ as the first\ncomponent in the (extended) head atom. The intuition for the generated head facts is that the first component will represent the addressee.\n\nNote that the programs \\(\\text{deduc}_P\\), \\(\\text{induc}_P\\) and \\(\\text{async}_P\\) are just Datalog\\(^*\\) programs over the schema \\(\\text{sch}(P)\\), or a subschema thereof. Moreover, \\(\\text{deduc}_P\\) is syntactically stratifiable because the deductive rules in every Dedalus program must be syntactically stratifiable. It is possible however that \\(\\text{induc}_P\\) and \\(\\text{async}_P\\) are not syntactically stratifiable. Now we define the semantics of each of these three subprograms.\n\nLet \\(I\\) be a database instance over \\(\\text{sch}(P)\\). During each step of a node, the intuition of the deductive rules is that they “complete” the available facts by adding all new facts that can be logically derived from them. This calls for a fixpoint semantics, and for this reason, we define the output of \\(\\text{deduc}_P\\) on input \\(I\\), denoted as \\(\\text{deduc}_P(I)\\), to be given by the stratified semantics. This implies \\(I \\subseteq \\text{deduc}_P(I)\\). Importantly, \\(I\\) is allowed to contain facts over \\(\\text{idb}(P)\\), and the intuition is that these facts were derived during a previous step (by inductive rules) or received as messages (as sent by asynchronous rules). This will become more explicit in Section 5.1.3.\n\nDuring each step of a node, the intuition behind the inductive rules is that they store facts in the memory of the node, and these stored facts will become visible during the next step. There is no notion of a fixpoint here because facts that will become visible in the next step are not available in the current step to derive more facts. For this reason, we define the output of \\(\\text{induc}_P\\) on input \\(I\\) to be the set of facts derived by the rules of \\(\\text{induc}_P\\) for all possible satisfying valuations in \\(I\\), in just one derivation step. This output is denoted as \\(\\text{induc}_P(I)\\).\n\nDuring each step of a node, the intuition behind the asynchronous rules is that they generate message facts that are to be sent around the network. The output for \\(\\text{async}_P\\) on input \\(I\\) is defined in the same way as for \\(\\text{induc}_P\\), except that we now use the rules of \\(\\text{async}_P\\) instead of \\(\\text{induc}_P\\). This output is denoted as \\(\\text{async}_P(I)\\). The intuition for not requiring a fixpoint for \\(\\text{async}_P\\) is that a message fact will arrive at another node, or at a later step of the sender node, and can therefore not be read during sending.\n\nRegarding data complexity (Vardi 1982), for each subprogram the output can be computed in \\(\\text{PTIME}\\) with respect to the size of its input.\n\n### 5.1.3 Transitions and Runs\n\nTransitions formalize how to go from one configuration to another. Here we use the subprograms of \\(P\\). Transitions are chained to form a run. Regarding notation, for a set \\(m\\) of pairs of the form \\((i, f)\\), we define \\(\\text{untag}(m) = \\{f \\mid \\exists i \\in \\mathbb{N} : (i, f) \\in m\\}\\).\n\nA transition with send-tag \\(i \\in \\mathbb{N}\\) is a five-tuple \\((\\rho_a, x, m, i, \\rho_b)\\) such that \\(\\rho_a = (\\text{st}_a, \\text{bf}_a)\\) and \\(\\rho_b = (\\text{st}_b, \\text{bf}_b)\\) are configurations of \\(P\\) on input \\(H\\), \\(x \\in \\mathcal{N}\\), \\(m \\subseteq \\text{bf}_a(x)\\), and, letting\n\n\\[\nI = \\text{st}_a(x) \\cup \\text{untag}(m),\nD = \\text{deduc}_P(I),\n\\delta^{i \\rightarrow y} = \\{(i, R(\\bar{a})) \\mid R(y, \\bar{a}) \\in \\text{async}_P(D)\\}\n\\]\n\nfor each \\(y \\in \\mathcal{N}\\),\nfor $x$ and each $y \\in \\mathcal{N} \\setminus \\{x\\}$ we have\n\n$$\n\\begin{align*}\nst_b(x) &= H(x) \\cup \\text{induc}_P(D), \\\\\nbf_b(x) &= (bf_a(x) \\setminus m) \\cup \\delta^{i\\rightarrow x},\n\\end{align*}\n$$\n\n$$\n\\begin{align*}\nst_b(y) &= st_a(y), \\\\\nbf_b(y) &= bf_a(y) \\cup \\delta^{i\\rightarrow y}.\n\\end{align*}\n$$\n\nWe call $\\rho_a$ and $\\rho_b$ respectively the source and target configuration, and say this transition is of the active node $x$. Intuitively, the transition expresses that $x$ reads its old state together with the received facts in $\\text{untag}(m)$ (thus without the tags), and describes the subsequent computation: subprogram $\\text{deduc}_P$ completes the available information; the new state of $x$ consists of the input facts of $x$ united with all facts derived by subprogram $\\text{induc}_P$; and, subprogram $\\text{async}_P$ generates messages, whose first component indicates the addressee.\n\nNote, $\\text{induc}_P$ and $\\text{async}_P$ do not influence each other, and can be thought of as being executed in parallel. Also, for each $y \\in \\mathcal{N}$, the set $\\delta^{i\\rightarrow y}$ contains all messages addressed to $y$, with send-tag $i$ attached. Messages with an addressee outside the network are ignored. This way of defining local computation closely corresponds to that of the language Webdamlog (Abiteboul et al. 2011). If $m = \\emptyset$, we call the transition a heartbeat.\n\nA run $R$ of $\\mathcal{P}$ on input $H$ is an infinite sequence of transitions, such that (i) the source configuration of the first transition is $\\text{start}(\\mathcal{P}, H)$, (ii) the target configuration of each transition is the source configuration of the next transition, and (iii) the transition at ordinal $i$ of the sequence uses send-tag $i$. Ordinals start at 0 for technical convenience. The resulting transition system is highly non-deterministic because in each transition we can choose the active node and also what messages to deliver; the latter choice is represented by the set $m$ from above.\n\n**Remark 2 (Parallel transitions)**\nTransitions as defined here can simulate parallel transitions in which multiple nodes are active at the same time and receive messages from their respective buffers. Indeed, if we would have multiple nodes active during a parallel transition, they would receive messages from their buffers in isolation, and this can be represented by a chain of transitions in which these nodes receive one after the other precisely the messages that they received in the parallel transition. For this reason, we limit our attention to transitions with single active nodes.\n\n### 5.1.4 Fairness and Arrival Function\n\nIn the literature on process models it is customary to require certain fairness conditions on the execution of a system, for instance to exclude some extreme situations that are expected not to happen in reality (Francez 1986; Apt et al. 1988; Lamport 2000b).\n\nLet $\\mathcal{R}$ be a run of $\\mathcal{P}$ on $H$. For every transition $i \\in \\mathbb{N}$, let $\\rho_i = (st_i, bf_i)$ denote the source configuration of transition $i$. Now, $\\mathcal{R}$ is called fair if:\n\n- every node is the active node in an infinite number of transitions of $\\mathcal{R}$; and,\n\n\\[13\\] Note, input facts are preserved by the transition. This aligns with the design of Dedalus, where we do not allow facts to be retracted; only negation as failure is permitted.\nfor every transition $i \\in \\mathbb{N}$, for every $y \\in \\mathcal{N}$, for every pair $(j, f) \\in bf_i(y)$, there is a transition $k$ with $i \\leq k$ in which $(j, f)$ is delivered to $y$.\n\nIntuitively, the fairness conditions disallow starvation: every node does an infinite number of local computation steps and every sent message is eventually delivered. We consider only fair runs in this paper. Note, a fair run exists for every input because heartbeats remain possible even when there are no messages to deliver.\n\nIn the second condition about message deliveries, it is possible that $k = i$, and in that case $(j, f)$ is delivered in the transition immediately following configuration $\\rho_i$. Because the pair $(j, f)$ can be in the message buffer of multiple nodes, this $k$ is not unique for the pair $(j, f)$ by itself. But, when we also consider the addressee $y$, it follows from the operational semantics that this $k$ is unique for the triple $(j, y, f)$.\n\nThis reasoning gives rise to a function $\\alpha_R$, called the arrival function for $R$, that is defined as follows: for every transition $i$, for every node $y$, for every message $f$ sent to addressee $y$ during $i$, the function $\\alpha_R$ maps $(i, y, f)$ to the transition ordinal $k$ in which $(i, f)$ is delivered to $y$. We always have $\\alpha_R(i, y, f) > i$. Indeed, the delivery of a message can only happen after it was sent. So, when the delivery of one message causes another to be sent, then the second one is delivered in a later transition. This is related to the topic of causality that we have introduced in Section 4. This topic will also be further discussed in Sections 5.2 and 5.3.\n\n5.1.5 Timestamps and Trace\n\nFor each transition $i$ of a run, we define the timestamp of the active node $x$ during $i$ to be the number of transitions of $x$ that come strictly before $i$. This can be thought of as the local (zero-based) clock of $x$ during $i$, and is denoted $loc_R(i)$. For example, suppose we have the following sequence of active nodes: $x, y, y, x, x, x, y$, etc. If we would write the timestamps next to the nodes, we get this sequence: $(x, 0), (y, 0), (y, 1), (x, 1), (x, 2), x$, etc.\n\nAs a counterpart to function $loc_R(\\cdot)$, for each $(x, s) \\in \\mathcal{N} \\times \\mathbb{N}$ we define $glob_R(x, s)$ to be the transition ordinal $i$ of $R$ such that $x$ is the active node in transition $i$ and $loc_R(i) = s$. In words: we find the transition in which node $x$ does its local computation step with timestamp $s$. It follows from the definition of $loc_R(\\cdot)$ that $glob_R(x, s)$ is uniquely defined.\n\nLet $R$ be a run of $P$ on input $H$. Recall that $H$ is over network $\\mathcal{N}$. We now capture the computed data during $R$ as a set of facts that we call the trace. For each transition $i \\in \\mathbb{N}$, let $x_i$ denote the active node, and let $D_i$ denote the output of subprogram $deduc_P$ during $i$. The operational semantics implies that $D_i$ consists of (i) the input $edb$-facts at $x_i$; (ii) the inductively derived facts during the previous step of $x_i$ (if $loc_R(i) \\geq 1$); (iii) the messages delivered during transition $i$; and, (iv) all facts deductively derived from the previous ones. So, intuitively, $D_i$ contains all local facts over $sch(P)$ that $x_i$ has during transition $i$. \nRecall the notations of Section 4.2. Now, the trace of $R$ is the following instance over $\\text{sch}(P)^{LT}$:\n\n$$\\text{trace}(R) = \\bigcup_{i \\in \\mathbb{N}} D^\\uparrow_{i, \\text{loc}_R(i)}.$$ \n\nThe trace shows in detail what happens in the run, in terms of what facts are available on the nodes during which of their steps.\n\n5.2 Run to Model\n\nLet $P$ be a Dedalus program and let $H$ be an input distributed database instance for $P$, over a network $\\mathcal{N}$. Let $R$ be a fair run of $P$ on input $H$. We show there is a model $M$ of $P$ on $H$ such that $\\text{trace}(R) = M|_{\\text{sch}(P)^{LT}}$. The main idea is that we translate the transitions of $R$ to facts over the schema of $\\text{pure}(P)$.\n\nFirst, in Section 5.2.1, we extract the happens-before relation on nodes and timestamps from $R$. Next, in Section 5.2.2, we define the desired model $M$.\n\n5.2.1 Happens-before Relation\n\nIn the operational semantics, we order the actions of the nodes on a fine-grained global time axis, by ordering the transitions in the runs. By contrast, we now define a partial order on $\\mathcal{N} \\times \\mathcal{N}$, saying which steps of nodes must have come before which steps of (other) nodes, without referring to the global ordering imposed by transitions.\n\nFirst, we extract from $R$ the message sending and receiving events. Formally, we define $\\text{mesg}(R)$ to be the set of all tuples $(x, s, y, t, f)$, with $f$ a fact, and denoting $i = \\text{glob}_R(x, s)$ and $j = \\text{glob}_R(y, t)$, such that $\\alpha_R(i, y, f) = j$, i.e., node $x$ during step $s$ sends message $f$ to $y$ that arrives at the step $t$ of $y$, with possibly $x = y$. In words: $\\text{mesg}(R)$ contains the direct relationships between local steps of nodes that arise through message sending.\n\nFrom $R$ we can now extract the happens-before relation $\\prec_R$ on the set $\\mathcal{N} \\times \\mathcal{N}$, which is defined as the smallest relation $\\prec_R$ on $\\mathcal{N} \\times \\mathcal{N}$ that satisfies the following three conditions:\n\n- for each $(x, s) \\in \\mathcal{N} \\times \\mathcal{N}$, we have $(x, s) \\prec_R (x, s + 1)$;\n- $(x, s) \\prec_R (y, t)$ whenever for some fact $f$ we have $(x, s, y, t, f) \\in \\text{mesg}(R)$;\n- $\\prec_R$ is transitive, i.e., $(x, s) \\prec_R (z, u) \\prec_R (y, t)$ implies $(x, s) \\prec_R (y, t)$.\n\nWe call these three cases respectively local edges, message edges and transitive edges. Naturally, the first two cases express a direct relationship, whereas the third case is more indirect.\n\nNote, if two runs on the same input have the same happens-before relation, they do not necessarily have the same trace. This is because relation $\\prec_R$ does not talk about the specific messages that arrive at the nodes.\n\nWe will now show that $\\prec_R$ is a strict partial order. Consider first the following property:\nLemma 1\nFor every run $R$, for each $(x, s) \\in N \\times N$ and $(y, t) \\in N \\times N$, if $(x, s) \\prec_R (y, t)$ then $\\text{glob}_R(x, s) < \\text{glob}_R(y, t)$.\n\nProof\nWe can consider a path from $(x, s)$ to $(y, t)$ in $\\prec_R$. We can substitute each transitive edge in this path with a subpath of non-transitive edges. This results in a path of only non-transitive edges:\n\n$$(x_1, s_1) \\prec_R (x_2, s_2) \\prec_R \\ldots \\prec_R (x_n, s_n),$$\n\nwhere $n \\geq 2$, $(x_1, s_1) = (x, s)$ and $(x_n, s_n) = (y, t)$. Because there are no transitive edges, for each $i \\in \\{1, \\ldots, n - 1\\}$, the edge $(x_i, s_i) \\prec_R (x_{i+1}, s_{i+1})$ falls into one of the following two cases:\n\n- $x_i = x_{i+1}$ and $s_{i+1} = s_i + 1$ (local edge);\n- $x_i$ during step $s_i$ sends a message to $x_{i+1}$ that arrives in step $s_{i+1}$ of $x_{i+1}$ (message edge).\n\nIn the first case, it follows from the definition of $\\text{loc}_R(\\cdot)$ that\n\n$$\\text{glob}_R(x_i, s_i) < \\text{glob}_R(x_{i+1}, s_{i+1}).$$\n\nFor the second case, by our operational semantics, every message is always delivered in a later transition than the one in which it was sent. So, again we have\n\n$$\\text{glob}_R(x_i, s_i) < \\text{glob}_R(x_{i+1}, s_{i+1}).$$\n\nSince this property holds for all the above edges, by transitivity we thus have $\\text{glob}_R(x, s) < \\text{glob}_R(y, t)$, as desired.\n\nCorollary 1\nFor every run $R$, the relation $\\prec_R$ is a strict partial order on $N \\times N$.\n\nProof\nFrom its definition, we immediately have that $\\prec_R$ is transitive. Secondly, irreflexivity for $\\prec_R$ follows from Lemma 1.\n\n5.2.2 Definition of $M$\nNow we define the model $M$:\n\n$$M = \\text{DECL}(H) \\cup \\bigcup_{i \\in \\mathbb{N}} \\text{trans}_R^{[i]},$$\n\nwhere $\\text{trans}_R^{[i]}$ for each $i \\in \\mathbb{N}$ is an instance over the schema of $\\text{pure}(\\mathcal{P})$ that describes transition $i$ of $R$. Let $i \\in \\mathbb{N}$. We define $\\text{trans}_R^{[i]}$ as\n\n$$\\text{trans}_R^{[i]} = \\text{caus}_R^{[i]} \\cup \\text{fin}_R^{[i]} \\cup \\text{duc}_R^{[i]} \\cup \\text{snd}_R^{[i]},$$\n\n14 Note, $M$ must include the input $\\text{DECL}(H)$ by definition of stable model (see Section 3.2.3).\nwhere each of these sets focuses on different aspects of transition $i$, and they are defined next. Regarding notation, let $\\prec_R$ be the happens-before relation as defined in the preceding subsection; let $loc_R(\\cdot)$, $glob_R(\\cdot)$, and $\\alpha_R$ be as defined in Section 5.1; let $x_i$ denote the active node of transition $i$; and, let us abbreviate $s_i = loc_R(i)$.\n\n**Causality** We define $\\text{caus}[^i]_R$ to consist of all facts $\\text{before}(x, s, x_i, s_i)$ for which $(x, s) \\in N \\times N$ and $(x, s) \\prec_R (x_i, s_i)$. Intuitively, $\\text{caus}[^i]_R$ represents the joint result of rules $[7]$, $[8]$, and $[10]$, corresponding to respectively the local edges, transitive edges, and message edges of $\\prec_R$.\n\n**Finite Messages** We define $\\text{fin}[^i]_R$ to consist of only a finite number of messages are delivered in transition $i$, thus at step $s_i$ of node $x_i$. We proceed as follows. First, let $\\text{senders}[^i]_R$ be the set of all pairs $(x, s) \\in N \\times N$ such that, denoting $j = glob_R(x, s)$, for some fact $f$ we have $\\alpha_R(j, x_i, f) = i$, i.e., the node $x$ during its step $s$ sends a message to $x_i$ with arrival timestamp $s_i$. It follows from the operational semantics that for each $(x, s) \\in \\text{senders}[^i]_R$ we have $glob_R(x, s) < i$.\n\nNow, we define $\\text{fin}[^i]_R$ to consist of the following facts:\n\n- the fact $\\text{hasSender}(x_i, s_i, x, s)$ for each $(x, s) \\in \\text{senders}[^i]_R$, representing the result of rule $[11]$;\n- the fact $\\text{isSmaller}(x_i, s_i, x, s)$ for each $(x, s) \\in \\text{senders}[^i]_R$ and $(x, s') \\in \\text{senders}[^i]_R$ with $s < s'$, representing the result of rule $[12]$; and,\n- the fact $\\text{hasMax}(x_i, s_i, x)$ for each sender-node $x$ mentioned in $\\text{senders}[^i]_R$, representing the result of rule $[13]$.\n\nWe know that in $\\mathcal{R}$ only a finite number of messages arrive at step $s_i$ of $x_i$. Hence, we add no fact $\\text{rcvInf}(x_i, s_i)$ to $\\text{fin}[^i]_R$. This also explains why the specification of the $\\text{hasMax}$-facts above is relatively simple: there is always a maximum send-timestamp for each sender-node.\n\n**Deductive** Let $D_i$ denote the output of subprogram $\\text{deduc}_P$ during transition $i$. We define $\\text{duc}[^i]_R$ to consist of the facts $D_i \\otimes s_i, x_i, h$. Intuitively, $\\text{duc}[^i]_R$ represents all facts over $\\text{sch}(\\mathcal{P})$ that are available at $x_i$ during step $s_i$, i.e., the joint result of rules in $\\text{pure}(\\mathcal{P})$ of the form $[1]$, $[2]$ and $[6]$.\n\n**Sending** We define $\\text{snd}[^i]_R$ to represent the sending of messages during transition $i$. We proceed as follows. Let $\\text{msg}[^i]_R$ denote the output of subprogram $\\text{async}_P$ during transition $i$, restricted to the facts having their addressee-component in the network. Now, we define $\\text{snd}[^i]_R$ to consist of the following facts:\n\n- all facts $\\text{cand}_R(x_i, s_i, y, t, \\bar{a})$ for which $R(y, \\bar{a}) \\in \\text{msg}[^i]_R$ and $t \\in N$ such that $(y, t) \\not\\prec_R (x_i, s_i)$, representing the result of rule $[9]$;\n- all facts $\\text{chosen}_R(x_i, s_i, y, t, \\bar{a})$ for which $R(y, \\bar{a}) \\in \\text{msg}[^i]_R$ and $t = loc_R(j)$ with $j = \\alpha_R(i, y, R(\\bar{a}))$, representing the result of rule $[4]$; and,\n- all facts $\\text{other}_R(x_i, s_i, y, u, \\bar{a})$ for which $R(y, \\bar{a}) \\in \\text{msg}[^i]_R$, $u \\in N$, $(y, u) \\not\\prec_R (x_i, s_i)$ and $u \\neq loc_R(j)$ with $j = \\alpha_R(i, y, R(\\bar{a}))$, representing the result of rule $[5]$. \n\nAmeloot et al.\nConclusion We can show that $M$ is indeed a model of $P$ on input $H$; this proof can be found in Appendix A of the online appendix to the paper. By construction of $M$, we have, as desired:\n\n$$M|_{sch(P)\\cup T} = \\bigcup_{i \\in \\mathbb{N}} \\Delta^{[i]}_R = \\bigcup_{i \\in \\mathbb{N}} D^{[i]}_{t,s,i} = trace(R).$$\n\n5.3 Model to Run\n\nLet $P$ be a Dedalus program and let $H$ be an input distributed database instance for $P$, over some network $\\mathcal{N}$. Let $M$ be a model of $P$ on input $H$. We show there is a fair run $R$ of $P$ on input $H$ such that $trace(R) = M|_{sch(P)\\cup T}$.\n\nThe direction shown in Section 5.2 is perhaps the most intuitive direction because we only have to show that a concrete set of facts is actually a stable model. In this section we do not yet understand what $M$ can contain. So, a first important step is to show that $M$ has some desirable properties which allow us to construct a run from it.\n\nUsing the notation from Section 3.2.3, let $G$ abbreviate the ground program $\\text{ground}_M(C, I)$ where $C = \\text{pure}(P)$ and $I = \\text{decl}(H)$. By definition of $M$ as a stable model, we have $M = G(I)$.\n\nFirst, it is important to know that in $M$ we find location specifiers where we expect location specifiers and we find timestamps where we expect timestamps. Formally, we call $M$ well-formed if:\n\n- for each $R(x, s, \\bar{a}) \\in M|_{sch(P)\\cup T}$ we have $x \\in \\mathcal{N}$ and $s \\in \\mathbb{N}$;\n- for each $\\text{before}(x, s, y, t) \\in M$, we have $x, y \\in \\mathcal{N}$ and $s, t \\in \\mathbb{N}$;\n- for each fact $\\text{cand}_R(x, s, y, t, \\bar{a})$, $\\text{chosen}_R(x, s, y, t, \\bar{a})$ and $\\text{other}_R(x, s, y, t, \\bar{a})$ in $M$, we have $x, y \\in \\mathcal{N}$ and $s, t \\in \\mathbb{N}$;\n- for each fact $\\text{hasSender}(x, s, y, t)$, $\\text{isSmaller}(x, s, y, t)$, $\\text{hasMax}(x, s, y)$ and $\\text{rcvInf}(x, s)$ in $M$, we have $x, y \\in \\mathcal{N}$ and $s, t \\in \\mathbb{N}$.\n\nIt can be shown by induction on the fixpoint computation of $G$ that $M$ is always well-formed. We omit the details.\n\nThe rest of this subsection is organized as follows. In Section 5.3.1 we extract a happens-before relation $\\prec_M$ from $M$. Next, in Section 5.3.2 we construct a run $R$: we use $\\prec_M$ to establish a total order on $\\mathcal{N} \\times \\mathbb{N}$ that tells us which are the active nodes in the transitions of $R$. Finally, we show in Section 5.3.3 that $R$ is fair.\n\n5.3.1 Partial Order\n\nWe define the following relation $\\prec_M$ on $\\mathcal{N} \\times \\mathbb{N}$: for each $(x, s) \\in \\mathcal{N} \\times \\mathbb{N}$ and $(y, t) \\in \\mathcal{N} \\times \\mathbb{N}$, we write $(x, s) \\prec_M (y, t)$ if and only if $\\text{before}(x, s, y, t) \\in M$. The rest of this section is dedicated to showing that $\\prec_M$ is a well-founded strict partial order on $\\mathcal{N} \\times \\mathbb{N}$.\n\nLet $G$ abbreviate the ground program $\\text{ground}_M(C, I)$ where $C = \\text{pure}(P)$ and $I = \\text{decl}(H)$. Regarding terminology, an edge $(x, s) \\prec_M (y, t)$ is called a local edge, a message edge or a transitive edge if the fact $\\text{before}(x, s, y, t) \\in M$ can be derived\nby a ground rule in $G$ of respectively the form 1, the form 10, or the form 8 15. It is possible that an edge is of two or even three types at the same time.\n\nConsider the following claim:\n\nClaim 5\nRelation $\\prec_M$ is a strict partial order on $N \\times N$.\n\nProof\nWe show that $\\prec_M$ is transitive and irreflexive.\n\nTransitive First, we show that $\\prec_M$ is transitive. Suppose we have $(x, s) \\prec_M (z, u)$ and $(z, u) \\prec_M (y, t)$. We have to show that $(x, s) \\prec_M (y, t)$. By definition of $\\prec_M$, we have before$(x, s, z, u) \\in M$ and before$(z, u, y, t) \\in M$. Because rule 8 is positive, we have the following ground rule in $G$:\n\n$$\\text{before}(x, s, y, t) \\leftarrow \\text{before}(x, s, z, u), \\text{before}(z, u, y, t).$$\n\nBecause $M$ is a stable model and the body of the previous ground rule is in $M$, we obtain before$(x, s, y, t) \\in M$. Hence, $(x, s) \\prec_M (y, t)$, as desired.\n\nIrreflexive Because an edge $(x, s) \\prec_M (x, s)$ for any $(x, s) \\in N \\times N$ would form a cycle of length one, it is sufficient to show that there are no cycles in $\\prec_M$ at all. This gives us irreflexivity, as desired.\n\nFirst, let $\\prec'_M$ denote the restriction of $\\prec_M$ to the edges that are local or message edges. Note that this definition allows some edges in $\\prec'_M$ to also be transitive. The edges that are missing from $\\prec'_M$ with respect to $\\prec_M$ are only derivable by ground rules of the form 8; we call these the pure transitive edges. We start by showing that $\\prec'_M$ contains no cycles. We show this with a proof by contradiction. So, suppose that there is a cycle in $N \\times N$ through the edges of $\\prec'_M$:\n\n$$(x_1, s_1) \\prec_M (x_2, s_2) \\prec_M \\ldots \\prec_M (x_n, s_n)$$\n\nwith $n \\geq 2$ and $(x_1, s_1) = (x_n, s_n)$. We have before$(x_i, s_i, x_{i+1}, s_{i+1}) \\in M$ for each $i \\in \\{1, \\ldots, n-1\\}$. Based on these before-facts, ground rules in $G$ of the form 8 will have derived before$(x_i, s_i, x_j, s_j) \\in M$ for each $i, j \\in \\{1, \\ldots, n\\}$.\n\nIf each edge on the above cycle would be only local, then for each $i, j \\in \\{1, \\ldots, n\\}$ with $i < j$ we have $x_i = x_j$ and $s_i < s_j$, and hence $s_i \\neq s_n$, which is false. So, there has to be some $k \\in \\{1, \\ldots, n-1\\}$ such that $(x_k, s_k) \\prec_M (x_{k+1}, s_{k+1})$ is a message edge, derived by a ground rule of the form 10:\n\n$$\\text{before}(x_k, s_k, x_{k+1}, s_{k+1}) \\leftarrow \\text{chosen}_R(x_k, s_k, x_{k+1}, s_{k+1}, \\bar{a}).$$\n\nTherefore chosen$_R(x_k, s_k, x_{k+1}, s_{k+1}, \\bar{a}) \\in M$. This chosen$_R$-fact must be derived by a ground rule of the form 4 in $G$, which implies that\n\n$$\\text{cand}_R(x_k, s_k, x_{k+1}, s_{k+1}, \\bar{a}) \\in M.$$ \n\nThis cand$_R$-fact must in turn be derived by a ground rule $\\psi$ of the form 9.\n\n15 The body of such a ground rule has to be in $M$. \n\nAmeloot et al.\nBecause rules of the form (8) in \\( \\text{pure}(P) \\) contain a negative before-atom in their body, the presence of \\( \\psi \\) in \\( G \\) requires that \\( \\text{before}(x_{k+1}, s_{k+1}, x_k, s_k) \\notin M \\). But that is a contradiction, because \\( \\text{before}(x_i, s_i, x_j, s_j) \\in M \\) for each \\( i,j \\in \\{1,\\ldots,n\\} \\) (see above).\n\nNow we show there are no cycles in the entire relation \\( \\prec_M \\). Since \\( M = G(\\text{decl}(H)) \\), we have \\( M = \\bigcup_{i \\in \\mathbb{N}} M_i \\) where \\( M_0 = \\text{decl}(H) \\) and \\( M_i = T(M_{i-1}) \\) for each \\( i \\geq 1 \\) where \\( T \\) is the immediate consequence operator of \\( G \\). By induction on \\( i \\), we show that an edge \\( \\text{before}(x, s, y, t) \\in M_i \\) either is a local or message edge, or it can be replaced by a path of local or message edges in \\( M_i \\). Then any cycle in \\( \\prec_M \\) would imply there is a cycle in \\( \\prec_M \\), which is impossible. So, \\( \\prec_M \\) can not contain cycles.\n\nNow, this induction property is satisfied for the base case because \\( M_0 \\) does not contain before-facts. For the induction hypothesis, assume the property holds for \\( M_{i-1} \\), where \\( i \\geq 1 \\). For the inductive step, let \\( \\text{before}(x, s, y, t) \\in M_i \\setminus M_{i-1} \\). If this fact is derived by a ground rule of the form (7) or (10) then the property is satisfied. Now suppose the fact is derived by a ground rule of the form (8):\n\n\\[\n\\text{before}(x, s, y, t) \\leftarrow \\text{before}(x, s, z, u), \\text{before}(z, u, y, t).\n\\]\n\nBoth body facts are in \\( M_{i-1} \\), implying \\( M_{i-1} \\) contains a path of local or message edges from \\( (x, s) \\) to \\( (z, u) \\) and from \\( (z, u) \\) to \\( (y, t) \\). Hence, using \\( M_{i-1} \\subseteq M_i \\), the edge \\( \\text{before}(x, s, y, t) \\in M_i \\) can be replaced by a path of local or message edges in \\( M_i \\).\n\nIn Section 4.3 we have added extra rules to \\( \\text{pure}(P) \\) to enforce that every node only receives a finite number of messages during each step. We now verify that this works correctly:\n\n**Claim 6**\n\nFor each \\( (y, t) \\in \\mathcal{N} \\times \\mathbb{N} \\) there are only a finite number of pairs \\( (x, s) \\in \\mathcal{N} \\times \\mathbb{N} \\) such that \\( (x, s) \\prec_M (y, t) \\) is a message edge.\n\n**Proof**\n\nWe start by noting that \\( M \\) does not contain the fact \\( \\text{rcvInf}(y, t) \\). Indeed, in order to derive this fact, we need a ground rule in \\( G \\) of the form (14), which has a body fact of the form \\( \\text{hasSender}(y, t, x, s) \\). Such \\( \\text{hasSender} \\)-facts must be generated by ground rules in \\( G \\) of the form (11). The rule (11) negatively depends on relation \\( \\text{rcvInf} \\). Thus, specifically, if we want a ground rule in \\( G \\) that can derive \\( \\text{hasSender}(y, t, x, s) \\), we should require the absence of \\( \\text{rcvInf}(y, t) \\) from \\( M \\). So \\( \\text{rcvInf}(y, t) \\in M \\) requires \\( \\text{rcvInf}(y, t) \\notin M \\), which is impossible.\n\nThe rest of the proof works towards a contradiction. So, suppose that \\( (y, t) \\) has an infinite number of incoming message edges. Because there are only a finite number of nodes in \\( \\mathcal{N} \\), there has to be a node \\( x \\) that has an infinite number of timestamps \\( s \\) such that \\( \\text{before}(x, s, y, t) \\in M \\) is a message edge. Since it is a message edge, such a fact \\( \\text{before}(x, s, y, t) \\) can be generated by a ground rule in \\( G \\) of the form (10), which implies that there is a relation \\( R \\) in \\( \\text{idb}(P) \\) and a tuple \\( a \\) such that \\( \\text{chosen}_R(x, s, y, t, a) \\in M \\). Because \\( \\text{rcvInf}(y, t) \\notin M \\) (see above), for each of\nthese \\textit{chosen}_R-facts, there is a ground rule of the form (11) in \\( M \\) that derives \\( \\text{hasSender}(y, t, x, s) \\in M \\).\n\nRule (14) has a negative \\textit{hasMax}-atom in its body. If we can show that \\( \\text{hasMax}(y, t, x) \\notin M \\), then there will be a ground rule in \\( G \\) of the form (14), where \\( \\text{hasSender}(y, t, x, s) \\in M \\):\n\n\\[\n\\text{rcvInf}(y, t) \\leftarrow \\text{hasSender}(y, t, x, s).\n\\]\n\nThis then causes \\( \\text{rcvInf}(y, t) \\in M \\), giving the desired contradiction.\n\nAlso towards a proof by contradiction, suppose that \\( \\text{hasMax}(y, t, x) \\in M \\). This means that there is a ground rule \\( \\psi \\) in \\( G \\) of the form (13):\n\n\\[\n\\text{hasMax}(y, t, x) \\leftarrow \\text{hasSender}(y, t, x, s).\n\\]\n\nBecause the rule (13) contains a negative \\textit{isSmaller}-atom in the body, and because \\( \\psi \\in G \\), we know that \\( \\text{isSmaller}(y, t, x, s) \\notin M \\). But because there are infinitely many facts of the form \\( \\text{hasSender}(y, t, x, s') \\in M \\), there is at least one fact \\( \\text{hasSender}(y, t, x, s') \\in M \\) with \\( s < s' \\). Moreover, the rule (12) is positive, and therefore the following ground rule is always in \\( G \\):\n\n\\[\n\\text{isSmaller}(y, t, x, s) \\leftarrow \\text{hasSender}(y, t, x, s), \\text{hasSender}(y, t, x, s'), s < s'.\n\\]\n\nSince the body of this ground rule is in \\( M \\), the rule derives \\( \\text{isSmaller}(y, t, x, s) \\in M \\), which gives the desired contradiction.\n\nAn ordering \\( \\prec \\) on a set \\( A \\) is called \\textit{well-founded} if for each \\( a \\in A \\), there are only a finite number of elements \\( b \\in A \\) such that \\( b \\prec a \\). We now use Claim 6 to show:\n\n\\textbf{Claim 7}\n\nRelation \\( \\prec_M \\) on \\( \\mathcal{N} \\times \\mathbb{N} \\) is well-founded.\n\n\\textbf{Proof}\n\nLet \\( (x, s) \\in \\mathcal{N} \\times \\mathbb{N} \\). We have to show that there are only a finite number of pairs \\( (y, t) \\in \\mathcal{N} \\times \\mathbb{N} \\) such that \\( (y, t) \\prec_M (x, s) \\). Technically, we can limit our attention to paths in \\( \\prec_M \\) consisting of local edges and message edges, because if we can show that there are only a finite number of predecessors of \\( (x, s) \\) on such paths, then there are only a finite number of predecessors when we include the transitive edges as well. First we show that every pair \\( (y, t) \\in \\mathcal{N} \\times \\mathbb{N} \\) has only a finite number of incoming local and message edges. If \\( t > 0 \\), we can immediately see that \\( (y, t) \\) has precisely one incoming local edge, as created by a ground rule of the form (7), and if \\( t = 0 \\) then \\( (y, t) \\) has no incoming local edge. Also, Claim 6 tells us that \\( (y, t) \\) has only a finite number of incoming message edges. So, the number of incoming local and message edges in \\( (y, t) \\) is finite.\n\nLet \\( (y, t) \\in \\mathcal{N} \\times \\mathbb{N} \\) be a pair such that \\( (y, t) \\prec_M (x, s) \\) is a local edge or a message edge. Starting in \\( (x, s) \\), we can follow this edge backwards so that we reach \\( (y, t) \\). If \\( (y, t) \\) itself has incoming local or message edges, from \\( (y, t) \\) we can again follow an edge backwards. This way we can incrementally construct backward paths starting from \\( (x, s) \\). Because at each pair of \\( \\mathcal{N} \\times \\mathbb{N} \\) there are only a finite number of incoming local or message edges (shown above), if \\( (x, s) \\) would have an infinite number of\npredecessors, we must be able to construct a backward path of infinite length. We now show that the existence of such an infinite path leads to a contradiction. So, suppose that there is a backward path of infinite length. Because there are only a finite number of nodes in the network \\( \\mathcal{N} \\), there must be a node \\( y \\) that occurs infinitely often on this path. We will now show that, as we progress further along the backward path, we must see the local timestamps of \\( y \\) strictly decrease. Hence, we must eventually reach timestamp 0 of \\( y \\), after which we cannot decrement the timestamps of \\( y \\) anymore, and thus it is impossible that \\( y \\) occurs infinitely often along the path. Suppose that the timestamps of \\( y \\) do not strictly decrease. There are two cases. First, if the same pair \\((y, t)\\) would occur twice on the path, we would have a cycle in \\( \\prec_M \\), which is not possible by Claim 5. Secondly, suppose that there are two timestamps \\( t \\) and \\( t' \\) of \\( y \\) such that \\( t < t' \\) and \\((y, t)\\) occurs before \\((y, t')\\) on the backward path, meaning that \\((y, t)\\) lies closer to \\((x, s)\\). Because the edges were followed in reverse, we have\n\n\\[\n(y, t') \\prec_M \\ldots \\prec_M (y, t).\n\\]\n\nBut since \\( t < t' \\), by means of local edges, we always have\n\n\\[\n(y, t) \\not\\prec_M (y, t + 1) \\prec_M \\ldots \\prec_M (y, t').\n\\]\n\nSo, there would be a cycle between \\((y, t')\\) and \\((y, t)\\). But that is again impossible by Claim 5. \n\n5.3.2 Construction of Run\n\nLet \\( \\prec_M \\) be the well-founded strict partial order on \\( \\mathcal{N} \\times \\mathbb{N} \\) as defined in the preceding subsection. The relation \\( \\prec_M \\) has the intuition of a happens-before relation of a run (Section 5.2.1), but the novelty is that it comes from a purely declarative model \\( M \\). We will now use \\( \\prec_M \\) to construct a run \\( R \\) such that \\( \\text{trace}(R) = M|_{\\text{exec}(P)}^{\\text{pt}} \\).\n\n**Total order** It is well-known that a well-founded strict partial order can be extended to a well-founded strict total order. So, let \\( <_M \\) be a well-founded strict total order on \\( \\mathcal{N} \\times \\mathbb{N} \\) that extends \\( \\prec_M \\), i.e., for each \\((x, s) \\in \\mathcal{N} \\times \\mathbb{N} \\) and \\((y, t) \\in \\mathcal{N} \\times \\mathbb{N} \\), if \\((x, s) \\prec_M (y, t)\\) then \\((x, s) <_M (y, t)\\), but the reverse does not have to hold.\n\nOrdering the set \\( \\mathcal{N} \\times \\mathbb{N} \\) according to \\( <_M \\) gives us a sequence of pairs that will form the transitions in the constructed run \\( R \\). Concretely, we obtain a sequence of nodes by taking the node-component from each pair. This will form our sequence of active nodes. Similarly, by taking the timestamp-component from each pair of \\( \\mathcal{N} \\times \\mathbb{N} \\), we obtain a sequence of timestamps. These are the local clocks of the active nodes during their transitions.\n\nWe introduce some extra notations to help us reason about the ordering of time that is implied by \\( <_M \\). For each \\((x, s) \\in \\mathcal{N} \\times \\mathbb{N} \\), let \\( \\text{glob}_M(x, s) \\in \\mathbb{N} \\) denote the ordinal of \\((x, s)\\) as implied by \\( <_M \\), which is well-defined because \\( <_M \\) is well-founded. For technical convenience, we let ordinals start at 0. Note, \\( \\text{glob}_M(\\cdot) \\) is an injective function. For any \\( i \\in \\mathbb{N} \\), we define \\((x_i, s_i)\\) to be the unique pair in \\( \\mathcal{N} \\times \\mathbb{N} \\) such that \\( \\text{glob}_M(x_i, s_i) = i \\).\nAs a counterpart to function $\\text{glob}_M(\\cdot)$, for each $i \\in \\mathbb{N}$ and each $x \\in \\mathcal{N}$, let $\\text{loc}_M(i, x)$ denote the size of the set\n\\[ \\{ s \\in \\mathbb{N} \\mid \\text{glob}_M(x, s) < i \\}. \\]\nIntuitively, if $i$ is regarded to be the ordinal of a transition in a run, $\\text{loc}_M(i, x)$ is the number of local steps of $x$ that came before transition $i$, i.e., the number of transitions before $i$ in which $x$ was the active node. If $x = x_i$ (the active node) then $\\text{loc}_M(i, x)$ is effectively the timestamp of $x$ during transition $i$, and if $x \\neq x_i$ then $\\text{loc}_M(i, x)$ is the next timestamp of $x$ that still has to come after transition $i$. Note, the functions $\\text{glob}_M(\\cdot)$ and $\\text{loc}_M(\\cdot)$ closely resemble the functions $\\text{glob}_R(\\cdot)$ and $\\text{loc}_R(\\cdot)$ of Section 5.1.3.\n\n**Configurations** We will now define the desired run $\\mathcal{R}$ of $\\mathcal{P}$ on $H$. First we define an infinite sequence of configurations $\\rho_0, \\rho_1, \\rho_2$, etc. In a second step we will connect each pair of subsequent configurations by a transition. Recall from Section 5.1.1 that a configuration describes for each node what facts it has stored locally (state), and also what messages have been sent to this node but that are not yet received (message buffer). The facts that are stored on a node are either input $\\text{edb}$-facts, or facts derived by inductive rules in a previous step of the node. The first kind of facts can be easily obtained from $M$ by keeping only the facts over schema $\\text{edb}(\\mathcal{P})^{LT}$, which gives a subset of $\\text{decl}(H)$.\n\nFor the second kind of state facts, we look at the inductively derived facts in $M$. Rules in $\\text{pure}(\\mathcal{P})$ that represent inductive rules of $\\mathcal{P}$ are recognizable as rules of the form (2); they have a head atom over $\\text{sch}(\\mathcal{P})^{LT}$ and they have a (positive) $\\tau_{\\text{succ}}$-atom in their body. No other kind of rule in $\\text{pure}(\\mathcal{P})$ has this form. Hence, the ground rules in $G$ that are based on rules of the form (2) are also easily recognizable, and we will call these inductive ground rules. A ground rule $\\psi \\in G$ is called active on $M$ if $\\text{pos}_\\psi \\subseteq M$, which implies $\\text{head}_\\psi \\in M$ because $M$ is stable. Let $M^{\\text{ind}}$ denote all head atoms of inductive ground rules in $G$ that are active on $M$. Note that $M^{\\text{ind}} \\subseteq M$. Regarding notation, for an instance $I$ over $\\text{sch}(\\mathcal{P})^{LT}$, we write $I^\\parallel$ to denote the set $\\{ R(\\bar{a}) \\mid \\exists x, s : R(x, s, \\bar{a}) \\in I \\}$, and we write $I^{\\parallel x, s}$ to denote the set $\\{ R(y, t, \\bar{a}) \\in I \\mid y = x, t = s \\}$.\n\nNow, for each $i \\in \\mathbb{N}$, for each node $x \\in \\mathcal{N}$, denoting $s = \\text{loc}_M(i, x)$, in configuration $\\rho_i = (st_i, bf_i)$, the state $st_i(x)$ is defined as\n\\[ (\\{ \\text{glob}_M(y, t), R(\\bar{a}) \\} \\mid \\exists u : \\text{chosen}_R(y, t, x, u, \\bar{a}) \\in M, s < i \\leq \\text{glob}_M(x, u)) \\].\nWe remove the location specifier and timestamp because we have to obtain facts over the schema of $\\mathcal{P}$, not over the schema of $\\text{pure}(\\mathcal{P})$.\n\nNow we define the message buffers in the configurations. Recall that the message buffer of a node always contains pairs of the form $(j, f)$, where $j \\in \\mathbb{N}$ is the transition in which fact $f$ was sent. For each $i \\in \\mathbb{N}$, for each node $x \\in \\mathcal{N}$, in configuration $\\rho_i = (st_i, bf_i)$, the message buffer $bf_i(x)$ is defined as\n\\[ \\{ (\\text{glob}_M(y, t), R(\\bar{a})) \\mid \\exists u : \\text{chosen}_R(y, t, x, u, \\bar{a}) \\in M, s < i \\leq \\text{glob}_M(x, u) \\}. \\]\nNote the use of addresssee \\( x \\) in this definition. The definition of \\( bf_f(x) \\) reflects the operational semantics, in that the messages in the buffer of node \\( x \\) must be sent in a previous transition, as expressed by the constraint \\( \\text{glob}_M(y, t) < i \\). Moreover, the constraint \\( i \\leq \\text{glob}_M(x, u) \\) says that \\( bf_f(x) \\) contains only messages that will be delivered in transitions of \\( x \\) that come after configuration \\( \\rho_i \\). Possibly \\( i = \\text{glob}_M(x, u) \\), and in that case the message will be delivered in the transition immediately after configuration \\( \\rho_i \\), which is transition \\( i \\) (see also below).\n\n**Transitions** So far we have obtained a sequence of configurations \\( \\rho_0, \\rho_1, \\rho_2, \\) etc. Now we define a sequence of tuples, one tuple per ordinal \\( i \\in \\mathbb{N} \\), that represents the transition \\( i \\). Let \\( i \\in \\mathbb{N} \\). Recall from above that \\( (x_i, s_i) \\) is the unique pair in \\( \\mathcal{N} \\times \\mathbb{N} \\) such that \\( \\text{glob}_M(x_i, s_i) = i \\). The tuple \\( \\tau_i \\) is defined as \\((\\rho_i, x_i, m_i, i, \\rho_{i+1})\\), where\n\n\\[\nm_i = \\{(\\text{glob}_M(y, t), R(\\bar{a})) \\mid \\text{chosen}_R(y, t, z, u, \\bar{a}) \\in M, \\text{glob}_M(z, u) = i\\}.\n\\]\n\nIntuitively, \\( m_i \\) selects all messages that arrive in transition \\( i \\). And since \\( \\text{glob}_M(z, u) = i \\) implies \\( z = x_i \\) and \\( u = s_i \\), we thus select all messages destined for step \\( s_i \\) of node \\( x_i \\).\n\n**Trace** We can show that sequence \\( \\mathcal{R} \\) is indeed a legal run of \\( \\mathcal{P} \\) on input \\( H \\) such that \\( \\text{trace}(\\mathcal{R}) = M_{sch(\\mathcal{P}), \\tau} \\); this proof can be found in Appendix B of the online appendix to the paper. In the following subsection we show that \\( \\mathcal{R} \\) is also fair.\n\n### 5.3.3 Fair Run\n\nLet \\( \\mathcal{R} \\) be the run as constructed in the previous subsection. We now show that \\( \\mathcal{R} \\) is fair. For each transition index \\( i \\in \\mathbb{N} \\), let \\( \\rho_i = (st_i, bf_f_i) \\) denote the source configuration of transition \\( i \\). Recall from Section 5.1.4 that we have to check two fairness conditions:\n\n1. every node is the active node in an infinite number of transitions; and,\n2. for every transition \\( i \\in \\mathbb{N} \\), for every \\( y \\in \\mathcal{N} \\), for every pair \\( (j, f) \\in bf_f_i(y) \\), there is a transition \\( k \\) with \\( i \\leq k \\) in which \\( (j, f) \\) is delivered to \\( y \\).\n\nWe show that \\( \\mathcal{R} \\) satisfies the first fairness condition. Let \\( x \\in \\mathcal{N} \\) be a node, and let \\( s \\in \\mathbb{N} \\) be a timestamp of \\( x \\). Consider transition \\( i = \\text{glob}_M(x, s) \\). This transition has active node \\( x_i = x \\). We can find such a transition with active node \\( x \\) for every timestamp \\( s \\in \\mathbb{N} \\) of \\( x \\), and these transitions are all unique because function \\( \\text{glob}_M(\\cdot) \\) is injective. So, there are an infinite number of transitions in \\( \\mathcal{R} \\) with active node \\( x \\).\n\nWe show that \\( \\mathcal{R} \\) satisfies the second fairness condition. Let \\( i \\in \\mathbb{N}, y \\in \\mathcal{N} \\), and \\( (j, f) \\in bf_f_i(y) \\). Denote \\( f = R(\\bar{a}) \\). From its construction, the pair \\( (j, f) \\in bf_f_i(y) \\) implies there are values \\( x \\in \\mathcal{N}, s \\in \\mathbb{N} \\) and \\( t \\in \\mathbb{N} \\) such that \\( \\text{chosen}_R(x, s, y, t, \\bar{a}) \\in M \\) and \\( j = \\text{glob}_M(x, s) < i \\leq \\text{glob}_M(y, t) \\). Denote \\( k = \\text{glob}_M(y, t) \\). Hence, \\( i \\leq k \\) and \\( (j, f) \\in m_k \\) by definition of \\( m_k \\). Thus \\( (j, f) \\) is delivered to \\( x_k = y \\) in transition \\( k \\).\nWe have represented distributed programs in Datalog under the stable model semantics. Moreover, we have shown that the stable models represent the desired behavior of the distributed program, as found in a realistic operational semantics. We now discuss some points for future work.\n\nAs mentioned, many Datalog-inspired languages have been proposed to implement distributed applications (Loo et al. 2009; Navarro and Rybalchenko 2009; Grumbach and Wang 2010; Abiteboul et al. 2011), and they contain several powerful features such as aggregation and non-determinism (choice). Our current framework already represents the essential features that all these languages possess: reasoning about distributed state and representing message sending. Nonetheless, we have probably not yet explored the full power of stable models. We therefore expect that this work can be extended to languages that incorporate more powerful language constructs such as the ones mentioned above. It might also be possible to remove the syntactic stratification condition that we have used for the deductive rules.\n\nMore related to multi-agent systems (Leite et al. 2002; Nigam and Leite 2006; Leite and Soares 2007), it might be interesting to allow logic programs used in declarative networking to dynamically modify their rules. The question would be how (and if) this can be represented in our model-based semantics.\n\nThe effect of variants of the model-based semantics can studied. For example, messages can be sent into the past when the causality rules are removed. Then, one might ask which (classes of) programs still work “correctly” under such a non-causal semantics; some preliminary results are in (Ameloot and den Bussche 2014).\n\nLastly, we can think about the output of distributed Datalog programs. Marczak et al. (2011) define the output with ultimate facts, which are facts that will eventually always be present on the network. This way, the output of a run (or equivalently stable model) can be defined. Then, a consistent program is required to produce the same output in every run. For consistent programs, the output on an input distributed database instance can thus be defined as the output of any run. We can now consider the following decision problem: for a consistent program, an input distributed database instance for that program, and a fact, decide if this fact is output by the program on that input. We think that decidability depends on the semantics of the message buffers. In this paper, we have represented per addressee duplicate messages in its message buffer. This is a realistic representation, since in a real network, the same message can be sent multiple times, and hence, multiple instances of the same message can be in transmission simultaneously. If we would forbid duplicate messages in the buffers, then the decision problem becomes decidable because only a finite number of configurations would be possible by finiteness of the input domain. But when duplicates are preserved, the number of configurations is not limited, and we expect that the problem will be undecidable in general. However, we might want to investigate whether decidability can be obtained in particular (syntactically defined) cases. If so, it might be interesting for those cases to find finite representations of the stable models. This could serve\nas a more intuitive programmer abstraction, or it could perhaps be used to more efficiently simulate the behavior of the network for testing purposes.\n\nAcknowledgment\nThe second author thanks Serge Abiteboul for a number of interesting discussions.\n\nReferences\n\n\nCavage, M. 2013. There’s just no getting around it: You’re building a distributed system. ACM Queue 11, 4.\n\n\nHellerstein, J. 2010b. The declarative imperative: experiences and conjectures in distributed logic. SIGMOD Record 39, 1, 5–19.\n\n\n"}}},{"rowIdx":187,"cells":{"id":{"kind":"string","value":"b87304d4789b0fd97de2fb8d608d53117ddbf816"},"text":{"kind":"string","value":"Permission is hereby given to modify or use, but not for profit, any or all of this program provided that this copyright notice is included:\n\nCopyright 19105\n\nFord Motor Company\nThe American Road\nDearborn, Michigan 48121\n\nThis work was supported by the Long Range Research Program of the Ford Motor Company, and was carried out at Ford Scientific Research Labs in Dearborn, Michigan and Ford Aerospace and Communications Corporation’s Western Development Laboratories in Palo Alto, California.\n\nPrinting of 11/6/105.\nThis is the user’s manual for the second release of the Pascal-F Verifier. The current version of the system operates on VAX and SUN systems running Berkeley UNIX.\n\nComments and trouble reports should be addressed to\n\nDivision Software Technology and Support \nMail Station X20 \nFord Aerospace and Communications Corporation \n3939 Fabian Way \nPalo Alto, CA 94303.\n\nor\n\nverifier@FORD-WDL1.ARPA\n\non the Internet.\n\n1. An introduction to verification\n\nVerifiers are not yet common software tools. For this reason, a substantial amount of explanation is in order. This manual is addressed to the professional programmer involved in the production of high-reliability software. Acquaintance with Pascal-F is assumed; acquaintance with verification is not. No specific mathematical background beyond that necessary to comprehend a Pascal-like language is assumed. Users who are uncomfortable with formal mathematics in any form, however, will find using the Verifier rather heavy going.\n\nThere has been a certain mystique associated with verification. Verification is often viewed as either an academic curiosity or as a subject incomprehensible by mere programmers. It is neither. Verification is not easy, but then, neither is writing reliable computer programs. More than anything else, verifying a program requires that one have a very clear understanding of the program’s desired behavior. It is not verification that is hard to understand; verification is fundamentally simple. It is really understanding programs that can be hard.\n\n1.1 What a verifier is and what it can and cannot do\n\nA verifier is a computer program, or set of computer programs. It examines other programs and tries to prove that they meet specified criteria. Some of these criteria are implied by the language in which the program is written. Others are supplied by the programmer or the system designer. It is the task of the verifier to try to show that the\nprogram always meets the stated criteria, no matter what data or conditions the program is faced with, provided only that the program is faithfully executed by the computer.\n\nThis task is not an easy one. It is much more difficult than, for example, checking that a program is syntactically correct. Showing that the program works for all cases requires a much more powerful approach than testing, simply because for programs of any complexity, exhaustive testing requires numbers of test cases that are far too large for there to be any hope of trying all of them.\n\nVerifiers attack this problem by turning a program and its criteria for correctness into a large number of mathematical formulas, and then trying to prove that all these formulas always hold. When the criteria for correctness can be expressed mathematically, this approach is very useful. When the criteria for correctness are not easy to define, the approach is of limited use.\n\nFortunately, it is quite straightforward to express mathematically the concept of a program “blowing up at run-time.” Errors that a run-time system for a language can catch, such as subscripting out of range, exceeding the allowed range of a variable, and referencing a variable that has not yet been assigned a value, are easy to define mathematically. Unlike a run-time system, which can only detect these errors when they occur, a verifier can detect these errors before they occur.\n\nThe first step in any sound verification is to show that no run-time errors occur. Some verifiers do not bother with this step, but assume, for example, that integer variables can contain any value and that arrays have infinite dimensions. While such verifiers are useful as research tools, one cannot place much confidence in a result of ‘no errors found’ from such a verifier.\n\nIdeally, verifying that a program cannot generate a run-time error should not require any help from the programmer, since the program contains sufficient information to decide this question. However, our verification tools are not sophisticated enough to do this checking without help.\n\nThe first step of verification is the translation of the question of the correctness of a program into a collection of mathematical formulas. This process is complex, but it is no worse than that of translating the program into object code, which is performed by a compiler. The hard part of verification is constructing proofs that the formulas are true, or discovering that they are false.\n\nEarly attempts at verification required users to write out proofs by hand, just as mathematicians have done for centuries. Other people read over the proofs and checked them. This approach didn’t work very well. It worked about as well as desk checking of programs does. A number of supposed program proofs published in various professional journals have been found to contain errors.\n\nThe next step was automatic proof checking. In this mode, people worked out their proofs at computer terminals, with the computer checking each step of the process. This approach is reliable, but it is slow and expensive. It has not been much used because of the high labor cost.\n\nFully automatic generation of proofs is the ultimate goal. Success has been achieved for\ncertain kinds of problems. Researchers are trying to extend the range of problems that\ncan be handled automatically. There are good, fast techniques for a useful class of simple\nproblems. Other more powerful (though much slower) techniques can be used on a larger\nclass of problems. Research continues in this area.\n\nA number of automatic theorem proving programs have been written. All verification\nsystems in serious use today use automatic theorem provers. However, verifiers are\nusually unable to prove programs correct without substantial help from the programmer,\nbecause of limitations of these theorem provers. It is this fact that keeps verifiers from\ncoming into widespread use.\n\nFortunately, the mathematics in real-time programs and system programs tends not to be\nvery advanced. More statements look like\n\n\\[ x := x + 1; \\]\n\nthan\n\n\\[ x := (-b + \\sqrt{b^2 - 4*a*c}) / (2*a); \\]\n\nThis fact makes verification of these programs tractable even with today’s theorem\nprovers.\n\nWe can attempt to verify any condition that can be expressed in the form of a computable\nBoolean expression that is always supposed to be true at some point in the program.\nSuch conditions are called assertions. A typical assertion would be\n\n\\[ \\text{ASSERT } x > y; \\]\n\nOne can compare this with a run-time check of the form\n\n\\[ \\text{IF NOT } (x > y) \\text{ THEN ABORT;} \\]\n\nIf correct operation of the program requires that \\( x \\) be greater than \\( y \\) when control reaches\nthis statement, we would like to be convinced that the ABORT will never occur. A\nverifier can often generate a proof that the assertion is true whenever control reaches the\nASSERT statement.\n\nVerifiers generally are not very good at diagnosing why a program cannot be verified.\nWhen a verifier says a program is correct according to its rules, then either the program is\ncorrect or the verifier is not working properly. (Sadly, an error in the verifier, as well as a\ncompiler error resulting in incorrectly generated object code, are always possibilities.)\nHowever, when a verifier fails to prove a program correct, the program may not be in\nerror. It may simply be that the verifier needs more help from the programmer, or that\nsome of the help already given is misleading. It is not always possible for the verifier to\ndiagnose the problem in a concise form. But the verifier can usually point out which\nsection of code is giving trouble. Beyond that, the typical verifier merely lets the\nprogrammer see the formula that it is trying to prove and lets the programmer try to figure\nout what is wrong. This level of diagnostic can be annoying, but is really no harder than\ndebugging.\n\nVerification is an iterative process. One submits the program to a verification system, gets some error messages, fixes the errors, and tries again until all the errors are gone. Because verifiers tend to be rather slow, facilities for reverifying only the parts that have changed are often provided. This feature is akin to being able to recompile only part of a program after making a change, and speeds up debugging substantially.\n\nIn time, verification may become a routine part of programming. At present, it is an area of active research, but the techniques of verification have been used only on a few projects. In most cases, the software tools needed to use verification on real projects have been lacking. This fact has retarded the acceptance of verification as a means of improving the quality of programs.\n\n1.2 The Pascal-F Verifier and its powers\n\nThe Pascal-F Verifier is designed to be used to improve the reliability of medium-sized real-time programs written in Pascal-F. Its power is generally adequate to check programs for absence of run-time errors. Higher-level constraints may be also be submitted for verification, and an attempt will be made to verify them, but there are limits on the complexity of the relations that can be verified.\n\nThe Verifier operates on a dialect of Pascal-F that has been augmented with language features used to provide additional information to the Verifier. These extensions are described in Chapter 2. The assertions required to verify a program are placed in the program text itself; there is no separate specification file. An extended version of the Pascal-F compiler is available which will accept but ignore the verification statements, allowing verified programs to be compiled without change.\n\nThe basic units of verification are the procedure, function, monitor, module, and main program. Collectively, we call these program units. We also refer to procedures and functions as routines. Each program unit is verified in isolation, using previously stored information about all other relevant procedures and variables. The information stored for each program unit is\n\n- The name, formal argument list, and result type\n- The ENTRY and EXIT assertions\n- The INVARIANT assertions\n- The list of global variables referenced\n- The list of global variables altered\n- The list of all routines called, and the arguments to each call\n- Information concerning multiprogramming.\n\nThese items define the interface of the routine. The only information about a routine available when verifying its callers is the interface. Therefore all the information about what a routine does must be included in the EXIT assertions, and all the information about what a routine needs must be included in the ENTRY assertions.\nBefore verifying a program, the verifier checks the program for violations of the rules given in chapter 2. This is referred to as *preverification checking*. Once all parts of a program have passed these tests, which in themselves may show up program “bugs”, the actual verification process begins. The Verifier generates assertions for all statements that could cause overflows, out-of-range subscripts, references to variables not yet assigned a value, or other run-time errors. Formulas called *verification conditions* are generated for all these assertions and for the user’s assertions. Attempts are made to prove all the verification conditions using an automatic theorem prover. Diagnostic messages are generated for all unproven conditions.\n\nIt is expected that the user will want to alter the program being verified and to attempt reverification. The Verifier maintains a file that minimizes the amount of work required when reverifying a program. The units of reverification are the procedure, function, monitor, and module. In general a change made within a program unit will not require reverification of parts of the program outside that unit unless the interface of the unit is altered by the user.\n\n2. Writing verifiable Pascal-F\n\nPrograms to be verified must in a sense be “understood” by the Verifier, for which it needs a substantial amount of help from the programmer. Most of this help is supplied in the form of special statements embedded in the text of the program. These statements are meaningless to the Pascal-F compiler (though the compiler will recognize and ignore them), but to the Verifier they supply information about how the program works.\n\n2.1 The Verifier’s view of Pascal-F\n\nThe Verifier needs additional information beyond the Pascal-F statements needed to produce a running program. The basic form of additional information is the assertion. An assertion is a Boolean expression (that is, one whose value is true or false) that is supposed to be true whenever some point in the program is reached. A typical assertion is\n\n\\[\n\\text{ASSERT } x > y;\n\\]\n\nThis assertion is a claim that whenever control reaches the statement, \\( x \\) will be greater than \\( y \\). The Verifier will take on the task of proving that the code that leads up to the \\text{ASSERT} statement always guarantees that \\( x \\) is greater than \\( y \\). Following the \\text{ASSERT} statement, the Verifier will assume that \\( x \\) is greater than \\( y \\).\n\nThe Verifier does not execute programs. It examines programs and attempts to predict their actions when executed. This examination takes place based on a set of built-in notions about the execution environment.\n\n2.1.1 Initialization\n\nAll variables are considered to be uninitialized at start and may not be referenced before being given a value. At program start, only constants have values. Upon entry to a routine, all local variables are uninitialized. Everywhere that a variable is used, the Verifier will attempt to prove that the variable has been assigned a value. For simple\nvariables this task is usually trivial; for arrays it is usually harder. See the section on the DEFINED predicate for information on how to cope with arrays.\n\n2.1.2 Ranges\n\nAll types have finite bounds. For subrange types, these are explicit. The bounds of the type INTEGER are from -32768 to 32767; these bounds are determined by the 16-bit hardware arithmetic used in the implementation of Pascal-F. Everything that has a numeric value thus has a subrange associated with it. All variables that have been initialized are assumed to be within range. Hence, all actions that change the value of a variable must be checked for out-of-range conditions.\n\n2.1.3 Multiprogramming\n\nThe Verifier views programs as if control can be taken away from the current process only at certain points called “singular points.” The singular points are at SEND and WAIT statements and places where a process calls a routine exported from a different monitor. This assumption allows the Verifier to process all other parts of programs as if they are purely sequential.\n\nThis assumption is a simplification of reality, since processes can be pre-empted when interrupts occur. However, since no monitor is allowed to access a variable that is declared in a different monitor, the fact that there is preemption can be ignored because the preempted process cannot detect that it was preempted.\n\nNormally, the Verifier can assume that any variable not altered by a statement does not change. When a process P encounters a singular point, this assumption is not valid. At those points P can be interrupted by other processes that can alter variables that P is allowed to read. When a process reaches a singular point, monitor variables visible to that process are assumed to be given new values that are consistent with the monitor invariant. Thus, the monitor invariant must be strong enough to contain all the necessary information about the values the monitor variables will contain whenever the monitor is entered or left.\n\nThe restrictions necessary to make this simplified model of multiprogramming work are enforced by the Verifier during the preverification checking phase. A style of programming in which shared variables are accessed only by routines declared within monitors is required. This style of programming is strongly recommended by various structured programming enthusiasts, including Hoare [HOARE74] but it tends to result in programs with many tiny routines. Efficient implementation of such programs will require additional optimization support in the compiler.\n\n2.1.4 Devices\n\nIn Pascal-F, devices have the syntax of variables, but very different semantics. The Verifier treats devices as procedures. Given the definitions\nTYPE atod = DEVICE (* A to D converter *)\n channel: 0..15; (* used to select channel *)\n data: 0..2047; (* returns data value *)\nEND;\n\nthe program fragment\n\n atod.channel := 2; (* select A/D channel *)\n tab[2] := atod.data; (* read A/D value *)\n\nis treated by the Verifier much as if the program read\n\n atodchannel(2); (* select A/D channel *)\n atoddata(tab[2]); (* read A/D value *)\n\nand atodchannel and atoddata were procedures. The Verifier makes no assumptions about the values returned by devices other than that values returned from devices are assumed to be in the range declared in the DEVICE declaration. Thus, DEVICE ranges should include the entire range of values that the device is electrically capable of producing. The Verifier assumes that the hardware has been correctly described by the programmer.\n\n2.1.5 Enforcement\n\nIn this chapter are a number of restrictions on the way in which Pascal-F programs intended for verification may be written. The Verifier checks and enforces all of these restrictions before proceeding with verification. This step is referred to as preverification checking.\n\n2.2 Extensions to Pascal-F for verification\n\n2.2.1 Verification statements\n\nThe statements described here have no effect on the behavior of the program. They serve only as a documentation aid, to help the Verifier (and the human reader) understand the operation of the program.\n\nBecause verification statements are not allowed to call have any effect on the program, they cannot contain calls to functions that have side effects.\n\n2.2.1.1 The ASSERT statement\n\n ASSERT ( <Boolean expression list> ) ;\n\nThis is the basic verification statement. An ASSERT statement is a claim that the given expressions are true whenever control reaches the statement. The Verifier will attempt to\nprove this claim. Like all verification statements, the ASSERT statement has no effect on program execution.\n\n2.2.1.2 The STATE statement\n\n\\[\n\\text{STATE ( <Boolean expression list> ) ;}\n\\]\n\nThe STATE statement may only be written within the body of a loop, and represents the loop invariant of the loop. The Boolean expressions in the STATE statement must be true every time the STATE statement is reached. The Verifier uses the STATE statement as the place at which it will begin and end analysis of the loop. Each Boolean expression in the STATE statement is verified for the path around the loop and for the path into the loop. For the path around the loop, the path tracing starts at the STATE statement, goes around the loop once (backwards) and ends at the same STATE statement. Thus, the Boolean expression list must include all important information about variables that are changed by the loop body, but it need not mention variables that are left untouched. More advice on the use of the STATE statement appears in the section “What to do when a verification fails”.\n\nOne (and only one) STATE statement must be written for every loop. The statement must contained in the loop body, at the top level. That is, if the loop body contains any compound statements then the STATE statement for the loop must appear outside those statements.\n\n2.2.1.3 The MEASURE statement\n\n\\[\n\\text{MEASURE ( <numeric expression> ) ;}\n\\]\n\nThe MEASURE statement is used to prove that loops terminate. Every WHILE and REPEAT loop (except for deliberate infinite loops, which must begin with \"WHILE true DO\" or end with \"UNTIL false;\")) must contain a MEASURE statement. The MEASURE statement must immediately follow the STATE statement associated with the loop. The <numeric expression> is a limit on the number of iterations of the loop body left to be performed. More specifically, the Verifier will insist that the value of the expression\n\n- be greater than or equal to zero when control reaches the MEASURE statement, and\n- decrease by at least one (for integers) or the precision of the expression (for fixed point numbers) each time control flows from the MEASURE statement around the loop back to the STATE statement.\n\nHow complex a MEASURE statement is required is a function of how obvious it is that the loop always terminates. FOR loops always terminate, and no MEASURE statement is used. If a loop uses a counter of one form or another, the MEASURE statement will\ncontain a simple expression involving the counter. For example, if the loop is counting $i$ from 1 to 100, \"MEASURE 100−$i$\" would be a good choice. If the fact that a loop terminates is subtle, a complicated MEASURE statement, perhaps one involving EXTRA variables, will be necessary. If the loop does not terminate under some circumstances, no MEASURE statement, no matter how complex, will be accepted by the Verifier.\n\n2.3 New expressions\n\nThe Verifier allows the use of some new constructs for building expressions. Some of these constructs can be used only in the special verification that will be described; others can be used in executable statements as well.\n\n2.3.0.1 The DEFINED predicate\n\n\\[\n\\text{DEFINED(<variable>)}\n\\]\n\\[\n\\text{DEFINED(<array>,<low bound>,<high bound>)}\n\\]\n\\[\n\\text{DEFINED(<block name>)}\n\\]\n\nDEFINED is a generic, built-in function that can be applied to any variable or part thereof and returns a Boolean value. DEFINED cannot be used in executable statements. A variable is said to be DEFINED whenever it is guaranteed to have a meaningful value. The following rules are used to determine whether an expression is DEFINED:\n\n- All constants are DEFINED, including VALUE constants.\n- Values obtained from DEVICE variables are DEFINED.\n- A record variable is DEFINED if and only if all the fields of the record are DEFINED.\n- An array variable is DEFINED if and only if all the entries of the array are DEFINED.\n- A variable is DEFINED after it has been used on the left side of an assignment statement in which the right side was DEFINED.\n- At the beginning of the body of a FOR loop, the index variable is DEFINED.\n- A subscripted variable is DEFINED if the subscript is DEFINED, the subscript is in the range of the array bounds, and the specific array element being referenced is DEFINED.\n\nOnce a variable is DEFINED it remains DEFINED, unless an operation is performed that results in the variable receiving an indeterminate value. Only the following circumstances can result in a variable not being DEFINED:\n\n- The variable is used in an index statement of a FOR loop is not DEFINED when the loop terminates.\nImmediately after the tag field of a variant record is changed, all the other fields in that record are no longer DEFINED.\n\nThe second form of DEFINED is used to test the definedness of portions of an array. The form\n\n\\[ \\text{DEFINED}(\\text{tab}, i, j) \\]\n\nis true if the array \\text{tab} has all elements DEFINED for elements with subscripts between \\(i\\) and \\(j\\) inclusive. This form is often used in loop invariants, inside the STATE statement.\n\nThe DEFINED predicate can also be applied to monitors and modules, as in the third form given above, but it has a slightly different meaning. If an INVARIANT has been declared for the monitor or module, the invariant is expected to hold whenever the construct is entered or left. There must be one exception to this rule, however. Since no variables are DEFINED when the program begins execution, the invariant cannot be expected to hold. It is the responsibility of the statements in the body of the monitor or module to initially establish the invariant. If \\(m\\) is a monitor or module, then \\(\\text{DEFINED}(m)\\) is TRUE whenever \\(m\\) has been initialized. No routine exported from a monitor or module may be called unless \\(\\text{DEFINED}(m)\\) is true.\n\n### 2.3.0.2 The OLD annotation\n\nAt the beginning of every procedure and function, the Verifier implicitly saves the value at entry of every variable used as an input to the routine. In assertions, it is possible to refer to these values by placing an \\texttt{.OLD} following a variable name or selector expression. Thus, if \\(X\\) is a parameter or variable, \\(X.\\texttt{OLD}\\) denotes the value the parameter or variable had when the routine was entered. Old values of array variables are referenced with forms such as \\(X[3].\\texttt{OLD}\\) for an array reference, or \\(X.\\texttt{FIELDNAME.OLD}\\) for field references. \\texttt{OLD} may only be used within verification statements and PROOF statements, since this saving of OLD values does not occur in the running program.\n\nThe chief use of OLD is as a specification tool. For example, suppose one wanted to write a procedure to increment the value of a variable by one. The interface for this procedure might be\n\n```\nTYPE smallint = 1..100;\nPROCEDURE bump(VAR x: smallint);\nENTRY x < 100;\nEXIT x = x.\\texttt{OLD} + 1;\n```\n\n### 2.3.0.3 The IMPLIES operator\n\nA new Boolean operator IMPLIES is added to the language. Informally, the expression \\(p \\text{ IMPLIES } q\\) means, \"if \\(p\\) is TRUE, then \\(q\\) will be TRUE as well.\" If \\(p\\) and \\(q\\) are Boolean expressions, then \\(p \\text{ IMPLIES } q\\) has the value TRUE if \\(p\\) is FALSE or \\(q\\) is TRUE, and it has the value FALSE in all other cases. For purposes of precedence, IMPLIES is considered to be a relational operator.\nThe IMPLIES operator is for the most part used in verification statements, but it may be used in executable statements as well. Because it happens to be the case that FALSE $\\leq$ TRUE, every IMPLIES operator in Pascal-F can be replaced by the operator $\\leq$ without changing the meaning of the program. This practice is not advised, since the resulting program will be harder to read than the one using IMPLIES.\n\n### 2.3.1 Verification declarations\n\nTo verify a program, more information about each routine is needed than what is necessary to compile a program. The Verifier expects routine headers that are more complex than those of standard Pascal. The extended syntax is:\n\n```pascal\n<block> ::= <entry declaration part>\n <exit declaration part>\n <effect declaration part>\n <invariant declaration part>\n <depth declaration part>\n <constant declaration part>\n <type declaration part>\n <variable declaration part>\n <statement part>\n```\n\nEach declaration part is either empty, or consists of a keyword followed by a series of declarations, each of which is followed by a semicolon. The declarations that are not part of standard Pascal are explained in this section.\n\n#### 2.3.1.1 The ENTRY declaration section\n\n```pascal\nENTRY <Boolean expression series>;\n```\n\nThe Boolean expressions given in this section are assertions that must be TRUE whenever the routine is called. The scope rules of Pascal-F prevent the Boolean expressions from containing variables other than parameters of the routine and variables global to the routine. In a routine exported from a module, ENTRY assertions cannot use variables local to the module. The purpose of the ENTRY section is to state restrictions on the values of these variables.\n\nENTRY assertions are a form of documentation as well as a verification requirement. Instead of writing \"This procedure may only be called when filesopen is 0\" in a comment, one writes\n\n```pascal\nENTRY filesopen = 0;\n```\n\nSome ENTRY assertions are automatically generated for each routine.\nFor each value argument, an assertion is generated that the argument is DEFINED.\n\nFor routines that are exported from a monitor or module m, an ENTRY assertion is generated consisting of the invariants for m.\n\nWhenever a variable is given a value, the Verifier checks that the value is appropriate to the type of the variable. Therefore, any variable that is DEFINED has a value that is appropriate to its type. Therefore it is not necessary to write ENTRY assertions that state that a parameter has a value appropriate for its subrange type.\n\nWhen a variable \\( v \\) is passed to a \\texttt{VAR} parameter \\( p \\) and used as an input variable, the Verifier automatically adds \\texttt{DEFINED(p)} to the ENTRY conditions of the routine being called. Similarly, for a \\texttt{VAR} output variable, \\texttt{DEFINED(p)} would be added to the EXIT conditions. This automatic insertion of \\texttt{DEFINED} predicates can be overridden by mentioning the formal argument involved in a user-supplied \\texttt{DEFINED} in an ENTRY or EXIT condition. A common case in which the user must override the Verifier’s automatic insertion is shown below.\n\n```pascal\nPROCEDURE search(var n: integer);\nENTRY DEFINED(n) = DEFINED(n);\nEXIT DEFINED(n);\nBEGIN\n n := 0;\n WHILE (n < 100) AND (tab[n] <> 0) DO BEGIN\n STATE(defined(n), defined(tab));\n n := n + 1;\n END;\nEND;\n```\n\nHere, we do not want to require that \\( n \\) be DEFINED at entry to \\texttt{search}, but \\( n \\) appears to be an output variable since there are references to it within the procedure. The use of\n\n\\[\n\\text{DEFINED}(n) = \\text{DEFINED}(n)\n\\]\n\nprevents the Verifier from adding a requirement that \\( n \\) be DEFINED at input, but does not impose any requirement of its own.\n\nThere are rare cases in which a parameter \\( p \\) is only sometimes used for input depending on the values of the other parameters are. In this case, an ENTRY assertion of the form\n\n\\[\n\\text{C IMPLIES DEFINED}(p)\n\\]\n\nshould be used, where \\( C \\) is the condition under which the variable is read. Routines that have array or record \\texttt{VAR} parameters may need complex ENTRY assertions indicating which portions of the array must be DEFINED at entry.\n\nMonitors and modules may have ENTRY declaration sections. These refer to the initialization block of the monitor or module. For monitors and modules, the assertions in the ENTRY section must be true when the \\texttt{INIT} statement for the monitor is executed,\nand will be assumed true at the beginning of the initialization part of the block.\n\n2.3.1.2 The EXIT declaration section\n\nEXIT <Boolean expression series>;\n\nThe EXIT declarations define the state of the program upon exit from a routine by giving assertions that will be true at that time. The scope rules of Pascal-F limit the variables allowed in an ENTRY assertion to parameters and variables global to the routine. An additional restriction enforced is that value parameters cannot appear in an EXIT assertion, except as fields of the record \\texttt{OLD}.\n\nEXIT assertions tend to be long and complex, because everything that the routine does that is of importance to the caller must be described in the EXIT assertions. In some cases the EXIT assertions may be as long as the body of the routine.\n\nIf a routine has a VAR parameter \\( p \\) that is used for output, \\texttt{DEFINED(p)} must be included among the EXIT assertions. If the parameter is only used for output some of the time, the situation must be described in an EXIT assertion of the form\n\n\\[\nC \\implies \\text{DEFINED}(p)\n\\]\n\nwhere \\( C \\) is the condition under which \\( p \\) is used for output. If \\( p \\) is an array or record and only part of \\( p \\) is written, the situation must be described using more complex EXIT assertion.\n\n2.3.1.3 The EFFECT declaration section\n\nEFFECT <Boolean expression series>;\n\nThis declaration may only appear in a routine that is exported from a module. An EFFECT assertion is similar to an EXIT assertion, except that EFFECT assertions cannot contain references to variables local to the module.\n\nUpon return from a “regular” routine (that is, one that is not part of a module) the Verifier uses the fact that the EXIT assertions (with actual arguments replacing formal parameters) for that routine are true. However, if the routine is exported from a module and called from outside the module, its EXIT assertions cannot be used since they may contain variables not visible to the caller. Instead, the EFFECT assertions are used by the Verifier. These assertions cannot contain variables local to the monitor. If a routine exported from a monitor is referenced from within the monitor, both EXIT and EFFECT assertions are used.\n\nThe following example shows how \\texttt{OLD}, \\texttt{ENTRY}, \\texttt{EXIT}, and \\texttt{EFFECT} are used to specify a module. The module also contains an INVARIANT declaration. INVARIANT declarations are explained in the next section.\nMODULE stack;\nEXPORTS size, push, pop;\nVAR stp: 0..maxsize;\n buf: array [1..maxsize] of stackelt;\n\nEFFECT size = 0;\n\nINVARIANT FOR x: 1..maxsize\n ALL x<stp IMPLIES DEFINED(buf[x]);\n\nPROOF FUNCTION size: 0..maxsize;\nEXIT size = stp;\nBEGIN size := stp END;\n\nPROCEDURE push(x: stackelt);\nENTRY size < maxsize;\nEFFECT size = OLD.size + 1;\nBEGIN stp := stp + 1;\n buf[stp] := x\nEND;\n\nFUNCTION pop: stackelt;\nENTRY size > 0;\nEFFECT size = OLD.size - 1;\nBEGIN pop := buf[stp];\n stp := stp - 1\nEND;\n\nBEGIN stp := 0 END;\n\nA few things should be noted about this example. The ENTRY assertions indicate under what conditions each routine can be called. They are written in terms of the proof function size. The EFFECT declarations describe what each routine does to size so that the users of the module can tell when it is valid to call push and pop. The EXIT assertion in size is used by the Verifier to translate the ENTRY and EFFECT assertions in push and pop into assertions about the variable stp, which is (unbeknownst to the caller) changed by those routines.\n\n2.3.1.4 The INVARIANT declaration\n\nINVARIANT <Boolean expression series>;\n\nThe assertions given in an INVARIANT declaration are required to hold at multiple points in a program.\n• Putting an INVARIANT P in a routine is equivalent to putting ASSERT P statements at the beginning of the routine (i.e. as an ENTRY assertion), the end of the routine (as an EXIT assertion), before and after each WAIT statement in the routine, and before and after each call to another routine.\n\n• Putting an INVARIANT P in a MONITOR is equivalent to putting ASSERT P statements at the end of the monitor block, before and after each WAIT statement in the monitor, before and after each call to a routine outside the monitor, and adding P as an INVARIANT assertion to each routine exported from the monitor. Note that an ASSERT P is not added to the beginning of the monitor block; the invariant is not assumed to hold until the monitor has been initialized.\n\n• If the declaration INVARIANT P is put into a MODULE, the only variables on which P can depend are those local to the MODULE. The assertion P must be true at the end of the initialization block of the MODULE, before and after each WAIT statement in the module, before and after each call to a routine outside the module, and at the beginning and end of each routine exported from the MONITOR.\n\nIn other words, if an assertion P is declared to be an INVARIANT of a construct, P must be true whenever control passes into or out of that construct.\n\n2.3.1.5 The DEPTH declaration\n\nA recursive routine R1 is one that can call R2, which in turn calls R3, and so on until R1 is called again. A special case of recursion is a routine that calls itself. When a program uses recursion, it is necessary to prove that it is impossible to initiate an endless sequence of routine calls, none of which ever returns.\n\nEvery recursive routine must contain a DEPTH declaration of the form:\n\n```\nDEPTH <integer expression>;\n```\n\nBy the scope restrictions of Pascal-F, the integer expression may only contain parameters of and variables global to the routine. Note that a fixed point expression cannot be used.\n\nThe DEPTH expression is an indication of how much time will be used by the routine. The ENTRY assertion for the routine must be strong enough to imply that the DEPTH expression is nonnegative whenever the routine is called.\n\nFrom a recursive routine R1 two kinds of calls to other routines are possible. If R1 calls itself, or if it calls a routine R2 that can initiate a chain of routine calls that eventually leads to R1 being called again, the call is said to be a recursive call. Otherwise, the call is said to be nonrecursive.\n\nWherever a recursive routine R1 makes a recursive call to a routine R2 (a special case is when R1 and R2 are the same routine), it must be established that an infinite chain of calls is not being initiated. Let d1 be the value (at the time R1 was called) of the DEPTH expression declared for R1. Similarly, let d2 be the value (at the time R2 is being called) of the DEPTH expression declared for R2. The Verifier will attempt to prove that d2 is strictly less than d1. If this condition is proved for every recursive call, then each call in a chain must perform a successively easier task, so that every use of recursion must\neventually terminate.\n\n2.3.2 EXTRA variables and PROOF statements\n\nQuite often, it is not easy to demonstrate to the Verifier that a program works. One method of simplifying this task is to demonstrate that a program with some ‘debug code’ added works. For example, in proving that a linked list is correctly linked, it is easier to prove that a doubly-linked list is correct than that a singly-linked list is correct, because in the doubly-linked case, an invariant can be stated that claims that the operations of inserting and deleting from the list keep the backward and forward links consistent. Consistency for a singly-linked list is harder to define.\n\nIn a case such as the above, implementing a doubly-linked list may not be necessary for the operation of the program, but may be desirable for verification. EXTRA variables, for use in assertions, and PROOF statements, for manipulating EXTRA variables, are useful in such situations.\n\n2.3.2.1 The EXTRA variable attribute\n\n```\n<variable name list>: EXTRA <type>;\n```\n\nThe EXTRA attribute may be used in VAR declarations, in formal parameter declarations, and in RECORD definitions. The type of the result of a function may not have the EXTRA attribute. In each case, the attribute denotes a variable, parameter, or record field that is to be used for proof purposes only. That is, EXTRA variables must be used in such a way that all the EXTRA information can be removed from a program without affecting its execution. See the section on PROOF statements for more details.\n\n2.3.2.2 The EXTRA function and procedure attribute\n\n```\nEXTRA FUNCTION <function definition>\n\nEXTRA PROCEDURE <procedure definition>\n```\n\nFunctions and procedures designated as EXTRA are solely for use in PROOF statements and assertions. Every parameter to an EXTRA routine is implicitly an EXTRA variable, and every statement in the routine is implicitly a PROOF statement.\n\n2.3.2.3 RULE functions\n\n```\nRULE FUNCTION <function definition> BEGIN END;\n```\n\nFunctions may be declared as RULE functions for use in proof rules. Such function definitions have no body.\nRule functions are used when an expression is needed in an assertion but the needed expression cannot be written as a simple Pascal-F expression. The use of rule functions is covered in detail in the chapter on rules.\n\nRule functions are restricted to results of types `integer`, `char`, and `boolean`. Arguments to rule functions may be declared as any valid Pascal-F type.\n\n2.3.2.4 The PROOF statement\n\n```\nPROOF <statement>\n```\n\nAny executable statement, even a compound statement, may be turned into a PROOF statement by preceding the statement with the keyword `PROOF`. Such statements are ignored by the compiler. PROOF statements are used to manipulate EXTRA variables and to control conditional execution of other PROOF statements. The removal of all PROOF statements and EXTRA variables from a program must not change the execution of the program. The Verifier checks this restriction by enforcing rules that prevent any PROOF statement from affecting any non-PROOF variable.\n\nAny expression containing an EXTRA variable will be referred to as a ‘proof expression’. The specific restrictions imposed to prevent PROOF statements and expressions from affecting program execution are as follows.\n\n- Proof expressions may not contain calls to non-EXTRA functions that have side effects (other than the modification of EXTRA variables).\n- Proof expressions can only be used in PROOF statements and as arguments to routines. The following parameter matching rules must be observed when calling non-EXTRA routines:\n - If a formal value parameter of a routine is an EXTRA variable, the corresponding argument cannot have any side effects (other than the modification of EXTRA variables).\n - If a formal VAR parameter of a routine is an EXTRA variable, the corresponding argument must also be an EXTRA variable.\n - If a formal parameter is not an EXTRA variable, the corresponding argument must not contain any EXTRA variables.\n- EXTRA functions and procedures may be called only from within PROOF statements.\n- Non-EXTRA variables may not be modified in any way by PROOF statements. This restriction applies to assignment statements, FOR loops, and routine calls.\n- The multiprogramming statements `WAIT`, `SEND`, and `INIT` are forbidden in PROOF statements.\n\nStudy of the sample engine control program in Chapter 4, which contains a number of EXTRA variables, will give some insight into the use of this language feature.\n2.4 Restrictions on Pascal-F programs\n\nThe restrictions given here are imposed to make the task performed by the Verifier easier. In most cases, the restrictions are in line with good programming practice. However, the concern here is not style but verifiability. A construct is prohibited only when there is some specific problem in handling that construct.\n\n2.4.1 Restrictions on program structure\n\n- The only legitimate ways to write non-terminating loops for a process is\n\n \\[\n \\text{WHILE true DO BEGIN <loop body> END;}\n \\]\n\n or\n\n \\[\n \\text{REPEAT <loop body> UNTIL true;}\n \\]\n\n This construct may not appear within any other control structure. This restriction is imposed so that the Verifier can discriminate between accidental and deliberate non-terminating loops.\n\n- The iteration variable of a FOR loop may not be modified from within the loop. Further, the value of the iteration variable is not DEFINED after the loop terminates. The Verifier issues an error message whenever a variable that is not DEFINED is accessed.\n\n2.4.2 Restrictions on variant records\n\nVariant records are not permitted by the verifier.\n\n2.4.3 Restrictions on exception handling\n\nPascal-F incorporates a powerful exception handling mechanism similar to that in Ada. This version of the Verifier operates on the assumption that exception handlers are not used in normal operation and enforces the following rules.\n\n- The RAISE statement, for exception handling, is considered to be a mechanism for recovering from hardware errors only. The Verifier will try to prove that no RAISE statement is ever executed.\n\n- Exception handling routines are not examined.\n\n2.4.4 Aliasing and side effects\n\nAliasing and side effects are two related phenomena that make programs difficult to understand and verify. Aliasing is the condition in which two names refer to the same variable. A side effect occurs when a function modifies one of its parameters or a global variable. The Verifier enforces restrictions that prevent variables from being changed in a fashion that it cannot detect, or in such a fashion that the resulting value of the modified variable depends of the order of evaluation.\n\nThe following program contains an example of aliasing.\nPROGRAM pr;\nVAR x: 1..100;\n\nPROCEDURE p(VAR a: 1..100);\nBEGIN\n a := 1;\n x := 2;\n ASSERT(a = 1);\nEND;\nBEGIN\n p(x);\nEND pr.\n\nProcedure p, viewed in isolation, is valid. The variable ‘a’ is clearly 1 after the body of the procedure has been executed. However, the call ‘p(x)’ causes the variables ‘a’ and ‘x’ to refer to the same variable within the procedure ‘p’. The assignment to ‘x’ will therefore change ‘a’ at the same time, and the assertion ‘a = 1’ will not be valid.\n\nBecause this sort of thing is far more often a cause of error than a useful feature of the language, it is prohibited.\n\nWhen a function is called, VAR parameters of the function or variables global to the function can be modified. The modification of a variable by a function is called a \"side effect\" because the modification is usually not the primary purpose of the statement in which the function is called. Generally, programming with side effects is a dangerous practice because it is easy to forget that the side effect will take place.\n\nThis danger is diminished when using the Verifier, since the Verifier will detect side effects. However, there is a class of side effects whose result depends on the order of evaluation in expressions. As an example, suppose the functions f and g set their arguments to 1 and 2, respectively. The value given to x by the statement:\n\n\\[ y := f(x) + g(x) \\]\n\ndepends on whether the call to f or g is evaluated first. The Verifier allows statements to have side effects only if it can determine that the results of the side effects are independent of the order of evaluation in expressions.\n\nThe programmer can use the following simple rules to avoid problems with aliasing and side effects.\n\n1. Do not pass the same variable to two different VAR parameters of a routine.\n2. Do not pass a variable or any component thereof to a VAR parameter of a routine that sets or uses the variable as a global.\n3. Within a function, do not modify VAR parameters or global variables, perform WAIT statements, or call a routine exported from a monitor, unless the function is called only in simple assignment statements.\n4. Do not use functions exported from monitors in expressions; use them only as the right side of simple assignment statements. The Verifier detects any violations of these rules.\n\n2.4.5 Restrictions on multiprogramming\n\nThe restrictions required to make programs with multiple processes verifiable are somewhat severe. Unlike the other restrictions, which generally prohibit only language forms of little if any real use, the multiprogramming restrictions can be difficult to live with. The object of these restrictions, as discussed earlier in this chapter, is to allow the Verifier (and the programmer) to generally ignore the fact that semi-concurrent operations are taking place.\n\nThe major restriction required to make multiprogramming work is to require that any code referencing a static variable must be at the same priority as the variable. In Pascal-F, this is easy to enforce, because both the priority of both code and static variables is determined strictly by the priority of the module in which they are enclosed. The rules are as follows.\n\n- No variable may be imported or exported from a monitor.\n- A routine that has been exported from the monitor may not be called before the monitor has been initialized with an INIT statement.\n- A monitor variable may not be passed as a VAR argument to a routine outside the monitor. (There are no restrictions on arguments passed by value.)\n- A signal may not be a component of any other type.\n\n2.5 Using Pascal-F with verification statements\n\n2.5.1 Guidelines for writing verifiable programs\n\n- Every variable should be of the minimum subrange type required for the range of values needed. For example, if negative values are illegal for a variable, its type should not permit negative values. Likewise, if zero is also prohibited, a positive range should be specified. These declarations give the Verifier extra information to use without extra writing by the programmer. They also can save space in the object program.\n- Where alternatives are mutually exclusive, use the IF - THEN - ELSE structure in preference to consecutive IF statements so that it is clearly impossible for more than one alternative to be executed. Properly structuring a program holds down the number of possible paths to be traced out. Large numbers of paths make for long sessions with the Verifier.\n- Use many short assertions instead of a few big ones. Do not lump assertions together with AND operators. The diagnostic messages, which refer to individual assertions, will then be more useful.\n• Because many diagnostic messages are line-number oriented, it helps to put only one assertion on a source line.\n\n• When writing loops, remember to use a STATE statement to describe what the state is after each iteration. Keeping the loop simple eases the difficult task of writing loop state assertions.\n\n• The Verifier can make better deductions about addition and subtraction than it can about multiplication and division. It will be quite difficult to verify anything that depends on more than the most obvious properties of multiplication and division. Multiplication by constants is not a problem. The Verifier can deduce the possible range of the result of a division, but little else.\n\n• Avoid scaling fixed-point operations so that truncation occurs. The Verifier can deduce the possible range of the result of a truncation, but little else.\n\n• When progressing through an array with a loop, use a FOR loop unless early exit from the loop is planned. The Verifier supplies the proofs that FOR loops terminate.\n\n• When processes at different priorities must communicate, one process will have to call a routine in another module to access any shared variables. This restriction is an incentive to reduce access to shared variables.\n\n• Do not combine data that logically belongs to different priority code in the same record. Doing so will force the use of access routines unnecessarily.\n\n2.5.2 Obtaining the most from the Verifier\n\nHaving a Verifier around encourages “defensive programming”. Good programmers often write error detection into programs. Unfortunately, when program space or time are at a premium, it is not possible to put in (or in some cases leave in) all the traps for software bugs that should be there. When these traps are written as verifiable assertions, the checking can be done during verification, and there is no execution penalty.\n\nIn this sense, the most important defense against errors is extensive use of ENTRY assertions. Use ENTRY assertions as a documentation aid, to explain each routine to its users. These assertions (and module INVARIANT assertions) can be used to protect the routine from its callers, since the Verifier requires that the state of the system is what it is supposed to be when the routine is called.\n\nOnce all these ENTRY assertions are verified, they should be left in the program as a guide for those who must maintain the program. Over the long haul, one of the most important benefits of verification is that it allows the designer of the original program to leave behind rules about how the program is supposed to work. These rules might be unknown, forgotten, or ignored by future maintenance programmers, but if they are in the program text, the Verifier will use them.\n\n3. Using the verifier\n\nThe Verifier runs on Digital Equipment Corporation VAX computers under Berkeley UNIX or Wollongong Eunice/VMS, or on SUN workstations. This chapter contains\ninstructions for using the verifier.\n\n3.1 Invoking the Verifier\n\nThe Verifier is called using the UNIX command line:\n\n```\npasver [flags] <file>\n```\n\nThis command initiates verification of the Pascal-F program in the named file. The file name must end in .pf indicating that the file is Pascal-F source.\n\nIf the -dvcg flag is given, messages will be printed indicating the progress of the verification, and failed verification conditions will be stored for examination by the user. The -d flag enables all internal debugging output, and should be used when trouble reports are submitted.\n\nThe verifier creates, in the current directory, a new directory for its scratch and history files. This new directory has the name of the program being verified, except that the trailing .pf is replaced with _d indicating a directory. The files in this directory are used to speed up reverifications when not all the program units of the program have been changed. The rules associated with the verification are also stored in this directory. Reverification is omitted for previously-verified program units when the unit is unchanged and the program unit was successfully verified in the past. Reverifications are much faster than original verifications.\n\n3.2 Understanding error messages\n\nThe verifier generates error messages during three phases of processing; syntax checking, preverification checking, and verification. Samples appear below. Detection of an error during any phase prevents further phases from taking place, so only one of the three kinds shown below will appear as output from any given verification attempt.\n\n3.2.1 Syntax error messages\n\n```\nprog.pf\n 4. IF x < 0 THEN x := 0)\n\n**** 14\n14: ';' expected\nCompilation complete - 1 errors detected\n*** Pass 2 deleted ***\nPass 1 error abort.\n```\n\nSyntax checking in the verifier is essentially the same as the Pascal-F compiler. This is to be expected, since the first passes of both are the same. The messages here are of the same types one would expect from a compiler. All messages here indicate errors; there are no ambiguities.\n3.2.2 Preverification error messages\n\nPass 1:\nPass 2:\nxxx.pf:\n 9. proc1(global1);\n*** Variable \"global1\" is already used globally by \"proc1\". ***\n1 error.\nPass 2 error abort.\n\nPreverification checking is performed only after the entire program has been syntax checked, and information about procedures and global objects has been collected. This phase is primarily a check for inconsistencies between definition and use of objects. In addition, the restrictions necessary to make verification possible are enforced by this phase, and some common errors which can be caught efficiently in this phase are diagnosed. In the example above, there is an aliasing error; the variable global1 is being passed as a VAR argument to a procedure which uses global1 as a global variable. This is of course forbidden, since proc1 will not behave as it normally would when a global and formal variable actually refer to the same location in memory.\n\nOne line of the source program is printed with each message to reduce the need to refer to a printed listing.\n\n3.2.3 Verification error messages\n\nIn general, a message from this phase indicates that the possibility of a problem exists. As discussed earlier, a change in the program or the assertions will be required to eliminate the message.\n\nEach message represents a proof failure along some path between a previous control point (procedure entry, loop invariant, wait, or STATE assertion) and the line displayed. Where more than one path exists, because of conditional statements, the path being traced out is described. This is done by stating the choice made at each conditional statement on the path.\nPass 1:\nPass 2:\nPass 3:\n\nVerifying example6\nCould not prove {example6.pf:18} table1[(j - 1) + 1] = 0\n (ASSERT assertion)\nfor path:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:11} FOR loop exit\n\nCould not prove {example6.pf:14} allzero(table1,1,i)\n (STATE assertion)\nfor path:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:15} Back to top of FOR loop\n\nCould not prove {example6.pf:14} allzero(table1,1,i)\n (STATE assertion)\nfor path:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:11} Enter FOR loop\n\nCould not prove {example6.pf:13} allzero(table1,1,i - 1)\n (ASSERT assertion)\nfor path:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:15} Back to top of FOR loop\n\nCould not prove {example6.pf:13} allzero(table1,1,i - 1)\n (ASSERT assertion)\nfor path:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:11} Enter FOR loop\n\n5 errors detected\n\nThe Verifier shows which specific assertion it could not prove, and for what path through\nthe program proof was unsuccessful. A listing of the Pascal-F program to which the\nabove messages refer appears in a later chapter.\n\n3.3 How to proceed when a verification fails\n\nThe first attempt at a verification will produce many error messages. An orderly\napproach to dealing with these will be helpful. The messages may be divided into several\nclasses, as shown below. Each class should be eliminated in order. When new errors\nappear in a class previously eliminated, the new errors should be dealt with before\ncontinuing work on the old.\n3.3.1 Eliminate the syntax errors\n\nFirst, if any syntax errors or preverification error messages are present, they must be eliminated before the verifier will attempt the verification phase. This is straightforward and the messages are usually unambiguous.\n\n3.3.2 Eliminate any definedness problems\n\nWhen verification-phase messages appear, the first thing to do is to look at all messages associated with definedness. These look like\n\n{progl.pf: 25} Cannot prove \"x\" is defined.\n\nMessages like this indicate that the Verifier could not prove that a variable was initialized at some point where the value of the variable was used. All errors related to definedness should be eliminated before working on further problems. Often this will require adding definedness assertions such as\n\nENTRY DEFINED(x);\n\nto procedure and function definitions. Adding an ENTRY condition such as the one above will usually eliminate the error message for the routine to which it is added, but since it places a new requirement on every caller to the routine the next verification attempt may well have new error messages concerning the callers of the routine. One works outward until the main program is reached.\n\nThe user should be aware that the Verifier generates ENTRY and EXIT definedness assertions internally for each procedure for each variable referenced (for ENTRY) and set (for EXIT) in the procedure but not mentioned by the user in the ENTRY and EXIT assertions. This convenience feature handles most common cases, but can be overridden by the user when required by mentioning the variable in a DEFINED clause. This mechanism usually does the right thing for simple variables. For more complex variables not fully initialized for all calls to the routine, the user will have to provide entry conditions of his own. If, for example, at entry to a routine, the array \\textit{tab} is only expected to be initialized from 1 to \\textit{x}, one would write an entry assertion of the form\n\nENTRY DEFINED(tab,1,x);\n\nA special case is the assignment before use of a global variable or \\texttt{var} argument to a procedure or function. For example, in\nprocedure p(var x: integer; y: integer);\nBEGIN\n x := 1;\n IF y > 0 THEN x := x + 1;\nEND;\n\nthe formal parameter \\( x \\) seems to be an input and an output variable, since it is both set and used within \\( p \\). Here, an entry condition of the form\n\n\\[\n\\text{ENTRY DEFINED}(x) = \\text{DEFINED}(x);\n\\]\n\nis required. This form is essentially meaningless but turns off the built-in assumption that \\( x \\) had to be DEFINED at any call to \\( p \\).\n\n3.3.3 Eliminate the run-time safety errors\n\nMessages referring to array bounds and variable ranges should be addressed next. Again, it may be necessary to add ENTRY and EXIT assertions to do this. It may also be necessary to add terms to STATE invariants.\n\n3.3.4 Eliminate ENTRY errors\n\nWhen an error message associated with an ENTRY condition appears, the message will specify which call to the routine is causing the problem. First check the ENTRY statement to make sure that the requirement is what you had in mind; if so, the caller may need work.\n\n3.3.5 Eliminate INVARIANT and EXIT errors\n\nThese refer to the state at the end of a routine.\n\n3.3.6 Work on loop invariants\n\nThis is the really hard job in verification. Fortunately, when one is only trying to prove absence of fatal run-time errors, it is not too tough. A few simple cases cover most situations, of which the following is typical.\n\n\\[\n\\text{WHILE parens > 0 DO BEGIN}\n\\text{printchar('')};\n\\text{parens := parens - 1;}\n\\text{STATE(DEFINED(parens))};\n\\text{END;}\n\\]\n\nThe invariant can go anywhere in the loop but usually placing it at the end of the loop is more convenient, as in the example below.\nFOR $i := 1$ TO 100 DO BEGIN\n tab[$i$] := 0;\n STATE(DEFINED(tab,1,$i$));\nEND;\n\nWhen initializing an array of records, it is usually desirable to write a procedure which initializes one record in the array through a var argument, and use that procedure in the initialization loop. The record initializing procedure should have as its exit condition that the entire var argument is DEFINED.\n\n3.3.7 Find all hard-to-prove assertions\n\nExamine the remaining error messages. Look at each one and ask yourself “can you convince yourself informally that the assertion is true for that path at that point, purely by tracing backward along the indicated path and looking at the statements there?”. If not, the program or the assertions need work. If so, defer working on that assertion until all the assertions that need work have been dealt with. Once all the easy assertions are out of the way, it is time to deal with the hard ones.\n\nThe Verifier can prove, without assistance, assertions that are true because of properties of addition, subtraction, multiplication by explicit constants, the relational operators, the Boolean connectives, and storing into and referencing arrays and records. This takes care of about 90-95% of all verification conditions. Beyond this point, the Verifier needs help.\n\nHelp is provided by adding ASSERT statements to the program and by adding rules to the rule database. Whenever an ASSERT statement is placed in a Pascal-F program, the Verifier will try to prove that it holds. For any statement after the ASSERT statement in the program, the assertion will be assumed true. Hard assertions should be preceded by an easy assertion or assertions (ones that the Verifier can prove) which imply the hard assertion by some formal argument the Verifier doesn’t yet know about. This argument should be something that depends only on the ASSERT statement and the following hard assertion. It will then be necessary to prove that argument as a rule. Proving rules is done with the Rule Builder as a separate job; when working on the program, all the hard assertions should be found and preceded with an easy assertion, until the entire verification is a success except for the errors from hard assertion preceded by easy ones. Then it is time to go to the Rule Builder, and probably to the resident Rule Builder expert.\n\nAn example is indicated.\n\nFOR $i := 1$ TO 100 DO BEGIN\n table1[$i$] := 0;\n assert(table1[$i$] = 0);\n assert(allzero(table1,1,$i$-1));\n STATE(allzero(table1,1,$i$));\nEND;\n\nIn this example, the STATE assertion is hard to prove. But if we add the two ASSERT\nstatements, both of which the Verifier can prove without much trouble, we could certainly argue that this makes it obvious that the STATE assertion is sound. If we had a rule that said\n\n\\[\na[i] = 0 \\text{ and allzero}(a,1,i-1) \\\\\n\\text{implies} \\\\\n\\text{allzero}(a,1,i)\n\\]\n\nthe Verifier would apply the rule and prove the assertion. So we now know exactly what rule we need, and can prove it with the Rule Builder.\n\n### 3.3.8 Completing the debugging\n\nWith this sequential approach to debugging a verification, the rather forbidding prospect of eliminating all those error messages is somewhat less intimidating. Note, though, that no sound statement can be made about the program until every error message has been eliminated. One false assertion can cause any number of other problems to be hidden. As an example, writing\n\nENTRY false;\n\nwill eliminate all error messages for any routine, but will cause any caller of the routine to fail. (It is an interesting property of the Verifier that unreachable code need not work!). The same problem can be induced by accident; for example\n\nENTRY \\((x < 0) \\text{ and } (x > 100)\\);\n\nis essentially equivalent to the previous statement, since no number can satisfy both constraints. Thus, until all error messages have been eliminated, the verification is unsuccessful.\n\n### 4. The Syntax of Pascal-F\n\nThis chapter describes the syntax of Pascal-F, including the verification statements. Lines marked with asterisks indicate productions altered to include the additional syntax necessary for verification. The syntax here is a superset of that given in the Pascal-F Language Reference Manual, and is given in the notation used in that manual.\n\n#### 4.1 Production Rules\n<program> ::= <program heading> <outer block> .\n\n<program heading> ::= PROGRAM <identifier> ;\n\n<outer block> ::= <label declaration part>\n <constant definition part>\n <type definition part>\n <value declaration part>\n <variable declaration part>\n <global routine declarations>\n <statement part>\n\n<label declaration part> ::= \n <empty> | LABEL <label> {, <label>} ;\n\n<entry declaration part> ::= <empty> | \n ENTRY <expression> {; <expression>} ;\n\n<exit declaration part> ::= <empty> | \n EXIT <expression> {; <expression>} ;\n\n<effect declaration part> ::= <empty> | \n EFFECT <expression> {; <expression>} ;\n\n<invariant declaration part> ::= <empty> | \n INVARIANT <expression> {; <expression>} ;\n\n<depth declaration part> ::= \n <empty> | DEPTH <expression> ;\n\n<constant definition part> ::= <empty> | CONST \n <constant definition> {; <constant definition>} ;\n\n$type definition part$ ::= <empty> | \n TYPE <type definition> {; <type definition>} ;\n\n<variable declaration part> ::= <empty> | \n VAR <variable declaration> \n {; <variable declaration>} ;\n\n<value declaration part> ::= <empty> | \n VALUE <value declaration> \n {; <value declaration>} ;\n\n<global routine declarations> ::= { <global routine> ; }\n<routine declaration part> ::= { <routine declaration> ;}\n\n<statement part> ::= BEGIN <statement> {; <statement>}\n{; <exception handler>} END\n\n<global routine> ::= <monitor declaration> |\n<routine declaration>\n\n<routine declaration> ::= <module declaration> |\n<function declaration> |\n<procedure declaration>\n\n<module declaration> ::=<module declaration> <block>\n\n<module heading> ::= MODULE <identifier> ;\n<export list> <import list>\n\n<export list> ::= EXPORTS <identifier> {, <identifier>} ;\n| <empty>\n\n<import list> ::= IMPORTS <identifier> {, <identifier>} ;\n| <empty>\n\n<monitor declaration> ::=<monitor declaration> <block>\n\n<monitor heading> ::= MONITOR <identifier> PRIORITY\n<priority level> ; <export list> <import list>\n\n<priority level> ::= <constant>\n\n<procedure declaration> ::= <procedure heading> <block>\n\n<procedure heading> ::= <possibly extra> PROCEDURE\n<identifier> <parameters> ;\n\n<function declaration> ::= <function heading> <block>\n\n<function heading> ::= <possibly extra> FUNCTION <identifier>\n<parameters> : <result type> ;\n\n<parameters> ::= ( <formal parameter section>\n{; <formal parameter section>} ) | <empty>\n<formal parameter section> ::= <parameter group> | \n VAR <parameter group>\n\n<parameter group> ::= <identifier> {, <identifier>} : *\n <possibly extra> <type identifier>\n\n<block> ::= <label declaration part>\n <entry declaration part> *\n <exit declaration part> *\n <invariant declaration part> *\n <effect declaration part> *\n <depth declaration part> *\n <constant definition part> *\n <type definition part> *\n <value declaration part> *\n <variable declaration part> *\n <routine declaration part> *\n <statement part>\n\n[value declaration] ::= <identifier> =\n <type identifier> ( <value list> )\n\n[value list] ::= <value> {, <value> }\n\n[value] ::= <constant> | ( <value list> )\n\n[compound statement] ::= BEGIN <statement> {; <statement>} END\n\n[statement] ::= <unlabeled statement> | \n <label> : <unlabeled statement> | \n PROOF <unlabeled statement> | \n <verification statement>\n\n[verification statement] ::= <assert statement> | \n <summary statement>\n\n[unlabeled statement] ::= <simple statement> | \n <structured statement>\n\n[simple statement] ::= <assignment statement> | \n <procedure statement> | \n <init statement> | \n <send statement> | \n <wait statement> | \n <raise statement> | \n <empty statement>\n<structured statement> ::= <compound statement> |\n <conditional statement> |\n <repetitive statement> |\n <with statement>\n\n<exception handler> ::= \n WHEN <exception spec> DO <statement>\n\n<exception spec> ::= <exception name> {, <exception name>} | \n OTHERS\n\n<exception name> ::= <identifier>\n\n<constant definition> ::= <identifier> = <constant>\n\n<constant> ::= <unsigned constant> | <sign> <unsigned constant>\n\n<type definition> ::= <identifier> = <type>\n\n<type> ::= <simple type> | <structured type>\n\n<simple type> ::= <ordinal type> | \n <fixed point type> | \n <signal type>\n\n<ordinal type> ::= <enumerated type> | \n <subrange type> | \n <type identifier> |\n\n<enumerated type> ::= ( <identifier> {, <identifier>} )\n\n<subrange type> ::= <constant> .. <constant>\n\n<type identifier> ::= <identifier>\n\n<fixed point type> ::= FIXED <constant> .. <constant>\n PRECISION <constant>\n\n<signal type> ::= SIGNAL <hardware mapping>\n\n<structured type> ::= <unpacked structured type> |\n PACKED <unpacked structured type> |\n DEVICE <hardware mapping> <field list> END\n\n<hardware mapping> ::= [ <address> ] | <empty>\n<address> ::= <expression>\n\n<unpacked structured type> ::= <array type> | <record type> | <set type>\n\n<array type> ::= ARRAY [ <index type> {, <index type>} ] OF <component type>\n\n<index type> ::= <ordinal type>\n\n<component type> ::= <type>\n\n<record type> ::= RECORD <field list> END\n\n<field list> ::= <fixed part> | <fixed part> ; <variant part> | <variant part>\n\n<fixed part> ::= <record section> {, <record section>}\n\n<record section> ::= <field identifier> {, <field identifier>} *\n\n<variant part> ::= CASE <tag field> <possibly extra>\n\n<type identifier> OF <variant> {; <variant>}\n\n<tag field> ::= <identifier> :\n\n<variant> ::= <case label list> : ( <field list> ) | empty\n\n<set type> ::= SET OF <base type>\n\n<base type> ::= <simple type>\n\n<variable declaration> ::= <identifier> {, <identifier>} :\n\n<possibly extra> <type> *\n\n<possibly extra> ::= empty | EXTRA *\n\n<result type> ::= <type identifier>\n\n<assignment statement> ::= <variable> := <expression> | <function identifier> := <expression>\n<variable> ::= <entire variable> {<component part>}\n\n<component part> ::= [ <expression> {, <expression>} ] | . <field identifier>\n\n<entire variable> ::= <variable identifier> | <field identifier>\n\n<variable identifier> ::= <identifier>\n\n<field identifier> ::= <identifier>\n\n<expression> ::= <relation> *\n\n<relation> ::= <simple expression> <relation part> *\n\n<relation part> ::= <empty> | <relational operator> <relation> *\n\n<relational operator> ::= = | <> | '<' | '<=' | '>' | IN | IMPLIES *\n\n<simple expression> ::= <unsigned simple expression> | <sign> <unsigned simple expression>\n\n<sign> ::= + | -\n\n<unsigned simple expression> ::= <term> <addend>\n\n<addend> ::= <empty> | <adding operator> <unsigned simple expression>\n\n<adding operator> ::= + | - | OR\n\n<term> ::= <factor> <multiplier part>\n\n<multiplier part> ::= <empty> | <multiplying operator> <term>\n\n<multiplying operator> ::= * | / | DIV | MOD | AND\n\n<factor> ::= <variable> | <unsigned constant> | ( <expression> ) | <function designator> | <set> | NOT <factor>\n\n<unsigned constant> ::= <unsigned number> | <string> | <constant identifier>\n\n<constant identifier> ::= <identifier>\n<while statement> ::= WHILE <expression> DO <loop body>\n<repeat statement> ::= REPEAT <loop body>\nUNTIL <expression>\n\n<for statement> ::= FOR <control variable> := <for list> DO\n<loop body>\n\n<for list> ::= <initial value> <direction> <final value>\n<direction> ::= TO | DOWNTO\n<control variable> ::= <identifier>\n<initial value> ::= <expression>\n<final value> ::= <expression>\n\n<loop body> ::= BEGIN {<statement> ;} <state statement>\n<optional measure statement> {; <statement>} END\n\n<optional measure statement> ::= ; <measure statement> | <empty>\n\n<with statement> ::= WITH <record variable list> DO <statement>\n<record variable list> ::= <record variable> {, <record variable>}\n<record variable> ::= <identifier>\n\n<init statement> ::= INIT <monitor identifier>\n<monitor identifier> ::= <identifier>\n\n<raise statement> ::= RAISE <exception name>\n\n<send statement> ::= SEND <signal name>\n\n<wait statement> ::= WAIT <signal name>\n\n<assert statement> ::= ASSERT ( <expression> {, <expression>} )\n\n<summary statement> ::= SUMMARY ( <expression> {, <expression>} )\n\n<state statement> ::= STATE ( <expression> {, <expression>} )\n\n<measure statement> ::= MEASURE ( <expression> )\n5. Examples\n\nThe examples in this chapter are designed to aid the user in learning to use the Verifier. For the first example, a square root calculation, verification conditions have been generated by hand and informal proofs given. This example is intended to give the user some insight into how the Verifier examines programs.\n\nThe second example, a set of routines for managing a circular buffer, shows the use of the verifier to verify only absence of run-time errors, and the maintenance of a simple invariant. It is useful to note how few assertions were required. This example has been passed by the Verifier in the form shown.\n\nThe third example, a very simple-minded engine control program, is intended to illustrate the use of assertions and proof variables in constructing a verifiable Pascal-F program. It also illustrates means of programming within the restrictions required for a reliable and verifiable multi-process program. This example also has been passed by the Verifier.\n\n5.1 A simple example worked by hand\n\nIn this example the reader is taken ‘behind the scenes’, so to speak, to see how program verification can be performed manually. The function shown here is a fixed point square root routine. In addition to the normal proof of runtime-error-free operation, a full proof of correctness is attempted, which is to say that we actually try to prove that the function computes square root to within some explicit error bound. This example is rather more complex mathematically than most parts of control programs, and as will be seen the verification conditions generated are sometimes difficult mathematically, especially when one bears in mind that the rules of fixed-point arithmetic are being interpreted strictly.\nFigure 1. Function before addition of verification statements\n\n(*\n Square root by bisection\n\n This technique has the useful property that it will work for any monotonic function.\n*)\n\nFUNCTION sqrt(s: FIXED 2.0 .. 100.0 PRECISION 0.1):\n FIXED 1.0 .. 10.0 PRECISION 0.1;\nVAR\n x, lowbound, highbound: FIXED 1.0 .. 100.0 PRECISION 0.1;\nBEGIN\n x := s; (* set initial try *)\n lowbound := 1.0; (* lowest possible square root *)\n highbound := x; (* highest possible *)\n (* stop when interval tiny *)\n WHILE highbound - lowbound > 0.1 DO\n BEGIN (* choose new trial value *)\n x := (highbound + lowbound) / 2;\n IF x*x > s THEN BEGIN (* if x is too big *)\n highbound := x; (* then answer must be below x *)\n END ELSE BEGIN (* if x is too small *)\n lowbound := x; (* then answer must be above x *)\n END;\n END;\n sqrt := x; (* return answer *)\nEND; (* of sqrt *)\n\nThe first step in documenting the function for verification is to define what the procedure is supposed to do. This is simple in this case, because square root is easy to define. An exit assertion of the form\n\n EXIT abs(x * x - s) < 0.2;\n\ndescribes the desired result.\n\nThe next step is to figure out how to prove that the function will produce the desired result. We can prove this by noting the following facts about the situation that exists when the loop exits.\n\n- x is between lowbound and highbound\n- s is between lowbound squared and highbound squared\n- lowbound is less than or equal to highbound\n• lowbound is within 0.1 of highbound\n\nAll these conditions except the last hold for every iteration of the loop, and thus form part of the loop invariant. These insights must be provided to the verifier in a STATE statement.\n\nProving that the loop terminates requires that we find some measure that decreases as the loop iterates. Since the algorithm operates by closing the interval between highbound and lowbound, the difference between these two is a suitable value to appear in the MEASURE statement.\nFigure 2. Function after addition of verification statements\n\n(*\n\nSquare root by bisection\n\nThis technique has the useful property that it it will work for any monotonic function.\n*)\n\nFUNCTION sqrt(s: FIXED 2.0 .. 100.0 PRECISION 0.1):\n FIXED 1.0 .. 10.0 PRECISION 0.1;\nEXIT abs(sqrt*sqrt - s) <= 0.2; (* definition of result *)\n\nVAR\n x, lowbound, highbound: FIXED 1.0 .. 100.0 PRECISION 0.1;\nBEGIN\n x := s; (* set initial try *)\n lowbound := 1.0; (* lowest possible square root *)\n highbound := x; (* highest possible *)\n (* stop when interval tiny *)\n WHILE highbound - lowbound > 0.1 DO\n BEGIN\n MEASURE highbound - lowbound;\n STATE lowbound*lowbound <= s,\n highbound*highbound >= s,\n highbound >= lowbound,\n x <= highbound,\n x >= lowbound;\n (* choose new trial value *)\n x := (highbound + lowbound) / 2;\n IF x*x > s THEN BEGIN (* if x is too big *)\n highbound := x; (* then answer must be below x *)\n END ELSE BEGIN (* if x is too small *)\n lowbound := x; (* then answer must be above x *)\n END;\n END;\n sqrt := x; (* return answer *)\nEND;\n\nWe can now attempt actual verification. The first step in verification is to trace out all possible paths of control flow. Paths begin and end at the boundaries of procedures and at STATE statements. There are thus six paths in this function.\n\n1. The path starting at the beginning of the function, treating the WHILE condition as true, and ending at the STATE statement.\n2. The path starting at the beginning of the function, treating the WHILE condition as false, and ending at the end of the procedure.\n\n3. The path starting at the STATE statement, treating the IF condition as true, going around the loop, treating the WHILE condition as true, and ending at the STATE statement.\n\n4. The path starting at the STATE statement, treating the IF condition as false, going around the loop, treating the WHILE condition as true, and ending at the STATE statement.\n\n5. The path starting at the STATE statement, treating the IF condition as true, going around the loop, treating the WHILE condition as false, and ending at the end of the procedure.\n\n6. The path starting at the STATE statement, treating the IF condition as false, going around the loop, treating the WHILE condition as false, and ending at the end of the procedure.\n\nAfter working out the control flow in the program, the next step is to locate all the assertions which must be verified for the path and generate a verification condition for each. Assertions come not only from the user’s EXIT and STATE statements but from internal requirements needed to prevent run-time errors.\n\nFor the first path, it is necessary to verify all the following conditions.\n\n1. A range error does not occur at ‘x := s’. (No problem, the type of x has less restrictive bounds than that of s.)\n\n2. A range error does not occur at ‘lowbound := 1.0’. (No problem, the constant value is in the correct range.)\n\n3. A range error does not occur at ‘highbound := x’. (No problem, the types match.)\n\n4. The value in the MEASURE statement is non-negative. (Since lowbound is 1.0, and highbound is constrained by its type to be 2.0 or greater, this requirement is met.) Note that we are only concerned with the first time through the loop on this path.\n\n5. The STATE assertion ‘lowbound * lowbound <= s’ holds. (Since 1.0 * 1.0 <= 2.0, this holds.)\n\n6. The STATE assertion ‘highbound * highbound >= s’ holds. (Since on this path highbound = x, we need only prove that x > 2.0 IMPLIES x*x > x.)\n\n7. The STATE assertion ‘highbound >= lowbound’ holds. (We know that highbound is not less than than 2.0 and that lowbound is 1.0, so this is no problem.)\n\n8. The STATE assertion ‘x <= highbound’ holds. (x is equal to highbound; no problem.)\n\n9. The STATE assertion ‘x >= lowbound’ holds. (We know that lowbound is 1.0, and that x is 2.0 or greater, so this is no problem.)\n\nProceeding on to path two, the path on which the WHILE statement body is never\nexecuted, we find an interesting phenomenon. The loop is entered under the following conditions:\n\n\\[\n\\begin{align*}\n\\text{lowbound} &= 1.0 \\\\\n\\text{highbound} &\\geq 2.0\n\\end{align*}\n\\]\n\nFor path two to be executed, the condition for exiting the loop,\n\n\\[\\text{NOT}(\\text{highbound} - \\text{lowbound} > 0.1)\\]\n\nwould have to be true at initial entrance to the loop. Since these three conditions cannot all be true simultaneously, this path is never executed, and the loop body is always executed at least once when the function is called. All verification conditions for this path are true since the requirement for entry is false. Note that there is no dead code; there merely is no case where a specific set of decisions are taken when passing through several conditional statements. It is not unusual for this to happen and this presents no problems.\n\nWe now reach the first of the two interesting paths, the one around the loop taking the true branch at the IF statement. This path starts and ends at the STATE statement. The STATE statement defines the loop invariant. We have already proved (for path one) that the loop invariant is true at entry to the loop. We must now prove that if the loop invariant is true for a given iteration of the loop, it will still be true at the end of that iteration. By proving this, we prove by induction that the loop invariant is true for every iteration of the loop.\n\nThis path is complex enough that each verification condition is written out formally as a proposition to be proven.\n\n1. The first verification condition is produced by trying to prove that the invariant condition\n\n\\[\\text{lowbound} \\times \\text{lowbound} \\leq x\\]\n\nholds. The verification condition generated is\nlowbound \\geq 1.0 \\text{ AND } lowbound \\leq 100.0\n\\text{ AND } highbound \\geq 1.0 \\text{ AND } highbound \\leq 100.0\n\\text{ AND } s \\geq 2.0 \\text{ AND } s \\leq 100.0\n\\text{ AND } lowbound \\times lowbound \\leq s\n\\text{ AND } highbound \\times highbound \\geq s\n\\text{ AND } highbound \\geq lowbound\n\\text{ AND } x \\leq highbound\n\\text{ AND } x \\geq lowbound\n\\text{ AND } x_{\\text{NEW}} = (\\text{highbound} + \\text{lowbound}) / 2\n\\text{ AND } x_{\\text{NEW}} \\times x_{\\text{NEW}} > s\n\\text{ AND } \\text{highbound}_{\\text{NEW}} = x_{\\text{NEW}}\n\\text{ AND } \\text{highbound}_{\\text{NEW}} - \\text{lowbound} > 0.1\n\\text{ IMPLIES }\nlowbound \\times lowbound \\leq s;\n\nThis simplifies to\n\n\\text{ lowbound } \\times \\text{ lowbound } \\leq s\n\\text{ IMPLIES }\n\\text{ lowbound } \\times \\text{ lowbound } \\leq s;\n\nwhich is obviously true. This is a trivial case, because lowbound did not change on this path.\n\n2.\n\nlowbound \\geq 1.0 \\text{ AND } lowbound \\leq 100.0\n\\text{ AND } highbound \\geq 1.0 \\text{ AND } highbound \\leq 100.0\n\\text{ AND } s \\geq 2.0 \\text{ AND } s \\leq 100.0\n\\text{ AND } lowbound \\times lowbound \\leq s\n\\text{ AND } highbound \\times highbound \\geq s\n\\text{ AND } highbound \\geq lowbound\n\\text{ AND } x \\leq highbound\n\\text{ AND } x \\geq lowbound\n\\text{ AND } x_{\\text{NEW}} = (\\text{highbound} + \\text{lowbound}) / 2\n\\text{ AND } x_{\\text{NEW}} \\times x_{\\text{NEW}} > s\n\\text{ AND } \\text{highbound}_{\\text{NEW}} = x_{\\text{NEW}}\n\\text{ AND } \\text{highbound}_{\\text{NEW}} - \\text{lowbound} > 0.1\n\\text{ IMPLIES }\n\\text{ highbound}_{\\text{NEW}} \\times \\text{highbound}_{\\text{NEW}} \\geq s;\n\nwhich simplifies to\n\n\\text{ x}_{\\text{NEW}} \\times \\text{ x}_{\\text{NEW}} > s\n\\text{ IMPLIES }\n\\text{ x}_{\\text{NEW}} \\times \\text{ x}_{\\text{NEW}} \\geq s\nwhich is true.\n\n3.\n\n\\[\n\\begin{align*}\n\\text{lowbound} & \\geq 1.0 \\ \\text{AND} \\ \\text{lowbound} \\leq 100.0 \\\\\n\\text{AND} \\ \\text{highbound} & \\geq 1.0 \\ \\text{AND} \\ \\text{highbound} \\leq 100.0 \\\\\n\\text{AND} \\ s & \\geq 2.0 \\ \\text{AND} \\ s \\leq 100.0 \\\\\n\\text{AND} \\ \\text{lowbound} \\ast \\text{lowbound} & \\leq s \\\\\n\\text{AND} \\ \\text{highbound} \\ast \\text{highbound} & \\geq s \\\\\n\\text{AND} \\ \\text{highbound} & \\geq \\text{lowbound} \\\\\n\\text{AND} \\ x & \\leq \\text{highbound} \\\\\n\\text{AND} \\ x & \\geq \\text{lowbound} \\\\\n\\text{AND} \\ \\text{xNEW} & = (\\text{highbound} + \\text{lowbound}) / 2 \\\\\n\\text{AND} \\ \\text{xNEW} \\ast \\text{xNEW} & > s \\\\\n\\text{AND} \\ \\text{highboundNEW} & = \\text{xNEW} \\\\\n\\text{AND} \\ \\text{highboundNEW} - \\text{lowbound} & > 0.1 \\\\\n\\text{IMPLIES} \\\\\n\\text{highboundNEW} & \\geq \\text{lowbound};\n\\end{align*}\n\\]\n\nwhich simplifies to\n\n\\[\n\\begin{align*}\n\\text{lowbound} & \\geq 1.0 \\\\\n\\text{AND} \\ \\text{highbound} & \\geq 1.0 \\\\\n\\text{IMPLIES} \\\\\n(\\text{highbound} + \\text{lowbound}) / 2 & \\geq \\text{lowbound}\n\\end{align*}\n\\]\n\nwhich is true.\n\n4.\n\n\\[\n\\begin{align*}\n\\text{lowbound} & \\geq 1.0 \\ \\text{AND} \\ \\text{lowbound} \\leq 100.0 \\\\\n\\text{AND} \\ \\text{highbound} & \\geq 1.0 \\ \\text{AND} \\ \\text{highbound} \\leq 100.0 \\\\\n\\text{AND} \\ s & \\geq 2.0 \\ \\text{AND} \\ s \\leq 100.0 \\\\\n\\text{AND} \\ \\text{lowbound} \\ast \\text{lowbound} & \\leq s \\\\\n\\text{AND} \\ \\text{highbound} \\ast \\text{highbound} & \\geq s \\\\\n\\text{AND} \\ \\text{highbound} & \\geq \\text{lowbound} \\\\\n\\text{AND} \\ x & \\leq \\text{highbound} \\\\\n\\text{AND} \\ x & \\geq \\text{lowbound} \\\\\n\\text{AND} \\ \\text{xNEW} & = (\\text{highbound} + \\text{lowbound}) / 2 \\\\\n\\text{AND} \\ \\text{xNEW} \\ast \\text{xNEW} & > s \\\\\n\\text{AND} \\ \\text{highboundNEW} & = \\text{xNEW} \\\\\n\\text{AND} \\ \\text{highboundNEW} - \\text{lowbound} & > 0.1 \\\\\n\\text{IMPLIES} \\\\\n\\text{xNEW} & \\leq \\text{highboundNEW};\n\\end{align*}\n\\]\n\nwhich transitivity of equality shows to be true.\n5. The possibility that overflow might occur in the statement\n\n\\[ x := (\\text{highbound} + \\text{lowbound}) / 2; \\]\n\nmust be considered. The verification condition\n\n\\[\n\\begin{align*}\n\\text{lowbound} \\geq 1.0 & \\text{ AND } \\text{lowbound} \\leq 100.0 \\\\\n\\text{AND highbound} \\geq 1.0 & \\text{ AND } \\text{highbound} \\leq 100.0 \\\\\n\\text{AND s} \\geq 2.0 & \\text{ AND } s \\leq 100.0 \\\\\n\\text{AND lowbound} \\times \\text{lowbound} \\leq s & \\\\\n\\text{AND highbound} \\times \\text{highbound} \\geq s & \\\\\n\\text{AND highbound} \\geq \\text{lowbound} \\text{ IMPLIES } \\\\\n(highbound + lowbound) / 2 \\geq 1.0 & \\text{ AND } (highbound + lowbound) / 2 \\leq 100.0\n\\end{align*}\n\\]\n\ndescribes this, and this can be shown to always hold based solely on the restrictions on lowbound and highbound.\n\n6. It is necessary to prove that the loop terminates. This is done by showing that the value in the MEASURE statement decreases with each loop iteration but never becomes negative.\n\n\\[\n\\begin{align*}\n\\text{lowbound} \\geq 1.0 & \\text{ AND } \\text{lowbound} \\leq 100.0 \\\\\n\\text{AND highbound} \\geq 1.0 & \\text{ AND } \\text{highbound} \\leq 100.0 \\\\\n\\text{AND s} \\geq 2.0 & \\text{ AND } s \\leq 100.0 \\\\\n\\text{AND lowbound} \\times \\text{lowbound} \\leq s & \\\\\n\\text{AND highbound} \\times \\text{highbound} \\geq s & \\\\\n\\text{AND highbound} \\geq \\text{lowbound} & \\\\\n\\text{AND x} \\leq \\text{highbound} & \\\\\n\\text{AND x} \\geq \\text{lowbound} & \\\\\n\\text{AND xNEW} = (\\text{highbound} + \\text{lowbound}) / 2 & \\\\\n\\text{AND xNEW} \\times \\text{xNEW} > s & \\\\\n\\text{AND highboundNEW} = \\text{xNEW} & \\\\\n\\text{AND highboundNEW} - \\text{lowbound} > 0.1 & \\\\\n\\text{IMPLIES} \\\\\n(highboundNEW - lowbound) < (highbound - lowbound) & \\text{ AND } (highboundNEW - lowbound) \\geq 0)\n\\end{align*}\n\\]\n\nThis immediately reduces to\nlowbound >= 1.0 AND lowbound <= 100.0\nAND highbound >= 1.0 AND highbound <= 100.0\nAND highbound >= lowbound\nAND ((highbound + lowbound) / 2) - lowbound > 0.1\nIMPLIES\nAND (highbound + lowbound) / 2 < highbound;\nAND (highbound + lowbound) / 2 >= lowbound;\n\nwhich is true.\n\nThe next path to be considered is the same as the one above, except that the IF branch takes the ‘false’ path. We will spare the reader the details of this path, which are similar to those shown above.\n\nThe last two paths start at the STATE statement and go to the top of the loop, but exit at the WHILE statement rather than continuing in the loop, finally ending at the EXIT assertion. Let us first consider the path through the ‘true’ branch.\n\n1. The replacement\n\n\\[\n\\text{sqrt := x; (* return answer *)}\n\\]\n\nimplies a restriction on x that x is less than or equal to 10.0, because the type of the function ‘sqrt’ is FIXED 1.0 .. 10.0, while the type of ‘x’ is FIXED 1.0 .. 100.0, leading to the verification condition\n\n\\[\n\\begin{align*}\n\\text{lowbound} &\\geq 1.0 \\text{ AND } \\text{lowbound} &\\leq 100.0 \\\\\n\\text{AND highbound} &\\geq 1.0 \\text{ AND } \\text{highbound} &\\leq 100.0 \\\\\n\\text{AND } s &\\geq 2.0 \\text{ AND } s &\\leq 100.0 \\\\\n\\text{AND } \\text{lowbound} \\times \\text{lowbound} &\\leq s \\\\\n\\text{AND highbound} \\times \\text{highbound} &\\geq s \\\\\n\\text{AND highbound} &\\geq \\text{lowbound} \\\\\n\\text{AND x} &\\leq \\text{highbound} \\\\\n\\text{AND x} &\\geq \\text{lowbound} \\\\\n\\text{AND xNEW} &=(\\text{highbound} + \\text{lowbound}) / 2 \\\\\n\\text{AND xNEW} \\times \\text{xNEW} &> s \\\\\n\\text{AND highboundNEW} &\\text{=} xNEW \\\\\n\\text{AND highboundNEW} - \\text{lowbound} &\\leq 0.1 \\\\\n\\text{IMPLIES} \\\\\n\\text{xNEW} &\\leq 10.0;\n\\end{align*}\n\\]\n\nPerforming obvious simplifications, we obtain\n\\begin{verbatim}\nlowbound <= 100.0\nAND highbound <= 100.0\nAND lowbound * lowbound <= 100.0\nAND highbound * highbound >= 2.0\nAND highbound >= lowbound\nAND xNEW = (highbound + lowbound) / 2\nAND xNEW - lowbound <= 0.1\nIMPLIES\nxNEW <= 10.0;\n\\end{verbatim}\n\nwhich we fail to prove.\n\nLet us see why. A counterexample to the above verification condition is\n\n\\begin{verbatim}\nlowbound = 10.0\nhighbound = 10.2\nxNEW = 10.1\n\\end{verbatim}\n\nwhich would cause overflow. There are two possibilities to be considered; either the Verifier does not have enough correct information to constrain the value more, because of an ill-chosen STATE assertion, or the program contains a bug.\n\nIn this case, the program indeed contains a bug; an attempt to take the square root of 100.0 will compute a value of 10.1, which is within the desired error tolerance for the square root routine but not within the range of approved values for the function. This is a good example of the sort of bug the Verifier is good at finding but which might be overlooked without verification.\n\n2. Continuing onward, our last verification condition for this path is that the square root function gets the right answer, or\n\n\\begin{verbatim}\nlowbound >= 1.0 AND lowbound <= 100.0\nAND highbound >= 1.0 AND highbound <= 100.0\nAND s >= 2.0 AND s <= 100.0\nAND lowbound * lowbound <= s\nAND highbound * highbound >= s\nAND highbound >= lowbound\nAND x <= highbound\nAND x >= lowbound\nAND xNEW = (highbound + lowbound) / 2\nAND xNEW * xNEW > s\nAND highboundNEW = xNEW\nAND highboundNEW - lowbound <= 0.1\nIMPLIES\nabs(xNEW * xNEW - s) <= 0.2;\n\\end{verbatim}\n\nOpening up the definition of ‘abs’ gives us\nlowbound >= 1.0 AND lowbound <= 100.0\nAND highbound >= 1.0 AND highbound <= 100.0\nAND s >= 2.0 AND s <= 100.0\nAND lowbound * lowbound <= s\nAND highbound * highbound >= s\nAND highbound >= lowbound\nAND x <= highbound\nAND x >= lowbound\nAND xNEW = (highbound + lowbound) / 2\nAND xNEW * xNEW > s\nAND highboundNEW = xNEW\nAND highboundNEW - lowbound <= 0.1\nIMPLIES\n((xNEW * xNEW > s) AND (xNEW * xNEW - s) < 0.2))\nOR ((xNEW * xNEW < s) AND (s - xNEW * xNEW) < 0.2));\n\nwhich simplifies to\n\nlowbound >= 1.0 AND lowbound <= 100.0\nAND highbound >= 1.0 AND highbound <= 100.0\nAND s >= 2.0 AND s <= 100.0\nAND lowbound * lowbound <= s\nAND highbound * highbound >= s\nAND highbound >= lowbound\nAND xNEW = (highbound + lowbound) / 2\nAND xNEW * xNEW > s\nAND xNEW - lowbound <= 0.1\nIMPLIES\nxNEW * xNEW - s < 0.2;\n\nwhich if augmented by the previously proved information that xNEW is greater than or equal to lowbound, can, with some difficulty, proved true.\n\nThis completes the analysis of the example. One clear bug was found, as mentioned above; an attempt to compute the square root of 100 will result in an out-of-range result. This sort of boundary condition bug is common, and is one of the things which the Verifier is good at finding.\n\n5.2 Circular buffering routines\n\nThis simple example shows a common program component; a set of circular buffering routines. Here the Verifier has been used to show absence of run-time errors and the maintenance of a “sanity invariant” which if violated would indicate that the various pointers were out of synchronism.\n\nThe main program here is a dummy one; the object here is to verify the subroutines.\nprogram circle;\n{\n Circular Buffering Module Version 1.9 of 1/5/83\n}\nmonitor circlebuf priority 5;\nexports bufget, bufput;\nconst bufsize = 20;\ntype bufindex = 1 .. 20; { position in buffer }\nbufarray = array [bufindex] of char;\nbuffer = record { buffer structure }\n bufin: bufindex; { next position to insert }\n bufout: bufindex; { next position to read }\n bufcount: 0 .. bufsize; { chars in buffer }\n buf: bufarray; { the buffer itself }\nend;\nvar b: buffer; { the buffer }\ninvariant defined(b); { the buffer is always defined }\n { buffer sanity }\n ((b.bufout + b.bufcount) = b.bufin)\n or\n ((b.bufout + b.bufcount - bufsize) = b.bufin);\n{\n bufput -- put in buffer\n}\nfunction bufput(ch: char) { char to insert }\n : boolean; { returns true if insert OK }\nbegin\n if b.bufcount < bufsize then begin { if buffer not full }\n b.bufcount := b.bufcount + 1; { increment buffer count }\n b.buf[b.bufin] := ch; { store char in buffer }\n assert(defined(b.buf, 1, bufsize)); { array still defined }\n if b.bufin = bufsize then { if max }\n b.bufin := 1 { reset to start }\n else b.bufin := b.bufin + 1; { otherwise increment }\n bufput := true; { success }\n end else begin { if full }\n bufput := false; { insert fails }\n end;\nend {bufput};\n{ bufget -- get from buffer }\n\nfunction bufget(var ch: char) : boolean;\n{ char returned }\n{ true if successful }\n{ char only if not empty }\nexit return implies defined(ch);\nbegin\n if b.bufcount > 0 then begin\n b.bufcount := b.bufcount - 1;\n assert(defined(b));\n ch := b.buf[b.bufout];\n if b.bufout = bufsize then\n b.bufout := 1\n else b.bufout := b.bufout + 1;\n bufget := true;\n end else bufget := false;\nend {bufget};\n\n{ buffer initialization block }\n\nvar i: bufindex;\nbegin\n for i := 1 to 20 do begin\n b.buf[i] := ' ';\n assert(defined(b.buf,1,i-1));\n state(defined(i),\n defined(b.buf,1,i));\n end;\n b.bufout := 1;\n b.bufin := 1;\n b.bufcount := 0;\nend {circlebuf};\n\nvar stat: boolean;\nch: char;\nbegin {main}\n init circlebuf;\n stat := bufput('x');\n stat := bufget(ch);\n if stat then begin\n end;\nend.\nThe Verifier can verify these routines in about four minutes. This verification does require rules, but all the rules needed are in the Rule Builder’s standard database.\n\nVerifying circle\nNo errors detected\n\nVerifying circlebuf\nNo errors detected\n\nVerifying circlebuf-bufget\nNo errors detected\n\nVerifying circlebuf-bufput\nNo errors detected\n\n5.3 An example in the form of an engine control program\n\nThe “engine control” program here is not related to any real engine or control electronics. It is an example of a way in which a real-time program might be written. The program was written primarily to illustrate the kinds of things one might attempt to prove about a program of this type. It also demonstrates that it is not overly difficult to program under the restriction that monitors may not import or export variables. The program was written two years before the Verifier was operational, and appeared in a preliminary version of this manual.\n\nThis program has been verified by the Verifier. Quite a number of bugs were found in the program during the process. Most of the work in getting the Verifier to accept the program was in discovering the invariants needed for the excluder module. Most of the bugs found were related to proper handling of failure of the clock or crankshaft interrupts. Note that the invariants provided to check proper engine operation now hold even if the crankshaft interrupt or clock interrupt never comes. For example, there is code to fire the spark (belatedly) if the next crankshaft interrupt comes in before the spark has been fired under normal timing rules. This code was required before the constraint of one-spark-per-crank-pulse could be met.\nThis is a sample program written to illustrate some features of Pascal-F as extended for verification purposes. The program has a rather simple-minded model of the engine, and controls only the fuel pump and spark. The only inputs available to the program are the clock, and the shaft position pulse.\n\nThis program does not interface with any existing engine hardware.\n\nJohn Nagle\nFord Aerospace and Communications Corporation\nWestern Development Labs\n\nconst\nmaxticks = 1000; (* biggest time value *)\nmaxrpm = 8000; (* largest possible RPM *)\nms = 2; (* unit of time is 500 us *)\ncylinders = 8; (* size of engine *)\nmaxsparkretard = 30; (* max retard angle *)\nmustrecalc = 10; (* 10 rpm change forces recalc *)\nstalllim = 200*ms; (* after 0.2 secs, stop fuel *)\ninterval = 2000; (* interval of spark table *)\ntablemax = 15; (* max entry in table *)\n\n(* retard at 1000 rpm int*)\n\nconst\nmaxticks = 1000; (* biggest time value *)\nmaxrpm = 8000; (* largest possible RPM *)\nms = 2; (* unit of time is 500 us *)\ncylinders = 8; (* size of engine *)\nmaxsparkretard = 30; (* max retard angle *)\nmustrecalc = 10; (* 10 rpm change forces recalc *)\nstalllim = 200*ms; (* after 0.2 secs, stop fuel *)\ninterval = 2000; (* interval of spark table *)\ntablemax = 15; (* max entry in table *)\n\n(* retard at 1000 rpm int*)\n\n(* retard at 1000 rpm int*)\n\nconst\nmaxticks = 1000; (* biggest time value *)\nmaxrpm = 8000; (* largest possible RPM *)\nms = 2; (* unit of time is 500 us *)\ncylinders = 8; (* size of engine *)\nmaxsparkretard = 30; (* max retard angle *)\nmustrecalc = 10; (* 10 rpm change forces recalc *)\nstalllim = 200*ms; (* after 0.2 secs, stop fuel *)\ninterval = 2000; (* interval of spark table *)\ntablemax = 15; (* max entry in table *)\n\n(* retard at 1000 rpm int*)\n\nconst\nmaxticks = 1000; (* biggest time value *)\nmaxrpm = 8000; (* largest possible RPM *)\nms = 2; (* unit of time is 500 us *)\ncylinders = 8; (* size of engine *)\nmaxsparkretard = 30; (* max retard angle *)\nmustrecalc = 10; (* 10 rpm change forces recalc *)\nstalllim = 200*ms; (* after 0.2 secs, stop fuel *)\ninterval = 2000; (* interval of spark table *)\ntablemax = 15; (* max entry in table *)\n\n(* retard at 1000 rpm int*)\n\nconst\nmaxticks = 1000; (* biggest time value *)\nmaxrpm = 8000; (* largest possible RPM *)\nms = 2; (* unit of time is 500 us *)\ncylinders = 8; (* size of engine *)\nmaxsparkretard = 30; (* max retard angle *)\nmustrecalc = 10; (* 10 rpm change forces recalc *)\nstalllim = 200*ms; (* after 0.2 secs, stop fuel *)\ninterval = 2000; (* interval of spark table *)\ntablemax = 15; (* max entry in table *)\n\n(* retard at 1000 rpm int*)\n\nconst\nmaxticks = 1000; (* biggest time value *)\nmaxrpm = 8000; (* largest possible RPM *)\nms = 2; (* unit of time is 500 us *)\ncylinders = 8; (* size of engine *)\nmaxsparkretard = 30; (* max retard angle *)\nmustrecalc = 10; (* 10 rpm change forces recalc *)\nstalllim = 200*ms; (* after 0.2 secs, stop fuel *)\ninterval = 2000; (* interval of spark table *)\ntablemax = 15; (* max entry in table *)\n\n(* retard at 1000 rpm int*)\n\nconst\nmaxticks = 1000; (* biggest time value *)\nmaxrpm = 8000; (* largest possible RPM *)\nms = 2; (* unit of time is 500 us *)\ncylinders = 8; (* size of engine *)\nmaxsparkretard = 30; (* max retard angle *)\nmustrecalc = 10; (* 10 rpm change forces recalc *)\nstalllim = 200*ms; (* after 0.2 secs, stop fuel *)\ninterval = 2000; (* interval of spark table *)\ntablemax = 15; (* max entry in table *)\n\n(* retard at 1000 rpm int*)\n\ntype\nrpm = 0 .. maxrpm; (* revolutions per minute *)\nangle = 0..45; (* for shaft angles *)\nticks = 0..maxticks; (* for time measurement *)\ndelay = 0..stalllim; (* spark delay type *)\ntableindex = 0..5; (* index to retard table *)\ntableentry = 0..tablemax; (* entry in table *)\ntabletype = array [tableindex] of tableentry; (* a retard table *)\n\n(* i.e at 2000 rpm, 12 degree retard*)\n\nvalue sparktable = tabletype(15,12,8,6,2,0);\n(*\n Rule function used in proofs concerning spark retard table\n*)\nrule function nonincreasing(a: tabletype; i,j: tableindex): boolean;\nbegin end;\n\n(*\n Monitor for interlocking – within the monitor processing is sequential.\n\n There is no process associated with this monitor; it exists only to protect\n the shared variables. The processes clockprocess and shaftprocess use the\n procedures exported from this monitor.\n*)\nmonitor excluder priority 2;\nexports\ndoclocktick, (* called from clock monitor *)\ndoshaftpulse; (* called from crankshaft monitor *)\nimports\nnonincreasing,\nrpm, angle, ticks,\ntableindex, tableentry, tabletype, tablemax,\ndelay,\nsparktable,\nmustrecalc,\nmaxticks,\nmaxrpm,\ninterval,\nstalllim,\nexcluder,\nms, cylinders, maxsparkretard;\n(*\n hardware interfaces\n*)\ntype engineinterface = device\n fuelpumpswitch: boolean; (* fuel pump on-off *)\n firespark: boolean; (* store into here to fire *)\nend;\n\nconst minrps = 1; (* minimum revs/second *)\n (* largest time per rev *)\n maxtimeperrev = (ms * 1000) div minrps;\n (* worst-case spark delay *)\n maxsparkdelay = stalllim; (* worst-case spark delay *)\n\nvar\n (*\n monitor global variables\n *)\n engine: engineinterface[01000]; (* engine hardware i/o *)\n sparkdelay: 0..maxsparkdelay; (* between pulse and spark*)\n (* angle: pulse to spark *)\n enginespeed: rpm; (* actual engine speed *)\n fuelpumpon: boolean; (* last orders to fuel pump *)\n ticksuntilspark: 0..maxsparkdelay; (* ticks until next spark needed *)\n tickssinceshaft: ticks; (* ticks since crankshaft pulse *)\n oldenginespeed: rpm; (* speed at last spark recalc *)\n\n (*\n global proof variables\n these have no existence in the operational program\n and can be used only in verification statements.\n *)\n cylssincespark: extra integer;\n tickssincespark: extra integer;\ninvariant\n (*\nThe following invariants are invariants of the excluder module. These invariants must be true whenever control is not in the excluder module.\n *)\n\n (*\nThe following invariants describe real-world constraints to be proved about the program.\n *)\n\n (* if fuel pump is on, spark must occur soon*)\nfuelpumpon implies (tickssincespark < (1000*ms));\n\n (* fuel pump must be disabled if the engine is not rotating *)\n(enginespeed < rpm(1)) implies (not fuelpumpon);\n\n (* a spark must be issued for each cylinder pulse *)\ncylssincespark <= 1;\nThe following invariants are needed to help the proof process. They must be proven; they are not accepted as given.\n\n(* either we have a spark scheduled or we haven’t seen a cylinder pulse since the last spark *)\n\n((cylssincespark > 0) and (ticksuntilspark > 0))\nor ((cylssincespark = 0) and (ticksuntilspark = 0));\n\n(* the invariants below were introduced during the task of making the program verifiable *)\n\n(* if engine is running, spark delay must be set *)\n\n(enginespeed > 0) implies (sparkdelay > 0);\n(* also true for last time around *)\n\n(oldenginespeed > 0) implies (sparkdelay > 0);\n(* consistency of timers *)\n\n(cylssincespark = 0) implies (tickssinceshaft >= tickssincespark);\n(* upper bound on tickssincespark *)\n\n(enginespeed > 0) implies\n((tickssinceshaft + 2*stalllim) >= tickssincespark);\n(* consistency of tickssincespark *)\n\n(enginespeed > 0) implies\n((tickssincespark + ticksuntilspark) <= 2*stalllim);\n(* if timeout, stalled *)\n\n(tickssinceshaft > stalllim) implies (enginespeed = 0);\n(* fuel pump locked to engine speed *)\n\n(enginespeed > 0) = fuelpumpon;\n(* old speed reset after stall *)\n\n(oldenginespeed = 0) = (enginespeed = 0);\n(* definedness conditions *)\n\ndefined(enginespeed);\ndefined(ticksuntilspark);\ndefined(tickssinceshaft);\ndefined(fuelpumpon);\ndefined(cylssincespark);\ndefined(tickssincespark);\ndefined(oldenginespeed);\ndefined(sparkdelay);\ndefined(excluder);\n(*\n spark -- fire spark and update counters\n*)\nprocedure spark;\n exit tickssince = 0;\n cylssince = 0;\nbegin\n engine.modespark := true; (* fire spark *)\n proof tickssince := 0; (* update proof variables *)\n proof cylssince := 0;\nend (* spark *);\n\n(*\n fuelpumpset -- check engine speed and set fuel pump\n*)\nprocedure fuelpumpset;\nexit fuelpumpon = (engine.speed > 0); (* on iff engine running *)\nbegin\n fuelpumpon := engine.speed > 0; (* turn on iff engine running *)\n engine.fuelpumpswitch := fuelpumpon; (* DEVICE I/O *)\nend (* fuelpumpset *);\n(*\ndoclocktick -- called from clock monitor on every tick\nthis procedure issues the spark command when required, and\nturns the fuel pump on and off based on engine rpm.\n*)\nprocedure doclocktick;\nbegin\n\nproof if tickssincespark < maxticks then (* count time for\n spark proof *)\ntickssincespark := tickssincespark + 1;\n\nif tickssinceshaft < maxticks then (* avoid timer overflow *)\ntickssinceshaft := (* used to compute inverse of rpm *)\ntickssinceshaft + 1;\n\nif tickssinceshaft >= stalllim then (* check for stalled engine *)\nbegin\nenginespeed := 0; (* engine is not rotating *)\noldenginespeed := 0; (* forget past history *)\nproof cylssincespark := 0; (* forget about spark history *)\nproof tickssincespark := 0; (* forget about spark history *)\ntickssinceshaft := 0; (* forget about crank history *)\nticksuntilspark := 0; (* unschedule spark *)\nend;\n\n(* spark timing *)\nif ticksuntilspark > 0 then (* if spark scheduled *)\nbegin (* count down time until spark *)\nticksuntilspark := ticksuntilspark - 1;\nif ticksuntilspark = 0 then spark; (* fire spark if time *)\nend;\n\nfuelpumpset; (* decide fuel pump on/off *)\nend; (* doclocktick *)\nprocedure recalcretard;\nexit (enginespeed.old > 0) implies (sparkdelay > 0);\noldenginespeed = enginespeed.old;\n\n(* retard at 1000 rpm int*)\ntype tdiff = 0..tablemax;\nvar\n low, high: tableentry;\n diff: tdiff;\n offset: 0..interval;\n i: tableindex;\n\nconst tickspersec = 1000*ms;\n k = (tickspersec div 360) * 60;\nvar sparkretard: angle;\n delaywork: 0..45*k;\nbegin\n (* force case analysis for table *)\n assert(nonincreasing(sparktable,0,0)); (* table is monotonic *)\n assert(nonincreasing(sparktable,0,1)); (* table is monotonic *)\n assert(nonincreasing(sparktable,0,2)); (* table is monotonic *)\n assert(nonincreasing(sparktable,0,3)); (* table is monotonic *)\n assert(nonincreasing(sparktable,0,4)); (* table is monotonic *)\n assert(nonincreasing(sparktable,0,5)); (* table is monotonic *)\n\n i := tableindex(enginespeed div interval); (* calc table index *)\n assert(sparktable[i] >= sparktable[i+1]); (* goal for rule *)\n offset := enginespeed mod interval; (* offset from last entry *)\n low := sparktable[i]; (* table entry from low side *)\n high := sparktable[i+1]; (* table entry from high side *)\n assert(high <= low); (* this is a decreasing table *)\n diff := tdiff(low - high); (* difference in this interval *)\n (* linear interpolation *)\n sparkretard := angle(high + (diff * offset) div interval);\n assert(sparkretard <= maxsparkretard); (* not too much *)\n\n (* compute delay until spark *)\n sparkdelay := 0;\n (* assume 0 (no spark) *)\n if enginespeed > 0 then begin (* if engine turning *)\n (* compute spark delay *)\n delaywork := ((k*sparkretard) div enginespeed) + 1;\n end;\n(* avoid oversize delay at low rpm *)\n\nif delaywork <= (stalllim div 2) then\n sparkdelay := delay(delaywork);\nelse\n sparkdelay := delay(stalllim);\nend;\n\noldenginespeed := enginespeed; (* save speed at last calc *)\n\nend; (* recalcretard *)\n( *\n doshaftpulse -- handle crankshaft pulse\n*)\nprocedure doshaftpulse;\nvar speedchange: integer; (* local for calculation *)\nrpmwork: 0..20000; (* working RPM *)\nbegin\n if ticksuntilspark > 0 then begin (* if spark still in future *\n (* TROUBLE: clock may have failed *)\n spark; (* force spark now, poorly timed *)\n end;\n\n assert(cylssincespark = 0); (* must not miss spark *)\n proof cylssincespark (* we try to prove this never reaches 2 *)\n := cylssincespark + 1; (* engine speed computation *)\n\n if (tickssinceshaft > 0) then begin (* compute new rpm *)\n rpmwork := 1 + (60*ms*(1000 div cylinders)) div tickssinceshaft;\n assert(rpmwork > 0); (* must be running if cyl pulse *)\n if rpmwork > maxrpm then (* limit measured engine speed *)\n enginespeed := maxrpm\n else enginespeed := rpm(rpmwork);\n tickssinceshaft := 0; (* clear shaft timer *)\n end else begin (* TROUBLE: probable clock fail *)\n enginespeed := rpm(1); (* assume minimum RPM *)\n end;\n\n if oldenginespeed = 0 then begin (* engine just started *)\n ticksuntilspark := 0; (* clear all timers and counters *)\n tickssinceshaft := 0;\n proof tickssincespark := 0;\n recalcretard; (* recalc spark retardation *)\n end else begin (* engine did not just start *)\n speedchange := enginespeed - oldenginespeed; (* calc speed change *\n (* take abs value *)\n if speedchange < 0 then speedchange := - speedchange;\n if (speedchange > mustrecalc) then (* if big change *)\n recalcretard; (* go recalculate spark *)\n end; (* end time to recalculate *)\n\n ticksuntilspark := sparkdelay; (* schedule next spark *)\n fuelpumpset; (* turn fuel pump on *)\nend (* doshaftpulse *);\nbegin\n(*\n initialization\n*)\n enginespeed := 0; (* start with engine stopped *)\nticksuntilspark := 0;\ntickssinceshaft := 0;\nsparkdelay := 0;\nfuelpumpon := false;\nproof cylssincespark := 0;\nproof tickssincespark := 0;\noldenginespeed := 0; (* original speed is zero *)\nend; (* excluder *)\n\n(*\n shaft signal process - once per cylinder time\n*)\nmonitor shaftpulse process priority 2;\nimports excluder, rpm, doshaftpulse;\nentry defined(excluder); (* must be defined at INIT *)\ninvariant defined(excluder); (* must stay defined *)\n\nvar\n shaftpulse: signal[0002B]; (* crankshaft pulse interrupt *)\n\n(*\n shaft processing loop\n*)\nbegin\n while true do begin\n wait(shaftpulse); (* wait for shaft pulse *)\n doshaftpulse; (* handle shaft pulse *)\n state(defined(excluder)); (* loop invariant *)\n end;\nend; (* shaftprocess *)\n(*\n clock monitor\n \n all the processing is done in the shaft monitor.\n*)\n\nmonitor clockprocess priority 2; (* from shaft *)\nimports excluder, doclocktick; (* must be defined at INIT *)\nentry defined(excluder); (* must stay defined *)\ninvariant defined(excluder); (* must stay defined *)\nvar hardwareclock: signal[0004B]; (* clock interrupt *)\nbeginn\n while true do\n begin wait(hardwareclock); (* wait for clock interrupt *)\n doclocktick; (* handle clock interrupt *)\n state(defined(excluder)); (* loop invariant *)\n end;\n end; (* end of clock monitor *)\n\n(*\n main program\n*)\nbegin\n init excluder; (* initialize variables *)\n init shaftprocess; (* start crankshaft process *)\n init clockprocess; (* start clock process *)\nend.\n\nVerification of this program takes about one hour and seven minutes on a VAX 11/780, without any previous history being available. This does not include the building of some necessary rules about the function nonincreasing with the Rule Builder. are sufficient to verify this program.\nVerifying clockprocess\nNo errors detected\n\nVerifying excluder\nNo errors detected\n\nVerifying excluder-doclocktick\nNo errors detected\n\nVerifying excluder-doshaftpulse\nNo errors detected\n\nVerifying excluder-fuelpumpset\nNo errors detected\n\nVerifying excluder-recalcretard\nNo errors detected\n\nVerifying excluder-spark\nNo errors detected\n\nVerifying shaftprocess\nNo errors detected\n\nVerifying simpleengine\nNo errors detected\n\n6. Rules\n\nIt is possible to prove quite complex things about programs with the Verifier. In order to accomplish this, the user must define rule functions which represent the properties to be proven and must prove rules about them using the rule builder. We will illustrate this with a simple example, going into considerable detail on how to go about doing such things.\n\n6.1 An introduction to rules\n\nConsider the following simple program fragment.\nHere we have cleared an array to zero, and somewhere further along in the program we need to be sure that a specific element in the array is zero. To do this we will need some way to express the concept that all the elements in the array are zero. Since there is no built-in way in Pascal to talk about the values of all the elements in an array in a collective sense, it is necessary to introduce a means for doing this.\n\nIn the is case we introduce a rule function called allzero. We define it in Pascal-F with the declaration\n\n```\nrule function allzero(a: tab; i,j: tabix): boolean; begin end;\n```\n\nHere, the keyword rule identifies this as a rule function. Rule functions are used only for verification purposes and are ignored by the compiler. Rule functions may not have function bodies or entry and exit assertions; they have only a minimal declaration as shown in the example.\n\nRule functions are useful only when some rules about them have been proven. We will define allzero informally as being true if the array elements of $a$ are all zero from element $i$ to element $j$ inclusive and false otherwise. Some useful rules for allzero are\n\n$$(j < i) \\implies \\text{allzero}(a,i,j)$$\n\nwhich says that allzero is vacuously true if the the upper bound is less than the lower bound;\n\n$$(i = j) \\implies (\\text{allzero}(a,i,j) = (a[i] = 0))$$\n\nwhich tells us that if both bounds are the same, the value of allzero is equal to true if the value at the bounds is true and false otherwise;\n\n$$(\\text{allzero}(a,i,j) \\text{ and } (a[j + 1] = 0)) \\implies \\text{allzero} (a,i,j + 1)$$\n\nwhich states that if allzero is true from $i$ to $j$ and $a[j + 1] = 0$ then allzero is true from $i$ to $j + 1$;\n\n$$(\\text{allzero}(a,i,j) \\text{ and } ((x < i) \\text{ or } (x > j)))$$\n\nimplies allzero ($<a,x,v>$,i,j),\n\n(where the strange notation $<a,x,v>$ means “the array $a$ with element $x$ replaced by $v$ which says that if allzero was true from $i$ to $j$, storing into an element $x$ outside the range $i$\nto \\( j \\) will not destroy the \\textit{allzero} property; and finally\n\n\\[(\\text{allzero}(a,i,j) \\text{ and } (x \\geq i) \\text{ and } (y \\leq j)) \\implies (a[i] = 0)\\]\n\nwhich allows us to use the information that \\textit{allzero} is true for a range of values to prove that a specific value is zero.\n\nFor the time being, we will ignore where these rules came from and will concentrate on what can be done with them. Going back to our program, it is clear that we are going to want to prove\n\n\\[\n\\text{allzero}(\\text{table1}, 1, 100)\n\\]\n\nat the end of the \\textbf{for} loop. This implies that a loop invariant, a \\texttt{state} statement, will be required to describe the situation which is true at each iteration of the loop.\n\nOne minor complication is that it is not obvious to the Verifier that storing into \\texttt{table1[i]} does not change the fact that \\textit{allzero} is true from 1 to \\( i-1 \\). We are going to need a rule that tells the Verifier that out-of-bounds stores don’t cause \\textit{allzero} to become false. Also, the rule handler in the Verifier only uses one rule between any two statements. We thus will have to put an assertion in the program that the previous \\texttt{STATE} is still true after the assignment statement. Since \\( i \\) has increased by 1, this assertion will be that \\textit{allzero} is true from 1 to \\( i-1 \\). So now let us see the program with the addition of the required assertions.\n\n```plaintext\ntype tabix = 1..100;\ntype tab = array [tabix] of integer;\nrule function allzero(a: tab; i, j: tabix): boolean; begin end;\nvar table1: tab;\ni, j: tabix;\n...\nfor i := 1 to 100 do begin\n table1[i] := 0;\n assert(allzero(table1, 1, i-1));\n state(allzero(table1, 1, i));\nend;\nassert(allzero(a, 1, 100));\n...\nassert(table1[j] = 0); { table1[j] must be 0 }\n```\n\nEach time through the loop, \\textit{allzero} becomes true for one more element, and \\textit{allzero} is then true from 1 up to the loop index.\n\nGiven the rules described, the verifier is able to prove all the assertions in the program fragment automatically.\n\nTypically, the user will be provided with a knowledge base containing a library of rules which cover most common situations in programming, and will be able to proceed much as shown above. In the next chapter, we will return to the example above and show in\n6.2 Rules and the Verifier\n\n6.2.1 How the Verifier applies rules\n\nRules are almost always of the form\n\n\\[ A \\implies B \\]\n\nwhere \\( A \\) is referred to as the hypothesis and \\( B \\) as the conclusion. The Verifier, when trying to prove something such as\n\n\\[\n\\text{assert(allzero(a, i, j));}\n\\]\n\nwhere \\text{allzero} is a rule function, will search the database for rules with conclusions of the form\n\n\\[\n\\text{allzero(x,y,z)}\n\\]\n\nand will then apply the rule by binding each free variable in the rule to the corresponding expression in the form being proven. This process is called \\text{instantiating} the rule, because the general form of the rule has now been applied to a specific instance. The Verifier will try every applicable rule in every legitimate way, but will not apply a rule to a form introduced by a rule. In other words, the Verifier applies rules only one deep. It is the user’s job to add assertions to the source program so that between any two assertions the application of only one rule is required. How to do this was described in detail in chapter 2.\n\n6.2.2 How the rules get to the Verifier\n\nRules are created with the Rule Builder (described in the next chapter) and made available to the Verifier with the \\text{putrules} utility program. The Rule Builder creates a \\text{knowledge base} file, which may be used for verifying several different programs. The rules being used in a given verification must be placed in a \\text{ruledatabase} file. There is one such file for each program being verified, and this file resides in the directory of work files used by the verifier for each program being verified. The directory has the name\n\n\\[\n<\\text{programname}>_d\n\\]\n\nwhere the program being verified has the name\n\n\\[\n<\\text{programname}>.pf\n\\]\n\nThis directory is created by the Verifier the first time an attempt is made to verify a given program, and is never deleted by the Verifier. The \\text{ruledatabase} and \\text{history} files, along with all the scratch files used during verification, reside in this directory, which is managed entirely by the Verifier. The user should not alter any file in the work file directory at any time.\n6.2.2.1 The putrules utility\n\nThe putrules utility reads a knowledge base file and creates a ruledatabase file. It is invoked with the call\n\n```\nputrules <knowledge base> <program>_d\n```\n\nwhere program is the name of the program (not including the trailing .pf ) being verified. Putrules can only be run after the verification of the program has been tried at least once and the Verifier’s work directory <program>_d created by the Verifier. After any change to the knowledge base, it is necessary to rerun putrules to make the changes in the knowledge base available to the Verifier.\n\nIf the changes to the knowledge base included the alteration or deletion of any rule function definition, putrules will print a message so stating and will clear the history of successfully verified routines, so that a full reverification will be performed the next time the Verifier is invoked. This check is required to insure soundness.\n\n6.2.3 Standard knowledge bases\n\nStandard knowledge bases may be created. A knowledge base may contain information useful for verifying more than one program. For example, the information about allzero above would be useful in any program that cleared arrays to zero. One useful knowledge base is the Rule Builder’s built-in knowledge base. This knowledge base is called verifier and is usually sufficient (and necessary) for programs which contain no user-provided rule functions but do contain instances of the 3-argument form of DEFINED for proving the definedness of parts of arrays.\n\nUsually a copy of this knowledge base is maintained in a well-known place on each system on which the Verifier is installed. But a copy of this knowledge base can be obtained, if required, by invoking the Rule Builder and, without proving any new theorems, using the Rule Builder command\n\n```\n(MAKE-LIB 'verifier)\n```\n\nwhich will create the knowledge base files verifier.lib and verifier.lisp in the current directory.\n\n7. The rule builder\n\nIn the previous chapter, the concept of verification using rules was introduced. These rules must be created by the user and proven with machine assistance. The rule builder is a tool used with the Verifier proper to construct sound new rules and thus provide the Verifier with more knowledge.\n\n7.1 Introduction\n\nUsing the Rule Builder requires a substantially greater level of expertise in both formal mathematics and verification than does using the Verifier proper.\n\nThe Rule Builder is a version of the Boyer-Moore theorem prover initialized with a knowledge base compatible with the Verifier’s built-in knowledge. It is a difficult\nprogram to use, and requires some training in formal logic to use successfully. Not all users of the Verifier need be familiar with the Rule Builder, but users must have access to someone with this expertise for assistance when a verification requires a new rule.\n\n### 7.1.1 Required reading\n\nBefore attempting to use the rule builder, it is necessary to become familiar with three documents. The first of these is the book *A Computational Logic*, by Robert S. Boyer and J. Strother Moore, published in 1979 by Academic Press, New York, NY. This book describes the theory upon which the prover is based. Chapters 1, 2, and 3 should be studied closely, and reading the entire text while trying out some of the examples is advisable.\n\nSome knowledge of the Franz Lisp implementation of Lisp is required. The reference manual is provided with the Berkeley UNIX distribution, and is also available from Franz, Inc. of Berkeley, California. However, anyone with a working knowledge of Lisp will probably not require this manual.\n\nFinally, the manual *A Theorem Prover for Recursive Functions: A User’s Manual* published in 1979 as Report CSL-91 by SRI International of Menlo Park, CA., is useful. This manual describes the mechanics of running the theorem prover. The key parts have been extracted and appear in the next few pages, but the theorem prover user’s manual goes into more detail and should be on hand.\n\nThe prover has changed somewhat since the 1979 manual. We will try to cover the important differences in this manual.\n\n### 7.2 An introduction to the Rule Builder\n\nIn *A Computational Logic* [BOYER79], Boyer and Moore describe a formal logic based on recursive functions, and they present a large number of techniques for discovering proofs in that theory. These techniques are implemented in their theorem prover. This chapter of the verifier manual is an adapted version of Boyer and Moore’s theorem prover manual.\n\n#### 7.2.1 Teaching the theorem prover\n\nWhile using the rule builder the user will spend most of his time teaching the system about the concepts he defines and their relationships to other defined concepts. The system is taught by defining functions and suggesting lemmas for it to prove and remember for future use.\n\nThe system uses axioms and previously proved lemmas in four distinct ways. The system does not decide automatically how to use a given theorem; whenever any new theorem is introduced, the user must specify how the lemma is to be used by providing the system with a list names drawn from the following keywords.*\n\n---\n\n* The *induction* lemma type has been discontinued. It is now necessary to use manually-provided *hints* to help the prover with difficult inductions.\nlemmas are used to rewrite terms. Most lemmas are rewrite lemmas.\n\nelim lemmas are used to replace certain complex terms by single variables.\n\ngeneralize lemmas are used to guide the theorem prover when it looks for stronger induction hypotheses.\n\nAny lemma with an empty list of lemma types will never be used again by the system. The theorem prover is very sensitive to the syntactic form chosen by the user to represent each new fact. For example, a rewrite lemma of the form\n\n\\[(\\text{implies} \\ (\\text{and} \\ p \\ q) \\ (\\text{equal} \\ r \\ s))\\]\n\nis used to rewrite instances of \\(r\\) to \\(s\\) provided that the system can first establish \\(p\\) and then \\(q\\). This is the most common form of lemma. Note the asymmetry between hypothesis and conclusion, and between left and right hand sides of the conclusion. In fact, because the system must limit the resources it is willing to spend establishing \\(p\\) and \\(q\\), even the order of the hypotheses is relevant to the system. Thus, the above rewrite lemma causes different behavior than any of the following logically equivalent formulae:\n\n\\[(\\text{implies} \\ (\\text{and} \\ p \\ q) \\ (\\text{equal} \\ s \\ r))\\]\n\n\\[(\\text{implies} \\ (\\text{and} \\ p \\ (\\text{not} \\ (\\text{equal} \\ r \\ s))) \\ (\\text{not} \\ q))\\]\n\n\\[(\\text{implies} \\ (\\text{and} \\ q \\ p) \\ (\\text{equal} \\ r \\ s))\\]\n\nTo become an effective user of the system one must understand how the commands influence the behavior of the system. It is possible to infer the meaning of the various lemma types after enough hands-on experience with the system. (Boyer and Moore add the comment here “It is also possible to infer the structure of a brick wall by battering it down with your head”.)\n\n### 7.2.1.1 Events, Dependencies, and Commands\n\nThe insertion of a definition or lemma into the knowledge base is called an **event**. All events have names. Some events, such as definitions of new functions, are naturally associated with a name (e.g., the name of the function defined); others, such as theorems, are given names by the user. See the section on syntax below.\n\nThe basic theorem-prover commands are those that create new events: the definition of a new function, and the proof and storage of a new theorem. The commands that create new events are **dcl**, **defn**, **prove-lemma**, and **move-lemma**.\n\nEvents are related to each other by logical dependencies. For example, the admission of a certain formula as a theorem depends on all of the functions and lemmas used in the\nproof of the theorem. Similarly, the admission of a new recursive function definition depends not only upon all of the previously introduced concepts used in the definition, but also upon the functions and lemmas used to prove that the proposed \"definition\" truly defines a function.\n\nThus, the theorem-prover’s knowledge base is actually a noncircular, directed graph of events. The theorem prover’s performance is largely determined by its knowledge base. The Rule Builder is initialized with a knowledge base with definitions and lemmas which define the basic objects of Pascal-F verifications, integers and arrays, and provide a reasonable set of knowledge about arithmetic and array operations. The user will need to add his own definitions and prove theorems about them. It is possible to dump the system’s knowledge base to a \"library file\" to save the system’s state from one session to the next, and to provide information to the Verifier proper.\n\nAfter proving several theorems, the user finds that one of his earliest defined concepts was inconveniently or inappropriately defined, the user can undo that definition (using the undo-name or undo-back-through commands) and lose only those results whose meaning or logical validity may depend on that definition.\n\n### 7.2.2 Error handling\n\nIf one tries to execute an inappropriate command (e.g., assign the same name to two different events, or attempt to define a function in terms of unknown concepts) self-explanatory error messages will be printed. The system checks for over 100 errors and has an error handling mechanism designed to keep the theorem proving machine in a consistent state. For example, when a new command is processed, all possible errors are checked before the first change is made to the data base, since an abortion midway through the update would leave the machine in an unacceptable state.\n\nError messages are grouped into three classes; WARNING, ERROR, and FATAL ERROR messages. Warnings arise when the system has detected something unusual but not logically incorrect. For example, the system prints a WARNING message if the user defines a function but do not refer to one of the formal parameters in the body of the function. After printing a WARNING message, the system continues normal execution.\n\nERROR messages result from true errors in the sense that the system cannot continue until the error is repaired, but the error can be repaired by editing a formula or changing a name. When such an error occurs the system prints an explanatory error message and then returns to the LISP command prompt level, discarding the failed command.\n\nFATAL ERROR messages occur when system resources are exhausted or when internal checks indicate the presence of inconsistency in the data base or bugs in the theorem prover itself. It is usually not possible to proceed past a fatal error. When a FATAL ERROR is observed, it should be reported as described in the section on reporting verifier problems.\n\nDespite the precautions taken in the theorem prover, it is possible to get the system in an illegal state by aborting a command while the data base is in the process of being changed. Ctl-C will abort any command, but this is unsafe. However, the prover may spend hours exploring dead ends when trying some proofs. It is thus necessary to abort\ncommands on some occasions. The following cautions apply:\n\n- **dcl, make-lib, move-lemma, note-lib, and undo-name** should never be aborted while running.\n\n- **dependent-events, events-since prove, ppe, and chronology** may be aborted at any time without harm.\n\n- **defn** and **prove-lemma** can be aborted but there is a small risk of corrupting the theorem prover’s database, if the **defn** or **prove-lemma** had in fact succeeded and the database was in the process of being updated.\n\nBoyer and Moore recommend that the result of any proof where a command was aborted be considered suspect.\n\n### 7.2.3 Output\n\nThe theorem prover prints an English description of what it is doing as it proceeds. The sample session, shown below, shows what this is like. Normally, the output goes to the user’s terminal, but can be diverted.\n\n### 7.2.4 Syntax\n\nAll formulas in Boyer-Moore logic are written in a LISP-like prefix notation. This notation is fully described in chapter III of *A Computational Logic*.\n\n#### 7.2.4.1 Functions\n\nThe functions usable in this notation are those defined in the section “The Built-In Knowledge Base” and any new user-defined functions the user introduces with the **defn** and **dcl** commands. Functions have a fixed number of arguments as specified in the definition of the function.*\n\n#### 7.2.4.2 Variables\n\nThe variables used in this notation are free variable names and have no relationship to names used in Pascal-F programs. Names of variables, and of new functions, may be composed of the characters A-Z, a-z, 0-9, “.”, and “!”. Upper case letters are converted to lower case letters.\n\n#### 7.2.4.3 Constants\n\nThe available constants are the integers, written in the usual way, and the explicit constants shown below.\n\n| (true) | Boolean true. |\n| t | Alternate for (true). |\n| (false)| Boolean false. |\n| f | Alternate for (false). |\n\n* Some functions are by design N-ary, for example, and and or.\nA specific object which is not an array, an integer, or a Boolean value. It is used in building up the theory of arrays.\n\nAn array-valued object, all elements of which are equal to (undefined).\n\nOnly t, f, and the integers are typically used by the user of the Rule Builder.\n\n7.3 The mechanics of using the Rule Builder\n\n7.3.1 Starting up the program\n\nThe instructions in this section apply to the UNIX version of the program.\n\nThe command\n\n\\[ \\text{rulebuilder} \\]\n\ninvokes the Rule Builder. This is a version of the Boyer-Moore prover pre-initialized with a knowledge base compatible with the Verifier. It takes about a minute to load the program (which requires about 2 megabytes of memory.) The messages\n\n\\[\n\\begin{align*}\n\\text{Pascal-F Rule Builder of } & 2\\text{-JAN-86 16:02:04} \\\\\n[\\text{load /usr/lib/verifier.lisp}] \\\\\n& \\text{Standard Pascal-F knowledge base loaded.} \\\\\n& ->\n\\end{align*}\n\\]\n\nindicate that the system is ready for commands.\n\nIf a previous session with the Rule Builder has been used to produce a knowledge base, that knowledge base can be used as a starting point for a new Rule Builder session by invoking the Rule Builder with the command\n\n\\[ \\text{rulebuilder knowledgebase} \\]\n\nwhere \\textit{knowledgebase} is the name of a knowledge base created with the \\textit{make-lib} command.\n\nCommands are aborted with control-C, which is sometimes unsafe, as mentioned above.\n\n7.3.2 Commands Summary\n\nThe commands listed below are a subset of the full command list of the Boyer-Moore theorem prover. The commands listed are normally sufficient for building rules for the Verifier.\n7.3.2.1 chronology\n\nThe word chronology, without parentheses, will display a list of the names in the current knowledge base, in reverse chronological order. Thus, the last name listed will be the name of the oldest event, which is usually ground-zero. The chronology list covers events brought in through note-lib, so the events which make up a library may be listed.\n\n7.3.2.2 (dcl <name> <arglist>)\n\nDcl declares name to be an undefined function of N arguments, where N is the length of arglist, which must be a list of distinct, but otherwise meaningless, variable names. Functions created via dcl have no semantics in the Rule Builder, but may have semantics in the Verifier. The theory of uninterpreted functions does apply to functions created by dcl, which means only that if \\( f \\) is an uninterpreted function,\n\n\\[\nx = y \\\\\n\\text{implies} \\\\\nf(x) = f(y)\n\\]\n\n7.3.2.3 (defn <name> <arglist> <body> [<hints>])\n\nDefn defines a function named name, with formal argument list arglist and body body. The optional parameter hints allows the user to assist the theorem prover in validating the definition. The arglist must be a list of distinct variable names, and body must be an expression in the theory. This expression must be constructed as described under the section on syntax, and may use as variable names only the names present in arglist. Only previously defined functions, and the the function being defined in the defn, may be used in the body.\n\nFor recursive definitions, the system insists that the recursion terminate and will not accept the definition fully unless it can prove this. The system will try to prove that some measure of arglist gets smaller in each recursive call to name within body.\n\nWhen the system cannot prove that a recursive definition terminates, a WARNING message appears stating that the definition is not well-founded. The definition is not, however, rejected by the system. It should be. The user should immediately remove it with an undo-name command.\n\nThe hint parameter to defn is seldom required. If the function being defined is nonrecursive, it is never required. If the function is recursive but recurses in such a way that at least one of the arguments in the recursive call is clearly less than the value at invocation, no hint should be required. For example, if the function recurses by subtracting 1 from an argument until the value becomes zero, the theorem prover will be able to satisfy itself of the soundness of the definition without difficulty. But if a function recurses by adding one to an argument until a limit is reached, a hint will be necessary.\n\nHints for defn are very similar to the Pascal-F MEASURE statement; the user must supply an expression whose value becomes smaller with each recursion. Hints have the\nform of a list of \\(<\\text{comparing-operator}> <\\text{recursion measure}>\\) terms. In the usual case, where only one hint is required, the hint parameter has the form \\((<\\text{comparing-operator}> <\\text{recursion measure}>\\)). Suitable comparing-operators are \\text{lessp}, and \\text{lex2}*. The recursion measure must be some expression which, when evaluated both at entry to the recursive function and at entry to the recursive function one level deeper in the recursion, becomes smaller with each recursion. Here, “smaller” is defined relative to the comparing-operator chosen.\n\nNote that \\text{defn} definitions are actually small recursive programs. It is possible to run these programs on test data; see the \\text{r} command.\n\n7.3.2.4 (dependent-events <name>)\n\n\\text{Dependent-events} takes an event name (i.e. a function or lemma name) and returns the events which depend on it. If \\text{name} is deleted with \\text{undo-name}, all the dependents of \\text{name} will be deleted.\n\nDependency is simply defined. If a \\text{defn} \\text{g} mentions a function \\text{f}, then \\text{g} depends on \\text{f}. If the proof of lemma \\text{x} used lemma \\text{y} and \\text{defn} \\text{f}, then \\text{x} depends on \\text{f} and \\text{y}.\n\n7.3.2.5 (events-since <eventname>)\n\nThis returns a list of all the events stored since the named event. The list is based strictly on time, not dependency.\n\n7.3.2.6 (exit)\n\n\\text{Exit} causes an exit from the Rule Builder. Any new knowledge added since the last \\text{make-lib} is lost.\n\n7.3.2.7 (lemmas <functions>)\n\nThis is a cross-referencing tool. A list of all lemmas which mention any function in \\text{functions} is returned.\n\n7.3.2.8 (make-lib <file>)\n\n\\text{Make-lib} makes a file named \\text{file.lib} and a file named \\text{file.lisp} which together contain the entire current knowledge base. Invoking the Rule Builder with\n\n\\begin{verbatim}\n rulebuilder <file>\n\\end{verbatim}\n\nwill restore the state of the Rule Builder to that in effect when the \\text{make-lib} was executed.\n\nLibrary files are of moderately large size, about 100 kilobytes, and contain not only the events but substantial amounts of internal information.\n\n7.3.2.9 (move-lemma <name> <lemmatypes> <oldname>)\n\nThe \\text{move-lemma} command allows the user to change the ways in which a lemma can be applied within the Rule Builder. It is used primarily to “hide” lemmas or definitions\n\n* See \\text{A Computational Logic} for an explanation of \\text{lex2}. \nwhich although correct cause the Rule Builder to pursue dead ends. Usually, lemmatypes is NIL, which causes the defn or prove-lemma event oldname to be hidden. When a prove-lemma event is hidden, the lemma will not be used by the Rule Builder, and when a defn event is hidden, that definition will not be opened up. Hiding a defn does not prevent its evaluation with the r command.\n\n7.3.2.10 (note-lib <file>.lib <file>.lisp)\n\nNote-lib reads in file, which must have been produced by make-lib, and reinitializes the Rule Builder with the knowledge base in that file. This is a reinitialization, not an addition; the state of the theorem prover is cleared before the read.\n\n7.3.2.11 (ppe <eventname>)\n\nThe ppe command prints the event eventname in a tidy format.\n\n7.3.2.12 (prove <thm>)\n\nProve attempts to prove the conjecture thm, using all the theorem-proving techniques at the system’s disposal. prove prints an English-language description of the proof attempt in real-time, so the user can monitor the progress of the attempt. The result of the proof is not saved.\n\n7.3.2.13 (prove-lemma <eventname> <lemmatypes> <thm> [<hints>])\n\nThis is the most important command in the Rule Builder. Prove-lemma attempts to prove a lemma as with prove, and if the attempt is successful, the lemma will be saved, available for use in the ways specified in the list lemmatypes. The allowed lemma types are rewrite, elim, and generalize. prove-lemma first checks to see if the syntactic form of thm is acceptable for the lemmatypes indicated. If no error is diagnosed in this pre-processing, a proof is attempted as with the prove command. If the proof succeeds, the lemma is stored under the name eventname and is usable with the lemma types lemmatypes.\n\nIf eventname ends in “-rule” or “-RULE”, and the lemmatypes list includes “rewrite” then the event is considered a Verifier rule and, if placed in a Rule Builder library with make-lib and then copied to a Verifier database file with the “putrules” utility, will be used by the Verifier.\n\nThe optional parameter hints allows the user to order the theorem prover to try a specific lemma or induction at the beginning of the proof, thus affording some minimal control over the proof process. Hints are not normally necessary; it is better when possible to help the theorem prover along by proving lemmas which will then be used in later proofs. However, hints can be provided if necessary. This is an advanced feature of the prover and is not recommended for new users.\n\nThe hints argument to the prove-lemma command, if not omitted, must be a list of hint entries. There are five kinds of hints:\n\nuse Indicates that a specific lemma is to be applied in a specific way at the beginning of the proof. The form of a use hint is\n(use (event1 (v1 t1) ... (vn tn)))\n...\n(eventk (vk tk) ... (vm tm)))\n\nwhere each \\textit{eventi} is the name of an \\textbf{add-axiom}, \\textbf{prove-lemma}, or \\textbf{defn} event, each \\textit{vi} is a variable name from the definition of the event, and each \\textit{ti} is a term in the formula being proven. The user is thus explicitly requesting the application of a rule, and the user must give the exact bindings of the variables in the rule to the terms in the formula being proven.\n\nA \\textbf{use} hint is a request, not a demand; if the lemma indicated in the hint cannot be applied to the formula being proven, the hint will be ignored and the prover will proceed without it. It is thus important when using \\textbf{use} hints to watch the beginning of the proof for the application of the hint.\n\n\\begin{itemize}\n\\item \\textbf{expand} Indicates that a \\textbf{defn} should be expanded at the beginning of the proof.\n\\item \\textbf{disable} Prevents the use of a named lemma or expansion of a named definition in the proof.\n\\item \\textbf{induct} Indicates the induction strategy that the prover is to use.\n\\item \\textbf{time} We don’t know what this is for.\n\\end{itemize}\n\nThe \\textbf{use} and \\textbf{disable} hint types are sufficient for most proofs. The prover has relatively good diagnostics for incorrectly formed hints; a badly formed hint will produce a message giving the correct form and an indication of why the prover is unhappy with the hint.\n\n\\textbf{7.3.2.14 (r <term>)}\n\nThe \\textbf{r} command evaluates \\textit{term}, which must be an expression constructed from valid built-in functions, defn functions, and constants. For example,\n\n\\begin{verbatim}\n(r (plus 2 2))\n\\end{verbatim}\n\nwill return 4. More usefully, if we define a function of our own,\n(defn FACTORIAL (N)\n (if (lessp 0 N)\n (times N (FACTORIAL (difference N 1)))\n 1))\n\nwe can then try test cases on it.\n\n(r (FACTORIAL 4))\n\nwill return 24.\n\nThis evaluation process is quite fast. The Rule Builder generates Lisp code for each defn when the defn is created, so that definitions can be rapidly evaluated for constant values. Recursive definitions generate recursive code. Since the Rule Builder insists that definitions be provably well-founded, infinite recursion is prevented.\n\nThe Boyer-Moore theory is a constructive theory of total functions. This means that any syntactically valid variable-free expression can be evaluated. For example, FACTORIAL can be applied to T, the Boolean value true, and a consistent value will be returned. When constructing definitions, the actions for inputs of unexpected types must be borne in mind.\n\nIt is worthwhile to try out the r command on some of the built-in functions to develop a feel for what they do. An interesting exercise is to produce an array-valued result. For example,\n\n(r (storea! (storea! (empty.array) 3 100) 5 200))\n\nwill produce an array-valued object with element 3 equal to 100 and element 5 equal to 200. This gives the user some insight into how arrays are represented internally.\n\n7.3.2.15 (undo-back-through <eventname>)\n\nEventname and all events performed since eventname will be undone. This includes events not dependent on eventname.\n\n7.3.2.16 (undo-name <eventname>)\n\nEventname and all events dependent upon it will be undone.\n\n7.4 The built-in knowledge base\n\nThe Rule Builder, as stated before, is a version of the Boyer-Moore theorem prover pre-initialize with a knowledge base compatible with the Verifier. This knowledge base includes definitions of arithmetic for the natural numbers and the integers, Boolean and comparison functions, and a definition of arrays. It also contains about a hundred lemmas of general utility, most of which are statements about arithmetic.\n7.4.1 The built-in functions\n\nThe predefined functions are as follows.\n\n- **(add1 N)** Adds one, usable on natural numbers only.\n- **(and B1 B2 ...)** N-argument and.\n- **(difference N M)** Natural number subtraction.\n- **(equal X Y)** Equality; usable on any type operands.\n- **(if P X Y)** If P then X else Y. If must not appear in rules, but may be used in defn definitions or non-rule lemmas.\n- **(implies P Q)** Boolean implication.\n- **(lesssp N M)** Natural number comparison.\n- **(not P)** Boolean negation.\n- **(numberp N)** True if value is a natural number.\n- **(or B1 B2 ...)** N-argument or.\n- **(plus N M)** Natural number addition.\n- **(quotient N M)** Natural number division.\n- **(remainder N M)** Natural number remainder.\n- **(sub1 N)** Subtracts one.\n- **(times N M)** Natural number multiplication.\n- **zero** Equivalent to 0.\n- **(zerop N)** True if N is equal to 0.\n- **(addi! I J)** Integer addition.\n- **(alltrue! r)** True if all parts of the argument are true. This is a dcl to the rule builder, and has no semantics in the rule builder. The Verifier expands alltrue! based on type information.\n- **(arrayp! A)** Array type predicate, true if the argument is an array.\n- **(arraytrue! A I J)** True if the elements from I to J of array A are alltrue!. When\n\n \\[\n \\text{defined}(A, I, J)\n \\]\n\nis written in Pascal-F source, (arraytrue! A I J) applied to the definedness part of A will be generated in the verification condition. This allows inductive proofs of definedness of arrays.\n\n- **(booleanp! A)** Type predicate, true if A is Boolean.\nInteger division.\n\nInteger >=.\n\nInteger >.\n\nType predicate, true if I is an integer.\n\nInteger <=.\n\nInteger <.\n\nInteger remainder. Mod should be applied to positive numbers only, because the Verifier has no knowledge about what the result is for negative numbers. This reflects the Pascal-F implementation.\n\nInteger multiply.\n\nInteger negation.\n\nType predicate, true if I is a natural number (nonnegative).\n\nArray subscripting function; equivalent to the Pascal form A[I].\n\nRecord selector, equivalent to the Pascal form “A.F”. The Rule Builder does not know about records because it lacks type information. This is a dcl uninterpreted function. The Verifier interprets selectr! based on the type information from the program.\n\nArray store function. The result of storea! is an array equal to A except that A[I] = V. This function has no Pascal infix-form equivalent, but is displayed in the Verifier’s log of verification conditions as “<A I V>”.\n\nRecord store function. The result of storer! is a record equal to A except that A.F = V. This function is displayed in verification conditions as “<A I V>”, and looks just like the array store function in that form. The storer! function, like selectr!, is a dcl.\n\nInteger subtraction.\n\nThe upper-case names are identical to those in A Computational Logic in both syntax and meaning. We have not changed these because they are built into the Boyer-Moore system. No rule function may be given the same name as one of the built-in names. The names ending in “!” represent the additional functions needed to handle Pascal-F verification conditions.\n\n7.5 An example of rule building\n\nIn the chapter “Rules”, we gave a sample program fragment which used a rule function called allzero. Verification of this piece of a program required some rules. As a concrete example, we make a simple program out of our program fragment.\nprogram example6;\n{\n Program fragment to demonstrate rule usage\n}\ntype tabix = 1..100;\ntype tab = array [tabix] of integer;\nrule function allzero(a: tab; i, j: tabix): boolean; begin end;\nvar table1: tab;\ni, j: tabix;\nbegin\n for i := 1 to 100 do begin\n table1[i] := 0;\n assert(allzero(table1, 1, i-1));\n state(allzero(table1, 1, i));\n end;\n assert(allzero(table1, 1, 100)); { some arbitrary value } \n j := 25;\n assert(table1[j] = 0); { table1[j] must be 0 } \nend.\n\nWe will make an attempt at verifying the program, knowing that the attempt will be unsuccessful, since the Verifier has no idea what allzero means.\n\n% pasver example6.pf\n\nOf course, we get diagnostic messages.\nPass 1:\nPass 2:\nPass 3:\n\nVerifying example6\nCould not prove \\{example6.pf:18\\} \\(\\text{table1}[(j - 1) + 1] = 0\\) (ASSERT assertion)\nfor path:\n \\{example6.pf:11\\} Start of \"example6\"\n \\{example6.pf:11\\} FOR loop exit\n\nCould not prove \\{example6.pf:14\\} \\(\\text{allzero}(\\text{table1},1,i)\\) (STATE assertion)\nfor path:\n \\{example6.pf:11\\} Start of \"example6\"\n \\{example6.pf:15\\} Back to top of FOR loop\n\nCould not prove \\{example6.pf:14\\} \\(\\text{allzero}(\\text{table1},1,i)\\) (STATE assertion)\nfor path:\n \\{example6.pf:11\\} Start of \"example6\"\n \\{example6.pf:11\\} Enter FOR loop\n\nCould not prove \\{example6.pf:13\\} \\(\\text{allzero}(\\text{table1},1,i - 1)\\) (ASSERT assertion)\nfor path:\n \\{example6.pf:11\\} Start of \"example6\"\n \\{example6.pf:15\\} Back to top of FOR loop\n\nCould not prove \\{example6.pf:13\\} \\(\\text{allzero}(\\text{table1},1,i - 1)\\) (ASSERT assertion)\nfor path:\n \\{example6.pf:11\\} Start of \"example6\"\n \\{example6.pf:11\\} Enter FOR loop\n\n5 errors detected\n\nWe obviously need rules about \\texttt{allzero}. In the previous chapters, we figured out what rules we needed. So let us build them.\n\nWe begin by invoking the rule builder\n\n% rulebuilder\n\nwhich responds with its signon message and a prompt.\nIn this session, we will define the function allzero, which is a predicate for testing whether an array is composed entirely of zero elements between two subscript bounds. The definition is a recursive function; allzero is true vacuously if J is less than I, otherwise we recurse, checking each element, until J is less than I.\n\n```\n-> (defn allzero\n (a i j)\n (if (lessp j i)\n t\n (and (allzero a (add1 i) j)\n (equal (selecta! a i) 0))))\n```\n\nWARNING: The recursion in allzero is unjustified.\n\nWarning: The admissibility of allzero has not been established. We will assume that there exists a function satisfying this definition. An induction principle for this function has also been assumed, corresponding to the obvious subgoal induction for the function. These assumptions may render the theory inconsistent.\n\nNote that (or (falsep (allzero a i j)) (truep (allzero a i j))) is a theorem.\n\n*************** F A I L E D ***************\n\n[14.183333 0.4166669999999992 ]\nnil\n\nThis is no good. We must not accept this definition or our theory might be unsound. Although the prover has (grudgingly) stored the definition, we want to delete it and try again. So we use the undo-back-through command to delete the definition of allzero.\nActually, there is nothing wrong with our definition of \\textit{allzero}. It is just that the theorem prover isn’t smart enough to figure out that the recursion terminates. There are two ways to deal with this problem; one is to rewrite the definition so that the theorem prover can figure this out by itself, and the other is to provide a hint. The first approach could be applied by rewriting \\texttt{allzero} so that it recursed by subtracting 1 from \\(j\\) on each iteration rather than adding 1 to \\(i\\). The theorem prover has no trouble understanding that subtracting 1 repeatedly with a test for \\texttt{lessp} in the right place must lead to termination.\n\nBut for purposes of illustration we’re going to bull our way through with a hint. As mentioned in the Command Summary section for \\texttt{defn}, a hint for a \\texttt{defn} is a lot like the Pascal-F \\texttt{MEASURE} statement. We need an expression which gets smaller with each recursion. The expression \\((\\text{difference} \\ (\\text{add1} \\ j) \\ i)\\) will do the job. We need the \\texttt{add1} because \\texttt{difference} returns a natural number; a negative value is not possible. We thus must bias the value of \\(j\\) to avoid trouble for the case where \\(j\\) is one less than \\(i\\).\n\nOur hint will have the form\n\n\\[\n\\text{lessp} \\ (\\text{difference} \\ (\\text{add1} \\ j) \\ i)\n\\]\n\nindicating that we want \\((\\text{difference} \\ (\\text{add1} \\ j) \\ i)\\) used as the recursion measure and \\texttt{lessp}, as usual, used as the well-founded relation.\n-> (defn allzero\n (a i j)\n (if (lessp j i) t\n (and (allzero a (add1 i) j)\n (equal (selecta! a i) 0)))\n ((lessp (difference (add1 j) i))))\n\nLinear arithmetic establishes that the measure (difference (add1 j) i) decreases according to the well-founded relation lessp in each recursive call. Hence, allzero is accepted under the principle of definition. Observe that:\n (or (falsep (allzero a i j))\n (truep (allzero a i j)))\n\nis a theorem.\n\n[ 3.2 0.25 ]\nallzero\n\nIt succeeds; the definition is valid. It has now been proven that the recursive definition cannot loop infinitely. The theorem prover also notes that allzero is Boolean-valued, which it may find useful later.\n\nWe ask the Rule Builder to print the definition of allzero to illustrate the ppe command.\n\n-> (ppe 'allzero)\n\nand the definition is printed in suitably indented form, with the hint included.\n\n(defun allzero\n (a i j)\n (if (lessp j i) t\n (and (allzero a (add1 i) j)\n (equal (selecta! a i) 0)))\n ((lessp (difference (add1 j) i))))\n nil\n\nIncidentally, we could have defined allzero so that it recursed downward, and the prover would still be able to prove every lemma proved in this session. In many ways, this would have been an easier approach; we would not have needed the hint in the defn command that defined allzero.\n\nLet us now test out our new definition. We have defined a function and can now run it on\nsome test data. The r command is used to run allzero on an array in which element 2 is 0 and element 3 is 0. (Remember that (storea! A I V) is equal to the array A except that element I has been replaced by the value V) The form (empty.array) is simply the array of no elements.\n\n```\n-> (r (allzero (storea! (storea! (empty.array) 2 0) 3 0) 2 3))\n```\n\nThe system responds with\n\n```\nt\n```\n\nwhich is what we want. Let us try an array which is not all zero.\n\n```\n-> (r (allzero (storea! (storea! (empty.array) 2 1) 3 1) 2 3))\n```\n\n```\nf\n```\n\nAnother test case; an array with one zero element; is it all zero from 2 to 2?\n\n```\n-> (r (allzero (storea! (storea! (empty.array) 2 0) 3 1) 2 2))\n```\n\n```\nt\n```\n\nIt is. Finally, we check out the case where the upper bound of the allzero is less than the lower bound.\n\n```\n-> (r (allzero (storea! (storea! (empty.array) 2 1) 3 1) 3 2))\n```\nThis, also, seems to work.\n\nWith our definition in good shape, we can now try to prove some theorems about it. Our first lemma will be that if the lower bound exceeds the upper bound in the \\texttt{allzero} call, then \\texttt{allzero} is vacuously true.\n\n\\begin{verbatim}\n -> (prove-lemma allzero-void-rule\n (rewrite)\n (implies (and (arrayp! a)\n (numberp i)\n (numberp j)\n (lessp j i))\n (allzero a i j)))\n\\end{verbatim}\n\nNote that the name of the lemma, \\texttt{allzero-void-rule}, ends in \\texttt{-rule} which will later make this rule available to the Verifier. The theorem prover now proceeds with the proof, which, given the definition, ought to be trivial.\n\nThis conjecture simplifies, opening up \\texttt{allzero}, to:\n\n\\begin{verbatim}\n t.\n\\end{verbatim}\n\nQ.E.D.\n\n\\begin{verbatim}\n[ 7.68333300000001 0.06666699999999916 ]\nallzero-void-rule\n\\end{verbatim}\n\nIt is trivial; the proof succeeds in 7.6 seconds (this is on a Sun II) and the event \\texttt{allzero-void-rule} is stored.\n\nWe also need a rule to handle the case where both bounds of \\texttt{allzero} are equal. This, too, should be trivial. We type in our lemma\nand the theorem prover goes to work.\nThis formula simplifies, using linear arithmetic, rewriting with allzero-void-rule and x-not-less-than-x, and expanding allzero, to:\n\n\\[\n\\text{(implies (and (arrayp! a) (numberp j))}\n\\begin{align*}\n& \\text{(equal (selecta! a j) 0)),}\n\\end{align*}\n\\]\n\nwhich we will name *1.\n\nWe will appeal to induction. The recursive terms in the conjecture suggest two inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme:\n\n\\[\n\\begin{align*}\n& \\text{(and (implies (and (array-recognizer a) (equal a (empty-array))) (p a j))}\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n& \\text{(implies (and (array-recognizer a) (not (equal a (empty-array))) (or (not (numberp (array-elt-subscript a)))) (equal (array-elt-value a) (undefined))) (equal (array-prev a) (empty-array))) (p a j))}\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n& \\text{(implies (and (array-recognizer a) (not (equal a (empty-array))) (not (or (not (numberp (array-elt-subscript a)))) (equal (array-elt-value a) (undefined))) (equal (array-prev a) (empty-array))) (p a j))}\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n& \\text{(implies (and (array-recognizer a) (not (equal a (empty-array))) (not (or (not (numberp (array-elt-subscript a)))) (equal (array-elt-value a) (undefined))) (not (equal (array-prev a) (empty-array))) (p (array-prev a) j)) (p a j))}\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n& \\text{(implies (not (array-recognizer a)) (p a j))}\n\\end{align*}\n\\]\n\nLinear arithmetic and the lemma array-prev-lessp can be used to show that the measure \\(\\text{(count a)}\\) decreases according to\nthe well-founded relation lessp in each induction step of the scheme. The above induction scheme generates six new goals:\n\nCase 6. (implies (and (array-recognizer a)\n (equal a (empty-array))\n (arrayp! a)\n (numberp j))\n (equal (selecta! a j) 0)),\n\nwhich simplifies, unfolding array-recognizer, arrayp!, equal, array-prev, array-elt-value, array-elt-subscript, and selecta!, to the formula:\n\n (not (numberp j)).\n\nEliminate the irrelevant term. This produces:\n\n f.\n\nNeed we go on?\n\n************** F A I L E D **************\n\nThe theorem prover stops, after about a minute of work, and reports failure. What went wrong? We can display the failed theorems in this session by typing\n\n-> (pp failed-thms)\n\nto which the theorem prover replies\n(setq failed-thms\n '((implies (and (arrayp a)\n (numberp i)\n (numberp j)\n (equal i j))\n (allzero a i j))\n (defn allzero\n (a i j)\n (if (lessp j i)\n t\n (and (allzero a (add1 i) j)\n (equal (selecta a i) 0)))\n nil))))\n\nWe get to see our previous failure with the definition of allzero as well as our latest problem. The problem is obvious; we aren’t testing anything for zero in the hypotheses of the theorem, so we can’t possibly expect it to prove allzero true in the conclusion. We are missing a hypothesis. Let us try again.\n\n-> (prove-lemma allzero-single-rule\n (rewrite)\n (implies (and (arrayp a)\n (numberp i)\n (numberp j)\n (equal i j)\n (equal (selecta a i) 0))\n (allzero a i j)))\n\nWe have added the hypothesis (equal! (selecta! a i) 0) and the theorem prover is now able to prove this quite easily.\nThis conjecture simplifies, using linear arithmetic, rewriting with allzero-void-rule and x-not-less-than-x, and unfolding the functions equal and allzero, to:\n\nt.\n\nQ.E.D.\n\n[ 3.2 0.1333330000000008 ]\nallzero-single-rule\n\nMuch better. Again, a trivial proof.\n\nNow we get to a hard but crucial lemma. When a program is iterating through an array, clearing each element to zero, we will need to be able to show that clearing each additional element extends the allzero property of the array. This will require an inductive proof.\n\n-> (prove-lemma allzero-extend-upward-rule\n (rewrite)\n (implies (and (arrayp! a)\n (numberp i)\n (numberp j)\n (allzero a i j)\n (equal (selecta! a (add1 j)) 0))\n (allzero a i (add1 j))))\n\nTurning the problem over to the theorem prover...\nCall the conjecture *1.\n\nLet us appeal to the induction principle. The recursive terms in the conjecture suggest four inductions. They merge into two likely candidate inductions. However, only one is unflawed. We will induct according to the following scheme:\n\n\\[\n\\begin{align*}\n\\text{(and (implies (lessp j i) (p a i j))} \\\\\n\\text{(implies (and (leq i j) (p a (add1 i) j))} \\\\\n\\text{(p a i j))}).\n\\end{align*}\n\\]\n\nLinear arithmetic informs us that the measure \n\\(\\text{difference (add1 j) i}\\) decreases according to the well-founded relation lessp in each induction step of the scheme. The above induction scheme generates three new formulas:\n\nCase 3. (implies (and (lessp j i)\\)\n\n(arrayp! a)\\)\n\n(numberp i)\\)\n\n(numberp j)\\)\n\n(allzero a i j)\\)\n\n(equal (selecta! a (add1 j)) 0))\\)\n\n(allzero a i (add1 j))},\n\nwhich simplifies, appealing to the lemmas allzero-void-rule and sub1-add1, and unfolding allzero and lessp, to four new formulas:\n\nCase 3.4.\\)\n\n(implies (and (lessp j i)\\)\n\n(arrayp! a)\\)\n\n(numberp i)\\)\n\n(numberp j)\\)\n\n(equal (selecta! a (add1 j)) 0)\\)\n\n(leq (sub1 i) j))\\)\n\n(allzero a (add1 i) (add1 j))),\n\nwhich again simplifies, using linear arithmetic, to:\n\n\\[\n\\begin{align*}\n\\text{(implies (and (lessp j (plus 1 j))} \\\\\n\\text{(arrayp! a)} \\\\\n\\text{(numberp (plus 1 j))} \\\\\n\\text{(numberp j)} \\\\\n\\text{(equal (selecta! a (add1 j)) 0))} \\\\\n\\text{(leq (sub1 (plus 1 j)) j))} \\\\\n\\text{(allzero a)} \\\\\n\\text{(add1 (plus 1 j))})\n\\end{align*}\n\\]\n(addl j))).\n\nBut this again simplifies, using linear arithmetic, rewriting with plus-1, sub1-add1, allzero-void-rule, and x-not-less-than-x, and unfolding the definitions of lessp, plus, numberp, add1, and sub1, to:\n\n\\[ Case \\, 3.3. \\quad (\\text{implies} \\ (\\text{and} \\ (\\text{lessp} \\ j \\ i) \\ (\\text{arrayp}\\! a) \\ (\\text{numberp} \\ i) \\ (\\text{numberp} \\ j) \\ (\\text{equal} \\ (\\text{selecta}! a \\ (\\text{add1} \\ j)) \\, 0) \\ (\\text{leq} \\ (\\text{sub1} \\ i) \\ j)) \\) \\ (\\text{equal} \\ (\\text{selecta}! a \\ i) \\, 0)). \\]\n\nThis again simplifies, using linear arithmetic, to:\n\n\\[ (\\text{implies} \\ (\\text{and} \\ (\\text{lessp} \\ j \\ (\\text{plus} \\ 1 \\ j)) \\ (\\text{arrayp}\\! a) \\ (\\text{numberp} \\ (\\text{plus} \\ 1 \\ j)) \\ (\\text{numberp} \\ j) \\ (\\text{equal} \\ (\\text{selecta}! a \\ (\\text{add1} \\ j)) \\, 0) \\ (\\text{leq} \\ (\\text{sub1} \\ (\\text{plus} \\ 1 \\ j)) \\ j)) \\) \\ (\\text{equal} \\ (\\text{selecta}! a \\ (\\text{plus} \\ 1 \\ j)) \\, 0)). \\]\n\nBut this again simplifies, applying the lemmas plus-1, sub1-add1, and x-not-less-than-x, and unfolding the functions lessp, plus, numberp, add1, sub1, and equal, to:\n\n\\[ t. \\]\n\nCase 3.2.\n\n\\[ (\\text{implies} \\ (\\text{and} \\ (\\text{lessp} \\ j \\ i) \\ (\\text{arrayp}\\! a) \\ (\\text{numberp} \\ i) \\ (\\text{numberp} \\ j) \\ (\\text{equal} \\ (\\text{selecta}! a \\ (\\text{add1} \\ j)) \\, 0) \\ (\\text{equal} \\ i \\ 0)) \\) \\ (\\text{allzero} \\ a \\ (\\text{add1} \\ i) \\ (\\text{add1} \\ j))), \\]\n\nwhich again simplifies, using linear arithmetic, to:\n\n\\[ t. \\]\nCase 3.1.\n\n\\[\n(\\text{implies} \\ (\\text{and} \\ (\\text{lessp} \\ j \\ i) \\\\\n\\quad (\\text{arrayp}! \\ a) \\\\\n\\quad (\\text{numberp} \\ i) \\\\\n\\quad (\\text{numberp} \\ j) \\\\\n\\quad (\\text{equal} \\ (\\text{selecta}! \\ a \\ (\\text{add1} \\ j)) \\ 0) \\\\\n\\quad (\\text{equal} \\ i \\ 0)) \\\\\n\\quad (\\text{equal} \\ (\\text{selecta}! \\ a \\ i) \\ 0))\n\\]\n\nwhich again simplifies, using linear arithmetic, to:\n\n\\[\nt.\n\\]\n\nCase 2. \\( (\\text{implies} \\ (\\text{and} \\ (\\text{leq} \\ i \\ j) \\\\\n\\quad (\\text{not} \\ (\\text{allzero} \\ a \\ (\\text{add1} \\ i) \\ j)) \\\\\n\\quad (\\text{arrayp}! \\ a) \\\\\n\\quad (\\text{numberp} \\ i) \\\\\n\\quad (\\text{numberp} \\ j) \\\\\n\\quad (\\text{allzero} \\ a \\ i \\ j) \\\\\n\\quad (\\text{equal} \\ (\\text{selecta}! \\ a \\ (\\text{add1} \\ j)) \\ 0) \\\\\n\\quad (\\text{allzero} \\ a \\ i \\ (\\text{add1} \\ j)))) \\]\n\nwhich simplifies, opening up allzero, to:\n\n\\[\nt.\n\\]\n\nCase 1. \\( (\\text{implies} \\ (\\text{and} \\ (\\text{leq} \\ i \\ j) \\\\\n\\quad (\\text{allzero} \\ a \\ (\\text{add1} \\ i) \\ (\\text{add1} \\ j)) \\\\\n\\quad (\\text{arrayp}! \\ a) \\\\\n\\quad (\\text{numberp} \\ i) \\\\\n\\quad (\\text{numberp} \\ j) \\\\\n\\quad (\\text{allzero} \\ a \\ i \\ j) \\\\\n\\quad (\\text{equal} \\ (\\text{selecta}! \\ a \\ (\\text{add1} \\ j)) \\ 0)) \\\\\n\\quad (\\text{allzero} \\ a \\ i \\ (\\text{add1} \\ j)))) \\]\n\nwhich simplifies, applying sub1-add1, and opening up the definitions of allzero, lessp, and equal, to:\n\n\\[\nt.\n\\]\n\nThat finishes the proof of *1. Q.E.D.\nIn 30 seconds, an inductive proof, produced without manual intervention. This is Boyer and Moore’s great accomplishment. It took them seven years to write the program that does this. Note that our earlier lemma \\texttt{allzero-void-rule} was used in the proof; we are teaching the prover more and more facts about \\texttt{allzero}.\n\nNow a seemingly simple but non-trivial property; storing into the array outside the bounds of \\texttt{allzero} does not affect the \\texttt{allzero} property.\n\n\\[\n\\rightarrow \\text{(prove-lemma allzero-unchanged-1-rule)} \\text{(rewrite)}\n\\text{(implies (and (numberp i) (numberp j) (arrayp! a) (allzero a i j) (numberp x) (or (lessp x i) (lessp j x))) (allzero (storea! a x v) i j))}\n\\]\n\nThe prover takes over...\nThis conjecture simplifies, opening up the function or, to two new goals:\n\nCase 2. \\((\\text{implies} \\ (\\text{and} \\ (\\text{numberp} \\ i) \\ (\\text{numberp} \\ j) \\ (\\text{arrayp!} \\ a) \\ (\\text{allzero} \\ a \\ i \\ j) \\ (\\text{numberp} \\ x) \\ (\\text{lessp} \\ x \\ i)) \\ (\\text{allzero} \\ (\\text{storea!} \\ a \\ x \\ v) \\ i \\ j)),\\)\n\nwhich we will name *1.\n\nCase 1. \\((\\text{implies} \\ (\\text{and} \\ (\\text{numberp} \\ i) \\ (\\text{numberp} \\ j) \\ (\\text{arrayp!} \\ a) \\ (\\text{allzero} \\ a \\ i \\ j) \\ (\\text{numberp} \\ x) \\ (\\text{lessp} \\ j \\ x)) \\ (\\text{allzero} \\ (\\text{storea!} \\ a \\ x \\ v) \\ i \\ j)),\\)\n\nwhich we would usually push and work on later by induction. But if we must use induction to prove the input conjecture, we prefer to induct on the original formulation of the problem. Thus we will disregard all that we have previously done, give the name *1 to the original input, and work on it.\n\nSo now let us consider:\n\n\\((\\text{implies} \\ (\\text{and} \\ (\\text{numberp} \\ i) \\ (\\text{numberp} \\ j) \\ (\\text{arrayp!} \\ a) \\ (\\text{allzero} \\ a \\ i \\ j) \\ (\\text{numberp} \\ x) \\ (\\text{lessp} \\ j \\ x)) \\ (\\text{allzero} \\ (\\text{storea!} \\ a \\ x \\ v) \\ i \\ j)) \\ (\\text{implies} \\ (\\text{and} \\ (\\text{numberp} \\ i) \\ (\\text{numberp} \\ j) \\ (\\text{arrayp!} \\ a) \\ (\\text{allzero} \\ a \\ i \\ j) \\ (\\text{numberp} \\ x) \\ (\\text{lessp} \\ x \\ i)) \\ (\\text{allzero} \\ (\\text{storea!} \\ a \\ x \\ v) \\ i \\ j))),\\)\n\nwhich we named *1 above. We will appeal to induction. The\nrecursive terms in the conjecture suggest 12 inductions. They merge into three likely candidate inductions. However, only one is unflawed. We will induct according to the following scheme:\n\n\\[\n\\begin{align*}\n&\\text{(and (implies (lessp j i) (p a x v i j))} \\\\\n&\\quad \\text{(implies (and (leq i j) (p a x v (add1 i) j))} \\\\\n&\\quad \\quad \\text{(p a x v i j))}. \\\\\n\\end{align*}\n\\]\n\nLinear arithmetic informs us that the measure \\((\\text{difference (add1 j) i})\\) decreases according to the well-founded relation \\(\\text{lessp}\\) in each induction step of the scheme. The above induction scheme produces the following seven new goals:\n\nCase 7. \\((\\text{implies (and (lessp j i) \\\\\nnumberp i) \\\\\nnumberp j) \\\\\n(arrayp! a) \\\\\n(allzero a i j) \\\\\n(numberp x) \\\\\n(lessp j x)) \\\\\n(allzero (storea! a x v) i j)).\\)\n\nThis simplifies, applying the lemmas allzero-void-rule and store-is-proper, to:\n\n\\(t.\\)\n\nCase 6. \\((\\text{implies (and (leq i j) \\\\\n(not (allzero a (add1 i) j)) \\\\\n(numberp i) \\\\\n(numberp j) \\\\\n(arrayp! a) \\\\\n(allzero a i j) \\\\\n(numberp x) \\\\\n(lessp j x)) \\\\\n(allzero (storea! a x v) i j)).\\)\n\nThis simplifies, unfolding the definition of allzero, to:\n\n\\(t.\\)\n\nCase 5. \\((\\text{implies (and (leq i j) \\\\\n(allzero (storea! a x v) (add1 i) j) \\\\\n(numberp i) \\\\\n(numberp j) \\\\\n(arrayp! a) \\\\\n(allzero a i j))}\\)\n(numberp x)\n(lessp j x))\n(allzero (storea! a x v) i j)).\n\nThis simplifies, rewriting with select-of-store, and unfolding the function allzero, to:\n\n(implies (and (leq i j)\n(allzero (storea! a x v) (add1 i) j)\n(numberp i)\n(numberp j)\n(arrayp! a)\n(allzero a (add1 i) j)\n(equal (selecta! a i) 0)\n(numberp x)\n(lessp j x)\n(equal x i))\n(equal v 0)).\n\nThis again simplifies, trivially, to:\n\n\\( t. \\)\n\nCase 4. (implies (and (lessp j i)\n(numberp i)\n(numberp j)\n(arrayp! a)\n(allzero a i j)\n(numberp x)\n(lessp x i))\n(allzero (storea! a x v) i j)).\n\nThis simplifies, applying allzero-void-rule and store-is-proper, to:\n\n\\( t. \\)\n\nCase 3. (implies (and (leq i j)\n(leq x j)\n(leq (add1 i) x)\n(numberp i)\n(numberp j)\n(arrayp! a)\n(allzero a i j)\n(numberp x)\n(lessp x i))\n(allzero (storea! a x v) i j)),\n\nwhich simplifies, using linear arithmetic, to:\n\nt.\n\nCase 2. (implies (and (leq i j)\n (not (allzero a (add1 i) j))\n (numberp i)\n (numberp j)\n (arrayp! a)\n (allzero a i j)\n (numberp x)\n (lessp x i))\n (allzero (storea! a x v) i j)),\n\nwhich simplifies, unfolding the definition of allzero, to:\n\nt.\n\nCase 1. (implies (and (leq i j)\n (allzero (storea! a x v) (add1 i) j)\n (numberp i)\n (numberp j)\n (arrayp! a)\n (allzero a i j)\n (numberp x)\n (lessp x i))\n (allzero (storea! a x v) i j)),\n\nwhich simplifies, rewriting with the lemma select-of-store, and opening up the function allzero, to:\n\n(implies (and (leq i j)\n (allzero (storea! a x v) (add1 i) j)\n (numberp i)\n (numberp j)\n (arrayp! a)\n (allzero a (add1 i) j)\n (equal (selecta! a i) 0)\n (numberp x)\n (lessp x i)\n (equal x i))\n (equal v 0)).\n\nHowever this again simplifies, using linear arithmetic, to:\nAn unexpectedly difficult proof; the prover went down a blind alley, backed up, started over, began induction, performed a case analysis, and found a proof.\n\nFor our next rule, we prove that storing zero into an array does not cause the allzero predicate to become false.\n\n-> (prove-lemma allzero-unchanged-2-rule\n (rewrite)\n (implies (and (allzero a i j)\n (arrayp a)\n (numberp i)\n (numberp j)\n (numberp x))\n (allzero (storea a x 0) i j)))\n\nThe prover replies:\nCall the conjecture *1.\n\nWe will appeal to induction. Four inductions are suggested by terms in the conjecture. They merge into two likely candidate inductions. However, only one is unflawed. We will induct according to the following scheme:\n\n$$\\begin{align*}\n & (\\text{and} \\ (\\text{implies} \\ (\\text{lessp} \\ j \\ i) \\ (p \\ a \\ x \\ i \\ j)) \\\\\n & \\quad (\\text{implies} \\ (\\text{and} \\ (\\text{leq} \\ i \\ j) \\ (p \\ a \\ x \\ (\\text{add1} \\ i) \\ j)) \\\\\n & \\quad \\quad (p \\ a \\ x \\ i \\ j))).\n\\end{align*}$$\n\nLinear arithmetic informs us that the measure \n\n$$\\text{(difference} \\ (\\text{add1} \\ j) \\ i)$$\n\ndecreases according to the well-founded relation lessp in each induction step of the scheme. The above induction scheme produces the following three new goals:\n\nCase 3. $$(\\text{implies} \\ (\\text{and} \\ (\\text{lessp} \\ j \\ i) \\\\\n\\quad (\\text{allzero} \\ a \\ i \\ j) \\\\\n\\quad (\\text{arrayp}! \\ a) \\\\\n\\quad (\\text{numberp} i) \\\\\n\\quad (\\text{numberp} j) \\\\\n\\quad (\\text{numberp} x)) \\\\\n\\quad (\\text{allzero} \\ (\\text{storea}! \\ a \\ x \\ 0) \\ i \\ j))$$. \n\nThis simplifies, rewriting with allzero-void-rule and store-is-proper, to:\n\n$$t.$$ \n\nCase 2. $$(\\text{implies} \\ (\\text{and} \\ (\\text{leq} \\ i \\ j) \\\\\n\\quad (\\text{not} \\ (\\text{allzero} \\ a \\ (\\text{add1} \\ i) \\ j)) \\\\\n\\quad (\\text{allzero} \\ a \\ i \\ j) \\\\\n\\quad (\\text{arrayp}! \\ a) \\\\\n\\quad (\\text{numberp} i) \\\\\n\\quad (\\text{numberp} j) \\\\\n\\quad (\\text{numberp} x)) \\\\\n\\quad (\\text{allzero} \\ (\\text{storea}! \\ a \\ x \\ 0) \\ i \\ j)),$$\n\nwhich simplifies, opening up allzero, to:\n\n$$t.$$ \n\nCase 1. $$(\\text{implies} \\ (\\text{and} \\ (\\text{leq} \\ i \\ j) \\\\\n\\quad (\\text{allzero} \\ (\\text{storea}! \\ a \\ x \\ 0) \\ (\\text{add1} \\ i) \\ j) \\\\\n\\quad (\\text{allzero} \\ a \\ i \\ j) \\\\\n\\quad (\\text{arrayp}! \\ a) \\\\\n\\quad (\\text{numberp} i) \\\\\n\\quad (\\text{numberp} j)$$\n(numberp x))\n(allzero (storea! a x 0) i j)),\n\nwhich simplifies, applying select-of-store, and opening up the functions allzero and equal, to:\n\nt.\n\nThat finishes the proof of *1. Q.E.D.\n\n[ 20.23333099999997 1.10000200000001 ]\nallzero-unchanged-2-rule\n\nThat one wasn’t too hard.\n\nFinally, the rule that lets us get some payoff from using allzero in a program verification; we show that if allzero is true for A from I to J, then for any element X between I and J, then A[X] = 0.\n\n-> (prove-lemma allzero-select-rule\n (rewrite)\n (implies (and (allzero a i j)\n (numberp i)\n (numberp j)\n (arrayp! a)\n (numberp x)\n (leq x j)\n (leq i x))\n (equal (selecta! a x) 0)))\n\nOver to the prover.\n\nWARNING: Note that allzero-select-rule contains the free variables j and i which will be chosen by instantiating the hypothesis (allzero a i j).\n\nHere the prover grumbles at us; our rule is not well chosen according to its built-in ideas as to what an efficient rewrite lemma is. Rules of this type may slow down the prover in later proofs. In this case, though, there is no better way to state this rule. The theorem prover proceeds; this was only a WARNING. There is no risk to soundness here.\nName the conjecture *1.\n\nLet us appeal to the induction principle. There are seven plausible inductions. They merge into three likely candidate inductions. However, only one is unflawed. We will induct according to the following scheme:\n\n\\[ (\\text{and} \\ (\\text{implies} \\ (\\text{lessp} \\ j \\ i) \\ (p \\ a \\ x \\ i \\ j)) \\n\\ (\\text{implies} \\ (\\text{and} \\ (\\text{leq} \\ i \\ j) \\ (p \\ a \\ x \\ (\\text{add1} \\ i) \\ j)) \\n\\ (p \\ a \\ x \\ i \\ j))). \\]\n\nLinear arithmetic establishes that the measure \\((\\text{difference} \\ (\\text{add1} \\ j) \\ i)\\) decreases according to the well-founded relation \\text{lessp} in each induction step of the scheme. The above induction scheme generates three new formulas:\n\nCase 3. \\( (\\text{implies} \\ (\\text{and} \\ (\\text{lessp} \\ j \\ i) \\n\\ (\\text{allzero} \\ a \\ i \\ j)) \\n\\ (\\text{numberp} \\ i) \\n\\ (\\text{numberp} \\ j) \\n\\ (\\text{arrayp!} \\ a) \\n\\ (\\text{numberp} \\ x) \\n\\ (\\text{leq} \\ x \\ j) \\n\\ (\\text{leq} \\ i \\ x)) \\n\\ (\\text{equal} \\ (\\text{selecta!} \\ a \\ x) \\ 0)) \\),\n\nwhich simplifies, using linear arithmetic, to:\n\n\\( t. \\)\n\nCase 2. \\( (\\text{implies} \\ (\\text{and} \\ (\\text{leq} \\ i \\ j) \\n\\ (\\text{not} \\ (\\text{allzero} \\ a \\ (\\text{add1} \\ i) \\ j)) \\n\\ (\\text{allzero} \\ a \\ i \\ j)) \\n\\ (\\text{numberp} \\ i) \\n\\ (\\text{numberp} \\ j) \\n\\ (\\text{arrayp!} \\ a) \\n\\ (\\text{numberp} \\ x) \\n\\ (\\text{leq} \\ x \\ j) \\n\\ (\\text{leq} \\ i \\ x)) \\n\\ (\\text{equal} \\ (\\text{selecta!} \\ a \\ x) \\ 0)) \\),\n\nwhich simplifies, unfolding allzero, to:\n\n\\( t. \\)\n\nCase 1. \\( (\\text{implies} \\ (\\text{and} \\ (\\text{leq} \\ i \\ j) \\n\\ (\\text{lessp} \\ x \\ (\\text{add1} \\ i)) \\n\\ (\\text{numberp} \\ i) \\n\\ (\\text{numberp} \\ j) \\n\\ (\\text{arrayp!} \\ a) \\n\\ (\\text{numberp} \\ x) \\n\\ (\\text{leq} \\ x \\ j) \\n\\ (\\text{leq} \\ i \\ x)) \\n\\ (\\text{equal} \\ (\\text{selecta!} \\ a \\ x) \\ 0)) \\),\nwhich simplifies, using linear arithmetic, to:\n\n(implies (and (leq i j)\n (lessp i (add1 i))\n (allzero a i j)\n (numberp i)\n (numberp j)\n (arrayp! a)\n (numberp i)\n (leq i j)\n (leq i i))\n (equal (selecta! a i) 0)).\n\nBut this again simplifies, applying sub1-add1, and opening up lessp, numberp, equal, and allzero, to:\n\n(implies (and (equal i 0)\n (allzero a 0 j)\n (numberp j)\n (arrayp! a))\n (equal (selecta! a 0) 0)),\n\nwhich again simplifies, opening up the definitions of add1, lessp, equal, and allzero, to:\n\n t.\n\nThat finishes the proof of *1. Q.E.D.\n\n[ 15.0 1.266665999999987 ]\nallzero-select-rule\n\nSuccess. We now have a set of rules which will allow us to use allzero in a verification and to use it in most of the reasonable ways to use such a predicate. Note that this\napproach will work for any predicate based on properties of individual array elements. **Allzero** is a simple example.\n\nWe are done proving; it is time to make a library file for use with the Verifier (or for later use with **note-lib** in case we need some more lemmas for our verification).\n\n```\n-> (make-lib 'allzero)\n(%$unopenedport %$unopenedport)\n```\n\nThe files **allzero.lib** and **allzero.lisp** have now been created in the current directory. Together these constitute our new knowledge base. We are now ready to leave the Rule Builder.\n\n```\n-> (exit)\n```\n\nThis returns us to the UNIX shell. At this point, we can put our new rules in the working directory created by the Verifier for the program **example6.pf** by using the **putrules** utility program, which extracts all the needed information from a Rule Builder database and puts it into a much more compact file which the Verifier can use.\n\n```\n% putrules allzero.lib example6_d\n```\n\nPutrules runs and prints some messages. This is just a format translation; nothing profound is going on here.\n\n```\nProcessing database allzero.lib\nInstalling new database in example6_d\n```\n\nWe can now rerun our verification.\n\n```\n% pasver example6.pf\n```\n\nand the verifier prints\nPass 1:\nPass 2:\nPass 3:\n\nVerifying example6\nNo errors detected\n\nso our verification is a success.\n\n7.6 Additional output from the verifier\n\nTo show what the Verifier actually does with the information provided through rules, we show some of the diagnostic output the Verifier produces for the use of those building and testing rules. When a verification is unsuccessful, it is usually best to try to fix the problem by looking at the source program. There are, though, additional outputs available from the Verifier for dealing with difficult problems.\n\nThis section is not intended to give a real understanding of how the Verifier works. There is an internal documentation manual for the Verifier, and the sections of that manual entitled Icode to Jcode Translator and Verification Condition Generator cover the generation of verification conditions and the internal file formats in much greater detail.\n\n7.6.1 The logging file\n\nThe output below all appears in the file p3-vcs in the Verifier’s scratch directory programname-dvecg flag is set on the call to pasver.)\n\n7.6.1.1 The rule listing\n\nThe first part of this file is the list of rules found in the ruledatabase file.\n\n```\nallzero-extend-upward-rule ---\n Usable on conclusions only, free variables (A I J g00002)\n Trigger pattern sequence: ((allzero A I g00002) (allzero A I J))\narrayp!(A)\nand numberp!(I)\nand numberp!(J)\nand allzero(A,I,J)\nand (A[addn!(J,1)] = 0)\nimplies\n allzero(A,I,addn!(J,1))\n```\n\nWe remember this rule from the Rule Builder session. Here, the rules appear in infix form, in Pascal-like notation. Operators which have no Pascal-F source representation appear as function calls. These names all end with “!” to avoid interference with user-defined functions. Note that numberp has become numberp!, and (add1 J) has become addn!(J,1), where addn! is the plus function (natural number add) from the Rule\nBuilder.\n\nThe list of free variables lists all the terms which must be bound when the rule is instantiated. The dummy name \\texttt{g00002} is a placeholder for the \\texttt{addn!} term in the conclusion.\n\nThe trigger pattern sequence shows when the rule will be applied. The Verifier will look at the verification condition, and will try to match the first pattern in the sequence. Once it matches, the variables in that pattern are bound and the Verifier begins looking for the second pattern in the sequence. The message “usable on conclusions only” indicates that the first pattern is general enough (containing only one function symbol) that applying the rule everywhere in every way that \\texttt{allzero} appeared would slow down the system too much. So this rule will only be applied when \\texttt{allzero} appears in a proof goal, that is, something written in an \\texttt{ASSERT, STATE, SUMMARY, ENTRY, exit, or INVARIANT}, or (not possible in this case) in an internally generated requirement used to insure subscripts within range or arithmetic results within bounds. Within this limitation, rules are applied in every possible combination of ways, but only one deep, so if a proof can be found in one step with the given rules, it will be found.\n\n\\begin{verbatim}\nallzero-select-rule --\n Usable on conclusions only, free variables (A I J X)\n Trigger pattern sequence: ((selecta! A X) (allzero A I J))\n\nallzero(A,I,J)\nand numberp!(I)\nand numberp!(J)\nand arrayp!(A)\nand numberp!(X)\nand not gtn!(X,J)\nand not gtn!(I,X)\nimplies\n A[X] = 0\n\\end{verbatim}\n\nNote that \\(A[X]\\) is \\(\\texttt{(selecta! A X)}\\) in the pattern. The function \\texttt{gtn!} is the greater than operator for the natural numbers.\nallzero-single-rule --\nUsable on conclusions only, free variables (A I J)\nTrigger pattern sequence: ((allzero A I J))\narrayp!(A) and numberp!(I) and numberp!(J) and (I = J) and (A[I] = 0)\nimplies\n allzero(A, I, J)\n\nallzero-unchanged-1-rule --\nUsable anywhere, free variables (A I J V X)\nTrigger pattern sequence: ((allzero (storea! A X V) I J))\n\nnumberp!(I)\nand numberp!(J)\nand arrayp!(A)\nand allzero(A, I, J)\nand numberp!(X)\nand (gtn!(I, X) or gtn!(X, J))\nimplies\n allzero(<A, X, V>, I, J)\n\nNote that this rule is usable anywhere. Because there are nested function symbols in the pattern, we don’t expect to see too many places where this rule could be applied without purpose. Also note the appearance of <A, X, V> which is the infix form of (storea! A X V).\n\nallzero-unchanged-2-rule --\nUsable anywhere, free variables (A I J X)\nTrigger pattern sequence: ((allzero (storea! A X 0) I J))\n\nallzero(A, I, J)\nand arrayp!(A)\nand numberp!(I)\nand numberp!(J)\nand numberp!(X)\nimplies\n allzero(<A, X, 0>, I, J)\nThe following rules are part of the standard database, and are used for proving definedness.\n\narraytrue-extend-upward-rule --\nUsable on conclusions only, free variables (A I J g00005)\nTrigger pattern sequence: ((arraytrue! A I g00005) (arraytrue! A I J))\n\n(arraytrue!(A, I, J) = true) and (alltrue!(A[addn!(J,1)])) = true\nimplies\narraytrue!(A, I, addn!(J,1)) = true\n\narraytrue-single-rule --\nUsable on conclusions only, free variables (A I)\nTrigger pattern sequence: ((selecta! A I))\n\narraytrue!(A, I, I) = true = alltrue!(A[I]) = true\n\narraytrue-unchanged-rule --\nUsable anywhere, free variables (A I J V X)\nTrigger pattern sequence: ((arraytrue! (storea! A X V) I J))\n\nnumberp!(X)\nand numberp!(I)\nand numberp!(J)\nand arrayp!(A)\nand (arraytrue!(A, I, J) = true)\nand (gtn!(I, X) or gtn!(X, J))\nimplies\narraytrue!(<A, X, V>, I, J) = true\narraytrue-void-rule --\n Usable on conclusions only, free variables (A I J)\nTrigger pattern sequence: ((arraytrue! A I J))\n\ngtn!(I,J) implies arraytrue!(A,I,J)\n\n7.6.1.2 The verification trace\n\nNow we go on to the verification goals themselves. If a verification condition had failed, it would have been printed, but all these succeeded, so only the goal and path appear. This is exactly the text that would appear as an error message if the proof failed.\n\nVerification condition for {example6.pf:18} table1[(j - 1) + 1] = 0\n(ASSERT assertion)\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:11} FOR loop never entered\n Tried arraytrue-single-rule.\nVC #1 proved in 1.00 seconds.\n\nThis one took one second, and arraytrue-single-rule was successfully pattern-matched, although it is irrelevant in this case. The message “Tried” indicates only that the rule could have been applied, not that it actually was.\n\nVerification condition for {example6.pf:18} table1[(j - 1) + 1] = 0\n(ASSERT assertion)\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:11} FOR loop exit\n Tried allzero-select-rule.\n Tried arraytrue-single-rule.\nVC #2 proved in 2.70 seconds.\n\nHere there is some statement about definedness in the hypothesis of the verification condition which triggered the built-in rule arraytrue-single-rule.\nVerification condition for `{example6.pf:16} allzero(table1,1,100)`\n(ASSERT assertion)\nPath:\n `{example6.pf:11} Start of \"example6\"\n `{example6.pf:11} FOR loop never entered\n Tried allzero-extend-upward-rule.\n Tried allzero-single-rule.\n Tried allzero-void-rule.\nVC #3 proved in 0.63 seconds.\n\nWe do not get any useful information about which rule did it, if any.\n\nVerification condition for `{example6.pf:16} allzero(table1,1,100)`\n(ASSERT assertion)\nPath:\n `{example6.pf:11} Start of \"example6\"\n `{example6.pf:11} FOR loop exit\n Tried allzero-extend-upward-rule 2 times.\n Tried allzero-single-rule.\n Tried allzero-void-rule.\nVC #4 proved in 1.00 seconds.\n\nVerification condition for `{example6.pf:11} i <= 99`\n(FOR loop count)\nPath:\n `{example6.pf:11} Start of \"example6\"\nVC #5 proved in 0.75 seconds.\nVerification condition for {example6.pf:14} allzero(table1,1,i) (STATE assertion)\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:15} Back to top of FOR loop\n Tried allzero-unchanged-2-rule 2 times.\n Tried allzero-unchanged-1-rule 2 times.\n Tried allzero-extend-upward-rule 2 times.\n Tried allzero-single-rule.\n Tried allzero-void-rule.\nVC #6 proved in 28.81 seconds.\n\nThis is the inductive case around the loop, the hard one. It took 28 seconds.\n\nVerification condition for {example6.pf:14} allzero(table1,1,i) (STATE assertion)\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:11} Enter FOR loop\n Tried allzero-unchanged-2-rule 2 times.\n Tried allzero-unchanged-1-rule 2 times.\n Tried allzero-extend-upward-rule 2 times.\n Tried allzero-single-rule.\n Tried allzero-void-rule.\nVC #7 proved in 2.45 seconds.\n\nVerification condition for {example6.pf:13} allzero(table1,1,i - 1) (ASSERT assertion)\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:15} Back to top of FOR loop\n Tried allzero-unchanged-2-rule.\n Tried allzero-unchanged-1-rule.\n Tried allzero-extend-upward-rule.\n Tried allzero-single-rule.\n Tried allzero-void-rule.\nVC #8 proved in 9.25 seconds.\nVerification condition for \\{example6.pf:13\\} allzero(table1,1,i - 1) (ASSERT assertion)\nPath:\n{example6.pf:11} Start of \"example6\"\n{example6.pf:11} Enter FOR loop\nTried allzero-unchanged-2-rule.\nTried allzero-unchanged-1-rule.\nTried allzero-extend-upward-rule.\nTried allzero-single-rule.\nTried allzero-void-rule.\nVC #9 proved in 2.03 seconds.\n\nVerification condition for \\{example6.pf:12\\} i - 1 <= 99 (subscript check for \"table1\" 1..100)\nPath:\n{example6.pf:11} Start of \"example6\"\n{example6.pf:15} Back to top of FOR loop\nVC #10 proved in 0.30 seconds.\n\nThis is an internally-generated proof goal, a subscript check.\n\nVerification condition for \\{example6.pf:12\\} i - 1 <= 99 (subscript check for \"table1\" 1..100)\nPath:\n{example6.pf:11} Start of \"example6\"\n{example6.pf:11} Enter FOR loop\nVC #11 proved in 0.26 seconds.\n\nVerification condition for \\{example6.pf:12\\} i - 1 >= 0 (subscript check for \"table1\" 1..100)\nPath:\n{example6.pf:11} Start of \"example6\"\n{example6.pf:15} Back to top of FOR loop\nVC #12 proved in 0.31 seconds.\nVerification condition for {example6.pf:12} i - 1 >= 0\n (subscript check for \"table1\" 1..100)\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:11} Enter FOR loop\nVC #13 proved in 0.26 seconds.\n\nVerification condition for {example6.pf:12} \"i\" is defined\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:15} Back to top of FOR loop\nVC #14 proved in 0.08 seconds.\n\nThis is a test to make sure the variable i was defined at line 12. These usually are very fast to prove.\n\nVerification condition for {example6.pf:12} \"i\" is defined\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:11} Enter FOR loop\nVC #15 proved in 0.06 seconds.\n\nThat is the summary of the verification. When a verification is unsuccessful, and it is not clear why, examination of this file can be quite useful. Remember that this file is not generated unless requested, and generating it does slow down the verification by about 20-40%.\n\n7.6.1.3 What verification conditions look like\n\nIt is not usually necessary for the user to look at verification conditions, but when difficulties are encountered it can sometimes be useful. When using a compiler, it is sometimes useful to turn on a listing of generated object code. The equivalent listing for a verifier is the listing of verification conditions. We thus provide an explanation as to how to read a verification condition.\n\nHad a verification condition failed, in the above example, we would see, in this log of verification conditions, the verification condition itself. If we force some errors by trying to run the verification above without any rules about allzero available, we would find the information below in the log.\nVerification condition for {example6.pf:14} allzero(table1,1,i)\n (STATE assertion)\nPath:\n {example6.pf:11} Start of \"example6\"\n {example6.pf:15} Back to top of FOR loop\n\n (TEMP4__v01 = 1)\n and (TEMP5__v01 = 100)\n and true\n and (i_4v03 <= TEMP5__v01)\n and allzero(table1_2v02,1,i_4v03)\n and (i_4v03 >= TEMP4__v01)\n and (i_4v03 < TEMP5__v01)\n and (i_4v03 <= 99)\n and (i_4v04 = i_4v03 + 1)\n and (i_4v04 - 1 >= 0)\n and (i_4v04 - 1 <= 99)\n and (table1_2v03 = (table1_2v02[(i_4v04 - 1) + 1] := 0))\n and allzero(table1_2v03,1,i_4v04 - 1)\nimplies\n allzero(table1_2v03,1,i_4v04)\n\nVC #6 FAILED in 1.48 seconds.\n\nHere, we see the actual verification condition to be proved. This verification condition is for the path around the loop, with the proof goal of allzero(table1,1,i) in the STATE statement.\n\nVerification conditions are always of the form “big conjunction implies proof goal”. The proof goal is always the term printed after the implication. The terms in the hypothesis are generated by backwards tracing through the program, examining each statement along the indicated path. The details of how this is done are beyond the scope of this manual, but generally follow the backwards-tracing approach of Floyd, Manna, and others. The basic idea is that programs are converted to formulas by tracing backwards through each statement, using a new variable name for each variable every time its value is changed. For example, the Pascal-F statements\n\n x := 1;\n x := x + 1;\n assert(x = 2);\n\nwould generate a verification condition of the form\n\\[\n\\begin{align*}\n x_{1v01} & = 1 \\\\\n \\text{and } x_{1v02} & = (x_{1v01} + 1) \\\\\n \\text{implies} \\\\\n x_{1v02} & = 2\n\\end{align*}\n\\]\n\nNote that \\textit{x\\_1v01} and \\textit{x\\_1v02} represent values of \\textit{x} at different points in the program. In our \\textit{allzero} example, the variable names \\textit{i} and \\textit{table1} appear here in modified form; the \\textit{table1\\_2v03} string is the variable \\textit{table1} after the third assignment to it. The names are actually constructed by taking the user’s name of the variable, adding a delimiter and a variable serial number, (so that variables with the same name but in different scopes are made unique) and adding a \\textit{v} or a \\textit{d}, where a \\textit{v} indicates that the \\textit{value} of the variable is being referred to, and \\textit{d} indicates that the \\textit{definedness part} of the variable is being referenced. Finally, a two digit suffix indicating, as in the little example with \\textit{x} above, which value of the variable we are referring to, is added to the name. the code.\n\nThe \\textit{v} or \\textit{d} component deserves some extra discussion. Definedness of variables is handled by a convenient fiction. We pretend that associated with each variable there is a definedness flag, set to true when any value is assigned to the variable and tested at every reference to the variable. We then try to prove that the flag is always true at every reference. For an array or record our definedness part will be an array or record with all-Boolean elements or lowest-level fields. When the Verifier generates a verification condition about the definedness of a variable, it constructs a name using the \\textit{d} letter.\n\nNot shown in the verification condition is the type information. The theorem prover has available to it all the information in the type declarations of the Pascal-F program. For example, if the declaration\n\n\\[\n\\text{var } i : 0..100;\n\\]\n\nappeared in a Pascal-F program, the theorem prover would be able to prove\n\n\\[\n\\begin{align*}\n \\text{true} \\\\\n \\text{implies} \\\\\n i_{1v01} & \\leq 100\n\\end{align*}\n\\]\n\nwithout any difficulty. We can assume that all variables stay within their type because we generate proof goals for the bounds of every variable at every assignment to that variable. Since we also check at every reference to every variable that the variable has been initialized (defined) we are thus safe in assuming that variables stay within their types.\n\n7.6.2 The diagnostics file\n\nThe file \\texttt{p3-diags} contains any error messages produced during the verification. This is useful if messages scroll by on a CRT terminal and are thereby lost. Only messages from\npass 3 appear in this file, but pass 3 is where all the time goes.\n\n7.6.3 The rule data base file\n\nThe rule data base file ruledatabase is created by the putrules utility and read by the Verifier. It contains the rule data base to be used for the current verification.\n\n7.6.4 The history file\n\nThe history file history contains the entire intermediate code for each program unit previously verified successfully. On reverification attempts, if the newly generated intermediate code matches that found in the history file, verification of that program unit is skipped. Removal of this file will force a complete rerun of the verification. Note that putrules will remove this file if a new database is used with different defn entries for some previously used defn definition.\n\n8. The formal theory of the Rule Builder\n\nThe theory built into the Rule Builder is the Boyer-Moore theory of the natural numbers, plus the definitions and lemmas given in this chapter. The notation is that of A Computational Logic. Note that everything here has been proven by the Boyer-Moore prover.\n\n8.1 The theory\n\nWe begin by defining the notion of Boolean value.\n\nDefinition.\n(booleanz! X)\n =\n (or (equal X (true))\n (equal X (false)))\n\nThe next step is to add a large batch of carefully chosen facts about the natural numbers.\n\nTheorem. equal-lessp:\n(equal (equal (lessp X Y) Z)\n (if (lessp X Y)\n (equal t Z)\n (equal f Z)))\n\nTheorem. associativity-of-plus:\n(equal (plus (plus X Y) Z)\n (plus X (plus Y Z)))\n\nTheorem. equal-times-0:\n(equal (equal (times X Y) 0)\n (or (zerop X) (zerop Y)))\n\nTheorem. commutativity2-of-plus:\n(equal (plus X (plus Y Z))\n (plus Y (plus X Z)))\nTheorem. commutativity-of-times:\n(equal (times X Y) (times Y X))\n\nTheorem. distributivity-of-times-over-plus:\n(equal (times X (plus Y Z))\n (plus (times X Y) (times X Z)))\n\nTheorem. plus-0:\n(equal (plus X 0) (fix X))\n\nTheorem. plus-1:\n(implies (numberp X)\n (equal (plus 1 X) (add1 X)))\n\nTheorem. x-not-less-than-x:\n(equal (lesssp X X) f)\n\nTheorem. times-0:\n(equal (times X 0) 0)\n\nTheorem. plus-non-numberp:\n(implies (not (numberp Y))\n (equal (plus X Y) (fix X)))\n\nTheorem. times-non-numberp:\n(implies (not (numberp Y))\n (equal (times X Y) 0))\n\nTheorem. associativity-of-times:\n(equal (times (times X Y) Z)\n (times X (times Y Z)))\n\nTheorem. commutativity2-of-times:\n(equal (times X (times Y Z))\n (times Y (times X Z)))\n\nTheorem. plus-add1:\n(equal (plus X (add1 Y))\n (if (numberp Y)\n (add1 (plus X Y))\n (add1 X)))\n\nTheorem. times-add1:\n(equal (times X (add1 Y))\n (if (numberp Y)\n (plus X (times X Y))\n (fix X)))\nTheorem. commutativity-of-plus:\n(equal (plus X Y) (plus Y X))\n\nTheorem. plus-equal-0:\n(equal (equal (plus A B) 0)\n (and (zerop A) (zerop B)))\n\nTheorem. plus-cancellation:\n(equal (equal (plus A B) (plus A C))\n (equal (fix B) (fix C)))\n\nTheorem. plus-right-id2:\n(implies (not (numberp Y))\n (equal (plus X Y) (fix X)))\n\nTheorem. monotonicity-of-plus-1:\n(implies (and (numberp A)\n (numberp B)\n (numberp C))\n (equal (lessp (plus A B) (plus A C))\n (lessp B C)))\n\nTheorem. difference-x-x:\n(equal (difference X X) 0)\n\nTheorem. difference-plus-1:\n(equal (difference (plus X Y) X)\n (fix Y))\n\nTheorem. difference-plus-2:\n(equal (difference (plus Y X) X)\n (fix Y))\n\nTheorem. equal-difference-0:\n(equal (equal 0 (difference X Y))\n (not (lessp Y X)))\n\nTheorem. zero-difference:\n(implies (lessp A B)\n (equal (difference A B) 0))\n\nTheorem. plus-difference3:\n(equal (difference (plus X Y) (plus X Z))\n (difference Y Z))\nTheorem. monotonicity-of-difference-1:\n(implies (and (numberp V)\n (numberp Y)\n (numberp Z)\n (not (lessp Z V))\n (not (lessp Y V)))\n (equal (lessp (difference Y V)\n (difference Z V))\n (lessp Y Z)))\n\nTheorem. monotonicity-of-difference-2:\n(implies (and (numberp V)\n (numberp Y)\n (numberp Z)\n (lessp Z V)\n (lessp Y V))\n (equal (lessp (difference V Z)\n (difference V Y))\n (lessp Y Z)))\n\nTheorem. monotonicity-of-difference-3:\n(implies (and (numberp W)\n (numberp V)\n (numberp X)\n (not (lessp X W))\n (not (lessp X V))\n (equal (lessp (difference X V)\n (difference X W))\n (lessp W V)))\n\nTheorem. times-zero:\n(equal (times X 0) 0)\n\nTheorem. distributivity-of-times-over-difference:\n(equal (times X (difference Y Z))\n (difference (times X Y) (times X Z)))\n\nTheorem. monotonicity-of-times-1:\n(implies (and (numberp X)\n (numberp Y)\n (numberp Z)\n (not (zerop X)))\n (equal (not (lessp (times X Y) (times X Z)))\n (not (lessp Y Z)))))\nTheorem. monotonicity-of-times-3:\n(implies (and (numberp A)\n (numberp B)\n (numberp C)\n (not (equal C 0)))\n (equal (lessp (times C A) (times C B))\n (lessp A B)))\n\nTheorem. monotonicity-of-times-by-twos:\n(implies (and (lessp X Y) (lessp Z W))\n (lessp (times X Z) (times Y W)))\n\nTheorem. remainder-x-x:\n(equal (remainder X X) 0)\n\nTheorem. remainder-quotient:\n(equal (plus (remainder X Y)\n (times Y (quotient X Y)))\n (fix X))\n\nTheorem. remainder-quotient-elim:\n(implies (and (not (zerop Y)) (numberp X))\n (equal (plus (remainder X Y)\n (times Y (quotient X Y)))\n X))\n\nTheorem. remainder-non-numeric:\n(implies (not (numberp X))\n (equal (remainder Y X) (fix Y)))\n\nTheorem. remainder-wrt-1:\n(equal (remainder Y 1) 0)\n\nTheorem. quotient-times:\n(equal (quotient (times Y X) Y)\n (if (zerop Y) 0 (fix X)))\n\nTheorem. monotonicity-of-times:\n(implies (and (numberp X)\n (numberp Y)\n (numberp Z)\n (not (lessp Y Z)))\n (equal (lessp (times X Y) (times X Z))\n f))\n\nWe now add an object called undefined which will be needed in the definition of arrays. This has nothing to do with the Verifier's proofs of definedness; it is just a default object.\nintroduced to make \\texttt{selecta!} a total function.\n\nShell Definition.\nAdd the shell undefined-object of zero arguments with\nbottom object undefined,\nrecognizer undefinedp,\naccessors,\nand default values.\n\nThe definition of arrays is constructive. An array is actually represented as an ordered list of subscript-value pairs.\n\nShell Definition.\nAdd the shell array-shell of three arguments with\nbottom object empty-array,\nrecognizer array-recognizer,\naccessors array-elt-value, array-elt-subscript, and array-prev,\ntype restrictions (none-of), (one-of numberp), and:\n(one-of array-recognizer)\nand default values undefined, zero, and empty.array.\n\nThe predicate \\texttt{arrayp!} is true only if an array is a valid ordered list of pairs, properly ordered in increasing order of subscript. Note that something is an array only if the subscripts in the list are in ascending order and no value part is UNDEFINED.\n\nDefinition.\n\\begin{verbatim}\n(arrayp! A) =\n(if\n (array-recognizer A)\n (if (equal A (empty-array))\n t\n (if (or (not (numberp (array-elt-subscript A)))\n (equal (array-elt-value A)\n (undefined)))\n f\n (if (equal (array-prev A) (empty-array))\n t\n (and (lessp (array-elt-subscript (array-prev A))\n (array-elt-subscript A))\n (arrayp! (array-prev A)))))\n f))\n\\end{verbatim}\n\n\\texttt{selecta!} is the array subscripting function, which searches the list of pairs.\nDefinition.\n(selecta! A I)\n= (if (equal (array-elt-subscript A) I)\n (array-elt-value A)\n (if (equal (array-prev A) (empty-array))\n (undefined)\n (selecta! (array-prev A) I)))\n\nstorea! is quite complex, since it is actually a routine for inserting into an ordered list. Our check on the validity of this is that we are able to prove all the standard theorems about selecta! and storea!, which are axioms in the Oppen system.\n\nDefinition.\n(storea! A I V)\n= (if (and (arrayp! A) (numberp I))\n (if (equal A (empty-array))\n (if (equal V (undefined))\n A\n (array-shell V I (empty-array)))\n (if (equal V (undefined))\n (array-shell V I (array-prev A))\n (if (lessp (array-elt-subscript A) I)\n (if (equal V (undefined))\n A\n (array-shell V I A))\n (array-shell (array-prev A) I)\n (if (equal V (undefined))\n A\n (array-shell V I A))\n (array-shell (array-elt-value A)\n (array-elt-subscript A)\n (storea! (array-prev A) I V))))\n (empty-array))\n\nThe result of storea! is shown to be a valid array.\n\nTheorem. store-is-proper:\n(equal (arrayp! (storea! A I V)) t)\n\nWe prove the classic lemmas about selecta! and storea! This not only shows the validity of our definition of storea! , but gives the Rule Builder a set of rules which comprise a decision procedure for our array theory.\n\nTheorem. select-of-store-1:\n(implies (and (arrayp! A) (numberp I))\n (equal (selecta! (storea! A I V) I)\n V))\nTheorem. store-of-select:\n(implies (and (arrayp! A) (numberp I))\n (equal (storea! A I (selecta! A I))\n A))\n\nTheorem. select-of-store-2:\n(implies (and (arrayp! A) (numberp I) (numberp J) (not (equal I J)))\n (equal (selecta! (storea! A I V) J)\n (selecta! A J)))\n\nTheorem. select-of-store:\n(implies (and (arrayp! A) (numberp I) (numberp J))\n (equal (selecta! (storea! A I V) J)\n (if (equal I J) V (selecta! A J))))\n\nTheorem. store-of-store-1:\n(implies (and (arrayp! A) (numberp I))\n (equal (storea! (storea! A I V) I W)\n (storea! A I W)))\n\nstorer! is the record store function. The Rule Builder does not know about Verifier record structures, but the definition as an undefined function allows the appearance of storer! in rules. Of course, the only thing known about it in the Rule Builder is that if the arguments to storer! are the same, the result is the same. The Verifier proper has built-in knowledge about storer! and selectr!, but that knowledge is type-dependent and cannot be used here.\n\nUndefined Function.\n(storer! A B C)\n\nUndefined Function.\n(selectr! r I)\n\nalltrue! is true of an object if and only if all its components have the Boolean value TRUE. The Verifier has built-in knowledge about alltrue! and, as with the record operators, that knowledge is type-dependent.\n\nUndefined Function.\n(alltrue! r)\n\nIntegers are built up by defining a Boyer-Moore shell such that negative numbers are a shell whose negative-guts field contains the natural number for the absolute value. This creates a problem in that there is such a thing as negative zero. This definition of integerp! disallows negative zero, and all our operations on the integers never produce\nnegative zero.\n\nDefinition.\n\\[\n\\text{integerp}(X) =\n\\begin{cases}\n\\text{t} & \\text{if (numberp X)} \\\\\n\\text{f} & \\text{if (negativep X)} \\\\\n\\text{f} & \\text{if (zerop (negative-guts X)) f t}\n\\end{cases}\n\\]\n\nThis turns negative zero into positive zero.\n\nDefinition.\n\\[\n\\text{znormalize}(X) =\n\\begin{cases}\n\\text{X} & \\text{if (negativep X)} \\\\\n\\text{X} & \\text{if (equal (negative-guts X) 0) 0 X}\n\\end{cases}\n\\]\n\nThis is a conversion from a natural number to a negative number which avoids minus zero.\n\nDefinition.\n\\[\n\\text{zmonus}(X) =\n\\text{znormalize (minus X)}\n\\]\n\nUnary negation.\n\nDefinition.\n\\[\n\\text{negi}(X) =\n\\begin{cases}\n\\text{0} & \\text{if (integerp X)} \\\\\n\\text{zmonus X) (negative-guts X) (zmonus X)} & \\text{if (negativep X)}\n\\end{cases}\n\\]\n\nInteger addition is defined by cases. Proofs about integer arithmetic thus generate extensive case analysis, and due to a limitation of the Boyer-Moore prover it does not help to provide lemmas about nonrecursive definitions. Therefore there are no lemmas in this knowledge base about the integer arithmetic functions. It is quite possible to prove rules about addi! and its friends, and it is not usually difficult, but such proofs run slowly.\nDefinition. \n(addy! X Y) \n= \n(if (negativep X) \n (if (negativep Y) \n (zmonus (plus (negative-guts X) \n (negative-guts Y))) \n (if (lessp Y (negative-guts X)) \n (zmonus (difference (negative-guts X) Y)) \n (difference Y (negative-guts X)))) \n (if (negativep Y) \n (if (lessp X (negative-guts Y)) \n (zmonus (difference (negative-guts Y) X)) \n (difference X (negative-guts Y)))) \n \n (plus X Y))\n\nDefinition. \n(subby! X Y) \n= \n(addy! X (negi! Y))\n\nDefinition. \n(muli! X Y) \n= \n(if (negativep X) \n (if (negativep Y) \n (times (negative-guts X) \n (negative-guts Y)) \n (zmonus (times (negative-guts X) Y))) \n (if (negativep Y) \n (zmonus (times X (negative-guts Y))) \n (times X Y)))\n\nDefinition. \n(divi! X Y) \n= \n(if (negativep X) \n (if (negativep Y) \n (quotient (negative-guts X) \n (negative-guts Y)) \n (zmonus (quotient (negative-guts X) Y))) \n (if (negativep Y) \n (zmonus (quotient X (negative-guts Y))) \n (quotient X Y)))\n\nThe integer relational operators are defined by cases.\nDefinition.\n(lti! X Y)\n= (if (negativep X)\n (if (negativep Y)\n (lessp (negative-guts Y)\n (negative-guts X))\n (not (and (equal (negative-guts X) 0)\n (zerop Y))))\n (if (negativep Y) f (lessp X Y)))\n\nDefinition.\n(gti! X Y)\n= (lti! Y X)\n\nDefinition.\n(gei! X Y)\n= (not (lti! X Y))\n\nDefinition.\n(lei! X Y)\n= (not (lti! Y X))\n\n*zabs* is not actually used in rule building, but has been used in producing soundness proofs for the definitions of integer arithmetic.\n\nDefinition.\n(zabs X)\n= (if (negativep X) (negative-guts X) X)\n\nDefinition.\n(sign-mult X Y)\n= (if (equal X 1) Y (if (equal Y 1) -1 1))\n\nDefinition.\n(positivep X)\n= (if (numberp X) (if (not (zerop X)) t f) f)\nDefinition.\n(sign X)\n =\n (if (numberp X)\n 1\n (if (negativep X) -1 0))\n\nDefinition.\n(switch s X)\n =\n (if (equal s 1) X (negi! X))\n\nDefinition.\n(negative-and-non-zerop X)\n =\n (if (negativep X)\n (if (not (zerop (negative-guts X)))\n t f)\n f)\n\nDefinition.\n(diff-plus-1 X Y)\n =\n (difference (add1 Y) X)\n\nThe arraytrue! function is used in showing definedness. arraytrue! of A is true from I to J if and only if every element of A within the range I to J is equal to true. The Verifier will crank out arraytrue! forms when the user writes\n\n defined(A,I,J)\n\nor\n\n defined(A)\n\nwhere A is an array.\n\nDefinition.\n(arraytrue! A I J)\n =\n (if (lessp J I)\n t\n (and (equal (alltrue! (selecta! A I)) t)\n (arraytrue! A (add1 I) J)))\n\nWe have all the obvious rules about arraytrue!.\n\nTheorem. arraytrue-void-rule:\n(implies (lessp J I)\n (arraytrue! A I J))\nTheorem. arraytrue-single-rule:\n(equal (equal (arraytrue! A I I) t)\n (equal (alltrue! (selecta! A I)) t))\n\nTheorem. arraytrue-extend-upward-rule:\n(implies (and (equal (arraytrue! A I J) t)\n (equal (alltrue! (selecta! A (add1 J))) t))\n (equal (arraytrue! A I (add1 J)) t))\n\nTheorem. arraytrue-unchanged-rule:\n(implies (and (numberp X)\n (numberp I)\n (numberp J)\n (arrayp! A)\n (equal (arraytrue! A I J) t)\n (or (lessp X I) (lessp J X))\n (equal (arraytrue! (storea! A X V) I J) t))\n\nTheorem. arraytrue-unchanged-2-rule:\n(implies (and (numberp X)\n (numberp I)\n (numberp J)\n (arrayp! A)\n (equal (alltrue! V) t)\n (equal (arraytrue! A I J) t))\n (equal (arraytrue! (storea! A X V) I J) t))\n\nTheorem. arraytrue-select-rule:\n(implies (and (arraytrue! A I J)\n (numberp I)\n (numberp J)\n (numberp X)\n (not (lessp X I))\n (not (lessp J X))\n (alltrue! (selecta! A X)))\n\nFinally, we have the array construction function. This function is used to construct constant arrays in which all elements are the same. The only use for this function is to construct objects which represent the definedness parts of arrays known to be defined. When an entire array replacement appears in Pascal-f, the definedness part of the array will be set equal to a value built with \\texttt{arrayconstruct!} in the verification condition.\nDefinition.\n(arrayconstruct! V I J) =\n (if (lessp J I)\n (empty-array)\n (storea! (arrayconstruct! V (add1 I) J)\n I V))\n\nTheorem. arrayconstruct-is-arrayp:\n(arrayp! (arrayconstruct! V I J))\n\nTheorem. arrayconstruct-select-rule:\n(implies (and (numberp I)\n (numberp J)\n (numberp X)\n (not (lessp X I))\n (not (lessp J X)))\n (equal (selecta! (arrayconstruct! V I J) X)\n V))\n\nTheorem. arrayconstruct-implies-arraytrue-rule:\n(implies (and (numberp I)\n (numberp J)\n (equal (alltrue! V) t))\n (equal (arraytrue! (arrayconstruct! V I J)\n I J)\n t))\n\nThat is the built-in knowledge base. It takes about two hours to prove.\n\n9. Appendices\n\n1. Restrictions and limitations\n2. Reporting trouble\n3. Acknowledgements\n4. References\n\n9.1 Restrictions and limitations\n\nThis release of the system is the first release, and while we have taken extensive precautions against unsoundness we cannot at this time make strong statements about the validity of the verifications. A number of features are unimplemented or implemented with restrictions; however, none of these limitations affect soundness.\n9.1.1 Unimplemented features\n\nThe system is faithful to this manual except as noted below.\n\n- Fixed point arithmetic is unimplemented.\n- The SUMMARY statement is not implemented.\n- Arrays with negative lower bounds are prohibited.\n- Variant records are unimplemented.\n- Arrays with Boolean subscripts (not elements) are prohibited.\n- Most set operators are unimplemented.\n- The built-in functions of Pascal are unimplemented. The type coercions `chr` and `ord`, along with the Pascal-F named type coercions, are implemented.\n- The EFFECT declaration part is not fully implemented; EFFECT clauses are accepted and checked but not utilized in proofs.\n\n9.1.2 Restrictions\n\n- Side effect detection for functions is safe, but overly restrictive. If a function has side effects, essentially the only way it can be used is alone in an assignment statement. Procedures with side effects present no problems.\n- The Verifier’s knowledge about multiplication is weak. Nothing prevents the user from building new rules about the multiplication operator, but performance would be much better if the knowledge were built-in.\n- The built-in knowledge about definedness of arrays is limited; arrays must be initialized in strictly increasing order of subscript. However, it is possible to prove more lemmas about `arraytrue!` to allow more general initialization if desired.\n- The target machine against which the Verifier verifies is the Ford Electronic Engine Control IV, and the 16-bit, twos complement restrictions of that machine are enforced by the verifier.\n- There is no compiler code generator pass compatible with the verifier at present, so there is no way to run Pascal-F programs containing verification statements. There is a Pascal-F compiler for the EEC IV, but it is not available for distribution outside Ford.\n\n9.1.3 Known bugs\n\n9.1.4 Pass 1 (Compiler pass)\n\n- Some VALUE statements generate unexpected syntax errors.\n• The compiler pass is not as solid as we would like; the intermediate code generated for some operations confuses the decompiler in pass 2, resulting in fatal internal errors.\n\n9.1.5 Pass 2 (Semantic analysis)\n\n• FORWARD declarations will cause pass 2 to become confused about block numbers and an internal check will abort the Verifier.\n\n• There is a worry that the semantics of the FOR loop exit test may not exactly match the compilers for the case where the bounds are near to arithmetic overflow or underflow. The Verifier’s semantics are conservative but may not be conservative enough.\n\n• Records with only one field can create ambiguities as to whether a reference to a data item refers to a field or the entire record. This can result in pass 2 internal errors.\n\n9.1.6 Pass 3 (Path tracing)\n\n• The optimization of verification conditions will sometimes cause a useful term to be omitted from a hypothesis of a verification condition. The omitted term will be from a proof goal, and will be a mention of a function whose arguments contain no variables needed in the proof at that point. A work-around for this is known.\n\n9.1.7 Pass 4 (Simplifier)\n\n• Rule handling is unreasonably slow in the presence of many rules applicable to the same expression.\n\n• In at least one known case, the numeric portion of the prover fails to find a proof for a simple formula known to be true.\n\n9.1.8 Rule Builder\n\n• Lemmas about nonrecursive functions are not effectively used by the Boyer-Moore prover. This severely limits the proof power of the system with respect to the integers.\n\n• The manual sections on hints are inadequate.\n\n9.2 Reporting trouble\n\nProblems with the system should be reported to the address given in the preface. All trouble reports should include copies of the files in the scratch directory, the source program, and the error messages printed. Before submitting the trouble report, the verification should be rerun with the -d keyletter on. This will rerun the verification with all debug output turned on.\n9.3 Acknowledgements\n\nPascal-F was developed at the Ford Scientific Research Laboratories in Dearborn, Michigan, by Dr Edward Nelson. The Verifier is the work of Dr. Scott Johnson, John Nagle, Dr. John Privitera, and Dr. David Snyder, of Ford Aerospace and Communications Corporation. Dr. Derek Oppen consulted on the theorem prover modifications. The assistance of Dr. Robert Boyer and Dr. Jay Moore, of the University of Texas at Austin, has been very valuable, and we are indebted to Dr. Steven German, of Harvard University, for his formulation of the problem of checking for run-time errors. Finally, I would like to thank Dr. Shaun Devlin, of the Ford Motor Scientific Research Labs, for his faith and encouragement over the two years of the project.\n\nJohn Nagle\n\n9.4 References\n\n\nBOYER80 Boyer and Moore, private communication.\n\n\nOPPEN79 Oppen, Derek, Simplification by Co-operating Decision Procedures, Computer Science Department, Stanford University, 1979."}}},{"rowIdx":188,"cells":{"id":{"kind":"string","value":"17f033da749a76592014d20d1e644fd35100c688"},"text":{"kind":"string","value":"Optimal Parsing for dictionary text compression\nAlessio Langiu\n\nTo cite this version:\n\nHAL Id: tel-00804215\nhttps://tel.archives-ouvertes.fr/tel-00804215\nSubmitted on 25 Mar 2013\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.\nOptimal Parsing for Dictionary Text Compression\n\nAuthor: LANGIU Alessio\nPh.D. Thesis in Computer Science\nApril 3, 2012\n\nPhD Commission:\n\nThesis Directors: Prof. CROCHEMORE MAXIME University of Paris-Est\nProf. RESTIVO ANTONIO University of Palermo\n\nExaminers: Prof. ILIOPoulos Costas King’s College London\nProf. LECROQ THIERRY University of Rouen\nProf. MIGNOSI Filippo University of L’Aquila\n\nReferees: Prof. GROSSI Roberto University of Pisa\nProf. ILIOPoulos Costas King’s College London\nProf. LECROQ THIERRY University of Rouen\nSummary\n\nDictionary-based compression algorithms include a parsing strategy to transform the input text into a sequence of dictionary phrases. Given a text, such process usually is not unique and, for compression purposes, it makes sense to find one of the possible parsing that minimize the final compression ratio. This is the parsing problem. An optimal parsing is a parsing strategy or a parsing algorithm that solve the parsing problem taking into account all the constraints of a compression algorithm or of a class of homogeneous compression algorithms. Compression algorithm constraints are, for instance, the dictionary itself, i.e. the dynamic set of available phrases, and how much a phrase weights on the compressed text, i.e. the number of bits of which the codeword representing such phrase is composed, also denoted as the encoding cost of a dictionary pointer.\n\nIn more than 30 years of history of dictionary-based text compression, despite plenty of algorithms, variants and extensions have appeared and while dictionary approach to text compression became one of the most appreciated and utilized in almost all the storage and communication processes, only few optimal parsing algorithms were presented. Many compression algorithms still lack optimality of their parsing or, at least, proof of optimality. This happens because there is not a general model of the parsing problem including all the dictionary-based algorithms and because the existing optimal parsing algorithms work under too restrictive hypotheses.\n\nThis work focuses on the parsing problem and presents both a general model for dictionary-based text compression called Dictionary-Symbolwise Text Compression and a general parsing algorithm that is proved to be optimal under some realistic hypotheses. This algorithm is called Dictionary-\nSymbolwise Flexible Parsing and covers almost all of the known cases of\ndictionary-based text compression algorithms together with the large class\nof their variants where the text is decomposed in a sequence of symbols and\ndictionary phrases.\n\nIn this work we further consider the case of a free mixture of a dictio-\nnary compressor and a symbolwise compressor. Our Dictionary-Symbolwise\nFlexible Parsing covers also this case. We have indeed an optimal parsing\nalgorithm in the case of dictionary-symbolwise compression where the dic-\ntionary is prefix closed and the cost of encoding dictionary pointer is vari-\nable. The symbolwise compressor is one the classic variable-length codes\nthat works in linear time. Our algorithm works under the assumption that\na special graph that will be described in the following, is well defined. Even\nif this condition is not satisfied, it is possible to use the same method to ob-\ntain almost optimal parses. In detail, when the dictionary is LZ78-like, we\nshow how to implement our algorithm in linear time. When the dictionary\nis LZ77-like our algorithm can be implemented in time $O(n \\log n)$. Both\nhave $O(n)$ space complexity.\n\nEven if the main purpose of this work is of theoretical nature, some\nexperimental results will be introduced to underline some practical effects\nof the parsing optimality in terms of compression performance and to show\nhow to improve the compression ratio by building extensions Dictionary-\nSymbolwise of known algorithms. A specific appendix reports some more\ndetailed experiments.\nRésumé\n\nLes algorithmes de compression de données basés sur les dictionnaires incluent une stratégie de parsing pour transformer le texte d’entrée en une séquence de phrases du dictionnaire. Étant donné un texte, un tel processus n’est généralement pas unique et, pour comprimer, il est logique de trouver, parmi les parsing possibles, celui qui minimise le plus le taux de compression finale.\n\nC’est ce qu’on appelle le problème du parsing. Un parsing optimal est une stratégie de parsing ou un algorithme de parsing qui résout ce problème en tenant compte de toutes les contraintes d’un algorithme de compression ou d’une classe d’algorithmes de compression homogène.\n\nLes contraintes de l’algorithme de compression sont, par exemple, le dictionnaire lui-même, c’est-à-dire l’ensemble dynamique de phrases disponibles, et combien une phrase pèse sur le texte comprimé, c’est-à-dire quelle est la longueur du mot de code qui représente la phrase, appelée aussi le coût du codage d’un pointeur de dictionnaire.\n\nEn plus de 30 ans d’histoire de la compression de texte par dictionnaire, une grande quantité d’algorithmes, de variantes et d’extensions sont apparus. Cependant, alors qu’une telle approche de la compression du texte est devenue l’une des plus appréciées et utilisées dans presque tous les processus de stockage et de communication, seuls quelques algorithmes de parsing optimaux ont été présentés.\n\nBeaucoup d’algorithmes de compression manquent encore d’optimalité pour leur parsing, ou du moins de la preuve de l’optimalité. Cela se produit parce qu’il n’y a pas un modèle général pour le problème de parsing qui inclut tous les algorithmes par dictionnaire et parce que les parsing optimaux\nexistants travaillent sous des hypothèses trop restrictives.\n\nCe travail focalise sur le problème de parsing et présente à la fois un modèle général pour la compression des textes basée sur les dictionnaires appelé la théorie Dictionary-Symbolwise et un algorithme général de parsing qui a été prouvé être optimal sous certaines hypothèses réalistes. Cet algorithme est appelé Dictionary-Symbolwise Flexible Parsing et couvre pratiquement tous les cas des algorithmes de compression de texte basés sur dictionnaire ainsi que la grande classe de leurs variantes où le texte est décomposé en une séquence de symboles et de phrases du dictionnaire.\n\nDans ce travail, nous avons aussi considéré le cas d’un mélange libre d’un compresseur par dictionnaire et d’un compresseur symbolwise. Notre Dictionary-Symbolwise Flexible Parsing couvre également ce cas-ci. Nous avons bien un algorithme de parsing optimal dans le cas de compression Dictionary-Symbolwise où le dictionnaire est fermé par préfixe et le coût d’encodage des pointeurs du dictionnaire est variable. Le compresseur symbolwise est un compresseur symbolwise classique qui fonctionne en temps linéaire, comme le sont de nombreux codeurs communs à longueur variable.\n\nNotre algorithme fonctionne sous l’hypothèse qu’un graphe spécial, qui sera décrit par la suite, soit bien défini. Même si cette condition n’est pas remplie, il est possible d’utiliser la même méthode pour obtenir des parsing presque optimaux. Dans le détail, lorsque le dictionnaire est comme LZ78, nous montrons comment mettre en œuvre notre algorithme en temps linéaire. Lorsque le dictionnaire est comme LZ77 notre algorithme peut être mis en œuvre en temps $O(n \\log n)$ où $n$ est le longueur du texte. Dans les deux cas, la complexité en espace est $O(n)$. Même si l’objectif principal de ce travail est de nature théorique, des résultats expérimentaux seront présentés pour souligner certains effets pratiques de l’optimalité du parsing sur les performances de compression et quelques résultats expérimentaux plus détaillés sont mis dans une annexe appropriée.\nContents\n\nIntroduction 1\n\n1 Background 7\n 1.1 Self-Information and Entropy ......................... 7\n 1.2 Entropy Encoding .................................... 9\n 1.3 Encoding of Numbers and Commas ...................... 11\n 1.4 Dictionary Methods .................................. 11\n\n2 Dictionary-Symbolwise Text Compression 15\n 2.1 Dictionary Compression ............................... 15\n 2.2 Dictionary-Symbolwise Compression ................. 18\n 2.3 The Graph-Based Model .............................. 23\n 2.4 On Parsing Optimality ................................ 26\n 2.5 Dictionary-Symbolwise Can Be Better ............... 29\n\n3 About the Parsing Problem 37\n 3.1 The Optimal Parsing Problem ......................... 37\n 3.2 An Overview about Theory and Practice .......... 38\n 3.3 A Generalization of the Cohn’s Theorem ............ 40\n\n4 Dictionary-Symbolwise Flexible Parsing 47\n 4.1 The $c$-supermaximal Edges ......................... 48\n 4.2 The Subgraph $G'_{AT}$ .............................. 55\n 4.3 The Dictionary-Symbolwise Flexible Parsing ....... 58\n 4.4 Time and Space Analyses ........................... 61\n5 The Multilayer Suffix Tree\n5.1 Preliminary Definitions\n5.2 The Data Structure\n5.3 On the Query\n5.4 On Weighted-Exist and Weighted-Extend\n\n6 Conclusion\n\nA Experiments\n\nB Time Analysis of the Constant Case\nIntroduction\n\nData compression concerns with transformations through a more concise data representation. When such transformation is perfectly invertible we have a lossless data compression, otherwise, a lossy compression. Since data preservation is usually required for textual data, lossless data compression is often called text compression. On the opposite, usually working on visual data, such as the images or video, on sound data and on data from many other domains, a certain degree of approximation is allowed to the compression-decompression process in favour of a stronger compression, i.e. a smaller compression ratio.\n\nRoughly speaking, compression ratios greater than a certain threshold given by the percentage of information contained in the data, are reachable by text compression techniques as they strip just redundancy in the text. Stronger compressions imply data approximation because part of their information is lost along the compression process. The quantity of information in a certain data or, more precisely, the average information inside the data provided by a source, is called entropy. The entropy ratio is then a limit for text compression, i.e. it is a lower bound for the compression ratio.\n\nEntropy, data complexity and data compression are therefore hidden all together. Indeed, fundamental and seminal methods for dictionary-based compression, such as the Lempel’ and Ziv’s methods, were firstly introduced as text complexity measures.\n\nLempel’ and Ziv’s methods are still the basis of almost all the recent dictionary compression algorithms. More in detail, they are the LZ77 and the LZ78 compression methods, i.e. the Lempel and Ziv compression methods presented in 1977 and 1978 years. They are the first relevant dictionary\nmethods that use dynamic dictionaries. Static dictionary compression was already known as it is a side effect of the code and the transducer theories. Static dictionary compression was the topic of many works around ’70, as the text substitution methods in Schuegraf’ and Heaps’s work (1974) or in the Wagner’s work (1973).\n\nDictionary-based compression include, more or less explicitly, a parsing strategy that transforms the input text into a sequence of dictionary phrases. Since that usually the parsing of a text is not unique, for compression purpose it makes sense to find one of the possible parsing that minimizes the final compression ratio. This is the parsing problem.\n\nIn the foundational methods (such as the work of Lempel and Ziv), the parsing problem was not immediately clear as it was confused with the dictionary building strategy. The overall compression algorithms have strictly imposed the parsing of the text. As soon as many variants of such methods appeared along the sequent years, like the Storer’ and Szymanski’s variant (1982) or the Welch’s variant (1984), the maintenance of the dynamic dictionary was clearly divided from the text parsing strategy and, in the meantime, the importance of coupling a kind of compression on the symbols different from the compression for the dictionary phrases taken place. This last feature was initially undervalued in the theoretical model of the compression processes.\n\nOne of the first parsing problem models is due to Schuegraf et al. (see [33]). They associated a graph with as many nodes as the characters that form the text and one edge for each dictionary phrase. In this model, the optimal parsing is obtained by using shortest path algorithms on the associated graph. But this approach was not recommended for practical purpose as it was considered too time consuming. Indeed, the graph can have quadratic size with respect to the text length.\n\nA classic formalization of a general dictionary compression algorithm was proposed by Bell et al. in the late 1990, focusing on just three points: the dictionary definition, the dictionary phrases encoding method and the parsing strategy. This model does not acquire all the richness of many advanced dictionary-based compression algorithms as it does not take account of the symbolwise compression.\nRecently, in chronological order, [12], [25], [8] and [9] revised both a more general dictionary compression algorithms definition and the graph-based model for the parsing problem and they also introduced a new optimal parsing algorithm. A similar result for the LZ77-like dictionary case, were independently presented in [17], where the symbolwise feature is still not considered.\n\nThe study of free mixtures of two compressors is quite involved and it represents a new theoretical challenge. Free mixture has been implicitly or explicitly used for a long time in many fast and effective compressors such as the gzip compression utility (see [30, Sect. 3.23]), the PkZip Archiving Tool (see [30, Sect. 3.23]), the Rolz Compressor\\(^1\\), and the MsZip cabinet archiving software (see [30, Sect. 3.7]), also known as CabArc. In order to glance at compression performances see the web page of Mahoney’s challenge\\(^2\\) about large text compression. In detail, there are two famous compression methods that can work together: the dictionary encoding and the statistical encoding, which are also called parsing (or macro) encoding and symbolwise encoding, respectively. The fact that these methods can work together is commonly accepted in practice even if the first theory of Dictionary-Symbolwise methods started in [12].\n\nThis work focus on the parsing problem and introduce a twofold result; a general model for dictionary-based text compression called Dictionary-Symbolwise theory and a general parsing algorithm that is proved to be optimal under some realistic hypothesis. The Dictionary-Symbolwise model extend both the Bell dictionary compression formalization and the Schuegraf parsing model based on graphs to fit better to the wide class of common compression algorithms.\n\nThe parsing algorithm we present is called Dictionary-Symbolwise Flexible Parsing and it covers almost all the cases of the dictionary-based text compression algorithms together with the large class of their variants where\n\n\n\\(^2\\)Matt Mahoney’s Large Text Compression Benchmark is a competition between lossless data compression programs. See the web page: http://mattmahoney.net/dc/text.html. Last verified on March 2012.\nthe text is parsed as a sequence of symbols and dictionary phrases. It exploits the prefix closed property of common dictionaries, i.e. both the LZ77 and LZ78-like dictionaries. It works for dynamic dictionaries and variable costs of dictionary phrases and symbols. His main part concerns with the construction of a smallest subgraph that guarantees parsing optimality preservation, and then a shortest path is found by using a classic single source shortest path approach.\n\nThe symbolwise encoding can be any classical one that works in linear time, as many common variable-length encoders do. Our algorithm works under the assumption that a special graph that will be described in the following is well defined. Even if this condition is not satisfied it is possible to use the same method to obtain almost optimal parses. In detail, when the dictionary is LZ78-like, we show that our algorithm has $O(n)$ complexity, where $n$ is the size of the text. When the dictionary is LZ77-like our algorithm can be implemented in time $O(n \\log n)$. Both above solutions have $O(n)$ space complexity.\n\nThis thesis is organized as follows. Chapter 1 is devoted to background notions for data compression. Chapter 2 defines and explores the dictionary-symbolwise model for dictionary compression as well as the graph-based model for the parsing problem. Chapter 3 is an overview about historic parsing solutions and contains the generalization to the dynamic case of the classic Cohn's theorem on greedy parsing optimality for suffix-closed dictionaries. Chapter 4 concerns with the new optimal parsing algorithm called dictionary-symbolwise flexible parsing. Chapter 5 presents a new indexing data structure that solves efficiently the rightmost position query of a pattern over a text. This problem is involved in the graph building process for LZ77-like algorithms, where edge labels, i.e. dictionary pointers costs, are not uniquely determined. Chapter 6 contains the conclusions of this thesis and some open problem.\n\nEven if the main aim of this work is theoretical, some experimental results are introduced in the Appendix A to underline some practical effects of the parsing optimality in compression performance. We have experimental evidence that many of the most relevant LZ77-like commercial compressors\nuse an optimal parsing. Therefore this thesis contains both a good model for many of the commercial dictionary compression algorithms and a general parsing algorithm with proof of optimality. This fills the gap between theory and best practice about text compression.\nChapter 1\n\nBackground\n\nThis chapter concerns with some well known concepts from the field of the Information Theory, that are fundamental to deal with data compression. Information Theory literature is quite large by now. We remand to [30], [31] and [32] books for a comprehensive look on background notions and standard techniques of data compression. We report here just few pre-requisites to make readers comfortable with notation and concepts we will use in the rest of this thesis.\n\n1.1 Self-Information and Entropy\n\nA foundational concept for Information Theory is the Shannon’s self-information definition. It is a quantitative measure of information. Let $A$ be a probabilistic event, i.e. $A$ is the set of outcomes of some random experiment. If $P(A)$ is the probability that the event $A$ will occur, then the self-information associated with $A$ is given by: $i(A) = -\\log_2 P(A)$ bits.\n\nIf we have a set of independent events $A_i$, which are sets of outcomes of some experiment $S$, which sample space is $S = \\bigcup A_i$, then the average self-information associated with the random experiment $S$ is given by $H(S) = \\sum P(A_i) i(A_i) = -\\sum P(A_i) \\log_2 P(A_i)$ bits. This quantity is called the entropy associated with the experiment.\n\nNow, if the experiment is a source $S$ that emits a string $S$ of symbols over the alphabet $\\Sigma = \\{1, \\ldots, m\\}$, i.e. $S = s_1s_2s_3 \\cdots$ with $s_i \\in \\Sigma$, then the\nsample space is the set of all the strings the source can produce, i.e. the set of all the possible sequences of alphabet symbols of any length. The entropy of the source \\( S \\) is given by\n\n\\[\nH(S) = \\lim_{n \\to \\infty} \\frac{1}{n} G_n\n\\]\n\nwith\n\n\\[\nG_n = - \\sum_{i_1=1}^{m} \\cdots \\sum_{i_n=1}^{m} P(s_1 = i_1, \\ldots, s_n = i_n) \\log P(s_1 = i_1, \\ldots, s_n = i_n).\n\\]\n\nIf each symbol in the string is independent and identically distributed (\\( iid \\)), then we have that\n\n\\[\nG_n = -n \\sum_{i=1}^{m} P(i) \\log P(i) \\quad \\text{and} \\quad H(S) = - \\sum_{i=1}^{m} P(i) \\log P(i).\n\\]\n\nWhen the symbol probabilities are not independent from each other, the distribution follow an intrinsic model of probability of the source. In this case, the above two entropy equations are not equal and we distinguish them calling the latter first order entropy.\n\nThe probability distribution over the symbols of a source is not usually \\( a \\ priori \\) known and the best we can do is to infer the distribution looking inside some sample strings. Obviously, the underlay assumption is that the source is an ergodic source, i.e. its output at any time has the same statistical properties.\n\nThe Markov process is the common way to model the source distribution when symbols are not independent each other. In this case we have that each new outcome depends on all the previous one. A discrete time Markov chain is a special type of Markov model for those experiments where each observation depends on just the \\( k \\) previous one, i.e.\n\n\\[\nP(s_n|s_{n-1}, s_{n-2}, \\ldots) = P(s_n|s_{n-1}, s_{n-2}, \\ldots, s_{n-k})\n\\]\n\nwhere the set \\( \\{s_{n-1}, s_{n-2}, \\ldots, s_{n-k}\\} \\) is the state of the \\( k \\)-order Markov process. The entropy of a Markov process is defined as the average value of the entropy at each state, i.e.\n\n\\[\nH(M_k) = - \\sum_{s_{n-k}} P(s_{n-k}) \\sum_{s_{n-k+1}} P(s_{n-k+1}|s_{n-k}) \\sum_{s_{n-k+2}} P(s_{n-k+2}|s_{n-k+1}, s_{n-k}) \\cdots\n\\]\n\\[\n\\cdots \\sum_{s_{n-1}} P(s_{n-1}|s_{n-2}, \\ldots, s_{n-k}) \\sum_{s_n} P(s_n|s_{n-1}, \\ldots, s_{n-k}) \\log P(s_n|s_{n-1}, \\ldots, s_{n-k})\n\\]\n\nwhere \\( s_i \\in \\Sigma \\). In the data compression field is common to refer to the state \\( \\{s_{n-1}, \\ldots, s_{n-k}\\} \\) of previous symbols by using the string \\( s_{n-k} \\ldots s_{n-1} \\) called the context of length \\( k \\) of \\( s_n \\).\n\n**Empirical Entropy**\n\nThe \\( k \\)-order empirical entropy (see [16]) is the measure of information of a text \\( T \\) based on the number of repetitions in \\( T \\) of any substring \\( w \\) of length \\( k \\). Let be\n\n\\[\nH_k(T) = -\\frac{1}{n} \\sum_{w \\in \\Sigma^k} n_w \\left[ \\sum_{\\sigma \\in \\Sigma} \\frac{n_w\\sigma}{n_w} \\log \\left( \\frac{n_w\\sigma}{n_w} \\right) \\right]\n\\]\n\nwhere \\( n = |T| \\), \\( \\Sigma \\) is the alphabet, \\( w \\in \\Sigma^k \\) is a string over \\( \\Sigma \\) of length \\( k \\), \\( w\\sigma \\) is the string \\( w \\) followed by the symbol \\( \\sigma \\) and \\( n_w \\) is the number of occurrences of \\( w \\) in \\( T \\).\n\nThis quantity does not refer to a source or to a probabilistic model, but it only depends from the text \\( T \\). The empirical entropy is used to measure the performance of compression algorithms as a function of the string structure, without any assumption on the input source.\n\n**1.2 Entropy Encoding**\n\nEntropy encoding, statistical codes or symbolwise codes, as they are also called, are those compression methods that use the expectation value to reduce the symbol representation. There are static model as well as adaptive or dynamic models. They are usually coupled with a probabilistic model that is in charge of providing symbol probability to the encoder. Common models use symbol frequencies or the symbol context to predict the next symbol.\n\nThe most simple statistical encoder is the 0-order arithmetic encoding. It considers all the symbols as if they are independent each other. The adaptive version use to estimate symbol probability with the frequency of occurrence of any symbol in the already seen text.\nHuffman code keeps count of the symbol frequencies while reads the input text or by preprocessing it, and then assigns shorter codewords of a prefix-free code to the most occurring symbols accordingly with the Huffman tree. Notice that the notation $k$-order used in this thesis refers to models where $k$ is the length of the context, i.e. a 0-order model is a model where the symbol probabilities just depend on the symbol itself.\n\n**Arithmetic coding**\n\nThe basic idea of arithmetic coding is to represent the entire input with an interval of real numbers between 0 and 1. The initial interval is $[0, 1)$ and then it is divided in slots accordingly to the symbol probability. Once that a symbol is encoded, the corresponding slot of the interval is divided again accordingly with the adapted symbol distribution. While the active slots becomes finer and finer, its internal points bit representation grows. As soon as the extremal points of the slot have an equal upper part in their bit representation, these bits are outputted and the slot is scaled to be maintained under the finite precision of the representation of real values inside the machine. As any point of a slot represents an infinite set of infinite strings, all having the same prefix, one of them is chosen when the input string terminate to be outputted. The termination ambiguity is usually handled by using a special terminal symbol or by explicitly giving the text length at the beginning.\n\nThe output length of arithmetic codes can be accurately estimated by using the Markov process entropy or the empirical entropy. Moreover, it is proved that their compression ratio converges in probability to the entropy of any i.i.d. source. A similar result can be stated in the case of Markov chains. In practice, when the source is unknown, better results are obtained when higher order models are used, because the models get “closer” to the real source. On the other side, higher order models need more time and space to be handled.\n1.3 Encoding of Numbers and Commas\n\nEncoding is a fundamental stage of many compression algorithms which consists of uniquely representing a sequence of integers as a binary sequence. In the most simple case the encoder makes use of a code, that is a mapping of the positive integers onto binary strings (codewords), in order to replace each value in input with its corresponding codeword. Codewords can be of variable-lengths as long as the resulting code is uniquely decodable, e.g. the prefix-free codes. Prefix-free property requires that no codeword can be equal to a prefix of another codeword. Several codes have been proposed that achieve small average codeword-length whenever the frequencies of the input integers are monotonically distributed, such that smaller values occur more frequently than larger values.\n\nThe unary encoding of an integer \\( n \\) is simply a sequence of \\( n \\) 1s followed by a 0. Unary encoding is rarely used as stand-alone tool and it is often component of more complex codes. It achieves optimality when integer frequencies decrease exponentially as \\( p(i + 1) \\leq p(i)/2 \\).\n\nThe Elias codes is a family of codes where codewords have two parts. The first one is devoted to states the codeword length and the second one is the standard binary representation of the integer, without the most significant bit. The first Elias encoder is the well-known \\( \\gamma \\)-code, which stores the prefix-part in unary. Elias \\( \\delta \\)-code differs from \\( \\gamma \\)-code because it encodes also first-part of the codewords with a \\( \\gamma \\)-code, rather than using the unary code. This is an \\textit{asymptotically optimal} code as the ratio between the codeword length and the binary representation length asymptotically tends to 1. The Elias \\( \\omega \\)-code can be seen as the iteration of as many \\( \\delta \\)-code nested encodings until a length of two or three bits is reached.\n\n1.4 Dictionary Methods\n\nDictionary compression methods are based on the substitution of phrases in the text with references to dictionary entries. A dictionary is an ordered collection of phrases, and a reference to a dictionary phrase is usually called dictionary pointer. The idea is that if the encoder and the decoder share\nthe same dictionary and, for most of the dictionary phrases, the size of the\nrepresentation in output of a dictionary pointer is less than the size of the\nphrase itself, then a shorter representation of the input text is obtained\nreplacing phrases with pointers. In order to proceed to the phrase substitu-\ntion, the text has to be divided into a sequence of dictionary phrases. Such\ndecomposition is called parsing and is not usually unique. For compression\npurpose it makes sense to find one of the possible parsing that minimizes\nthe final compression ratio. This is the parsing problem.\n\nThe foundational methods in dictionary compression class are Lempel’\nand Ziv’s LZ77 and LZ78 algorithms that will be extensively considered\nalong this thesis. Lempel’ and Ziv’s methods are the basis of almost all the\ndictionary compression algorithms. They are the first relevant dictionary\nmethods that use dynamic dictionaries.\n\nThe LZ77 method consider the already seen text as the dictionary, i.e.\nit uses a dynamic dictionary that is the set of all the substrings of the text\nup to the current position. Dictionary pointers refer to occurrences of the\npointed phrase in the text by using the couple \\((length, offset)\\), where the\noffset stand for the backward offset w.r.t. the current position. Since a\nphrase is usually repeated more than once along the text and since pointers\nwith smaller offset are usually smaller, the occurrence close to the current\nposition is preferred. Notice that this dictionary is both prefix and suffix\nclosed. The parsing strategy use the greedy approach to find the longest\nphrase in the dictionary equal to a prefix of the rest of the text.\n\nThe LZ78 dictionary is a subset of the LZ77 one. It is prefix-closed but\nit is not suffix-closed. Each dictionary phrases is equal to another dictionary\nphrase with a symbol appended at the end. Exploiting this property, dictio-\nnary is implemented as an ordered collection of couples \\((dictionary pointer,\nsymbol)\\), where the dictionary pointer refers to a previous dictionary phrase\nor to the empty string. As long as the input text is analyzed, the longest\nmatch between the dictionary and the text is selected to form a new dic-\ntionary phrase. Indeed, a new couple is formed by this selected dictionary\nphrase and the symbol in the text that follows the occurrence of this phrase.\nThis new dictionary phrase is added to the dynamic dictionary and it is\nchosen also to be part of the parsing of the text accordingly with the greedy\nMore detail about these method will be reported in next chapters.\nChapter 2\n\nDictionary-Symbolwise Text Compression\n\nMany dictionary-based compression algorithms and their practical variants use to parse the text as a sequence of both dictionary phrases and symbols. Different encoding are used for those two kinds of parse segments. Indeed, many variants of the classic Lempel and Ziv algorithms allow to parse the text as a free mixture of dictionary phrases and symbols. This twofold nature of the parsing segments was not caught in classic formulation of the dictionary-based compression theory. In this chapter we recall the classical dictionary compression algorithm formulation and the classic model of the parsing problem before presenting the more general framework for Dictionary-Symbolwise compression that better fits to almost all the dictionary-based algorithms.\n\n2.1 Dictionary Compression\n\nIn [4] it is possible to find a survey on Dictionary and Symbolwise methods and a description of the deep relationship among them (see also [3, 11, 30, 31]).\n\nDefinition 2.1. A dictionary compression algorithm, as noticed in [4], can be fully described by:\n\n1. The dictionary description, i.e. a static collection of phrases or a\ncomplete algorithmic description on how the dynamic dictionary is built and updated.\n\n2. The encoding of dictionary pointers in the compressed data.\n\n3. The parsing method, i.e. the algorithm that splits the uncompressed data in dictionary phrases.\n\nWe notice that any of the above three points can depend on each other, i.e. they can be mutually interdependent.\n\nAs the reader can notice, above three points are general enough to describe both static and dynamic dictionary and both static and variable costs for the dictionary phrase representation in the output data. We want now to focus on its third point where the parsing is defined as just a sequence of dictionary pointers. The drawback of this constraint is to lead to an overuse of formalism as it is not easy to describe the role played by symbols. Let us show this effect by examples. The characterization of the classic LZ77 and LZ78 algorithms according to the above Definition 2.1 are stated in what follows.\n\n**LZ77 characterization**\n\nGiven an input text $T \\in \\Sigma^*$, it is processed left to right. At time $i$, $D_i$ is the current state of the dictionary and $T_i = T[1:i]$ is the prefix of $T$ of length $i$ that has been already parsed. $T[i-P:i]$ is called the search buffer and $T[i+1:i+Q]$ is called the look-ahead buffer, where $P$ is the maximum offset for text factors, $Q$ is the maximum length for dictionary phrases.\n\n1. Let be $D_i = \\{wa, \\text{such that } w \\in \\text{Fact}(T[i-P:i]), \\quad a \\in \\Sigma \\text{ and } |wa| \\leq Q\\}$, where $\\text{Fact}(x)$ is the set of all the factors (or substrings) of the text $x$. Let us notice that this dictionary is essentially composed by the factors having length less than or equal to $Q$ that appear inside a sliding window of size $P$ ending at position $i$ over the text.\n\n2. The dictionary phrase $wa = T[i-p : i-p+q]a$ is represented by the vector $(p, q, a)$ where $p$ is the backward offset in the search buffer of an occurrence of $w$ and $q = |w|$. The vector $(p, q, a)$ is coded by using\nthree fixed length sequences of bits where $p$ has length $\\log_2(P)$, $q$ has length $\\log_2(Q)$ and $a$ is represented with 8 bits by using the ascii code for symbols.\n\n3. An online greedy parsing is used. At time $i$, $i$ is the position in the text at which the parsing ends up. At this point, the longest match between a dictionary phrase $wa \\in D_i$ and a prefix of the look-ahead buffer $T[i + 1 : i + Q]$ is added to the parsing. The new parsing covers now the text up to the position $i + |wa|$. The next parsing phrase will be chosen at position $i + |wa|$. For instance if the parsing of the text up to the position $i$ is the sequence of phrases $w_1a_1w_2a_2\\ldots w_ja_j$, then the parsing up to the position $i + |wa|$ is $w_1a_1w_2a_2\\ldots w_ja_jw_{j+1}a_{j+1}$, with $w_{j+1}a_{j+1} = wa$.\n\n**LZ78 characterization**\n\nLet us suppose that we have a text $T \\in \\Sigma^*$ and that we are processing it left to right. We also suppose that at time $i$ the text up to the $i$th character has been encoded. The algorithm maintains a dynamic table $M_i$ of phrases, initialized with the empty word $M_0 = [\\varepsilon]$.\n\n1. The dictionary $D_i$ is defined as $D_i = \\{wa \\text{ such that } w \\in M_i \\text{ and } a \\in \\Sigma\\}$. At time $i$, the longest dictionary phrase $wa \\in D_i$ that matches with the text at position $i$ is chosen to be part of the set $M_{i+|wa|}$, while $M_i = M_j$ with $i \\leq j < i + |wa|$. Then, $wa$ is added at the first empty row of $M_i$ that becomes $M_{i+|wa|} = M_i \\cup wa$. Consequently, $D_{i+|wa|} = D_i \\cup wa\\Sigma$ and $D_i = D_j$ with $i \\leq j < i + |wa|$. $D_i$ is prefix closed at any time by construction. Many practical implementations use a bounded size dictionary by keeping fixed the dictionary once it gets full or by using a prune strategy that preserves the prefix-closed property.\n\n2. The dictionary phrase $wa \\in D_i$ is represented by the couple $(x, a)$ where $x$ is the index of $w$ over $M_i$. The couple $(x, a)$ is encoded by using a fixed length encodings for the integer $x$ followed by the ascii value of $a$. \n\n17\n3. The parsing is the greedy parsing. It is the sequence of the longest matches between the dictionary and a prefix of the uncompressed part of the text. The parsing phrases are equal to the dictionary phrases $wa$ used as support for dictionary extension. For instance if the parsing of the text up to the position $i$ is the sequence of dictionary phrases $w_1a_1 w_2a_2 \\ldots w_pa_p = T[1 : i]$, then the parsing up to the position $i + |wa|$ is $w_1a_1 w_2a_2 \\ldots w_pa_p$ with $wa \\in D_i$.\n\n2.2 Dictionary-Symbolwise Compression\n\nWe propose a new definition for the class of dictionary-based compression algorithms that takes account of the presence of single characters beside to dictionary phrases. For this reason we chose to name them dictionary-symbolwise algorithms. The following definition is an extension of the above Definition 2.1 due to Bell et al. (see [4]) and it refines what was presented in [8, 12, 25].\n\n**Definition 2.2.** A dictionary-symbolwise compression algorithm is specified by:\n\n1. The dictionary description.\n2. The encoding of dictionary pointers.\n3. The symbolwise encoding method.\n4. The encoding of the flag information.\n5. The parsing method.\n\nA *dictionary-symbolwise* algorithm is a compression algorithm that uses both dictionary and symbolwise compression methods. Such compressors may parse the text as a free mixture of dictionary phrases and literal characters, which are substituted by the corresponding pointers or literal codes, respectively. Therefore, the description of a dictionary-symbolwise algorithm also includes the so called *flag information*, that is the technique used to distinguish the actual compression method (dictionary or symbolwise) used for each phrase or factor of the parsed text. Often, as in the case of\nLZSS (see [36]), an extra bit is added either to each pointer or encoded character to distinguish between them. Encoded information flag can require less space than one bit according to the encoding used.\n\nFor instance, a dictionary-symbolwise compression algorithm with a fixed dictionary $D = \\{ab, cbb, ca, bcb, abc\\}$ and the static symbolwise codeword assignment $[a = 1, b = 2, c = 3]$ could compress the text $abccacbabcacbcb$ as $Fd_1Fs_3Fd_3Fs_2Fd_1Fd_4Fd_2$, where $Fd$ is the flag information for dictionary pointers and $Fs$ is the flag information for the symbolwise code.\n\nMore formally, a parsing of a text $T$ in a dictionary-symbolwise algorithm is a pair $(\\text{parse}, Fl)$ where $\\text{parse}$ is a sequence $(u_1, \\cdots, u_s)$ of words such that $T = u_1 \\cdots u_s$ and where $Fl$ is a boolean function that, for $i = 1, \\ldots, s$ indicates whether the word $u_i$ has to be encoded as a dictionary pointer or as a symbol. See Table 2.1 for an example of dictionary-symbolwise compression.\n\n**LZ77 characterization**\n\nGiven a text $T \\in \\Sigma^*$ and processing it left to right, at time $i$ the text up to the $i$th character has been read.\n\n1. Let be $D_i = \\{w, \\text{ such that } w \\in \\text{Fact}(T[i - P : i]) \\text{ and } |w| < Q\\}$, where $P$ is the maximum offset for text factors, $Q$ is the maximum length for dictionary phrases. Let $T[i - P : i]$ be called the search buffer and $T[i + 1 : i + Q]$ be called the look-ahead buffer.\n\n2. The dictionary phrase $w = T[i - p : i - p + q]$ is represented by the vector $(p, q)$ where $p$ is the backward offset in the search buffer at\n\n<table>\n<thead>\n<tr>\n<th>Input</th>\n<th>ab</th>\n<th>c</th>\n<th>ca</th>\n<th>cbb</th>\n<th>ab</th>\n<th>bcb</th>\n<th>cbb</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Output</td>\n<td>$Fd_1$</td>\n<td>$Fs_3$</td>\n<td>$Fd_3$</td>\n<td>$Fd_2$</td>\n<td>$Fd_1$</td>\n<td>$Fd_4$</td>\n<td>$Fd_2$</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.1: Example of compression for the text $abccacbabcacbcb$ by a simple Dictionary-Symbolwise algorithm that use $D = \\{ab, cbb, ca, bcb, abc\\}$ as a static dictionary, the identity as a dictionary encoding and the mapping $[a = 1, b = 2, c = 3]$ as a symbolwise encoding.\nwhich the phrase \\( w \\) appears. The vector \\((p, q)\\), also called dictionary pointer, is coded by using two fixed length sequences of bits, where \\( p \\) has length \\( \\log_2(P) \\) and \\( q \\) has length \\( \\log_2(Q) \\).\n\n3. Any symbol \\( a \\in \\Sigma \\) is represented with 8 bits by using the ascii code for symbols.\n\n4. The flag information is not explicitly encoded because it is completely predictable. Indeed, after a dictionary pointer there is a symbol and after a symbol there is a dictionary pointer.\n\n5. The parsing impose a strictly alternation between dictionary pointers and symbols. At any time \\( i \\), if \\( i \\) is the position in the text at which the already chosen parsing ends up, then the match between the longest prefix of the look-ahead buffer \\( T[i+1:i+Q] \\) and a dictionary phrase \\( w \\in D_i \\) is chosen to be outputted followed by the mismatch symbol. For instance, if \\( w \\) is the longest match between the dictionary and the look-ahead buffer, with \\( w \\) represented by the couple \\((p, q)\\), then \\( F_d p q F_s T_{i+|w|} \\) are concatenated to the parsing. Otherwise, the already chosen parsing overpass position \\( i \\) in the text and nothing has to be added to the current parsing.\n\nThis new formalization allows to describe dictionary algorithms in a more natural way. Moreover, it allows to easily describe those variants where just a single point of the algorithm is different. For instance, let us focus on LZSS, the LZ77-based algorithm due to Storer and Szymanski of the '82 (see [36]). The main idea of this algorithm is to relax the parsing constrain of LZ77 about dictionary pointers and symbols alternation, allowing to use dictionary pointers every time that it is possible and to use symbols just when it is needed.\n\n**LZSS characterization**\n\nGiven a text \\( T \\in \\Sigma^* \\) and processing it left to right, at time \\( i \\) the text up to the \\( i \\)th character has been read.\n1. Let be \\( D_i = \\{ w, \\text{ such that } w \\in \\text{Fact}(T[i - P : i]) \\text{ and } |w| < Q \\} \\), where \\( P \\) is the maximum offset for text factors, \\( Q \\) is the maximum length for dictionary phrases. Let \\( T[i - P : i] \\) be called the search buffer and \\( T[i + 1 : i + Q] \\) be called the look-ahead buffer.\n\n2. The dictionary phrase \\( w = T[i - p : i - p + q] \\) is represented by the vector \\( (p, q) \\) where \\( p \\) is the backward offset in the search buffer at which the phrase \\( w \\) appears. The vector \\( (p, q) \\), also called dictionary pointer, is coded by using two fixed length sequences of bits, where \\( p \\) has length \\( \\log_2(P) \\) and \\( q \\) has length \\( \\log_2(Q) \\).\n\n3. Any symbol \\( a \\in \\Sigma \\) is represented with 8 bits by using the ascii code for symbols.\n\n4. The flag information is explicitly encoded by using 1 bit with conventional meaning. For instance, \\( F_d = 0 \\) and \\( F_s = 1 \\).\n\n5. At any time \\( i \\), if \\( i \\) is the position in the text at which the already chosen parsing ends up, the match between the longest prefix of the look-ahead buffer \\( T[i + 1 : i + Q] \\) and a dictionary phrase \\( w \\in D_i \\) is chosen to be outputted. For instance, if \\( w \\) is the longest match between the dictionary and the look-ahead buffer, with \\( w \\) represented by the couple \\( (p, q) \\), then \\( \\{F_d \\ p \\ q \\} \\) are concatenated to the parsing. If there is no match between dictionary and look-ahead buffer, then a single symbol is emitted, i.e. \\( F_s \\ T[i + 1] \\). Otherwise, the above chosen parsing overpass position \\( i \\) in the text and nothing has to be added to the current parsing.\n\n**Dictionary-Symbolwise Scheme**\n\nLet now focus on the parsing point. For any dictionary compression algorithm we can build a class of variants taking fixed the first four points and changing the parsing strategy or, if it is needed, arranging a bit the first four points to allow using a different parsing. Usually the variants of the same class maintain decoder compatibility, i.e. their outputs can be decoded by the same decoding algorithm. Algorithms of the same class can\nbe compared looking for the best parsing, i.e. the parsing that minimizes compression ratio. We call scheme such class of algorithms.\n\n**Definition 2.3.** Let a dictionary-symbolwise scheme be a nonempty set of dictionary-symbolwise algorithms having in common the same first four specifics, i.e. they differ from each other by the parsing methods only.\n\nA scheme does not need to contain all the algorithms having the same first four specifics. Let us notice that any of the above points from 1 to 5 can depend on all the others, i.e. they can be mutually interdependent. The word scheme has been used by other authors with other meaning, e.g. scheme is sometimes used as synonymous of algorithm or method. In this thesis, scheme always refers to the above Definition 2.3.\n\n**Remark 2.1.** For any dictionary-symbolwise scheme $S$ and for any parsing method $P$, a dictionary-symbolwise compression algorithm $A_{S,P}$ is completely described by the first four specifics of any of the algorithms belonging to $S$ together with the description of the parsing method $P$.\n\nLet us here briefly analyze some LZ-like compression algorithms. The LZ78 algorithm is, following the above definitions, a dictionary-symbolwise algorithm. It is easy to naturally arrange its original description to a dictionary-symbolwise complaint definition. Indeed, its dictionary building description, its dictionary pointer encoding, its symbolwise encoding, its parsing strategy and the null encoding of the flag information are, all together, a complete dictionary-symbolwise algorithm definition. The flag information in this case is not necessary, because there is not ambiguity about the nature of the encoding to use for any of the parse segments of the text as the parsing strategy imposes a rigid alternation between dictionary pointers and symbols. Similar arguments apply for LZ77. Later on we refer to these or similar dictionary-symbolwise algorithms that have null flag information as “pure” dictionary algorithms and to scheme having only “pure” dictionary algorithms in it as “pure” scheme.\n\nLZW (see [30, Section 3.12]) naturally fits Definition 2.1 of dictionary algorithms and, conversely, LZSS naturally fits Definition 2.2 on dictionary-symbolwise algorithms as well as the LZMA algorithm (see [30, Section 3.24]).\nLet us notice that sometimes the flag information may be implicitly represented. For instance, in the \\textit{deflate} compression method, characters and part of the dictionary pointers (i.e. the length part of the couples (length,distance) that represent the dictionary pointers) are firstly mapped into a single codeword space (together with few control characters), and then encoded via Huffman code belonging to just a single Huffman tree. This mapping hides the flag information that has to be considered implicitly represented, but still existing. It is easy to show how in this case the flag information is involved in the compression process. Indeed the frequency of any character related code is equal to the frequency of the character on the character space, times the frequency of the flag information for the character encoding. The same argument applies to the length-codeword frequencies. In this way, the compressed stream is a sequence of character codewords and dictionary pointer codewords bringing implicitly the flag informations.\n\n2.3 The Graph-Based Model\n\nExtending the approach introduced for static dictionaries in [33] to the dynamic dictionary case, similarly to what it is already done in [12, 25, 8, 9], we show how to associate a directed weighted graph \\(G_{D,T} = (V,E,L)\\) with any dictionary compression algorithm \\(A\\), any text \\(T = a_1a_2a_3\\cdots a_n\\) and any cost function \\(C : E \\to \\mathbb{R}^+\\) in the following way.\n\nThe set of vertices is \\(V = \\{0, 1, \\ldots, n\\}\\), where vertex \\(i\\) corresponds to \\(a_i\\), i.e. the \\(i\\)-th character in the text \\(T\\), for \\(1 \\leq i \\leq n\\) and vertex 0 corresponds to the position at the beginning of the text, before any characters. The\nempty word $\\varepsilon$ is associated with vertex 0, that is also called the origin of the graph. The set of directed edges is\n\n$$E = \\{(p, q) \\in (V \\times V) \\mid p < q \\text{ and } \\exists w_{p,q} = T[p+1 : q] \\in D_p\\}$$\n\nwhere $T[p+1 : q] = a_{p+1}a_{p+2} \\cdots a_q$ and $D_p$ is the dictionary relative to the $p$-th processing step, i.e. the step in which the algorithm either has processed the input text up to character $a_p$, for $p > 0$, or it has begun, for $p = 0$. For each edge $(p, q)$ in $E$, we say that $(p, q)$ is associated with the dictionary phrase $w_{p,q} = T[p+1 : q] \\in D_p$. In the case of a static dictionary, $D_i$ is constant along all the algorithm steps, i.e. $D_i = D_j, \\forall i, j = 0 \\cdots n$.\n\nLet $L$ be the set of edge labels $L_{p,q}$ for every edge $(p, q) \\in E$, where $L_{p,q}$ is defined as the cost (weight) of the edge $(p, q)$ when the dictionary $D_p$ is in use, i.e. $L_{p,q} = C((p, q))$.\n\nLet us consider for instance the case where the cost function $C$ associates the length in bit of the encoded dictionary pointer of the dictionary phrase $w_{p,q}$ to the edge $(p, q)$, i.e. $C((p, q)) = \\text{length(encode(pointer(w_{p,q}))})$, with $w_{p,q} \\in D_p$. In this case the weight of a path $P$ from the origin to the node $n = |T|$ on the graph $G_{A,T}$ corresponds to the size of the output obtained by using the parsing induced by $P$. The path of minimal weight on such graph corresponds to the parsing that achieves the best compression. The relation between path and parsing will be investigated in Section 2.4.\n\nIf the cost function is a total function, then $L_{p,q}$ is defined for each edge of the graph.\n\n**Definition 2.4.** Let us say that $G_{A,T}$ is well defined iff $L_{p,q}$ is defined for each edge $(p, q)$ of the graph $G_{A,T}$.\n\nFor instance, the use of common variable-length codes for dictionary pointers, as Elias or Fibonacci codes or a static Huffman code, leads to a well defined graph. Sometimes the cost function is a partial function, i.e. $L_{p,q}$ is not defined for some $p$ and $q$, and $G_{A,T}$ in such cases is not well defined. For instance, encoding the dictionary pointers via statistical codes, like a Huffman code or an arithmetic code, leads to partial cost functions. Indeed the encoding of pointers and, accordingly, the length of the encoded dictionary pointers may depend on how many times a code is used. For\ninstance, when a dynamic code like the online adaptive Huffman code is used, the codeword lengths depend on how frequently the codewords have been used in the past. In the case of a semi static Huffman code, since it is an offline encoding, the codeword lengths depend on how frequently the codewords are used in the compression process of the whole text. In these cases, the cost function obviously depends on the parsing and the labels of the graph edges are not defined until a parsing is fixed. Moreover, the cost function may be undefined for edges that represent phrases never used by the parsing. The latter case is still an open problem, i.e. it is not known how to find an optimal parsing strategy when the encoding costs depend on the parsing itself.\n\nRemark 2.2. We call $G_{A,T}$ the “Schuegraf’s graph” in honour of the first author of [33] where a simpler version was considered in the case of static-dictionary compression method.\n\nWe can naturally extend the definition of the graph associated with an algorithm to the dictionary-symbolwise case. Given a text $T = a_1 \\ldots a_n$, a dictionary-symbolwise algorithm $A$, and a cost function $C$ defined on edges, the graph $G_{A,T} = (V,E,L)$ is defined as follows. The vertices set is $V = \\{0 \\ldots n\\}$, with $n = |T|$. The set of directed edges $E = E_d \\cup E_s$, where\n\n$$E_d = \\{(p, q) \\in (V \\times V) \\mid p < q - 1, \\text{ and } \\exists w = T[p + 1 : q] \\in D_p\\}$$\n\nis the set of dictionary edges and\n\n$$E_s = \\{(q - 1, q) \\mid 0 < q \\leq n\\}$$\n\nis the set of symbolwise edges. $L$ is the set of edge labels $L_{p,q}$ for every edge $(p, q) \\in E$, where the label $L_{p,q} = C((p, q))$. Let us notice that the cost function $C$ hereby used has to include the cost of the flag information to each edge, i.e. $C((p, q))$ is equal to the cost of the encoding of $F_d$ ($F_s$, resp.) plus the cost of the encoded dictionary phrase $w \\in D_p$ (symbolwise $a_q$, resp.) associated with the edge $(p, q)$ where $(p, q) \\in E_d$ ($E_s$, resp.). Moreover, since $E_d$ does not contain edges of length one by definition, $G_{A,T} = (V,E,L)$ is not a multigraph. Since this graph approach can be extended to multigraph, with an overhead of formalism, one can relax the $p < q - 1$ constrain in the\ndefinition of \\( E_d \\) to \\( p \\leq q - 1 \\). All the results we will state in this thesis, naturally extend to the multigraph case.\n\n Figure 2.2: Graph \\( G_{A,T} \\) for the text \\( T = abccacabcbcb \\), for the dictionary-symbolwise algorithm \\( A \\) with static dictionary \\( D = \\{ ab, abc, bcb, ca, cbb \\} \\) and cost function \\( C \\) as defined in the graph. The dictionary phrase or the symbol associated with an edge is reported near the edge label within parenthesis.\n\n### 2.4 On Parsing Optimality\n\nIn this section we assume that the reader is well acquainted with LZ-like dictionary encoding and with some simple statistical encodings such as the Huffman code.\n\n**Definition 2.5.** Fixed a dictionary description, a cost function \\( C \\) and a text \\( T \\), a dictionary (dictionary-symbolwise) algorithm is *optimal* within a set of algorithms if the cost of the encoded text is minimal with respect to all others algorithms in the same set. The parsing of an optimal algorithm is called *optimal* within the same set.\n\nWhen the bit length of the encoded dictionary pointers is used as a cost function, the previous definition of optimality is equivalent to the classical well known definition of bit-optimality for dictionary algorithm. Notice that the above definition of optimality strictly depends on the text \\( T \\) and on a set of algorithms. A parsing can be optimal for a certain text but not for another one. Obviously, we are mainly interested on parsings that are optimal either for all texts over an alphabet or for classes of texts. Whenever it is not explicitly written, from now on when we talk about optimal parsing we\nmean optimal parsing for all texts. About the set of algorithm it makes sense to find sets as large as possible.\n\nClassically, there is a bijective correspondence between parsings and paths in $G_{A,T}$ from vertex 0 to vertex $n$, where optimal parses correspond to minimal paths and vice-versa. We say that a parse (path, resp.) induces a path (parse, resp.) to denote this correspondence. This correspondence was firstly stated in [33] only in the case of sets of algorithms sharing the same static dictionary and where the encoding of pointers has constant cost.\n\nFor example the path along vertices $(0, 3, 4, 5, 6, 8, 11, 12, 13, 14)$ is the shortest path for the graph in Fig. 2.2. Authors of [12] were the first to formally extend the Shortest Path approach to dynamically changing dictionaries and variable costs.\n\n**Definition 2.6.** A scheme $S$ has the Schuegraf property if, for any text $T$ and for any pair of algorithms $A, A' \\in S$, the graph $G_{A,T} = G_{A',T}$ with $G_{A,T}$ well defined.\n\nThis property of schemes is called property of Schuegraf in honor of the first of the authors in [33]. In this case we define $G_{S,T} = G_{A,T}$ as the graph of (any algorithm of) the scheme. The proof of the following proposition is straightforward.\n\n**Proposition 2.4.1.** There is a bijective correspondence between optimal parsings and shortest paths in $G_{S,T}$ from vertex 0 to vertex $n$.\n\n**Definition 2.7.** Let us consider an algorithm $A$ and a text $T$ and suppose that graph $G_{A,T}$ is well defined. We say that $A$ is graph optimal (with respect to $T$) if its parsing induces a shortest path in $G_{A,T}$ from the origin (i.e. vertex 0) to vertex $n$, with $n = |T|$. In this case we say that its parsing is graph optimal.\n\nLet $A$ be an algorithm such that for any text $T$ the graph $G_{A,T}$ is well defined. We want to associate a scheme $SC_A$ with it in the following way. Let $S$ be the set of all algorithms $A$ such that, for any text $T$, $G_{A,T}$ exists (i.e. it is well defined). Let $B$ and $C$ be two algorithms in $S$. We say that $B$ and $C$ are equivalent or $B \\equiv C$ if, for any text $T$, $G_{B,T} = G_{C,T}$. \n\n27\nWe define the scheme $\\mathcal{SC}_A$ to be the equivalence class that has $A$ as a representative. It is easy to prove that $\\mathcal{SC}_A$ has the Schuegraf property.\n\nWe can connect the definition of graph optimal parsing with the previous definition of $\\mathcal{SC}_A$ to obtain the next proposition, which proof is an easy consequence of the Proposition 2.4.1 and of the Schuegraf property of $\\mathcal{SC}_A$. Roughly speaking, the graph optimality within the scheme $\\mathcal{SC}_A$ implies scheme (or global) optimality.\n\n**Proposition 2.4.2.** Let us consider an algorithm $A$ such that for any text $T$ the graph $G_{A,T}$ is well defined. Suppose further that for a text $T$ the parsing of $A$ is graph optimal. Then the parsing of $A$ of the text $T$ is (globally) optimal within the scheme $\\mathcal{SC}_A$.\n\n\n\nWe have simple examples (see Figure 2.3), where a parsing of a text is graph optimal and the corresponding algorithm belongs to a scheme that has not the Schuegraf property and it is not optimal within the same scheme.\n\nFor instance, let us now consider the text $T = ab$ and two algorithms $A$ and $A'$ in the same scheme, where $A$ is the algorithm that uses the greedy parsing and $A'$ uses the anti-greedy parsing, as in Figure 2.3. The parsing of $A$ is the greedy parsing, that at any reached position chooses the longest match between text and dictionary. The graph $G_{A,T}$ for this greedy algorithm has three nodes, 0, 1, 2, and only two edges, both outgoing 0, one to node 1 that costs 10 and another to node 2 that costs 20. The greedy parsing reaches the end of the text with this second edge which has global cost 20 and then it is graph optimal. The parsing of $A'$ is the anti-greedy that at any reached position chooses the shortest nonempty match between text and dictionary. The graph $G_{A',T}$ for this anti-greedy algorithm has three nodes, 0, 1, 2, and three edges, two outgoing 0, one to node 1 that costs 10\nand another to node 2 that costs 20 and a third outgoing 1 to node 2 that costs 5. The parsing of the anti-greedy algorithm is \\((a)(b)\\) and it costs 15.\n\nThe dictionary is composed by \\((a, ab)\\) if the parsing of the processed text has reached an even position (starting from position 0) with a cost of 10 and 20 respectively. The dictionary is \\((a, b)\\) if the parsing of the processed text has reached an odd position with a cost of 5 each. Notice that now the dictionary phrase “a” has a different cost than before. The dictionary and the edge costs are changing as a function of the reached position, depending if this position is even or odd, and, in turn, it depends on the parsing. Therefore, we have that \\(G_{A,T}\\) and \\(G_{A',T}\\) are well defined but they are different from each other and the scheme has not the Schuegraf property. Therefore both the greedy and the anti-greedy parsing are graph optimal but none of them is (globally) optimal.\n\n### 2.5 Dictionary-Symbolwise Can Be Better\n\nSo, why should we use dictionary-symbolwise compressors?\n\nFrom a practical point of view, coupling a fast symbolwise compressor to a dictionary compressor gives one more degrees of freedom to the parsing, increasing compression ratio without slowing up the entire compression process. Or, on the contrary, a dictionary compressor coupled with a powerful symbolwise compressor can speed up the decompression process without decreasing the compression ratio. This approach that mixes together dictionary compression and symbolwise compression methods is already widely used in practical compression software solutions, even if its scientific basis were not clearly defined and it was treated just as a practical trick to enhance compression ratio and to take under control and improve the decompression speed. Several viable algorithms and most of the commercial data compression programs, such as gzip, zip or cabarc, are, following our definition, dictionary-symbolwise. Still from a practical point of view, some experimental results are showed and discussed in next section.\n\nIn this section instead we study some theoretical reasons for using dictionary-symbolwise compression algorithms.\n\nFirst of all, it is not difficult to give some “artificial” and trivial example\nwhere coupling a dictionary and a symbolwise compressor give rise to a better optimal solution. Indeed let us consider the static dictionary \\( D = \\{a, b, ba, bb, abb\\} \\) together a cost function \\( C \\) that could represents the number of bits of a possible code: \\( \\{C(a) = 8, C(b) = 12, C(ba) = 16, C(bb) = 16, C(abb) = 4\\} \\).\n\nA greedy parsing of the text \\( babb \\) is \\( (ba)(bb) \\) and the cost of this parsing is 32. An optimal parsing for this dictionary is \\( (b)(abb) \\) that has cost 16. This example shows, as also the one of Figure 2.3, that a greedy parsing is not always an optimal parsing in dictionary compressors.\n\nLet us consider further the following static symbolwise compressor that associates with the letter \\( a \\) a code of cost 8 and that associates with the letter \\( b \\) a code of cost 4 that could represent the number of bits of this code. The cost of coding \\( babb \\) following this symbolwise compressor is 20.\n\nIf we connect them in a dictionary-symbolwise compressor then an optimal parsing is \\( S(b)D(abb) \\) where the flag information is represented by the letter \\( S \\) for symbolwise and by \\( D \\) for dictionary. The cost of the trivially encoded flag information is one bit for each letter or phrase. Therefore the cost of this parsing is 10.\n\nIn this subsection, however, we will prove something more profound than artificial examples such the one above. Indeed, from a theoretical point of view, Ferragina et al. (cf. [17]) proved that the compression ratio of the classic greedy-parsing of a LZ77 pure dictionary compressor may be far from the bit-optimal pure dictionary compressor by a multiplicative factor \\( \\Omega(\\log n / \\log \\log n) \\), which is indeed unbounded asymptotically. The family of strings that is used in [17] to prove this result, is a variation of a family that was used in [24].\n\nIn next two subsections we show a similar result between the bit optimal dictionary compressor and a dictionary-symbolwise compressor. Therefore a bit optimal dictionary-symbolwise compressor can use, in some pathological situation, the symbolwise compressor to avoid them and be provably better than a simple bit optimal dictionary compressor.\nLZ77 Case\n\nLet us define these two compressors. The first is a LZ77-based compressor with unbounded window size as dictionary and with a Huffman code on lengths and an optimal parser. It allows overlaps between the search buffer, i.e. the dictionary, and the look ahead buffer. The encoding of pointers can be any of the classical encoding for integer. We just impose a Huffman code on the lengths.\n\nWe further denote by OPT-LZH(s) the bit length of the output of this compressor on the string s.\n\nThe same LZ77 is used as dictionary compressor in the dictionary-symbolwise compressor. Clearly we do not include the parser in the dictionary-symbolwise compressor, but, analogously as above, we suppose to have an optimal parser for the dictionary-symbolwise compressor, no matter about the description. The flag information \\{D, S\\} is coded by a run-length encoder. The cost of a run is subdivided over all symbolwise arcs of the run, i.e. if there is a sequence of n consecutive symbolwise arcs in the optimal parsing then the cost of these n flag information S (for Symbolwise) will be in total \\(O(\\log n)\\) and the cost of each single flag information in this run will be \\(O\\left(\\frac{\\log n}{n}\\right)\\).\n\nIt remains to define a symbolwise compression method.\n\nIn the next result we could have used a PPM* compressor but, for simplicity, we use a longest match symbolwise. That is, the symbolwise at position k of the text searches for the closest longest block of consecutive letters in the text up to position k – 1 that is equal to a suffix ending in position k. This compressor predicts the \\(k + 1\\)th character of the text to be the character that follows the block. It writes a symbol ‘y’ (that is supposed not to be in the text) if this is the case. Otherwise it uses an escape symbol ‘n’ (that is supposed not to be in the text) and then writes down the correct character plainly. A temporary output alphabet has therefore two characters more than the characters in the text. This temporary output will be subsequently encoded by a run-length encoder (see [15]).\n\nThis is not a very smart symbolwise compressor but it fits our purposes, and it is simple to analyze.\nWe further denote by OPT-DS(s) the bit length of the output of this dictionary-symbolwise compressor on the string s.\n\n**Theorem 2.5.1.** There exists a constant $c > 0$ such that for every $n' > 1$ there exists a string $s$ of length $|s| \\geq n'$ satisfying\n\n$$OPT-LZH(s) \\geq c \\frac{\\log |s|}{\\log \\log |s|} \\cdot OPT-DS(s).$$\n\n**Proof.** For every $n'$ let us pick a binary word $w$ of length $3n$, $n \\geq n'$, $w = a_1a_2 \\cdots a_{3n}$ that has the following properties.\n\n1. For any $i, i = 1, 2 \\cdots n$, the compressor OPT-LZH(s) cannot compress the word $a_ia_{i+1} \\cdots a_{2i+n-1}$ of length $n + i$ with a compression ratio greater than $2$.\n\n2. every factor (i.e. every block of consecutive letters) of $w$ having length $3\\log 3n$ of $w$ is unique, i.e. it appears in at most one position inside $w$.\n\nEven if it could be hard to explicitly show such a word, it is relatively easy to show that such a word exists. Indeed, following the very beginning of the Kolmogorov’s theory, the vast majority of words are not compressible. A simple analogous counting argument can be used to prove that Property 1 is satisfied by the vast majority of strings of length $3n$, where, for vast majority we mean that the percentage of strings not satisfying Property 1 decreases exponentially in $n$. Here, to play it safe, we allowed a compression “two to one” for all the $n$ considered factors.\n\nA less known result (see [2, 7, 13, 14, 18, 37]) says that for random strings and for any $\\epsilon > 0$ the percentage of strings of length $n$ having each factor of length $2\\log n + \\epsilon$ unique grows exponentially to 1 (i.e. the percentage of strings not having this property decreases exponentially). Here we took as $\\epsilon$ the number 1. Therefore such a string $a_1 \\cdots a_{3n}$ having both properties surely exists for some $n \\geq n'$.\n\nLet us now define the word $s$ over the alphabet $\\{0, 1, c\\}$ in the following way.\n\n$$s = a_1a_2 \\cdots a_{n+1}c^{2n} \\cdots a_{i}a_{i+1} \\cdots a_{2i+n-1}c^{2n} \\cdots a_{n}a_{n+1} \\cdots a_{3n-1}c^{2n} a_{n+1}a_{n+2}$$\nLet us now evaluate OPT-LZH($s$). By Property 1 each binary word that is to the left or to the right of a block of $2^n$ $c$'s cannot be compressed in less than $\\frac{1}{2} n$ bits in a “stand-alone” manner. If one such a string is compressed by a pointer to a previous string then the offset of this pointer will be greater than $2^n$ and, so, its cost in bit is $O(n)$. We defined the string $s$ in such a manner that all “meaningful” offsets are different, so that even a Huffman code on offsets (that we do not use, because we use a Huffman code only for lengths) cannot help. Therefore there exists a constant $c'$ such that $\\text{OPT-LZH}(s) \\geq c' n^2$.\n\nLet us now evaluate OPT-DS($s$). We plan to show a parse that will give a string of cost $P-DS(s) \\leq \\hat{c} n \\log n$ as output. Since $\\text{OPT-DS}(s) \\leq P-DS(s)$ then also $\\text{OPT-DS}(s) \\leq \\hat{c} n \\log n$.\n\nThe blocks of $2^n$ $c$’s have all the same length. We parse them with the dictionary compressor as $(c)(c^{2^n} - 1)$. The dictionary compressor is not used in other positions in the parse $P$ of the string $s$. The Huffman code on lengths of the dictionary compressor would pay $n$ bits for the table and a constant number of bits for each occurrence of a block of $2^n$ $c$’s. Hence the overall cost in the parse $P$ of all blocks of letters $c$ is $O(n)$. And this includes the flag information that consists into two bits $n$ times.\n\nParse $P$ uses the symbolwise compressor to parse all the binary strings. The first one $a_1a_2\\cdots a_{n+1}$ costs $O(n)$ bits. Starting from the second $a_2a_3\\cdots a_{n+3}$ till the last one, the symbolwise will pay $O(\\log n)$ bits for the first $3\\log 3n$ letters and then, by Property 2, there is a long run of ‘y’ that will cover the whole string up to the last two letters. This run will be coded by the run-length code of the symbolwise. The overall cost is $O(\\log n)$ and this includes the flag information that is a long run of $S$ coded by the run-length of the flag information. The cost of the symbolwise compressor including the flag information over the whole string is then $O(n \\log n)$, that dominates the cost of the dictionary-symbolwise parse $P$.\n\nThe length of the string $s$ is $O(n2^n + n^2)$ and therefore $\\log |s| = n + o(n)$ and the thesis follows.\n\n\\[\\square\\]\n\nRemark 2.3. In the theorem above it is possible to improve the constants in the statement. This can be done simply using for instance a word $a_1 \\cdots a_{n^2}$\ninstead of $a_1 \\cdots a_{3n}$. It is possible to optimize this value, even if, from a conceptual point of view, it is not important.\n\nWe want to underline that the Huffman code on the lengths is essential in this statement. At the moment we are not able to find a sequence of strings $s$ where the dictionary-symbolwise compressor is provably better than the optimal dictionary version without using a Huffman code. It is an open question whether this is possible.\n\nWe finally notice that if the dictionary is coupled with a ROLZ technique then the optimal solution of the pure dictionary compressor reaches the same level of the dictionary-symbolwise compressor. This is not surprising because the ROLZ technique is sensible to context and do not “pay” for changing the source of the text.\n\n**LZ78 Case**\n\nMatias and Sahinalp in [28] already shown that Flexible Parsing is optimal with respect to all the prefix-closed dictionary algorithms, including LZ78, where optimality stands for phrase optimality. Flexible Parsing is also optimal in the suffix-close dictionary algorithm class. Phrase optimality is equal to bit optimality under the fixed length codeword assumption, so we say just optimality. From now on we assume $FP$ or its extension as optimal parsing and the bit length of the compressed text as coding cost function.\n\nIn this subsection we prove that there exists a family of strings such that the ratio between the compressed version of the strings obtained by using an optimal LZ78 parsing (with constant cost encoding of pointers) and the compressed version of the strings obtained by using an optimal dictionary-symbolwise parsing is unbounded. The dictionary, in the dictionary-symbolwise compressor, is still the LZ78 dictionary, while the symbolwise is a simple Last Longest Match Predictor that will be described later. We want to notice here that similar results were proved in [28] between flexible parsing and the classical LZ78 and in [17] between a compressor that uses optimal parsing over a LZ77 dictionary and the standard LZ77 compressor (see also [24]). Last but not least we notice that in this example, analogously as done in [28], we use an unbounded alphabet just to make the example more clear.\nAn analogous result can be obtained with a binary alphabet with a more complex example.\n\nLet us define a Dictionary-Symbolwise compressor that uses LZ78 as dictionary method, the Last Longest Match Predictor as symbolwise method, Run Length Encoder to represent the flag information and one optimal parsing method. Let us call it OptDS-LZ78. We could have used a PPM* as symbolwise compressor but Last Longest Match Predictor (LLM) fits our purposes and it is simple to analyze. LLM Predictor is just a simple symbolwise compression method that uses the last longest seen match to predict next character.\n\nThe symbolwise searches, for any position $k$ of the text, the closest longest block of consecutive letters up to position $k - 1$ that is equal to a suffix ending in position $k$. This compressor predicts the $(k + 1)$-th character of the text to be the character that follows the block. It writes a symbol ‘y’ (that is supposed not to be in the text) if this is the case. Otherwise it uses an escape character ‘n’ (that is supposed not to be in the text) and then writes down the correct character plainly. A temporary output alphabet has therefore two characters more than the characters in the text. This temporary output will be subsequently encoded by a run-length encoder. This method is like the Yes?No version of Symbol Ranking by P. Fenwick (see [15]).\n\nIt costs $\\log n$ to represent a substring of $n$ characters that appear after the match. For each position $i$ in the uncompressed text if $m_i$ is the length of the longest match in the already seen text it produces $n$ that costs $O(\\log n)$ bits as output, i.e. $C(T[i + 1 : i + n]) = n$ and $Cost(n) = O(\\log n)$ where\n\n$$\\forall m, j \\quad m_i = \\max_m (T[i - m : i]) = T[j - m : j] \\text{ with } j < i \\text{ and } T[i - m - 1] \\neq T[j - m - 1])$$\n\nLet us consider a string $S$\n\n$$S = \\sum_{z=1}^{k} 1 + \\cdots + z = [1 + 12 + 123 + \\cdots + 1..z + \\cdots + 1..k]$$\n\nthat is the concatenation of all the prefixes of $1..k$ in increasing order. Let us consider the string $T'$ that is the concatenation of the first $\\sqrt{k}$ suffixes of $2..k$, i.e. $T' = 2..k \\cdot 3..k \\cdot \\ldots \\cdot \\sqrt{k}..k$ and a string $T = S \\cdot T'$. We\nuse $S$ to build a dictionary formed by just the string $1..k$ and its prefixes and no more. We assume that both the dictionary and the symbolwise methods work the same up to the end of the string $S$, so they produce an output that is very similar in terms of space. It is not difficult to prove that an optimal LZ78 compressor would produce on $T$ a parse having cost at least $O(k + k \\log k) = O(k \\log k)$ while the optimal dictionary-symbolwise compressor (under the constant cost assumption on encoding pointers) has a cost that is $O(k + \\sqrt{k} \\log k) = O(k)$.\n\n**Proof.** (Sketch) An optimal constant-cost LZ78 compressor must uses $k$ phrases to code $S$. Then each phrase used to code the subword $2\\ldots k$ of $T'$ has length at most 2 and therefore the number of phrases that it must use to code $2\\ldots k$ is at least $(k - 1)/2 \\geq \\frac{1}{2}k/2$. Analogously, each phrase used to code the subword $3\\ldots k$ of $T'$ has length at most 3 and therefore the number of phrases that it must use to code $3\\ldots k$ is at least $(k - 2)/3 \\geq \\frac{1}{3}k/2$. We keep on going up to conclude that number of phrases that it must use to code $\\sqrt{k}\\ldots k$ is at least $(k - \\sqrt{k} + 1)/\\sqrt{k} \\geq \\frac{1}{\\sqrt{(k)}}k/2$. Adding all these numbers we get that the total number of phrases is smaller than or equal to $O(k + \\log \\sqrt{k} \\times k/2) = O(k \\log k)$.\n\nLet us now prove that an optimal dictionary-symbolwise compressor has a cost that is $O(k)$ by showing that there exists at least one parse that has cost $O(k)$.\n\nThe parse that we analyze parses $S$ with the LZ78 dictionary and spend for this part of the string $O(k)$. Then it uses the LLM Predictor to compress the subword $2\\ldots k$ of $T'$. Firstly it outputs a symbol 'n' followed by the symbol 2 because it is unable to predict the symbol 2 and then it outputs $k - 2$ symbols 'y' that, in turn, are coded by the run length encoder with a cost that is $O(\\log k)$. The whole cost of subword $2\\ldots k$ is then $O(\\log k)$. Then the LLM Predictor compresses sequentially the subword $i\\ldots k$ of $T'$, with $3 \\leq i \\leq \\sqrt{k}$ and any time it spends at most $O(\\log k)$. The total cost of this parse is then $O(k + \\sqrt{k} \\log k) = O(k)$. \\qed\nChapter 3\n\nAbout the Parsing Problem\n\nIn this chapter we survey some of the milestone results about the parsing problem, starting from those concerning static dictionaries through the dynamic case. In the last section we present a small new contribution that complete the picture of fixed costs case. It is the generalization of the greedy parsing of Cohn for static dictionary to the dynamic dictionary case.\n\n3.1 The Optimal Parsing Problem\n\nOptimal with respect to what? Obviously in data compression we are mainly interested to achieve the best compression ratio, that corresponds to minimizing the size of the compressed data. This notion of optimality is sometimes called bit-optimality. But our question has a deeper sense. When can we say that a parsing algorithm is an optimal parsing algorithm? We could say that a parsing is optimal with respect to the input data or with respect to the compression algorithms in which it is involved.\n\nFollowing Proposition 2.4.2, we say that, fixed a compression scheme, e.g. the LZ77-like algorithms, an optimal parsing is the parsing algorithm that applied to the scheme gives the compression algorithm (see the Remark 2.1) with the best compression ratio for any input text with respect to all the compression algorithms in the same scheme.\n\nTherefore, given a dictionary-based compression algorithm, e.g. LZW, we take the largest compression scheme that contains this algorithm. This\nscheme is the set of all the algorithms that use the same dictionary description and the same encodings (e.g. the LZW-like algorithms or LZW scheme). All the algorithms in this scheme differ each other in just the parsing method. If the scheme has the Schuegraf property (see Definition 2.6), then an optimal parsing will be any parsing that minimize the compression ratio within the algorithms of the scheme, i.e., from Proposition 2.4.1, any parsing that induces a shortest path on the graph associated to the scheme. Notice that if the scheme has not the Schuegraf property, then it is not clear how to obtain an optimal parsing that is optimal for the entire scheme.\n\n3.2 An Overview about Theory and Practice\n\nIn this section we do not want to give an exhaustive dissertation about the parsing problem as there is a vast literature concerning this topic and there are many practical solutions. We want just to recall some of the milestones in the data compression field that are strongly relevant with the scope of this thesis.\n\nIn ’73, the Wagner’s paper (see [38]) shows a \\(O(n^2)\\) dynamic programming solution, where a text \\(T\\) of length \\(|T| = n\\) is provided at ones.\n\nIn ’74 Schuegraf (see [33]) showed that the parsing problem is equal to the shortest path problem on the graph associated to both a text and a static dictionary (see Section 2.3 for the graph-based model of the parsing problem). Since that the full graph for a text of length \\(n\\) can have \\(O(n^2)\\) edges in the worst case and the minimal path algorithm has \\(O(V + E)\\) complexity, we have another solution for the parsing problem of \\(O(n^2)\\) complexity.\n\nIn ’77 and ’78 years the foundational dynamic dictionary-based compression methods LZ77 and LZ78 have been introduced. They both use an online greedy parsing that is simple and fast. Those compression methods use both an uniform (constant) cost model for the dictionary pointers. The online greedy approach is realized by choosing the longest dictionary phrase that matches with the forwarding text to extend the parsing, moving on the text left to right, until the whole text is covered.\n\nIn ’82, the LZSS compression algorithm, based on the LZ77 one, was presented (see [36]). It improves the compression rate and the execution\ntime without changing the original parsing approach. The main difference is that a symbol is used only when there is no match between dictionary and text. But when there is any match, the longest one is always chosen. It uses a flag bit to distinguish symbols from dictionary pointers. In the same paper Storer proved the optimality of the greedy parsing for the original LZ77 dictionary with unbounded size (see Theorem 10 in [36] with \\( p = 1 \\)).\n\nIn '84, LZW variant of LZ78 was introduced by Welch (see [39]). This is, to our best knowledge, the first theoretical compression method that uses a dynamic dictionary and variable costs of pointers.\n\nIn '85, Hartman and Rodeh proved in [20] the optimality of the one-step-lookahead parsing for prefix-closed static dictionary and uniform pointer cost. The main point of this approach is to chose the phrase that is the first phrase of the longest match between two dictionary phrases and the text, i.e. if the current parsing cover the text up to the \\( i \\)th character, then we chose the phrase \\( w \\) such that \\( ww' \\) is the longest match with the text after position \\( i \\), with \\( w, w' \\) belong to the dictionary.\n\nIn '89 and later in '92, the deflate algorithm was presented and used in the PKZIP and gzip compressors. It uses a LZ77-like dictionary, the LZSS flag bit and, for some options, a non-greedy parsing. Both dictionary pointers and symbols are encoded by using a Huffman code.\n\nIn '95, Horspool investigated in [21] about the effect of non-greedy parsing in LZ-based compression. He showed that using the above one-step-lookahead parsing in the case of dynamic dictionaries leads to better compression. Horspool tested this parsing on the LZW algorithm and on a new LZW variant that he presented in the same paper.\n\nIn '96 the greedy parsing was ultimately proved by Cohn et al. (see [5]) to be optimal for static suffix-closed dictionary under the uniform cost model. They also proved that the right to left greedy parsing is optimal for prefix-closed dictionaries. Notice that the greedy approach is linear and online. These results will be reported and extended in the next section.\n\nIn '99, Matias and Sahinalp (see [28]) gave a linear-time optimal parsing algorithm in the case of prefix-closed dynamic dictionary and uniform cost of dictionary pointer, i.e. the codeword of all the pointers have equal length. They extended the results given in [20], [21] and [23] to the dynamic case.\nMatias and Sahinalp called their parsing algorithm *Flexible Parsing*. It is also known as semi-greedy parsing.\n\nIn ’09, Ferragina et al. (see [17]) introduced an optimal parsing algorithm for LZ77-like dictionary and variable-length code, where the code length is assumed to be the cost of a dictionary pointer.\n\nIn ’10, Crochemore et al. (see [8]) introduced an optimal parsing for prefix-closed dictionaries and variable pointer costs. It was called *dictionary-symbolwise flexible parsing* and it is extensively treated and extended in this thesis. It works for the original LZ77 and LZ78 algorithms and for almost all of their known variants.\n\n### 3.3 A Generalization of the Cohn’s Theorem\n\nA static dictionary $D$ is prefix-closed (suffix-closed) if and only if for any phrase $w \\in D$ in the dictionary all the prefixes (suffixes) of $w$ belong to the dictionary, i.e. $\\text{suff}(w) \\subseteq D$ ($\\text{pref}(w) \\subseteq D$). For instance, the dictionary $\\{bba, aba, ba, a\\}$ is suffix-closed.\n\nThe classic Cohn’ and Khazan’s result of ’96 (see [5]) states that if $D$ is a static suffix-closed dictionary, then the greedy parsing is optimal under the uniform cost assumption. Symmetrically, the reverse of the greedy parsing on the reversed text, i.e. the right to left greedy parsing, is optimal for static prefix-closed dictionary. Roughly speaking, the original proof concerns with suffix-closed dictionaries and shows that choosing the longest dictionary phrases guarantees to cover the text with the minimum number of phrases. The main idea is that, fixed a point $a$ on the text, the greedy choice is the longest match with the dictionary and text on the right of $a$, e.g the phrase that cover the text from $a$ to $b$. Now, $b$ is the rightmost point that can be reached from $a$ or from any point on the left of $a$. For absurd, given $\\alpha$ on the left of $a$, if in the dictionary there is a phrase equal to the text from $\\alpha$ to $\\beta$ on the right of $b$, then, for the suffix-closed property, the phrase $a - \\beta$ is in the dictionary too. This contradicts that $a - b$ is the longest match.\n\nNotice that the optimal greedy solution for suffix-closed static dictionary can be computed *online*.\n\nLet us compare these results to the LZ family of algorithms. We notice\nthat above results concern with static dictionaries and cannot be directly applied in these cases. Moreover, the greedy parsing of the LZ-78 algorithm is not the one that was proved to be optimal for the prefix-closed case.\n\nFor the LZ77 algorithm, which dictionary is both prefix-closed and suffix-closed, we need to generalize the Cohn’ and Khazan’s result for suffix-closed dictionary to the dynamic case. Within this thesis we refer to the Cohn’ and Khazan’s result on suffix-closed dictionary simply as the Cohn’s theorem in honour of its first author.\n\nLet us start focusing on the prefix and suffix-closed definition of dynamic dictionaries. The classic definition of suffix-closed dynamic dictionary just require that the dictionary is suffix-closed at any time. Therefore, given a suffix-closed dynamic dictionary $D$, if $D_i$ is the dictionary $D$ at the time $i$, then $D_i$ is suffix-closed, for any $i$. The prefix-closed case is analogously defined. Notice that this definition does not make any assumption on the relationship between dictionaries in two different moments. We call above properties weak suffix-closed property and weak prefix-closed property respectively. We introduce the strong suffix-closed property and the strong prefix-closed property of dynamic dictionary as follows.\n\n**Definition 3.1.** A dynamic dictionary $D$ has the strong prefix-closed property iff, for any dictionary phrase $w \\in D_i$, for any $k$ in $[0,|w|]$, $w_k$ is in $D_i$ and in $D_{i+k}$, where $w_k$ is the prefix of $w$ of length $k$.\n\n**Definition 3.2.** A dynamic dictionary $D$ has the strong suffix-closed property iff, for any dictionary phrase $w \\in D_i$, for any $k$ in $[0,|w|]$, $w^k$ is in $D_i$ and in $D_{i+k}$, where $w^k$ is the suffix of $w$ of length $|w| - k$.\n\nNotice that the strong prefix-closed property implies the weak prefix-closed property. Analogously, the strong suffix-closed property implies the weak property.\n\nWe say that a dictionary is non-decreasing when $D_i \\subseteq D_j$ for any $i, j$ points in time, with $0 \\leq i \\leq j$. A static dictionary is obviously non-decreasing. Practically speaking, a dynamic dictionary is non-decreasing when it can only grow along the time, as for instance the original LZ78 where, at each algorithm step, at most one phrase is inserted in the dynamic dictionary.\nRemark 3.1. For non-decreasing dictionaries, the weak suffix-closed property and the weak prefix-closed property are equal to the strong suffix-closed property and to the strong prefix-closed property, respectively.\n\nNotice that while the original LZ78 dictionary is non-decreasing, many of its practical implementation and its variants are not. This is because the size of the dictionary is bounded in practice for space saving purpose. Since the original LZ77 dictionary is defined as the set of the substrings of the search buffer, i.e. the backward text up to a certain distance, LZ77 has not the non-decreasing property at all.\n\nProposition 3.3.1. The LZ77 dictionary is both weak prefix-closed and weak suffix-closed. The LZ77 unbounded dictionary is non-decreasing. The original LZ77 dictionary is strong suffix-closed.\n\nProof. We refer to the LZ77 dictionary definition given in Section 2.2. The dictionary at time $i$ is defined as $D_i = \\{w, \\text{ such that } w \\in \\text{Fact}(T[i - P : i]) \\text{ and } |w| < Q\\}$, where $P$ is the maximum offset for text factors, $Q$ is the maximum length for dictionary phrases.\n\nSince any set of factors is prefix and suffix closed and since for any phrase $w$ each of its suffixes or prefixes has length less than or equal to $|w|$, then LZ77 dictionary is weak prefix-closed and weak suffix-closed by definition.\n\nThe LZ77 dictionary is unbounded when $P \\geq |T|$. In this case the dictionary is equal to the set $\\{w, \\text{ such that } w \\in \\text{Fact}(T[0 : i]) \\text{ and } |w| < Q\\}$ that is obviously non-decreasing.\n\nLet us focus on the general set $\\text{Fact}(T[i - P : i])$. This is a sliding window of size $P$ over the text $T$. For any value $i$, let be $T[i - P : i] = au$ and $T[i - P + 1 : i + 1] = ub$ with $a, b$ in $\\Sigma$ and $u$ in $\\Sigma^*$. Since all the proper suffixes of $au$ are also suffixes of $u$, then for any $w \\in \\text{Fact}(T[i - P : i])$ the proper suffixes $w^k$ of length $|w| - k$ where $1 < k \\leq |w|$ are also in $\\text{Fact}(T[i - P + 1 : i + 1])$. Therefore this property also holds for the dictionaries $D_i$ and $D_{i+1}$ and it easy to see that this property is equivalent to the strong suffix-closed property defined in Definition 3.2.\n\nCorollary 3.3.2. The LZ77 dictionary has the strong suffix-closed property in both the bounded and the unbounded variants.\nThe proof of the above proposition comes straightforward from the Proposition 3.3.1, the Remark 3.1 and the dictionary definition.\n\nLet us now show the effect of the suffix-closed and the prefix-closed properties on the Schuegraf graph to visualize those concepts. Given a text \\( T \\) and an algorithm \\( A \\) that uses a dictionary \\( D \\), we have that if \\( D \\) has the strong suffix-closed property, then for any edge \\((i, j)\\) of the graph \\( G_{A,T} \\) associated with the phrase \\( w \\in D_i \\), with \\( |w| = j - i \\) and \\( w = T[i + 1 : j] \\), then all the edges \\((k, j), i < k < j\\) are into \\( G_{A,T} \\). In the case of prefix-closed dictionaries, as prefix edges start from the same node, the prefix of a dictionary phrase are all represented in the graph if the dictionary has just the weak prefix-closed property.\n\nWe want now to extend the elegant proof of Cohn et al. (see [5]) to the case of strong suffix-closed dynamic dictionaries.\n\nGiven a text \\( T \\) of length \\( n \\) and a dynamic dictionary \\( D \\), where, at the moment \\( i \\)-th with \\( 0 \\leq i < n \\), the text \\( T_i \\) has been processed and \\( D_i \\) is the dictionary at time \\( i \\). Recall that we are under the uniform cost assumption.\n\n**Theorem 3.3.3.** The greedy parsing of \\( T \\) is optimal for strong suffix-closed dynamic dictionaries.\n\n**Proof.** The prove is by induction. We want to prove that for any \\( n \\) smaller than or equal to the number of phrases of an optimal parsing, there exists an optimal parsing where the first \\( n \\) phrases are greedy phrases. The inductive hypothesis is that there exists an optimal parsing where the first \\( n - 1 \\) phrases are greedy phrases. We will prove that there is an optimal parsing where the first \\( n \\) phrases are greedy and, therefore, any greedy parsing is optimal.\n\nFixed a text \\( T \\) and a strong suffix-closed dynamic dictionary \\( D \\), let \\( \\mathcal{O} = o_1 o_2 \\cdots o_p = T \\) be an optimal parsing and let \\( \\mathcal{G} = g_1 g_2 \\cdots g_q = T \\) be the greedy parsing, where, obviously, \\( p \\leq q \\).\n\nThe base of the induction with \\( n = 0 \\) is obviously true. Let us prove the inductive step.\n\nBy inductive hypothesis, \\( \\forall \\ i < n \\) we have that \\( o_i = g_i \\). Since \\( g_n \\) is greedy, then the \\( n \\)-th phrase of the greedy parsing is longer than or equal\nto the $n$-th phrase of the optimal parsing, i.e. $|o_n| \\geq |o_n|$ and therefore $|o_1 \\cdots o_n| \\leq |g_1 \\cdots g_n|$.\n\nIf $|g_n| = |o_n|$, then the thesis follows. Otherwise, $|g_n| > |o_n|$ and $o_n$ is the first phrase in the optimal parsing that is not equal the $n$-th greedy phrase.\n\nLet $h$ be the minimum number of optimal parsing phrases that overpass $g_n$ over the text, i.e. $h = \\min \\{ i \\mid |o_1 \\cdots o_i| \\geq |g_1 \\cdots g_n| \\}$. Since $|g_n| > |o_n|$, then $h > n$. If $|o_1 \\cdots o_h| = |g_1 \\cdots g_n|$, then the parsing $g_1 \\cdots g_n o_{h+1} \\cdots o_p$ uses a number of phrases strictly smaller than the number of phrases used by the optimal parsing that is a contradiction. Therefore $|o_1 \\cdots o_h| > |g_1 \\cdots g_n|$.\n\nThe reader can see this case reported in Figure 3.1.\n\nLet $|o_1 \\cdots o_{h-1}| = T_j$ be the text up to the $j$-th symbol. Then $o_h \\in D_j$, where $D_j$ is the dynamic dictionary at the time $j$. Let $o_h^k$ the $k$-th suffix of $o_h$ with $k = |o_1 \\cdots o_h| - |g_1 \\cdots g_n|$. For the Property 3.2 of $D$, $o_h^k \\in D_{j+k}$ and then there exists a parsing $o_1 \\cdots o_{n-1} g_n o_h^k o_{h+1} \\cdots o_p$, where $g_n o_h^k = o_n \\cdots o_h$.\n\nFrom the optimality of $O$, it follows that $h = n + 1$, otherwise there exists a parsing with less phrases than an optimal one. See Figure 3.2.\n\nTherefore $o_1 \\cdots o_{n-1} g_n o_h^k o_{n+1} \\cdots o_p$ is also an optimal parsing. Since $o_1 \\cdots o_{n-1}$ is equal to $g_1 \\cdots g_{n-1}$, the thesis follows.\n\n\\[ \\square \\]\n\n**Corollary 3.3.4.** The greedy parsing is an optimal parsing for any version of the LZ77 dictionary.\n\nThe proof of the above corollary comes straightforward from the Theorem 3.3.3 and the Corollary 3.3.2.\n\nTo our best knowledge, this is the first proof of optimality of the greedy\nFigure 3.2: Detail of the differences between parsing $O$ and parsing $G$ over a text $T$ between positions $|o_1 \\cdots o_n|$ and $|o_1 \\cdots o_h|$. Nodes and dots represent the text and edges represent parsing phrases as reported on edge labels. The dashed edge $o_h^k$ represents a suffix of $o_h$.\n\nparsing that cover the original LZ77 dictionary case and almost all of the practical LZ77 dictionary implementations where the search buffer is a sliding windows on the text.\nChapter 4\n\nDictionary-Symbolwise Flexible Parsing\n\nIn this chapter we consider the case of dictionary-symbolwise algorithms where the parsing is a free mixture of dictionary phrases and symbols. We present the dictionary-symbolwise flexible parsing that is a dictionary-symbolwise optimal parsing algorithm for prefix-closed dictionaries and variable costs. This is a generalization of the Matias’ and Sahinalp’s flexible parsing algorithm (see [28]) to variable costs.\n\nThe algorithm is quite different from the original Flexible Parsing but it has some analogies with it. Indeed, in the case of LZ78-like dictionaries, it makes use of one of the main data structures used for the original flexible parsing in order to be implemented in linear time.\n\nIn next sections we will show some properties of the graph $G_{A,T}$ when the dictionary of the algorithm $A$ is prefix-closed and the encoding of the dictionary pointers leads to a nondecreasing cost function. We will call $c$-supernormal some significant edges of $G_{A,T}$ and we will use those edges to build the graph $G'_{A,T}$ that is a subgraph of $G_{A,T}$. Then, we will show that any minimal path from the origin of $G'_{A,T}$ is a minimal path in $G_{A,T}$.\n\nWe will introduce the dictionary-symbolwise flexible parsing algorithm that build the graph $G'_{A,T}$ and then find a minimal weight path on it in order to parse the text. We will prove that this parsing is optimal within any scheme having the Schuegraf Property. We will show that the dictionary-\nsymbolwise flexible parsing has linear time complexity w.r.t. the text size in the LZ78-like dictionary cases. In the case of LZ77-like dictionaries, the same algorithm has $O(n \\log n)$ time complexities and uses $O(n)$ space, where $n$ is the size of the text.\n\n4.1 The c-supermaximal Edges\n\nWe suppose that a text $T$ of length $n$ and a dictionary-symbolwise algorithm $A$ are given. We assume here that the dictionary is prefix closed at any moment.\n\nConcerning the costs of the dictionary pointer encodings, we recall that costs are variable, that costs assume positive values and that they must include the cost of the flag information. Concerning the symbolwise encodings, the costs of symbols must be positive, including the flag information cost. They can vary depending on the position of the characters in the text and on the symbol itself. Furthermore, we assume that the graph $G_{A,T}$ is well defined following our Definition 2.4, i.e. we assume that all edges have a well defined cost.\n\nWe denote by $d$ the function that represents the distance of the vertices of $G_{A,T}$ from the origin of the graph. Such a distance $d(i)$ is classically defined as the minimal cost of all possible weighted paths from the origin to the vertex $i$, with $d(0) = 0$. This distance obviously depends on the cost function. We say that cost function $C$ is prefix-nondecreasing at any moment if for any $u, v \\in D_p$ phrases associated with edges $(p, i), (p, q)$, with $p < i < q$ (that implies that $u$ is prefix of $v$), one has that $C((p, i)) \\leq C((p, q))$.\n\nLemma 4.1.1. Let $A$ be a dictionary-symbolwise algorithm such that for any text $T$ the graph $G_{A,T}$ is well defined. If the dictionary is always prefix-closed and if the cost function is always prefix-nondecreasing then the function $d$ is nondecreasing monotone.\n\nProof. It is sufficient to prove that for any $i$, $0 \\leq i < n$ one has that $d(i) \\leq d(i + 1)$. Let $j \\leq i$ be a vertex such that $(j, i + 1)$ is an edge of the graph and $d(i + 1) = d(j) + C((j, i + 1))$. If $j$ is equal to $i$ then $d(i + 1) = d(i) + C((i, i + 1))$ and the thesis follows. If $j$ is smaller than\nthen, since the dictionary $D_j$ is prefix closed, $(j, i)$ is still an edge in $D_j$ and $d(i) \\leq d(j) + C((j, i)) \\leq d(j) + C((j, i + 1)) = d(i + 1)$ and the thesis follows. The last inequality in the previous equation comes from the prefix-nondecreasing property of the cost function.\n\nLet us call vertex $j$ a predecessor of vertex $i$ if $(j, i) \\in E$ such that $d(i) = d(j) + C((j, i)) = d(j) + C((j, i + 1))$. Let us define $pre(i)$ being the smallest of the predecessors of vertex $i$, $0 < i \\leq n$, that is $pre(i) = \\min\\{ j \\mid d(i) = d(j) + C((j, i)) \\}$. In other words $pre(i)$ is the smallest vertex $j$ that contributes to the definition of $d(i)$. Clearly $pre(i)$ has distance smaller than $d(i)$. We notice that a vertex can be a predecessor either via a dictionary edge or via a symbol edge. It is also possible to extend previous definition to pointers having a cost smaller than or equal to a fixed $c$ as follows.\n\n**Definition 4.1.** For any cost $c$ we define $pre_c(i) = \\min\\{ j \\mid d(i) = d(j) + C((j, i)) \\text{ and } C((j, i)) \\leq c \\}$. If none of the predecessor $j$ of $i$ is such that $C((j, i)) \\leq c$ then $pre_c(i)$ is undefined.\n\nIf all the costs of pointers are smaller than or equal to $c$ then for any $i$ one has that $pre_c(i)$ is equal to $pre(i)$.\n\nAnalogously to the notation of [27], we want to define two boolean operations *Weighted-Extend* and *Weighted-Exist*.\n\n**Definition 4.2. (Weighted-Extend)** Given an edge $(i, j)$ in $G_{AT}$ and a cost value $c$, the operation $\\text{Weighted-Extend}(i, j, c)$ finds out whether the edge $(i, j + 1)$ is in $G_{AT}$ having cost smaller than or equal to $c$.\n\nMore formally, let $(i, j)$ in $G_{AT}$ be such that $w = T[i + 1 : j] \\in D_i$. Operation $\\text{Weighted-Extend}(i, j, c) = \\text{“yes”} \\iff \\forall a_{j+1} = T[i+1 : j+1] \\in D_i$ with $j < n$ such that $(i, j + 1)$ is in $G_{AT}$ and $C((i, j + 1)) \\leq c$, where $C$ is the cost function associated with the algorithm $A$. Otherwise $\\text{Weighted-Extend}(i, j, c) = \\text{“no”}$. Let us notice that $\\text{Weighted-Extend}$ always fails to extend any edge ending at node $n$.\n\n**Definition 4.3. (Weighted-Exist)** Given $i, j$ with $0 \\leq i < j \\leq n$ and a cost value $c$, the operation $\\text{Weighted-Exist}(i, j, c)$ finds out whether or not the phrase $w = T[i + 1 : j]$ is in $D_i$ and the cost of the corresponding edge $(i, j)$ in $G_{AT}$ is smaller than or equal to $c$. \n\n49\nLet us notice that doing successfully the operation $\\text{Weighted-Extend}$ on $((i, j), c)$ means that $w_{a_{j+1}} \\in D_i$ is the weighted extension of $w$ and the encoding of $(i, j + 1)$ has cost less or equal to $c$. Similarly, doing successfully a $\\text{Weighted-Exist}$ operation on $(i, j, c)$ means that an edge $(i, j)$ exists in $G_{A,T}$ having cost less than or equal to $c$.\n\n**Definition 4.4. (c-supermaximal)** Let $E_c$ be the subset of all the edges of the graph having cost smaller than or equal to $c$. For any cost $c$, let the set $M_c \\subseteq E_c$ be the set of c-supermaximal edges, where $(i, j) \\in M_c \\iff (i, j) \\in E_c$ and $\\forall p, q \\in V$, with $p < i$ and $j < q$, the arcs $(p, j), (i, q)$ are not in $E_c$. For any $(i, j) \\in M_c$ let us call $i$ a c-starting point and $j$ a c-ending point.\n\n**Proposition 4.1.2.** Suppose that $(i, j)$ and $(i', j')$ are in $M_c$. One has that $i < i'$ if and only if $j < j'$.\n\n**Proof.** Suppose that $i < i'$ and that $j \\geq j'$. Since the dictionary $D_i$ is prefix closed we have that $(i, j')$ is still in $D_i$ and therefore it is an edge of $G_{A,T}$. By the prefix-nondecreasing property of function $C$ we have that $C((i, j')) \\leq C((i, j)) = c$, i.e. $(i, j') \\in E_c$. This contradicts the fact that $(i', j')$ is in $M_c$ and this proves that if $i < i'$ then $j < j'$. Conversely suppose that $j < j'$ and that $i \\geq i'$. If $i > i'$ by previous part of the proof we must have that $j > j'$, that is a contradiction. Therefore $i = i'$. Hence $(i, j)$ and $(i, j')$ both belongs to $M_c$ and they have both cost smaller than or equal to $c$. This contradicts the fact that $(i, j)$ is in $M_c$ and this proves that if $j < j'$ then $i < i'$.\n\nBy previous proposition, if $(i, j) \\in M_c$ we can think $j$ as a function of $i$ and conversely. Therefore it is possible to represent $M_c$ by using an array $M_c[\\ ]$ such that if $(i, j)$ is in $M_c$, then $M_c[i] = j$ otherwise $M_c[i] = \\text{Nil}$. Moreover the non-nil values of this array are strictly increasing. The positions $j$ having value different from $\\text{Nil}$ are the ending positions.\n\nWe want to describe a simple algorithm that outputs all c-supermaximal edges scanning the text left-to-right. We call it $\\text{Find Supermaximal}(c)$. It uses the operations $\\text{Weighted-Extend}$ and $\\text{Weighted-Exist}$. The algorithm starts with $i = 0, j = 0$ and $w = \\varepsilon$, i.e. the empty word. The word $w$ is\nindeed implicitly defined by the arc \\((i, j)\\) when \\(i < j\\) or it is the empty word when \\(i = j\\). Therefore \\(w\\) will not appear explicitly in the algorithm. Since the values of \\(i\\) and \\(j\\) are only increased by one and \\(i\\) is always less than or equal to \\(j\\), the word \\(w\\) can be seen as a sliding window of variable size that scans the text left-to-right. \\(w\\) is moved along the text either by extensions or by contractions to its suffixes.\n\nAt each step of the algorithm, \\(j\\) is firstly increased by one. This extends \\(w\\) concatenating it to \\(T[j]\\). The algorithm executes then a series of Weighted-Exist increasing \\(i\\) by one, i.e. it contracts many times \\(w\\). This series of Weighted-Exist ends when \\(w\\) is the empty word or an edge \\((i, j) \\in E_c\\) is found such that \\((i, j)\\) is not contained in any already found \\(c\\)-supermaximal edge (see 4.1.4). Indeed, since the increment on \\(j\\) at line 3, if such edge \\((i, j)\\) exists, then we have that \\(\\forall (p, q) \\in M_c\\) with \\(p < i, (i, j) \\in E_c\\). Moreover, if such edge \\((i, j)\\) exists, \\(i\\) is a \\(c\\)-starting point and a series of Weighted-Extend is executed looking for the corresponding \\(c\\)-ending point. After each Weighted-Extend positive answer, \\(j\\) is incremented by one. Once that Weighted-Extend outputs “no”, i.e. once that \\((i, j)\\) cannot be weighted-extended any more, \\((i, j)\\) is a \\(c\\)-supermaximal and it is inserted into \\(M_c\\) to be outputted later. The step of the algorithm ends when a \\(c\\)-supermaximal is found or when \\(w\\) is equal to the empty word. The algorithm runs as long as there are unseen characters, i.e. until \\(j\\) reaches \\(n\\).\n\nThe algorithm is stated more formally in Table 4.1.\n\n**Proposition 4.1.3.** Given a cost value \\(c\\), the Find Supermaximal algorithm correctly computes \\(M_c\\).\n\n**Proof.** First of all let us prove that if \\((i, j)\\) is inserted by the algorithm in \\(M_c\\) then \\((i, j)\\) is \\(c\\)-supermaximal.\n\nIf \\((i, j)\\) is inserted into \\(M_c\\) at line 11, then an edge \\((i, j')\\) at line 4 was previously proved to exist and to have cost \\(C((i, j')) \\leq c\\). It caused the termination of the loop at lines 4 – 6. For the line 7 we know that \\(i < j'\\) and by the loop 8 – 10 we know that all the edges \\((i, q)\\) with \\(j' \\leq q \\leq j\\) exist and they all are such that \\(C((i, q)) \\leq c\\). Therefore \\((i, j)\\) costs at most \\(c\\) and then the first part of the definition is verified. Since the Weighted-Extend\\(((i, j), c) = “no” at line 8, that was the exit condition of that loop,\nTable 4.1: The pseudocode of the \\textit{Find Supermaximal} algorithm. The function INSERT simply insert the edge \\((i, j)\\) in the dynamical set \\(M_c\\).\n\n\\[\n\\text{Find Supermaximal}(c) \\\\\n01. \\quad i \\leftarrow 0, j \\leftarrow 0, M_c \\leftarrow \\emptyset \\\\\n02. \\quad \\text{WHILE } j < n \\text{ DO} \\\\\n03. \\quad \\quad j \\leftarrow j + 1 \\\\\n04. \\quad \\quad \\text{WHILE } i < j \\text{ AND } \\text{Weighted-Exist}(i, j, c) = \\text{“no”} \\text{ DO} \\\\\n05. \\quad \\quad \\quad i \\leftarrow i + 1 \\\\\n06. \\quad \\quad \\text{ENDWHILE} \\\\\n07. \\quad \\text{IF } i < j \\text{ THEN} \\\\\n08. \\quad \\quad \\text{WHILE } \\text{Weighted-Extend}((i, j), c) = \\text{“yes”} \\text{ DO} \\\\\n09. \\quad \\quad \\quad j \\leftarrow j + 1 \\\\\n10. \\quad \\quad \\text{ENDWHILE} \\\\\n11. \\quad \\quad \\text{INSERT } ((i, j), M_c) \\\\\n12. \\quad \\text{ENDIF} \\\\\n13. \\quad \\text{ENDWHILE} \\\\\n14. \\quad \\text{RETURN } M_C\n\\]\n\nthen \\((i, j + 1) \\notin E_c\\). Since \\(D_i\\) is prefix closed and the cost function \\(C\\) is prefix-nondecreasing \\(\\forall q \\in V\\) with \\(j < q\\) the arc \\((i, q)\\) is not in \\(E_c\\), because otherwise \\((i, j + 1)\\) would be in \\(E_c\\).\n\nIt remains to prove that \\(\\forall p \\in V\\) with \\(p < i\\) the arc \\((p, j)\\) is not in \\(E_c\\). Suppose by contradiction that such arc \\((p, j)\\) exists in \\(E_c\\). Since the variables \\(i, j\\) never decrease along algorithm steps, the variable \\(i\\) reaches the value \\(p\\) before that \\((i, j)\\) is inserted in \\(M_c\\). Let \\(j_p\\) be the value of \\(j\\) when \\(i\\) reached the value \\(p\\). Since the variable \\(i\\) is increased only inside the loop at lines 4 – 6, we have that \\(p \\leq j_p\\). If \\(p = j_p\\) the algorithm terminates the current step by the conditions at lines 4 and 7 and it enters the next step with \\(j = j_p + 1\\) due to line 3. Therefore \\(j\\) will reach the value \\(j_p + 1\\) for \\(p = j_p\\) otherwise \\(j\\) will be equal to \\(j_p\\). In both cases, since \\(i < j\\), the condition at line 7 is satisfied and the loop 8 – 10 is reached. Since \\(D_p\\) is prefix closed and the cost function is prefix-nondecreasing then \\(\\forall q\\) such that \\(j \\leq q < j\\), \\(\\text{Weighted-Extend}((p, q)) = \\text{“yes”}\\). Then, the loop 8 – 10 increases the \\(j\\) up...\nto at least the value j, i.e. the algorithm reaches the line 11 with j ≤ j. At\nthis point, an edge (p, j) is inserted in Mc and the algorithm moves on the\nnext step. Since the increment of the variable j at line 3, we have that in the\nrest of the algorithm only edges where j is greater than j may be considered\nand then (i,j) will not be inserted. That is a contradiction. Therefore, if\n(i,j) is inserted by the algorithm in Mc then (i,j) is c-supermaximal.\n\nWe have now to prove that if (i,j) is c-supermaximal then it is inserted\nby the algorithm in Mc.\n\nSuppose that variable i never assumes the value i. The algorithm ends\nwhen variable j is equal to n. Let in be the value of variable i when j becomes\nn, then we have that in < i < j < n = j. If the variable j reaches the value\nn inside the loop 8–10 then the operation Weighted-Extend((in, n−1), c)\nhas outputted “yes” just before. At line 11 the edge (in, n) is inserted into\nMc and then (in,n) is c-supermaximal. This contradicts that (i,j) is c-\nsupermaximal. Otherwise, if the variable j reaches the value n at line 3,\nthen we have two cases. In the first one, Weighted-Exist(in, n, c) outputs\n“yes”, i.e. the edge (in, n) is in Ec. Since i = in < n = j line 7 condition\nis satisfied, Weighted-Extend((in, n), c) outputs “no” by definition and then\n(in, n) is in Mc, i.e. it is a c-supermaximal. That is a contradiction again.\nIn the second case, Weighted-Exist(in, n, c) outputs “no” one or multiple\ntimes while i grows up to a value i' < i by hypothesis. Using the same\nargumentation as before, (i', n) in Mc leads to a contradiction.\n\nTherefore at a certain moment variable i assumes the value i. Let ji be\nthe value of variable j in that moment. We suppose that ji ≤ j. Since the\ndictionary D1 is prefix closed and the cost function is prefix nondecreasing,\nWeighted-Exist(i, ji, c) outputs “yes” causing the exit from the loop at lines\n4–6. At this point, inside the loop 8–10, the variable j reaches the value\nj since Weighted-Extend((i, j), c) outputs “yes” for any j less than j, while\nWeighted-Extend((i, j), c) outputs “no”. Finally, (i,j) is inserted into Mc at\nline 11. Suppose by contradiction that j_i > j when i assumes the value i at\nline 5. This may happen only if the edge (i−1, j_i) has been inserted in Mc in\nthe previous step of the algorithm. Since i−1 < i < j < j_i this contradicts\nthe hypothesis that (i,j) is c-supermaximal.\n\n□\nProposition 4.1.4. For any edge \\((i, j) \\in E_c\\) there exists a c-supermaximal edge \\((\\hat{i}, \\hat{j})\\) containing it, i.e. such that \\(i \\leq \\hat{i}\\) and \\(j \\leq \\hat{j}\\).\n\nProof. We build \\((\\hat{i}, \\hat{j})\\) in algorithmic fashion. The algorithm is described in what follows in an informal but rigorous way. If edge \\((i, j)\\) is not c-supermaximal then we proceed with a round of \\(\\text{Weighted-Extend}((i, j), c)\\) analogously as described in algorithm \\(\\text{Find Supermaximal}\\) and we increase \\(j\\) of one unit until \\(\\text{Weighted-Extend}\\) outputs “no”. Let \\(j'\\) be the value of \\(j\\) for which \\(\\text{Weighted-Extend}\\) output “no”. Clearly \\((i, j)\\) is not c-supermaximal the only possibility is that there exists at least one \\(i_0 < i\\) such that \\((i_0, j) \\in E_c\\). At this point we keep iterating previous two steps starting from \\((i - 1, j)\\) instead of \\((i, j)\\) and we stop whenever we get a c-supermaximal edge, that we call \\((\\hat{i}, \\hat{j})\\).\n\nBy previous proposition, for any node \\(v \\in G_{A,T}\\) if there exists a node \\(i < v\\) such that \\(C((i, v)) = c\\) and \\(d(v) = d(i) + c\\) then there exists a c-supermaximal edge \\((i, j)\\) containing \\((i, v)\\) and such that \\(j\\) is the closest arrival point greater than \\(v\\). Let us call this c-supermaximal edge \\((i_v, j_v)\\). We use \\(i_v\\) in next proposition.\n\nProposition 4.1.5. Suppose that \\(v \\in G_{A,T}\\) is such that there exists a previous node \\(i\\) such that \\(C((i, v)) = c\\) and \\(d(v) = d(i) + c\\). Then \\(i_v\\) is a predecessor of \\(v\\), i.e. \\(d(v) = d(i_v) + C((i_v, v))\\) and, moreover, \\(d(i_v) = d(i)\\) and \\(C((i_v, v)) = c\\).\n\nProof. Since \\((i_v, j_v)\\) contains \\((i, v)\\) and the dictionary at position \\(i_v\\) is prefix closed then \\((i_v, v)\\) is an edge of \\(G_{A,T}\\). Since \\((i_v, j_v)\\) has cost smaller than or equal to \\(c\\) then, by the suffix-nonincreasing property, also \\((i_v, v)\\) has cost smaller than or equal to \\(c\\). Since the distance \\(d\\) is nondecreasing we know that \\(d(i_v) \\leq d(i)\\). By very definition of the distance \\(d\\) we know that \\(d(v) \\leq d(i_v) + C((i_v, v))\\).\n\nPutting all together we have that\n\n\\[\nd(v) \\leq d(i_v) + C((i_v, v)) \\leq d(i) + c = d(v).\n\\]\n\nHence the inequalities in previous equation must be equalities and, furthermore, \\(d(i_v) = d(i)\\) and \\(C((i_v, v)) = c\\).\nCorollary 4.1.6. For any vertex \\( v \\), the edge \\((i_v, v)\\) is the last edge of a path of minimal cost from the origin to vertex \\( v \\).\n\nProof. Any edge \\( x \\) in \\( G_{A,T} \\) such that \\( d(v) = d(x) + C((x, v)) \\) is the last edge of a path of minimal cost from the origin to vertex \\( v \\). \\( \\square \\)\n\nRemark 4.1. Let us notice that the variable \\( i \\) is increased only at line 05 along the Find Supermaximal algorithm.\n\n4.2 The Subgraph \\( G'_{A,T} \\)\n\nIn the following we describe a graph \\( G'_{A,T} \\) that is a subgraph of \\( G_{A,T} \\) and that is such that for any node \\( v \\in G_{A,T} \\) there exists a minimal path from the origin to \\( v \\) in \\( G'_{A,T} \\) that is also a minimal path from the origin to \\( v \\) in \\( G_{A,T} \\). The proof of this property, that will be stated in the subsequent proposition, is a consequence of Proposition 4.1.5 and Corollary 4.1.6.\n\nWe describe the building of \\( G'_{A,T} \\) in an algorithmic way.\n\nThe set of nodes of \\( G'_{A,T} \\) is the same of \\( G_{A,T} \\). First of all we insert all the symbolwise edges of \\( G_{A,T} \\) in \\( G'_{A,T} \\). Let now \\( C \\) be the set of all possible costs that any dictionary edge has. This set can be built starting from \\( G_{A,T} \\), but, in many meaningful cases, the set \\( C \\) is usually well known and can be ordered and stored in an array in a time that is linear in the size of the text.\n\nFor any \\( c \\in C \\) we use algorithm Find Supermaximal to obtain the set \\( M_c \\). Then, for any \\((i, j) \\in M_c \\), we insert in \\( G_{A,T} \\) all the prefix of \\((i, j)\\) except those which are contained in another \\( c \\)-supermaximal edge \\((i', j') \\in M_c \\). In detail, for any \\( c \\)-supermaximal edge \\((i, j) \\in M_c \\), let \\((i', j') \\in M_c \\) be the previous \\( c \\)-supermaximal edge overlapping \\((i, j)\\), i.e. \\( j' = \\max_{h \\in \\{i < h < j\\}} (i, h) \\in M_c \\).\n\nNotice that this \\( j' \\) could not exist but, if it exists then by Proposition 4.1.2 there exists a unique \\( i' \\) such that \\((i', j') \\in M_c \\). If \\((i', j') \\) exists, then we add in \\( G'_{A,T} \\) all the edges of the form \\((i, x)\\), where \\( j' < x \\leq j \\), with label \\( L_{(i,x)} = c \\). If \\((i', j') \\) does not exist, then we add in \\( G'_{A,T} \\) all the edges of the form \\((i, x)\\), where \\( i < x \\leq j \\), with label \\( L_{(i,x)} = c \\). In both cases, If such an edge \\((i, x)\\) is already in \\( G'_{A,T} \\), we just set the label \\( L_{(i,x)} \\) to \\( \\min \\{ L_{(i,x)}, c \\} \\).\n\nThis concludes the construction of \\( G'_{A,T} \\).\n\nThe algorithm Build \\( G'_{A,T} \\) is formally stated in the Table 4.2.\nTable 4.2: The pseudocode of the Build $G'_{A,T}$ algorithm.\n\nRemark 4.2. Notice that for any cost $c$ the above algorithm add in $G'_{A,T}$ at most a linear number of edges. For any node in $G'_{A,T}$ there is an incoming symbolwise edge and there also can be at most one incoming dictionary edge for any cost $c$.\n\nLet us notice that the graph $G'_{A,T}$ is a subgraph of $G_{A,T}$. Nodes and symbolwise edges are the same in both graphs by definition of $G'_{A,T}$. The edges $(i, x)$ we add to $G'_{A,T}$, are the prefix of a $c$-supermaximal edge $(i, j)$ of $G_{A,T}$. Since that the dictionary $D_i$ is prefix closed, then all the edges $(i, x)$ are also edges of $G_{A,T}$.\n**Proposition 4.2.1.** For any node \\( v \\in G_{A,T} \\), any minimal path from the origin to \\( v \\) in \\( G'_{A,T} \\) is also a minimal path from the origin to \\( v \\) in \\( G_{A,T} \\).\n\n**Proof.** The proof is by induction on \\( v \\). If \\( v \\) is the origin there is nothing to prove. Suppose now that \\( v \\) is greater than the origin and let \\((i, v)\\) be the last edge of a minimal path in \\( G_{A,T} \\) from the origin to \\( v \\). By inductive hypothesis there exists a minimal path \\( \\mathcal{P} \\) from the origin to \\( i \\) in \\( G'_{A,T} \\) that is also a minimal path from the origin to \\( i \\) in \\( G_{A,T} \\). If \\((i, v)\\) is a symbolwise arc then it is also in \\( G'_{A,T} \\) and the concatenation of above minimal path \\( \\mathcal{P} \\) with \\((i, v)\\) is a minimal path from the origin to \\( v \\) in \\( G'_{A,T} \\) that is also a minimal path from the origin to \\( v \\) in \\( G_{A,T} \\).\n\nSuppose now that \\((i, v)\\) is a dictionary arc and that its cost is \\( c \\). Since it is the last edge of a minimal path we have that \\( d(v) = d(i) + c \\). By Proposition 4.1.5 \\( d(v) = d(i_v) + C((i_v, v)) \\) and, moreover, \\( d(i_v) = d(i) \\) and \\( C((i_v, v)) = c \\). By Corollary 4.1.6, the edge \\((i_v, v)\\) is the last edge of a path of minimal cost from the origin to vertex \\( v \\). By inductive hypothesis there exists a minimal path \\( \\mathcal{P} \\) from the origin to \\( i_v \\) in \\( G'_{A,T} \\) that is also a minimal path from the origin to \\( i_v \\) in \\( G_{A,T} \\). Since \\((i_v, v)\\) has been added by construction in \\( G'_{A,T} \\), the concatenation of above minimal path \\( \\mathcal{P} \\) with \\((i_v, v)\\) is a minimal path from the origin to \\( v \\) in \\( G'_{A,T} \\) that is also a minimal path from the origin to \\( v \\) in \\( G_{A,T} \\). \\( \\square \\)\n\nLet us notice that it is possible to create the dictionary edges of \\( G'_{A,T} \\) without an explicit representation in memory of all the \\( M_c \\) arrays. This is just an implementation detail that enhances speed and the usage of memory of the Build \\( G'_{A,T} \\) algorithm in practice, without changing its order of complexity. The point is that we can insert the \\( c \\)-supermaximal edges and their prefix directly in the graph as soon as they are found along a Find Supermaximal execution. The correctness of this approach is a direct consequence of the following remark.\n\n**Remark 4.3.** Given a cost \\( c \\), the edges \\((i, x)\\) used by the Build \\( G'_{A,T} \\) algorithm inside the block at lines 10 – 20 are those which the Weighted-Extend and the Weighted-Exist operations of the Find Supermaximal\\((c)\\) algorithm report a positive answer for.\n4.3 The Dictionary-Symbolwise Flexible Parsing\n\nWe can now finally describe the Dictionary-symbolwise flexible parsing. The Dictionary-symbolwise flexible parsing algorithm firstly uses the algorithm Build $G'_{A,T}$ and then uses the classical Single Source Shortest Path (SSSP) algorithm (see [6, Ch. 24.2]) to recover a minimal path from the origin to the end of graph $G_{A,T}$. The correctness of the above algorithm is stated in the following theorem and it follows from the above description and from Proposition 4.2.1.\n\n**Theorem 4.3.1.** Dictionary-symbolwise flexible parsing is graph optimal.\n\nNotice that graphs $G_{A,T}$ and $G'_{A,T}$ are directed acyclic graphs (DAG) and their nodes from 1 to $n$, where 1 is the origin or the unique source of the graph and $n = |T|$ is the last node, are topologically ordered and linked by symbolwise edges. Recall that, given a node $v$ in a weighted DAG, the classic solution to the SSSP is composed by two steps. The first one computes the distance and a predecessor of any node in the graph. It is accomplished by performing a visit on all the nodes in topological order and making a relax on any outgoing edge. Therefore, for any node $v$ from 1 to $n$ and for any edge $(v, v')$ in the graph, the relax of $(v, v')$ sets the distance and the predecessor of $v'$ to $v$ if $d(v) + C((v, v')) < d(v')$. The classic algorithm uses two arrays, $\\pi[]$ and $p[]$, to store distance and predecessor of nodes. The second step recovers the shortest path by following backward the predecessors chain from the last node to the origin of the graph and reverting it. From this simple analysis it follows that if we know all the outgoing edges of any node in topological order then we can do directly the relax operation on them without having an explicit representation of the graph.\n\nLet us suppose to have an online version of the Build $G'_{A,T}$ algorithm, where for any $i$ from 1 to $|T|$, only edges $(i, j)$ are created on the graph. We want now to merge the online Build $G'_{A,T}$ algorithm to the relax step of the SSSP algorithm. We maintain the two arrays $\\pi[]$ and $p[]$ of linear size w.r.t. the text size, containing the distance and the predecessor of any node and we replace any edge creation or label updating with the relax operation.\n\nAbout the online version of the Build $G'_{A,T}$, we can use the Remark 4.1 to make a kind of parallel run of the Find Supermaximal algorithm.\nfor any cost $c$, maintaining the variables $i$ synchronized on the same value. Moreover, we use the Remark 4.3 to directly handle the edge creation as soon as they are found. We address all of these variations to the Build $G'_{A,T}$, the Find Supermaximal as well as the merge with the SSSP algorithm in order to obtain the Dictionary-Symbolwise Flexible Parsing algorithm. The pseudocode of the Dictionary-Symbolwise Flexible Parsing algorithm is reported in Table 4.3.\n\nLet us notice that above algorithm uses only one dictionary at one time and it never needs to use previous version of the dynamic dictionary. Recall that the dictionary is used by the Weighted-Exist and the Weighted-Extend operations. This is a direct consequence of the fact that any edge $(i, j)$ refers to the dictionary $D_i$ and that after edge $(i, j)$ creation, only edge $(p, q)$ with $p \\geq i$ can be created.\n\n**Proposition 4.3.2.** Any practical implementations of the Dictionary-symbolwise flexible parsing does not require to explicitly represent the graph $G'_{A,T}$ regardless of its size. Since $G'_{A,T}$ nodes are visited in topological order by classic SSSP solutions, the algorithm needs to maintain just two linear size arrays, i.e. the array of node distances and the array of node predecessors, in order to correctly compute an optimal parsing.\n\nLet us summarize the Dictionary-Symbolwise Flexible Parsing algorithm requirements. Given a text $T$ of size $n$ the Dictionary-Symbolwise Flexible Parsing algorithm uses\n\n- $O(n)$ space for the $\\pi[]$ and $p[]$ arrays, regardless of the graph $G'_{A,T}$ size that is not really built, plus the dictionary structure.\n- $O(|E|)$ time to analyze all the edges of the graph $G'_{A,T}$.\n- it is not online because the backward recovering of the parsing from the $p[]$ array.\n\nWith respect to the original Flexible Parsing algorithm we gain the fact that it can work with variable costs of pointers and that it is extended to the dictionary-symbolwise case. This covers for instance the LZW-like and\nDictionary-Symbolwise Flexible Parsing\n\n01. FOR $i$ FROM 0 TO $|T| - 1$\n02. \n Relax $(i, i + 1, C((i, i + 1)))$\n03. \n FOR ANY $c \\in C$\n04. \n IF $i = j_c$ THEN\n05. \n $j_c \\leftarrow 1 + j_c$\n06. \n ENDIF\n07. \n IF $j_c \\leq |T|$ AND Weighted-Exist $(i, j_c, c) = \\text{“yes”}$ THEN\n08. \n Relax $(i, j_c, C((i, j_c)))$\n09. \n WHILE Weighted-Extend $((i, j), c) = \\text{“yes”}$ DO\n10. \n $j_c \\leftarrow 1 + j_c$\n11. \n Relax $(i, j_c, C((i, j_c)))$\n12. \n ENDWHILE\n13. \n $j_c \\leftarrow 1 + j_c$\n14. \n ENDIF\n15. \nENDFOR\n16. \nENDFOR\n17. \nRETURN Reverse $(v)$\n\nRelax$(u, v, c)$\n\n01. \n IF $\\pi[u] + c < \\pi[v]$ THEN\n02. \n $\\pi[v] \\leftarrow \\pi[u] + c$\n03. \n $p[v] \\leftarrow u$\n04. \n ENDIF\n\nReverse$(v)$\n\n01. \n IF $v > 0$ THEN\n02. \n Reverse $(p[v])$\n03. \n ENDIF\n04. \nRETURN $v$\n\nTable 4.3: The pseudocode of Dictionary-Symbolwise Flexible Parsing algorithm, the Relax and the Reverse procedures. The distance array $\\pi[]$ and the predecessor array $p[]$ are initialized to 0. Notice that the algorithm uses a different $j_c$ variable for any $c$ value.\nthe LZ77-like cases. But we lose the fact that the original one was “online”. A minimal path has to be recovered, starting from the end of the graph backward. But this is an intrinsic problem that cannot be eliminated. Even if the dictionary edges have just one possible cost, in the dictionary-symbolwise case it is possible that any minimal path for a text $T$ is totally different from any minimal path for the text $Ta$, that is the previous text $T$ concatenated to the symbol $a$. The same can happen when we have a (pure) dictionary case with variable costs of dictionary pointers. In both cases, for this reason, it is unlikely that there exists an “on-line” optimal parsing algorithm, and, indeed, the original flexible parsing fails being optimal in the dictionary case when costs are variable.\n\nOn the other hand our algorithm is suitable when the text is divided in several contiguous blocks and, therefore, in practice there is not the need to process the whole text but it suffices to end the current block in order to have the optimal parsing (relating to that block).\n\n4.4 Time and Space Analyses\n\nIn this section we analyze the Dictionary-symbolwise flexible parsing in both LZ78 and LZ77-like algorithm versions.\n\nLZ78 Case\n\nConcerning LZ78-like algorithms, the dictionary is prefix closed and it is implemented by using the LZW variant. We do not enter into the details of this technique. We just recall that the cost of pointers increases by one unit whenever the dictionary size is “close” to a power of 2. The moment when the cost of pointers increases is clear to both encoder and decoder. In our dictionary-symbolwise setting, we suppose that the flag information has a constant cost. We assume therefore that it takes $O(1)$ time to determine the cost of a dictionary edge.\n\nThe maximal cost that a pointer can assume is smaller than $\\log_2(n)$ where $n$ is the text size. Therefore the set $C$ of all possible costs of dictionary edges has a logarithmic size and it is cheap to calculate.\nIn [27] the operations \\textit{Extend} and \\textit{Contract} are presented. It is also presented a linear size data structure called trie-reverse-trie-pair that allows to execute both those operations in \\(O(1)\\) time. The operation \\textit{Extend}(\\(w, a\\)) says whether the phrase \\(wa\\) is in the currently used dictionary. The operation \\textit{Contract}(\\(w\\)) says whether the phrase \\(w[2:|w|]\\) is in the current dictionary.\n\nSince at any position we can calculate in \\(O(1)\\) time the cost of an edge, we can use the same data structure to perform our operations of \\textit{Weighted-Extend} and of \\textit{Weighted-Exist} in constant time as follows. In order to perform a \\textit{Weighted-Extend}((\\(i, j\\)),\\(c\\)) we simply execute the operation \\textit{Extend}(\\(w, a_{j+1}\\)) with \\(w = T[i+1:j]\\), i.e. the phrase associated to the edge \\((i, j)\\), and then, if the answer is “yes”, we perform a further check in \\(O(1)\\) time on the cost of the found edge \\((i, j+1)\\). Therefore, \\textit{Weighted-Extend}((\\(i, j\\),\\(c\\)) is equal to \\textit{Extend}(\\(T[i+1:j]\\),\\(a_{j+1}\\)) AND \\(C((i, j+1)) \\leq c\\).\n\nIn order to perform a \\textit{Weighted-Exist}((\\(i, j\\),\\(c\\)) simply use the \\textit{contract} on the phrase \\(a_iw\\), where \\(w = T[i+1:j]\\), and, if the answer is “yes” we perform a further check in \\(O(1)\\) time on the cost of the found edge \\((i, j)\\). Therefore, \\textit{Weighted-Exist}((\\(i, j\\),\\(c\\)) is equal to \\textit{Contract}(\\(a_iT[i+1:j]\\)) AND \\(C((i, j)) \\leq c\\).\n\nAt first glance, the algorithm \\textbf{Build} \\(G_{A,T}'\\) seems to take \\(O(n \\log n)\\) time. But, since there is only one active cost at any position in any LZW-like algorithms, then if \\(c < c'\\) then \\(M_c \\subset M_{c'}\\), as stated in the following proposition.\n\n\\textbf{Definition 4.5.} We say that a cost function \\(C\\) is \\textit{LZW-like} if for any \\(i\\) the cost of all dictionary pointers in \\(D_i\\) is a constant \\(c_i\\) and that for any \\(i\\), \\(0 \\leq i < n\\) one has that \\(c_i \\leq c_{i+1}\\).\n\n\\textbf{Proposition 4.4.1.} If the cost function \\(C\\) is \\textit{LZW-like}, one has that if \\(c < c'\\) then \\(M_c \\subseteq M_{c'}\\).\n\n\\textit{Proof.} We have to prove that for any \\((i, j) \\in M_c\\) then \\((i, j) \\in M_{c'}\\). Clearly if \\((i, j) \\in M_c\\) then its cost is smaller than or equal to \\(c < c'\\). It remains to prove that \\((i, j)\\) is \\(c'\\)-supermaximal, e.g. that \\(\\forall p, q \\in V,\\) with \\(p < i\\) and \\(j < q,\\) the arcs \\((p, j), (i, q)\\) are not in \\(E_{c'}\\). Since \\((i, j) \\in M_c\\) and since the cost of \\((i, j)\\) is by hypothesis equal to \\(c_i\\), we have that \\(c_i \\leq c\\). If arc \\((p, j)\\) is in\n$E_{c'}$ then its cost is $c_p \\leq c_i \\leq c$ and therefore it is also in $E_c$ contradicting the $c$-supermaximality of $(i, j)$. If arc $(i, q)$ is in $E_{c'}$ then its cost is $c_i \\leq c$ and therefore it is also in $E_c$ contradicting the $c$-supermaximality of $(i, j)$. \\hfill \\Box\n\nAt this point, in order to build $G'_{A,T}$ we proceed in an incremental way. We build $M_c$ for the smallest cost. Then, we start from the last built $M_c$ to build $M_{c'}$, where $c'$ is the smallest cost grater than $c$. And so on until all the costs are examined. We insert any edge $(i, j)$ only in the set $M_c$ where $c$ is the real cost of the $(i, j)$ edge. In this way, we avoid to insert the same edge $(i, j)$ in more than one $M_c$ since that the algorithm will insert eventually the edge $(i, j)$ from the set $M_c$ with the minimal cost $c = C((i, j))$. A direct consequence of above approach, we have that only a linear number of edges are inserted in the graph $G'_{A,T}$.\n\nThe overall time for building $G'_{A,T}$ is therefore linear, as well as its size. The Single Source Shortest Path over $G'_{A,T}$, that is a DAG topologically ordered, takes linear time (see [6, Ch. 24.2]).\n\nIn conclusion we state the following proposition.\n\n**Proposition 4.4.2.** Suppose that we have a dictionary-symbolwise scheme, where the dictionary is LZ78-like and the cost function is LZW-like. The symbolwise compressor is supposed to be, as usual, linear time. Using the trie-reverse-trie-pair data structure, Dictionary-Symbolwise flexible parsing is linear.\n\n**LZ77 Case**\n\nConcerning LZ77, since the dictionary has the weak prefix-closed property, i.e. the dictionary is always prefix closed, we have that the Dictionary-Symbolwise Flexible Parsing is an optimal parsing. We exploit the discreteness of the cost function $C$ when it is associated to the length of the codewords of a variable-length code, like Elias codes or a Huffman code, to bound the cardinality of the set $C$ to $O(log n)$. Indeed let us call $\\hat{c}$ the maximum cost of any dictionary pointer, i.e. the length in bits of the pointer with the maximum possible offset and the maximum possible length.\n\nEven if the cost actually depends on the text $T$, it usually has an upper\nbound that depends on the encoding and on the dictionary constrains and we can assume it being \\( \\hat{c} = O(\\log n) \\), with \\( |T| = n \\).\n\nOperations \\textit{Weighted-Exist} and \\textit{Weighted-Extend} can be implemented in linear space and constant time by using classical suffix tree or other solutions when the dictionary is a LZ77-like one. For instance, in [10] it is shown how to compute the Longest Previous Factor (LPF) array in linear time. Recall that \\( T[i : LPF[i]] \\) is the longest factor already seen in the text at some position \\( i' < i \\). It is easy to see that following relations hold. The operation \\textit{Weighted-Exist} \\((i, j, c)\\) outputs “yes” \\( \\iff j \\leq i + LPF[i] \\) AND \\( C((i, j)) \\leq c \\) and the operation \\textit{Weighted-Extend} \\(((i, j), c)\\) outputs “yes” \\( \\iff j < i + LPF[i] \\) AND \\( C((i, j + 1)) \\leq c \\). We recall that we are also assuming that it is possible to compute the cost of a given edge in constant time. Therefore, we use linear time and space to build the LPF array and then any operation \\textit{Weighted-Exist} or \\textit{Weighted-Extend} take just constant time.\n\nSuppose to have a dictionary-symbolwise scheme, where the dictionary is LZ77-like and the dictionary pointer encoding, the symbolwise encoding and the flag information encoding are any variable-length encoding one. The use of the codeword length as cost function leads to a function that assumes integer values. Given \\( \\hat{c} \\) the maximum cost of any dictionary pointer with \\( \\hat{c} \\leq \\log(n) \\), the Dictionary-Symbolwise Flexible Parsing runs in \\( O(n \\log n) \\) time and space.\n\nLet us notice that in most of the common LZ77 dictionary implementation, as it is in the \\textit{deflate} compression tool, our assumption about the computation of edge cost in \\( O(1) \\) time is not trivial to obtain.\n\nObviously, we are interested, for compression purpose, to the smallest cost between all the possible encoding of a phrase. For instance, the use of the length-distance pair as dictionary pointer leads to multiple representation of the same (dictionary) phrase since this phrase can occur more then once in the (already seen) text.\n\nSince the closest occurrence uses the smallest distance to be represented, the cost of encoding the phrase using this distance is usually the smallest one, accordingly to the used encoding method.\nA practical approach that looks for the above smallest distance makes use of hash tables, built on fixed length phrases.\n\nA new data structure able to answer to the edge cost query in constant time and able to support the *Weighted-Exist* and the *Weighted-Extend* operation in the case of LZ-77 dictionaries will be introduced in next chapter.\nChapter 5\n\nThe Multilayer Suffix Tree\n\nWe introduce here an online full-text index data structure that is able to find the rightmost occurrence of any factor or an occurrence which bit representation has equal length (Query 1). It has linear space complexity and it is built in $O(n \\log n)$ amortized time, where $n$ is the size of the text. It is able to answer to the Query 1, given a pattern $w$, in $O(|w| \\log \\log n)$. Furthermore, we will show how to use this structure to support the Weighted-Exist and the Weighted-Extend operations used by the Dictionary-Symbolwise Flexible Parsing algorithm in $O(1)$ amortized time.\n\n5.1 Preliminary Definitions\n\nLet $Pos(w) \\subset \\mathbb{N}$ the set of all the occurrences of $w \\in \\text{Fact}(T)$ in the text $T \\in \\Sigma^*$, where $\\text{Fact}(T)$ is the set of the factors of $T$. Let $\\text{Offset}(w) \\subset \\mathbb{N}$ the set of all the occurrence offsets of $w \\in \\text{Fact}(T)$ in the text $T$, i.e. $x \\in \\text{Offset}(w)$ iff $x$ is the distance between the position of an occurrence of $w$ and the end of the text $T$. For instance, given the text $T = babcabbababb$ of length $|T| = 12$ and the factor $w = abb$ of length $|w| = 3$, the set of positions of $w$ over $T$ is $Pos(w) = \\{4, 9\\}$. The set of the offsets of $w$ over $T$ is $\\text{Offset}(w) = \\{7, 2\\}$. Notice that $x \\in \\text{Offset}(w)$ iff exists $y \\in Pos(w)$ such that $x = |T| - y - 1$. Since the offsets are function of occurrence positions, there is a bijection between $Pos(w)$ and $\\text{Offset}(w)$, for any factor $w$.\n\nGiven a number encoding method, let $\\text{Bitlen} : \\mathbb{N} \\to \\mathbb{N}$ a function that\nassociates to a number $x$ the length in bits of the encoding of $x$. Let us consider the equivalence relation having equal codeword bit-length on the set $Offset(w)$. The numbers $x, y \\in Offset(w)$ are bit-length equivalent iff $Bitlen(x) = Bitlen(y)$. Let us notice that the having equal codeword bit-length relation induces a partition on $Offset(w)$.\n\n**Definition 5.1.** The *rightmost* occurrence of $w$ over $T$ is the offset of the occurrence of $w$ that appears closest to the end of the text, if $w$ appears at least once over $T$, otherwise it is not defined.\n\nNotice that for any factor $w \\in Fact(T)$, the rightmost offset of $w$ is defined as follows.\n\n$$rightmost(w) = \\begin{cases} \n\\min\\{x \\mid x \\in Offset(w)\\} & \\text{if } Offset(w) \\neq \\emptyset \\\\\n\\text{not defined} & \\text{if } Offset(w) = \\emptyset\n\\end{cases}$$\n\nLet us notice that referring to the rightmost occurrence of a factor in an *online* algorithmic fashion, where the input text is processed left to right, corresponds to referring to the rightmost occurrence over the text *already processed*. Indeed, if at a certain algorithm step we have processed the first $i$ symbols of the text, the rightmost occurrence of $w$ is the occurrence of $w$ closest to the position $i$ of the text reading left to right.\n\n**Definition 5.2.** Let $rightmost_{i}(w)$ be the rightmost occurrence of $w$ over $T_i$, where $T_i$ is the prefix of the text $T$ ending at the position $i$ in $T$. Obviously, $rightmost_{n}(w) = rightmost(w)$ for $|T| = n$.\n\nIn many practical algorithms, like in the data compression field, the text we are able to refer to is just a portion of the whole text. Let $T[j : i]$ be the factor of the text $T$ starting from the position $j$ and ending to the position $i$. We generalize the definition of $rightmost(w)$ over a factor $T[j : i]$ of $T$ as follows.\n\n**Definition 5.3.** Let $rightmost_{j,i}(w)$ be the rightmost occurrence of $w$ over $T[j : i]$, where $T[j : i]$ is the factor of the text $T$ starting at the position $j$ and ending at the position $i$ of length $i - j + 1$. Obviously, $rightmost_{1,n}(w) = rightmost(w)$ for $|T| = n$. \n\n68\nThe online full-text index we are going to introduce is able to answer to the \\textit{rightmost equivalent length} query in constant time, also referred hereby as \\textit{Query 1}. The Query 1 is more formally stated as below.\n\n\\textbf{Definition 5.4. (Query 1)} Let us suppose that we have a text $T \\in \\Sigma^*$, a pattern $w \\in \\Sigma^*$ and a point $i$ in time. Assume that the prefix $T_i$ of the text has been read. If $w$ appears at least once in $T_i$, then the \\textit{rightmost equivalent length} query provides an occurrence of $w$ which offset is in $[\\text{rightmost}_i(w)]$, where $[\\text{rightmost}_i(w)]$ is the equivalence class induced by the relation \\textit{having equal codeword bit-length} containing $\\text{rightmost}_i(w)$. Otherwise the \\textit{rightmost equivalent length} query provides the value nil.\n\n\\section{5.2 The Data Structure}\n\nThere are many classic full-text index able to represent the set $\\text{Fact}(T[1 : i])$, like the suffix tree, the suffix array, the suffix automaton and others. Many of them can easily be preprocessed in the \\textit{offline} fashion to make them able to find efficiently the rightmost occurrence of any factor over the whole text, but none of them can directly answer to the above Query 1.\n\nThe main idea of this new data structure, is based on two observations. The first one is that the equivalence relation \\textit{having equal codeword bit-length} that induces a partition on $\\text{Offset}(w)$, for any $w$, also induces a partition on the set of all the possible offsets over a text $T$ independently of a specific factor, i.e. on the set $[1..|T|]$. The second observation is that for any encoding method for which the $\\text{Bitlen}$ function is a monotonic function, each equivalence class in $[1..|T|]$ is composed by contiguous points in $[1..|T|]$. Indeed, given a point $p \\in [1..|T|]$, the equivalence class $[p]$ is equal to the set $[j..i]$, with $j \\leq p \\leq i$, $j = \\min\\{x \\in [p]\\}$ and $i = \\max\\{x \\in [p]\\}$.\n\nPutting these observations all together suggests that the Query 1 can be addressed by a set of classic full text indexes, each one devoted to one or more classes of equivalence of the relation \\textit{having equal code bit-length}.\n\nFixed an encoding method for numbers and a text $T$, we assume that $\\text{Bitlen}$ is a monotonic function and that we know the set $B = \\{b_1, b_2, \\ldots, b_s\\}$, with $b_1 < b_2 < \\cdots < b_s$, that is the set of the $\\text{Bitlen}$ values of all the\npossible offsets over $T$. We define the set $SW = \\{sw_1, sw_2, \\ldots, sw_s\\}$, with $sw_1 < sw_2 < \\cdots < sw_s$, where $sw_i$ is the greatest integer (smaller than or equal to the length of the text $T$) such that $\\text{Bitlen}(j)$ is less than or equal to $b_i$. More formally, $sw_i = \\max\\{j \\leq |T| \\mid \\text{Bitlen}(j) \\leq b_i\\}$. Notice that $sw_s = |T|$.\n\nAll the known standard non-unary representation of numbers satisfy the following property.\n\n**Property 5.1.** There exists a constant $k > 1$ and an integer $\\hat{k}$ such that for any $\\hat{k} \\leq i < s$ one has $sw_i \\geq k sw_{i-1}$\n\n**Remark 5.1.** A similar result can be stated about the lengths. Let $B' = \\{b'_1, b'_2, \\ldots, b'_j\\}$, with $b'_1 < b'_2 < \\cdots < b'_j$, that is the set of the $\\text{Bitlen}$ values of all the possible lengths over $T$. Notice that if we use the same encoding for the lengths and the offsets then $B' = B$ and $j = s$. Analogously we can define the set $SW'$. In what follows within this thesis we will use the same encoding for the lengths and the offsets and therefore the set $SW'$ is equal to $SW$ and previous property holds for the lengths too with the same constants $\\hat{k}$ and $k$.\n\nLet us consider an example.\n\nThe Table 5.1 reports the Elias $\\gamma$ codes and the $\\text{Bitlen}$ values for integers from 1 to 18. Suppose, for instance, that our cost function is associated to this Elias codes and that we have a text $T$ of length 18. The set $B$ therefore is $B = \\{b_1 = 1, b_2 = 3, b_3 = 5, b_4 = 7, b_5 = 9\\}$ and we have that $sw_1 = 1$, $sw_2 = 3$, $sw_3 = 7$, $sw_4 = 15$ and $sw_5 = 18$. Notice that, indeed, Property 5.1 is satisfied for $\\hat{k} = 2$ and $k = 2$.\n\nLet us now introduce the Multilayer Suffix Tree data structure.\n\nWe suppose that a text $T$ is provided online and at time $i$ the first $i$ characters of $T$ have been read, i.e. at time $i$ the prefix $T_i$ of length $i$ of the text $T$ has been read.\n\n**Definition 5.5.** The Multilayer Suffix Tree is a data structure composed by the set $S = \\{S_{sw_1}, S_{sw_2}, \\ldots, S_{sw_s}\\}$ of suffix trees where, for any $\\alpha \\in SW$ and at any moment $i$, $S_\\alpha$ is the suffix tree for sliding window of $T_i$ with sliding\nTable 5.1: Elias $\\gamma$ code for integers from 1 to 18 and their $Bitlen$ value.\n\n<table>\n<thead>\n<tr>\n<th>$i$</th>\n<th>$\\gamma(i)$</th>\n<th>$Bitlen(\\gamma(i))$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>010</td>\n<td>3</td>\n</tr>\n<tr>\n<td>3</td>\n<td>011</td>\n<td>3</td>\n</tr>\n<tr>\n<td>4</td>\n<td>00100</td>\n<td>5</td>\n</tr>\n<tr>\n<td>5</td>\n<td>00101</td>\n<td>5</td>\n</tr>\n<tr>\n<td>6</td>\n<td>00110</td>\n<td>5</td>\n</tr>\n<tr>\n<td>7</td>\n<td>00111</td>\n<td>5</td>\n</tr>\n<tr>\n<td>8</td>\n<td>0001000</td>\n<td>7</td>\n</tr>\n<tr>\n<td>9</td>\n<td>0001001</td>\n<td>7</td>\n</tr>\n<tr>\n<td>10</td>\n<td>0001010</td>\n<td>7</td>\n</tr>\n<tr>\n<td>11</td>\n<td>0001011</td>\n<td>7</td>\n</tr>\n<tr>\n<td>12</td>\n<td>0001100</td>\n<td>7</td>\n</tr>\n<tr>\n<td>13</td>\n<td>0001101</td>\n<td>7</td>\n</tr>\n<tr>\n<td>14</td>\n<td>0001110</td>\n<td>7</td>\n</tr>\n<tr>\n<td>15</td>\n<td>0001111</td>\n<td>7</td>\n</tr>\n<tr>\n<td>16</td>\n<td>000010000</td>\n<td>9</td>\n</tr>\n<tr>\n<td>17</td>\n<td>000010001</td>\n<td>9</td>\n</tr>\n<tr>\n<td>18</td>\n<td>000010010</td>\n<td>9</td>\n</tr>\n</tbody>\n</table>\n\nwindow of size $\\alpha$ such that $S_\\alpha$ represents all the factors of $T[i - \\alpha : i]$. We call $S_\\alpha$ simply the layer $\\alpha$ or the layer of size $\\alpha$.\n\nFrom now on we will refer to suffix trees or layers indifferently.\n\nWe use a online suffix tree for sliding window introduced by Larson in [26] and later refined by Senft in [34], in order to represent each layer of our multilayer suffix tree. Therefore, for any $S_\\alpha \\in S = \\{S_{sw_1}, S_{sw_2}, \\ldots, S_{sw_s}\\}$, $S_\\alpha$ is a full-text index for $T[i - \\alpha : i]$, where $T$ is a given text and $i$ is a point in time.\n\nWe think that it is possible to adapt our data structure to work with other classic indexes for sliding window (see for instance [22, 29, 35]).\n\nLet us recall that in [26] an online and linear time construction for the\nThe suffix tree is reported. The suffix tree uses linear space w.r.t. the text size, i.e. $S_\\alpha$ uses $O(\\alpha)$ space. Moreover, any common full-text index allows to find an occurrence of a given pattern in constant time, but cannot be directly used to answer to the Query 1.\n\n**Proposition 5.2.1.** 1. If a pattern $w$ is in layer $\\alpha$ with $\\alpha \\in SW$, then $w$ is also in layer $\\beta$ for any $\\beta \\in SW$ with $\\alpha \\leq \\beta$. 2. If a pattern $w$ is not in a layer $\\alpha$, $\\alpha \\in SW$, then $w$ is not in layer $\\beta$ with $\\beta \\leq \\alpha$.\n\nProof. The proof of the property at point 1 comes immediately from suffix trees properties. Since layer $\\alpha$ is a full text index for $T[i-\\alpha : i]$ and layer $\\beta$ is a full-text index for $T[i-\\beta : i]$, for any $\\alpha, \\beta \\in SW$ with $\\alpha \\leq \\beta$ and for any $i$, $T[i-\\alpha : i]$ is a suffix of $T[i-\\beta : i]$. The property at point 2 can be deduced by point 1. $\\square$\n\n**Proposition 5.2.2.** Fixed a text $T$ of size $|T| = n$, at any moment $i$ with $0 \\leq i \\leq n$ and for any standard variable-length code, the multilayer suffix tree uses $O(i)$ space.\n\nProof. Since at time $i$ the maximum offset of all the occurrences in the text $T_i$ is $O(i)$, for any standard variable-length code the maximum value of the set $SW$ is $O(i)$. Since Property 5.1 holds for the set $SW$ and since the multilayer suffix tree space is equal to the sum of the space of its layers, as an immediate consequence we have that space used by the multilayer suffix tree is $\\sum_{\\alpha \\in SW} \\alpha = O(i)$. $\\square$\n\nFrom the linear time of the online construction of the suffix tree for sliding window and since the number of layers is $|SW| = O(\\log |T|)$, we can immediately state the following proposition.\n\n**Proposition 5.2.3.** Given a text $T$ of length $|T| = n$, for any standard variable-length code, it is possible to build online the multilayer suffix tree in $O(n \\log n)$ amortized time.\nFigure 5.1: The Multilayer Suffix Tree for the text $T = \\text{ababaa}$ and for the Elias $\\gamma$-code, where $B = \\{1, 3, 5\\}$, $SW = \\{1, 3, 6\\}$. The solid edges are regular ones and the dashed links are the suffix-links of internal nodes. For convenience, we added edge labels with the substring of $T$ associated to edges. The node value is the position over the text of the incoming edge. We omitted the string depth of nodes. Let consider, for instance, the phrase $w = \\text{\"ba\"}$ with $\\text{Pos}(w) = \\{1, 3\\}$, $\\text{Offset}(w) = \\{4, 2\\}$, $\\text{rightmost}(w) = 2$ and $\\gamma(2) = 010$. Since $w$ is in layer $sw_2 = 3$ and is not in layer $sw_1 = 1$, we have that $\\text{Bitlen(rightmost}(w)) = 3$ is equal to $\\text{Bitlen}(sw_2 = 3) = b_2 = 3$.\n\n5.3 On the Query 1\n\nWe want now to show how to answer to the Query 1 for a given pattern in $O(|\\text{pattern}| \\log \\log n)$, with $n$ equal to the length of the text.\n\n**Proposition 5.3.1.** If a pattern $w$ is in layer $\\beta$ and is not in layer $\\alpha$, where $\\alpha$ is the maximum of the values in $SW$ smaller than $\\beta$, then any occurrence of $w$ in the layer $\\beta$ correctly answer to the Query 1.\n\n**Proof.** If a pattern $w$ is in layer $\\beta$ and is not in layer $\\alpha$, where $\\alpha$ is the\nmaximum of the values in $SW$ smaller than $\\beta$, then from Prop. 5.2.1, it follows that $\\beta$ is the smallest layer where it appears $w$. Therefore $w$ has at least one occurrence in $T[i - \\beta : i - \\alpha - 1]$, i.e. $\\text{rightmost}_i(w) \\in (\\alpha..\\beta)$.\n\nSince $(\\alpha..\\beta)$ is the equivalence class $[\\beta]$ of the having equal codeword bit-length relation, we have that any occurrence of $w$ in the layer $\\beta$ correctly answer to the Query 1. $\\square$\n\n\\textbf{Remark 5.2.} Let us notice that if $S_{sw_x}$ is the smallest layer where $\\text{rightmost}_i(w)$ appears, then the Bitlen value of the offset of $\\text{rightmost}_i(w)$ is equal to $b_x$.\n\n\\begin{itemize}\n\\item Using above proposition, we are able to answer to the Query 1 once we find the smallest layer containing the rightmost occurrence of the pattern, if any, otherwise we just report nil.\n\\item What follows is the trivial search of the smallest layer that contains an occurrence of a given pattern.\n\\item Given a pattern $w$ at time $i$, we look for $w$ in the layer $sw_1$, i.e. the smallest layer. If $w$ is in $S_{sw_1}$, then all the occurrences of $w$ in $T[i - sw_1 : i]$ belong to the class of the rightmost occurrence of $w$ over $T$. If $w$ is not in $S_{sw_1}$, then we look for any occurrence of $w$ is in $S_{sw_2}$, the next layer in increasing order. If $w$ is in $S_{sw_2}$, since it is not in $S_{sw_1}$, for the Prop. 5.3.1, any occurrence of $w$ in this layer belong to the rightmost occurrence of $w$ over $T_i$. Continuing in this way, as soon as we found an occurrence of $w$ in a layer, this occurrence correctly answer to the Query 1.\n\\end{itemize}\n\n\\textbf{Proposition 5.3.2.} Using the trivial search of a given pattern in the layers on the multilayer suffix tree we are able to answer to the Query 1 in time proportional to the pattern size times the cardinality of the set $SW$.\n\nSince many of the classic variable-length codes for integers, like the Elias’s $\\gamma$-codes, produce codewords of length proportional to the logarithm of the represented value, we can assume that the cardinality of $SW$ is $O(\\log |T|)$. Since that $|T_i| = i$, in the online fashion, we have that above proposition becomes as follows.\n\n\\textbf{Proposition 5.3.3.} Using any classic variable-length code method, the above data structure is able to answer to the Query 1 in $O(|\\text{pattern}| \\log i)$ time.\nA similar result can be obtained by using a variant of the Amir et al. algorithm presented [1], but it does not support \\textit{Weighted-Exist} and \\textit{Weighted-Extend} operations in constant time.\n\nSince Prop. 5.2.1 holds for the layers of our data structure, we can use the binary search to find the smallest layer containing a given pattern. Since for any classic variable-length code $|SW| = O(\\log i)$, the number of layers in our structure is $O(\\log i)$ and the proof of following proposition comes straightforward.\n\n\\textbf{Proposition 5.3.4.} Using any classic variable-length code, at any time $i$ the multilayer suffix tree is able to answer to the Query 1 for a given pattern in $O(|\\text{pattern}| \\log \\log i)$ time.\n\n\\section{On \\textit{Weighted-Exist} and \\textit{Weighted-Extend}}\n\nLet us now focus on the \\textit{Weighted-Exist} and on the \\textit{Weighted-Extend} operations used by the Dictionary-Symbolwise Flexible Parsing algorithm. We want to show how to use the multilayer suffix tree to support the \\textit{Weighted-Exist} and the \\textit{Weighted-Extend} operations in amortized constant time when the dictionary is LZ77-like. For simplicity in the following we focus on the case of LZ77 dictionary with unbounded size. The case of LZ77 dictionary with bounded size, like in the original LZ77 case, is a simple generalization of the unbounded case that comes from the sliding window capability of the layers of the multilayer suffix tree. Indeed, the unbounded case is the special case of the bounded dictionary where the search buffer size is greater than or equal to the text size.\n\nWe assume that the Dictionary-Symbolwise Flexible Parsing has to parse the text $T$ and that at any time $i$ with $0 \\leq i \\leq |T|$, the dynamic dictionary $D_i$ is represented by the multilayer suffix tree of $T_i$.\n\nLet us consider a run of the \\textit{Find Supermaximal} algorithm described in Section 4.1 and reported for convenience in Table 5.4, where $c$ is a fixed value.\n\nRecall that the cost of any dictionary phrase $w \\in D_i$ associated to the edge $(i, j) \\in G_{A,T}$ is given by the cost of the flag information $F_d$ for the dic-\nTable 5.2: The pseudocode of the \\textit{Find Supermaximal} algorithm as in the Table 4.1 of Page 52.\n\nLet us consider $F_d$ constant within this section. Moreover, since any dictionary pointer in LZ77-like algorithms is encoded by the couple $(\\text{length}, \\text{offset})$ as described in Section 2.2, the cost of the encoding of a dictionary pointer is equal to the cost of the encoding of the length of the dictionary phrase plus the cost of the encoding of the offset of the rightmost occurrence of the phrase inside the dictionary.\n\nLet us recall that for any cost value $c$ and for any phrase $w \\in D_i$ associated to the edge $(i, j)$ in $G_{A,T}$ with $w = T[i+1 : j]$, the operation $Weighted-Extend((i, j), c)$ finds out whether the phrase $wa = T[i+1 : j+1]$ is in $D_i$ and the cost of the edge $(i, j+1)$ in $G_{A,T}$ is smaller than or equal to $c$. Let us also recall that given $i, j$ with $0 \\leq i < j \\leq n$ and a cost value $c$, the operation $Weighted-Exist(i, j, c)$ finds out whether or not the phrase $w = T[i+1 : j]$ is in $D_i$ and the cost of the corresponding edge $(i, j)$ in $G_{A,T}$ is smaller than or equal to $c$. \n\n\\begin{table}[h]\n\\begin{tabular}{|l|}\n\\hline\n\\textbf{Find Supermaximal}(c) \\\\\n01. $i \\leftarrow 0, j \\leftarrow 0, M_c \\leftarrow \\emptyset$ \\\\\n02. WHILE $j < n$ DO \\\\\n03. \\hspace{1em} $j \\leftarrow j + 1$ \\\\\n04. \\hspace{1em} WHILE $i < j$ AND $Weighted-Exist(i, j, c) = \\text{“no”}$ DO \\\\\n05. \\hspace{2em} $i \\leftarrow i + 1$ \\\\\n06. \\hspace{1em} ENDWHILE \\\\\n07. IF $i < j$ THEN \\\\\n08. \\hspace{1em} WHILE $Weighted-Extend((i, j), c) = \\text{“yes”}$ DO \\\\\n09. \\hspace{2em} $j \\leftarrow j + 1$ \\\\\n10. \\hspace{1em} ENDWHILE \\\\\n11. INSERT $((i, j), M_c)$ \\\\\n12. ENDIF \\\\\n13. ENDWHILE \\\\\n14. RETURN $M_C$ \\\\\n\\hline\n\\end{tabular}\n\\end{table}\nTherefore, we can summarize as it follows.\n\n\\[ C((i, j)) = C(F_d) + \\text{Bitlen}(|w|) + \\text{Bitlen}(\\text{rightmost}_i(w)) \\]\n\n\\( \\text{Weighted-Exist}((i, j), c) = \\text{“yes”} \\iff T[i + 1 : j] \\text{ is in } D_i \\text{ and } C((i, j)) \\leq c \\)\n\n\\( \\text{Weighted-Extend}((i, j), c) = \\text{“yes”} \\iff T[i + 1 : j + 1] \\text{ is in } D_i \\text{ and } C((i, j + 1)) \\leq c \\)\n\nNotice that previous statements depend on \\( \\text{rightmost}_i(w) \\) that cannot be found in constant time. Notice also that we could use Query 1 of \\( w \\) instead of \\( \\text{rightmost}_i(w) \\), since they have equal Bitlen values. Unfortunately, also the Query 1 cannot be done in constant time. Indeed, using the Query 1 we can perform any of the needed operations in \\( O(|w| \\log \\log i) \\) time.\n\nThe idea to perform these operations in constant time is based on the observation that we don’t actually need to know the cost of the given edge, but we can just check if a phrase is in a specific layer of our data structure that is the greatest layer that satisfy the \\( C((i, j)) \\leq c \\) inequality.\n\nSince for any \\( sw_k \\in SW \\) there is a \\( b_k \\in B \\) associated to it by definition of \\( SW \\), we can restate the operations as it follows.\n\n\\( \\text{Weighted-Exist}((i, j), c) = \\text{“yes”} \\iff \\exists k \\text{ such that } T[i + 1 : j] = sw_k \\text{ and } C(F_d) + \\text{Bitlen}(|w|) + b_k \\leq c \\)\n\n\\( \\text{Weighted-Extend}((i, j), c) = \\text{“yes”} \\iff \\exists k \\text{ such that } T[i + 1 : j + 1] = wa \\text{ is in the layer } sw_k \\text{ and } C(F_d) + \\text{Bitlen}(|wa|) + b_k \\leq c \\)\n\n**Definition 5.6.** Let be \\( L(w, c) = \\max\\{k \\mid C(F_d) + \\text{Bitlen}(|w|) + b_k \\leq c\\} \\).\n\nLet us notice that an edge has cost less than or equal to \\( c \\) if and only if the phrase associated to this edge is in the layer \\( sw_{L(w, c)} \\). More formally,\n\n**Proposition 5.4.1.** Let be \\( (i, j) \\in G_{A,T} \\). We have that for any \\( c, C((i, j)) \\leq c \\iff w = T[i + 1 : j] \\text{ is in the layer } sw_{L(w, c)}. \\)\n\n**Proof.** The phrase \\( w \\) is the dictionary phrase associated to the edge \\((i, j)\\). If \\((i, j)\\) is in \\( G_{A,T} \\), then \\( w \\) is in \\( D_i \\). Let us call \\( sw_p \\in SW \\) the smallest\nlayer where $w$ appears. For the Prop. 5.2.1 we have that $w$ is also in all the layers $s_{w_x}$ with $s_{w_x} \\geq s_{w_p}$. If $C((i,j)) \\leq c$, then for some value $b_k$ we have that $C(F_d) + \\text{Bitlen}(|w|) + b_k \\leq c$. From the definition of $L(w,c)$ we have that $b_{L(w,c)}$ is the greatest cost that satisfies the cost inequality and $s_{w_{L(w,c)}}$ is the layer associated to it. We have that $s_{w_{L(w,c)}} \\geq s_{w_p}$. Indeed, by contradiction, if $s_{w_{L(w,c)}} < s_{w_p}$, then $b_{L(w,c)} < b_p$ and $b_p$ does not satisfy the cost inequality, i.e. $C(F_d) + \\text{Bitlen}(|w|) + b_p > c$. This contradicts $C((i,j)) \\leq c$. This completes the “if” part of the proof.\n\nIf $w$ is in layer $s_{w_{L(w,c)}}$, then $w$ is in $D_i$ and by definition of $L(w,c)$, we have that $C(F_d) + \\text{Bitlen}(|w|) + s_{w_{L(w,c)}} \\leq c$. Therefore, we have that $(i,j)$ is in $G_{A,T}$ by definition of $G_{A,T}$ and since $b_{L(w,c)}$ is the maximum cost that satisfies the cost inequality, we have that $C((i,j)) \\leq C(F_d) + \\text{Bitlen}(|w|) + s_{w_{L(w,c)}} \\leq c$. This concludes the proof. \n\n\\begin{corollary}{5.4.2.}\n\\end{corollary}\n\nWeighted-Exist($i,j,c$) = “yes” $\\iff T[i+1:j] = w$ is in the layer $s_{w_{L(w,c)}}$\n\nWeighted-Extend($i,j,c$) = “yes” $\\iff T[i+1:j+1] = wa$ is in the layer $s_{w_{L(wa,c)}}$\n\nLet us show how to associate a point in our data structure to a pattern.\n\nSince that edges in suffix trees may have labels longer than one character, the ending point of a pattern may be either a node or a point in the middle of an edge. A classic notation to refer to a general point in a suffix tree is a triple composed by a locus, a symbol and an offset. The locus is the node closest to the point on the path from the root, the symbol is the discriminant character between the outgoing edges of the locus, and the offset tells how many characters in the edge precede the point.\n\nMore formally, given a pattern $w \\in \\text{Fact}(T)$, let $S_T$ be the suffix tree for the text $T$. Let be $w = uv$, with $u,v \\in \\text{Fact}(T)$, where $u$ is the longest prefix of $w$ ending at a node $p$ in $S_T$ and $v$ is the prefix of the edge where the pattern $w$ ends out. Let call $p$ the locus of $w$, $|v|$ the offset and $v[1]$ the discriminant character between the outgoing edges of $p$. If $w$ ends to a node\nin $S_T$, then $w = uc$, this node is the locus $p$, the length is equal to 0 and the symbol is any $c \\in \\Sigma$.\n\nIn the multilayer suffix tree we denote by $P(pattern, x)$ the point of the given pattern in the layer $sw_x$.\n\n**Constant Case**\n\nLet us notice that if, for any $w \\in \\Sigma^*$, $C(F_d)$ and $Bitlen(|w|)$ are constant along a run of the $Find Supermaximal(c)$ algorithm, then also $L(w, c) = L$ is a constant. It would be easy to obtain an amortized constant time for our operations. Let us take a closer look to this case and let us show how to perform the $Weighted-Exist$ and the $Weighted-Extend$ operations.\n\nLet suppose to have a pointer to $P(w, L)$ in our data structure for the text $T_i$, with $w = T[i+1:j]$. Let us define the procedure $Find$ as in Table 5.3. In order to perform a $Weighted-Extend((i, j), c)$ we use the procedure $Find(j+1)$. In order to perform a $Weighted-Exist(i, j, c)$ we use the procedure $Find(j)$. The correctness of this approach immediately follows from Corollary 5.4.2.\n\nEssentially, we handle a point $p$ in the layer $sw_L$. A $Weighted-Extend$ corresponds to read a character in the layer $sw_L$. A $Weighted-Exist$ corresponds to follow a suffix-link from the locus of the point $p$ together with the skip-count trick (see [19, Sec. 6.1.3]) and to read one character. The time spent to do the two operations $Weighted-Extend$ and $Weighted-Exist$ in this way turns out to be amortized constant.\n\nWe are here using standard techniques concerning suffix trees.\n\nFor the purists, we report in the Appendix B all the details concerning how to use the procedure $Find$ inside the algorithm $Find Supermaximal$ together with the adapted pseudocode and the proof of correctness and time analysis.\n\nFrom the time analysis in Appendix B next proposition directly follows.\n\n**Proposition 5.4.3.** Let $c$ be a cost value and $L$ a constant. The $Weighted-Exist$ and the $Weighted-Extend$ operations of the $Find Supermaximal(c)$ algorithm are performed in amortized constant time by using the multilayer suffix tree data structure.\nFind$(k)$\n1. $a \\leftarrow T[k]$\n2. IF $Succ(p, a) \\neq \\text{nil}$ THEN\n3. $p \\leftarrow Succ(p, a)$\n4. RETURN “yes”\n5. ELSE\n6. $p \\leftarrow Suff(p)$\n7. RETURN “no”\n8. ENDIF\n\n$Succ(P(w, k), a)$\n1. IF $wa$ is in layer $sw_k$ THEN\n2. RETURN $P(wa, k)$\n3. ELSE\n4. RETURN nil\n5. ENDIF\n\n$Suff(P(aw, k))$\n1. RETURN $P(w, k)$\n\nTable 5.3: The pseudocode of the Find procedure and its subroutines. The $Succ(p, a)$ routine reads the character $a$ starting from the point $p$ in constant time. The $Suff(p)$ routine finds the point of the longest proper suffix of $p$ by using one suffix-link and the skip-count trick in $O(1)$ amortized time.\n\n**General Case**\n\nIn previous subsection we showed how to perform the two operations $Weighted-Extend$ and $Weighted-Exist$ used inside the algorithm $Find Super-maximal$ in amortized constant time by using the multilayer data structure under one hypothesis. The hypothesis is that $Bitlen(|w|)$ (and therefore $L(w, c)$) is constant.\n\nIn this subsection we want to extend this result to the general case. Here we consider just one cost $c$. The algorithm that we will describe in the\nfollowing is immediately parallelizable to all costs to support the Dictionary-Symbolwise Flexible Parsing algorithm.\n\nIn the general case, along a run of the Find Supermaximal algorithm, since \\(L(w, c)\\) may change following \\(\\text{Bitlen}(|w|)\\) changes, we may have to change layer while we move the point \\(p\\). The main goal of what we are going to describe is that we can handle the layer changes in amortized constant time by using just two points instead of one. The following description is informal but rigorous.\n\nLet \\(p, q\\) be two points in our data structure. Fixed a cost \\(c\\), the Find Supermaximal algorithm set \\(i = 0\\) and \\(j = 0\\) (that means that the text is just starting). The points \\(p\\) and \\(q\\) are set to be equal to the root of the layer \\(sw_{L(\\epsilon, c)}\\), where \\(\\epsilon\\) is the empty word. Let be \\(L(\\epsilon, c) = L\\). We assume that we can calculate \\(L(w, c), \\text{Bitlen}(|w|)\\) and therefore \\(b_{L(w, c)}\\) in constant time, that is an absolutely natural hypothesis that is verified for standard Variable-Length Codes. The algorithm starts to perform the operations Weighted-Extend((i, j), c) and Weighted-Exist(i, j + 1, c) in the order described by the algorithm Find Supermaximal. As described in previous subsection, we support these operations and we maintain \\(p = q = P(w, L)\\) in the same layer \\(sw_L\\) until \\(L(w, c)\\) changes, i.e. until when \\(L(w, c) = L'\\) with \\(L \\neq L'\\).\n\nWhenever \\(L(w, c)\\) changes from \\(L\\) to \\(L'\\), we maintain \\(q\\) on the layer \\(L\\) and we move \\(p\\) to the layer \\(L'\\). Roughly speaking, \\(sw_{L'}\\) is the current layer and \\(sw_L\\) is the previous layer. This simple dynamic programming trick allows to save time when \\(L(w, c)\\) turns back to its previous value. In this case we just swap \\(p\\) and \\(q\\). Otherwise, when \\(sw_{L'}\\) is different from the layer of \\(q\\), we firstly save \\(p\\) by using \\(q\\), i.e. we set \\(q\\) equal to \\(p\\), and then we set \\(p\\) to be equal to \\(P(w, L')\\). In order to reach the point \\(P(w, L')\\), we simply start reading \\(w\\) from the root of the layer \\(sw_{L'}\\) in \\(O(|w|)\\) time. We will see in the time analysis that this quantity can be amortized to a constant in the overall run of the algorithm.\n\nNotice that for \\(L' \\leq L\\), i.e. when the new layer \\(sw_{L'}\\) is smaller than the layer \\(sw_L\\), we have that if \\(w\\) is in \\(sw_{L'}\\), then \\(w\\) is also in \\(sw_L\\) for the Prop. 5.2.1. In this case, we can maintain \\(p = P(w, L')\\) and \\(q = P(w, L)\\) as stated before. Otherwise, for \\(L' > L\\) and \\(w\\) is in \\(sw_{L'}\\), we have not guarantees that\nw is in \\( sw_L \\). In this case we let \\( q \\) points to the longest prefix of \\( w \\) in \\( sw_L \\).\n\nTherefore, if \\( v \\) is the longest prefix of \\( w \\) in \\( sw_L \\), then we set \\( q = P(v, L) \\).\n\nAs soon as a new Weighted-Extend or a new Weighted-Exist operation is accomplished, we maintain \\( q \\) to the longest prefix of \\( w \\).\n\nSince \\( v \\) is a prefix of \\( w \\), the number of steps used to reach \\( P(v, L) \\) in the layer \\( sw_L \\) is less than or equal to the number of steps needed to reach \\( P(w, L) \\). Furthermore, the number of steps used later to keep \\( q \\) to the longest prefix of \\( w \\) is less or equal to the number of steps saved before.\n\nThe redefined Find procedure in Table 5.4 is in charge of handling the \\( p,q \\) points as described. The same table reports also some subroutines.\n\nWe present the time analysis of the overall pointer handling.\n\nFrom the above description and from the results of previous subsection, we have that the overall time to move two pointers \\( p \\) and \\( q \\) inside the multilayer suffix tree inside two fixed layers is linear on the size of the text. Let \\( L_p \\) be the cost of the phrase pointed by \\( p \\) and \\( L_q \\) the cost of the phrase pointed by \\( q \\). Let us now focus on the steps used to move \\( p \\) and \\( q \\) from a layer to another. Since \\( q \\) simply follows point \\( p \\), we focus just on the pointer \\( p \\).\n\nTwo cases are possible. If \\( L(w, c) = L_q \\), then \\( p \\) is set to \\( q \\) in constant time. Otherwise, \\( L(w, c) \\neq L_q \\) and we have to move \\( p \\) from \\( P(\\varepsilon, L(w, c)) \\) to \\( P(w, L(w, c)) \\) in \\( O(|w|) \\) time. We want to show that these \\( O(|w|) \\) steps are amortizable over the number of algorithm steps between two consecutive change of \\( L(w, c) \\).\n\nSuppose that a change of \\( L(w_t, c) \\) happens at time \\( i_t \\) with \\( j = j_t \\), \\( w_t = T[i_t + 1 : j_t] \\) of length \\( h = |w_t| \\). Suppose that the first changes after time \\( i_t \\) happens at time \\( i_{t'} \\) with \\( j = j_{t'} \\), \\( w_{t'} = T[i_{t'} + 1 : j_{t'}] \\) of length \\( h' = |w_{t'}| \\).\n\nIf \\( h' > h \\), then, from the Property 5.1 and the Remark 5.1, we have that \\( h' \\geq k h \\) unless \\( h' \\leq \\hat{k} \\), where \\( \\hat{k} \\) is a constant and there is no need of amortizing. Notice that, from time \\( i_t \\) to time \\( i_{t'} \\), the algorithm do \\( (i_{t'} - i_t + j_{t'} - j_t) \\geq (h' - h) \\) steps. We amortize the \\( O(|w_{t'}| = h') \\) steps of the pointer \\( p \\) over the \\( (h' - h) \\) steps of the Find Supermaximal algorithm. For each algorithm step we make at most\n\n\\[\n\\frac{h'}{h' - h} \\leq \\frac{k}{\\hat{k} - 1}\n\\]\nsteps on the multilayer suffix tree. Indeed, from $h' \\geq kh$ follows\n\n$$\\frac{h}{h'} \\leq \\frac{1}{1 - \\frac{1}{k}} \\Rightarrow 1 - \\frac{h}{h'} \\geq \\frac{1}{1 - \\frac{1}{k}} \\Rightarrow \\frac{h'}{h' - h} \\leq \\frac{k}{k - 1}$$\n\nwhere $\\frac{k}{k - 1}$ is the amortization constant over the $h' - h$ last algorithm steps.\n\nIf $h' < h$, then $h' \\leq \\frac{1}{k} h$. Therefore, for each algorithm step we make at most\n\n$$\\frac{h'}{h - h'} \\leq \\frac{1}{k - 1}$$\n\nsteps on the multilayer suffix tree. This complete the time analysis. The following theorem is an immediate consequence of this time analysis.\n\n**Proposition 5.4.4.** The total number of steps on the multilayer suffix tree used to perform all the Weighted-Exist and the Weighted-Extend operations of a run of the Find Supermaximal($c$) algorithm is linear on the size of the text. Therefore, the multilayer suffix tree uses amortized constant time for any operation.\n\nAnalogously to what done in Subsection 5.4 concerning cost parallelization, we extend above proposition to the Dictionary-Symbolwise Flexible Parsing as it follows.\n\n**Corollary 5.4.5.** The multilayer suffix tree supports the Weighted-Exist and the Weighted-Extend operations inside the Dictionary-Symbolwise Flexible Parsing algorithm in amortized constant time.\nTable 5.4: The pseudocode of the redefined Find procedure and its subroutines. Variables $L_p, L_q, p, q, gap$ and $i$ are variables of the Find Supremaximal algorithm. $L_p$ and $L_q$ are initialized to $L(\\epsilon, c)$, $p$ and $q$ are initialized to $P(\\epsilon, L_p)$ and the gap counter is initialized to 0. Notice that Find begins always with $p = P(T[i-1 : k-1], L_p)$ and $q = P(T[i-1 : k-1 - gap], L_p)$. \nChapter 6\n\nConclusion\n\nIn this thesis we present some advancement on dictionary-symbolwise theory. We describe the Dictionary-Symbolwise Flexible Parsing, a parsing algorithm that extends the Flexible Parsing (see [28]) to variable costs and to the dictionary-symbolwise domain. We prove its optimality for prefix-closed dynamic dictionaries under some reasonable assumption. Dictionary-Symbolwise Flexible Parsing is linear for LZ78-like dictionaries. In the case of LZ77-like dictionary, we obtain the $O(n \\log n)$ complexity as authors of [17] recently did by using a completely different subgraph, where $n$ is the text size.\n\nWe introduce the Multilayer Suffix Tree data structure that is able to represent the LZ77 dictionary in $O(n)$ space and $O(n \\log n)$ building time. This data structure is also able to perform the cost-based queries of the Dictionary-Symbolwise Flexible Parsing algorithm in amortized constant time.\n\nWe also prove that dictionary-symbolwise compressors can be asymptotically better than optimal pure dictionary compressors in terms of compression ratio.\n\nFurthermore, we ultimately prove the optimality of the greedy parsing for LZ77-like dictionary under the uniform cost assumption about the encoding of dictionary-phrases.\n\nLast but not least, our Dictionary-Symbolwise Flexible Parsing algorithm allows to couple classical LZ-like compressors with several symbolwise meth-\nods to obtain new dictionary-symbolwise algorithms with proof of parsing optimality.\n\nWe conclude this thesis with two open problems.\n\n1. Theoretically, LZ78 is better on memoryless sources than LZ77. Experimental results say that when optimal parsing is in use it happens the opposite. To prove this fact both in pure dictionary case and in dictionary-symbolwise case.\n\n2. Common symbolwise compressors are based on the arithmetic coding approach. When these compressors are used, the costs in the graph are almost surely noninteger and, moreover, the graph is usually not well defined. The standard workaround is to use an approximation strategy. A big goal should be finding an optimal solution for these important cases.\nBibliography\n\n\nAppendix A\n\nExperiments\n\nWe now discuss about some experiments. Readers must keep into account that the results of this thesis are mainly theoretical and that they apply to a very large class of compression algorithms. Due to this, the use of different methods of encoding for dictionary pointers as well as for symbolwise encoding and for the flag information encoding together with the dictionary constrains leads to different performances. Performances about time and space are strongly dependent on the programming language in use and on the programmers abilities. Therefore we decided to focus only on compression ratio.\n\nHere we discuss two particular cases that allow to compare our results with some well know commercial compressors. The first one is related to LZ78-like dictionary and a Huffman code. The second one concerns LZ77-like dictionaries with several window sizes and a Huffman code. We compare the obtained compression ratio with the gzip, zip and cabarc compression tools. The encoding method in use is a semi static Huffman code.\n\nIn the first experiment, using a simple semi static Huffman code as symbolwise compressor, we improved the compression ratio of the Flexible Parsing with LZW-dictionary by 3 to 5 percent on texts such as the bible.txt file or the prefixes of English Wikipedia data base (see Table A.1). We obtain that the smaller is the file the greater is the gain.\n\nWe have experimental evidence that many of the most relevant LZ77-like commercial compressors are, following our definition, dictionary-symbolwise\n<table>\n<thead>\n<tr>\n<th>File (size)</th>\n<th>bible.txt (4047392 Byte)</th>\n<th>enwik (100 MB)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>gzip -9</td>\n<td>29.07%</td>\n<td>36.45%</td>\n</tr>\n<tr>\n<td>lzwfp</td>\n<td>30.09%</td>\n<td>35.06%</td>\n</tr>\n<tr>\n<td>lzhds</td>\n<td>25.84%</td>\n<td>31.79%</td>\n</tr>\n</tbody>\n</table>\n\nTable A.1: Compression ratio comparison of some LZW-like compressors and the gzip tool. (*gzip* -9 is the gzip compression tool with the -9 parameter for maximum compression. *lzwfp* is the Flexible Parsing algorithm of Matias-Rajpoot-Sahinalp with a LZW-like dictionary. *lzhds* is our Dictionary-Symbolwise Flexible Parsing algorithm with LZW-like dictionary and a Huffman code.)\n\n<table>\n<thead>\n<tr>\n<th>File (size)</th>\n<th>bible.txt (4047392 Byte)</th>\n<th>enwik (100 MB)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>gzip -9</td>\n<td>29.07%</td>\n<td>36.45%</td>\n</tr>\n<tr>\n<td>gzip by 7zip</td>\n<td>27.44%</td>\n<td>35.06%</td>\n</tr>\n<tr>\n<td>zip by 7zip</td>\n<td>25.99%</td>\n<td>33.72%</td>\n</tr>\n<tr>\n<td>cabarc</td>\n<td>22.13%</td>\n<td>28.46%</td>\n</tr>\n<tr>\n<td>lzhds-32KB</td>\n<td>27.47%</td>\n<td>35.02%</td>\n</tr>\n<tr>\n<td>lzhds-64KB</td>\n<td>26.20%</td>\n<td>33.77%</td>\n</tr>\n<tr>\n<td>lzhds-2MB</td>\n<td>22.59%</td>\n<td>28.82%</td>\n</tr>\n<tr>\n<td>lzhds-16MB</td>\n<td>22.51%</td>\n<td>26.59%</td>\n</tr>\n</tbody>\n</table>\n\nTable A.2: Compression ratio comparison of some LZ77-like compressors. (*gzip* -9 is the gzip compression tool with the -9 parameter for maximum compression. *gzip by 7zip* is the gzip compression tool implemented in the 7-Zip compression suite. *zip by 7zip* is the 7-Zip implementation of the zip compression tool. *cabarc* is the MsZip cabinet archiving tool also known as cabarc (version 5.1.26 with -m lzx:21 option used). *lzhds*-x is our Dictionary-Symbolwise Flexible Parsing algorithm with LZ77-like dictionary of different dictionary sizes, as stated in the suffix of the name, and a Huffman code.)\n<table>\n<thead>\n<tr>\n<th>File (size)</th>\n<th>bible.txt (4047392 Byte)</th>\n<th>enwik (100 MB)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>gzip -9 / lzhds-32KB</td>\n<td>105.82%</td>\n<td>104.08%</td>\n</tr>\n<tr>\n<td>gzip by 7zip / lzhds-32KB</td>\n<td>99.89%</td>\n<td>100.11%</td>\n</tr>\n<tr>\n<td>zip by 7zip / lzhds-64KB</td>\n<td>99.19%</td>\n<td>99.85%</td>\n</tr>\n<tr>\n<td>cabarc / lzhds-2MB</td>\n<td>97.96%</td>\n<td>98.75%</td>\n</tr>\n</tbody>\n</table>\n\nTable A.3: Ratio between the compression ratio of different LZ77-like compressors. All the involved compressors, except for the gzip one, seem to have an optimal parsing strategy. (See Table A.2 caption for compressor descriptions.) Notice that on each row there are compressors having the same windows size.\n\nalgorithms and they use an optimal parsing (see Table A.2 and Table A.3). In Table A.3 is shown the ratio between compression performances of compressors with similar constrains and encoding. Indeed, gzip and lzhds-32KB use a LZ77-like dictionary of 32KB, zip and lzhds-64KB have dictionary size of 64KB. cabarc and lzhds-2MB use 2MB as dictionary size. They all use a Huffman code. We notice that a difference of about 5 percent is due to parsing optimality while small differences of about 2 percent are due to implementation details like different codeword space and different text block handling. We think that gzip and zip implementations in the 7-Zip compression suite and cabarc have an optimal parsing, even if this fact is not clearly stated or proved.\nAppendix B\n\nTime Analysis of the Constant Case\n\nWe present the time analysis of the \\textit{Find Supermaximal} algorithm variant for the constant $\\text{Bitlen}(|w|)$ case, defined as in Table B.1, where the \\textit{Weighted-Exist} and the \\textit{Weighted-Extend} operations are done by using the \\textit{Find} procedure of the Multilayer Suffix Tree of $T_i$.\n\nFor a fixed text $T$, let us define the set $J = \\{j_0, j_1, \\ldots, j_q\\} \\subset [0..n]$ to be the set of the $j$ values after each of the positive answer of the \\textit{Weighted-Exist}(i, j, c) operations in the \\textit{Find Supermaximal} algorithm for a fixed integer $(c)$. Notice that, since at each step of the \\textit{Find Supermaximal} algorithm either $i$ or $j$ is increased and they are never decreased, we have that for each $j_p \\in J$ there exists one and only one value $i$ such that $\\textit{Weighted-Exist}(i, j, c)$ gives a positive answer. For any $j_p \\in J$, let us call $i_p$ such corresponding value.\n\nWe want to show how to perform the \\textit{Weighted-Exist} and the \\textit{Weighted-Extend} operations from the generic step $j_p$ to the step $j_{p+1}$ with $0 \\leq p < q$. In the meantime, we want to proof following proposition.\n\n\\textbf{Proposition B.0.6.} If at time $i_p$ we have a pointer $P(w, L)$ such that $w = T[i_p + 1 : j_p]$, then at time $i_{p+1}$ we will have correctly computed the pointer $P(w, L)$ with $w = T[i_{p+1} + 1 : j_{p+1}]$ using at most $i_{p+1} - i_p + j_{p+1} - j_p$ steps on our data structure.\nProof. The proof is by induction on $p$. For $p = 0$, let $j_0$ be the first element in $J$.\n\nWhen $i = j$, $T[i + 1 : j] = \\epsilon$ by definition. $P(\\epsilon, L)$ is the pointer to the root of the layer $sw_L$. From a simple analysis of the pseudocode of Find Supermaximal in Table 4.1 we have that $i_0 = j_0 - 1$. Therefore, $Weighted-Exist(i, i + 1, c)$ returns a positive answer as soon as there is a character $T[i + 1] \\in D_i$. In order to perform this check, we maintain the pointer $P(\\epsilon, L)$ fixed to the root of the layer $L$ and we just check for an outgoing edge starting with the character $a = T[i + 1]$ in constant time for $0 \\leq i \\leq i_0 = j_0 - 1$. Once that $i = i_0$, we move in constant time $P(\\epsilon, L)$ to $P(a, L)$. So, for $p = 0$ and consequently at time $i_0$, we have the pointer $P(a, L)$ with $a = T[i_0 + 1 : j_0]$ and $Weighted-Exist(i_0, j_0, c)$ gives a positive answer. This is the base of the induction.\n\nThe inductive hypothesis is that for a generic $p < q$, i.e. at time $i_p$, we have the pointer $P(w, L)$ with $w = T[i_p + 1 : j_p]$ and $L = L(w, c)$ for any $w$. At time $i_p$, the Find Supermaximal algorithm has successfully done $Weighted-Exist(i_p, j_p, c)$, i.e. the edge $(i, j)$ is in $G_{AT}$ and $C(i, j) \\leq c$ with $i = i_p$ and $j = j_p$.\n\nWe want to proof for $p + 1$ that we can find $P(T[i_{p+1} + 1 : j_{p+1}], L)$.\n\nWe consider the steps from time $i_p$ to the time $i_{p+1}$. At time $i_p$ we have $P(w, L)$ with $w = T[i_p + 1 : j_p]$ by inductive hypothesis. Since that the algorithm has yet successfully done $Weighted-Exist(i, j, c)$ with $i = i_p$ and $j = j_p$, it now performs a series of $Weighted-Extend((i, j), c)$ operations for increasing values of $j$, until it found a $j$ such that $(i, j)$ is in $G_{AT}$ with $C(i, j) \\leq c$ and $(i, j + 1)$ is not. In order to perform such series of operations we have just to check, for any $j$, if $wa$ is in the layer $L(wa, c)$, where $a = T[j + 1]$ is the $j + 1$-th character of $T$. Since we are assuming $L(w, c)$ constant, we have that $L(wa, c) = L(w, c) = L$ and we have just to check if an $a$ can be read starting from the point $P(w, L)$. If there is an $a$ after $P(w, L)$, then $(i, j + 1)$ is in $D_i$ with $C(i, j + 1) \\leq c$ and the $Weighted-Extend((i, j), c)$ returns \"yes\". We also let $P(w, L)$ become $P(wa, L)$ and the algorithm increase the value of $j$ of an unit. If there is not an $a$ after $P(w, L)$, then $Weighted-Extend((i, j), c)$ returns \"no\" and the series of $Weighted-Extend$ terminate.\nAt this point, the algorithm starts a series of \\textit{Weighted-Exist}(i+1, j+1, c) increasing the value of \\(i\\), until \\textit{Weighted-Exist}(i + 1, j + 1, c) returns \"yes\".\n\nNotice that the edge \\((i + 1, j)\\) represents the longest proper suffix of \\(w\\) and since the dictionary has the strong suffix-closed property (see Corollary 3.3.2), \\((i + 1, j)\\) is in \\(D_i\\). Let \\(u\\) be such suffix of \\(w\\). Since the cost function \\(C\\) is \\textit{prefix-nondecreasing}, we know that \\(C(i + 1, j) \\leq C(i, j)\\) and then \\(u\\) is in the layer \\(sw_{L(w,c)}\\). We move \\(P(w, L)\\) to \\(P(u, L)\\) in amortized constant time by using standard property of suffix trees.\n\nSince we have \\(P(u, L)\\), in order to perform the operation \\textit{Weighted-Exist}(i + 1, j + 1, c), we have just to check if there is an \\(a\\) after \\(P(u, L)\\), where \\(a\\) is equal to \\(T[j + 1]\\). As we have already seen, we can check this in constant time. If there is not an \\(a\\) after \\(P(u, L)\\) the \\textit{Weighted-Exist}(i + 1, j + 1, c) returns ”no”. The algorithm increases the value of \\(i\\) of an unit and we move again \\(P(u, L)\\) to its longest proper suffix. Otherwise, If there is an \\(a\\) after \\(P(u, L)\\) the \\textit{Weighted-Exist}(i + 1, j + 1, c) returns ”yes”.\n\nThe algorithm now increases \\(i\\) and \\(j\\) by one. Since last \\textit{Weighted-Exist} operation returned ”yes”, we know that \\(ua \\in D_i\\), where \\(ua\\) is the dictionary phrase associated to the edge \\((i, j)\\). Therefore we can move \\(P(u, L)\\) to \\(P(ua, L)\\). Since this is the first positive \\textit{Weighted-Exist} answer after \\(i_p\\), we know that current value of \\(i, j\\) are \\(i = i_{p+1}\\) and \\(j = j_{p+1}\\). Since \\(ua\\) is equal to \\(T[i + 1 : j]\\), this concludes the proof.\n\n\\(\\square\\)\nTable B.1: The pseudocode of the Find Supermaximal algorithm for the constant Bitlen(|w|) case, together with the Find procedure and its subroutines. The Succ(p, a) routine reads the character a starting from the point p in constant time. The Suff(p) routine find the point of the longest proper suffix of p by using one suffix-link and the skip-count trick in amortized constant time."}}},{"rowIdx":189,"cells":{"id":{"kind":"string","value":"e35a635bbf8abed4c404dca1f819bbbbdec74a86"},"text":{"kind":"string","value":"NOTICE\n\nThis document is disseminated under the sponsorship of the U.S. Department of Transportation in the interest of information exchange. The United States Government assumes no liability for the contents or use thereof. The United States Government does not endorse products or manufacturers. Trade or manufacturer’s names appear herein solely because they are considered essential to the objective of this report. This document does not constitute FAA certification policy. Consult your local FAA aircraft certification office as to its use.\n\nThis report is available at the Federal Aviation Administration William J. Hughes Technical Center’s Full-Text Technical Reports page: actlibrary.tc.faa.gov in Adobe Acrobat portable document format (PDF).\n**SOFTWARE SERVICE HISTORY REPORT**\n\n**Abstract**\n\nThe safe and reliable operation of software within civil aviation systems and equipment has historically been assured through the application of rigorous design assurance applied during the software development process. Increasingly, manufacturers are seeking ways to use software that has been previously developed for other domains or that has been previously certified for use in lower criticality aviation applications. Product service history is one method for demonstrating that such software is acceptable for use in the new application domain. In theory, product service history would seem to be a fairly simple concept, both to understand and to apply. However, in practice, such use has proved extremely problematic, as questions of how to measure the historic performance and the relevance of the provided data have surfaced. This report represents the results of research in this area, for use by the Federal Aviation Administration in formulating new guidance and prioritizing future research work in the area of product service history.\n\n**Key Words**\n\nDO-178B, SC-190, DO-248, Product service history, Software reliability, Airborne systems and equipment, Error rates\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>EXECUTIVE SUMMARY</td>\n<td>vii</td>\n</tr>\n<tr>\n<td>1. INTRODUCTION</td>\n<td></td>\n</tr>\n<tr>\n<td>1.1 Purpose</td>\n<td>1</td>\n</tr>\n<tr>\n<td>1.2 Scope</td>\n<td>1</td>\n</tr>\n<tr>\n<td>1.3 Background</td>\n<td>1</td>\n</tr>\n<tr>\n<td>1.4 The Research Effort</td>\n<td>3</td>\n</tr>\n<tr>\n<td>1.5 Related Activities/Documents</td>\n<td>4</td>\n</tr>\n<tr>\n<td>1.6 Document Structure</td>\n<td>5</td>\n</tr>\n<tr>\n<td>2. DO-178B FRAMEWORK</td>\n<td>6</td>\n</tr>\n<tr>\n<td>2.1 The Definition of Product Service History</td>\n<td>6</td>\n</tr>\n<tr>\n<td>2.2 Analysis of Product Service History in DO-178B</td>\n<td>7</td>\n</tr>\n<tr>\n<td>2.3 Relationship With Previously Developed Software</td>\n<td>15</td>\n</tr>\n<tr>\n<td>2.4 Product Service History Versus Software Reliability</td>\n<td>15</td>\n</tr>\n<tr>\n<td>3. THE ELEMENTS OF PRODUCT SERVICE HISTORY</td>\n<td>16</td>\n</tr>\n<tr>\n<td>3.1 Questions of Problem Reporting</td>\n<td>16</td>\n</tr>\n<tr>\n<td>3.1.1 Individual Questions to Consider</td>\n<td>17</td>\n</tr>\n<tr>\n<td>3.1.2 Identified Gaps and Gap Closure—Problem Reporting</td>\n<td>21</td>\n</tr>\n<tr>\n<td>3.2 Questions of Operation</td>\n<td>24</td>\n</tr>\n<tr>\n<td>3.2.1 Individual Questions to Consider</td>\n<td>26</td>\n</tr>\n<tr>\n<td>3.2.2 Identified Gaps and Gap Closure—Operation</td>\n<td>27</td>\n</tr>\n<tr>\n<td>3.3 Questions of Environment</td>\n<td>28</td>\n</tr>\n<tr>\n<td>3.3.1 Individual Questions to Consider</td>\n<td>30</td>\n</tr>\n<tr>\n<td>3.3.2 Identified Gaps and Gap Closure—Environment</td>\n<td>32</td>\n</tr>\n<tr>\n<td>3.4 Questions of Time</td>\n<td>33</td>\n</tr>\n<tr>\n<td>3.4.1 Individual Questions to Consider</td>\n<td>35</td>\n</tr>\n<tr>\n<td>3.4.2 Identified Gaps and Gap Closure—Time</td>\n<td>36</td>\n</tr>\n<tr>\n<td>4. ADEQUACY OF DEVELOPMENT PROCESS</td>\n<td>38</td>\n</tr>\n<tr>\n<td>5. ESTABLISHMENT OF “EQUIVALENT SAFETY”</td>\n<td>40</td>\n</tr>\n</tbody>\n</table>\n6. RESEARCH SUMMARY\n 6.1 Research Findings\n 6.2 Follow-On Prioritized Research Needs\n\n7. CONCLUSION\n\nAPPENDICES\n A—Data Collection and Synthesis\n B—Service History—Literature Search\n\nLIST OF FIGURES\n\n<table>\n<thead>\n<tr>\n<th>Figure</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>3</td>\n</tr>\n<tr>\n<td>2</td>\n<td>4</td>\n</tr>\n<tr>\n<td>3</td>\n<td>24</td>\n</tr>\n<tr>\n<td>4</td>\n<td>29</td>\n</tr>\n<tr>\n<td>5</td>\n<td>33</td>\n</tr>\n<tr>\n<td>6</td>\n<td>34</td>\n</tr>\n<tr>\n<td>7</td>\n<td>38</td>\n</tr>\n</tbody>\n</table>\n\nLIST OF TABLES\n\n<table>\n<thead>\n<tr>\n<th>Table</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>8</td>\n</tr>\n<tr>\n<td>2</td>\n<td>18</td>\n</tr>\n<tr>\n<td>3</td>\n<td>26</td>\n</tr>\n<tr>\n<td>4</td>\n<td>31</td>\n</tr>\n<tr>\n<td>5</td>\n<td>35</td>\n</tr>\n<tr>\n<td>Abbreviation</td>\n<td>Full Form</td>\n</tr>\n<tr>\n<td>--------------</td>\n<td>-----------</td>\n</tr>\n<tr>\n<td>AC</td>\n<td>Advisory Circular</td>\n</tr>\n<tr>\n<td>ACO</td>\n<td>Aircraft Certification Office</td>\n</tr>\n<tr>\n<td>ATM</td>\n<td>Air Traffic Management</td>\n</tr>\n<tr>\n<td>CAST</td>\n<td>Certification Authorities Software Team</td>\n</tr>\n<tr>\n<td>CNS</td>\n<td>Communication, Navigation, Surveillance</td>\n</tr>\n<tr>\n<td>COTR</td>\n<td>Contracting Officer's Technical Representative</td>\n</tr>\n<tr>\n<td>COTS</td>\n<td>Commercial Off-The-Shelf</td>\n</tr>\n<tr>\n<td>DO</td>\n<td>Document</td>\n</tr>\n<tr>\n<td>DOT</td>\n<td>Department of Transportation</td>\n</tr>\n<tr>\n<td>ED</td>\n<td>European Document</td>\n</tr>\n<tr>\n<td>EUROCAE</td>\n<td>European Organization for Civil Aviation Equipment</td>\n</tr>\n<tr>\n<td>FAA</td>\n<td>Federal Aviation Administration</td>\n</tr>\n<tr>\n<td>FAR</td>\n<td>Federal Aviation Regulations</td>\n</tr>\n<tr>\n<td>HBAW</td>\n<td>Airworthiness Handbook</td>\n</tr>\n<tr>\n<td>ICSE</td>\n<td>International Conference on Software Engineering</td>\n</tr>\n<tr>\n<td>IEEE</td>\n<td>Institute of Electrical and Electronic Engineers</td>\n</tr>\n<tr>\n<td>ISO/IEC</td>\n<td>International Organization for Standardization/International Electrotechnical Commission</td>\n</tr>\n<tr>\n<td>JAA</td>\n<td>Joint Airworthiness Authorities</td>\n</tr>\n<tr>\n<td>MTTR</td>\n<td>Mean Time to Repair</td>\n</tr>\n<tr>\n<td>MoD</td>\n<td>Ministry of Defense, United Kingdom</td>\n</tr>\n<tr>\n<td>NASA</td>\n<td>National Aeronautics and Space Administration</td>\n</tr>\n<tr>\n<td>OSED</td>\n<td>Operational Services and Environment Definition</td>\n</tr>\n<tr>\n<td>PDF</td>\n<td>Portable Document Format</td>\n</tr>\n<tr>\n<td>PDS</td>\n<td>Previously Developed Software</td>\n</tr>\n<tr>\n<td>PSAC</td>\n<td>Plan for Software Aspects of Certification</td>\n</tr>\n<tr>\n<td>RTCA</td>\n<td>formerly Radio Technical Commission for Aeronautics</td>\n</tr>\n<tr>\n<td>SAS</td>\n<td>Software Accomplishment Summary</td>\n</tr>\n<tr>\n<td>SC</td>\n<td>Special Committee</td>\n</tr>\n<tr>\n<td>SCM</td>\n<td>Software Configuration Management</td>\n</tr>\n<tr>\n<td>SOUP</td>\n<td>Software of Unknown Pedigree</td>\n</tr>\n<tr>\n<td>SSA</td>\n<td>System Safety Assessment</td>\n</tr>\n<tr>\n<td>SSAC</td>\n<td>Streamlining Software Aspects of Certification</td>\n</tr>\n<tr>\n<td>TGL</td>\n<td>Temporary Guidance Leaflet</td>\n</tr>\n</tbody>\n</table>\nEXECUTIVE SUMMARY\n\nThe safe and reliable operation of software within civil aviation systems and equipment has historically been assured through the application of rigorous design assurance applied during the software development process. Increasingly, manufacturers are seeking ways to use software that has been previously developed for other domains, has been previously certified for use in lower criticality aviation applications, or has been certified to earlier versions or different standards than those currently employed. Product service history is one method for demonstrating that such software is acceptable for use in a new application. In theory, product service history would seem to be a fairly simple concept, both to understand and to apply. However, in practice, such use has proved extremely problematic, as questions of how to measure the historic performance and the relevance of the provided data have surfaced. To date, no specific guidance has been produced to aid in the formulation of service history approaches beyond the limited discussion in DO-178B, “Software Considerations in Airborne Systems and Equipment Certification.” This research effort is designed to collect, analyze, and synthesize what is known and understood about evaluating product service history.\n\nTwo deliverables were produced as part of this research effort: a handbook and this report. The handbook, the contents of which are included within this report, is intended for use by both industry and the Federal Aviation Administration (FAA) in applying and evaluating service history arguments made for the purposes of obtaining certification credit. The handbook was limited in scope to cover only those items for which there is current supporting guidance within DO-178B. This technical report presents the results of this research effort for use by the FAA in formulating new guidance and prioritizing future research work in the area of product service history.\n\nUsing a taxonomy of questions derived from the definition of product service history in DO-178B, both quantitative and qualitative considerations are explored. This discussion is extended by inclusion of additional questions from other industries in which service history is used in evaluating software maturity. A set of worksheets is included for evaluating the relevance and sufficiency of service history data for possible certification credit.\n\nFurther extending the above taxonomy, gaps in the current guidance relative to each area of questions and the associated paragraphs in DO-178B are highlighted along with possible approaches to close these gaps. Following the discussion of the four parts of the product service history definition, a description of the relationship of process assurance and equivalent safety to product service history is provided. The report concludes with a research summary and suggestions for further actions stemming from this research effort.\n1. INTRODUCTION.\n\n1.1 PURPOSE.\n\nThis report, produced under a Federal Aviation Administration (FAA) research contract, discusses gaps in industry practice and knowledge of software service history for which further work is needed. It is closely related to the Service History Handbook that was also created as part of this research effort. This report is intended for use as a planning document for policy and guidance development, as well as follow-on research efforts in the areas of service history credit for certification and system approvals. Both the report and the handbook adopt the same questions-based approach to highlight specific areas of concern in the evaluation of service history data.\n\nThe primary subject of both the handbook and report is the provision of certification credit for software for which little is known about the design assurance and verification activities. Data from the development may be incomplete or inaccessible to those wishing to use the software in a safety-related application. Of particular concern are the differences between formal verification of the software and experience realized through service usage of the software.\n\nWhile the handbook is intended for use by both the FAA and industry practitioners, this report is primarily for FAA use. It expands on a number of topics found in the handbook for the purposes of highlighting specific gaps and contradictions that were found during the course of the research effort. It also serves as the collection point for the raw data that was collected and reviewed during the execution of the service history contract. For completeness, the technical content of the handbook also appears in this document. This allows the report to stand alone.\n\n1.2 SCOPE.\n\nThe scope of this report and the underlying research is restricted to software used in airborne applications. This would include avionics, electronic engine controls, in-flight entertainment systems, etc. While aviation-related use of software service history on the ground was not included, it is expected that many of the same issues apply.\n\nWhile primarily focused in the area of software, it should be noted that many of the concerns and issues raised in the report might also be extended for application to complex electronic hardware.\n\n1.3 BACKGROUND.\n\nDuring the creation of DO-178B, product service history was identified as a possible alternative method for demonstrating compliance to one or more of the objectives in DO-178B\\(^1\\). To date, use of this method has been limited due to both the difficulty in demonstrating the relevance and sufficiency of the product service history, as well as a lack of any consistent guidance for approaching such a demonstration. It is hoped that the results of this research may allow such guidance to be developed.\n\n\\(^1\\) DO-178B is invoked by the FAA through Advisory Circular 20-115B. ED-12B, the EUROCAE equivalent of DO-178B, is similarly invoked by Temporary Guidance Leaflet (TGL) #4, by the Joint Airworthiness Authorities (JAA).\nThis report, along with the accompanying handbook, attempts to capture in one place what is known about the topic of product service history. Using the guidance provided in DO-178B as a starting point, other safety-critical industries were canvassed in an attempt to identify if service history was being used as part of system evaluations, and if so, in what manner. Similarly, other sources of guidance for the aviation industry were explored, most notably the work accomplished by Radio Technical Commission for Aeronautics (RTCA) Special Committees 180 and 190 (SC-180 and SC-190) and by the Certification Authorities Software Team (CAST).\n\nSC-180, which produced DO-254, “Design Assurance Guidance for Airborne Electronic Hardware,” outlines how product service experience may be used “to substantiate design assurance for previously developed hardware and COTS components.” DO-254 was released in April 2000. DO-254’s treatment of product service experience is contained in two separate sections, 11.3 and Appendix B, paragraph 3.2. The guidance in 11.3 closely parallels the guidance in DO-178B for product service history. However, the guidance in the appendix requires additional design assurance for level A and B hardware if service experience is claimed. There is also a requirement to link any analysis of product service history experience into the functional failure path analysis for levels A and B. This is analogous to the tie back to system safety objectives required in 12.3.5 of DO-178B.\n\nSC-190 is still an active committee, although their final work products are currently moving through editorial review as of the publication of this handbook. Their outputs include DO-248B and a guidance document for nonairborne Communication, Navigation, Surveillance/Air Traffic Management (CNS/ATM) ground systems. Within DO-248B, frequently asked question No. 19 and discussion paper No. 4 specifically address the use of product service history. The content of these items have been reflected in this handbook. Considerable discussion occurred in the SC-190 CNS/ATM subgroup on the establishment of a tiered approach to minimum service history duration based on criticality levels. No consensus could be reached on the minimum duration since the proposals were derived from the software reliability field that is not viewed by some to be a mature field.\n\nCAST is comprised of representatives of certification authorities from Europe, Canada, and the United States. CAST meets regularly to discuss technical and regulatory matters related to the uniform interpretation of DO-178B and related guidance. CAST produced a position paper on the subject of product service history. Both the final paper and a number of earlier drafts were considered in the course of completing this research effort.\n\nIn addition to the aviation sources mentioned above, numerous references were reviewed from the nuclear, military, consumer products, and medical devices domains, as well as general software literature. The most mature treatment of the topics were found in Europe, most notably in standards published by the United Kingdom Ministry of Defense (MoD) and safety-consulting called Adelard. In addition to the written materials that were reviewed, a series of interviews were conducted with practitioners in these other fields to further explore exactly how the subject of service history was addressed in practice.\n\nThe final activity, prior to the actual creation of this handbook, was the conduct of a detailed breakout session during the FAA’s National Software Conference held in Boston, MA, in June\n2001. Preliminary results of the study were shared and feedback was sought relating to specific issues arising from the product service history definition. Both the interviews and the breakout session served to validate the findings from the literature review and contributed greatly to the final contents of both the report and handbook.\n\n1.4 THE RESEARCH EFFORT.\n\nThe research effort consisted of four basic steps: data collection, data analysis, data synthesis (including gap analysis), and gap closure plan development. Two deliverables were produced as a result of these activities, a handbook usable by both the government and industry in evaluating and applying the concept of product service history and a report (this document) capturing the overall results of the research effort along with any identified gaps in existing guidance and plans for closing those gaps.\n\nFigure 1 illustrates the basic flow for the four activities.\n\n![Diagram showing the flow of research activities: Data Collection, Data Synthesis & Gap Analysis, Data Analysis, Gap Closure Planning, Report, Handbook]\n\n**FIGURE 1. OVERALL RESEARCH EFFORT DESIGN**\n\nTwo taxonomies (see figure 2) were identified early on as a way to organize the research effort. The first of these involved the elements of the product service history definition.\n\nThis taxonomy resulted in four specific areas of questions that were explored in depth. These were time, operations, environment, and problem reporting. The second taxonomy was intended to segregate the issues associated with evaluating product service history into regulatory, procedural, and technical components. While the first of these taxonomies worked well, the second was never fully realized. In reality, there is very little distinction that can be made between procedural and regulatory aspects of product service history. There is some value in separating out the technical aspects, which is accomplished in the research summary.\nFIGURE 2. RESEARCH TAXONOMIES\n\nData collected in the first phase of the effort was analyzed and parsed using the taxonomy just discussed along with a series of questions related to the definition of product service history. A generic checklist, included as part of appendix A, was used to facilitate the data review and analysis process. The results of the data analysis were then used to populate the handbook. Where gaps were identified in the data, relating to how product service history could be evaluated, the gap was described and a possible approach to filling the gap was identified. This information was captured in the report as part of the data synthesis activity. A small number of interviews and a breakout session at the 2001 National Software Standardization Conference were used to validate the findings from these efforts. Final cleanup and assembly of both the report and handbook resulted in additional insights that are captured herein as possible future research areas.\n\n1.5 RELATED ACTIVITIES/DOCUMENTS.\n\nThe following documents relate directly to the issues addressed herein and define the nature of the problem studied in this evaluation:\n\na. DO-178B/ED-12B\nb. DO-254/ED-80\nc. DO-248B/ED-94B\nd. FARs and associated AC’s, most notably\n - XX.1309\n - XX.1301\n - XX.901\n\nwhere XX represents the aircraft type for example, 25.1309, 23.1309 etc.\nIn addition, FAA Notices 8110.85 and 8110.89 are relevant to this discussion. Finally, specific discussion papers presented at the RTCA SC-167 and SC-190 meetings were reviewed and considered. In many cases, these papers contained useful ideas that were not included in the final products of their associated committees due to a lack of consensus or the constraints placed on the committee.\n\n1.6 DOCUMENT STRUCTURE.\n\nThis report follows a similar structure to that found in the handbook. The major discussions in sections 2 through 5 are repeated from the handbook and are annotated with additional notes. Two subsections are introduced for each element of section 3. The first of these subsections incorporates the relevant worksheet that addresses the question area and contradictions in the material related to that specific topic. The second subsection outlines gaps and steps that might be taken to close the gaps ranging from improved guidelines for use of product service history to follow-on research for identifying workable approaches. There are two appendices that capture the detailed work accomplished to develop both the handbook and this report. These include the full bibliography, research notes from the source review, and detailed notes from the interviews. A brief summary of the contents is provided here for reference.\n\nSection 1 provides introductory material including the purpose, scope, background, and related documents.\n\nSection 2 discusses DO-178B’s treatment of the Product Service History alternative method, as well as its definition.\n\nSection 3 provides a detailed discussion of the elements that comprise the product service history definition.\n\nSection 4 discusses the relationship of product service history to both process and product assurance.\n\nSection 5 draws the various aspects of a product service history argument together for the purposes of illustrating how an equivalent level of safety argument might be made using product service history data.\n\nSection 6 provides a summary of the research effort, as well as a set of recommendations to address systemic gaps.\n\nAppendix A provides notes on data collection and data synthesis associated with the various sources (references, interviews, and the industry feedback session at the FAA Nation Software Conference).\n\nAppendix B is the complete list of sources used in the literature search.\n\nNote: Throughout both the handbook and the report, the language and the philosophy of DO-178B are retained. For example, the vocabulary used in various domains of this research is different from that used in DO-178B. Words such as in-service history, field data,\noperating experience, operational history, proven-in-use data, and item history, are used for product service history. A translation has been performed to maintain commonality of terms with those used in DO-178B.\n\n2. DO-178B FRAMEWORK.\n\nWith almost 20 years of usage by the airborne software community, DO-178 is the measure by which all airborne software in safety-critical applications is measured in civil aviation. As such, it is important that studies, such as this one, relate their findings back to DO-178B, and in particular, the processes identified in this guidance. Toward that end, every effort has been made to ensure that where gaps have been identified, the affected process and the corresponding objective evidence needed to demonstrate compliance with the process have been highlighted. Each proposal to fill the perceived gap has been placed in context of one or more DO-178B processes that would be satisfied once the gap is closed.\n\nDO-178B outlines a total of 66 objectives that should be satisfied for software with the highest potential impact on safety in the event of its failure (Level A). Four additional levels of software are provided (Levels B through E), each with a decreasing number of objectives that must be satisfied as the potential safety impact is reduced. All of the objectives are described in the context of the software development process and a series of integral processes that cut across the entire software development effort. In addition, DO-178B discusses a small number of alternative methods for demonstrating compliance to 1 or more of the 66 objectives. Product service history is one such alternative method.\n\nNote: The idea of software levels that correspond with specific levels of safety is maintained in both the handbook and the report. This tiered approach is common in other domains; however, the exact level definition may be slightly different. A translation was attempted for the purposes of comparison with and subsequent incorporation of specific approaches from these sources. However, difficulties in establishing system safety levels without using error rates prevented a recommendation of a tiered approach to product service history assurance.\n\n2.1 THE DEFINITION OF PRODUCT SERVICE HISTORY.\n\nDO-178B defines product service history as “a contiguous period of time during which the software is operated within a known environment, and during which successive failures are recorded.” This definition has three major components:\n\n- Problem reporting\n- Environment\n- Time\n\nFor the purposes of this report, the environment component has been subdivided into two pieces, one focused on external operations such as operating modes, people, and procedures; and the second focused on computing (hardware environment) aspects of the software. Likewise, the problem reporting component has been broadened to include all facets of configuration management as they relate to the use of product service history.\nDO-178B, Section 12.3.5, states that the acceptability of any argument predicated on the use of product service history depends on six items:\n\n- Configuration Management of the Software\n- Effectiveness of Problem Reporting Activity\n- Stability and Maturity of the Software\n- Relevance of Product Service History Environment\n- Actual Error Rates and Product Service History\n- Impact of Modifications\n\nA total of 11 specific guidance statements are then provided for the purposes of evaluating and demonstrating that these six items have been satisfied. These 11 items (a through k), are discussed in section 2.2 of this report in the context of one or more elements of the definition of product service history.\n\n2.2 ANALYSIS OF PRODUCT SERVICE HISTORY IN DO-178B.\n\nThe following table was constructed as a result of analysis of current guidance given in DO-178B, Section 12.3.5. Each item in this section was studied to understand what questions must be asked to get pertinent information and what additional considerations are not discussed directly in DO-178B. The taxonomy described in section 1.4 of this document (problem reporting, operation, environment, and time) is used to classify the contents of DO-178B, Section 12.3.5. A preliminary set of questions was derived during this analysis; these questions were later improved as gaps were recognized. The completed sets of questions within each taxonomy appear as worksheets in section 3.\n<table>\n<thead>\n<tr>\n<th>DO-178B Section 12.3.5 Reference</th>\n<th>Observations on DO-178B Section 12.3.5</th>\n<th>Software Service History Questions</th>\n<th>Question Category</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>a.</strong> The applicant should show that the software and associated evidence used to comply with system safety objectives have been under configuration management throughout the product service history.</td>\n<td>If this evidence for safety objectives is missing or noncompliant, there is no work around. The service history data that is associated with software that is not configuration controlled should not be used as evidence since there is no confidence in the data or software. There is no basis for computing error rates.</td>\n<td>1. Are the software versions tracked during the service history duration? 2. Are problem reports tracked with respect to particular versions of software? 3. Are problem reports associated with the solutions/patches and an analysis of change impact? 4. Is revision/change history maintained for different versions of the software? 5. Have change impact analyses been performed for changes?</td>\n<td><strong>Question of Problem Reporting</strong></td>\n</tr>\n<tr>\n<td><strong>b.</strong> The applicant should show that the problem reporting during the product service history provides assurance that representative data is available and that in-service problems were reported and recorded and are retrievable.</td>\n<td>If this evidence is unsatisfactory, the significance of available service history data is reduced. There are a number of issues regarding the integrity of problem reporting system: the vendors' self-interest in not publishing all of the problem data, not all of the data may be reported, not all of the data may be recorded. In case there are doubts as to whether “representative” data are available, the available data may be used for finding out if there were safety critical problems during the service history duration without taking credit for certification. Although this item is describing the elements of configuration control, the guidance does not directly state that the problem reports need to be under configuration control.</td>\n<td>1. Were in-service problems reported? 2. Were all reported problems recorded? 3. Were these problem reports stored in a repository from which they can be retrieved? 4. Were in-service problems thoroughly analyzed and are those analyses included or appropriately referenced in the problem reports?</td>\n<td><strong>Question of Problem Reporting</strong></td>\n</tr>\n<tr>\n<td>DO-178B Section 12.3.5 Reference</td>\n<td>Observations on DO-178B Section 12.3.5</td>\n<td>Software Service History Questions</td>\n<td>Question Category</td>\n</tr>\n<tr>\n<td>-----------------------------------</td>\n<td>----------------------------------------</td>\n<td>-----------------------------------</td>\n<td>------------------</td>\n</tr>\n<tr>\n<td>c. Configuration changes during the product service history should be identified and the effect analyzed to confirm the stability and maturity of the software. Uncontrolled changes to the Executable Object Code during the product service history may invalidate the use of product service history.</td>\n<td>This point is also dealing with the integrity of the problem data, in terms of whether the software was under configuration control. Without configuration control, the problem reports cannot be associated with specific versions of the software. Uncontrolled changes to software also indicate deficiencies in the development process.</td>\n<td>1. Is each problem report tracked with its status of whether it is fixed or open? 2. If a problem was fixed, is there a record of how the problem was fixed? 3. Is there a record of the new version of software with the new release after the problem was fixed? 4. Are there problems with no corresponding record of change in software version? 5. Does the change history show that the software is currently stable and mature?</td>\n<td>Question of Problem Reporting</td>\n</tr>\n<tr>\n<td>d. The intended software usage should be analyzed to show the relevance of the product service history.</td>\n<td>If there are fundamental differences in the usage, the product cannot be used in the proposed environment and there will not be any need to use the service history. In some cases, additional code, in the form of a "wrapper" or "glue code," may be needed to integrate the existing software into the new operating environment. In this case, the effect of this additional code on the relevance of the service history should also be considered.</td>\n<td>1. Is the intended software operation similar to the usage during the service history? (Its interface with the external "world," people, and procedures.) 2. Have the differences between service usage and proposed usage been analyzed?</td>\n<td>Questions of Operation and Environment</td>\n</tr>\n<tr>\n<td>e. If the operating environments of the existing and proposed applications differ, additional software verification should confirm compliance with the system safety objectives.</td>\n<td>There is no guidance on what elements of the two operating environments need to be compared. There exists a dilemma in the case of multiple copies of the product being used in many diverse operating environments, service history in a dissimilar environment may actually give a larger coverage of input/output space and thus resulting in problem reports, which may not have been written up if the product was executed only in a similar environment.</td>\n<td>1. If the input/output domains differ between service history duration and intended use, has there been an analysis of what functions are covered by the service history? 2. Is the hardware environment of service history and the target environment similar? 3. Is the product compatible with the target computer without</td>\n<td>Question of Operation and Environment</td>\n</tr>\n</tbody>\n</table>\n### TABLE 1. ANALYSIS OF DO-178B, SECTION 12.3.5 (Continued)\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Section 12.3.5 Reference</th>\n<th>Observations on DO-178B Section 12.3.5</th>\n<th>Software Service History Questions</th>\n<th>Question Category</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>f. The analysis of configuration changes and the product service history environment may require the use of software requirements and design data to confirm the applicability of the product service history environment.</td>\n<td>This item is a companion to items c and e. The text in DO-178B does not claim that software requirements and design data will be needed for this analysis nor does it claim that these are the only sources of needed information. In fact, the required information may be present from looking at the problem reports, version dates, patch descriptions, and perhaps details of how the problem was fixed which might be present in the problem report logs/database. If this additional information is insufficient, then the requirements and design data may need to be reviewed.</td>\n<td>making modifications to the product software? 4. If the computer environments are different, are the differences verified (through analysis and/or testing)? 5. Are there differences in the operating modes in the new usage?</td>\n<td>Questions of operation, environment, and problem reporting</td>\n</tr>\n<tr>\n<td>g. If the software is a subset of the software that was active during the service period, then analysis should confirm the equivalency of the new environment with the previous environment and determine those software components that were not executed during normal operation.</td>\n<td>This item does not discuss what happens to functions that are not going to be used in the proposed application. Assurance requirements for dead code or deactivated code in DO-178B may apply, depending upon the technique used to prevent the usage of these functions.</td>\n<td>1. Are only some of the functions of the proposed application used in service usage? 2. Is there a gap analysis of functions that are needed in the proposed application but have not been used in the service duration?</td>\n<td>Questions of Operation and Environment</td>\n</tr>\n</tbody>\n</table>\n\nNote: Additional verification may be needed to confirm compliance with the system safety objectives for those components.\nTABLE 1. ANALYSIS OF DO-178B, SECTION 12.3.5 (Continued)\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Section 12.3.5 Reference</th>\n<th>Observations on DO-178B Section 12.3.5</th>\n<th>Software Service History Questions</th>\n<th>Question Category</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>h. The problem report history should be analyzed to determine how safety-related problems occurred and which problems were corrected.</td>\n<td>If safety-related problems are still pending, the analysis must show that the problem is not an issue for the intended application. This is generally a difficult issue since, if the operational environment is similar, the safety critical problem is of significance; if the operational environment is not similar, then the service history is not of consequence.</td>\n<td>1. Are all problems within the problem report repository classified? 2. Are safety-related problems identified as such? 3. Can safety-related problems be retrieved? 4. Is there a record of which problems are fixed and which problems are left open? 5. Is there enough data after the last fix of safety-related problems to assess that the problem is solved, and that no new safety-related problems have surfaced? 6. Do open problem reports have any safety impact?</td>\n<td>Question of Problem Reporting</td>\n</tr>\n<tr>\n<td>i. Those problems that are indicative of an inadequate process, such as design or code errors, should be indicated separately from those whose cause are outside the scope of this document such as hardware or system requirements errors.</td>\n<td>The level of detail that is required here for logging problem reports with their solutions and the source of errors may itself indicate good engineering practice. A lack of sufficient information may be indicative of an inadequate process.</td>\n<td>1. Are the problem reports and their solutions classified to indicate how a fix was implemented? 2. Is it possible to separate those problems that caused a design or code correction? 3. Is it possible to separate the problem reports that were fixed in the hardware or change of requirements?</td>\n<td>Questions of Problem Reporting and Environment</td>\n</tr>\n<tr>\n<td>The data described above and these items should be specified in the Plan for Software Aspects of Certification: j. (1) Analysis of the relevance of the product service history environment</td>\n<td>Analysis of the relevance of the product service history environment is discussed in items d, e, f, g, and i.</td>\n<td>All questions on similarity of usage and operational environment associated with these items apply.</td>\n<td>Questions of Operation and Environment</td>\n</tr>\n</tbody>\n</table>\nTABLE 1. ANALYSIS OF DO-178B, SECTION 12.3.5 (Continued)\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Section 12.3.5 Reference</th>\n<th>Observations on DO-178B Section 12.3.5</th>\n<th>Software Service History Questions</th>\n<th>Question Category</th>\n</tr>\n</thead>\n</table>\n| The data described above and these items should be specified in the Plan for Software Aspects of Certification: | Item j (2) has a requirement for calculating the length of service history duration by taking into consideration the number of hours of service, similar operation, and the number of independently operating copies. However, the independence here is not fully applied. It is inferred that the independence in operation should result in statistically independent error rates. The definition of normal operation is also left up to the applicant. This definition should be consistent with the proposed use of the software. | 1. What is the definition of service period? \n2. Is the service period defined appropriate to the nature of software in question? \n3. How many copies of the software are in use and being tracked for problems? \n4. Are the input/output domains the same? \n5. What was the criterion for evaluating the service period duration? \n6. What is the definition of normal operation time? \n7. Does the service period include normal and abnormal operating conditions? \n8. Is the definition of normal operation and normal operation time appropriate to the product? | Question of Time, Environment, and Operation |\n| j. (2) Length of Service period and rationale for calculating the number of hours of service, including factors such as operational modes, the number of independently operating copies in the installation and in service, and the definition “normal operation” and “normal operation time.” | | | |\n| The data described above and these items should be specified in the Plan for Software Aspects of Certification: | Item j (3) is not referenced directly in any of the other items; there is a reference to classification of problems in item h where the classification does not go beyond whether the problem was safety related. Definition of errors here refers to how errors were defined in the service history data. It is important that this definition have an acceptable rationale, and also, that the definition should have been applied to all of the problems consistently throughout the service history duration. | 1. Was there a procedure used to log the problem reports as errors? \n2. What was the reasoning behind the contents of the procedure? \n3. Is there evidence that use of this procedure was enforced and used consistently throughout the service history period? | Question of Problem Reporting |\n<p>| j. (3) Definition of what was counted as an error and rationale for that definition. | | | |</p>\n<table>\n<thead>\n<tr>\n<th>DO-178B Section 12.3.5 Reference</th>\n<th>Observations on DO-178B Section 12.3.5</th>\n<th>Software Service History Questions</th>\n<th>Question Category</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>The data described above and these items should be specified in the Plan for Software Aspects of Certification: j. (4) Proposed acceptable error rates and rationale for the product service history period in relation to the system safety and proposed error rates.</td>\n<td>Acceptable methods for computing error rates are not stated in DO-178B. The requirement that this has to be forecast in relationship with the system safety is in direct conflict with the idea that software reliability measures cannot be used to justify safety, nor can these numbers be used in system safety analysis. The duration that is used in the equation for computing error rates can be varied. If data exists from many application environments but only a few of these environments are similar to the target environment, not all available errors or the duration can be used in the error rate computation. In that case, if there were noted safety problems in the applications that are not considered in the error rate, should we be concerned? Common sense dictates that we should be. However, if we do not use this data in the error rate, how can we consider these problems?</td>\n<td>1. Do you have a proposed error rate, justifiable and appropriate for the level of safety of proposed usage, (before analyzing the service history data)? 2. How do you propose that this error rate be calculated (before analyzing the service history data)? 3. Is the error rate computation appropriate to the application in question? Note: (Error rates may be computed in a number of different ways, such as total errors divided: • by time duration • by number of execution cycles • by number of events such as landing • by flight hours • by flight distance • by total population operating time • by number of hours during which the product is expected to perform. (Other definitions for error rates may be used depending upon the particular usage.)</td>\n<td>Questions of Time, Operation, Environment, and Problem Reporting</td>\n</tr>\n</tbody>\n</table>\n### TABLE 1. ANALYSIS OF DO-178B, SECTION 12.3.5 (Continued)\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Section 12.3.5 Reference</th>\n<th>Observations on DO-178B Section 12.3.5</th>\n<th>Software Service History Questions</th>\n<th>Question Category</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>k. If the error rate is greater than that identified in the plan, these errors should be analyzed and the analyses reviewed with the certification authority.</td>\n<td>Same issues as in item j (4) above exist for this item. Unless a method for using error rates in system safety assessment is established, this item cannot be resolved objectively. Also, there is no mention here of whether the errors were safety related or not. High error rates of nonsafety problems cannot have the same weight as the low error rates of safety problems. Although, item h deals with an analysis of safety problems and the problems that may not have been fixed, the analysis is not required to be used in the review of error rates. Error rates during normal operation within the service history duration are usually large soon after deployment of major corrections and releases. It is not clear whether the referenced error rates are over the span of the entire period of service history or a selected section such as in the last year of usage. Although impact of modifications is cited as one of the considerations in the acceptability of service history for certification credit (in the lead in paragraph of section 12.3.5), it is not referenced in the determination of error rates. For example, error rates can be computed for every version of the software product or it can be computed for all versions combined. This relates to the problem of what are the rules for computing the time duration, i.e., the rules for resetting the clock. This also brings up the point of whether the applicant can choose to use only the last 2 years of contiguous service history during which the software may be more stable compared to the very first fielding of the product. The guidance is silent on how long is long enough for a particular level, whether the length of service history is important, definition of error rates, definition of stability, and how to use error rates in system safety assessment to arrive at what rates are acceptable for a given criticality level.</td>\n<td>1. What is the actual error rate computed using the service history? 2. Is this error rate greater than the proposed acceptable error rate defined in PSAC, according to J(4)? 3. If the error rate is greater, was analysis conducted to reassess the error rates?</td>\n<td>Question of Problem Reporting</td>\n</tr>\n</tbody>\n</table>\n2.3 RELATIONSHIP WITH PREVIOUSLY DEVELOPED SOFTWARE.\n\nDO-178B uses the term previously developed software (PDS) to describe software that falls in one of three categories:\n\n- Commercial Off-The-Shelf (COTS) software,\n- Software developed to a standard other than DO-178B, and\n- Software developed prior to DO-178B.\n\nBy this definition, it is hard to imagine an instance when a product service history argument will be made on software other than PDS. DO-178B provides specific guidance for PDS that should be used in conjunction with the contents of this report when seeking certification credit. Combining alternative methods to meeting one or more objectives is best accomplished by conducting a gap analysis designed to determine where data may be insufficient to clearly demonstrate compliance with the objective. Such an approach is described in DO-248, discussion paper No. 5.\n\n2.4 PRODUCT SERVICE HISTORY VERSUS SOFTWARE RELIABILITY.\n\nThe DO-178B definition of product service history is very similar to the IEEE definition of reliability, which is “the ability of a product to perform a required function under stated conditions for a stated period of time.” It should also be noted that DO-178B states the following paragraphs regarding software reliability:\n\nSection 2.2.3: “Development of software to a software level does not imply the assignment of a failure rate for the software. Thus, software levels or software reliability rates based on software levels cannot be used by the system safety assessment process as can hardware failure rates.”\n\nSection 12.3.4: “During the preparation of this document, methods for estimating the post-verification probabilities of software errors were examined. The goal was to develop numerical requirements for such probabilities for software in computer-based airborne systems or equipment. The conclusion reached, however, was that currently available methods do not provide results in which confidence can be placed to the level required for this purpose. Hence, this document does not provide guidance for software error rates. If the applicant proposes to use software reliability models for certification credit, rationale for the model should be included in the Plan for Software Aspects of Certification, and agreed with by the certification authority.”\n\nThe effect of these two statements has been a virtual moratorium on the application or even exploration of software reliability as an alternative method for satisfying DO-178B.\n\nThis creates an inherent difficulty for the product service history approach as well, since service history arguments are largely predicated on the residual error rates or the probability of latent software errors remaining after verification. The authors of DO-178B side-stepped this issue by allowing certification credit for service history based on qualitative assessments of the sufficiency and relevancy of the product service history.\n3. THE ELEMENTS OF PRODUCT SERVICE HISTORY.\n\nAs noted in the previous section, the topic of product service history may be examined by looking at the various elements that comprise its definition. For the purposes of this report, four components were defined: problem reporting, operations, environment, and time. Considering each of these components separately results in different but interrelated sets of questions that must be asked when the use of product service history is being considered. The questions have been broken into these classes only to simplify the problem. Answers to these questions must satisfy both the relevancy and sufficiency criteria discussed in Section 12.3.5 of DO-178B.\n\nThis section provides a discussion of each set of questions arising from the product service history definition. One representation of these questions is provided in the form of worksheets. While these worksheets may be adapted or tailored to fit a particular project, users are cautioned to maintain an objective view when evaluating service history data. As illustrated in the sections below, even subtle changes in any one of the four areas can lead to unpredictable results when software is used in a new system or in a way not originally envisioned.\n\n3.1 QUESTIONS OF PROBLEM REPORTING.\n\nQuestions of problem reporting are primarily the same as ones faced in configuration control and management. All of the elements of DO-178B Section 11.4, Software Configuration Management (SCM) Plan, apply. The problems have to be uniquely identified, they should be traceable to the version of software/product, a method of closing the problems must be defined, and closure of the problems must be accomplished with proper change control activity. Changes must be reviewed for priority of problems and change impact. Data on problems, corrections, and baselines must be kept under control to assure the integrity of data.\n\nAll of these activities are a natural part of a well-defined process. However, in the case of previously developed software (PDS), it is assumed that these activities are not visible to the user of the product. The vendor who is in charge of problem collection may not have a robust process. The vendor may not have a robust policy for classifying and prioritizing the problems. This is further exacerbated by multiple users employing the software in ways to which the vendor has no visibility.\n\nWhen patches are installed, some users may install the patch, whereas many others may not. This means that some users are using the uncorrected version and some are using the corrected version. This results in a service history that cannot be treated as a monolithic block, rather, it must be distributed across the different versions. Only those versions with a clear similarity to the intended use may be used to arrive at the total product service history. There are numerous reasons affecting problem report classification and accuracy including:\n\n- Not all users may be using the product per the user manual.\n- Vendors may not have a complete, consistent, or accurate way of identifying those problems attributable to software.\n- Not all users may be reporting all of the problems.\n• Users may find work-around procedures and thus stop reporting all occurrences.\n\n• Vendors may not require subsequent occurrences of a problem to be reported.\n\n• Vendors may treat problems found internally differently from those found by their customers, thus underreporting the total number of problems experienced.\n\nProblems may also be introduced while fixing other problems. Such problems should also be logged once the product is fielded. If some of the problems are unique to a particular small sector of users, the vendor may not fix the problem or may selectively provide a patch. Attention must be paid to the number and type of open problems. A vendor’s policy for choosing which errors are to be fixed should also be noted in the qualitative assessment. A vendor may place priority on non-safety-critical problems reported by a large sector of users over safety-critical problems reported by a small sector of users.\n\nAssignment of version numbers and tracking the operating versions of the product to be traced to the problems is a difficult task. If vendors provide patches for their software or frequently introduce revisions to the field, this must be taken into account in arriving at the total number of versions for which service history is valid, and for which the total service periods can be combined.\n\nVisibility into how problems were fixed may be of use when the solutions affect the usage of the product in a safety-critical application (whether requirements were compromised, new assumptions were made, new requirements were added, new design features were added, change-impact analysis was conducted, list of affected requirements/assumptions are provided to user, any effect on hardware is noted, etc.).\n\nSome vendors may be following certain regulations or policy regarding configuration control of the problem reporting process. Such policies may help in determining if service history data is clean. Some problems may also be corrected in periodic upgrades of the product. It is important to understand the vendor’s policy for dissemination of patches, warnings, work-arounds, and upgrades. After a new version is disseminated, spikes in error rates need to be traced to assess the complexity of changes, the quality of change-impact analysis, the quality of the vendor’s verification process, and the diversity of the product usage.\n\n3.1.1 Individual Questions to Consider.\n\nThe key questions to be addressed in the area of problem reporting and configuration management for the purpose of establishing the minimum objective criteria for using service history include a good consistent definition of problems, classification of problems, tracking with respect to software versions, and tracking with respect to solutions.\n\nTable 2 provides a set of questions in the form of a worksheet that may be used to evaluate the relevance and sufficiency of problem report/configuration management using the data available from product service history. Further, this table indicates where there are gaps in DO-178B\nguidance with respect to problem reports and analyses that should be performed for calculation of error rates.\n\nThe following considerations, based on Section 12.3.5 of DO-178B, were used in formulating the questions in table 2:\n\n- Data available on problems\n- Data derivable from the problem reports\n- Analysis to be performed\n- Indications of supplemental verification\n\n**TABLE 2. WORKSHEET FOR QUESTIONS OF PROBLEM REPORTING**\n\n<table>\n<thead>\n<tr>\n<th>Area: Problem Reporting/Configuration Management</th>\n<th>Software Being Evaluated:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Project:</td>\n<td>Evaluator:</td>\n</tr>\n<tr>\n<td>Date:</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Reference</th>\n<th>Question</th>\n<th>Response</th>\n<th>Issues</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. 12.3.5 a and c</td>\n<td>Are the software versions tracked during the service history duration?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2. 12.3.5 a and c</td>\n<td>Are problem reports tracked with respect to particular versions of software?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>3. 12.3.5 a</td>\n<td>Are problem reports associated with the solutions/patches and an analysis of change impact?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>4. 12.3.5 a</td>\n<td>Is revision/change history maintained for different versions of the software?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>5. 12.3.5 a</td>\n<td>Have change impact analyses been performed for changes?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>6. 12.3.5 b</td>\n<td>Were in-service problems reported?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>7. 12.3.5 b</td>\n<td>Were all reported problems recorded?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>8. 12.3.5 b</td>\n<td>Were these problem reports stored in a repository from which they can be retrieved?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>9. 12.3.5 b</td>\n<td>Were in-service problems thoroughly analyzed and/or those analyses included or appropriately referenced in the problem reports?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>10.</td>\n<td>Are problems within the problem report repository classified?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>DO-178B Reference</td>\n<td>Question</td>\n<td>Response</td>\n<td>Issues</td>\n</tr>\n<tr>\n<td>------------------</td>\n<td>--------------------------------------------------------------------------</td>\n<td>----------</td>\n<td>--------</td>\n</tr>\n<tr>\n<td>11.</td>\n<td>If the same type of problem was reported multiple times, were there multiple entries or a single entry for a specific problem?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>12.</td>\n<td>If problems were found in the lab in executing copies of operational versions of software during the service history period, were these problems included in the problem reporting system?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>13. 12.3.5 c</td>\n<td>Is each problem report tracked with the status of whether it is fixed or open?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>14. 12.3.5 c</td>\n<td>If the problem was fixed, is there a record of how the problem was fixed (in requirements, design, code)?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>15. 12.3.5 c</td>\n<td>Is there a record of a new version of software with new release after the problem was fixed?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>16. 12.3.5 c</td>\n<td>Are there problems with no corresponding record of change in software version?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>17. 12.3.5 c</td>\n<td>Does the change history show that the software is currently stable and mature?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>18.</td>\n<td>Does the product have the property of exhibiting the error with a message to the user? (Some products may not have error trapping facilities, so they may just continue executing with wrong results and with no indication of failure.)</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>19.</td>\n<td>Has the vendor (or the problem report collecting agency) made it clear to all users that problems are being collected and corrected?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>20. 12.3.5 h</td>\n<td>Are all problems within the problem report repository classified?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>21. 12.3.5 h</td>\n<td>Are safety-related problems identified as such? Can safety-related problems be retrieved?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>22. 12.3.5 h</td>\n<td>Is there a record of which safety problems are fixed and which problems are left open?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>DO-178B Reference</td>\n<td>Question</td>\n<td>Response</td>\n<td>Issues</td>\n</tr>\n<tr>\n<td>------------------</td>\n<td>----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</td>\n<td>----------</td>\n<td>--------</td>\n</tr>\n<tr>\n<td>23. 12.3.5.h</td>\n<td>Is there enough data after the last fix of safety-related problems to assess that the problem has been corrected and no new safety-related problems have surfaced?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>24. 12.3.5h</td>\n<td>Do open problem reports have any safety impact?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>25.</td>\n<td>Is there enough data after the last fix of safety-related problems to assess that the problem is solved and no new safety-related problems have surfaced?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>26. 12.3.5 i</td>\n<td>Are the problem reports and their solutions classified to indicate how a fix was implemented?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>27. 12.3.5 i</td>\n<td>Is it possible to trace particular patches with release versions and infer from design and code fixes that the new versions correspond to these fixes?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>28. 12.3.5 i</td>\n<td>Is it possible to separate the problem reports that were fixed in the hardware or change of requirements?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>29.</td>\n<td>Are problem reports associated with the solutions/patches and an analysis of change?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>30.</td>\n<td>If the solutions indicated a change in the hardware or mode of usage or requirements, is there an analysis of whether these changes invalidate the service history data before that change?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>31.</td>\n<td>Is there a fix to a problem with changes to software but with no record of the change in the software version?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>32. 12.3.5 j(2)</td>\n<td>Is the service period defined appropriate to the nature of software in question?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>33. 12.3.5 j(2)</td>\n<td>How many copies of the software are in use and being tracked for problems?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>34.</td>\n<td>How many of these applications can be considered to be similar in operation and environment?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>35. 12.3.5 j(2)</td>\n<td>Are the input/output domains the same between the service duration and the proposed usage?</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### TABLE 2. WORKSHEET FOR QUESTIONS OF PROBLEM REPORTING (Continued)\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Reference</th>\n<th>Question</th>\n<th>Response</th>\n<th>Issues</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>36.</td>\n<td>If the input/output domains are different, can they be amended using glue code?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>37. 12.3.5 j(2)</td>\n<td>Does the service period include normal and abnormal operating conditions?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>38.</td>\n<td>Is there a record of the total number of service calls received during the period?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>39.</td>\n<td>Were warnings and service interruptions a part of this problem-reporting system?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>40.</td>\n<td>Were warnings analyzed to assure that they were or were not problems?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>41. 12.3.5 j(3)</td>\n<td>Was there a procedure used to log the problem reports as errors?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>42. 12.3.5 j(3)</td>\n<td>What was the reasoning behind the contents of the procedure?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>43. 12.3.5 j(3)</td>\n<td>Is there evidence that this procedure was enforced and used consistently throughout the service history period?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>44.</td>\n<td>Does the history of warranty claims made on the product match with the kind of problems seen in the service history?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>45.</td>\n<td>Have problem reports identified as a nonsafety problem in the original domain been reviewed to determine if they are safety related in the target domain?</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n#### 3.1.2 Identified Gaps and Gap Closure—Problem Reporting\n\nThere are considerable gaps in DO-178B’s treatment of problem reporting and configuration management as it relates to product service history.\n\n- **Guidance on Error Detection/Reporting Methods**\n\n The product may not have the property of exhibiting an error with a message to the user or other external symptoms. Some products may not have error-trapping facilities, so they may just continue executing with wrong results with no indication of failure. Such systems will have very few errors logged as problem reports. The gap that needs to be filled here is to include questions on whether service interruptions were a part of this problem-reporting system. In addition, warnings (not necessarily error messages) need to be analyzed to assess if they were truly problems.\n• Guidance on Complete Reporting/Problem Report Format\n\nIt may not make good business sense to a vendor to publish a large number of problems. One cannot assume that all of the problems that were reported were logged into the problem-reporting system. One way to check if any of the problems were left out from the logs is to check if there is a record of a total number of service calls received during the period and check this number against the log entries. Also, logs should be inspected to understand what separates true software problems from user errors. If software errors are classified as system features and user errors, the number of problems will be lower.\n\nThere is no guideline in DO-178B for what constitutes an acceptable problem report. If the vendor had an acceptable policy on how to log problems as errors, logs should be examined to see if there is evidence that this policy was used consistently throughout the service history period. History of warranty claims made on the product should match with the kind of problems seen in the service history.\n\n• Guidance on Consistency in Assessing Safety Effects\n\nIf there are problem reports that are not fixed, the applicant needs to decide if there are safety-critical problems that are not fixed. To analyze the problem, one needs to understand the vendor’s policy on resolving problems. The concern is that if the problem is found by a minority group of users, the vendor may not fix the problem—even if it is a safety problem. Classification of problems may or may not show these errors as critical problems, depending upon the classification of problems.\n\n• Guidance on Correlation of Problem Reports to Specific Fixes\n\nThere is no guidance on how problem reports, the corresponding fixes, and the version of the software related to one another. If the solutions indicated a change in the hardware or mode of usage or requirements, problem reports should be associated with the solutions/patches and an analysis of change. There should be an analysis of whether these changes invalidate the service history data before that change. If there was a fix to a problem with changes to software but with no corresponding record of change in the software version, this indicates that the software was not under proper configuration control. If there is no log entry within the problem-reporting system, correlation of problem reports to software errors may not be possible. If the problems are not categorized, it may be impossible to tell if safety problems are fixed. Imposing an acceptable list of minimum data items that must exist in the vendor’s logs kept under configuration control can fill this gap.\n\n• Guidance on Consistent Policy for Documentation of Problem Reports\n\nThe analysis needs to consider the policy used for entry of problem reports. If the same type of problem was reported multiple times, there may be multiple entries or a single entry for a specific problem. A single entry for multiple occurrences of the problem will make the error rate smaller than it really is. On the other hand, if a user is impatient and\nmakes several calls for the same problem, these multiple calls may or may not be distinguished in the problem logs. If problems were found in the lab in executing copies of operational versions of software during the service history period, these problems may or may not have been included in the problem-reporting system, again skewing the error rate computation. Further, no consistent policy may have been applied; each technical support staff that took the report may have applied his/her own judgment on whether to enter the problem, as well as how to classify them. A common guideline on how to deal with problems and their classification is needed.\n\n- Guidance on an Open Invitation to the Users to Report Problems\n\nUsers may report the problems only when there is such an option available to them. It is important to know if the vendor (or the problem report collecting agency) made it clear to all users that problems are being collected and corrected. If the users were discouraged from reporting problems, there may not be as many service calls and that would make the error rates seem low. A request to see the published technical support policy may be required to trust that such an offer was made to users.\n\n- Guidance on Objective Evidence of Adequate Repair Process\n\nDO-178B does not mention the need for objective evidence for an adequate repair process during the product history. Questions must be included in this regard to analyze problem data after the last fix of safety-related problems to assure that the problem is solved and that no new safety-related problems have surfaced.\n\n- Guidance on Correlation of Problem Reports to Specific Copies Used in Specific Applications\n\nIf there are many users using the products in many different applications, DO-178B requires an analysis of these applications for similar operation and environment. However, the guidance regarding this scenario is unclear. Certain questions need to be asked to bring forth additional information. When some of the applications in use are not considered to be of similar operation and environment, it is important to separate problem reports from those applications from all other problem reports. DO-178B is silent on safety problems reported in these applications. There may also be patches that are implemented into all copies because of problems in these nonrelevent applications. Guidance should be added that provides a correlation between operation, environment, and the problem report when multiple copies are in use.\n\n- Guidance on Glue Code\n\nIf the input/output domains are different, they can be, and often are, amended using glue code. DO-178B service history guidance stays silent on this possibility. It should be noted that glue code could be used to make the environment similar. Guidance should be added to consider glue code as developmental code.\n• Guidance on Evaluating Problems in the Target Environment\n\nProblems that were previously analyzed and determined to be nonsafety related should be re-evaluated to determine if they might have a safety effect in the proposed (target) domain. This issue is not discussed in DO-178B. New guidance should require such an analysis.\n\n3.2 QUESTIONS OF OPERATION.\n\nThe concept of operation is to define the usage characteristics of the software within the previous domain as compared with the target domain. These characteristics include people and procedures and the modes in which the service history was documented against the same items within the target domain. Figure 3 illustrates the type of comparisons that are needed.\n\n![Diagram showing Original Domain and Target Domain with overlaps in Interaction with People, Usage of Procedures, Safety Effects, Normal Operations, Abnormal Operations, and Operational Modes.]\n\n**FIGURE 3. OPERATION**\n\nThere are many concerns in evaluating similarity-of-operation that may not be so obvious. Where people and procedures are concerned, the training and qualifications of the people in the service history domain have to be noted so that the proposed (target) domain of usage can account for this by requiring similar operator training and qualification requirements.\n\nSimilarity in operational modes and the subset of software functions between the service history domain and the target domain are the main focus in this area. In general, it is expected that the functions to be employed in the target domain are a subset of those from the service history domain. Input and output domains may be evaluated in normal and abnormal operations to assess the completeness of coverage of all the functions that are to be reused in the target domain. This is the most fundamental basis for getting credit for service history by assessing that the software has a tried and tested history of pertinent functions.\nConsider the case of ARIANE 5. The self-destruction of the launcher was caused by the failure to mitigate the environmental differences between ARIANE 5 and ARIANE 4. Software reused in ARIANE 5 from ARIANE 4 included a function for the alignment of the strap-down inertial platform to be operative for 50 seconds. This requirement was based on a particular operational sequence of launch that is no longer used. Software exception generated from this portion of the code caused a chain of events that eventually led to shutting off the backup processor, errors in the primary processor causing an angle of attack of more than 20 degrees, separation of booster on the main stage, and self-destruction of the launcher. The reused function should have been operative only before liftoff or there should have been a thorough analysis of abnormal operating modes, differences in flight operations, and nominal range and value of parameters. There should have been a discussion of software exceptions and differences in actions taken to resolve these exceptions. Questions of operation and environment (discussed next) are highly interrelated. In this example, a study of target operations could have found the fault just as easily as a study of the target environment. Note also that what was a normal operation for ARIANE 4 became an abnormal operation for ARIANE 5.\n\nThe total availability of service history data may be much longer than what is considered similar operation. For example, there may be a total of 10,000 copies of particular software in use in the public domain, out of which only 10 copies may be in use in domains similar to the proposed usage. This would have a direct bearing on the ability to calculate error rates. This is discussed in more detail in Section 3.4, Questions of Time, of this document.\n\nModifications to the product during the service history interval need to be studied to understand if these modifications were made for correcting errors in a dissimilar domain (for which service history credit is not being sought). The question here would be to note if change-impact analysis has been performed to assure that the functions that are of consequence in the service history data have not been adversely affected. This is quite possible if the changes have affected either the assumptions or requirements in this area.\n\nIf the service history collection occurred when the software was being used at a lower criticality than the intended usage in the target domain, caution should be exercised in taking credit. The types and severity of errors, as well as open problem reports must be examined to assure that the service history gives the proper level of assurance.\n\nIt must be noted that the service history duration should ideally include both normal and abnormal operations to cover features such as redundancy, backup, other fault-tolerance techniques, and corner conditions. An analysis should be conducted to find which features were not exercised in the service history, so that supplemental verification can be performed.\n\nIf the product was used with different data/parameters (for example adaptation data, external data sets, internal parameters) in the service environment, these differences should be examined for possible risks in the target environment.\n\n---\n\n3.2.1 Individual Questions to Consider.\n\nThe key questions to be addressed in the area of operation for the purpose of establishing the minimum objective criteria for use of service history data include an analysis for establishing similarity of operation between the service history and the proposed application. Service history data that reflect dissimilar operations cannot be used for computing service history duration.\n\nTable 3 provides a set of questions in the form of a worksheet that may be used to evaluate the similarity of operation using the data available from the product service history. Further, this table indicates where DO-178B guidance is lacking with respect to similarity analysis, as well as analyses when dissimilarities are found.\n\nThe following considerations, based on Section 12.3.5 of DO-178B, were used in formulating the questions in table 3:\n\n- Data pertinent to operation\n- Derivable data associated with operations\n- Analysis to be performed\n- Indications of supplemental verification\n\n### TABLE 3. WORKSHEET FOR QUESTIONS OF OPERATION\n\n<table>\n<thead>\n<tr>\n<th>Area:</th>\n<th>Operation</th>\n<th>Software Being Evaluated:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Project:</td>\n<td>Evaluator:</td>\n<td></td>\n</tr>\n<tr>\n<td>Date:</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Reference</th>\n<th>Question</th>\n<th>Response</th>\n<th>Issues</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. 12.3.5 d</td>\n<td>Is the intended software operation similar to the usage during the service history (i.e., its interface with the external world, people, and procedures)?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2. 12.3.5 e</td>\n<td>Have the differences between service history usage and proposed usage been analyzed?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>3. 12.3.5 e</td>\n<td>Are there differences in the operating modes in the new usage?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>4. 12.3.5 g</td>\n<td>Are only some of the functions of the proposed application used in service usage?</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### TABLE 3. WORKSHEET FOR QUESTIONS OF OPERATION (Continued)\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Reference</th>\n<th>Question</th>\n<th>Response</th>\n<th>Issues</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>5. 12.3.5 j(1), g</td>\n<td>Is there a gap analysis of functions that are needed in the proposed application but have not been used in the service duration?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>6. 12.3.5 j(2)</td>\n<td>Is the definition of normal operation and normal operation time appropriate to the product?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>7.</td>\n<td>Does the service period include normal and abnormal operating conditions?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>8.</td>\n<td>Is there a technology difference in the usage of the product from service history duration (manual vs automatic, user intercept of errors, used within a network vs standalone, etc.)?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>9.</td>\n<td>Was operator training on procedures required in the use of the product during the recorded service history time period?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>10.</td>\n<td>Is there a plan to provide similar training in the new operation?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>11.</td>\n<td>Will the software level for the new system be the same as it was in the old system?</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n#### 3.2.2 Identified Gaps and Gap Closure—Operation.\n\n- Guidance on the Analysis of Abnormal Conditions Within Normal Operations\n\nThe service history may be a result of the software in question that is embedded in a larger system. In the larger system, the input to the software in question may be filtered or sanitized to avoid abnormal behavior. It is difficult or impossible to draw conclusions that the operating environments are the same, particularly if there are no plans to use the same glue code, partitioning, or error trapping in the proposed computer environment. The service history may be collected in the normal operating conditions, but the data that causes abnormal conditions may not have reached the software in question. The proposed method for filling this gap is to provide additional guidance on\n\na. Documentation of the exact circumstances of operating the software in question\nb. The use of the same or similar wrapper code, glue code, or error-trapping code\n• Guidance on Analysis of Technology Differences in Operation\n\nTechnology differences in the usage of the product from service history duration (for example manual vs automatic, user intercept of errors, used within a network vs stand alone, etc.) may affect the argument of similar operations. DO-178B does not explicitly call for an analysis of such differences in operation. In the service history duration there may have been a user intercept or a procedural go-around for a problem so the problem was not reported as a problem. Additional guidance is needed in this area.\n\n• Guidance on Consideration of Operator Training\n\nOperator training for performing expected procedures is part of the safety net in the use of the system. One may be comparing lack of errors in an operation where the operator is highly trained with an operational profile where no training is planned. DO-178B is silent on this aspect of similarity of operation. A trained operator may have been the reason for a low-error rate. If the same product is used with an untrained operator, there may be many problems that were not originally expected. Further guidance should be developed to address this issue.\n\n• Guidance on Analysis of Similarity of Operation\n\nProblem data may or may not have all of the data needed to make a decision of what functions were covered by the product service history. In order to assess similarity of operations, the functions that were used in the service history should be noted. However, there may not be data available to make this assessment. Problem data in the area of that function may be the only clue to indicate that the function was used. Functions that did not cause a problem may not have left any clues regarding their usage. As a corollary, absence of problems may not mean that the function was perfect and operated without problems. That function may not have been exercised by any of the users. An examination of other data sources that are needed to understand the operation during the service history duration is warranted. Perhaps a survey of past users may be conducted to assess the functions that were exercised. Very focused testing on code functionality never or infrequently exercised in nominal operation may be the answer to check those functions or abnormal conditions that may not have been exercised in the service history duration. Possible research in running code through automated toolsets to find keywords associated with abnormal processing or code structure is a suggested method for filling this gap. This is effectively supplementing service history approach with focused reverse engineering.\n\n3.3 QUESTIONS OF ENVIRONMENT.\n\nQuestions of environment were separated from the questions of operation in order to distinguish the immediate computer environment in which the service history data was collected. This particular set of questions is tailored to address and mitigate software errors, which have their origin in hardware errors, interface, or resource assumptions. It should be noted that the exception handling and fault tolerance of the product whose service history is tracked should be\nseparated from the larger system in which it is embedded to assure the robustness of the product. This knowledge allows for an appropriate reuse of the product in the new environment. Figure 4 illustrates the items that should be considered in this area.\n\n\n\nSimilarity of environment may be assessed using the history of modifications to the product due to the particular hardware platform or because of resource requirements in the service environment, and the similar types of modifications needed to the product in the target environment.\n\nConsider the example of the Patriot system failure to intercept the El Hussein (Scud) missile in Dharan. Operational specifications for the system matched with the way the system behaved. However, the problems in the software were bugs only AFTER the operational environment had been redefined. The weapon was used, not in the detection and interception of aircraft, but rather, in the detection and interception of land-launched missiles. In its new capacity, the software failed because (1) there were missiles in a speed range that could and should be attacked and (2) the Patriot systems’ primary mission would NOT be defending against hostile aircraft over a relatively short attack time, but rather, defending against a potential land-launched missile threat over many days. System performance degradation due to uncompensated clock drift crippled the weapon’s defensive capability after the system had been continuously powered for days rather than the hours it was designed for. Unlike the ARIANE 5 case, it would have been difficult to detect the problems in this case since the system’s failure was ultimately tied to the overall environment definition.\n\nService history credit should be counted strictly when the types of installations match the target environment, i.e., same or similar hardware platforms. Product literature may be reviewed to compare computer environments in terms of limitations and constraints such as resource usage.\n\n---\n\nIf the problem reports identify problems because of usage in a particular computer environment different from the target environment, and the changes were made to fix these problems, the effect of these changes in the target environment should be considered.\n\nIf the product was used with different data/parameters (for example, adaptation data, external data sets, and internal parameters) in the service environment, these differences should be examined for possible risks in the target environment.\n\n3.3.1 Individual Questions to Consider.\n\nThe key questions to be addressed in the area of environment include assessing the computing environment to assure that the environment in which the software was hosted during the service history is similar to the proposed environment. This analysis must include not just object code compatibility but time and memory utilization, accuracy, precision, communication services, built-in tests, fault tolerance, channels, ports, queuing models, priorities, and error recovery actions, etc.\n\nTable 4 provides a set of questions in the form of a worksheet that may be used to evaluate the similarity of environment using the data available from the product service history.\n\nThe following considerations, based on Section 12.3.5 of DO-178B, were used in formulating the questions in table 4:\n\n- Data pertinent to the computer environment\n- Derivable data associated with the computer environment\n- Analysis to be performed\n- Indications of supplemental verification\nTABLE 4. WORKSHEET FOR QUESTIONS OF ENVIRONMENT\n\n<table>\n<thead>\n<tr>\n<th>Area: Environment</th>\n<th>Software Being Evaluated:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Project:</td>\n<td>Evaluator:</td>\n</tr>\n<tr>\n<td>Date:</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Reference</th>\n<th>Question</th>\n<th>Response</th>\n<th>Issues</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. 12.3.5 e</td>\n<td>Are the hardware environment of service history and the target environment similar?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2.</td>\n<td>Have the resource differences between the two computers been analyzed (time, memory, accuracy, precision, communication services, built-in tests, fault tolerance, channels and ports, queuing modes, priorities, error recovery actions, etc.)?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>3.</td>\n<td>Are safety requirements encountered by the product the same in both environments?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>4.</td>\n<td>Are exceptions encountered by the product the same in both environments?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>5. 12.3.5 f</td>\n<td>Is the data needed to analyze similarity of environment available? (Such data are not usually a part of problem data.)</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>6.</td>\n<td>Does the analysis show which portions of the service history data are applicable to the proposed use?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>7.</td>\n<td>How much service history credit can be assigned to the product, as opposed to the fault-tolerant properties of the computer environment in the service history duration?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>8.</td>\n<td>Is the product compatible with the target computer without making modifications to the product software?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>9. 12.3.5 e and j(2)</td>\n<td>If the hardware environments are different, have the differences been analyzed?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>10.</td>\n<td>Were there hardware modifications during the service history period?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>11.</td>\n<td>If there were hardware modifications, is it still appropriate to consider the service history duration before the modifications?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>12.</td>\n<td>Are software requirements and design data needed to analyze whether the configuration control of any hardware changes noted in the service history are acceptable?</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n3.3.2 Identified Gaps and Gap Closure—Environment.\n\n- Guidance on Fault Tolerant Properties of the Service History Environment\n\nSoftware anomalies in the problem reports may be due to the lack of fault tolerance, error trapping, or built-in-testing in the computing environment in which the service history was collected. On the other hand, the fault tolerance properties of the computing environment may make the service history data look better than it should. The biggest gap identified in this area relates to the quality of data assumed in any service history argument. There is no guidance in DO-178B that directs the applicant to investigate whether software anomalies in the software under consideration for use in a new environment were being suppressed by the presence of other factors in the old installation. There have been techniques such as applying fault tree analyses to the various components to estimate the errors that are due to the software in question. Unfortunately, data to enable such an analysis is seldom available. Guidance should be developed for analyzing the amount of service history credit that can be assigned to the product, as opposed to the fault-tolerant properties of the computer environment in the service history duration.\n\n- Guidance on Comparison of Computer Environments\n\nThere is no guidance in DO-178B to direct the applicant on the types of analyses that must be conducted to understand computer environment differences. Resource differences such as time, memory, accuracy, precision, communication services, built-in tests, fault tolerance, channels and ports, queuing modes, priorities, and error recovery actions, etc., should be considered. Safety requirements and exceptions encountered by the product should be included in analyzing the similarity of environment. If software modifications have to be made compliant with the target hardware, analysis should be conducted to assess the quantity of service history data that is still valid. Guidance is needed in this area.\n\n- Guidance on Consideration of Hardware Modifications During Service History Duration\n\nDO-178B does not give guidance for dealing with hardware modifications during the service history duration. All of the data needed for assessing if the same target hardware was used during the entire service history duration, may not be available. The data may have to be gleaned from other sources such as the history of the product. If there were changes to hardware during the service history duration, analysis should be conducted to assess if it is still appropriate to consider the service history duration before the modifications. Guidance is needed on hardware modifications during service history duration.\n\n- Guidance on Consideration of Hardware Modifications for Computation of Error Rates\n\nDO-178B does not provide guidance to consider hardware modifications during the service history. If hardware was changed during the service history period, analysis should be conducted to assess if data before the modification can be used for computing\nerror rates. Analysis should also include considerations of whether software changes were made because of hardware modifications. New guidance is needed in this area.\n\n3.4 QUESTIONS OF TIME.\n\nThere are many different ways of measuring the service history duration; duration may be measured without considering the changes made to the software or the clock may be restarted at corrections to safety problems. This question is related to how problems are classified and the vendor’s priority system for correcting the problems. Figure 5 illustrates one common approach to measuring service history duration.\n\n\n\n**FIGURE 5. TIMELINE**\n\nThe question of defining time relative to certification or continuing airworthiness has its parallels in other areas of the FAA. For example, following the Aloha Airlines incident in 1988, the National Transportation Safety Board noted, as part of their findings, that there appeared to be confusion in the terms flight cycle versus flight hour. The FAA released a Flight Standards Handbook Bulletin (HBAW 94-05B) to address this confusion as it related to aircraft maintenance.\n\nThe premise for using service history is based on the assumption that service history data gives us the evidence that all of the required functions have been repeatedly exercised and are correct. Strictly speaking, this assumption has no bearing on time at all. Time comes into the picture only because there is a comfort in a statistical sense that the probability of exercising all of the needed functions is greater as more time passes.\n\nTime is further modified within the definition by the need for its measurement to take place over a contiguous period. This qualification is designed to eliminate the potential for periods of improper execution or dormancy to be suppressed, thus skewing any conclusions drawn about the software under consideration.\n\nA close review of the DO-178B product service history guidance produces additional terms that directly relate to time, most notably “hours in-service” and “normal operation time.” These sound suspiciously like terms used to arrive at reliability numbers for hardware. An applicant wishing to use product service history is asked to describe in their Plan for Software Aspects of Certification (PSAC) the rationale for choosing a particular number of hours in service, including how normal operation time is defined. Consider a software function that is only used during\nlanding. It hardly seems reasonable to define in-service hours as flight time when the landing phase, during which the software is being exercised, accounts for only a small fraction of this overall time.\n\nWhile DO-178B is silent on whether the contiguous time period varies with software level, all of the discussions within SC-190, SC-180, and CAST have tended to accept this as an axiom. Likewise, the assumption is always made that what is being discussed, in some way, is measurable using hours, minutes, days, etc. Generally, it is felt that attempting to categorize software execution in terms of clock cycles, frames, or states is something for which sufficient data would be impossible to directly measure and would ultimately rely on inference from a clock-based measurement.\n\nDO-178B in Sections 12.3.5 j(2) and k refer to computation of error rates. DO-178B does not provide specific guidance as to how this computation should be performed or what specific data is be used. This provides the applicant with a fair amount of flexibility in the application of the service history argument. Error rates could be defined as number of errors divided by the time duration. In some cases, time duration is not as relevant as using the number of events such as takeoffs or landing, flight hours, flight distance, total population operating time, or only the number of times an operator queried the software for specific information. For use in this computation, the duration should be analyzed to be relevant. DO-178B does not specify whether all errors are considered to be of the same weight in these computations. It seems logical that even a few safety errors should be of higher consequence than a large number of nonsafety errors. Although there is a discussion of safety problems in Section 12.3.5 h, there is no indication of how these problems are used in error-rate computations.\n\nNote: Grounds for restarting the clock within the service history duration is not discussed in DO-178B. When there is a major software update or a hardware change, whether the data that is collected before the changes can be counted, as service history duration for measuring the error rates for the new software, is the question. In a number of software reliability models, time is reset when major changes are made since the software that was tracked is no longer the software that is used. There are other models that compensate for changes in software. This gap is tied to whether software reliability models can be used, and if so how do you assess that correct assumptions are made in the use of a particular model in a particular circumstance. This is illustrated in figure 6.\n\n\\[\n\\begin{align*}\n\\text{Maximum Product Service History} \\\\\n\\text{Available (single instance)}\n\\end{align*}\n\\]\n\n| Original Domain - Entry into Service | Clock - Reset - Due to Safety-Related Problem | PSAC - Error Rates Defined | SAS - Error Rates Validated or Renegotiated |\n\nFIGURE 6. CALCULATION OF SERVICE HISTORY DURATION\n3.4.1 Individual Questions to Consider.\n\nThe key questions to be addressed in the area of time for the purpose of establishing the minimum objective criteria concerning service history include units of measurement in the service history duration definition as appropriate to the usage of the software in question, reliability and consistency of time measurement, and justification for duration used in the calculation of error rates.\n\nTable 5 provides a set of questions in the form of a worksheet that may be used to evaluate service history time duration and error rates using the data available from product service history.\n\nThe following considerations, based on Section 12.3.5 of DO-178B, were used from formulating the questions in table 5.\n\n- Pertinent data related to time\n- Derivable data regarding time\n- Error rate considerations\n- Analysis to be performed\n- Indications of supplemental verification\n\n<table>\n<thead>\n<tr>\n<th>TABLE 5. WORKSHEET FOR QUESTIONS OF TIME</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Area: Time</td>\n</tr>\n<tr>\n<td>Project:</td>\n</tr>\n<tr>\n<td>Date:</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>DO-178B Reference</th>\n<th>Question</th>\n<th>Response</th>\n<th>Issues</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. 12.3.5 j(2)</td>\n<td>What is the definition of service period?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>2. 12.3.5 j(2)</td>\n<td>Is the service period defined appropriate to the nature of software in question?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>3. 12.3.5 j(2)</td>\n<td>What is the definition of normal operation time?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>4. 12.3.5 j(2)</td>\n<td>Does normal operation time used in service period include normal and abnormal operating conditions?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>5. Glossary</td>\n<td>Can contiguous operation time be derived from service history data?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>6.</td>\n<td>Is “applicable-service” portion recognized from the total service history data availability?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>7. 12.3.5 j(2)</td>\n<td>What was the criterion for evaluating the service period duration?</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n35\n<table>\n<thead>\n<tr>\n<th>DO-178B Reference</th>\n<th>Question</th>\n<th>Response</th>\n<th>Issues</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8. 12.3.5 j(2)</td>\n<td>How many copies of the software are in use and being tracked for problems?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>9.</td>\n<td>What is the duration of applicable service?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>10.</td>\n<td>Is applicable-service definition appropriate?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>11.</td>\n<td>Is this the duration used for calculation of error rates?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>12.</td>\n<td>How reliable was the means of measuring time?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>13.</td>\n<td>How consistent was the means of measuring time throughout the service history duration?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>14. 12.3.5 j(4)</td>\n<td>Do you have a proposed accepted error rate justifiable and appropriate for the level of safety of proposed usage, before analyzing the service history data?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>15. 12.3.5 j(4)</td>\n<td>How do you propose that this error rate be calculated, before analyzing the service history data?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>16.</td>\n<td>Is the error rate computation (total errors divided by time duration, by number of execution cycles, by number of events such as landing, by flight hours, by flight distance, or by total population operating time) appropriate to the application in question?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>17.</td>\n<td>What was the total duration of time used for this computation? Has care been taken to consider only the appropriate durations?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>18. 12.3.5 k</td>\n<td>What is the actual error rate computed after analyzing the service history data?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>19. 12.3.5 k</td>\n<td>Is this error rate greater than the proposed acceptable error rate defined in PSAC, according to j(4)?</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>20. 12.3.5 k</td>\n<td>If the error rate is greater, was analysis conducted to reassess the error rates?</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n3.4.2 Identified Gaps and Gap Closure—Time.\n\n\nDO-178B is silent on minimum criteria for configuration management and quality assurance of problem reports for evaluating a service period duration. Guidance is needed in this area.\n• **Guidance on Acceptable Service History Duration**\n\nDefinition of acceptable service duration is missing in DO-178B. Current guidance states that the error rates have to be predicted at the time of planning. Error rates should be computed using the service history period. There are arguments that the acceptable period does not have to be in time, since what is important here is the extent of usage. There is also an argument that the users usually underreport the problems. If the problem reports are tracked for a reasonable length of time, there is a chance that problems, if any, are reported which may be one reason to collect data for a long period of time. Thresholds for service history duration may vary by software criticality level. Thresholds cannot objectively vary with time unless a connection can be made with the safety requirements of that level. SC-190 discussions for CNS/ATM software did indicate “engineering judgment” as a subjective measure for the length of time. Thresholds may vary by code complexity or similar architectural measure (code size, degree of coupling, etc.). Such measures may not be practical, since there is no guarantee that the software structure is known. However, guidance is needed in this area.\n\n• **Guidance on Definition of Normal Operation Time**\n\nDefinition of normal operation time is left open in DO-178B. It is presumed that normal operation time is the time of operation similar to expected operation in the proposed environment. These conditions of operation should include similar external stimuli as input into the software; the number of data and control inputs, the input characteristics, the frequency of the input, accuracy and precision of input, the statistical spread of input, the combinations and permutations of input, etc., should be the same as operations in the proposed environment. Guidance on such considerations is needed.\n\n• **Guidance on Restarting the Clock Within Service History Duration**\n\nGrounds for restarting the clock within the service history duration is not discussed in DO-178B. When there is a major software update or a hardware change, whether the data that is collected before the changes can be counted, as service history duration for measuring the error rates for the new software, is the question. In a number of software reliability models, time is reset when major changes are made since the software that was tracked is no longer the software that is used. There are other models that compensate for changes in software. This gap is tied to whether software reliability models can be used, and if so, how do you assess that correct assumptions are being made pertaining to a particular model in a particular circumstance? Guidance is needed in this area also.\n\n• **Guidance on Methodology for Assessing Corner Condition Processing Time**\n\nThe total service history duration may not reflect how much of the time was spent in routine processing versus exception handling or corner condition processing. Research could be conducted in this area to derive a method to find average rates of processing time spent in nominal processing versus exception processing. Such a method would provide guidance to fill this gap.\nGuidance on Computing Error Rates Using Service History From Repeated Use of Software\n\nDO-178B is silent on how to combine multiple instances (see figure 7) of software used to derive total duration and total error rates. Attempting to do this may lead to cases where different error rates are observed. This would imply differences in the way errors are collected and logged. It may also imply that the operation and computer environments are not truly similar. Guidance is needed to address these issues.\n\nMax. Product Service History Available (single instance)\n\nMax. Product Service History Available (single instance)\n\nTotal Product Service History equals number of instances times the duration of a single instance\n\nFIGURE 7. PRODUCT SERVICE HISTORY—MULTIPLE OPERATING COPIES\n\n4. ADEQUACY OF DEVELOPMENT PROCESS.\n\nDO-178B gives guidance for both process and product assurance. Product service history does not provide any direct objective evidence of the process used in creating the software for which it describes. Applicants wishing to make use of product service history must determine a way of demonstrating compliance with the objectives of DO-178B. This generally involves complementing product service history with additional alternate methods.\n\nNumerous attempts have been made to equate specific objectives for which product service history could be \"traded with.\" Such attempts within SC-190 and CAST actually involved the creation of tables listing the objectives of DO-178B and stating for each objective whether service history could fully or partially satisfy the objective. These attempts were reviewed as part of this research in hopes that something had been overlooked that prevented their acceptance by the broader community. The inherent problem is the unquantifiable nature of the processes used to create and assure software. DO-178B is based on the premise that a good development process yields a better product; one that is more likely to perform its intended function and less likely to perform unintended functions. By its very nature, this is a qualitative approach, rather than a quantitative one.\nThe 66 objectives of DO-178B are divided across six main areas: planning, development, verification, quality assurance, configuration management, and certification liaison. The definition of product service history really only addresses two of these. The first is fairly direct, namely, problem reporting and configuration management of the software the data describes. The second is verification of the code to some degree by virtue of its execution. In fact, a cogent argument can be made that service history represents at least some amount of a variety of testing techniques including:\n\n- Stress testing\n- Random testing\n- Scenario-based testing\n- Regression testing\n- Accelerated life testing\n- Exhaustive testing\n- Domain testing\n- Error guessing\n\nAll of these techniques may be used to accomplish one or more of the verification objectives outlined in DO-178B. Frequently, they are elements of blackbox testing in controlled environments (either laboratory or airplane) in typical DO-178B projects. The good news is that about 60% of the objectives in DO-178B are verification objectives. The bad news is that there would not seem to be any corollary to product service history for planning, development, quality assurance, and certification liaison during the original development of the software that the service history data describes.\n\nWith this in mind, it would seem most appropriate to focus specific attention on things that may be done to gain confidence in these other areas. If any development records are still available from the original vendor, these may be reviewed to gain confidence in the process that was followed. Such records could include the requirements documents, design data, quality assurance data, and test data that may supplement the service history data. In this last case, special attention should be paid to testing accomplished for error-handling routines, performance testing, and other testing focused on the robust characteristics of the software. Remember that these are the parts of the code least likely to have been exercised as part of the service history.\n\nConfidence in the supplier’s development process may also be gained through careful analysis of the problem report data collected over the service history period. In addition to the items discussed at the beginning of section 3, trend data may be analyzed to determine how well the supplier accomplishes reverification and whether the software does, in fact, appear to be maturing over time. This type of analysis is not directly discussed in the DO-178B, but is generally accepted by the software community.\n\nNote that each of the above approaches can be stated in the negative as well. Spikes in problem reports right after a major build or a patch may indicate that the software is not maintainable or the quality of updates is not quite high. Recurring or chronic problems that go unresolved may also indicate poor processes.\n5. ESTABLISHMENT OF \"EQUIVALENT SAFETY\".\n\nWithin a month and half of its publication, DO-178B was formally recognized via Advisory Circular (AC) 20-115B as a means, but not the sole means, for securing FAA approval of software in airborne systems. For new projects started after this AC was published, compliance with DO-178B had to be demonstrated. Those who have sought to use other approaches for securing FAA approval have generally been required to show how their approach met the intent behind the DO-178B objectives.\n\nWhen discussing product service history, one of the most basic issues to understand is what the service history is demonstrating. Since the service history data generally exists for a system, typically a line-replaceable unit on an aircraft, any claim made for the software is an extrapolation from the system’s performance. Systems are required to comply with one or more Federal Aviation Regulation (FAR), (more formally known as Title 14 Code of Federal Regulations (CFR)) before being certificated for use on an aircraft. A careful reading of DO-178B, along with the guidance governing certification of parts and equipment described in 14 CFR Part 21, shows that DO-178B is simply a means of satisfying the CFRs, specifically those elements describing intended function and absence of unintended function. The logical question that arises is whether service history can be used to demonstrate compliance directly with the CFRs.\n\nWhile current guidance does not preclude such an argument, actually being able to demonstrate CFR compliance would be extremely difficult. Any attempt would need to overcome the basic issue of reliability applied to software. CFR XX.1309 uses terms such as extremely improbable to describe events that simply should not happen in the lifetime of a particular aircraft type. This has historically been translated to failure probabilities of $10^{-9}$ or better. There is no commercially accepted model written for software reliability that comes close to this number or that can be based on a realistic model.\n\nAdding an unknown software component to a system is considered a safety risk. This safety risk has been under constant debate since software was first introduced to the flight management system in the early 1980s. For the time being, design assurance remains the only viable approach, with DO-178B serving as the most mature model for its application. There are, however, other ways of mitigating risk from an unknown software component. For example, architectural means may be employed to limit the effect of a software error leading to a system-level failure. Examples of architectural means include:\n\n- Partitioning—preventing failures from noncritical functions affecting critical functions\n- Wrappers—wrapper software prevents use of unneeded functionality, checks validity of parameters\n- Software performance and safety monitors—credibility checks, redundant processors checking one another, fail-safe architectures\n- External monitors—e.g., watchdog timers\nUnfortunately, architectural means may not always be an option to protect against latent errors in software for which only service history data is available for certification credit. It may also be that the architectural means actually increases the system’s complexity, thus potentially decreasing safety rather than increasing it. For higher criticality systems, service history may simply not be an appropriate or practical choice.\n\nIt is generally accepted that using service history data becomes easier when systems are relatively simple and are low criticality, the service history data is both abundant and of high quality, and the system’s operating characteristics and external environment are close to the original systems.\n\n6. RESEARCH SUMMARY.\n\nThe primary outputs of this research effort is a set of worksheets to facilitate consistent and complete assessments of service history data along with a detailed analysis of the impediments to applying service history arguments. An additional output is the identification of needed guidance, as well as follow-on research that may be useful in furthering the use of service history data while maintaining an equivalent level of safety. The remainder of this section discusses the results of this research in more detail with an emphasis on follow-on activities.\n\n6.1 RESEARCH FINDINGS.\n\nThe preceding two sections served to summarize the current limitations in attempting to use service history to demonstrate compliance with the 66 objectives of DO-178B or even directly to the CFRs. As noted in section 3, gaps in the existing guidance can be found in every facet of the product service history definition. The lack of guidance addressing these issues has limited the use of service history as a viable alternate method. In cases where service history has been applied, these difficulties call into question the completeness and consistency of the arguments that were made and accepted.\n\nService history is data taken from real operations, unlike in simulated test environments where there may be mistakes in assumptions and data characteristics. Service history data is not systematic. Unlike a laboratory test setup, coverage of functions may not be known. If no errors were reported about a particular functionality, there is frequently no data to determine whether or not the functionality was not executed or if it was deemed to be error free. Resolving this ambiguity requires a coverage analysis for which no guidance exists. Assuming that such an analysis approach could be described and implemented, additional verification could be targeted at those elements of the software that were not executed. It is important to realize that if such an approach were viable, the duration of service history (i.e., how many times or how long the product was executed) would no longer matter, since instead of calculating error rates, the actual coverage of execution would be known.\n\nIt is a common misbelief that software with a sufficiently long service history duration can be used for safety-critical applications without further verification. Service history data is statistical in nature. There are many statistical models (software reliability) used for estimating the number and severity of software defects to provide management input for staffing, scheduling, quality, cost, and time to release. Any use of service history suffers from all of the same limitations these\ncurrent software reliability models suffer, most notably the assumption that errors are randomly distributed. Various approaches have been proposed to overcome this issue, most notably John Musa’s contention that variability in the personnel creating the software, as well as variations in program execution relative to external factors do allow for the application of a random process model. This is an area for which additional study is needed before guidance can be formulated to truly allow service history use at higher criticality levels without additional process assurance.\n\nIf a statistical model were to be used in substantiating a claim using service history, validation of the model needs to be considered. One novel approach suggested during the breakout session of the FAA National Software Standardization Conference was the application of tool qualification for the model. Criteria would need to be developed on how such a qualification effort could be accomplished.\n\nAnother area in which further exploration may be warranted is in the development of “safety cases.” A common approach to the evaluation and approval of safety-critical systems in Europe is the development of a comprehensive plan for meeting the required safety criteria, called a safety case. Specific approaches for building safety cases have been defined for IEC 61508. It may be possible to create a similar set of approaches for compliance with DO-178B and the related elements of the CFRs.\n\nThe development of an objective model for evaluating problem-reporting data is needed to facilitate using service history data. There is evidence that users in the field do not generally report all of the failures that they encounter. This observation works against using service history for credit since the data may be underreporting the failure and, hence, overreporting the reliability of software (and hardware). Some users may not take the time to report failures while others may not understand all of the system requirements (what the system is or is not supposed to do). There may also be some errors that are not clearly detected with error messages by the system. Likewise, errors attributable to the software may not be identified as such due to the system complexity or other masking factors. In calculating error rates, these kinds of errors must be compensated. This cannot be accomplished if they are not initially identified.\n\nSome concerns (availability, integrity, reliability, maintainability, usability) are treated or weighted differently in other industrial sectors. Products from these domains may need to be evaluated using the assumptions from the initial industry that created or used them. Currently, no guidelines exist for this type of an evaluation. The FAA could publish guidelines on how to collect and document service history data. Industry now has the opportunity to glean this data from a number of data collection programs that are implemented through military and airline programs, and similar to telemetry data collection, during flight tests and shadow operations. Such guidelines could build on the question models contained herein, with the possible addition of weighting for each question based on that question’s relative contribution to the integrity and usefulness of the data.\n\nOther items that suggest further exploration include:\n\n- Combining existing service history data with a period of shadow operations in a non-safety-critical environment (laboratory or test rack onboard an aircraft);\n• Development for detailed criteria for evaluating problem reports for safety effects, both in the original domain and in the target domain;\n\n• Definition of a similar concept to the Operational Services and Environment Definition (OSED) (defined in DO-264), to allow objective comparisons between two operations and computer environments; and\n\n• Development of criteria for subtracting out the effects of system architecture and installation on service history data for the purposes of isolating the contribution of software to overall system error rates.\n\n6.2 FOLLOW-ON PRIORITIZED RESEARCH NEEDS.\n\nRecommendations for new guidance on product service history and for furthering the gap closure work includes (in order of importance):\n\na. Elimination of inconsistencies in DO-178B between using service history and prohibiting software reliability use in the assessment of system safety.\n\nb. Development and publication of guidelines for using specific software reliability models, only if the models can be justified by means of tool qualification.\n\nc. Provision of additional guidance to augment Section 12.3.5 of DO-178B as suggested by the gaps in question areas including the possible development of weights for each question area.\n\nd. Creation of a requirement for additional design assurance activities when using service history at level A and B (consistent with DO-254).\n\ne. Formulation of a tiered approach to service history duration at different levels based on either system safety (as computed from error rates) or on engineering judgment.\n\nf. Publication of minimum requirements for the contents of problem reports (extension of DO-178B, Section 11.17 specifically for service history arguments).\n\ng. Development and publication of guidance for making a safety case compliant to DO-178B.\n\nItem a above is by far the largest and most difficult of these items. It also needs to be accomplished before or, at least, in parallel with item b. Item c covers a myriad of topics and has the potential for removing at least some of the current roadblocks to service history use. The development of a weighting system for the individual question discussed in both the report and handbook could be one way of adopting a risk-based approach similar to that discussed in AC 23.1309. Without a weighting structure, no framework exists by which to modulate the guidance given in DO-178B, Section 12.3.5, by software level. Item e represents another approach to achieving this, but is first dependent on items a and b being done and accepted by industry. Finally, item g represents a new paradigm within the aviation community. Although one could\nargue that this was already accomplished, the mechanisms, language, and to some extent, the focus are different in an System Safety Assessment (SSA) from that found in a safety case.\n\n7. CONCLUSION.\n\nService history is a powerful approach, which when used correctly, can make it possible to demonstrate the maturity of software that has previously been fielded and for which good data regarding its operation is available. To accomplish this, careful attention must be paid to a number of questions concerning the application of service history. Section 3 of this report (including the worksheets from appendix A of the Service History Handbook) discussed these questions in detail. Sections 4 and 5 helped to place those questions in the context of design assurance and safety, two fundamental aspects of creating and assuring software for airborne systems and equipment.\n\nService history, as an alternate method for demonstrating compliance to the objectives of DO-178B, is only one of many approaches that may be taken to demonstrate software maturity. When contemplating its use, one must be careful to consider the relationship between service history and software reliability. As noted in section 2, software reliability remains controversial, and cannot be used quantitatively in a safety assessment. Careful attention must be applied when defining error rates for a particular application and their definition should be discussed with the appropriate ACO at the onset of the certification project.\n\nAs more confidence is gained in the use of service history arguments for supporting certification efforts, the FAA may develop additional guidance. This report provides a first step in identifying where such guidance is needed, as well as the research that may be required to produce such guidance. It is also expected that this subject will be revisited when DO-178B is revised in the future. In the interim, it is hoped that this report, along with the handbook will help applicants apply service history arguments in a more thorough and consistent manner. Use of these documents by the FAA should allow for more consistent expectations being placed on applicants, something that has generally been shown to help control costs associated with achieving certification.\n\nIn conclusion, there is an inherent contradiction within DO-178B concerning service history as an alternate method and its disallowance of software reliability as it relates to system safety. If service history is to be a viable alternative method, significant work remains in the development of clear, concise, and scientifically valid guidance for its use. This report has provided an analysis of DO-178B content, gaps in that content, information concerning the topic from other industries, and a number of approaches for closing the gaps beginning with the inclusion of detailed worksheets for framing a service history evaluation.\nAPPENDIX A—DATA COLLECTION AND SYNTHESIS\n\nData collection and synthesis was accomplished by studying the research papers, by interviewing industry practitioners from different domains, and by holding an industry breakout session with a group of engineers from the aviation domain. All of the data that was collected was used in the gap analysis and gap closure plan. Much difficulty was observed in finding literature for service history usage on projects using commercial software, which are seeking the latest technology—inhertently opposing ideas.\n\nA.1 DATA COLLECTION AND SYNTHESIS 1: RESEARCH PAPERS.\n\nA.1.1 DATA COLLECTION QUESTIONNAIRE.\n\n1. Is the definition of product service history the same as in the aviation industry?\n\n2. If yes, is it used in this reference for gaining assurance on the product reliability?\n\n3. How is it used?\n\n4. What is the method of assessment of quality and quantity of service history data?\n\n5. Is this industry concerned with the process of error correction and other development methods?\n\n6. Is this treatment of service history transferable to the aviation industry?\n a. With modifications\n b. In conjunction with other means\n\n7. Are there problems in usage of service history as proposed in this reference?\n\n8. If so, how can these problems be addressed?\n\n9. Are there any details of “how to” on collection of problem reports, configuration control of problems and corrections, version control of released products, assessment of error data, statistical significance of amount of data, etc.?\n\n10. What are the industry/regulator concerns in the proposed methods?\n\n11. How does the material within this reference contribute to the handbook?\n a. Within the context of the proposed outline\n b. Outside the context of the outline—new items need to be added to the outline\nA.1.2 DATA COLLECTION – LITERATURE SURVEY SELECTED NOTES.\n\nU.K. Ministry of Defence, Defence Standard (9 December 1988) 00-40 (Part 6)/Issue 1 (ARMP-6) Reliability and Maintainability Part 6: In-Service R & M\n\nDef Stan 0040 Part 6 is adapting ARMP-6 which is the NATO document “Allied Reliability and Maintainability Publication - 6”\n\nThe document describes a method of collecting data to assess the in-service reliability of systems. The purpose may be to assure the reliability or to improve the reliability. The same data may be used to augment certification data for a new system in which the product is being reused if it is in a similar environment. The questions at hand are how much data and what kind of data are needed for such purposes.\n\na. The data will state the type and numbers of systems/equipments for which service history is being collected.\n\nb. The data will include the application and installation specifics as to whether it is installed in different ships, tanks, aircraft, and whether the application is in a standby or a fully operational mode.\n\nc. All relevant information such as version numbers, scheduled maintenance actions, time duration of usage of the system (actual flight hours for aircraft), problem history, and corrective actions.\n\nd. If the system is comprised of a group of smaller components, it is useful to track the history of individual systems.\n\ne. It is prudent to record usage conditions such as climatic and mechanical conditions, the localized environment of the system/equipment, duty cycles, switching, electromagnetic environment, etc., as well as conditions such as storage and handling. Errors that may be due to these conditions can then be removed from skewing the statistics for the actual software errors. (Software errors can affect hardware and eventually cause system failures.)\n\nf. The defect/failure data reporting, analysis, and categorization procedures should be clearly documented.\n\n\nDef Stan 0040 Part 8 is adapting ARMP-8 which is the NATO document “Allied Reliability and Maintainability Publication - 8.”\nThe document describes considerations given to procurement of off-the-shelf (OTS) equipment including what to look for in the data supporting the reliability of the OTS equipment. The following points are noteworthy for service history data:\n\n- New versions should be examined to determine if they were introduced to add new features or correct defects.\n- Experience with faults that resulted in system shutdown or \"crashes\" should be of prime importance.\n\n**MoD 0055 Part 1 Issue 2, Requirements for Safety Related Software In Defence Equipment, Part 1: Requirements**\n\nThe discussion of in-service history of previously developed software is less elaborate than DO-178B. Discussion here is purely qualitative and provided for merging into all other system documentation for completeness of considerations.\n\n**MoD 0055 Part 2 Issue 2, Requirements for Safety Related Software in Defence Equipment, Part 2: Guidance**\n\nThis has a relatively good discussion of in-service history usage. It requires both the software and the associated service history evidence to have been under configuration management throughout the software's service life.\n\nConfiguration changes during the software's service life should be identified and assessed in order to determine the stability and maturity of the software and to determine the applicability of the entire service history data to the particular version to be incorporated in the SRS (same as DO-178B).\n\nThe problem reporting system for the previously developed software should be such that there is confidence that the problems reported incorporate all software faults encountered by users, and that appropriate data is recorded from each problem report to enable judgments to be made about the severity and implications of the problems. (Notice that all software faults are to be recorded—this is stricter than DO-178B.)\n\nThis also advocates a safety case: The suitability of the quantified methods, assumptions, rationale, and factors relating to the applicability of the data should be justified in the Software Safety Case. The justification should include a comparison of actual error rates with the acceptability criteria defined in the Software Safety Plan and justification for the appropriateness of the data to the new application. (The comparison of error rates is similar to DO-178B.)\n\nIn cases where the previously developed software is justified on the basis of in-service history or extensive V&V and is treated as a black box, it may be acceptable for design information not to be provided as long as a comprehensive requirements specification for the software is provided (similar to DO-178B).\nThe operating environments of the previously developed software should be assessed to\ndetermine their relevance to its proposed use in the new application (similar to DO-178B).\n\nThis error rate computation follows similar guidelines as in DO-178B. But this standard goes\nfurther by asking for failure probabilities.\n\nMoD 0056 Part 2 Issue 2 Safety Management Requirements for Defence Systems, Part 2:\nGuidance, 13 December 1996\n\nAppendix D has guidance on using service history to allow validation of safety requirements by\ncomparing safety requirements. “Arguments of similarity should not be used until any\nsignificant system problems experienced in service have been understood and resolved.” The\nfollowing points are made concerning service history:\n\na. Problem reporting procedures during the period of applicable service history were\n sufficient to provide an appropriate cross-section of in-service problems.\n\nb. Changes to the referenced system or its operating instructions and environment during the\n service history period did not materially alter the safety of the system.\n\nc. Proposed system modifications do not involve technology changes (for instance replacing\n a mechanical system with a software one).\n\nd. Actual usage of the referenced system during the service history period was consistent\n with the intended usage of the new or modified system. If the operational environments\n of the existing and proposed applications differ, additional analyses should be conducted\n according to the requirements of this Standard.\n\nAny reported safety related problems together with their causes and corrective actions should be\nanalyzed in order to establish whether or not they are relevant to the proposed system, system\nmodification or system application and the conclusions documented.\n\nThe other major point made in this document is the safety argument. “The Safety Case should\ncontain well organized and reasoned justification clearly showing that:\n\na. Existing or supplemental analysis is sufficient to demonstrate that the system is tolerably\n safe.\n\nb. Service history is applicable and changes to the referenced system configuration have\n been appropriately controlled and documented.”\n\nMoD 0042 Part 2 Issue 1, Reliability and Maintainability Assurance Guides, Part 2:\nSoftware, 1 September 1997\n\nThe document talks about an in-service software reliability case which is similar to the evidence\nthat is being required in DO-178B. The argument is extended to particular methods, techniques,\nand processes rather than just software. Attributes to be used for similarity argument are:\n• Data rates\n• Throughput\n• Functions used\n• Input ranges\n• Resource usage (e.g., CPU time)\n• Configuration options (e.g., data conversion routines and thresholds)\n• Operational mode\n• Accuracy\n• Mission time\n\nUsing field data in computing reliability is also discussed.\n\nISO/IEC 12207-1 Guide for Information Technology\n\nThis international standard is not intended for off-the-shelf software products unless incorporated into a deliverable product. This clause does not imply that the suppliers or developers of off-the-shelf software should not use ISO/IEC 12207 when developing, operating, or maintaining such software.\n\nAdditional guidance from ISO/IEC 12207 is to ensure that requirements are satisfied, documentation is available, and rights are satisfied.\n\nThe acquirer will consider options for acquisition against analysis of appropriate criteria to include risk, cost, and benefits for each option. Options include:\n\na. Purchase an off-the-shelf software product that satisfies the requirements.\nb. Develop the software product or obtain the software service internally.\nc. Develop the software product or obtain the software service through contract.\nd. A combination of a, b, and c above.\ne. Enhance an existing software product or service.\n\nWhen an off-the-shelf software product is to be acquired, the acquirer will ensure the following conditions are satisfied:\n\na. The requirements for the software product are satisfied.\nb. The documentation is available.\nc. Proprietary, usage, ownership, warranty, and licensing rights are satisfied.\nd. Future support for the software product is planned.\n\nThis reference promotes the use of off-the-shelf software product \"as is.\" The full development process (5.3) may be excessive. Performance, documentation, proprietary matters, usage, ownership, warranty and licensing rights, and future support related to the software product should be evaluated.\n\nModification of off-the-shelf software product: Documentation may not be available. Depending on the criticality and expected future changes, the Development Process (5.3) should\nbe used via the Maintenance Process (clause 5.5). Performance, documentation, proprietary matters, ownership, usage, warranty and licensing rights, and future support related to the software product should be evaluated.\n\nSoftware or firmware product embedded in or integral to a system: Since such a software product is a part of a larger system, the system-related activities in the Development Process (5.3) should be considered. In the system-related activities, only one verb \"perform\" or \"support\" needs to be selected. If the software or firmware product is not likely to be modified in the future, extent of documentation needs should be carefully examined.\n\nDiscussions of Software Service History in the Safety Critical news group, July 2000 (safety-critical@cs.york.ac.uk)\n\n\nCBS Activity Areas have three primary categories of practices.\n\n- Product and Technology evaluation\n- Acquisition and Management\n- Design and Software Engineering\n\nProduct and technology evaluation deals with user requirements and component qualification practices. The article supposes that it is not enough to have a system built of quality components; there are a number of other issues to consider when the system is to be used for an extended period of time. There is also a discussion of architectural mitigation of risks in using the product.\n\nIn the Acquisition and Management section, there is a discussion of business issues such as estimating costs, identifying and reducing risks, managing personnel and schedules, and flexible contracts. SEI has collected lessons learned from various projects.\n\nDesign and software engineering deals with glue code, software architecture, and working with the COTS manufacturers to come up with solutions to mismatched components.\n\nThere is no mention of service history in this article.\n\nOther articles reviewed on this page are:\n\n- \"Requirements and COTS-Based Systems: A Thorny Question Indeed,\" by David Carney.\n• “COTS Evaluation in the Real World,” by David Carney.\n\n• “Simplex Architecture: Meeting the Challenges of Using COTS in High-Reliability System,” by Lui Sha, John B. Goodenough, and Bill Pollak (through a link to Crosstalk-1998).\n\n\n• “Assembling Large Systems From COTS Components: Opportunities, Cautions, and Complexities,” by David Carney.\n\n• “Lessons Learned Applying Commercial Off-The-Shelf Products,” by Lisa Brownword.\n\nThere is no mention of service history in these articles.\n\nAbts, Christopher, “COTS Software Integration Cost Modeling Study,” Technical Report, University of Southern California, Center for Software Engineering, Barry Boehm, Director. The report (along with other information about COCOTS) is available at: http://sunset.usc.edu/COCOTS/cocots.html\n\nThis study was originally performed for the USAF Electronic Systems Center Hanscom AFB, Massachusetts. The study deals with only the economic feasibility of using a COTS product. This model does not deal with technical or strategic evaluation of COTS. There is just a mention of “mature products with a solid history of performance.” No further discussion of the product history exists in either the paper or the web page.\n\n\nThis article deals with the process, planning and individual responsibilities of the evaluation of commercial software for incorporation into systems. There is no discussion of product history.\n\n\nThis article has an excellent idea of scoring the COTS using a set of criteria and weights assigned to them. The idea may be extended to apply to scoring findings within service history data. Criteria and weights for the use of particular COTS must be defined and product service history should be examined to derive the score.\n\nTotal score = ∑ weight * individual score\n\nThis paper deals with the environment in which COTS component under assessment is examined. It makes the point that the previous performance of a COTS component, as a part of a larger system, should be examined to extract the reliability estimates of the COTS component apart from the whole system in which it is embedded. The paper also makes the point that COTS should not be treated any differently from a custom product in the case of safety- (and mission) critical applications.\n\n\nThis is a general paper on software, with many of the ideas applicable to COTS. This paper describes the aging process for software. Using change history, predictions of aging, and decaying of a software product may be made to indicate the current reliability of the product. Both product and process measures are used. Process measures used here are conclusions drawn from defect history data, namely, the number of changes, average age of the code, contribution of each change to the fault potential. Statistical models have been proposed to evaluate which characteristics of a module history were likely to indicate that it would see a large amount of faults. This paper is very useful in assessing COTS reliability using its service history.\n\n\nThis is a good introductory text on software reliability. The review was focused on possible application/relevance to failure reports from fielded software.\n\nA relevant point that is discussed in this text is how to deal with unreported failures. Musa reports that it is observed that users in the field do not generally report all of the failures that they encounter. This observation works against using of service history for credit since the data may be underreporting the failure and, hence, overreporting the reliability of software (and hardware). He suggests compensating for the underreporting by observing the software update logs and nature of an error that must have occurred many times over before it was formally reported. Some users may not take the time to report failures while others may not understand all of the system requirements (what the system is or is not supposed to do). There may also be some errors, which are not as apparent, to be reported. Musa suggests models to compensate for unreported failures.\n\nThere is also an interesting discussion on failures of programs that have been fielded with no features added or faults removed (Poisson distribution) as opposed to failures of programs that are updated (step function).\n\nThis book deals with basic definitions of safety and reliability and surveys various industries such as transportation, aerospace, defense, nuclear power, and biomedical, to assure safety and reliability. She also deals with non-sector-specific standards.\n\nWithin many of these discussions, such as NATO COTS Software Acquisition Guidelines and Policy Issues, there are points to be noted that are relevant to software service history. Upon studying this text, the following considerations that are specific to COTS were concluded:\n\n1. How does the service history data of a component within a larger system translate to an indication of safety or reliability of that component which will be used as part of a different system?\n2. Assessment of safety and reliability has to involve both qualitative and quantitative means.\n3. Some concerns are unique to certain industrial sectors; COTS from other industry sectors should not be blindly applied to avionics systems.\n4. Idea of product metrics from ANSI/IEEE STD 982.1 1989 and 982.2 1989 (measures to produce reliable software) can be extended to COTS products. Service history may be used to generate error, fault, and failure metrics.\n\n\nThe article is written for software in general, not just COTS. Whether or not a formal reliability model is used to assess COTS on the basis of the product service history, certain basic assumptions are questioned in this paper. Among these assumptions is the thinking that the software (SW) contains a fixed number of errors and with the passage of time more and more of these errors are found. It should be noted that while fixing errors, other errors might be introduced. Further, the defect finding techniques are to be questioned to assure that poor testing or insufficient usage do not make a bad COTS look good. A very good table of assumptions, reality, and effect on conclusions is presented.\n\nThe set of assumptions modified to apply to COTS service history are as follows:\n\n1. Defects are repaired immediately when they are discovered.\n2. Defect repair is perfect.\n3. No new code is introduced during the time period of service history.\n4. All reported defects are from similar usage.\n5. Each unit of execution time is equally likely to find defects.\n6. Service history accurately represents the proposed operational profile.\nUnited States Navy Submarine Electronic System Acquisition Program Offices (Team Submarine), Strategy 2000, Commercial Off-The-Shelf (COTS) Acquisition Primer, 12 November 1996\n\nThis is an acquisition guide for the U.S. Navy. The document states that the use of item history and previous user experience can and should be used for determining maintenance aspects of the system. The document does not make a distinction between software and hardware for this point; the discussion is at the system level. However, the notion of accurate prediction of errors, maintenance needs, and environmental factors can be extended to software.\n\n\n“For some complex products with a large number of commercial users, there may be a user’s group. The program can have representation in the group to help influence the vendor to correct deficiencies and improve the product. One of the often-cited advantages of COTS products is the large number of users who help to find errors so that the quality of the product improves. This does lead to a phenomenon that the maintenance organization must contend with; namely, that the vendor will send out a stream of patches to the software to fix errors found by other users. The maintainer must decide which to incorporate, and when. The fixes may be in areas of the COTS package that are not used by the system, or could potentially lead to other errors because of the way that the system uses the COTS package. The maintainers must find a low-risk way of dealing with these patches. One of the difficult problems in maintaining the quality of the system when a COTS software product is replaced is how much to test. Clearly, only black box testing can be done. When the product is replaced, it is important to test for any side effects that may not be directly at the interface of the product with the rest of the system. Collecting problem reports and analyzing them is an important part of quality control for COTS software. The data should show when the problem was due to an error in a COTS product and how long it took for a correction. This kind of information can show trends in the reliability of each product and the kind of service the maintainer of that product is giving. These metrics are useful in determining when a product needs to be replaced because of its poor performance or that of its vendor.”\n\nPoints to note:\n\n1. Do user groups influence the vendor to repair what is needed by one group of people rather than allowing safety-critical errors to be fixed first?\n\n2. Some users may choose not to implement the patch—does the problem-reporting mechanism track different users with different versions?\n\n3. When users implement a patch that was meant to fix someone else’s problems, it may result in more problems because of differences in the usage of the same software. How does the vendor track this phenomenon as a error resulting from error fix?\n\n4. The author recommends reliability measurement of the product using the error metrics.\nLjerka Beus-Dukic, “Non-Functional Requirements for COTS Software Components,”\nSchool of Computing and Mathematics, University of Northumbria at Newcastle\n\nThis paper has a good discussion of what the author calls nonfunctional requirements, which\nmay be especially important for products that are built for general use. One of the major points\nmade in this paper is the domain differences and that “Vendors” vested interest in a particular\ndomain (if sufficient it provides a scope for introducing component features relevant to that\ndomain).” The nonfunctional requirements are the “ilities” that are important to that user or that\ndomain: maintainability, availability, integrity, usability, portability etc. These requirements\noften escape comparisons of what is required in the proposed environment. This paper agrees\nwith NATO arguments that when a reuse is brought from one domain to other care should be\nexercised to make sure that the domain differences are accounted for.\n\nShane Lunga and Meera Galoria, “Using COTS Components: Their Location,\nQualification and Selection,” DERA Portsdown West, UK\n\nThis paper does not have much information on service history. However, one point of interest is\nthe in-service life support and evolvability which highlights some of the qualities that one may\nput in the contract with the vendor including the compatibility with its previous version and to a\nlimited extent with its next version. The paper has a good set of criteria for selection of COTS.\n\nW.M. Gentleman, “If Software Quality is a Perception, How Do We Measure It?” Software\nEngineering Laboratory, National Research Council, Canada\n\nThis is a very good, thought-provoking article on quality. “In the past, much of the thinking\nabout quality has been in the context of one-on-one customer/contractor relationship. Galsworthy\n(1912) extolled the virtues of hand crafted custom products. Today’s customer often faces a very\ndifferent situation: a choice between competitive off-the-shelf products.” This article celebrates\nthe value of “field experience” above system requirements. The need for new types of metrics to\nunderstand and analyze off-the-shelf products is proposed. The author recognizes that we are\nmoving to qualitative measures with this shift in usage of field experience.\n\n“Software quality is often defined in terms of the fitness of the product for its purpose.” This\ndefinition of quality stretches what we are trying to do with service history. Service history is\nused to compute error rates so that we have a good idea of what to expect in the future use of the\nsystem in a “similar” purpose. How different will it be from the purpose for which it was used\nduring the service history? “... objective measures should be used to support subjective\nassessment.”\n\nC. Jones, R.E. Bloomfield, P.K.D Froome, and P.G Bishop, “Methods for Assessing the\nSafety Integrity of Safety-Related Software of Uncertain Pedigree (SOUP),” Adelard,\n\nThis is an excellent document on software of uncertain pedigree. It also has a good comparison\nof various standards. There are many good points made in general for COTS. The most\ninteresting quote from this document is, “The PDS should be provided with documentation\nequivalent to the rest of the safety-related software. However, in cases where the PDS is justified on the basis of in-service history or extensive V&V and is treated as a “black box,” it may be acceptable for design information not to be provided as long as a comprehensive requirement specification for the software is provided.” There is an analysis to show what kind of errors can be found by black box testing and what other complementary methods may be used to complete V&V of the product whose in-service history is known. The document agrees with DO-178B in requiring that the following data be used in the computation of error rates:\n\n- The length of the service period\n- The operational hours, allowing for different operational modes, and the numbers of copies in service\n- The definition of what is counted as a fault/error/failure\n\n\nAn excellent document, which is a companion to the other Adelard document on SOUP. Asserts that “(field experience) Gives feedback on failures occurring in field operation. Applicable to SOUP, but needs to be of high quality to demonstrate reliability.” The document has been written to analyze how a SOUP can satisfy the requirements of IEC 61508; a similar analysis would be useful for guiding COTS compliance to DO-178B.\n\n\nThis document has a lot of insight into how to ensure COTS in safety-critical systems. One similarity between this document and the Adelard documents is the reliance on standards for different characteristics of the COTS. This document relies all of the requisite qualities of COTS with IEEE standards. There are many ideas that stem out of the discussions in the document.\n\nThe document discusses dissimilarities in installations between sites; although the same product is being used. This point may be of interest when many copies of the subject software are running in different installations during the service history duration.\n\nThe other idea is to require that the problems be tracked.\n\nThere is a discussion of values of gradations of assurance for different levels of safety.\n\na. For the highest level of safety, Category A, the suggestion is the following: “The COTS product should have significant (> 1 year operating time), current severe-error-free operating experience in at least two independent operating locations. Adverse reports should not be excluded even if two operating locations can be found with no adverse reports. The version and release of the proposed COTS product should be identical to that\nused in the experience database. The configuration of the product in the experience data base should closely match that of the proposed COTS product.”\n\nb. For the next, Category B: “The COTS product has operated satisfactorily in similar applications. The version and release of reported experience may not be identical to the proposed COTS product, but a consistent configuration management program and well-managed update program provide traceability and change control. Error reporting, tracking, and resolution are consistent and correctly attributable to version and release. The version and release proposed has no major unresolved problems. A current bug list should be available to COTS purchasers as a support option.”\n\nc. For Category C: “The COTS product has been shown to operate without serious malfunction in the instant application. An error-reporting scheme is planned or in place that tracks malfunctions of this COTS product in applications controlled by this applicant. Documentation and records retention allow error histories of 5 years or length of service, whichever is shorter.”\n\n\nThis document contains a discussion of what an applicant or a regulator should be mindful of when service history is proposed for certification credit. “It seems intuitive that operating experience data derived from extensive usage of the same version of a product in similar applications would indicate that the product is acceptable for the intended application. Several issues with this assumption should be considered. First, configuration data of the actual version used in the problem report supplied can be difficult to obtain. As such, the statistical validity of the data is unknown. Error-reporting databases commonly span multiple releases and configurations of a given product. Another issue is that circumstances surrounding the occurrence, monitoring, and recording of failures are often vaguely reported. Even the highest avionics software level system have difficulty in reproducing and diagnosing problems due to the inability to recreate the problem from the information provided. Indeed, some of these activities are not only improperly controlled, but in fact, there might be some motivation for COTS vendors to limit publication of negative experiences, particularly if the COTS product was not originally intended for safety-critical systems. Another key issue regarding operating experience is that extensively used products can still have crucial faults that could cause problems in safety systems. The tendency is to consider operational experience to be like extensive random testing. In this regard, operational experience suffers from the same shortcoming as testing: testing cannot prove the absence of faults.”\n\nA.2 DATA COLLECTION AND SYNTHESIS 2: INTERVIEWS.\n\nA.2.1 INTERVIEWEES.\n\nInterviewees included engineers who have worked on verification and validation of systems in the nuclear domain, utility companies, DoD in general, the U.S. Navy, and general safety-critical application to a variety of application domains. Interviews for the most part focused on\nregulations and practice; some conversations were also had on conclusions reached because of personal experiences.\n\nA.2.2 INTERVIEW CHECKLIST.\n\nA basic set of questions for interviews was asked to assess the use of service history in other domains of industry (nuclear, consumer industry, chemical industry, DoD etc.).\n\nThe actual questions were slightly modified during the conversations, depending upon the domain and the interviewee’s field of specialization.\n\n1. Introduction: A brief synopsis of what we are doing. The term service history may not be used in the domain at hand. Straighten out the vocabulary of COTS, service history, certification, assurance, equivalent level of safety, and alternate means.\n\n2. Scope: Software whose development process is not known, may be COTS or other previously developed software.\n\n3. Service history may be used as a means of establishing confidence in the integrity of software (COTS or for grandfathering of software). Is this means allowed in your industry domain? By itself or in conjunction with other means or both? Is use through explicit or implicit means?\n a. What regulations are in place? Are copies of these regulations available? Are they well understood by the regulators, by the industry? Are there instances where the interpretation of regulations differed? Explain in what areas, and how they were resolved?\n b. How long have these regulations been used?\n c. In your opinion, what are its good points, its bad points?\n d. How would you improve these regulations?\n\n4. If this is an ad hoc process, what is the usual process? Is it widely understood?\n a. What are its advantages and disadvantages?\n b. How would you improve the process whether formal or ad hoc?\n\n5. Whatever method is used, how does the applicant provide assurance for the following questions?\n a. Time: How long is long enough? How did you derive the number? Is it based on engineering judgment or software reliability measures?\n b. Operation: How do you know that the operation in question is exactly the same as during the service history?\nc. Environment: Data collected in one environment can be used to gain confidence in another environment only if the environments are similar. How do you assess/establish similarity of environment? How do you assure that mode confusion problems are resolved? How do you assure that differences in kind of exceptions, and exception handling are resolved? How do you assure that human factors issues such as expected behavior of the system under similar circumstances are resolved?\n\nd. Problem Reporting: Many of the COTS suppliers do not have a rigorous problem reporting system. If credit were taken for service history duration, one would have to assure that all of the problems were reported, and all of them were logged and dealt with. How do you assess the quality of problem reporting and configuration of software?\n\n6. Is any of the above assurance activities graduated by the criticality of the system in which service history is to be applied? In avionics applications, the assurance needed depends upon the software criticality, which is a measure of the damage that may be caused if the software were to fail.\n\n7. In assuring avionics, the usual process involves assuring the development process and assuring the product by verification.\n\na. How do you address proof of adequacy of development process commensurate with the safety and reliability expected?\n\nb. What methods do you use to assure the product? Is safety assured by your methods for COTS using service history equivalent to if you had overseen the development process? In this question, service history may have been used by itself or in conjunction with other measures.\n\n8. Are there particular examples that you can share regarding uses of service history by itself or in conjunction with other measures in your domain. Please also state the level of safety and reliability expected of these examples.\n\n9. In your opinion have these been success stories?\n\n10. What lessons have been learned from these cases? What additional measures would you recommend in the future assurance projects involving COTS? In particular regarding service history?\n\n11. Is there anyone else in your organization who you would suggest talking to?\n\n12. Any one else in related fields or suppliers who might contribute to this study?\nA.2.3 INTERVIEW RESULTS.\n\nInterviews 1 and 2:\n\nIn the Nuclear domain, Title 10 Part 50 regulations are followed for safety-critical systems that are called Class 1E. These systems are built very conservatively—mostly hardware (HW) and firmware and analog systems. They have to be physically robust (such as earthquake proof) and redundant. There is not much chance of using COTS in this class of systems.\n\nAll of the other software are divided into different classes in different power plants. Nuclear Software Management Group is the industry group for software management issues to be resolved. There is a graded approach to building software. At the highest levels of safety the vendor may be required to be \"appendix B qualified\" which means that the QA system is of the standard that is expected by the NRC through Title 10 part 50 requirements. At lower levels of safety, contracts are used to assure that proper error reporting is established for both safety and business purposes. Corporate administration process is also used for reporting problems. These records are usually kept for the life of the code. There may be some records that are kept for the life of the power plant plus 10 years.\n\nService experience of COTS or reuse software is of interest only as a risk mitigation tool. Not much credence is given to this data. Testing for intended functions is the way to gain assurance of software. When the testing is successful, commercial dedication is achieved—i.e., although the part or software is not built for the nuclear application, the testing has shown that the part or software is high grade.\n\nAdvantages of this type of \"informal\" approach are that progress may be made quickly. The disadvantages are the risks associated with any informal process. In the nuclear industry there is a pact to alert fellow power plant businesses of safety problems, and share this data freely. At the national level the Institute for Nuclear Power Operations (INPO) and at the world level World Association of Nuclear Operators (WANO) are used as vehicles for maintaining the high level of safety in the nuclear field.\n\nFederal regulations are used as the minimum that an operator would have to do; many of the power plants do more than what is required by the regulations. It is a matter of safety and prudent business decisions.\n\nInterview 3:\n\nDomain: DoD and Nuclear\n\nApplications: 1. SW development tools\n 2. COTS used within Mission Planning software and Mapping software\n\nRoger noted mixed experience in case of development tools. Sometimes the tools did not perform as advertised. Also, service history was very thin since these were the cutting edge tools. The problems noted were due to scale of application; the other successful applications of COTS may have been of small scale. Complexity is also an issue. He would advocate using\ncomplexity and size as criteria for whether to use COTS. Three to five years of service experience for a tool such as a compiler would be acceptable. Beyond 5 years the problem is that the tool is losing its edge in technology. Quality of service history or problem data records available from the vendor is varied depending upon the vendor.\n\nIn mission planning and mapping software, simpler COTS have been used with success. Again, these are simpler uses than the ones described for tools. Complexity is an issue. Roger would not advocate using COTS within software systems of high criticality. For the kind of applications that he is talking about, capabilities, not service history forms the basis for whether to buy those COTS. Size (scalability) is not an issue in these particular types of software (mission planning or mapping). Ease of use, ease of connectivity, and ease of openness are important. A copy of COTS software is tested in a prototype before making the buy decision. Mode is an issue that is hard to address. Usually requirements are obtained from the vendor and the system is tested thoroughly using these requirements. If one vendor has the requirements and another does not for an otherwise comparable product, Roger would buy the product with requirement with the hope that the vendor has better software engineering practices. Testing will be done to exercise all features. Roger has again noticed differences in the details of problem reporting between vendors. In-house problem reporting kept at his company trace the problems down to the LRU level so that when time comes to upgrade the COTS, a decision can be made with respect to the vendor. In-house reports log the resolutions also. Roger emphasized that for critical applications he would not recommend COTS. Roger would like to see COTS vendors using software engineering principles so that their product would be of better quality.\n\nInterview 4:\n\nDomain: U.S. Navy, General safety-critical applications\n\nThere is no absolute need to use COTS in all cases; when the safety of the system is in question, it is not clear that equivalence to development assurance can be gained by using service history.\n\nInterview 5:\n\nIn nuclear applications a process of assurance of safety critical software whose development history is not known, is documented in IEEE ANS 7-4.3.2. This document assigns what is known as “commercial dedication” to a piece of equipment that may then be used in safety critical applications. The assurance depends upon intense product verification not just on product service history. Product service history is of interest only in a qualitative sense.\n\nA.3 DATA COLLECTION AND SYNTHESIS 3: INDUSTRY BREAKOUT SESSION.\n\nDuring the FAA National Software Standardization Conference in Danvers, MA (June 5-7, 2001) a breakout session was conducted to solicit industry opinion and ideas on use of service history for certification credit. Twenty-five engineers from industry, as well as government attended the session. The following data was collected based on the comments made during the discussion. The comments validated some of the conclusions independently reached by literature search. The comments also provided some new ideas such as use of tool qualification to justify software reliability method.\nA.3.1 COMMENTS CAPTURED DURING THE SESSION.\n\nQuestions of Time\n\nPrimary flight control (PFC) was initially approved to DO-178B, Level B. The company wanted to bring it over from one aircraft to another. The question was how to combine multiple sets of service history data along with existing design assurance data from the previous software approval.\n\nCan time measurement cut across environments and operations at all?\n\nWhat is the appropriate unit of time? The warm and fuzzy factor - more qualitative than quantitative.\n\nStatistical significance must be extrapolated down from the aircraft level to a system contribution to a particular failure condition.\n\nHow do you separate out the true software contributions from the hardware failure rates, infant mortality, etc?\n\nTaxonomy may be hiding considerations of the “big” picture\n\nAre there certain objectives that simply may not be met through service history?\n\nIt may be that service history must be decoupled from individual objectives - you’re really making an argument against the FARs/JARs\n\nHOWEVER, it is likely that the most common cases where people would like to employ service history arguments is just that, namely credit for one or more specific objectives (e.g. service history of x hours for MC/DC)\n\nIf you have a failure that is attributable to software but can clearly show through analysis that it is not safety-related, you don’t have to restart the clock. [CNS/ATM group]\n\nWhat about the problem of problems introduced by modding the code?\n\nDetermination of the amount of time will be, by definition, a case-by-case basis - too many variables to define a one size fits all solution.\n\nSuccess story: Ten years of data, non-flight-critical, three well-defined updates, level B - with an independent monitor (would have been level A otherwise), approx 280 A/C with complete service hours documented (approx 75K)\n\nBottom-line, however, was the argument was made to FARs not specific objectives, i.e., no tit for tat arguments\n\nHow do you take into account functions that operate for only a small window of the total flight hours (e.g., 150 sec for WAAS)\nWhatever you do here, it must be relevant and significant!\n\nWhat about framing this in terms of events?\n\nDOE - Agricultural domain to extrapolate time - similar to HALT\n\nQuestions of Operation\n\nHow much exposure has each mode seen? Is it ever possible to have visibility to this information - what would the metric look like?\n\nWhat happens when you translate a common mode of operation from the civil arena to the military arena (e.g. FMC pt A to pt A)\n\nApproach this from the perspective of a trade study. Are there different weightings for the various questions? Weighting criteria tend to be subjective. Can it be tied back to safety? Isn’t this just reliability in disguise?\n\nConsider an exponential curve with a lot of latitude at level D - probably not at all at level A\n\nState analysis, human factors, or other approaches to get at differences between the two operational domains - this is the antithesis of the dissimilarity argument\n\nQuestions of Environment\n\nConsider any changes in hardware, interfacing systems, etc\n\nEverything in terms of changes must tie back to safety assessment.\n\nDon’t forget to consider the ramifications of processor changes, compiler changes, linkers, etc...\n\nWhat about just a “minor” change to the option set used to build (e.g. optimization)\n\nQuestions of Problem Reporting (CM)\n\nIs the failure going to be reportable (visible) to allow a problem report even to be generated?\n\nProblem versus a feature?\n\nAttribute the problem to what?\n\nWhat do you do with the “one-offs” (nonrepeatable, one-time occurrences)?\n\nAll PRs must go through safety analysis process.\n\nMilitary environment - encourage problem reporting under warranty, discourage after warranty expires due to costs born by unit\nNFF problems\n\nTrace-back and fault isolation are key to ensuring the integrity of data.\n\nIn-service PR’s are much more important than development PRs for the purposes of evaluating maturity (i.e. legitimate service history) Suggested to consider about 2-3 months prior to release.\n\nMTTR for software problems - lots of considerations in how you get at this actual metric.\n\nIs there an industry average that can be derived for particular types of aircraft to predict expected numbers of problems to externally validate what is being seen?\n\nWhat is the effect of “operational” workarounds on this whole scenario?\n\nDrop off of reporting once problem becomes known.\n\nConclusions as presented at the conference:\n\n- Multiple time duration based on available life cycle data and criticality\n- Statistical significance derived from the aircraft level to the software level\n- FAR/JAR safety argument instead of DO-178B objectives\n- Measurement of time must consider exposure to the function and be stated in appropriate units\n- Must be relevant and significant (as specified in DO-178B)\n- Clock must be restarted for failures having a safety implication\n- Artificially extending the duration by statistical prediction\n- Approach service history from the perspective of a trade study – give different weights to different attributes\n- Service history is really the antithesis of the dissimilarity argument in DO-178B\n- Many problems are simply not visible in a way that allows appropriate problem reporting (attributable to software)\n- All problem reports should be investigated through safety assessment\n- Problem reporting may be encouraged or discouraged for business, procedural or perception reasons\n- Nonrepeateable and “no fault found” problems – what then?\n- Can Mean Time To Repair (MTTR) be used as a measure of the severity of the problem?\nAPPENDIX B—SERVICE HISTORY—LITERATURE SEARCH\n\nAbout 200 references were examined for this project. Not all of the references had a discussion on service history. There was a contradiction inherent to commercial software that embraced COTS because of the novelty of technology. No consideration was given to service history data and, in many cases, none existed. The only domains where service history played an important role were safety-critical domains of nuclear, defense, and aviation. Of these fields, it was generally found that the European literature is more prolific in addressing the use of service history. Further, the European safety culture also accepts software reliability measures. The close connection between software reliability and product service history helps the discussion of both the topics in European defense standards, guidelines for medical devices, and nuclear applications.\n\nB.1 GENERAL PAPERS.\n\nThis category includes general material that spans multiple industry segments or is generic to the topic of COTS or service history. In addition, this section contains material that relates to the use of COTS and service history in consumer products such as those evaluated by Underwriter's Laboratories (UL).\n\nMany of the COTS used in aviation (mainly ground systems and less frequently in avionics) have a product history in the consumer domain (cars, telecommunications, display, and sound from entertainment systems, etc.). Further, considerations in using product history for product assurance are common across the various domains.\n\nB.1.1 Bibliography.\n\n\nB-1\n\n\n26. COTS information and white papers from National Research Council, Canada.\n\n\n42. Interview with FDA on use of Service History in certification of medical devices.\n\n43. Interview with UL on use of Service History in certification of consumer electronics.\n\n\n60. Ljerka Beus-Dukic, “Non-Functional Requirements for COTS Software Components,” School of Computing and Mathematics, University of Northumbria at Newcastle.\n\nB-5\n\n\n81. Shane Lunga and Meera Galoria “Using COTS Components: Their Location, Qualification and Selection,” DERA Portdown West, UK.\n\n\n86. The Safety-Critical Systems Club Newsletter, May 2001, Volume 10, Number 3, University of Newcastle upon Tyne, UK.\n\n\nB.2 NUCLEAR.\n\nAlthough their use of software is fairly small compared to civil aviation, the nuclear industry, and in particular the Nuclear Regulatory Commission (NRC), invested significant funds in establishing guidelines for the use of COTS in nuclear applications. These guidelines along with the associated research efforts have established ground rules including many elements of service history.\n\nBoth the aviation sector and the nuclear sector are concerned with safety. The NRC follows a tiered system of three levels of safety criticality. The aviation industry may be able to draw upon the experiences in other regulated safety-critical industry.\n\nB.2.1 BIBLIOGRAPHY.\n\n\n3. Interview with Bob Brill and John Gallagher of NRC regarding use of Service History in the Nuclear Sector.\n\n\nB.3 DEFENSE.\n\nMuch of the data that has been collected for review as the research plan is developed originates in the defense sector. It is important to note at this early stage that the relevance and usefulness of this data has not been established. This caveat stems from the difference in focus of mission critical versus safety critical.\nMany of the COTS used in DoD are used in military aviation. Rules for use of service history within this COTS selection and acquisition process may help answer some of the concerns within the civil aviation community.\n\nB.3.1 Bibliography.\n\n\n14. Interview with AF personnel regarding use of Service History in acquisition of Avionics with COTS.\n\n\n18. Title 10, United States Code, Ch 140 (Sections 2375-2377), \"Procurement of Commercial Items,\" 1996.\n\nB.4 CIVIL AVIATION AND SPACE APPLICATIONS.\n\nService History has been an area of debate ever since the rules for civil aircraft certification were established. References in this area cover the latest dialogues underway in RTCA SC-190 on the subject, as well as prior work and guidance. A small number of sources have been identified from the space sector to supplement this area.\n\nUse of COTS in Aviation raises concerns of safety, reliability and product obsolescence from both the industry and regulators. Further, there are concerns of measurable objective evidence that can be applied to variety of products built using variety of processes. Concerns need to be addressed in any policy that will be useful for both the regulators and the industry.\n\nB.4.1 Bibliography.\n\n\n4. Civil Aviation Authority Publication 670 SW 01, issue 3. Requirements for Software Safety Assurance in Safety Related ATS Equipment. Available by request from A. Eaton, Safety Regulation Group, UK Civil Aviation Authority, Aviation House, Gatwick Airport South, West Sussex, England, RH6 0YR.\n\nB-11\n\n\n17. RTCA SC 167 Papers on Service History, Previously Developed Software and Alternate Means.\n\n\n21. RTCA SC 190, papers on Service History, Previously Developed Software and Alternate Means.\n\n22. RTCA SC 190, Web discussions on Service History, Previously Developed Software and Alternate Means.\n\n\nB.5. SUPPLEMENTAL—SOFTWARE TESTING, RELIABILITY, AND SAFETY.\n\nThe four areas of software testing, risk management, reliability, and safety were included in the literature search to aid in the assessment of service history approaches as they relate to certification. Given the breadth of each of these areas, this part of the search was more narrowly defined to those sources that would allow determination of how service history relates to, could be established by, or could be assessed through their use.\nB.5.1 BIBLIOGRAPHY.\n\n\n13. Hecht, H., and M. Heckt, \"Qualitative Interpretation of Software Test Data,\" SoHar, Inc.\n\n\nB-15\n\n\n46. W.M. Gentleman, “If Software Quality Is a Perception, How Do We Measure It?” Software Engineering Laboratory, National Research Council, Canada.\n\n\n"}}},{"rowIdx":190,"cells":{"id":{"kind":"string","value":"2e7a34336069c6acf39d83296543cb096a08f6ea"},"text":{"kind":"string","value":"Signing and security of Hue software\n\nCitation for published version (APA):\n\nDocument status and date:\nPublished: 28/09/2017\n\nPublisher 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.\nSigning and security of Hue software\n\nIgor Anastasov\nSigning and security of Hue software\n\nEindhoven University of Technology\nStan Ackermans Institute / Software Technology\n\nPartners\n\nPhilips Lighting\n\nEindhoven University of Technology\n\nSteering Group\n\nLuud Woltjer (Philips Lighting)\nLeon Bouwmeester (Philips Lighting)\nWalter Slegers (Philips Lighting)\nTanir Ozcelebi (TU/e)\nAd Aerts (TU/e)\nYanja Dajsuren (TU/e)\n\nDate\n\nSeptember 2017\n\nDocument Status\n\nPublic\n\nSAI report no.\n\n2017/036\n\nThe design described in this report has been carried out in accordance with the TU/e Code of Scientific Conduct.\nAbstract\n\nDeveloping software for the Hue devices poses plenty of challenges among the engineers at Philips Lighting. These challenges arise at each stage of the Software Development Life-Cycle (SDLC). Improvement of it is of immense importance to the Philips Lighting. This report describes a project which focus was to automate the SDLC, as well as to improve the security in it. The end result solves many challenges. It delivers a complete release management tool dedicated to the engineers at the Home Systems department. First, it visualizes release workflows in a simple user interface. Second, the core activities of the SDLC, such as the software signing, are fully automated. What is more important is that the signing is executed in a highly secure environment. This is very important for Philips Lighting not only because this automation saves a lot of time, but also because it reduces the risk of a human error. The same benefits are gained through an automation of other activities, such as approvals, distribution of the software to the factories, and deploying the software to the device cloud. Third, the system provides a traceability about each step executed in the process. Finally, the system is highly configurable, which makes it easy to be extended and adjusted to support different device types with different release workflows.\n\nKeywords\n\nSoftware signing, security, SDLC, release management workflow, software deployment, Philips Hue, Philips Lighting, TUE, Software technology, PDEng\n\nPreferred reference\n\n\nPartnership\n\nThis project was supported by Eindhoven University of Technology and Philips Lighting.\n\nDisclaimer\n\nReference herein to any specific commercial products, process, or service by trade name, trademark, manufacturer, or otherwise, does not necessarily constitute or imply its endorsement, recommendation, or favoring by the Eindhoven University of Technology or Philips Lighting. The views and opinions of authors expressed herein do not necessarily state or reflect those of the Eindhoven University of Technology or Philips Lighting, and shall not be used for advertising or product endorsement purposes.\n\nTrademark\n\nProduct and company names mentioned herein may be trademarks and/or service marks of their respective owners. We use these names without any particular endorsement or with the intent to infringe the copyright of the respective owners.\n\nCopyright\n\nCopyright © 2017. Eindhoven University of Technology. All rights reserved. No part of the material protected by this copyright notice may be reproduced, modified, or redistributed in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the Eindhoven University of Technology and Philips Lighting.\nForeword\n\nSecurity is becoming more and more important in the IoT space. One of the most recent examples is the hack of a casino through an internet-connected fish tank [1] that clearly shows today’s creativity of hackers. Like quality, security is not a department, but an attitude that should be embraced by the entire organization supported by integral processes to always keep further improving.\n\nThis report describes the results of one such important improvement: it provides a link between the software development projects on one hand versus the digital operation to deploy the software artefacts towards end-users on the other hand. It includes a fully automated release process in a highly secure environment that not only saves a lot of time, but also eliminates the possibility of human error to a large extend. Given the diversity and scale of products in combination with necessary speed of innovation, the resulting tool is an absolute must to keep providing secure solutions. The first demonstrations clearly showed the value of this tool.\n\nIgor played a pivoting role in this project: he identified the (key) stakeholders in this project and what their (non) functional requirements were. He also setup the initial architecture and design which determined the foundation for the resulting implementation. During the entire development process Igor in particularly paid attention to the integral security aspects of his solution by working with the various security engineers. With this report, the project hasn’t stopped: Igor continues to work on this, but now as an employee of Philips Lighting.\n\nI. H.A. Bouwmeester, Project Manager Hue system platform.\nSeptember 2017\nPreface\n\nThis report summarizes the “Signing and security of Hue software” project carried out by Igor Anastasov as the final part of the Professional Doctorate in Engineering (PDEng) program in Software Technology, provided by the Eindhoven University of Technology, Stan Ackermans Institute. The project lasted for nine months and was conducted at Philips Lighting, Eindhoven.\n\nThis document describes the successful realization of the project and elaborates the software development and project management processes. Audience of this report can be both technical as well as non-technical readers. However, it is primarily intended for the engineers at Home Systems Department in Philips Lighting who have the greatest interest of this project. Readers who are interested in the existing software release management processes and challenges within the Home Systems Department, can read Chapters 1, 2 and 3. Readers who are willing to learn more details about the software development life-cycle and core challenges in Internet of Things environment in general are invited to read Chapter 4. Readers who are interested in the technical details, such as system requirements, system architecture, system design, and system implementation will be interested in Chapters 6-11. Readers mainly interested in the results or future continuation of the project can read Chapter 12. Project managers are referred to Chapter 2, 5, 13, and 14. Readers who are interested in the entire project, are welcome to read the entire report.\n\nIgor Anastasov\nSeptember 2017\nAcknowledgements\n\nFirstly, I would like to express my sincere gratitude to my supervisors from Philips Lighting, Leon Bouwmeester, Luud Woltjer and Walter Slegers for providing me the opportunity to do my project in Philips Lighting. I would like to thank all of you for the continuous support, motivation and feedback. Your valuable guidance as well as the knowledge and necessary information you provided, helped me to reach the success of this project. I enjoyed working with you these nine months and thank you for the vast experience I have been able to have with you. Furthermore, I am excited and looking forward to continuing cooperating with you in future as colleague in Philips Lighting.\n\nThis project would not have been a success without the support from my university supervisor Dr. Tanir Ozelebi. Thank you for guiding me throughout the project. Your critical thinking, ideas, feedback and necessary information provided encouraged me to explore different angles and views on the project. Thank you for the continuous support.\n\nMy gratitude goes to everybody involved in the PDEng program, especially Ad Aerts, Yanja Dajsuren, and Desiree van Oorschot for giving me the opportunity to be part of the PDEng program and their support and guidance during these past two years.\n\nI would also like to thank my colleagues from the PDEng program for the great moments and experiences we shared together.\n\nAnd last but not least, I would like to thank my family for their continuous support. A special thank you goes to my girlfriend, Maja, for her support and patience. A special thank you to my parents, Zoran and Keti, for everything they have done for me, and to my sister, Natasha, for her support.\n\nIgor Anastasov,\nSeptember 2017\nExecutive Summary\n\nThe Internet of Things (IoT) is an inter-networking of physical devices embedded with electronics, software, sensors, actuators, and network connectivity that enable these devices to collect and exchange data. Developing software applications for the IoT devices poses plenty of challenges that arise at each stage of the Software Development Life-Cycle (SDLC). Enterprise customers expect their IoT systems to perform for many years, during which they will require regular attention and frequent upgrading to take advantage of advances in technology. This puts pressure on engineers to deliver applications quickly, but without compromising security and performance. That means that software engineers must anticipate what systems will require in the future and plan for the whole life cycle of devices and applications at the design stage, from development, configuration, and deployment through management, monitoring, and, ultimately, decommissioning.\n\nImprovement of the complete SDLC is of immense importance to Home Systems department at Philips Lighting too. Engineers there aim for continuous integration, deployment, and delivery processes in each aspect of the SDLC. They tend to make the SDLC as automated as possible, without compromising security aspects of the systems. This project is part of this global movement and its successful delivery makes a step further in reaching these high-level company objectives. The project has two main goals. First goal is to optimize and automate the software release management workflow, with main emphasis on the code signing process. Second goal is to improve the security in these processes, such as storing and operating the highly sensitive software signing keys.\n\nThe end result of this project solves a lot of challenges in the SDLC. It is a release management tool dedicated for the engineers at the Home department at Philips Lighting. First, it visualizes ongoing software release workflows in a simple and easy to use web-based user interface. With a lot of searching and sorting possibilities, users are able to quickly find out the specific details about a particular software release process. Second, the core activities of the SDLC process are fully automated. The testing architects are now able to digitally sign software with just a few clicks on the web-based user interface. What is more important is that this signing is executed in a highly secure and protected environment. This is of huge importance for Philips Lighting not only because this automation saves a lot of time, but also because it reduces the risk of human error that was present before. The same benefits are gained through an automation of other activities in the SDLC, such as approving the steps, distributing the signed software to the manufacturing factories or deploying the software on the device in the field. Third, the system provides a traceability of each step executed in the process, for instance, who approved the software for signing or who uploaded the signed files to the Hue device portal. Finally, the system is highly configurable, which makes it easy to be extended and adjusted to support different device types with different release workflows.\n\nFrom the software architecture point of view, the designed system exhibits properties, such as modularity and maintainability, which makes it easily extendable. One of the core non-functional requirements of this project was security. This was achieved by applying advanced security mechanisms in every aspect of the 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\n1. Introduction .................................................................. 1\n 1.1 Context ................................................................. 1\n 1.2 Internet of Things .................................................. 1\n 1.3 Philips Lighting ..................................................... 2\n 1.4 Philips Hue System ................................................. 2\n 1.5 Outline ................................................................. 3\n\n2. Stakeholder Analysis .................................................... 5\n 2.1 List of stakeholders ................................................ 5\n 2.2 Stakeholders Analysis ............................................. 5\n 2.2.1. Project Manager and Project Owner ............... 5\n 2.2.2. Product Owner of the Hue platform .............. 6\n 2.2.3. Test Architect in the Integration & Validation team .... 6\n 2.2.4. Security Officer in the Integration & Validation team ...... 7\n 2.2.5. The Bridge Platform team ............................... 7\n 2.2.6. The Bridge Application team ............................ 7\n 2.2.7. The Integration & Validation team in China ......... 8\n 2.2.8. Validation Engineer in Quality Assurance Department .... 8\n 2.2.9. Digital Operations Department ......................... 8\n 2.2.10. Eindhoven University of Technology (TU/e) .......... 9\n 2.2.11. PDEng trainee .............................................. 9\n\n3. Problem Analysis ........................................................ 11\n 3.1 Context ................................................................. 11\n 3.1.1. Software signing ............................................. 11\n 3.1.2. Software deployment in IoT world ................... 11\n 3.1.3. Project goals ............................................... 12\n 3.2 Business Roadmaps ............................................... 12\n 3.3 Design Opportunities ............................................. 12\n\n4. Domain Analysis ........................................................ 13\n4.1 Challenges in the SDLC in IoT world ...........................................13\n4.1.1. Design and Development..............................................13\n4.1.2. Deployment .................................................................14\n4.1.3. Solution........................................................................14\n4.2 Software signing ..................................................................14\n\n5. Feasibility Analysis .................................................................17\n5.1 Issues ...............................................................................17\n5.2 Risks ...............................................................................17\n5.2.1. Project risks ...............................................................17\n\n6. System Requirements .............................................................19\n6.1 Introduction .......................................................................19\n6.1.1. Requirements gathering process ....................................19\n6.1.2. Scope ...........................................................................19\n6.1.3. Intended audience and reading suggestions .......................19\n6.1.4. Definitions, acronyms, and abbreviations ..........................20\n6.2 Overall Description .............................................................20\n6.2.1. Product features and use cases ......................................20\n6.2.2. Operating environment ...............................................22\n6.2.3. Design/Implementation constraints .................................23\n6.3 Functional Requirements .....................................................23\n6.4 Non-functional requirements .................................................25\n6.4.1. Security requirements ..................................................25\n6.4.2. Software quality attributes .............................................25\n\n7. System Architecture ..............................................................27\n7.1 Architectural reasoning .........................................................27\n7.2 Data layer ..........................................................................29\n7.3 Business logic layer ............................................................29\n7.3.1. Representational State Transfer (REST) .........................31\n7.3.2. Hypertext Transfer Protocol ..........................................33\n7.3.3. Business logic layer architecture .....................................34\n7.4 Presentation tier .................................................................35\n7.4.1. Model View Controller (MVC) .....................................35\n7.4.2. Architecture choice for presentation tier .........................36\n7.5 Trade-offs between non-functional requirements ...................37\n\n8. System Design ......................................................................39\n8.1 Introduction ......................................................................39\n8.2 Reference use case .............................................................40\n8.3 Logical view .......................................................................40\n8.3.1. Release workflow system ............................................41\n8.3.2. Software signer system ...............................................43\n8.3.3. Presentation layer .........................................................43\n8.4 Process view ......................................................................44\n8.5 Development view .............................................................45\n8.6 Deployment view ................................................................. 47\n\n9. Implementation ........................................................................ 49\n 9.1 Introduction ............................................................................ 49\n 9.2 Presentation and business-logic layer: Release workflow application ......................................................... 49\n 9.3 Software signer system ............................................................. 50\n 9.4 Data layer ............................................................................ 50\n\n10. Verification and Validation ..................................................... 51\n 10.1 Validation ............................................................................. 51\n 10.2 Verification ............................................................................ 51\n\n11. Deployment .............................................................................. 53\n 11.1 Deployment view ................................................................. 53\n 11.2 Deployment options analysis .................................................. 55\n 11.2.1. Deploying in the Lighting Data Center ......................... 55\n 11.2.2. Deploying in the existing IT environment in the Home Systems department .................................................. 55\n 11.2.3. Deploying in a cloud environment .................................. 55\n 11.2.4. Deployment decision ....................................................... 58\n\n12. Conclusions ............................................................................. 61\n 12.1 Results ................................................................................ 61\n\n13. Project Management ............................................................... 63\n 13.1 Introduction .......................................................................... 63\n 13.2 Work-Breakdown Structure (WBS) ........................................ 63\n 13.3 Project Planning and Scheduling ............................................ 65\n 13.3.1. Initial ........................................................................... 65\n 13.3.2. Final ............................................................................ 65\n 13.4 Project execution ................................................................. 66\n\n14. Project Retrospective ............................................................... 67\n 14.1 Introduction .......................................................................... 67\n 14.2 Design opportunities revisited .............................................. 68\n\nGlossary ...................................................................................... 69\n\nBibliography ................................................................................ 70\n\nAbout the Authors ......................................................................... 73\nList of Figures\n\nFigure 1.1 Hue system overview .............................................................. 3\nFigure 6.1 System level use-cases ............................................................ 22\nFigure 6.2 Envisioned deployment of the system ....................................... 23\nFigure 7.1 Client-server architecture ....................................................... 28\nFigure 7.2 3-tier architecture deployment on separate physical servers ........ 29\nFigure 7.3 Logic tier architecture ............................................................. 34\nFigure 7.4 MVC design pattern ............................................................... 36\nFigure 7.5 Presentation tier architecture .................................................. 37\nFigure 8.1 Logic tier architecture ............................................................. 42\nFigure 8.2 Presentation tier design ........................................................... 44\nFigure 8.3 Handling signing request process. All layers are involved in this communication ......................... 45\nFigure 8.4 Development view of the Release workflow system ............... 46\nFigure 8.5 Development view of the presentation layer ......................... 47\nFigure 8.6 Deployment view of the entire system. A more comprehensive view is offered in the Deployment chapter .............................................................. 48\nFigure 11.1 Deployment view revisited. Concrete implementation specifics are taken into consideration ............................................................. 54\nFigure 13.1 Work-breakdown structure of the project ............................. 64\nFigure 13.2 Initial project plan ................................................................. 65\nFigure 13.3 Final project planning ............................................................. 66\nList of Tables\n\nTable 5.1 Project risks ..............................................................18\nTable 6.1 Definitions, acronyms, and abbreviations ....................20\nTable 6.2 Main users and scenarios ...........................................21\nTable 6.3 Functional requirements ............................................25\nTable 11.1 Deployment options comparison ................................59\n1. Introduction\n\nThis chapter introduces the project and its context. 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 \"Signing and security of Hue software\" project was conducted by Igor Anastasov, 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 4TU.School for Technological Design, Stan Ackermans Institute. [2]\n\nThis Professional Doctorate in Engineering program (PDEng) is an accredited and challenging two-year, third-cycle (doctorate-level) engineering degree program during which its trainees focus on strengthening their 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. PDEng focuses on large-scale project-based design and development of this kind of software. [3]\n\nThe various parts of the PDEng degree program aid in developing the capability of individuals to work within a professional context. It advocates a scientific research-based approach to solving problems, a systematic way of collecting evidence and a critical, reflective, and independent mind for the analysis and interpretation of evidence. The first fifteen months of the program consist of advanced training and education, including four small, industry driven training projects. During the last nine months, a major design project in a company takes place.\n\nThe current project was initiated by Philips Lighting, an organization that develops connected lighting systems and services. By leveraging the Internet of Things, they are transforming buildings, urban places and homes to increase energy efficiency and manage working environments in a more environmentally friendly way. The next section, gives a brief introduction to the Internet of Things paradigm.\n\n1.2 Internet of Things\n\nFrom the first emails to Web 2.0 to the cloud and mobile access, the Internet has made spectacular progress over the past decades. One of the things that the future has in store is an 'Internet of things': connected appliances and machines that dynamically and intelligently adapt to users' needs and preferences. In these developments, light may play a crucial part. [4]\n\nThe Internet of Things is the inter-networking of physical devices, vehicles, buildings, and other items embedded with electronics, software, sensors, actuators, and network connectivity that enable these objects to collect and exchange data. These devices are also referred to as \"connected devices\" and \"smart devices\". In 2013 the Global Standards Initiative on Internet of Things (IoT-GSI) defined the IoT as \"the infrastructure of the information society.\" The IoT allows objects to be sensed and / or controlled remotely across existing network infrastructure, creating opportunities for more direct integration of the physical world into computer-based systems and resulting in improved efficiency, accuracy and economic benefit in addition to reduced human intervention. When IoT is augmented with sensors and actuators, the technology becomes an instance of the more general class of cyber-physical systems, which also encompasses technologies such as smart grids, smart homes, intelligent transportation and\nsmart cities. Each thing is uniquely identifiable through its embedded computing system but is able to interoperate within the existing Internet infrastructure. Experts estimate that the IoT will consist of almost 50 billion objects by 2020. [5]\n\nAs the possibilities for digital, connected lighting develop and expand, Philips Lightings’ smart lighting infrastructure can become the glue that connects the physical world to the digital realm, creating a true \"Internet of Lights\". In this brave new world of connected intelligence, lighting can become an integral and responsive part of our everyday environments. [4]\n\n1.3 Philips Lighting\n\n“Philips Lighting is the leading provider of lighting solutions and applications for both professional and consumer markets, pioneering in how lighting is used to enhance the human experience in the places where people live and work. Whether being at home, on the road, in the city, shopping, at work or at school, Philips Lighting is creating lighting solutions that transform environments, create experiences, and help shape identities. Philips Lighting serves its customers through a market segment approach, which encompasses Homes, Office and Outdoor, Industry, Retail, Hospitality, Entertainment, Healthcare and Automotive. The company employed approximately 33,600 people worldwide with sales of EUR 7.4 billion in 2015. In 2015, Philips Lighting spanned a full-service lighting value chain—from lamps, luminaires, electronics, and controls to connected and application-specific systems and services.” [6]\n\n1.4 Philips Hue System\n\nIn 2012, Philips Lighting launched the Philips Hue System. The Hue is a completely connected home lighting system of linked bulbs that can be controlled by smartphone or tablet via a ZigBee1 bridge that connects to the home Wi-Fi network.\n\nPhilips Hue is an internet connected (wireless) lighting system designed to transform how users experience light inside their homes. It is one of the leading and most installed smart home / Internet of Things products in the world. Philips Hue transforms how users can experience light by enabling color tunable lights to be controlled from smartphones, web services or other control logic and devices running in the system. Furthermore, it is an open system, which means that other suppliers can add third-party components via standardized or published interfaces. [7]\n\nThe Hue system consists of various products: the Hue portal2, the mobile applications, the bridges, various lamps and luminaires, sensors, and switches. Figure 1.1 shows a high-level overview of the Hue system and its main components. Several of these devices, such as lamps, luminaires, bridges, sensors, and switches contain software. It is essential that the respective software is securely signed before it is deployed to the production factories and installed on the device. Moreover, when there is an updated version of the software available, all consumer devices in the field need to be updated with the latest version of the software. This also requires the software to be securely signed. Additionally, the distribution channels through which the software is being distributed to the factories and to the consumer devices in the field, need to be highly secured and to conform to the highest security standards.\n\nWithin the Philips Lighting projects software engineers are working towards continuous integration and deployment. Once the Integration & Verification (I&V) team has given their approval on release of specific software, the software running on, for example, the bridge must be signed and uploaded to the Hue cloud for further distribution towards all consumer devices in the field. The bridge software must also be signed and securely sent to the factory as a running change on all devices that are being produced.\n\n1 http://www.zigbee.org/\n2 For the remainder of this report, the terms “Hue portal,” “Hue device cloud,” and “Hue cloud” are used interchangeably and refer to the same system\nCurrently, all these steps beginning from the 'approval' from the I&V are manual steps which are error prone. The aim of this project is to automate and optimize this process.\n\nFigure 1.1 Hue system overview\n\n1.5 Outline\n\nThe next chapter, Chapter 2, introduces the stakeholders of this project together with their interests and goals. A problem analysis is described in Chapter 3 that elaborates the problem that this project is focusing on and its current state in the ecosystem. Chapter 4 talks about the domain of the problem and gives directions towards the problem's solution. The issues and challenges encountered during the lifetime of the project as well as the risks that might arise are elaborated in Chapter 5.\n\nThe following chapters focus on the design and implementation phases of the project. Chapter 6 lists the user and functional requirements derived from the domain and problem analysis as well as from the many discussions we had with the stakeholders. The requirements together with the domain and problem analysis give an input for the system architecture that is elaborated in Chapter 7. After modeling the architecture, the design of the system is created. The system design is presented in Chapter 8. Chapter 9 describes the implementation of the system. The process of validation and verification of the system is discussed in Chapter 10. Explanation of the deployment of the solution is described in the Chapter 11. Finally, the conclusions and future work are addressed in Chapter 12.\n\nThe project management process during the lifetime of the project is described in Chapter 13. Finally, Chapter 14 gives the retrospective and reflection on the project from the author's perspective.\n2. Stakeholder Analysis\n\nThis chapter gives an overview of the stakeholders involved in the project. The main concerned parties are Philips Lighting (supervisors and the Department of Home Systems) and the Eindhoven University of Technology (supervisor and PDEng trainee). For each concerned party, the representative stakeholders are listed together with their role, responsibilities, concerns, acceptance criteria, and involvement.\n\n2.1 List of stakeholders\n\nThe following stakeholders were identified:\n- Project Manager\n- Product Owner\n- Test Architect in the Integration & Validation team\n- Security Officer in the Integration & Validation team\n- Product Owner of the Hue bridge platform\n- The Bridge Application team\n- The Bridge Platform team\n- The ZigBee Platform team\n- The ZigBee Products team\n- The Mobile Applications team\n- The Device cloud (HSDP) team\n- The Digital Operations department\n- Quality Assurance Department\n- The Integration & Validation team in China\n- Factory employee – responsible for receiving and deploying the updated bridge firmware\n- Eindhoven University of Technology (TU/e)\n- PDEng trainee\n\n2.2 Stakeholders Analysis\n\nThe following table gives an overview of each stakeholder’s role, concerns, acceptance criteria, and their involvement during the project.\n\n2.2.1 Project Manager and Project Owner\n\n- ROLE\n - The project owner is the person who defines the goals of the project, funds it and looks for the business value\n - The project manager is the person who organizes the project and has to make sure that the project goals (defined by the owner) are met one time and within budget\n\n- REPRESENTATIVE\n - Project owner: Luud Woltjer\n - Project manager: Leon Bouwmeester\n\n- RESPONSIBILITIES\n - Monitor, evaluate, assess, and provide regular feedback on the project progress and deliverables\n - Provide relevant domain knowledge, references, and contacts\n - Provide relevant information regarding the needs and requirements of the project\n - Evaluate whether the solution meets the requirements\n - Review the final project report\n\n- ACCEPTANCE CRITERIA\n - Timely report of the project deliverables\n• CONCERNS\n ✓ Project is delivered according to the defined timeline\n ✓ System is developed by using approved licenses. For instance, MIT, BSD are preferred over GPL.\n• INVOLVEMENT\n ✓ During the entire project by continuous communication via daily meetings on ad–hoc basis, regular weekly progress update meetings, and regular monthly project steering group meetings.\n\n2.2.2. Product Owner of the Hue platform\n• ROLE\n ✓ Software architect responsible for and owning the Hue platform.\n• REPRESENTATIVE\n ✓ Walter Slegers\n• RESPONSIBILITIES\n ✓ Monitor, evaluate, assess and provide regular feedback on the project progress and deliverables\n ✓ Provide relevant domain knowledge, references, and contacts\n ✓ Provide relevant information regarding the needs and requirements of the project\n ✓ Evaluate whether the solution meets the requirements\n ✓ Review the final project report\n• ACCEPTANCE CRITERIA\n ✓ Timely report of the project deliverables\n ✓ Solution meets functional and non-functional requirements\n• CONCERNS\n ✓ Deploying the software to the wrong luminaires/lamps/bridges (a wrong bridge image deployed seemed to have happened in the early days of Hue)\n ✓ Being able to stop a software deployment (has been necessary once because the software contained a problem discovered after deployment started)\n ✓ Accidentally deploying to the wrong region / world or to the customers instead of alpha/beta groups.\n ✓ Being able to see the deployment status (For example. version X detected on y% of connected bridges)\n• INVOLVEMENT\n ✓ During the entire project by continuous communication via daily meetings on ad–hoc basis, regular weekly progress update meetings, and regular monthly project steering group meetings.\n\n2.2.3. Test Architect in the Integration & Validation team\n• ROLE\n ✓ Testing & Validation of the software\n• REPRESENTATIVE\n ✓ Luud Woltjer\n• RESPONSIBILITIES\n ✓ Provide relevant domain knowledge\n ✓ Provide relevant information regarding the needs and requirements of the project\n ✓ Evaluate whether the solution meets the requirements\n• ACCEPTANCE CRITERIA\n ✓ Solution meets functional and non–functional requirements\n• CONCERNS\n ✓ Giving approval on a specific release is automated and is a simple process\n ✓ It is visible and clear which version of the release is under validation\n✓ There is a clear and simple communication channel with the respective development teams\n\n- INVOLVEMENT\n ✓ During the entire project by continuous communication via daily meetings on ad-hoc basis, regular weekly progress update meetings\n\n### 2.2.4. Security Officer in the Integration & Validation team\n\n- ROLE\n ✓ Digitally signing the production firmware version\n ✓ Upload signed firmware to the device cloud\n ✓ Approve deployment of the firmware on specific devices and/or factory\n\n- REPRESENTATIVE\n ✓ Luud Woltjer\n\n- RESPONSIBILITIES\n ✓ Provide relevant domain knowledge\n ✓ Provide relevant information regarding the needs and requirements of the project\n ✓ Evaluate whether the solution meets the requirements\n\n- ACCEPTANCE CRITERIA\n ✓ Solution meets functional and non-functional requirements\n\n- CONCERNS\n ✓ Signing certificates for production firmware are securely stored under highest possible security measures\n ✓ Software signing is an automated, simple and straightforward process\n ✓ Uploading the firmware to the device cloud is automated and is a simple process. It is visible which version is deployed on the test and production device cloud.\n ✓ Approving deployment of the firmware on specific devices and/or factory is an automated and simple process\n ✓ There is an archive of all production builds, i.e. it is clear and visible which version is released\n\n- INVOLVEMENT\n ✓ During the entire project by continuous communication via daily meetings on ad-hoc basis, regular weekly progress update meetings\n\n### 2.2.5. The Bridge Platform team\n\n- ROLE\n ✓ Develop bridge firmware\n\n- REPRESENTATIVE\n ✓ Erik Maas\n\n- RESPONSIBILITIES\n ✓ Provide relevant domain knowledge\n\n- ACCEPTANCE CRITERIA\n ✓ Solution meets functional and non-functional requirements\n\n- CONCERNS\n ✓ Signing production firmware is done by using same development scripts which are maintained by developers\n ✓ There is a clear procedure for signing and deployment with clear responsibilities about who is liable for the specific step\n\n- INVOLVEMENT\n ✓ Meetings on an ad-hoc basis\n\n### 2.2.6. The Bridge Application team\n\n- ROLE\n ✓ Develop bridge application firmware\n\n- REPRESENTATIVE\n✓ Ino Dekker\n\nRESPONSIBILITIES\n✓ Provide relevant domain knowledge\n\nACCEPTANCE CRITERIA\n✓ Solution meeting functional and non-functional requirements\n\nCONCERNS\n✓ Signing production firmware is done by using the same development scripts that are constantly maintained by the software developers\n✓ The process of uploading firmware artifacts to the Hue portal is automated\n\nINVOLVEMENT\n✓ Meetings on an ad-hoc basis\n\n2.2.7. The Integration & Validation team in China\n\nROLE\n✓ Approve the release of the new firmware version for several devices such as the bridges, various lamps, sensors and switches\n\nREPRESENTATIVE\n✓ Paul Krekel\n\nRESPONSIBILITIES\n✓ Provide relevant domain knowledge and technical information regarding the needs and requirements of the project\n\nACCEPTANCE CRITERIA\n✓ Solution meets functional and non-functional requirements\n\nCONCERNS\n✓ Signing certificates for production firmware are securely stored under highest possible security measures\n✓ There is an archive of all production builds and it is clear and visible which version is released on specific date\n✓ Specific configuration files related to particular products such as lamps and luminaires are archived and stored together with specific build artifacts\n\nINVOLVEMENT\n✓ Meetings on ad-hoc basis\n\n2.2.8. Validation Engineer in Quality Assurance Department\n\nROLE\n✓ Quality Assurance in the Software Development process\n\nREPRESENTATIVE\n✓ John Goor\n\nRESPONSIBILITIES\n✓ Provide relevant domain knowledge and requirements regarding the quality aspects of the delivered solution\n\nACCEPTANCE CRITERIA\n✓ Solution meets functional and non-functional requirements\n\nCONCERNS\n✓ To have a clear explanation about the process for signing and deployment of Hue software (responsibilities, workflow)\n✓ Traceability in the process\n\nINVOLVEMENT\n✓ Meetings on ad-hoc basis\n\n2.2.9. Digital Operations Department\n\nROLE\n✓ Manages specific operations\n\nREPRESENTATIVE\n✓ Carlos Sierra\n• RESPONSIBILITIES\n ✓ Provide relevant domain knowledge and requirements related to the Digital Operations (DO) department\n• ACCEPTANCE CRITERIA\n ✓ Solution meeting functional and non-functional requirements\n• CONCERNS\n ✓ To distribute the software at a high level of security\n ✓ To have traceability in the process\n ✓ To be included in the specific steps in the process\n• INVOLVEMENT\n ✓ Meetings on ad-hoc basis\n\n2.2.10. Eindhoven University of Technology (TU/e)\n• ROLE\n ✓ The university guards the educational interests of the university and the trainee\n• REPRESENTATIVE\n ✓ PDEng Program Director: Ad Aerts\n ✓ TU/e supervisor: Tanir Ozcelebi\n• RESPONSIBILITIES\n ✓ Monitor, evaluate, assess and provide regular feedback on the project progress and deliverables\n ✓ Provide relevant domain knowledge, references and contacts\n ✓ Provide relevant information regarding the needs and requirements of the project\n ✓ Monitor, evaluate, assess and provide feedback on the trainee’s design process and qualities of the design\n ✓ Review the final project report\n• ACCEPTANCE CRITERIA\n ✓ Timely report of the project deliverables\n ✓ Design, implementation, project management and documentation that meet the level of a PDEng project\n• INVOLVEMENT\n ✓ During the entire project by continuous communication via meetings on ad-hoc basis with the PDEng trainee and regular monthly project steering group meetings.\n\n2.2.11. PDEng trainee\n• ROLE\n ✓ Software designer, project manager\n• REPRESENTATIVE\n ✓ Igor Anastasov\n• RESPONSIBILITIES\n ✓ Responsible for complete project implementation\n• ACCEPTANCE CRITERIA\n ✓ Content of sufficient quality as to the level expected of a PDEng trainee\n3. Problem Analysis\n\nThe first two chapters give a brief overview of the project’s context and scope, and the stakeholders’ interests and goals. This chapter focuses on the problem that the project is trying to solve, by analyzing not only the use cases and challenges of the software signing and deployment within Philips Lighting, but also the overall challenges of the security and software deployment processes.\n\n3.1 Context\n\n3.1.1. Software signing\n\nSoftware signing is a process of digitally signing executables and scripts to confirm the software author and guarantee that the code has not been altered or corrupted since it was signed. The most common use of code signing is to provide security when deploying software. Almost every code signing implementation provides some sort of digital signature mechanism to verify the identity of the author. [8]\n\nThe efficacy of code signing as an authentication mechanism for software depends on the security of underpinning signing keys. As with other public key infrastructure (PKI) technologies\\(^3\\), the integrity of the system relies on publishers or authors securing their private keys against unauthorized access.\n\nWithin Philips Lighting, the Security Officer inside the Integration & Validation team is responsible for storing the signing keys. Additionally, he is responsible for signing the production version of the appropriate Hue software. Storing the signing keys safely and securely is one of the main challenges and responsibilities of the Security Officer. There should be highest possible security measures in place in order to prevent unauthorized access to these keys. Another challenge that the Security Officer is facing now is the signing process itself. The current process includes many steps that are manual and therefore error prone. There is a specific software script that, combined with the secret keys, generates the signed production version of the Hue software. However, this execution is done manually with a real possibility of mistakes. Moreover, there are two versions of the production software that are generated and require diverse ways of signing. One version is needed for distribution to the device factories, and one version is uploaded to the Hue portal.\n\n3.1.2. Software deployment in IoT world\n\nThe IoT combines smart devices and sensors with analytics and the cloud. This paradigm shift presents new challenges involving software distribution, updates, and security. The world is evolving into an “everything as a service” environment and the embedded industry is no different. Internet of Things applications make heavy use of the cloud and this new paradigm is essentially what differentiates IoT from traditional networked embedded systems. Software updates are essential. Within the context of IoT and cloud applications, the ability to soft-configure the system is critical and an essential part of the motivation for moving traditional networked embedded systems in this new emerging direction. These kinds of capabilities offer the ability to quickly deploy new features and capabilities at a fraction of the cost. New capabilities promise lower cost and increased revenue. The ability to quickly, securely, and flexibly update any cloud-based service is essential to take advantage of the benefits this environment provides. Further, within the cloud, adding new services can adversely affect the security of the existing hosted services. For these reasons, new tools, capabilities, and techniques are emerging to coordinate and synchronize software distribution. [9]\n\n\\(^3\\) https://en.wikipedia.org/wiki/Public_key_infrastructure\nThe software distribution process involves software developers, integrators, testers and software users. The developers create the software and utilize a variety of integrated development environments (IDEs), code repositories, automated test, and continuous integration tools. Once the production binaries are created and tested, these binaries need to be controlled, stored, and managed throughout the release. Sometimes these are called \"binary artifacts.\" It is important for binary management solutions to integrate with popular repositories, build tools, and continuous integration servers. The other consideration is how developers store, publish, download, and distribute software. The cloud environment adds significant complexity. In many IoT instances, endpoints may be a variety of platforms with end users that may or may not upgrade in a timely manner. [9]\n\nWithin the Philips Lighting projects, the engineers are working toward continuous integration and deployment. Once the Integration & Verification (I&V) team has given their approval on release of specific software, the software running on, for example, the bridge, must be signed and uploaded to the Hue cloud for further distribution toward all consumer devices in the field. The bridge software must also be signed and securely sent to a factory as a running change on all devices that are being produced. There are several actions that need to be undertaken until the software is released. All these actions are consisted of manual steps.\n\n3.1.3. Project goals\nImprovement of the complete Software Development Life-Cycle (SDLC) is of immense importance to Philips Lighting. Engineers there tend to make the SDLC as automated as possible, without compromising security aspects of the systems. This project is part of this global movement and its successful delivery makes a step further in reaching these high-level company objectives. The project has two main goals. First goal is to optimize and automate the software release management workflow, with main emphasis on the automation of the code signing process. Second goal is to improve the security in these processes, such as storing and operating the highly sensitive software signing keys. The following section explains in detail the current process of Hue software deployment and pinpoints the possible issues that could happen with it.\n\n3.2 Business Roadmaps\nImprovement of the complete Software Development Life-Cycle (SDLC) is significant to the Philips Lighting too. Engineers there aim for continuous integration, deployment, and delivery processes in each aspect of the SDLC. They tend to make the SDLC as automated as possible, without compromising security aspects of the systems. This project is part of this global movement and its successful delivery makes a step further in reaching these high-level company objectives.\n\n3.3 Design Opportunities\nDuring the study of the Hue system domain and the problem analysis, the following design opportunities were identified, namely security, usability and reliability. First, the system shall have access to the keys used for signing the production Hue software. These keys are sensitive and the system needs to provide the highest possible security measures in order to prevent unauthorized access to them. Second, the system should replace a complete process. Therefore, the system should satisfy the requirements of the owner and the stakeholders of the project in a way that the system is made usable and intuitive. Finally, the system should be reliable. The speed of execution is not critical, but the correctness of the processes is crucial. It is preferred that processes run sequentially. Concurrency is not preferred since every action need to be atomic and therefore system should know its state in every moment of time.\n4. Domain Analysis\n\nThe problem analysis discussed in the previous chapter reveals the domain in which the project resides, namely the Software Deployment Life-Cycle (SDLC) in the IoT domain and the software signing with specific emphasis on the security perspective of these processes. The objective of this chapter is to broaden the understanding of the domains by analyzing the core challenges in them and identify the relevant parts that provide insight for the solution to the problem.\n\n4.1 Challenges in the SDLC in IoT world\n\nDeveloping applications and devices for the Internet of Things (IoT) poses plenty of challenges. Because IoT systems may be expected to perform for many years, developers must plan for their entire lifecycle, from design through end-of-life. Demand for IoT solutions puts pressure on developers to deliver applications quickly without compromising security and performance. Enterprise customers expect their IoT systems to perform for many years, during which they will require regular attention and frequent upgrading to take advantage of advances in technology. That means developers must anticipate what systems will require in the future and plan for the whole lifecycle of devices and applications at the design stage, from development, configuration, and deployment through provisioning, management, monitoring, and, ultimately, decommissioning. [10]\n\nManaging the IoT lifecycle presents a prominent level of complexity. IoT systems often entail connecting existing “brownfield” devices that were not designed for connectivity. Developers must also ensure that the connection is secure, which requires implementing protective measures at all levels – device, network, and cloud. Once devices are securely connected, operators need a way to provision them, which today often means literally going from device to device with a thumb drive and loading applications or performing upgrades manually. Finally, IoT systems face the challenge of integrating with enterprise systems that can aggregate, analyze, and act upon the data collected from devices, bridging operational technology (OT) and information technology (IT) systems that have historically been separated by air gaps. [10]\n\nTo bring greater simplicity and efficiency to SDLC process, developers and system operators need the means to configure, provision, and manage field devices remotely. Many organizations today have, at most, the means to connect devices and collect data via gateways, but lack the ability to “push” control instructions back to devices. With hundreds or even thousands of devices on a single IoT network, the cost of lifecycle management and the risk of failure can be extremely high. To better understand the capabilities needed to address these challenges, it is instructive to walk through the entire device lifecycle. [10]\n\n4.1.1. Design and Development\n\nThe new challenges arising from IoT call for new, more flexible development methods that enable developers to build applications efficiently and deploy them to multiple devices. In the absence of a single standard of device connectivity, ease of integration with a variety of platforms is a necessity. A pre-configured development platform, optimized for IoT, which does not require the use of actual devices, can dramatically accelerate development and enhance efficiency, reducing the risk of errors and delays. Increasingly, software development is distributed among teams, often working in separate locations. With a cloud-based development platform that allows anytime, anywhere access, distributed development teams can collaborate more effectively and further speed the process. Security is a paramount concern in IoT development. An end-to-end security strategy must be factored in across the application lifecycle at the design stage. Building in security functionality adds a layer of complexity that can be a drag\non development and interfere with the eventual performance of the application. Developers can mitigate this, however, by building on a platform using pre-configured, integrated software components in which many security issues have already been addressed. This reduces complexity, saves time, and lowers the risk of security gaps due to misconfiguration. [10]\n\n4.1.2. Deployment\n\nOnce an application has been tested, developers need the means to deploy it easily to hundreds or thousands of devices in the field. A similar challenge is facing the Philips Lighting. This can be accomplished with a platform that includes built-in capabilities for the remote commissioning, provisioning, and customization of devices with new applications.\n\n4.1.3. Solution\n\nTo overcome the complexity of IoT development, it is important to think of the system lifecycle not as a sequence of discrete steps, but in a holistic fashion. The key capabilities for managing the system lifecycle, therefore, need to be integrated.\n\nThese capabilities would include tools for:\n\n- **Remote device management**: Sending out engineers to maintain and upgrade devices in the field is simply not viable in large-scale IoT deployments. System operators need to be able to manage devices from a central location in a closed-loop system from provisioning to end-of-life.\n\n- **Virtualized application development**: Developers need the ability to customize and reconfigure deployed devices with new applications, using an abstracted target hardware platform that does not require proximity to an actual device.\n\n- **Modeling and testing**: Development teams need to test applications thoroughly even during the debug phase, using simulation models capable of replicating the entire system across its entire lifecycle.\n\nFinally, to enable distributed development teams to collaborate efficiently and effectively, it makes sense to house these tools in a secure cloud environment, whether on an internal server or through an external provider that allows anywhere, anytime access to authorized developers. [10]\n\nThis Section explores the challenges that arise at each stage of the lifecycle and how to address them, and outlines the advantages of having an integrated development environment for building, testing, deploying, and managing IoT applications.\n\n4.2 Software signing\n\nSoftware signing is the method of using a certificate-based digital signature to sign executables and scripts in order to verify the author’s identity and ensure that the code has not been changed or corrupted since it was signed by the author. This helps users and other software to determine whether the software can be trusted. [11]\n\nBecause of the potential damage that an executable or script can cause to a computer system, it is important that users are able to trust the code published on the Internet. There are two important ways that Code Signing increases trust, namely:\n\n- **Authentication.** Verifying who the author of the software is.\n- **Integrity.** Verifying that the software has not been tampered with since it was signed.\n\nFor example, every time a developer publishes a software application, he signs it with his own signing certificate. Before using the application, other users can clearly see\n\n---\n\n4 Sometimes is referred to as Code signing\nthat it is signed by a known developer and they will know that it has not been changed by a hacker in the process of downloading it.\n\nAnother advantage that code signing provides is the ability to trust updates. If an update to a software application is released and signed using the same key as the original application, the update can be automatically trusted because it could not have come from anywhere other than the original trusted software developer or organization.\n\nAlmost every code signing implementation will provide some sort of digital signature mechanism to verify the identity of the author or build system, and a checksum to verify that the object has not been modified. The efficacy of code signing as an authentication mechanism for software depends on the security of underpinning signing keys. As with other public key infrastructure (PKI) technologies, the integrity of the system relies on publishers securing their private keys against unauthorized access. Keys stored in software on general-purpose computers are susceptible to compromise. Therefore, it is more secure, and best practice, to store keys in secured tamper-proof devices. Software is written code, and code can be read and analyzed. Once it has been analyzed, it can be modified to the requirements of an attacker. If a device is reprogrammed with modified software, the authentication process and system integrity can be broken. Another potential and severe weakness of software-based solutions is the inappropriate storage of secret keys during various process and production steps. Typically, in software-based protection systems, attackers can easily identify secret keys that are built into the software or otherwise stored in readable form. [8]\n\nSetting up a secure storage for software signing keys is one of the challenges that the Philips Lighting faces. Therefore, one of the most important goals of this project is to find a more secure way of handling and storing these keys.\n5. Feasibility Analysis\n\nAfter elaborating the problem and domain analysis, a feasibility analysis is performed to identify and analyze issues and risks that exist or might appear. This chapter discusses issues and risks identified together with their mitigation strategies.\n\n5.1 Issues\n\nThis section describes issues and challenges that we came across during the lifetime of the project.\n\ni. Arranging meetings with all important stakeholders of this project is a challenging activity. The discussions with testing architects, security officers, different development teams, the product security department, and distributed teams in Bangalore are crucial input to the problem analysis and further definition of the use cases and requirements of the project. Given their busy everyday schedule, arranging discussions for exacting key requirements and evaluating the result is a challenging task that requires stakeholder management and time management skills.\n\nii. Having an appropriate deployment environment where the final results will be installed is critical for delivering the end product of this project as it affects the design, modeling, implementation, and validation steps of the project. Deployment of the end product introduces an extra level of complexity because of two reasons. First, there are several possibilities for deployment, such as internal Philips Lighting data center, existing IT infrastructure in the Home Department, and cloud providers. Second, if cloud providers are chosen, there are a lot of legal regulations that need to be satisfied in order to make a contract with some of these providers. Having complete deployment environment is a risk identified and elaborated in the following section.\n\niii. Finally, integrating the existing Hue software into the system-under-development means that several adjustments need to be implemented into the existing software for code signing. Currently, there are several types of Hue software, such as bridge and lamp. Some of these software files are signed with external signing software that runs on a specific operating system. To integrate completely into one system, some of the existing code signing scripts need to be migrated to a different operating system. Properly communicating those changes and defining who is liable for them now and in the future, adds additional complexity to the project itself.\n\n5.2 Risks\n\n5.2.1 Project risks\n\nDuring the project, a number of risks are identified. Table 4 lists risks together with their impact on the project and corresponding mitigation strategy. A more proactive risk management is applied during the initial months of the project due to the uncertainties and not clearly defined milestones. Further through the lifetime of the project, this list was updated as the scope and complexity became clearer.\n\n<table>\n<thead>\n<tr>\n<th>Risk ID</th>\n<th>Description</th>\n<th>Impact</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>R01</td>\n<td>Stakeholders’ unavailability</td>\n<td>Some stakeholders might not be available for (detailed) discussions, so the input gathered might be limited.</td>\n</tr>\n</tbody>\n</table>\n### Mitigation strategy\n\nMake plans for meetings in advance. Always try to have a backup strategy in case important stakeholder is unavailable.\n\n### Risk ID\n\n**R02**\n\n### Description\n\nThe Home department does not have dedicated servers for deployment of the final product of this project. This is understandable, since they are more oriented towards embedded development. Therefore, the author needs to properly communicate and choose a deployment option. There is a risk that this decision and implementation will take a longer time, having in mind all legal and security regulations that Philips Lighting has.\n\n### Impact\n\nIt will not be possible for the stakeholders to use the system.\n\n### Mitigation strategy\n\nPlan deployment early. Specify acceptance criteria and start analyzing deployment options. Set a fixed deadline for the decision and implementation. Clearly communicate this risk with the stakeholders and together define a backup plan in case this process is not finished on time.\n\n### Risk ID\n\n**R03**\n\n### Description\n\nNot a feasible requirement. One requirement of the project stays that the system shall implement an automated process for software upload to device cloud. However, the device cloud system is owned by the Royal Philips and there is a chance that it is technically not possible to integrate with this system as stakeholder’s desire.\n\n### Impact\n\nIt will not be possible for the stakeholders to automatically upload signed software artifacts to the device cloud.\n\n### Mitigation strategy\n\nAnalyze if this requirement is technically feasible. If not, then clearly communicate this to the stakeholders and together define a backup scenario.\n\n### Risk ID\n\n**R04**\n\n### Description\n\nOperating system incompatibility. As we briefly mentioned in the Section 5.1, there are diverse ways of software signing for different types of Hue devices. Some of them require Windows operating system and some of them are fully Linux dependent. Since the goal of the project is to integrate all signing processes into one automated system, some of those signing processes need to be migrated into a different operating system. However, this migration is a complete project and is not in the scope of this one. Therefore, there is a risk that the system will not be applicable for some of the device types.\n\n### Impact\n\nThe final product will not support all possible device types, such as Hue bridge and Hue lamps.\n\n### Mitigation strategy\n\nDiscuss with stakeholders who is liable for this migration. Define a proper timeline for the migration.\n\n### Table 5.1 Project risks\n\nAs addition to the risks listed in Table 5.1, a comprehensive Information Security Risk assessment was performed during the architecture, design and implementation phases on the project deliverable. The purpose of this assessment was to analyze how the system is exposed to the security risks happening in its environment. The output of this analysis was a risk register, that contains a list of information security threats that are relevant to this project. Each threat was given with the following details: vulnerability, threat source, threat explanation, likelihood of the threat, impact, mitigation strategy, risk level, and risk level after mitigation. The mitigation strategies proposed here influenced and steered some further decisions that were made.\n6. System Requirements\n\nThis chapter describes the system requirements from the project “Signing and security of Hue software.” After analysis of the domain and its problems, a set of requirements are extracted and formulated that must be satisfied for this project. This document presents these requirements, both functional and non-functional ones.\n\n6.1 Introduction\n\nAlthough this chapter is primarily intended for engineers, it does not specify each functionality with technical details. It is assumed that the reader is familiar with the Hue system, current project description, goals, domain and the problem statement.\n\n6.1.1 Requirements gathering process\n\nBoth the problem and domain analysis reveal the core of the problem and its position in the bigger ecosystem. Still, 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\nTwo sets of requirements are identified: functional requirements and non-functional requirements. Each requirement has a priority assigned to it, which indicates the importance of that requirement. The following three categories are defined for priority, based on the descriptions defined by S. Brander [12]:\n\n- MUST — absolute requirement of the specification.\n- SHOULD — there may exist valid reasons in particular circumstances to ignore a particular item, but the full implications must be understood and carefully weighed before choosing a different course.\n- OPTIONAL — the requirement is truly optional.\n\n6.1.2 Scope\n\nThe scope of the project includes the processes of signing and deployment of the Hue software running on the following devices:\n\n- Hue Bridges and\n- Hue Lamps\n\nThe scope of the project starts after the moment the software is developed and the development phase is finished. There is no differentiation among different versions of the Hue devices. The project sees the software as a collection of files (artifacts) that are a complete product that need to be signed and further distributed.\n\n6.1.3 Intended audience and reading suggestions\n\nThis chapter is intended for any individual user, developer, tester, project manager, or documentation writer who needs to understand the basic system specifications.\n\nHere are the potential uses for each one of the reader types:\n\n- Developer: The developer who wants to read, change, modify or add new requirements into the existing program must firstly consult this chapter and update the requirements in the appropriate manner so as not to destroy the\nactual meaning of them and pass the information correctly to the next phases of the development process.\n\n- **User:** The user of this system reviews the diagrams and the specifications presented in this chapter and determines if the software has all the suitable requirements and if the software developer has implemented all of them.\n- **Tester:** The tester needs this chapter to validate that the initial requirements of this system correspond to the executable system correctly.\n\n### 6.1.4. Definitions, acronyms, and abbreviations\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>The software</td>\n<td>In the current context, the term software is related to the specific Hue software developed for a device such as the bridge device and the Hue lamp. Sometimes it is referred as “firmware,” “software version,” “software artifacts,” and “release.”</td>\n</tr>\n<tr>\n<td>Software signing</td>\n<td>In the current context, it refers to the activity of running the signing script together with production keys to build a production signed version of the software.</td>\n</tr>\n<tr>\n<td>The Hue portal</td>\n<td>The cloud system where software artifacts are uploaded for future deployment. Sometimes referred to as “device cloud,” or “Hue device cloud”.</td>\n</tr>\n<tr>\n<td>I&V</td>\n<td>The Integration and Verification team.</td>\n</tr>\n<tr>\n<td>SO</td>\n<td>The Security Officer from the I&V team responsible for signing the production software.</td>\n</tr>\n<tr>\n<td>MAC</td>\n<td>A media access control address (MAC address) of a computer is a unique identifier assigned to network interfaces for communication at the data link layer of a network segment.</td>\n</tr>\n<tr>\n<td>Software developer</td>\n<td>In current context, the software developer term can relate to the developer working in the following teams: Bridge Application, Bridge Platform, ZigBee Platform and ZigBee Products.</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.1 Definitions, acronyms, and abbreviations\n\n### 6.2 Overall Description\n\n#### 6.2.1. Product features and use cases\n\nSix major features are identified from the requirements gathering process, namely, centralized location for software released versions, automated software signing, automated software distribution to the Hue portal, automated software deployment, automated upload of the software to the production factories, and automated distribution of the software for mobile application release.\n\ni. The first feature, centralized location for firmware versions, serves as an archive of all production releases. Moreover, the system shall provide information about specific data related to a release. For instance, when the software is released, who approved specific step in the process and which files are related to that release.\n\nii. The second feature, an automated process for software signing, deals with the process of digitally signing software artifacts. The automation of this process helps Security Officers to replace the current manual error prone procedure with a fast, automated and reliable process.\n\niii. The third feature, an automated process for software distribution to the Hue portal, focuses on the process of uploading the software files to the device cloud. The current process is manual and therefore is error prone. Moreover, it requires a lot of communication overhead between the Testing Architects and the employees who are responsible for uploading the files.\niv. The fourth feature, an automated process for software deployment, deals with the process of deploying the artifacts on specific devices. Devices can be specified by their MAC addresses and/or their physical location. This process is also known as regional deployment. At the moment, it is also a manual process.\n\nv. The fifth feature, an automated process for uploading software to factories, will allow the Security Officer to directly upload artifacts to the production factories. At the moment, this is also a manual process.\n\nvi. The sixth feature, an automated process for distributing software for mobile application release, will allow the Security Officer to directly send artifacts to the mobile application development team. This is needed for further creation of the mobile application version release. This last step is not in the scope of this project.\n\nvii. It is important to understand that all features from second to the sixth, are part of a larger workflow that deals with the entire process of distribution and deployment of the software release. Therefore, another feature of the system is to manage this workflow. There should be clear explanation of the process and responsibilities inside it. Each action in the process will be traceable.\n\nThe refinement of the requirements revealed also the main actors or users of the product. Table 6.2 lists the identified users and their main scenarios/steps within the system. The presented scenarios in the table are expressed from an abstract point of view. After refinement of the main requirements and use cases, the list of functional requirements was identified. The functional requirements are discussed in Section 6.3.\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>Admin</td>\n<td>• Configure and manage the workflows, user, roles and permissions</td>\n</tr>\n<tr>\n<td>Security officer</td>\n<td>• Approve a step in the release workflow</td>\n</tr>\n<tr>\n<td></td>\n<td>• Sign software files</td>\n</tr>\n<tr>\n<td></td>\n<td>• Upload signed files to the production factories</td>\n</tr>\n<tr>\n<td></td>\n<td>• View release workflow details</td>\n</tr>\n<tr>\n<td>Software developer</td>\n<td>• Approve a step in the release workflow</td>\n</tr>\n<tr>\n<td></td>\n<td>• Start a new release workflow</td>\n</tr>\n<tr>\n<td></td>\n<td>• View release workflow details</td>\n</tr>\n<tr>\n<td>Test architect</td>\n<td>• Approve a step in the release workflow</td>\n</tr>\n<tr>\n<td></td>\n<td>• Send files to the mobile app development team</td>\n</tr>\n<tr>\n<td></td>\n<td>• Deploy software on end devices</td>\n</tr>\n<tr>\n<td></td>\n<td>• Upload the software files to the device cloud</td>\n</tr>\n<tr>\n<td></td>\n<td>• View release workflow details</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.2 Main users and scenarios\n\nFigure 6.1 shows the system level use cases, which are based on the identified major 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.2.2. Operating environment\n\nOne of the concerns and requirements that users of the system have is that it should be easily accessible via web browser from everywhere inside the Philips Lighting network. In this way, authorized users can sign software, approve specific step in the workflow, upload the software to the Hue portal or factory or send the artifacts to the mobile application team. Figure 6.2 depicts the envisioned deployment of the system.\n6.2.3. Design/Implementation constraints\nThe following technical constraints need to be taken into consideration during the design and implementation phases. First, a Linux\\(^5\\) based operating system is preferred option for the system where the software signing processes will run, because the software signing applications are specifically developed for Linux operating system. Changing or adjusting these signing applications is not in the scope of this project.\n\nThe signing applications that are used to sign Hue software are coded in Python. Therefore, the application server where the system will run need to have the appropriate version of Python installed.\n\nRegarding the licenses for the software libraries used in the implementation phase, open-source based licenses are preferred, specifically the MIT\\(^6\\) and BSD\\(^7\\) type of licenses.\n\n### 6.3 Functional Requirements\nThis section includes the requirements that specify all the fundamental actions of the system. Each requirement has a brief description and an assigned priority.\n\n<table>\n<thead>\n<tr>\n<th>ID</th>\n<th>Description</th>\n<th>Depends on</th>\n<th>Priority</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>FR01</td>\n<td>The system shall implement a process management tool (workflow) for managing releases of Hue software. This means approval / execution of all steps connected to the release process (signing, uploading, and distribution). The process should be clear about who is liable for specific step.</td>\n<td>FR01</td>\n<td>MUST</td>\n</tr>\n<tr>\n<td>FR02</td>\n<td>The system shall provide an interface to specify and customize the workflow. This means that authenticated and authorized users can define the workflow and who is liable for each step in it.</td>\n<td>FR01</td>\n<td>SHOULD</td>\n</tr>\n<tr>\n<td>FR03</td>\n<td>The system shall implement an authentication and authorization mechanisms for accessing</td>\n<td>FR01</td>\n<td>MUST</td>\n</tr>\n</tbody>\n</table>\n\n---\n\n5 https://en.wikipedia.org/wiki/Linux \n6 https://en.wikipedia.org/wiki/MIT_License \n7 https://en.wikipedia.org/wiki/BSD_licenses\nand for execution of specific step in the release process (user roles).\n\n| FR04 | The system shall implement an information overview regarding the status of each release process (what is the current state in the process) | FR01 | MUST |\n| FR05 | The system shall provide traceability about each step executed in the process. For instance, who approved the Hue software for signing, who uploaded to the Hue portal, and/or who distributed to the mobile application team. | FR01 | MUST |\n| FR06 | The system shall implement an interface that allows uploading the development software artifacts to it. | FR01 | MUST |\n| FR07 | The system shall provide a historical overview of all signed production releases of the Hue software (archive). This includes: version number, type of device, release date, workflow overview (who did specific step of the release process), links to the software artifacts (files, configurations) and the I&V report. | FR01 | SHOULD |\n| FR08 | The system shall implement an automated process for signing of Hue software production releases. | FR01 | MUST |\n| FR09 | The system shall implement an automated process for software upload to the production Hue portal. | FR01 | SHOULD |\n| FR10 | The system shall implement an automated process for software upload to the test Hue portal. | FR01 | SHOULD |\n| FR11 | The system shall implement an automated process of deploying the artifacts on devices, specified by their MAC addresses. | FR01 | SHOULD |\n| FR12 | The system shall implement an automated process of deploying the artifacts on specific region (regional deployment). This means that devices can be specified by their physical location. | FR01 | OPTIONAL |\n| FR13 | The system shall implement an automated process for sending the software artifacts to factories. | FR01 | MUST |\n| FR14 | The system shall implement an automated process for distributing software artifacts to the mobile application team. | FR01 | SHOULD |\n| FR15 | The system shall implement an interface that allows uploading the I&V report to the specific Hue software that is to be signed. | FR01 | SHOULD |\n| FR16 | The script for signing the production Hue software shall be same as the development signing script that is maintained by software developers. | | MUST |\n| FR17 | The system shall provide notifications for specific actions or steps executed in the process. It should be configurable who receives notification regarding specific action. | | SHOULD |\n| FR18 | The system shall provide an information overview of the deployment status. For instance, version X of the bridge software is detected on y% of connected bridges. | | OPTIONAL |\nThe system shall be able to stop a deployment. For instance, if the software is deployed in a wrong region, for wrong customers, or on wrong devices.\n\nThe system shall be integrated with the product database application. Integration will mean that each software has a link to the appropriate product database record and it is constantly maintained.\n\nThe system shall implement an interface for adding new signing production keys, by authorized and authenticated users.\n\nThe system shall implement an interface for revoking existing signing production keys.\n\nThe system shall maintain an audit trail (log) for each activity performed.\n\nThe system shall implement an automatic test process. This means that the system automatically checks that signed production software can be installed on a Hue bridge and a Hue bridge can be updated with the newest software release.\n\nThe system shall implement automatic notification actions for external systems for information purposes. For instance, interface to the Datadoc API that provides release information in Dashboards.\n\n| FR19 | The system shall be able to stop a deployment. For instance, if the software is deployed in a wrong region, for wrong customers, or on wrong devices. | OPTIONAL |\n| FR20 | The system shall be integrated with the product database application. Integration will mean that each software has a link to the appropriate product database record and it is constantly maintained. | OPTIONAL |\n| FR21 | The system shall implement an interface for adding new signing production keys, by authorized and authenticated users. | MUST |\n| FR22 | The system shall implement an interface for revoking existing signing production keys. | MUST |\n| FR23 | The system shall maintain an audit trail (log) for each activity performed. | MUST |\n| FR24 | The system shall implement an automatic test process. This means that the system automatically checks that signed production software can be installed on a Hue bridge and a Hue bridge can be updated with the newest software release. | SHOULD |\n| FR25 | The system shall implement automatic notification actions for external systems for information purposes. For instance, interface to the Datadoc API that provides release information in Dashboards. | OPTIONAL |\n\nTable 6.3 Functional requirements\n\n6.4 Non-functional requirements\n\nBesides the functional requirements, several non-functional requirements are identified from the requirements gathering process.\n\n6.4.1 Security requirements\n\nThe system shall have access to the production keys used for signing the production Hue software. These keys are sensitive and the system need to provide highest possible security measures to prevent unauthorized access to them.\n\n6.4.2 Software quality attributes\n\nSeveral software quality attributes are identified that the system should satisfy.\n\nUsability\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 and intuitive.\n\nMaintainability\n\nThe system should be easily maintainable, meaning that the system can undergo changes with a degree of ease.\n\nExtensibility\n\nThe system should be extendable. This means that it should be easy to add or modify features, for instance, adding new types of Hue software.\nReliability / Dependability\n\nThe system should be reliable. The speed of execution is not critical, but the correctness of the processes is crucial. It is preferred that processes run sequentially. Concurrency is not preferred since every action need to be atomic and therefore the system should know its state in every moment of time.\n\nMinimum system that satisfies the requirements is defined as the system that implements all functional requirements marked with MUST and supports all non-functional requirements.\n7. System Architecture\n\nThe previous chapter (Chapter 6) describes the functional and non-functional requirements of the system. This chapter explains the architectural reasoning and design decisions that are made and which resulted in a design of the system, based on the identified requirements. The purpose of designing an architecture for a system is solving a problem statement formalized with system requirements.\n\n7.1 Architectural reasoning\n\nThe architecture of a system is a set of early key decisions that gives direction to the design, implementation and evolution of the system in its environment. The purpose of having a system architecture is to have one appropriate consistent system with balanced design decisions in line with the requirements of the stakeholders.\n\nIn agile processes, it is generally accepted that an early stage of the development process should be concerned with establishing an overall system architecture. Incremental development of architectures is not usually successful. While refactoring components in response to changes is usually relatively easy, refactoring a system architecture is likely to be expensive. [13]\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 provides 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. [14]\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. For 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.2) is for it to be a web application available to end users, such as security officers, test architects and software developers. Typically, web applications follow an n-tiered architecture pattern, where n is the number of tiers. The simplest form of the n-tiered architecture is the 2-tiered web architecture or the client-server architectural style. Typically, when users browse the Internet, they use Web Browser software such as Internet Explorer, Google Chrome or Mozilla Firefox. The computer where the browser runs is called a client, whilst the machine which provides a Web page is called a server. [15]\n\nWhen specific page is requested from the Web Browser, the user’s computer forms a network connection to a Web server. In this situation, the computer is in effect a client, which is linked to a Web server. The web server, as the name suggests, serves the requesting browser with Web pages, such as HTML, ASPX, JSP and PHP pages. This simple scenario, where the Web server is connected to one or more clients, is known as a 2-tier architecture model. Figure 7.1 demonstrates how Web pages are accessed via a browser, using this 2-tier architecture.\n\nIn the following text, terms tier and layer are used interchangeably.\nGenerally computing applications consist of three different and distinct types of functionalities, namely presentation, logic, and data management. The difference with the client-server architecture is the addition of a specific layer that handles all business logic and computing. Every application includes some data processing and this may also involve database interactivity. For example, the user authentication module requires the logic unit to read user-role combinations from a database and check if the current user has permission to access a specific page. Starting from a client-server architecture, this addition of a new tier moves 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\nSince the nature of the project is that the system performs many actions in an automated way, naturally there is a need for a specific layer that handles all business logic, such as automation of software signing, approval of workflow steps and/or access rights management. Although it is not an explicit requirement for this project, there is a possibility to integrate this system with one existing system/service from Royal Philips. This system is used for release management of the software components that are not part of the Hue system software stack. This integration could possibly mean that this system will need to have access to the specific data from the database. Having a separate layer that only handles database related topics, will make this integration easier.\n\nIf we reflect on the non-functional requirements in Section 6.4, the 3-tier architecture suggests a good fit, because one of the non-functional requirements was maintainability. Moreover, it adds qualities not envisioned initially, such as testability. Because components belong to specific layers in the architecture, other layers can be mocked or stubbed, making this pattern is relatively easy to test. A developer can mock a presentation component or screen to isolate testing within a business component, as well as mock the business layer to test certain screen functionality. This is complemented with the functional requirements where unique features are identified, each with its own distinctive purpose. Since security is one of the most important non-functional requirements, another vertical layer that is spread over all three tiers is introduced, namely the security slice. The purpose of the security layer is to provide guidelines for the architectural decisions in order to provide high security standards in all tiers from the 3-tier architecture. Figure 7.2 depicts the proposed architecture of the system.\n\nOne of the core principles behind the client-server model (the predecessor of the 3-tier model) is separation of concerns. Each layer of the architecture has a specific role and responsibility within the application. For example, a presentation layer would be responsible for handling all user interface and browser communication logic, whereas a business layer would be responsible for executing business rules associated with the request. Each layer forms an abstraction around the work that needs to be done to satisfy a business request. For example, the presentation layer does not need to know or worry about how to get customer data; it only needs to display that information on a screen in a particular format. Similarly, the business layer only needs to get the data from the persistence layer, perform business logic against the data, and pass that information up to the presentation layer. This separation of concerns allows any tier to be changed, replaced, or tested without affecting the rest of the system if the communication interface remains the same. [16]\nThe deployment of a typical 3-tier web architecture consists of a presentation tier (front-end web server that hosts the web application), business logic tier (application server that hosts the business logic of the system), and data tier (database server that hosts the data itself).\n\n\n\n**Figure 7.2 3-tier architecture deployment on separate physical servers**\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 layer\n\nThe data layer 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. The 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, here a specific workflow details are stored, such as, status of the workflow, step execution details, responsible persons and user role management. [17]\n\n### 7.3 Business logic layer\n\nThe logic layer 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. [18]\n\nSince the system under development is in very initial stages, many modifications are expected in the future. Moreover, possible integration is expected with one existing system from Royal Philips, as we mentioned earlier in this chapter. With this in mind,\na 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 architecture choice into a component-based style. 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. [19]\n\nHaving a separate and independent logic-tier, means that there should be appropriate communication protocol established with the front-end part of the application (the presentation tier), as well as with other parts of the system. Typically, in web systems there are two ways of offering functionalities to another system, namely:\n\n1. Through web services\n2. Through shared libraries\n\nOn the one hand, a service-oriented approach will allow numerous services to be hosted and maintained separately. This will make probable future integration with different systems easier to implement. On the other hand, a complete shared library can serve as an interface between the presentation and the logic-tier. This way, we can be sure that code is executed sequentially and locally inside the main program. With this approach, the performances of the application will be increased since the code runs together with the native application code. Applying this approach will mean that the library will be deployed on the same machine together with the web application. Moreover, an API library is very useful when we want to interact with things with as little overhead as possible. The consequence is that there is a higher coupling between the API and the applications using it.\n\nSince this system is completely developed from scratch, and the services it provides will be only accessible from the web application (presentation layer), a shared library is a good fit. Also, this is preferable because this way we can minimize the need for applying different security measures for the presentation and business layer. Since both presentation and the business logic tiers will be deployed on same machine, the tasks for maintenance and configuration of deploying machines will be simplified. Because of this reasoning, a shared library is chosen as a communication channel between the presentation and business logic tiers. Still, the design of the business logic tier should be such that it is easily maintainable if changes are required in future. We explain in more detail how this is achieved in the next chapter 8 - System Design.\n\nIf we reflect again on the non-functional requirements listed in Section 6.3, we can remember that security is the main consideration of this system. The most critical data that will be operated by this system are the production software signing keys and the software files. There will be only a few people who will be authorized to access and operate with the production signing keys. However, since the automation of activities is one of the core ideas of this system, it means that these critical keys will be accessible from the server that runs the business layer. This situation introduces additional risk, because all users who can have access to the business layer (for instance, developers and system administrators), can potentially access the signing keys. This leads to the decision that the business layer should be split into different security zones, that can be potentially deployed in different physical servers with different security measures applied. First server will run the main web application and will interact with the presentation layer. Moreover, this layer will communicate with the database layer and operate with all workflow related data. The data that is stored in the database is mainly metadata for the release process, such as software version, friendly name, start and modification dates and status. These entries do not contain highly critical data. The second server will store the software signing keys and will run the signing applications. Since this is security critical task, this server will be securely isolated from the rest part of\nthe application. The second server will not be accessible from the presentation layer. Specific actions on this machine can only be initiated through pre-defined messages coming from the first server only. Based on the specific purposes they serve, these servers (and therefore applications they run) are named Release workflow and Software signer system respectively.\n\nThe split of the business logic layer into two different servers, implies that appropriate communication mechanism need to be in place in order to connect both servers in the business layer. In 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 have any knowledge 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 first server will request functionalities offered by the services or APIs (second server), which in turn will process the request and return appropriate response, 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.3 presents the architecture of the logic tier.\n\n7.3.1. Representational State Transfer (REST)\n\nRepresentational state transfer (REST) or RESTful web services is a way of providing interoperability between computer systems on the Internet. REST-compliant Web services allow requesting systems to access and manipulate textual representations of Web resources using a uniform and predefined set of operations. Other forms of Web service exist, which expose their own arbitrary sets of operations such as WSDL and SOAP.\n\n\"Web resources” were first defined on the World Wide Web as documents or files identified by their URLs, but today they have a much more generic and abstract definition encompassing every thing or entity that can be identified, named, addressed or handled, in any way whatsoever, on the Web. In a RESTful Web service, requests made to a resource's URI will elicit a response that may be in XML, HTML, JSON or some other defined format. The response may confirm that some alteration has been\nmade to the stored resource, and it may provide hypertext links to other related resources or collections of resources. Using HTTP, as is most common, the kind of operations available include those predefined by the HTTP verbs GET, POST, PUT, DELETE and so on.\n\nBy making use of a stateless protocol and standard operations, REST systems aim for fast performance, reliability, and the ability to grow, by re-using components that can be managed and updated without affecting the system, even while it is running.\n\nThe architectural properties affected by the constraints of the REST architectural style are:\n\n- **Performance** — component interactions can be the dominant factor in network efficiency;\n- **Scalability** to support large numbers of components and interactions among components;\n- **Simplicity** of a uniform interface;\n- **Modifiability** of components to meet changing needs; and\n- **Portability** of components.\n\nThere are six guiding constraints that define a RESTful system. These constraints restrict the ways that the server may process and respond to client requests so that, by operating within these constraints, the service gains desirable non-functional properties, such as performance, scalability, simplicity, modifiability, visibility, portability, and reliability. If a service violates any of the required constraints, it cannot be considered RESTful.\n\nThe formal REST constraints are as follows:\n\n- **Client-server** — Separation of concerns is the principle behind the client-server constraints. By separating the user interface concerns from the data storage concerns, we improve the portability of the user interface across multiple platforms and improve scalability by simplifying the server components. Perhaps most significant to the Web, however, is that the separation allows the components to evolve independently, thus supporting the Internet-scale requirement of multiple organizational domains.\n\n- **Stateless** — The client–server communication is constrained by no client context being stored on the server between requests. Each request from any client contains all the information necessary to service the request, and session state is held in the client. The session state can be transferred by the server to another service such as a database to maintain a persistent state for a period and allow authentication. The client begins sending requests when it is ready to make the transition to a new state. While one or more requests are outstanding, the client is considered to be in transition. The representation of each application state contains links that may be used the next time the client chooses to initiate a new state-transition.\n\n- **Cache** — As on the World Wide Web, clients and intermediaries can cache responses. Responses must therefore, implicitly or explicitly, define themselves as cacheable or not to prevent clients from reusing stale or inappropriate data in response to further requests. Well-managed caching partially or completely eliminates some client–server interactions, further improving scalability and performance.\n\n- **Layered system** — A client cannot ordinarily tell whether it is connected directly to the end server, or to an intermediary along the way. Intermediary servers may improve system scalability by enabling load balancing and by providing shared caches. They may also enforce security policies.\n\n- **Code on demand** — 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• **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\nWeb service APIs that adhere to the REST architectural constraints are called RESTful APIs. HTTP-based RESTful APIs are defined with the following aspects:\n\n- Base URL, such as `http://api.example.com/resources/`;\n- An internet media type that defines state transition data elements (e.g. XML, and images);\n- Standard HTTP methods (e.g., OPTIONS, GET, PUT, POST, and DELETE)\n\n7.3.2. Hypertext Transfer Protocol\n\nThe Hypertext Transfer Protocol (HTTP) is an application protocol for distributed, collaborative, and hypermedia information systems. HTTP is the foundation of data communication for the World Wide Web. Hypertext is structured text that uses logical links (hyperlinks) between nodes containing text. HTTP is the protocol to exchange or transfer hypertext.\n\nHTTP functions as a request–response protocol in the client–server computing model. A web browser, for example, may be the client and an application running on a computer hosting a website may be the server. The client submits an HTTP request message to the server. The server, which provides resources such as HTML files and other content, or performs other functions on behalf of the client, returns a response message to the client. The response contains completion status information about the request and may also contain requested content in its message body.\n\nA web browser is an example of a user agent (UA). Other types of user agent include the indexing software used by search providers (web crawlers), voice browsers, mobile apps, and other software that accesses, consumes, or displays web content.\n\nHTTP is designed to permit intermediate network elements to improve or enable communications between clients and servers. High-traffic websites often benefit from web cache servers that deliver content on behalf of upstream servers to improve response time. Web browsers cache previously accessed web resources and reuse them when possible to reduce network traffic. HTTP proxy servers at private network boundaries can facilitate communication for clients without a globally routable address, by relaying messages with external servers.\n\nHTTP is an application layer protocol designed within the framework of the Internet protocol suite. Its definition presumes an underlying and reliable transport layer protocol, and Transmission Control Protocol (TCP) is commonly used. However, HTTP can be adapted to use unreliable protocols such as the User Datagram Protocol (UDP), for example in HTTPU and Simple Service Discovery Protocol (SSDP).\n\nHTTP resources are identified and located on the network by Uniform Resource Locators (URLs), using the Uniform Resource Identifiers (URI's) schemes http and https. URIs and hyperlinks in HTML documents form inter-linked hypertext documents.\n\nHTTP/1.1 is a revision of the original HTTP (HTTP/1.0). In HTTP/1.0 a separate connection to the same server is made for every resource request. HTTP/1.1 can reuse a connection multiple times to download resources, after the page has been delivered. HTTP/1.1 communications therefore experience less latency as the establishment of TCP connections presents considerable overhead. [21]\n7.3.3. Business-logic layer architecture\n\nThe system design is a combination of two architectural styles, namely the component-based style and the REST style. The component-based design allows features to be independent, while REST allows distribution to security risky services to different, isolated servers. In the system-under-design this is the Software signer system, mentioned early.\n\nFigure 7.3 shows the business-logic layer architecture. The functionalities of the “Release workflow system” are exposed through shared library, which uses the components of the system to process the requests. The functionalities of the “Software signer system” are exposed through REST services, which in same way uses the components of the system to process the requests.\n\nFigure 7.3 Logic tier architecture\n\nThe goal of this modular design is to separate the concerns of each component. The “Release workflow system” components handle the specific processing they are intended to perform. The WorkflowStepManagement component is responsible for execution of specific step in the release workflow. This step can be from different type such as approval, software signing or software upload to the cloud. More details for the design of this component are given in the Chapter 8 - System Design. UserRolemanagement component is responsible for managing users, roles and role permissions for specific parts of the system. The role of the ReleaseCreation component is to allow creation and manipulation with release and release candidates entries in the system. The role of the ReleaseCreation component is to allow creation and manipulation with release and release candidates entries in the system. The DeviceTypeManagement component is responsible for configuration of the system specific settings and operations, such as workflow definition per different device types. Moreover, this component is used to create a new device type in the system. The role of the EmailManagement component offers services related to E-mail receivers data, such as modifying, adding or deleting factory E-mail recipients. Finally, the role of the ReleaseCandidate component is to provide relevant information about particular workflow, such as: status, device type, software version, build number, last modification date and number of steps.\n\nAs one can observe from the diagram, all the components use the Data Access Object (DAO) component. The DAO 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.\nThe role of the SoftwareSigner component of the “Software signer” system offers service related to software file signing processes. These services include initiation of software signing process, retrieving signed files and distributing the signed artifacts to different systems. KeyManagement component is responsible for the features related to generation and replacement of new production signing keys. Please note that this feature / interface is not directly exposed on the front-end application, from security reasons. There will be simple command line interface only exposed from the Signing sub-system that will allow replacement of the production signing keys. Generation of the keys will be one-directional always. No one should be able to read / retrieve the signing keys.\n\nThe signing “SoftwareSigner” system does not depend on “Release workflow system”, meaning this RESTful API can be reused in different applications with different technologies.\n\nChapter 8 dives into more detail for the API and the components.\n\n7.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. If we reflect on the functional requirements for this project, the envisioned interface is a web-based application.\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. [17]\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 and scalability must be taken into consideration. Additionally, the coupling between the presentation layer and the business-logic layer should be as minimum as possible, so that it will support any changes or replacement of the layers in future if required. [17]\n\nOver the years, user interface development has gone through many changes. One of the biggest change that happened in the recent years, is the use of MVC pattern for developing a web based user interfaces. The Model–View–Controller shortly known as MVC is a software architectural design for implementing web based user interfaces. The MVC pattern is a three-tier architecture that is independent of the programming language used for the system development. In the next Section 7.4.1 we present the core principles of the MCV pattern and the reasoning why it is chosen for the development of the presentation layer in this system.\n\n7.4.1. Model View Controller (MVC)\n\nModel–view–controller (MVC) is a software architectural pattern for implementing user interfaces on computers. It divides a given application into three interconnected parts in order to separate internal representations of information from the ways that information is presented to and accepted from the user. The MVC design pattern decouples these major components allowing for efficient code reuse and parallel development.\nTraditionally used for desktop graphical user interfaces (GUIs), this architecture has become popular for designing web applications and even mobile, desktop and other clients. Modern programming languages like Java, C#, Ruby, PHP and others have popular MVC frameworks that are currently being used in web application development straight out of the box.\n\nThe core components of the MVC pattern are:\n- *Model* means data, which is required to display in the view. It can sometimes be the exact data entities that are retrieved from the business layer or a variation of it. Model encapsulates business tier.\n- A *view* can be any output representation of information, such as a chart or a diagram. Multiple views of the same information are possible, such as a bar chart for management and a tabular view for accountants. In MVC pattern view should be simple and free of business logic implementation. View invokes methods on Controller depending on user actions. In MVC pattern View monitors the model for any state change and displays updated model. Model and View interact with each other using the Observer pattern.\n- The third part, the *controller*, accepts input and converts it to commands for the model or view. Controller is invoked by view, it interacts with the model and performs actions that updates the model.\n\nThe main advantages of applying the MVC pattern are:\n- Simultaneous development — Multiple developers can work simultaneously on the model, controller and views.\n- High cohesion — MVC enables logical grouping of related actions on a controller together. The views for a specific model are also grouped together.\n- Low coupling — The very nature of the MVC framework is such that there is low coupling among models, views or controllers\n- Ease of modification — Because of the separation of responsibilities, future development or modification is easier\n- Multiple views for a model — Models can have multiple views [22]\n\nThe following Figure 7.4 depicts the structure of MVC pattern.\n\n\n\n**Figure 7.4 MVC design pattern**\n\n### 7.4.2. Architecture choice for presentation tier\n\nThe reasoning behind the architecture is based on the user interface point of view. As we mentioned in the previous chapters, the system should replace the existing processes for software signing and deployment. Therefore, the usability of the application is a crucial factor for future usage. Usability by itself is defined with several other non-\nfunctional 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. Another core reason is that many changes are expected in this system in the future, in both presentation and business-logic layer. By knowing this, we would like to have as low coupling as possible between these two layers.\n\nBased on the facts above, the MVC architecture is chosen for the presentation layer. The main reason is the low coupling between the Controller, the View and the Model concepts. With this decoupling, it should be relatively easy to replace the complete presentation layer and integrate the system with another user interface if it is required in the future. This is in line with one of the potential future integration with one existing system from Royal Philips.\n\nFigure 7.5 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 five different components that cover the desired functionalities of the system under design and several other components for various purposes, such as visualization libraries to support the visualization or JavaScript and AJAX libraries to implement asynchronous communication. Each of these five components interacts with the interfaces provided from the business-logic layer, more precisely the provided interfaces from the “Release workflow system,” explained in the Section 7.3.3.\n\nThe five application-specific components follow the MVC pattern, with each module having a separate view, model, and controller.\n\n### 7.5 Trade-offs between non-functional requirements\n\nPrevious Sections in this chapter explain the reasoning and set up the basic system architecture. Here, we would like to emphasize the trade-offs that were made between the non-functional requirements (NFR) of the system, listed in the Section 6.4. The most sensitive part of the system architecture is the security. Therefore, several trade-offs were made that increases the satisfaction level for this NFR, but on the other hand decrease the satisfaction level for the other NFR. Here, we list two most interesting examples.\n\n---\n\n**Figure 7.5 Presentation tier architecture**\n\nThe five application-specific components follow the MVC pattern, with each module having a separate view, model, and controller.\n1. **Security vs Usability:** According to the NFR, Security is the most important aspect of the system. Because of it, several security measures are implemented. One of them is the encryption of the signing keys and therefore having the need for the user to type in the decryption password every time there is a need for production software signing. This, however, limits the usability of the system by introducing another obligatory step in the code signing process. Usability, on the other hand, is another important NFR.\n\n2. **Security vs Maintainability:** Another important NFR is the maintainability. The system should be easily maintainable and can undergo changes with a degree of ease. However, because of security reasons, we have decided to split the business logic layer and add additional layer that handles code signing processes. This decision is explained in detail in Section 7.3. This split adds more complexity to the system from maintenance point of view, because two different applications and two different servers need to be maintained.\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 specific details.\n8. System Design\n\nThe previous chapter, “System architecture,” shows the high-level view on the system and its major components. The business-logic and presentation layers have different responsibilities and therefore distinctive designs are created. This chapter describes the two designs and the transition from high-level architecture to component design.\n\n8.1 Introduction\n\nIn the previous chapters, we have identified stakeholders, set principles and guidelines, found the architectural constraints and in general the functional and non-functional requirements of the system. However, before we move into the next designing phase, it is worthwhile to analyze which models we want to create and what kind of view we want to use to communicate them.\n\nIEEE 1471 defines an architectural view as a representation of an entire system from the perspective of a set of concerns, where the concerns are the key interests of the different stakeholders. A view is consisted of parts of one or more models to demonstrate how the concerns are covered. A view is an instantiation of the pattern defined in a viewpoint. [23]\n\nFor example, if we are concerned about concurrency and timing issues we are interested in threads and process models. Therefore, we can use views such as process diagrams and timing diagrams.\n\nIEEE 1471 suggests that a viewpoint would hold the following information:\n\n- Viewpoint name\n- The stakeholders addressed by the viewpoint\n- The stakeholder concerns to be addressed by the viewpoint\n- The viewpoint language, modeling techniques, or analytical methods used\n- The source, if any, of the viewpoint (e.g., author, literature citation)\n\nA viewpoint may also include:\n\n- Any consistency check associated with the underlying method to be applied to models within the view\n- Any evaluation or analysis techniques to be applied to models within the view\n- Any heuristics, patterns, or other guidelines that aid in the synthesis of an associated view or its models\n\n\nFor the system under development, the following viewpoints are identified:\n\n- **Logical view**: The reasoning is that the system under development is developed by applying the object-oriented paradigm. Therefore, this view elaborates on the object model and the behavior of the design and gives direction for the further implementation phase.\n\n- **Process view**: Although performance, scalability and throughput are not critical non-functional requirements of the system, it is important to understand how specific actions are performed in the system and how objects communicate between them. Therefore, activity or communication diagrams can be useful for modeling these interactions. Moreover, this view gives information\nabout which components are used / active during a specific process, like software signing. Additionally, the purpose of this view is to give information about which processes can run in parallel and / or sequentially.\n\n- **Development view**: This view focuses on the static organization of the software in its development environment.\n- **Deployment view**: With this view, we show how the software components are mapped into hardware devices.\n\nNext sections elaborate the views defined in this introduction.\n\n### 8.2 Reference use case\n\nChapter 6 - “System Requirements” discusses the key features and use cases of the product. In that chapter, several main use cases and a few auxiliary ones are described. The use cases represent the user stories in the system, or what the system is supposed to do in the interaction with the user.\n\nAs mentioned earlier, several scenarios are identified, such as signing a software image and sending signed software to factory. These scenarios involve participation of the end user. Furthermore, similarities between them exist. For example, most of the scenarios involve selecting a workflow and workflow step. Next, an action is triggered from the user to process a specific step. The request is processed, data is generated and returned to the end user in the form of visual information or feedback. With this, we can identify common steps for all these scenarios. The notation used to describe the common use case is:\n\n- User – represents the end user, such as test architect or security officer\n- Web application in browser – represents the presentation tier\n- Release workflow system – represents the first level of the business-logic layer\n- Software signer system - represents the second level of the business-logic layer\n\nThe steps are as follows:\n\n1. The user requests to execute a feature;\n2. The web application checks if the user has permission to execute requested feature;\n a. If user has permission, the web application shows the interface;\n b. If user does not have permission, interface is not shown and scenario finishes;\n3. The user enters the required information and initiates action;\n4. The web application verifies the information\n a. If the entered information is incorrect, the user is notified. No action is taken;\n b. If the entered information is correct, the scenario continues;\n5. The web application sends a request to the “Release workflow system” to perform the requested action;\n6. The “Release workflow system” accepts and processes the request;\n a. If the step requires communication with the Software signer system, an appropriate request is sent to the “Software signer system” and the returned response is processed.\n7. The “Release workflow system” generates the requested information and sends it back to the web application;\n8. The web application receives the information and displays it to the user.\n\n### 8.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\nbe replaced or modified. If we refer to the architecture decisions in Section 7.3, we can remember that we have decided to split the logic tier into two distinct parts that will be deployed on different servers, namely the Release management workflow and the software signer applications.\n\nThe architecture of the system includes a combination of two architectural styles, namely REST and component-based. The REST style is used to design the software signer application part and the component-based style to design the business or application logic of the release management workflow application. The following sub-sections describes the logical design with more details.\n\n8.3.1. Release workflow system\nThe architecture of the release management application consists of several components. To be more understandable and simple, the designs shown in the following figures concern one chosen component, namely WorkflowStepManagement. This component is responsible for processing a specific step from the release workflow. If the name Workflow step is replaced with the name of the other components, such as UserRoleManagement, ReleaseCreation, or DeviceTypeManagement, the design of the other components can be obtained. Figure 8.1 depicts the architecture of the release management workflow application, starting from the web application controllers at the top and moving towards concrete implementations of the components at the bottom.\nclass ReleaseProcessWorkflow\n\nApplication\n«abstract»\nController\n\nWorkflowStepController\ntags\nRequestMapping = /workflow-steps\n\nWorkflowStepServiceImpl\n\n<<instantiate>>\n<<instantiate>>\n\nFigure 8.1 Logic tier architecture\nThe presentation layer is a web based application that consists of several controllers that handle requests coming from the web browsers. Each controller is responsible for handling requests for a specific component. For instance, the WorkflowStep controller is responsible for workflow step related requests, such as executing the step and getting step data from the database.\n\nEach controller is identified by a segment of the URI it can handle. These URIs are uniquely identifiable access points or endpoints for each service offered by the web application. In Figure 8.1, this is shown through the Request Mapping section of the concrete controller WorkflowStepController and its RequestMapping value of “/workflow-steps.” Every request with a URI that has a segment equal to “/workflow-steps” is handled by the WorkflowStepController. Furthermore, each controller exposes concrete endpoints that clients can use to request their service.\n\n8.3.2. Software signer system\n\nThe design of the Software signer application uses a similar approach to the design of the release workflow application. The core difference is the main point of interaction. On the first one is the REST endpoints, while on the latter is a web browser. Since the functionality that this application does is limited, the design is simpler than the one of the release management application. Here, we have identified only one component, namely the SoftwareSigner component.\n\nThe REST-based API consists of only one controller, the SigningController. This controller is identified by a segment of the URI it can handle. Every request with a URI that has a segment equal to “/api” is handled by the SigningController.\n\nSince we are following the same approach as the previous application, this controller also requires exactly one service interface. This level of abstraction 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).\n\n8.3.3. Presentation layer\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.\n\nFigure 8.2 shows the design of the presentation tier and its connection with the logic tier. Again, the design shown, namely for the Workflow step, represents 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 UserRoleManagement, ReleaseCreation, or DeviceTypeManagement. 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 workflow step related information, such as, type of step and status. The design of the controller, in this case the Workflow step controller, is already shown in Figure 8.1.\n8.4 Process view\n\nThe process view is concerned with aspects regarding non-functional requirements, such as performance and availability. It mainly focuses on the run-time behavior of the system. Typically, the process view is explained using activity diagrams. As we already mentioned, the performance, scalability and throughput are not critical non-functional requirements of the system. Still, it is important to understand how specific actions are performed in the system and how objects communicate between them.\n\nFigure 8.3 depicts the process view of the system, showing a request-response sequence, initiated from a User that wants to execute specific action in the system. Since the software signing process activates both systems of the business-logic layer (Release workflow and software signer), we assume that the User initiated a software signing process. In this scenario, all layers from the architecture are involved in the communication. There are simpler scenarios where the Software signer system is not involved in the communication. For instance, execution of an approval step from the workflow process.\n8.5 **Development view**\n\nThe development view focuses on the actual module organization within the software. This organization is expressed through packages or libraries organized in a way that they provide interfaces between them.\n\nFigure 8.4 depicts the development view of the Release workflow system. The organization of the view is layered, so that each layer communicates with the layers next to it. The Business layer is on the top of the diagram composed of three sub-packages: for the interfaces, implementation and the workflow specific classes. The `interface` package defines interfaces that are the contract between the business-logic layer and the presentation layer. Their concrete implementation is contained within the `implementation` package. Finally, the `workflow` package contains the core implementation of the workflow execution functionalities.\nThe layer below the Business Logic Layer package is represented by the Data Access Layer package. As the name suggests, this package includes the data access related interfaces and their implementation. The package is composed of four packages. First, the model package, contains the classes that represent the domain specific concepts such as ReleaseCandidate, Step and DeviceType. These concepts are further used in the second package, called dao which contains components whose main goal is to map the database raw entries into these concepts. Next, the impl contains the core implementation of the database related operations, such as retrieve and update data. The behavior of these components is defined as interfaces in the fourth package called interfaces. This organization allows concrete implementations or even complete packages to be replaced, which makes it easily maintainable.\n\nThe development view of the presentation layer is much simpler than the one of the logic layer. Figure 8.5 depicts this view. The tier is split into four distinct packages:\nresources, which contains the user interface specifics such as views, HTML files, and JavaScript libraries; controllers, which contains user interaction handling; admin, which contains user interaction handling in the admin pages of the web application; and webapp, which contains configuration and settings components, such as the global exception handling controller.\n\nFigure 8.5 Development view of the presentation layer\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. The Deployment view focuses on aspects of the system that are important after the system has been tested and is ready to go into live operation. This view defines the physical environment in which the system is intended to run, including the hardware environment that the system needs (e.g., processing nodes and network interconnections), the technical environment requirements for each node (or node type) in the system, and the mapping of the software elements to the run-time environment that executes them. [29]\n\nFigure 8.6 depicts the designed deployment view of the system. The client, which is the web application executed on the end user’s personal computer, makes requests via HTTP(s) to the Release workflow system, which runs on a remote server accessible via the internal Philips Lighting network. This web application communicates with the database server, which hosts the database that contains all data, and with the Software signer server which runs on another remote server accessible also via the Philips Lighting internal network. In order to elaborate the specifics for the deployment view with more details, the deployment view is revisited in Chapter 11.\nFigure 8.6 Deployment view of the entire system. A more comprehensive view is offered in the Deployment chapter.\n9. Implementation\n\nThe previous two chapters discussed the system architecture and design. This chapter explains the realization of the design, specifically the technologies chosen for its 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 a demonstration of the feasibility of the project. For implementing the design, choices are made on which technologies to use. Since the product is comprised of several layers, several choices are made, one for each layer, in the architecture.\n\nAs we mentioned in Section 6.2.3, Design and implementation constraints, there were several technical and operational restrictions that influenced the decisions made in each layer of the architecture. First, the Linux-based operating system is preferred option for the application server that hosts the Software signer system, since most of the software signing software applications are specifically developed for Linux operating system. Next, open-source licensees were preferred for complete development, specifically the MIT and BSD.\n\n9.2 Presentation and business-logic layer: Release workflow application\n\nThe type of user interface for this system was decided when the requirements were gathered for this project. The stakeholders explicitly requested a Web application. This meant that one decision had already been made. Additionally, in the System Architecture we decided to bind the web application with the business-logic layer using a shared library. The next choices were the operating system, the framework, and programming language that was used for the development of these two layers.\n\nAs we briefly mentioned in the previous section, a Linux operating system was required for running the Software signer system. Because of this, we decided to use the same operating system for hosting the web application too. The main reasoning was to have unified operating systems for all layers. This way we could apply the same configuration and the same security measures are in place. Also, from the maintenance point of view, having same type of Operating System is a preferred option.\n\nWith the evolution of modern software development, many recent technologies and frameworks for both web and business-logic layer development have emerged that support both the architecture and the implementation constraints listed in Section 6.2.3. One requirement that needs to be supported by the technology chosen is the ability to connect to a database and manipulate data. Almost all modern programming languages support the architecture of the back-end part of the application. Based on the candidate’s preference, Java was selected as a language for the development of the release workflow application.\n\nThere are many frameworks in Java that supports web development. Therefore, choosing the right one is not an easy task. The main aspects that were considered are that this framework needs to support the MVC architecture pattern proposed in the System Architecture chapter. Also, the selection of the framework was based on the popularity,\n\n9 https://en.wikipedia.org/wiki/Linux\n10 https://en.wikipedia.org/wiki/MIT_License\n11 https://en.wikipedia.org/wiki/BSD_licenses\n12 https://www.java.com\nonline support, and again the personal preference of the candidate. For these reasons, Spring Web MVC\\textsuperscript{13} framework was selected as a framework for the development of the web application. The Spring Web MVC framework provides Model-View-Controller (MVC) architecture and ready components that can be used to develop flexible and loosely coupled web applications. Therefore, if we compare with our reasoning in the System Architecture chapter, we can conclude that the Spring MVC framework is a good fit for this architecture. [30]\n\nSpring MVC supports many types of views for different presentation technologies, such as JSP\\textsuperscript{14}, Hyper Text Markup language (HTML)\\textsuperscript{15}, and Thymeleaf\\textsuperscript{16} templates. Again, based on the candidate preference, the Thymeleaf templates were chosen for the design of the user interface. The Thymeleaf completely relies on the standard Web development technologies such as HTML, JavaScript\\textsuperscript{17} and Cascading Style Sheets (CSS)\\textsuperscript{18}. Since usability was one of the non-functional requirements of this project, special attention was put on the user interface design. Users can use devices, such as personal computers, laptops, or tablet, to access it. In order to provide a consistent design, a specific approach is taken, namely responsive web design. One of the most famous and often used frameworks for developing responsive sites is Bootstrap\\textsuperscript{19}. Section 9.5 elaborates the user interface with more details.\n\n9.3 Software signer system\n\nThe Software signer system consists of a REST API and the application logic modules. Again, there are multiple technologies and frameworks that support development of RESTful APIs and can be hosted on a Linux based operating system. Based on the candidate’s preference, once more Java was selected as a language for the development of the Software signer system. The Spring Framework was used for the development, since it fully supports building the RESTful services elaborated in the System design chapter.\n\n9.4 Data layer\n\nThe main aspects when choosing the Database Management System (DBMS) were that it is fully supported in Java, can be hosted in Linux based operating system, and has open-source license. Therefore, the decision was made for the MySQL\\textsuperscript{20} database engine. MySQL is an open-source, free-to-use database management system, and it is widely used, especially in web systems.\n\n\\textsuperscript{13} https://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html\n\\textsuperscript{14} http://www.oracle.com/technetwork/java/javaee/jsp/index.html\n\\textsuperscript{15} http://www.w3schools.com/html/html_intro.asp\n\\textsuperscript{16} http://www.thymeleaf.org/\n\\textsuperscript{17} https://www.w3schools.com/js/\n\\textsuperscript{18} https://www.w3schools.com/css/css_intro.asp\n\\textsuperscript{19} http://getbootstrap.com/\n\\textsuperscript{20} https://www.mysql.com/\n10. Verification and Validation\n\nThe previous chapter described the implementation of the project. To ensure that the system is being correctly created, the process of verification and validation should be put in place. This chapter describes the process together with the techniques used.\n\n10.1 Validation\n\nValidation of a software product is the process of checking whether the product built satisfies the stakeholder’s requirements. Two 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. For the non-functional requirements, the validation should address how they are achieved and satisfied.\n\nFollowing an iterative development approach (see chapter 13), the results were continuously validated by the stakeholders. Once per week, a meeting was scheduled with the main stakeholders 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\nAdditionally, the candidate was in the same department with the main future users of the system. With this setting, the users of the system were always up-to-date with the system implementation, so that they could validate it during the complete development process.\n\nRegarding the non-functional requirements, the security was identified as the most important one. For this reason, a dedicated internal team of security experts was created, which main purpose was to evaluate the system architecture from security perspective and approve it for further implementation. Additionally, the candidate proposed performing a formal penetration test from authorized experts that will validate the security of the developed product. This activity is planned to be executed before the system goes live. At the moment of writing this report this is not performed yet, and therefore this is listed as future work (see Section 12.2).\n\n10.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 - presentation layer and business logic layer, 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 business logic layer the code needs to be tested.\n\nOn the user interface, manual testing was conducted. The user interface was tested with following browsers: Google Chrome 21 (version 60.0.3112.90), Mozilla Firefox 22 (version 54.0.1), and Internet Explorer 23.11. This testing revealed several bugs as well as proposed several improvements. For instance, it was detected that page refresh was not\n\n21 https://www.google.com/chrome/\nvery convenient when user initiated specific action, such as software signing. Because of this, an AJAX\\textsuperscript{24} based interaction between user interface (the web browser) and the back-end part of the system was implemented, which prevented refreshing of the page when user was interacting with it.\n\nThe code in the business-logic layer was mainly tested manually, by running specific scenarios, as well as by performing unit tests on specific functions in the code. The testing environment where the system ran was the consisted of one server running all layers of the system. The Operating System for this server was Linux Ubuntu 16.04 LTS \\textsuperscript{25}. Unit tests were written in the JUnit\\textsuperscript{26} testing framework. JUnit is a unit testing framework for the Java programming language. JUnit has been important in the development of test-driven development, and is one of a family of unit testing frameworks which is collectively known as xUnit. [33]\n\nFinally, manual tests were performed on the system outputs. Since one of the key features of the system is the automated software signing, the output of the signing process was manually tested and verified. This included binary comparisons of the signed software files produced with the developed system and the files that are produced with existing manual process for software signing. This comparison proved that the system only automates the current process, without interfering and modifying it. ■\n\n\\textsuperscript{24} https://www.w3schools.com/xml/ajax_intro.asp\n\\textsuperscript{25} https://www.ubuntu.com/download/desktop\n\\textsuperscript{26} http://junit.org/junit4/\n11. 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 infrastructure, technologies and programming languages.\n\n11.1 Deployment view\n\nBased on the decisions for the system implementation (elaborated in the chapter 9), the development view defined in the Section 8.6 is revisited to take these choices into consideration and provide a clearer picture of the entire system. Figure 11.1 depicts the revisited deployment view of the system.\n\nThe main interface to the system is the web application that is delivered to the users on their PCs web browsers. The “Application server 1” host the web application, called “Release Workflow System”. To run this application an environment that hosts a Java Virtual Machine is required.\n\nThe “Application server 2” hosts the RESTful API and the “Software signer system”. The “Release Workflow System” sends HTTP requests and the “Software signer” server responds with HTTP response. To run the API and the services behind it, an environment that hosts a Java Virtual Machine is required. Moreover, to run the “Software Signer” scripts, a Linux operating system is required, with specific configuration.\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. MySQL is chosen as the database engine.\n\nSection 11.2 explains the deployment options that were analyzed and steer the decision for the chosen option.\nFigure 11.1 Deployment view revisited. Concrete implementation specifics are taken into consideration.\n11.2 Deployment options analysis\n\nBased on the deployment view presented in the previous Section 11.1 we have identified the following deployment options for hosting the complete architecture:\n\n1. Deploying in the internal Lighting Data Center\n2. Deploying in the existing IT environment in the Home Systems department\n3. Deploying in the cloud computing environment. For this, the following options are considered:\n a. Amazon Web Services\\(^{27}\\)\n b. Google Cloud\\(^{28}\\)\n\nThe following sub-sections summarize the advantages and disadvantages of each option and steer the decision for the chosen one. If we reflect on the System requirements described in chapter 6, we can see that Security is one of the most important non-functional requirements of the system. The system shall have access to the production keys used for signing the production Hue software. These keys are sensitive and the system needs to protect them from unauthorized access. Therefore, when we analyze the advantages and disadvantages of each option, we considered the security requirements as the most influencing point.\n\n11.2.1. Deploying in the Lighting Data Center\n\nPhilips Lighting has its own IT infrastructure (so called Lighting Data Center) where many internal applications are hosted and running. Therefore, considering deployment here was a natural option.\n\nLighting Data Center has available servers with Linux Red Hat distribution, which the system-under-development supports. These servers can be easily set up and scaled and adjusted according to the system needs. The Lighting IT department will be responsible for server maintenance and support for all server and hardware related issues. The Home Systems Department will be responsible for all application related issues, as well as the database related operations, such as maintenance, backup, and restore.\n\nSince these servers are owned by the Philips Lighting Data Center (PLDC), the complete physical and logical security is a responsibility of the PLDC.\n\n11.2.2. Deploying in the existing IT environment in the Home Systems department\n\nAnother option is to host the complete system in the existing IT infrastructure inside the Home department, where the main users of the system will be located.\n\nHowever, there are many security risks if this option is considered. First, proper physical security measures must be in place for all PCs where the system components will be installed. Second, custom logical security measures must be implemented for the machines, so that the risk of unauthorized users getting remote ownership is prevented.\n\nAdditionally, complete maintenance of all servers will be responsibility of the Home department. This maintenance will include, but not be limited to: server updates, backups, restore and database maintenance.\n\n11.2.3. Deploying in a cloud environment\n\nCloud computing and storage provide users with capabilities to store and process their data in third-party data centers. This allows organizations to better focus on doing what they are known for, and allow many of the technicalities be taken care of by an infrastructure that already exists and is constantly being upgraded. There are many cloud\n\n\\(^{27}\\) https://aws.amazon.com/\n\\(^{28}\\) https://cloud.google.com/\nservice providers. Because of the sensitivity of the data that could be stored and operated on these servers, only the following well-known providers were considered: Amazon Web Services and Google Cloud Platform. An additional reason is that there are already several services from Philips Lighting that are hosted on both Google Cloud and Amazon Web Services. When analyzing the cloud options, the following criteria must be satisfied:\n\n- The solution should offer the possibility to define Virtual Private Networks so that all resources can be accessed only from the internal Philips Lighting network.\n- The system architecture should not be dependent on the cloud environment. This means that the cloud solution should fully support the system architecture. At minimum, the following services are needed to support and host the system architecture:\n - Application servers for both the ReleaseWorkflowApp and the SoftwareSignerApp\n - File system with high level of security\n - Database server that supports MySQL engine\n\nThe following sub-sections analyzes cloud hosting options in more details.\n\n**Amazon Web Services (AWS)**\n\nThe following services that are suitable for the system architecture are available from the AWS:\n\n- **Application server:** Amazon EC2 is a web service that provides flexible compute capacity. New servers (instances) can be added within minutes, which are suited to scaling upwards or downwards at any time. Both application servers can be configured to run on the Amazon EC2 service. [31]\n\n- **Database server:** Amazon RDS is a scalable and highly available relational database in the cloud which fully supports the MySQL database engine. Amazon RDS makes it easy to set up, operate, and scale MySQL deployments in the cloud. Amazon RDS allows the developers to fully focus on application development by managing time-consuming database administration tasks including backups, software patching, monitoring, scaling and replication. Our database server can run in the Amazon RDS. [32]\n\n- **File storage:** Amazon offers two types of file systems, the Amazon Elastic File System (EFS) and the Amazon Elastic Block Store (EBS). EFS provides scalable file storage for use with Amazon EC2 instances in the AWS Cloud. Amazon EFS offers a simple interface that allows quick creation and configuration of the file systems. With Amazon EFS, storage capacity is elastic, growing and shrinking automatically as new files are added or existing ones are removed, so the applications have the storage they need, when they need it. All software artifacts and all generated files during the signing process can be stored on the Amazon EFS. [33]\n\nAmazon EBS allows creating storage volumes and attaching them to Amazon EC2 instances. Once attached these volumes can be used as standard block storage, for example, file system can be created or database can be run on top of them. Amazon EBS volumes are placed in a specific Availability Zone, where they are automatically replicated to protect users from the failure of a single component. All EBS volume types offer durable snapshot capabilities and are designed for 99.999% availability. Amazon EBS encryption offers seamless encryption of EBS data volumes, boot volumes and snapshots, eliminating the need to build and manage a secure key management infrastructure. EBS encryption enables data at rest security by encrypting data volumes, boot volumes and snapshots using Amazon-managed keys or keys that can be created and managed using the AWS Key Management Service (KMS). In addition, the encryption occurs on the servers that host EC2 instances, providing\nencryption of data as it moves between EC2 instances and EBS data and boot volumes. [34]\n\n- **VPN:** Amazon VPC enables organizations to have a private, isolated environment in the cloud. This is important feature, since it will enable private environment that can only be accessed from the internal Philips Lighting network. Additionally, a Hardware Virtual Private Network (VPN) connection can be created between the corporate data center and the VPC and leverage the AWS cloud as an extension of corporate data center. Amazon VPC provides advanced security features such as security groups and network access control lists to enable inbound and outbound filtering at the instance level and subnet level. Optionally, users can choose to launch dedicated instances which run on hardware dedicated to a single customer for additional isolation. [35]\n\n### Google Cloud Platform (GCP)\n\nThe following services that are suitable for the system architecture are available from the GCP:\n\n- **Application server:** Google Compute Engine delivers virtual machines running in Google's data centers and worldwide fiber network. Compute Engine's tooling and workflow support enable scaling from single instances to global, load-balanced cloud computing. Compute Engine's VMs are designed to boot quickly, come with persistent disk storage, and are available in many configurations including predefined sizes or the option to create Custom Machine Types optimized for specific needs. Both application servers can be configured to run on the Amazon EC2 service. [36]\n\n- **Database server:** Cloud SQL is a fully-managed database service that makes it easy to set up, maintain, manage, and administer relational PostgreSQL and MySQL databases in the cloud. Cloud SQL offers high performance, scalability, and convenience. Hosted on Google Cloud Platform, Cloud SQL provides a database infrastructure for applications running anywhere. Our database server can run in the Amazon RDS. However, Google Cloud SQL needs a specific way and syntax for accessing and manipulating data. This will require additional changes in the application source code which will make the system Google Platform dependent. [37]\n\n- **File storage:** Google Persistent Disk is durable and high-performance block storage for the Google Cloud Platform. Persistent Disk provides SSD and HDD storage which can be attached to instances running in either Google Compute Engine or Google Container Engine. Storage volumes can be transparently resized, quickly backed up, and offer the ability to support simultaneous readers. Persistent Disks are automatically encrypted to protect your data. You can supply your own key or Google will automatically generate one for you. [38]\n\n- **VPN:** With Google Cloud Platform (GCP) VPC, you can provision your GCP resources, connect them to each other, and isolate them from one another in a Virtual Private Cloud (VPC). You can also define fine-grained networking policies within GCP, and between GCP and on-premise or other public clouds. VPC is a comprehensive set of Google-managed networking capabilities, including granular IP address range selection, routes, firewalls, Virtual Private Network (VPN), and Cloud Router. [39]\n\n### Cloud options comparison and conclusion\n\nBased on the comparison between Google Cloud Platform and Amazon Web Services cloud providers, we can conclude that both GCP and AWS support the architecture and the main requirements listed above. However, AWS has a slight advantage because of its database engine.\n\nGoogle Cloud Platform offers two ways of hosting the MySQL database. The first requires stand-alone installation of MySQL server on the virtual servers. This option\nwill mean that all responsibility for maintenance and administration of the database will be on Philips Lighting, in same way as hosting in the internal premises.\n\nThe second option is to completely use Google Cloud SQL. However, Google Cloud SQL needs a specific way and syntax for accessing and manipulating data. This will require additional changes in the application source code which will make the system Google Platform dependent.\n\nOn the other hand, hosting the MySQL database in Amazon RDS instance means that the database is fully managed by Amazon and is accessible with the same existing source code.\n\n11.2.4. Deployment decision\nTable 11.1 summarizes the analysis made in the Section 11.2. Based on the analysis, an appropriate decision was made for the deployment of the developed system.\n<table>\n<thead>\n<tr>\n<th>Deployment option</th>\n<th>Security</th>\n<th>Architecture support</th>\n<th>Responsibilities</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Lighting data center</strong></td>\n<td>- Additional custom logical security measures need to be implemented (For instance: Two - factor authentication and disk encryption).</td>\n<td>- Fully supports the proposed architecture.</td>\n<td>- Lighting DC is responsible for server and hardware related topics.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>- Environment can be scaled according to the system needs.</td>\n<td>- Home Systems department is responsible for all application related issues and all database maintenance tasks, such as backups and index rebuild.</td>\n</tr>\n<tr>\n<td><strong>IT environment at Home Systems</strong></td>\n<td></td>\n<td>- Freedom to customize the servers according to the system needs, so that they fully support the architecture.</td>\n<td>- Home Systems department is responsible for complete hardware and software maintenance tasks.</td>\n</tr>\n<tr>\n<td></td>\n<td>- Additional physical security measures need to be implemented.</td>\n<td>- If need for scaling, additional hardware need to be purchased.</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>- Additional custom logical security measures need to be implemented (ex. Two - factor authentication, disk encryption).</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Google Cloud Platform</strong></td>\n<td>- Virtual Private Cloud is supported. Connection to the resources is only available through VPN from Philips Lighting network.</td>\n<td>- Fully supports the proposed architecture.</td>\n<td>- Google service provider is responsible for all hardware/server related issues and all database maintenance tasks, such as backups and index rebuild.</td>\n</tr>\n<tr>\n<td></td>\n<td>- File system encryption is possible.</td>\n<td>- Environment can be scaled according to the system needs.</td>\n<td>- Home department is only responsible for application functionality.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>- Application needs some adjustments in the source code for database connection, since Google Database Service has specific Google API for accessing.</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Amazon Web Services</strong></td>\n<td>- Virtual Private Cloud is supported. Connection to the resources is only available through VPN from Philips Lighting network.</td>\n<td>- Fully supports the proposed architecture.</td>\n<td>- Amazon service provider is responsible for all hardware/server related issues and all database maintenance tasks, such as backups and index rebuild.</td>\n</tr>\n<tr>\n<td></td>\n<td>- File system encryption is possible.</td>\n<td>- Environment can be scaled according to the system needs.</td>\n<td>- Home department is only responsible for application functionality.</td>\n</tr>\n</tbody>\n</table>\n\nTable 11.1 Deployment options comparison\n12. Conclusions\n\nThis chapter analyses the results achieved by this project as well as the added value to the stakeholders.\n\n12.1 Results\n\nDeveloping software applications for the Hue devices poses unique challenges among the engineers at Philips Lighting. These challenges arise at each stage of the Software Development Life-Cycle (SDLC). Improvement of the complete SDLC is of immense importance to the Philips Lighting. This was the focus of this project, to make the process as automated as possible, without compromising security aspects of the systems.\n\nThe end result of this project solves a lot of challenges in the SDLC. It is a complete release management tool dedicated to the engineers at the Home department at Philips Lighting. First, it visualizes ongoing software release workflows in a simple and easy to use user interface. With a lot of searching and sorting possibilities, users are able to quickly find out the specific details about a particular software release process. Second, the core activities of the SDLC process are fully automated. The testing architects are now able to digitally sign software with just a few clicks on the web-based user interface. What is more important is that this signing is executed in a highly secure and protected environment. This is of a huge importance for Philips Lighting not only because this automation saves a lot of time, but also because it reduces the risk of a human error that was present before. The same benefits are gained through an automation of other activities in the SDLC, such as approval of steps, distributing the signed software to the Hue production factories, and deploying the signed software to the Hue device cloud. Third, the system provides a traceability about each step executed in the process. For instance, who approved the software for signing or who uploaded the signed files to the Hue device portal. Finally, the system is highly configurable, which makes it easy to be extended and adjusted to support different device types with different release workflows.\n\nFrom the software architecture point of view, the designed system exhibits properties, such as modularity and maintainability, which makes it easily extendable. One of the core non-functional requirements of this project was security. This is achieved by applying advanced security mechanisms in every aspect of the system.\n13. Project Management\n\nThis chapter elaborates on the management conducted throughout the project’s lifetime.\n\n13.1 Introduction\n\nThe management of the project was conducted under the agile methodology by using the Kanban approach. Kanban is a popular framework used by software teams practicing agile software development. Kanban gives teams flexible planning options, faster output, clearer focus, and transparency throughout the development cycle. 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 was focused mainly on Hue domain study and analysis, system environment analysis and requirements engineering. The second part of the project focused on design and implementation of the system based on the outcome 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\n13.2 Work-Breakdown Structure (WBS)\n\nThe work-breakdown structure for the project is presented in Figure 13.1. Two top-level packages are identified to match the two parts discussed earlier. Each package is further decomposed into smaller packages. These packages are later referenced in the project plan and execution section.\nThe Hue domain study and analysis part consists of three packages:\n\n- Domain study: Research and investigations — research and study about the Hue system, the current software signing process and the current software distribution procedure;\n- System Environment Analysis — research and study about the software and hardware components that are composed into the current Hue system; and\n- Requirements Engineering — formalization of the project requirements.\n\nThe Design and implementation part consists of seven packages, each with its own set of sub-packages. It includes:\n\n- Centralize release management — design and develop a workflow based system that will be used for the release process of Hue software;\n- Automate software signing — automate the current software signing process;\n- Automate upload to the device cloud — automate the current process of uploading software images to the device portal;\n- Automate software deployment to the end devices in the field;\n- Automate upload to the factories — automate the current process of sending software images to the Hue production factories;\n- Automate upload to mobile apps — automate the current process of uploading software images to the mobile application development team; and\n- Centralized location for software images — design and develop a web based system that will serve as a centralized location of the Hue software images.\n13.3 Project Planning and Scheduling\n\nBased on the breakdown structure defined in the previous section, a project plan was formulated. As expected, the initial project planning defined 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 last version of the project plan in forms of a Gantt charts.\n\n13.3.1. Initial\n\nThe initial version of the planning involved four major parts: the preparation and setup, for which the initial two weeks were reserved; the Hue domain study and problem analysis, for which the first two months were reserved; the design and implementation, for which six months were reserved; and project finalization phase, one month. The reporting on the project is considered an ongoing task for the entire lifespan of the project. Figure 13.2 shows a Gantt chart for the initial planning for the project.\n\n\n\nFigure 13.2 Initial project plan\n\n13.3.2. Final\n\nDuring the project, several adjustments were introduced. New tasks were added and several were modified or deleted. This was a reflection on the understanding of the project and refining of the stakeholders’ requirements. Additionally, these adjustments were reflection to the corrections of the initial estimations. This is reasonable, since at the beginning of the project the level of domain knowledge and problem understanding was not sufficient to make highly accurate estimations.\nThe execution of the project followed a structured path based on the project planning. The first three months comprised of meetings with stakeholders and reading domain literature. They also included understanding the high-level requirements of the stakeholders and refining them.\n\nFollowing the agile approach of iterative software development, a Project Steering Group (PSG) meeting was held on regular basis where the progress of the project was presented by the trainee and the direction of the project was redefined. Additionally, regular weekly meeting was held with the Philips Lighting supervisors, where the project progress was discussed with more deep level of details. During these meetings, the trainee presented the status as well as parts of the final deliverable. The stakeholders gave feedback and to some extent validation of the deliverable. If it was deemed necessary, additional meetings were scheduled by the trainee to obtain extra information regarding specific domain knowledge. For each meeting, notes were taken by the trainee (meeting minutes), which were later put in documents and occasionally sent back to the stakeholders for review and comments.\n\nBy following the project plan, stakeholders could transparently observe how the project is progressing, and if the status satisfied their standards and 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, several 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.\n14. Project Retrospective\n\nThis chapter finalizes the document by providing a reflection on the project based on the author’s perspective. It also depicts the revision of the design opportunities, defined in the begging of the project.\n\n14.1 Introduction\n\nDuring these nine months, the project demonstrated several familiar aspects and numerous challenging ones. On the familiar side, there was already sufficient knowledge in software development. Although it was a first time for me to use Java programming language in a professional environment, I had enough experience with similar object-oriented languages so the transition to Java went smooth. Additionally, there was adequate knowledge of software architectures, modeling and designing a software as well some insights on project management. Having a working experience as Information Security Office in a bank, as well as having a Master diploma in the field of information security was of a huge importance for this project, since the security was a core topic for all aspects of the system.\n\nThe challenging parts include getting to know the domain and understanding the current software release processes. As with every project, a sufficient level of understanding of the domain is required to be able to translate requirements into a result. Besides the insights from the stakeholders, time of the project was devoted on domain understanding and problem analysis in order to gain sufficient knowledge for the current software development life cycle, especially in the beginning of these nine months. Luckily, the stakeholders from the Philips Lighting 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\nAdditional challenge was to discover all project stakeholders. Many departments contribute to the development of the Hue system. Some of them are even geographically distributed to different countries, such as India and China. Therefore, a sufficient time was spent on the stakeholder’s analysis. Again, the project owners and project supervisors team were very helpful in defining the initial list of stakeholders, that were furthermore interviewed during the project.\n\nOne of the most challenging technical aspects was the deployment for the final product. As I have already mentioned in the Deployment chapter, there are a lot of Philips internal services that are running on a cloud based environment. Although, I was already introduced to the cloud computing and solutions, I have never had practical experience with them. This was a challenge for me at the beginning, especially in understanding the terminology used and possibilities that these solutions have. Therefore, time of the project was devoted on studying the popular cloud service providers and what they could offer that is relevant to the current project.\n\nOverall, the project was a vast experience and a chance to develop and improve a range of skills, both technical and non-technical. Cooperating with people and managing expectations is crucial and this was repeatedly exercised along the project. Managing and executing the project, while at the same time defining and shaping it, was a great lesson that broadened my skills and knowledge. On top of that, several innovative technologies were used that broadened the technical knowledge and opened new horizons for the future.\n14.2 Design opportunities revisited\n\nDuring the study of the Hue system domain and the problem analysis, the following design opportunities were identified, namely security, usability and reliability. Security is achieved by applying advanced security mechanisms in every aspect of the system. First, system is integrated with existing user membership services, used inside Philips Lighting. Next, the system utilizes advanced encryption methods in several features, such as distributing signed files to different endpoints or storing production software signing keys at the signing machine. Furthermore, the complete system is deployed in a highly secured and isolated environment, utilizing a proven and trusted cloud environment. Finally, a dedicated internal team of security experts was created, which main purpose was to evaluate the system architecture from security perspective and sign it off for further implementation.\n\nSince the system should have replaced complete process, it needed to be made usable and intuitive. This was achieved by designing simple and easy to user interface, which can convey the information and provide feedback to the user as clearly as possible. At the moment of writing this report, the system was still not used in the production environment. Valuable feedback is expected from the users regarding the usability once the system is used more extensively and therefore possible changes of the user interface are expected in the future. Usability test is also good option to evaluate how easy-to-use the system is.\n\nThe reliability in the current aspect meant the following. The speed of execution is not critical, but the correctness of the processes is crucial. It was preferred that processes are running sequentially because every action need to be atomic and system should know its state in every moment of time. This was achieved by synchronizing activities in the system and making all process execution activities running sequentially, both at the application and operating system level.\n# Glossary\n\nThis section presents the terminologies used throughout this report along with their explanations.\n\n<table>\n<thead>\n<tr>\n<th>Term</th>\n<th>Explanation</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>SAI</td>\n<td>Stan Ackermans Institute</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>API</td>\n<td>Application Programming Interface</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>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>HTTPS</td>\n<td>Hyper Text Transfer Protocol Secure (HTTPS) is the secure version of HTTP. The 'S' at the end of HTTPS stands for 'Secure'.</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>URL</td>\n<td>Uniform Resource Locator</td>\n</tr>\n<tr>\n<td>URI</td>\n<td>Uniform Resource Identifier</td>\n</tr>\n<tr>\n<td>HTML</td>\n<td>Hyper Text Markup Language is a markup language for describing web documents (web pages)</td>\n</tr>\n<tr>\n<td>MVC</td>\n<td>Model View Controller (architectural style)</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<tr>\n<td>SDLC</td>\n<td>Software Development Life Cycle</td>\n</tr>\n<tr>\n<td>IoT</td>\n<td>Internet of Things</td>\n</tr>\n<tr>\n<td>IoT-GSI</td>\n<td>Global Standards Initiative on Internet of Things</td>\n</tr>\n<tr>\n<td>HSDP</td>\n<td>HealthSuite Digital Platform</td>\n</tr>\n<tr>\n<td>SSL</td>\n<td>SSL (Secure Sockets Layer) is the standard security technology for establishing an encrypted link between a web server and a browser.</td>\n</tr>\n<tr>\n<td>ASPX</td>\n<td>ASPX files are generated by a web server and contain scripts and source codes that help communicate to a browser how a web page should be opened and displayed</td>\n</tr>\n<tr>\n<td>JSP</td>\n<td>Java Server Pages (JSP) is a technology that helps software developers create dynamically generated web pages based on HTML, XML, or other document types</td>\n</tr>\n<tr>\n<td>PHP</td>\n<td>PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML.</td>\n</tr>\n<tr>\n<td>PGP</td>\n<td>Pretty Good Privacy (PGP) encryption program provides cryptographic privacy and authentication for data communication.</td>\n</tr>\n<tr>\n<td>PKI</td>\n<td>Public key infrastructure</td>\n</tr>\n<tr>\n<td>HSM</td>\n<td>Hardware Security Module</td>\n</tr>\n<tr>\n<td>LDAP</td>\n<td>Lightweight Directory Access Protocol</td>\n</tr>\n</tbody>\n</table>\nBibliography\n\n\nAbout the Authors\n\nIgor Anastasov received his Bachelor of Electrical Engineering and Information Technologies from the Faculty of Electrical Engineering and Information Technology (Skopje, Macedonia), in 2011, 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 2014.\n\nIn his Master Thesis called “SIEM implementation for global and distributed environments” he proposes a new model and architecture for SIEM system that is using multiple hierarchically connected SIEM systems. Part of the investigations in this thesis resulted in a research paper published at the International Conference on Computer Information Systems (ICCIS) WCCAIS 2014 in Tunisia.\n\nAfter his graduation in 2011 he worked in several IT companies in Macedonia, developing software applications mainly in .NET and SQL Server RDBMS. Between 2012 and 2014 he worked in ProCredit bank, Macedonia as Information Security Officer. His responsibilities include development and execution of a clear and effective strategy concerning Information Security throughout the organization. From September 2015 until September 2017, he worked at the Eindhoven University of Technology, as PDEng trainee in the Software Technology program from the 4TU.Stan Ackermans Institute."}}},{"rowIdx":191,"cells":{"id":{"kind":"string","value":"3a672e356c7e0c2d90fe60c0e1ebda2a83fe01b7"},"text":{"kind":"string","value":"A True Positives Theorem for a Static Race Detector\n\nNIKOS GOROGIANNIS, Facebook, UK and Middlesex University London, UK\nPETER W. O’HEARN, Facebook, UK and University College London, UK\nILYA SERGEY∗, Yale-NUS College, Singapore and University College London, UK\n\nRacerD is a static race detector that has been proven to be effective in engineering practice: it has seen thousands of data races fixed by developers before reaching production, and has supported the migration of Facebook’s Android app from a single-threaded to a multi-threaded architecture. We prove a True Positives Theorem stating that under certain assumptions, which reflect the way that product code (but not infrastructure code) uses concurrency, an idealized theoretical version of the analysis never reports a false positive. We also provide an empirical evaluation of an implementation of this analysis, versus the original RacerD.\n\nThe theorem was motivated in the first case by the desire to understand the observation from production that RacerD was providing remarkably accurate signal to developers, and then the theorem guided further analyzer design decisions. Technically, our result can be seen as saying that the analysis computes an under-approximation of an over-approximation, which is the reverse of the more usual (over of under) situation in static analysis. Until now, static analyzers that are effective in practice but unsound have often been regarded as ad hoc; in contrast, we suggest, that that theorems of this variety might in future be generally useful in understanding, justifying and designing effective static analyses for bug catching.\n\n1 CONTEXT FOR THE TRUE POSITIVES THEOREM\n\nThe purpose of this paper is to state and prove a theorem that has come about by reacting to surprising properties we observed of a static program analysis that has been in production in industry for over a year.\n\nThe RacerD program analyzer searches for data races in Java programs, and it has had significantly more reported industrial impact than any other concurrency analysis that we are aware of. It was released as open source in October of 2017, and the OOPSLA’18 paper by Blackshear et al. (2018) describes its design, and gives more details about its deployment. They report, for example, that over 2,500 concurrent data races found by RacerD have been fixed by Facebook developers, and that it has been used to support the conversion of Facebook’s Android app from a single-threaded to a multi-threaded architecture.\n\nRacerD’s designers did not establish the formal properties of the analyzer, but it has been shown to be effective in practice. We wanted to understand this point from a theoretical point of view. RacerD is not sound in the sense of computing an over-approximation of some abstraction of executions. Over-approximations support a theorem: if the analyzer says there are no bugs, then there are none. I.e., there are no false negatives (when the program has no bugs), which is often considered as a “soundness” theorem. RacerD favoured reducing false positives over false negatives. A design goal was to “detect actionable races that developers find useful and respond to” but “no need to (provably) find them all”. In fact, it is very easy to generate artificial false negatives, but the authors of RacerD say that few have been reported in over a year of running RacerD in production.\n\n∗Work done while employed as a part-time contractor at Facebook.\n\nAuthors’ addresses: Nikos Gorogiannis, Facebook, UK, Middlesex University London, UK, nikosgorogiannis@fb.com; Peter W. O’Hearn, Facebook, UK, University College London, UK, peteroh@fb.com; Ilya Sergey, Yale-NUS College, Singapore, University College London, UK, i.sergey@ucl.ac.uk.\n\n2018. 2475-1421/2018/10-ART $15.00\nhttps://doi.org/10.1145/nnnnnnn.nnnnnnn\n\nOne can react to this by saying that RacerD is simply an \\textit{ad hoc}, if effective, tool. But, the tool does not heuristically filter out bug reports in order to reduce false positives. It first does computations with an abstract domain, and then issues data race reports if any potential races are found according to the abstract domain. Its architecture is like that of a principled analyzer based on abstract interpretation, \\textit{even though it does not satisfy the usual soundness theorem}. This suggests that saying RacerD is an ad hoc tool for not satisfying a soundness theorem is somehow missing something: It would be better if a demonstrably-effective analyzer with a principled design came with a theoretical explanation, even if partial, for its effectiveness. That is the research problem we set ourselves to solve in this work.\n\nA natural question is if it is possible to actually modify RacerD so as to make it sound, without losing its effectiveness in generating signal—actionable and useful data race reports that developers are keen to fix. RacerD elided standard analysis techniques such as alias and escape analysis, on the grounds that this was consistent with the goal of reducing false negatives. We implemented an escape analysis to find race bugs due to locally declared references escaping their defining scope, to reduce the false negatives. The escape analysis led to too many false positives; it contradicted the goal of high signal. We also tried another tack to reduce false negatives: a simple alias analysis, to find races between distinct syntactic expressions that denote the same lvalue. Again the attempt caused too many false positives.\n\nNext we wondered: might there be a \\textit{different} theorem getting to the heart of why RacerD works? Because it is attempting to reduce false positives, a natural thing to try would be an \\textit{under-approximation} theorem. This would imply that every report is a true positive. This theorem is false for the analyzer, because it is possible to artificially generate false positives. One of the main reasons for this is that conditionals and loops are treated in a path-insensitive manner (\\textit{i.e.}, join corresponds to taking the union of potential racy accesses across the different branches).\n\nIt seems plausible to modify RacerD to be under-approximate in two ways, but each of these has practical problems. In the first way, one considers sets of abstract states, and uses conjunction for interpreting \\textit{if} statements: this is like in symbolic execution. This would cause scaling challenges. RacerD runs quickly, in minutes, on millions of lines of code, and this is important for delivering timely signal. It would not be in the spirit of RacerD, so would not explain why the existing analyzer is effective. The other way would be to use a meet (like intersection) while sticking with one abstract state per program point. The problem here is that this prunes very many reports: while the signal given would be high, it would no longer provide value.\n\nThese considerations led us to the following hypothesis, which we would like to validate:\n\n\\textbf{Conjecture (True Positives (TP) Theorem).} \\textit{Under certain assumptions reflecting product code, the analyzer reports no false positives.}\n\nAn initial version of the assumptions was described as follows. Consider an idealized language, IL, in which programs have only \\textit{non-deterministic} choice in conditionals and loops, and where there no is recursion. The absence of booleans in conditionals reflects the idea that in product code very coarse-grained locking (\\textit{e.g.}, via Java’s \\texttt{synchronized}) is typically used. We don’t often, for example, select a lock conditionally based on the value of a field, like we do in ownership transfer or fine-grained concurrency examples. This is a way of explaining, we suggest, why the analyzer reports few false positives, even though it uses join for \\textit{if} statements. The no-recursion condition is there because we want to say that the analyzer gets the races right except for when divergence makes a piece of code impossible to reach. Even though IL does not perfectly represent product code (nothing does as far as we know), it is still useful as a working hypothesis for theory, as well as for practical deployment on code bases that to the large extent satisfy this assumption.\nOne can see our True Positives Theorem as establishing an under-approximation of an over-approximation in a suitably positioned context. Start with a program without recursion (context). Replace boolean values in conditionals and loop statements by non-determinism (over-approximation). Finally, report only true positives in that over-approximation (i.e., under-approximate the potential bugs in that over-approximation). The more usual position in program analysis is to go for the reverse decomposition, an over-approximation of an under-approximation. The “under” comes about from ignored behaviors (e.g., due to open-world assumptions), and the “over” comes from a usual sound-for-bug-prevention analysis (when a program has no bugs none will be reported). In contrast, our notion of under-of-over seems like a good way to think about a static analysis for bug catching.\n\nWe explained above how we arrived at the statement of the TP Theorem by considering properties of a particular analyzer, paired with considerations of its effectiveness. We don’t claim that to get an effective race detector you must end up in the position of the TP theorem. It might be possible to obtain a demonstrably useful-in-practice data race detector that satisfies a standard soundness (over-approximation) theorem. It might also be possible to find one satisfying a standard (unconditional) under-approximation theorem. In fact, there exist a number of dynamic data race detectors that are very promising, and at least one (Serebryany and Iskhodzhanov 2009) that is widely deployed in practice. Both of these directions are deserving of further research. The work here is not in conflict with these valuable research directions, but would simply complement it by providing new insights on designing static race analyzers.\n\nNow, the True Positives Theorem was not actually true of RacerD when we formulated it, and apparently it is still not. But, subsequent to our discovery of the theorem, the authors of RacerD took it as a guiding principle. For example, they implemented a “deep ownership” assumption (Clarke and Drossopoulou 2002): if an access path, say x.f, is owned (i.e., accessible through just one object instance), then so are all extensions, e.g. x.f.g. The analyzer would never report a race for an owned access. Somewhat surprisingly, even though the deep ownership assumption goes against soundness for bug prevention (over-approximation), it is compatible with the goal of reducing false positives and commonly holds in practice.\n\nWe have proven a version of the TP Theorem for RacerDX, a modified version of RacerD analyzer, which is based on IL and is not too far removed from the original. In this paper we formulate and prove the TP theorem for an idealized theoretical language, and we carry out an empirical evaluation of an implementation of the analysis in relation to the in-production analyzer, wrt. change in the the number of reports produced. The distance between RacerD and RacerDX is such that the latter, which has a precise theorem attached to it, gives on the order of %X fewer reports when measures against production code at Facebook. Later, we will comment on the scenarios under which one might switch RacerDX for RacerD.\n\nBroader Significance of Results. Our starting point was a desire to understand theoretically why the specific analyzer RacerD is effective in practice, and we believe that our results go some way towards achieving this, but it appears that they have broader significance. They exemplify a way of studying program analysis tools designed for catching bugs rather than ensuring their absence.\n\nThe first point we emphasize is the following:\n\nUnsound static analyses can be principled, satisfying meaningful theorems that help to understand their behaviour and guide their design.\n\nThe concept ‘sound’ has often been taken as almost a synonym for ‘principled’ in some branches of the research community, and colleagues we have presented our results to have often reacted with surprise that such a theorem is possible. Representative is the remark of one of the POPL referees, who wrote ‘It is remarkable that the authors manage to prove any theorem at all about...\nan unsound analysis’ and the referees collectively who said ‘proving a theorem for an unsound static analysis is a first’. Whether or not our case is unique (considering, e.g., symbolic execution for bug-catching potentially satisfying under-approximation theorems), the potential for genuine theoretical insights on unsound and incomplete analyses is perhaps less widely appreciated than it could be. Such analyses are not necessarily ad hoc (although they can be).\n\nJust to avoid misunderstanding, note that we are not talking about the common situation of where an analyzer is unsound generally but designed to be sound under assumptions. This situation can be understood as soundness (over-approximation) wrt a different model than the usual concrete semantics, typically an under-approximation of the concrete semantics. By striving for minimizing false positives instead of false negatives, our analyzer is purposely designed to be unsound, and this difference is reflected in the shape of our theorem being under-of-over rather than the converse.\n\nIt is all well and good to say just that there exists an unsound analysis with a theorem, and this would in fact be easy to establish for some useless analysis (e.g., ones that rarely or never report). Much more significant would be if we could make the above claim for an analyzer that was useful in the sense of helping people.\n\nHere, the fact that RacerD (the in-prod analyzer, without a theorem) and RacerDX (its close cousin, with a theorem) are not the same at first glance seems problematic. However, our experiments suggest strongly that, if RacerDX rather than RacerD had been put into production originally, it would have found thousands of bugs, far outstripping the (publicly reported) impact of all previous static race detectors. We infer:\n\nOne can have an unsound but effective static analysis, which has significant industrial impact, and which is supported by a meaningful theorem (in our case the TPT theorem).\n\nThe discussion of this second point is based on counter-factual reasoning (what if we ‘had’ deployed RacerDX instead of RacerD?), admittedly, but the possibility of it being a false argument seems to be vanishingly small. The point is so powerful, and accepted by the Infer static analysis team members even outside the authors, that the TPT theorem is guiding the construction of new analysers at Facebook.\n\nThus, it seems that our results could be more broadly significant than the initial but perhaps worthwhile goal of ‘understand why RacerD is effective’. The fact that RacerD and RacerDX don’t coincide is not so important for the larger point, though it would have made for a neat story if they had. Such neat stories have so far been rather rare when developing analysers under industrial rather than scientific constraints. Future analysers, including ones being developed at Facebook will perhaps adhere more to the ‘neat’ story.\n\n**Paper Outline.** In the remainder of the paper we give an overview of the intuition and reasoning principles for identifying and reporting concurrent data races in RacerD (Section 2). We then describe an idealized language (IL), whose set of features matches the common conventions followed in production Java code, as well as IL’s over-approximating semantics (Section 3). We then provide a formal definition of RacerDX, a modified RacerD analysis, tailored for reporting no false positives, in the framework of abstract interpretation (Section 4). Our formal development culminates with a proof of the True Positives Theorem, coming in two parts: in Section 5 we prove completeness of RacerDX wrt. to its abstraction and in Section 6 we show how to reconstruct provably racy executions from the analysis results. In Section 7, we discuss the implementation of the theoretical analyzer described in Section 4. We then present an evaluation of RacerDX which compares it with RacerD on a set of real-world Java projects. We discuss related work in Section 8 and discuss the common formal guarantees considered for static concurrency analyses, positioning RacerDX amongst related tools and approaches.\n2 OVERVIEW\n\nA textbook definition of a data race is somewhat low-level: a race is caused by potentially concurrent operations on a shared memory location, of which at least one is a write (Herlihy and Shavit 2008). Data races in object-based languages with a language-provided synchronization mechanism (e.g., Objective C or Java) can be described more conveniently, for the sake of being understood and fixed by the programmer, in terms of the program’s syntax (rather than memory), via access paths, which would serve as runtime race “witnesses”, by referring to the dynamic semantics of concurrent executions. Given two programs (e.g., calls to methods of the same instance of a Java class), \\( C_1 \\) and \\( C_2 \\), there is a data race between \\( C_1 \\) and \\( C_2 \\) if one can construct their concurrent execution trace \\( \\tau \\), and identify two access paths, \\( \\pi_1 \\) and \\( \\pi_2 \\) (represented as field-dereferencing chains \\( x.f_1,\\ldots,f_n \\), where \\( x \\) is a variable or this), in \\( C_1 \\) and \\( C_2 \\), respectively, such that:\n\n(a) at some point of \\( \\tau \\) both \\( \\pi_1 \\) and \\( \\pi_2 \\) are involved into two concurrent operations, at least one of which is a write, while both \\( \\pi_1 \\) and \\( \\pi_2 \\) point to the same shared memory location;\n(b) the sets of locks held by \\( C_1 \\) and \\( C_2 \\) at that execution point respectively, are disjoint.\n\nThis “definition” of a data race provides a lot of freedom for substantiating its components. Of paramount importance are (i) the considered set of pairs of programs that can race, (ii) the assumptions about the initial state of \\( C_1 \\) and \\( C_2 \\), and (iii) the notion of the dynamic semantics, employed for constructing concurrent execution traces. A choice of those determines what is considered to be a race and reflects some assumptions about program executions. For instance, accounting for the “worst possible configuration” (e.g., arbitrary initial state and uncontrolled aliasing) would make the problem of sound (i.e., over-approximating) reasoning about data races non-tractable in practice, or render its results too imprecise to be useful.\n\n2.1 Race Detection in RacerD\n\nAs a specific set of design choices with respect to identifying data races in terms of access paths, let us consider RacerD (Blackshear et al. 2018)—a tool for static compositional analysis by Facebook—and its take on a toy example in Figure 1. The Java class \\texttt{Dodo} has one \\texttt{private} field \\texttt{dee} and two \\texttt{public} methods, both manipulating \\texttt{dee}’s state. To instantiate the definition of a data race above, RacerD considers all pairs of method calls of the same class instance as concurrently running programs \\( C_1 \\) and \\( C_2 \\) from the definition above (i). To instantiate the initial state, it assumes that method parameters of the same type (e.g., \\texttt{Dodo}) may alias, thus, maximizing a possibility of a race (ii). Finally, it assumes there is only one reentrant lock in the entire program (e.g., \\texttt{Dodo}’s this), and over-approximates the dynamic semantics by taking all branches of the conditionals and entering every loop (iii).\n\nWith this setup, RacerD reports the class \\texttt{Dodo} (annotated with \\texttt{javax.annotation.concurrent.ThreadSafe}) as racy, due to concurrent unsynchronized accesses to the field \\texttt{dee} in two paths: a read from \\texttt{dee} in the method \\texttt{zap()} and the write to \\texttt{dee} in \\texttt{zup()}—both detected based on the assumption that the two \\texttt{d} can be run-time aliases, since they share the same type. This assumption makes it easy to reconstruct a concurrent execution of the two culprit methods, invoked with the same object, which would exhibit a race, thus making this report a true positive of the analysis.\n\n---\n\n1We will provide a more rigorous definition in Section 3.\n2.2 Fighting False Positives\n\nBy its nature, RacerD is a bug detector, hence it sacrifices the traditional concept of soundness (the property customary for static analyses stating that all behaviors of interest are detected (Cousot and Cousot 1979)) and, thus, may suffer false negatives (i.e., miss races).\\(^2\\) Instead, for the purposes of correctly detecting bugs, and minimizing the time programmers spend investigating the reports, RacerD emphasizes completeness (Ranzato 2013) over soundness, targeting what we are going to refer to as the True Positives Conjecture—that is if it reports a data race, one should be able to find a witness execution and access paths which exhibit the concurrency bug, given the assumptions made.\n\nAs a next example, consider the Java class Burble in Figure 2. For the same reason as with Dodo, the methods meps and reps race with each other when run with aliased arguments. It is less obvious, however, whether meps races with beps—and in fact they do not! The reason for that is that beps reassigns a freshly allocated instance of Bloop to the formal b before assigning to the field of the latter, thus, effectively avoiding a race with a concurrent access to b.f in meps.\n\nThis phenomenon of “destabilizing” an access path in a potentially racy program can be manifested both intra-procedurally (as in Burble) and inter-procedurally. To wit, in another example in Figure 3, the class Wurble demonstrates a similar instance of a false race, with the private method zwup() “destabilizing” the path w.g by assigning a newly allocated Wurble instance to it, thus, ensuring that qwop() and gwap() avoid a race with each other.\n\nA sound static analyzer would typically be expected to report races in both of these examples, corresponding to a loss of precision. However, having a non-negligible number of false positives is not something a practical bug detector can afford.\n\nTo avoid this loss of signal effectiveness, RacerD employs an ownership tracking domain (Flanagan and Freund 2009; Naik et al. 2006), used to record the variables and paths that have been assigned a newly allocated object, thus remedying the situation shown above.\n\nUpon closer examination, we found that RacerD’s abstract domain, including that of ownership, was not enough to allow us to prove that an access path resolves to the same address, before and after execution. To wit, knowing that an access path x.f.g is not owned, does not guarantee that\n\n---\n\n\\(^2\\)Although no races were missed in Facebook’s production code, as reported by Blackshear et al. (2018).\nthe lvalue it corresponds to stays the same during execution. The reason we wanted this latter property is that it is one of the simplest ways to exhibit a race: once we have set up an initial state where a path resolves to a certain address, and have shown that execution of $C_1 \\parallel C_2$ does not modify that address (i.e., the path to address is stable), we are in the position to unconditionally say that if both programs access that address, they will race. The answer we came up with is that of stability; its negation, instability (or wobbliness), over-approximates ownership.\n\nThus we pose the question: can we state the reasonable (i.e., non-trivial) conditions under which we can in confidence state (i.e., formally prove) that all of RACERD’s reported races are true positives?\n\nWe refer to this desirable result as the True Positives Theorem (TPT) for a static race detector, and in this paper we deliver such a theorem for a version of RACERD (called RACERDX, using stability), formulating a set of assumptions under which it holds, and assessing their practical implications and impact on signal.\n\n2.3 A True Positives Theorem for RACERDX\n\nOur main result enabling the TPT proof is defining an over-approximating concrete semantics and stating the sufficient conditions, both reflecting the behavior of production code, under which RACERDX, a modified version of RACERD, reports no false data races. The RACERDX True Positives Theorem, which substantiates this statement, builds on the following three pieces of the formal development that together form the central theoretical contribution of this work.\n\n2.3.1 An Over-Approximating Concrete Semantics and Practical Assumptions. RACERDX is a flow- and path-insensitive static analysis, which goes in all branches of conditional expressions and loops. To account for this design choice while stating a formal completeness result, we adopt a novel non-deterministic (single-threaded) trace-collecting semantics that treats branch and loop guards as non-deterministically valued variables and explores all execution sequences (Section 3). We use this semantics to give meaning to single-threaded program executions, thus, building a concrete domain for the main RACERDX analysis procedure. Amongst other things, we assume just one global lock and a language with a single class (although we do not restrict the number of its fields and methods, as well as their signatures). We also restrict the reasoning to programs with well-balanced locking (e.g., in Java terminology it would mean that only synchronized-enabled locking is allowed), and forbid recursion.\n\n2.3.2 RACERDX Abstraction and Sequential Completeness of its Analysis. We formulate the abstract domain for RACERDX analysis (Section 4) along with the abstraction function to it from the concrete domain of the previously defined multi-threaded trace-collecting semantics, à la Brookes (2007), which we show to form a Galois connection (Cousot and Cousot 1979). We then prove, in Section 5, a tower of lemmas, establishing the “sequential” completeness of RACERDX’s static analysis, which analyzes each sequential sub-program compositionally in isolation, without considering concurrent interleavings, with respect to this abstraction (Theorem 5.15). The novelty of our formal proof is in employing the classical framework of Abstract Interpretation, while taking a different perspective by establishing the completeness rather than soundness of an analysis in the spirit of the work by Ranzato (2013).\n\n2.3.3 Syntactic Criteria for Ensuring True Positives. We introduce the notions of path stability and its counterpart, wobbliness (i.e., instability)—simple syntactic properties, which are at the heart of stating the sufficient conditions for RACERDX’s TPT,—and connect it to the previously developed abstract domain and single-threaded RACERDX abstraction. A similar tower of lemmas is built, showing that a stable path resolves to the same address before and after execution, thus providing us with the tools for validating the reported race. Our formal development culminates in Section 6,\nwith leveraging the sequential completeness result of RACERDX for reconstructing the concrete concurrent execution traces exhibiting provably true data races, thus delivering the final statement and the proof of TPT (Theorem 6.10).\n\n2.4 Measuring the Impact of True Positives Theorem on Signal Effectiveness\nThe practical contribution of our work, described in Section 7, is an implementation of RACERDX, a revised version of RACERD, incorporating the analysis machinery enabling the result of TPT, and its evaluation at scale. Specifically, we aimed to measure the impact of employing stability as a sufficient condition for detecting true races with respect to the reduction in overall number of reported bugs.\\footnote{It is easy to have a vacuous TPT by reporting no bugs whatsoever!} We ran experiments contrasting RACERD and RACERDX on a number of open-source Java projects, ranging from 25k to 273k LOC. We evaluated the runtime of each analyser, and looked at the reports the two analyzers produced in several ways, in order to assess the loss of signal induced by RACERDX.\n\n3 CONCRETE EXECUTION MODEL\nTo formally define our execution model and the notion of a race, we first describe an idealized programming language (IL) that accurately captures the essence of RACERDX’s intermediate representation and faithfully represents the race-relevant aspects of Java and similar languages.\n\n3.1 Language and Assumptions about Programs\nWe start by defining a programming language with a semantics suitable for RACERDX’s goals. Our language is simplified compared to Java, with assumptions made to help our study of the question of whether the data race reports are effective.\n\nA1 The language has only one class, that of record-like objects with an arbitrary, but finite set of fields (with names from a fixed set Field) which are themselves pointers.\n\nA2 The concurrency model is restricted to exactly two threads, and use a single, reentrant lock. The commands \\texttt{lock()} and \\texttt{unlock()} are only allowed to appear in \\textit{balanced pairs} within block statements and method bodies.\n\nA3 Local variables need no declaration, but must be assigned to before first use. Formal parameters are always taken from a fixed set. There are no global variables.\n\nA4 There is no destruction of objects, only allocation.\n\nA5 All methods are non-recursive, have call-by-value parameters and no return value. The assumption on non-recursion is standard, as we don’t want to reason here about termination.\n\nA6 Control for conditional statements and while loops is \\textit{non-deterministic}; there are no booleans.\n\nAssumptions A1 and A5 are about ignoring potential sources of false positives which have nothing in particular to do with races. For example, if you enter an infinite loop before a potential data race then you would have a false positive if you reported the race, but we wouldn’t expect a (static) race detector to detect infinite loops. Similarly, if you have a class that can’t be inhabited you can’t get races on it, but we view this as separate from the question of the effectiveness of the race reports themselves.\n\nThe reason for the simplifications A1 and A2 are both related to RACERDX’s setup with which it targets detection of race in only one class at a time, with races manifested by parallel execution of its single instance’s methods. Assumption A2 is a potential source of real false negatives, as methods of the same class that use distinct locks can race. Furthermore, the well-balanced assumption in A2 corresponds directly to scoped synchronisation mechanisms like Java’s \\texttt{synchronized(m){ }} construction (Goetz et al. 2006), where \\texttt{m} is a static global mutex object. A3 corresponds to the\nA True Positives Theorem for a Static Race Detector\n\nf ∈ Field \\quad \\text{field names}\n\\text{x, arg}_i \\in \\text{Var} \\quad \\text{variables}\n\\pi \\in \\text{Path} \\quad ::= \\pi.f | \\pi.f\n\\text{e} \\in \\text{Exp} \\quad \\triangleq \\text{Var} \\cup \\text{Path}\n\\text{c} \\in \\text{Stmt} \\quad ::= \\text{skip} | x := \\pi | x := \\text{new()} | \\text{lock()} | \\text{unlock()} | \\text{pop()}\n\\text{C} \\in \\text{CStmt} \\quad ::= c \\mid C \\mid \\text{if } * \\text{ then } C \\mid \\text{else } C \\mid \\text{while } * \\text{ do } C \\mid C.m(e, \\ldots , e)\n\\text{M} \\in \\text{Method} \\quad ::= m(\\text{arg}_1, \\ldots , \\text{arg}_n)\\{C\\}\n\\text{p} \\in \\text{Program} \\quad ::= C \\parallel C\n\n\\text{Fig. 4. Syntax grammar of the concurrent programming language.}\n\nRACERDX’s intermediate language representation of parameters and variables. The lack of global variables is a genuine restriction, but which is easy to address; we discuss this from a practical point of view in Section 7. The assumption A4 is due to the fact that Java is a garbage-collected language.\n\nFinally, the assumption A6 is the most significant one, both from the perspective of formalising a language semantics, and from the point of specifying completeness. By assuming that every execution branch may be taken, we do not have to reason statically about branching and looping conditions. This is effectively an over-approximation of the actual semantics of the concurrent programs. This assumption is motivated by two considerations: (i) in product code, developers do not often avoid races by choosing which branch to take; (ii) RACERD uses join for if statements in order not to have too many false negatives.\n\nThe grammar defining the language of interest is given in Figure 4. We represent expressions \\text{e} \\in \\text{Exp} as either program variables and method formals \\text{x} \\in \\text{Var}, and access paths \\pi \\in \\text{Path} = \\text{Var} \\times \\text{Field}^\\times. The language contains no constants such as, e.g., \\text{null}. We partition statements into simple and composite. Simple statements include assignments to variables, paths, reading from paths, allocating a new object, (blocking) lock acquisition via \\text{lock()}, releasing a lock via \\text{unlock()}, and popping an execution stack. The command \\text{pop()} is not to be used directly in programs; it only occurs in our semantics of method calls and is needed for defining the trace-collecting semantics described below. Composite statements provide the support the sequential composition (\\text{·}), as well as conditionals (if \\text{· then · else ·}), loops (\\text{while · do ·}) and method calls, with the latter resulting in pushing a new stack frame on the call stack, as well as emitting a \\text{pop()} command to remove it at runtime after the method body is fully executed.\n\nFollowing the tradition of Featherweight Calculi for object-oriented languages (Igarashi et al. 2001), we introduce the function mbody(·) : Method → CStmt, which maps method names to bodies and #(·) : Method → \\mathbb{N}, which gives the number of formal parameters. We impose the convention that the formal parameters are always \\text{arg}_1, \\ldots , \\text{arg}_n for all methods, where \\text{n} = #(m) and that no other variables of the form \\text{arg}_j, where \\text{j} > \\text{n}, appear in mbody(m). We also allow local variables (i.e. variables \\text{x} which are not of the form \\text{arg}_i) but forbid their use without definite prior initialisation.\n\n3.2 Concrete Semantics\n\nIn this work, we do not tackle fine-grained concurrency (Turon et al. 2013), and we only consider lock-based synchronisation, as per assumption A2. Therefore, our concurrent semantics adopts the model of sequential consistency (Lamport 1979). To define it, we start by giving semantics to sequential program runs, which we will later combine to construct concurrent executions.\nare defined in a field-splitting style, as\n\n\\[\n[tuple] (s, h, L) \\triangleq (\\epsilon)\n\\]\n\n\\[c \\mapsto \\tau \\mapsto (s, h, L) \\triangleq \\begin{cases} \n0 & \\text{if } [\\tau]_{s, h} \\notin \\text{dom}(h) \\\\\n[c] & \\text{if } [\\tau]_{s, h} \\notin \\text{dom}(h) \n\\end{cases}\n\\]\n\n\\[c \\mapsto \\text{new}(x) \\mapsto (s, h, L) \\triangleq \\begin{cases} \n\\text{locn}(s' = s + h, h'[x \\mapsto \\ell], L) & \\ell \\notin \\text{locn}(h), s' = s[x \\mapsto \\ell], h' = h \\cup \\bigcup_{\\text{field}}((\\ell, f) \\mapsto f) \n\\end{cases}\n\\]\n\n\\[c \\mapsto \\text{lock}(x) \\mapsto (s, h, L) \\triangleq (\\text{lock}(x), s, h, \\text{add}(L, 1))\n\\]\n\n\\[c \\mapsto \\text{unlock}(x) \\mapsto (s, h, L) \\triangleq 0 \\text{ if } L \\leq 0\n\\]\n\n\\[c \\mapsto \\text{pop}(x) \\mapsto (s, h, L) \\triangleq (\\text{pop}(x), s, h, L)\n\\]\n\n\\[c : m(e_1, \\ldots, e_n) \\mapsto (s, h, L) \\triangleq \\begin{cases} \n0 & \\text{if for some } i \\leq n, [e_i]_{s, h'} \\text{ is undefined for } (s = S', h', L') = \\text{last}([C] (s, h, L)) \\\\\nC & \\text{last}(\\tau) = [\\text{push}\\{m; \\text{pop}\\}(\\ell)] (s = S', h', L') \n\\end{cases}\n\\]\n\n\\[C : c \\mapsto (s, h, L) \\triangleq \\begin{cases} \n\\tau & \\text{if } \\tau \\in [C] (s, h, L), (s = S', h', L') = \\text{last}(\\tau) \\\\\n\\tau' & \\text{if } \\tau \\in [C] (s, h, L), (s = S', h', L') = \\text{last}(\\tau), \\tau' \\in [C] (S', h', L')\n\\end{cases}\n\\]\n\n\\[C : (\\text{if } \\epsilon \\text{ then } C_1 \\text{ else } C_2) \\mapsto (s, h, L) \\triangleq \\begin{cases} \n\\tau & \\text{if } \\tau \\in [C] (s, h, L), (s = S', h', L') = \\text{last}(\\tau) \\\\\n\\tau' & \\text{if } \\tau \\in [C] (s, h, L), (s = S', h', L') = \\text{last}(\\tau), \\tau' \\in [C] (s, h, L)\n\\end{cases}\n\\]\n\n\\[C : (\\text{while } \\epsilon \\text{ do } C') \\mapsto (s, h, L) \\triangleq \\text{fix } \\tau (\\text{if } \\epsilon \\text{ then } C_1 \\text{ else } C_2) \\mapsto (s, h, L), \\text{ where }\n\\]\n\n\\[\\varphi \\triangleq \\lambda T. T \\cup \\{\\tau \\mapsto \\epsilon \\mid \\tau \\in T, (s', h', L') = \\text{last}(\\tau), \\tau' \\in [C'] (s', h', L')\\}\n\\]\n\nFig. 5. Single-threaded trace-collecting semantics of simple (top) and compound statements (bottom).\n\nOur definition of runtime executions works over the following semantic categories. Loc denotes a countably infinite set of object locations. A stack \\(s \\in \\text{Stack} \\) is a mapping \\(s : \\text{Var} \\rightarrow \\text{Loc} \\). Addresses \\(\\text{Addr} \\) are defined in a field-splitting style, as \\(\\text{Addr} = \\text{Loc} \\times \\text{Field} \\). A heap \\(h \\in \\text{Heap} \\) is a partial, finite map \\(h : \\text{Addr} \\rightarrow \\text{Fin} \\) \\text{Loc} \\. The constant \\(\\text{nil} \\) is such that there no heap is ever defined on an address of the form \\((\\text{nil}, f) \\). We write \\(\\text{snil} \\) for the stack such that \\(s(x) = \\text{nil} \\) for all \\(x \\in \\text{Var} \\). The projection of an address to its first component is \\(\\text{locn}(\\cdot), \\text{i.e.}, \\text{locn}(\\ell, f) = \\ell \\). We lift this definition to sets of addresses, \\(\\text{locn}(A) = \\{\\text{locn}(\\alpha) \\mid \\alpha \\in A\\} \\), and to heaps, \\(\\text{locn}(h) = \\text{locn}(\\text{dom}(h)) \\). For example, \\(\\text{locn}((\\ell_1, f) \\mapsto \\ell_2; (\\ell_2, g) \\mapsto \\ell_3) = (\\ell_1, \\ell_2) \\). A lock context \\(L \\in \\text{Locks} = \\mathbb{N} \\) is a natural number.\n\nA (single-thread) \\textit{program state} \\(c \\in \\text{State} = \\text{Stmt} \\times \\text{Stack} \\times \\text{Heap} \\times \\text{Locks} \\) is a tuple \\((c', s, h, L) \\), where \\(c' \\in \\text{Stmt}^* \\) is a either simple statement \\(c \\in \\text{Stmt} \\) (Figure 4) or a \\textit{runtime} call-statement \\(\\text{push}(e_1, \\ldots, e_n); S \\in \\text{Stack}^+ \\) models the call-stack, \\(h \\) is a heap, and \\(L \\in \\text{Locks} \\). The stack at head position in the list \\(S \\) is the current stack frame. The \\(L \\) component is the lock context of the thread, signifying how many times a \\text{Lock}(\\cdot) instruction has been executed without a corresponding \\text{unlock}(\\cdot). We remark that the stack, heap and lock state components are those \\textit{produced by executing} \\(c \\) \\textit{starting at some previous program state}.\n\nA \\textit{two-threaded} program state is a tuple \\(c || (s_1, s_2), h, (L_1, L_2) \\), where \\(c || \\) is either \\(c \\parallel e \\) or \\(e || c \\), denoting one of the two threads executing command \\(c \\). The pairs \\((s_1, s_2) \\) and \\((L_1, L_2) \\) are the thread-local call-stacks and lock contexts for each thread, and \\(h \\) is the shared heap.\n\nFor the next series of definitions, we overload the term \\textit{state} to describe stack-heap pairs for both single-threaded and multi-threaded executions when the context is unambiguous.\n\n\\textbf{Definition 3.1.} The \\textit{address}, \\([\\pi]_{s, h}, \\) of a path \\(\\pi \\) in a state \\((s, h) \\) is recursively defined as follows:\n\n\\[cxf \\triangleq (s(x), f) \\quad [\\pi']f \\triangleq (h([\\pi']_{s, h}), f)\\]\nA True Positives Theorem for a Static Race Detector\n\nThe symbol \\( \\tau \\) will be used to avoid naming values we don’t care for. We do this throughout this paper.\n\nWe define \\( \\text{successor} \\) on a lock acquisition, the \\( \\tau \\) of traces starting from an initial configuration \\( C \\) and multi-threaded executions. For the sake of uniformity, we assume that each program starts from the \\( \\text{skip} \\) command.\n\n\\[\n\\begin{align*}\n\\langle C_1 \\parallel C_2 \\rangle \\ (\\langle S_1, S_2 \\rangle, h, (L_1, L_2)) & \\triangleq \\bigcup_{\\tau_1 \\in \\langle C_1 \\rangle} \\bigcup_{\\tau_2 \\in \\langle C_2 \\rangle} \\text{interl } \\tau_1 \\tau_2 \\ (\\langle S_1, S_2 \\rangle, h, (L_1, L_2)), \\\\\n\\text{interl } \\tau_1 \\tau_2 \\ (\\langle S_1, S_2 \\rangle, h, (L_1, L_2)) & \\triangleq \\begin{cases} \n\\epsilon, \\\\\n\\langle C_1 \\parallel \\epsilon, (S_1, S_2), h, (L_1, L_2) \\rangle, \\\\\n\\langle C_1, \\epsilon, (S_1, S_2), h, (L_1, L_2) \\rangle = \\tau \\end{cases}, \\\\\n\\text{interl } \\epsilon \\epsilon \\ (\\langle S_1, S_2 \\rangle, h, (L_1, L_2)) & \\triangleq \\{ \\epsilon \\}\n\\end{align*}\n\\]\n\nFig. 6. Concurrent trace-collecting semantics.\n\nThe \\textit{value}, \\( [e]_{s,h} \\), of an expression \\( e \\) in a state \\( s, h \\) is recursively defined as follows:\n\n\\[\n[x]_{s,h} \\triangleq s(x) \\quad [\\pi]_{s,h} \\triangleq h([\\pi]_{s,h})\n\\]\n\nThe address of a path is, intuitively, the address read or written when a load or a store accesses that path.\n\nDefinition 3.2 (Execution trace). A (single-threaded) execution trace is a possibly empty list \\( \\tau = [\\xi_0, \\ldots, \\xi_n] \\) of program states. The set of all traces is \\( \\mathcal{T} = \\text{State}^* \\).\n\nWe are now equipped with all the necessary formal components to give meaning to both single- and multi-threaded executions.\n\nDefinition 3.3 (Sequential trace-collecting semantics). A trace-collecting semantics of a single-threaded (possibly compound) program \\( C \\), denoted \\( \\lbrack C \\rbrack : \\text{Stack}^+ \\times \\text{Heap} \\times \\text{Locks} \\to \\varphi(\\mathcal{T}) \\) is a set of traces starting from an initial configuration \\( (S, h, L) \\). The trace-collecting semantics are defined in Figure 5.\\(^4\\) The auxiliary function \\( \\text{last}(\\tau) \\) (defined only on non-empty traces) returns the triple \\( \\langle S', h', L' \\rangle \\) if the last element of the non-empty trace \\( \\tau \\) is \\( \\langle c, S', h', L' \\rangle \\) for some command \\( c \\).\n\nWe give the semantics for concurrent programs in the style of Brookes (2007).\n\nDefinition 3.4 (Concurrent trace-collecting semantics). The trace-collecting semantics of a parallel composition of programs \\( C_1 \\) and \\( C_2 \\) is defined in Figure 6.\n\nWe conclude this section of definitions by formally specifying concurrent data races.\n\nDefinition 3.5 (Data Race). The program \\( C_1 \\parallel C_2 \\) race if there exists a state \\( \\xi_0 \\) and a non-empty \\( \\tau \\in \\lbrack C_1 \\parallel C_2 \\rbrack \\xi_0 \\) such that \\( \\text{last}(\\tau) = \\langle \\_, (s_1 : \\_, s_2 : \\_), h, \\_ \\rangle \\)\\(^5\\) and,\n\n- there exist paths \\( \\pi_1, \\pi_2 \\) such that \\( \\lbrack \\pi_1 \\rbrack_{s_1,h} = \\lbrack \\pi_2 \\rbrack_{s_2,h} \\);\n- there exist states \\( \\xi_1 = \\langle c_1 \\parallel \\epsilon, \\_, \\_, \\_, \\_ \\rangle \\) and \\( \\xi_2 = \\langle \\epsilon \\parallel c_2, \\_, \\_, \\_, \\_ \\rangle \\) such that \\( \\tau : \\xi_1, \\tau : \\xi_2 \\in \\lbrack C_1 \\parallel C_2 \\rbrack \\xi_0 \\);\n- \\( c_1 = (\\pi_1 := x) \\wedge c_2 = (\\pi_2 := y) \\), or, \\( c_1 = (\\pi_1 := x) \\wedge c_2 = (y := \\pi_2) \\), or, \\( c_1 = (x := \\pi_1) \\wedge c_2 = (\\pi_2 := y) \\).\n\nHow can this definition capture races without mentioning locks? For a thread to be blocked on a lock acquisition, the \\textit{successor} instruction to the current state \\textit{must} be a \\textit{lock()} statement, which is excluded by the syntactic condition on the successor instructions (cf. restrictions \\textit{wrt.})\n\n\\(^4\\)For the sake of uniformity, we assume that each program starts from the \\textit{skip} command.\n\n\\(^5\\) We will use the notation \\_ to avoid naming values we don’t care for. We do this throughout this paper.\nlocking contexts $L_i = L'_i = 0$ in Figure 6). Other sources of getting stuck are excluded by our assumptions A2–A6: there no deadlocks due to a single reentrant lock, no deterministic infinite loops and no recursion.\n\n4 RACERDX ANALYSIS AND ITS ABSTRACT DOMAIN\n\nThe core RACERDX analysis statically collects information about path accesses occurring during an abstract program execution, as well as their locking contexts. In addition to those fairly standard bits, it tracks an additional program property, which makes it possible to filter out potential false negatives at the reporting phases—wobbly paths.\n\nDefinition 4.1. We call a path $\\pi$ non-stable (or unstable, or wobbly) in a program $c$ if it appears as either LHS or RHS in a read or an assignment command during some execution of $C$. We elaborate this concept in the presence of method calls below.\n\nFormally, the analysis operates on an abstract domain, which is a product of the three components: domain of wobbly paths, an access path domain and a lock domain.\n\nDefinition 4.2 (RACERDX abstract states). The abstract domain is $D \\triangleq \\varphi(W) \\times L \\times A$, where\n\n- $W \\in \\{W \\triangleq \\text{Exp is the set of wobbly accesses};$\n- $L \\in \\mathcal{L} \\triangleq \\text{Locks} = \\mathbb{N}$ is the current lock context;\n- $A \\subseteq \\mathcal{A} \\triangleq \\varphi\\{\\langle c, L \\rangle \\mid c \\in \\{x := \\pi, \\pi := x\\}, L \\in L\\}$ is a domain of sets of recorded read/write accesses from/to paths which occur under lock state $L$.\n\nThe lattice structure on $D$ (which we will often refer to as summaries) is ordered (via $\\subseteq$) by pointwise lifting of the order relations $(\\subseteq, \\leq, \\subsetneq)$ on the three components of the domain (Cousot and Cousot 1979). For an element $D \\in D$, we refer to the corresponding three projections as $D_W$, $D_L$ and $D_A$. For computing the join of branching control-flow and loops, the analysis employs a standard monotone version of a lub-like operator.\n\nDefinition 4.3 (Least-upper bound on $D$). For $D_1 = \\langle W_1, L_1, A_1 \\rangle$ and $D_2 = \\langle W_2, L_2, A_2 \\rangle$,\n\n$$D_1 \\sqcup D_2 = \\langle W_1 \\cup W_2, \\max(L_1, L_2), A_1 \\cup A_2 \\rangle.$$\n\nThe intuition of what might go wrong with $\\sqcup$ defined this way, when aiming for an analysis “no-information-loss”, is easier to see on an example. Consider the program if * then $C_1$ else $C_2$; $C$, where in $C_1$ the lock (which is reentrant, as agreed above) is taken strictly more times than in $C_2$; then by taking an over-approximation of the total number of times the lock is taken for both branches (i.e., max), we have a chance to miss a race in the remainder program $C$, as some access path can be recorded by the analyzer as having a larger lock context than if fact it would have in a concrete execution. What comes to the rescue is the assumption A2, which we will exploit in our proofs of TP Theorem. Turns out, in practice, implementations of all classes we run the analysis on (cf. Section 7) have well-scoped locking, mostly relying on Java’s synchronized primitive.\n\nThe definition of RACERDX analysis for arbitrary compound programs is given in Figure 7. The abstract transition function $[\\cdot]_*$ relies on the three primitives, wobbly, locking, and accs, that account for the three corresponding components of the abstract domain. In the case of method calls, $[\\langle m(e_1, \\ldots, e_n) \\rangle_*]$, the analysis also takes advantage of its own compositionality, adapting a summary of a method $m$ to its caller context ($\\langle W, L, A \\rangle$) and the actual arguments $e_1, \\ldots, e_n$.\n\n**What does the analysis achieve?** First, the results of the analysis from Figure 7 are used to construct a set of race candidates in RACERDX. Following the original RACERD algorithm described by Blackshear et al. (2018), if for a pair of method calls (possibly of the same method) of the same class instance, the same syntactic access path $\\pi$ appears in both methods summaries, depending\nlocking\nL\nwobbly paths “destabilise” the future results of the analysis, allowing the real path-underlying\nA True Positives Theorem for a Static Race Detector :13\nRacerDX\nvalues “escape” the race, thus rendering it a false positive—precisely what we are aiming to avoid.\n\nIn this section, we deliver on the first part of the agenda towards True Positive Theorem: the\nefficient while being precise, in the assumptions\nthat the notion of wobbliness\nDefinition 3.5. Furthermore, the evaluation of\nnon-destabilised accesses are indeed\ntrue positives\nthat were affected by wobbly prefixes.\n\nlock L (x := new()) = L\nlocking L (lock()) = incr(L)\nlocking L (unlock()) = decr(L)\nlocking L (push(e1, ..., e_n) | pop()) = L\nlocking L (x := e | e := x) = W ∪ \\{x, e\\}^{\\text{fml}}\nlocking L (x := new()) = W ∪ \\{x\\}^{\\text{fml}}\n\n\\[ \\text{wobbly } W \\{\\text{lock()} | \\text{unlock()}\\} = W \\]\n\\[ \\text{wobbly } W \\{x := e | e := x\\} = W \\cup \\{x, e\\}^{\\text{fml}} \\]\n\\[ \\text{wobbly } W \\{x := \\text{new()}\\} = W \\cup \\{x\\}^{\\text{fml}} \\]\n\\[ \\text{wobbly } W \\{\\text{push}(e_1, ..., e_n) | \\text{pop()}\\} = W \\]\n\\[ \\text{locking } L \\{x := \\text{new()}\\} | e := x | x := e\\} = L \\]\n\\[ \\text{locking } L \\{\\text{lock()}\\} = \\text{incr}(L) \\]\n\\[ \\text{locking } L \\{\\text{unlock()}\\} = \\text{decr}(L) \\]\n\n\\[ \\text{accs}(A, L) \\{x := y | x := \\text{new()}\\} = A \\]\n\\[ \\text{accs}(A, L) \\{\\text{lock()}\\} = A \\]\n\\[ \\text{accs}(A, L) \\{\\text{unlock()}\\} = A \\]\n\\[ \\text{accs}(A, L) \\{(x := \\pi, L)\\}^{\\text{fml}} = A \\cup \\{(x := \\pi, L)\\}^{\\text{fml}} \\]\n\\[ \\text{accs}(A, L) \\{(\\pi := x, L)\\}^{\\text{fml}} = A \\cup \\{(\\pi := x, L)\\}^{\\text{fml}} \\]\n\n\\[ \\text{locking } L \\{\\text{push}(e_1, ..., e_n) | \\text{pop()}\\} = A \\]\n\n\\[ \\{c\\}^\\circ \\{W, L, A\\} = \\{\\text{wobbly } W \\ c, \\ \\text{locking } L \\ c, \\ \\text{accs } (A, L) \\ c\\} \\]\n\\[ \\{C; c\\}^\\circ \\{W, L, A\\} = [c]^{\\circ}[\\{C\\}^\\circ \\{W, L, A\\}] \\]\n\\[ \\{C; m(e_1, ..., e_n)\\}^\\circ \\{W, L, A\\} = [m(e_1, ..., e_n)]^{\\circ}[\\{C\\}^\\circ \\{W, L, A\\}] \\]\n\\[ \\{C; (\\text{if } \\ast \\ \text{then } C_1 \\ \text{else } C_2\\}^\\circ \\{W, L, A\\} = \\{C_1\\}^{\\circ}[\\{C\\}^\\circ \\{W, L, A\\}] \\cup \\{C_2\\}^{\\circ}[\\{C\\}^\\circ \\{W, L, A\\}] \\]\n\\[ \\{C; \\text{while } \\ast \\ \text{do } C'\\}^\\circ \\{W, L, A\\} = \\{C'\\}^{\\circ}[\\{C\\}^\\circ \\{W, L, A\\}] \\]\n\\[ \\{m(e_1, ..., e_n)\\}^\\circ \\{W, L, A\\} = \\{W', L'', A''\\}, \\text{ where} \\]\n\\[ W'' = W \\cup \\{e_i | \\exists j \\neq i, e_i \\approx e_j\\} \\cup W'[e_1/\\text{arg}_1, ..., e_n/\\text{arg}_n], \\]\n\\[ L'' = \\text{add}(L, L'), \\]\n\\[ A'' = A \\cup \\{(c, \\text{add}(L, L')) | \\{c, L_c\\} \\in A'\\}[e_1/\\text{arg}_1, ..., e_n/\\text{arg}_n] \\]\n\\[ \\{W', L', A'\\} = [\\text{mbody}(m)]^{\\circ}[0, 0, 0) \\]\n\nFig. 7. Definition of the abstract analysis semantics \\([\\cdot]^{\\circ} : D \\rightarrow D\\). We define \\text{add}(L, L') = \\text{min}(L + L', \\hat{L})\\), \\text{incr}(L) = \\text{add}(L, 1), \\text{decr}(L) = \\text{max}(L - 1, 0)\\) and \\(\\hat{L} \\in \\mathbb{N}^+ \\). ¹We define a substitution \\(\\cdot[\\theta] \\) (applied recursively to all syntactic elements) as applying only to the path component of \\(c\\) (eg, \\(\\pi := x[\\theta] = (\\pi[\\theta] := x)\\)). The function \\text{fml} acts as a filter that only selects expressions rooted at formals, i.e., variables of the form \\text{arg}_j, and is extended straightforwardly to sets of elements of \\(A\\), depending on the path component of the command.\n\non the nature of the access (read or write) and the locking context \\(L\\), at which the access has been captured, it might be deemed a race.\n\nSecond, the gathered wobblyness information comes into play. If a path \\(\\pi'\\), which is a proper prefix of \\(\\pi\\), is identified as wobbly by the analysis, a race on \\(\\pi\\), might be a false positive. That is, wobbly paths “destabilise” the future results of the analysis, allowing the real path-underlying values “escape” the race, thus rendering it a false positive—precisely what we are aiming to avoid. Therefore, in order to report only true races, RACERDX removes from the final reports all paths that were affected by wobbly prefixes.\n\nIn Sections 5–6 we establish this completeness guarantee formally, showing that races reported on non-destabilised accesses are indeed true positives, in the sence that there exists a pair of execution traces for a pair method calls of the same class instances that exhibit the behaviour described by Definition 3.5. Furthermore, the evaluation of RACERDX in Section 7 provides practical evidence that the notion of wobblyness does not remove too many reports, that is that the analysis remains efficient while being precise, in the assumptions A1–A6.\n\n5 TOWARDS TP THEOREM, PART I: ANALYSIS COMPLETEENESS\n\nIn this section, we deliver on the first part of the agenda towards True Positive Theorem: the\ndefinition of RACERDX abstraction (wrt. the concrete semantics), and the proof of completeness\nof the analysis with respect to it. That is, informally, if for a program \\(C\\), the analysis \\([C]^{\\circ}\\) repots a certain path \\(\\pi\\) accessed under a locking context \\(L\\), then there exists an initial configuration\n\n\\(\\langle S, h, 0 \\rangle\\) and an execution trace \\(\\tau \\in [C] \\, \\langle S, h, 0 \\rangle\\), such that \\(\\tau\\) contains a command accessing \\(\\pi\\) with a locking context \\(L\\). To establish this, we follow the general approach of the Abstract Interpretation framework (Cousot 1978; Cousot and Cousot 1977), aiming for completeness, i.e., no information loss wrt. chosen abstraction (Ranzato 2013), stated in terms of a traditional abstract transition function and an abstraction from a concrete domain of sets of traces.\n\nWe first formulate the abstraction and prove its desirable properties. The remainder of this formal development in this arc of our story takes a “spiral” pattern, coming in two turns: establish the completeness of the analysis for straight-line programs (turn one), and then lift this proof for the inter-procedural case (turn two). In most of the cases, we provide only statements of the theorems, referring the reader to Appendix A for auxiliary definitions and proofs.\n\n5.1 RACERDX Abstraction for Trace-Collecting Semantics\n\nThe abstraction connects the results of the analyzer to the elements of the concrete semantics, i.e., traces. It is natural to restrict the considered traces and states to such that could indeed be produced by executions. We will refer to them as well-formed (WF) and well-behaved (WB).\n\nDefinition 5.1. An execution trace is well-formed if for each two subsequent states \\(\\zeta_i\\) and \\(\\zeta_{i+1}\\), the stack and heap of \\(\\zeta_{i+1}\\) can be obtained by executing the simple command in \\(\\zeta_{i+1}\\)’s first component with respect to the stack/heap of \\(\\zeta_i\\).\n\nIt is easy to show that for any program \\(C, S, h, L\\) trace \\(\\tau \\in [C] \\, \\langle S, h, L \\rangle\\), \\(\\tau\\) is well-formed.\n\nDefinition 5.2. A program state \\(\\langle \\_ \\_ \\_ \\_ \\rangle, (S_1, S_2), \\_ \\_ \\_ \\_\\_ \\) is well-behaved iff (a) for any \\(s\\) appearing in \\(S_1, S_2\\) and any variable \\(x\\), \\(s(x) \\in \\text{locn}(h)\\), and, (b) for any address \\(a \\in \\text{dom}(h), h(a) \\in \\text{locn}(h)\\).\n\nLemma 5.3 (Preservation of well-behavedness). Let \\(\\tau\\) be a non-empty, well-formed trace, whose starting state is well-behaved. Then, every state in \\(\\tau\\) is well-behaved.\n\nAbstract domain and abstraction function. The analysis’s domain (Definition 4.2) is rather coarse-grained: it does not feature any information about runtime heaps or stacks. To bring the concrete traces closer to abstract summaries, for an execution trace \\(\\tau\\), we define syntactic trace \\(\\tilde{\\tau}\\) as a list, obtained by taking only the first components of each of \\(\\tau\\)’s elements. That is, \\(\\tilde{\\tau} \\triangleq \\text{map}(\\lambda \\, \\langle C, -, -, - \\rangle \\, , \\_ \\_ \\_ \\_ \\_ \\, C \\rangle \\) \\(\\tau\\). We now define the abstraction function \\(\\alpha : \\wp(\\text{T}) \\rightarrow \\mathcal{D}\\), from the lattice of sets of execution traces \\(\\wp(\\text{T})\\) to \\(\\mathcal{D}\\), which corresponds to “folding” a syntactic trace, encoding a run of straight-line program (equivalent to the original program for this particular execution), left-to-right, to an abstract state recursively.\\(^{6}\\)\n\nDefinition 5.4 (Abstraction Function). For a set of well-formed traces \\(T \\subseteq \\mathcal{T}\\),\n\n\\[\n\\alpha(T) = \\bigsqcup_{\\tau \\in T} (\\text{fst} \\, (\\text{exec} \\, \\tilde{\\tau} \\, (\\bot_D, \\epsilon))), \\text{ where } \\bot_D = \\langle \\bot_W, \\bot_L, \\bot_R \\rangle\n\\]\n\nand \\(\\text{exec} : \\mathcal{T} \\rightarrow \\mathcal{D} \\times (\\text{Var} \\rightarrow \\text{tm} \\, \\text{Exp})\\) is defined in Figure 8.\n\nThe \\(\\theta\\) component in the state carried forward by exec is a stack of substitutions (from formals, \\(\\text{arg}_L\\), to paths) which mirrors the call stack in a concrete execution. Whenever an access occurs, the substitutions \\(\\theta\\) are immediately applied, and the result is a path that is rooted at a top-level variable \\(\\text{arg}_L\\). Accesses rooted at local variables (any variable \\(x\\) which is not in the syntactic form \\(\\text{arg}_L\\) or not in the domain of the top-most substitution) are discarded (the substitution function returns an empty set). Similarly, the set \\(W\\) is populated with expressions that have the substitutions \\(\\theta\\) already applied, and similarly discarded if rooted at a local variable.\n\n\\(^{6}\\)We overload the list notation \\(\\tilde{\\tau} \\triangleright c\\) to denote appending a list \\([c]\\) to \\(\\tilde{\\tau}\\), i.e., \\(\\tilde{\\tau} \\triangleright c \\triangleq \\tilde{\\tau} ++ [c]\\).\nFig. 8. An auxiliary function exec for executing syntactic traces to compute RACERDX abstraction.\n\nThe commands push() and pop() accordingly manipulate the substitution stack, while push() also adds certain extra paths to W; this is to avoid the effects of aliasing of paths rooted at different formals inside the method body. That is, paths can become wobbly because parts of the same path have been provided as parameters in a method call, such as in $m(x.f, x.f.g)$. The full reasoning behind this definition will become clearer in Section 6, where it is used in the construction of a memory state where there is exactly one parameter pointing to the heap-image of the racy path.\n\nWe next establish a number of facts about $\\alpha$ necessary for the proof of our analysis completeness.\n\n**Lemma 5.5 (Additivity of $\\alpha$).** $\\alpha$ is additive (i.e., preserves lubs) with respect to $\\cup_\\psi(\\gamma)$ and $\\cup_\\mathcal{D}$.\n\nThanks to Lemma 5.5, we can define the (monotone) Galois connection $\\langle \\psi(\\gamma), \\subseteq \\rangle \\rightleftharpoons \\langle \\mathcal{D}, \\subseteq \\rangle$ between the two complete lattices, where $\\gamma \\triangleq \\lambda a. \\cup \\{ T \\in \\psi(\\gamma) \\mid \\alpha(T) \\subseteq a \\}$ (Cousot and Cousot 1992). Having a Galois connection between $\\psi(\\gamma)$ and $\\mathcal{D}$ in conjunction with completeness of the analysis (Theorem 5.15) allows us to argue for the presence of a certain accesses in some concrete trace of a program $C$, if the analysis reports it for $C$. This is due to the following fact establishing that if $\\alpha$ records an access in a certain trace, then such a path was indeed present in its argument:\n\n**Lemma 5.6 (Path Access Existence).** Let $T$ be a set of traces, $\\alpha(T) = \\langle \\_, \\_, A \\rangle$, and $q = \\langle c, L \\rangle$ (where $c = (x := \\pi)$ or $c = (\\pi := x)$) is a query about the access path $\\pi$ in the locking context $L$. If $q \\in A$ then there exist a trace $\\tau \\in T$ and a non-empty, shortest prefix $\\tau' \\approx \\tau$ such that\n\n- the last state of $\\tau'$ is $\\langle c', \\_, \\_, L \\rangle$ and $c'$, $c$ are both stores or loads;\n- $\\text{exec } \\overset{\\pi}{\\tau'(\\bot)} = (\\langle \\_, \\_, A \\rangle, \\theta)$ where $\\pi \\in A$;\n- a path $\\pi'$ such that $c' = (x := \\pi')$ or $c' = (\\pi' := x)$, and $\\{ \\pi \\} = \\{ \\pi' \\}$.\n\n**Proof.** By the definition of $\\alpha(\\cdot)$ and the properties of $\\cup_\\mathcal{D}$ follows that there must exist a trace $\\tau \\in T$ such that $q \\in \\alpha(\\{ \\tau \\})_A$. By the definition of exec the other elements follow directly. \\qed\n5.2 Proving that the Analysis Loses No Information\n\nWe structure the proof in two stages: first considering only straight-line programs with no method calls (Section 5.2.1) and then lifting it to programs with finite method call hierarchies (Section 5.2.2). We do not consider the cases with recursive calls (cf. Assumption A5).\n\n5.2.1 Intra-procedural case. The abstract transfer function of the analysis for simple commands is defined in Figure 7 as $[c]^\\alpha(W, L, A)$. We first prove the completeness for simple commands for a singleton-trace concrete domain.\n\n**Lemma 5.7 (Analysis is complete for simple commands (per-trace)).** For any non-empty WF trace $\\tau \\in T$, sets $W, A$, number $L$, and a simple command $c$, which is not pop(), such that (a) $\\langle W, L, A \\rangle = \\alpha(\\{\\tau\\})$, (b) $[c]$ last($\\tau$) = $\\{[\\varsigma] | \\varsigma \\text{ is an execution state}\\}$, where last($\\tau$) is the configuration $\\langle S, h, L \\rangle$ of the last element of $\\tau$, the following holds:\n\n$$[c]^\\alpha(W, L, A) = \\alpha \\left( \\bigcup \\{ \\tau : \\varsigma | [\\varsigma] \\in [c] \\text{ last}(\\tau) \\} \\right).$$\n\nThe following result lifts the reasoning of Lemma 5.7 from singletons to sets of arbitrary traces.\n\n**Lemma 5.8 (Analysis of simple commands is complete for sets of traces).** For any set $T$ of non-empty well-formed traces, $W, L, A$, and simple command $c$, which is not pop(), such that (a) $\\langle W, L, A \\rangle = \\alpha(T)$, (b) for any $\\tau \\in T$, $[c]$ last($\\tau$) = $\\{[\\varsigma] | \\varsigma \\text{ is an execution state}\\}$, then\n\n$$[c]^\\alpha(W, L, A) = \\alpha \\left( \\bigcup \\{ \\tau : \\varsigma | [\\varsigma] \\in [c] \\text{ last}(\\tau) \\} \\right).$$\n\nThe fact of preserving the equality of abstract results in Lemmas 5.7 and 5.8 is quite noteworthy: for straight-line programs (and, in fact, for any program in our IL) the analysis is precise, i.e., we do not lose information wrt. locking context, wobbliness, or access paths, and hence can include elements $(c, L)$ into the $A$-component as a part of accs-machinery without the loss of precision.\n\nWe now lift these facts to the analysis for compound programs without method calls. Recall that we only consider programs with balanced locking (Assumption A2), i.e., such that within them:\n\n- the commands lock() and unlock() are only allowed to appear in balanced pairs (including their appearances in nested method calls) within conditional branches and looping statements, and,\n- every unlock() command has a matching lock().\n\nThe following two lemmas are going exploit this fact for proving the analysis completeness.\n\n**Lemma 5.9 (RacerDX analysis and balanced locking).** If $C$ is a compound program with balanced locking, and $\\langle W', L', A' \\rangle = [C]^\\alpha(W, L, A)$. Then $L' = L$.\n\n**Lemma 5.10 (Balanced locking and syntactic traces).** For any program $C$ with balanced locking and well-behaved states $S_1, h_1$ and $S_2, h_2$ and $L \\geq 0$, $\\{\\hat{\\tau} | \\tau \\in [C] \\langle S_1, h_1, L \\rangle\\}) = \\{\\hat{\\tau} | \\tau \\in [C] \\langle S_2, h_2, L \\rangle\\}) \\neq \\emptyset$.\n\nAs a corollary, $\\alpha([C] \\langle S_1, h_1, 0 \\rangle) = \\alpha([C] \\langle S_2, h_2, 0 \\rangle)$.\n\nThe proof of Lemma 5.10 hinges on the following observations:\n\n- Balanced locking ensures that $[\\text{unlock}(\\cdot)] (S, h, L) \\neq \\emptyset$, which the case for any intermediate state of the traces of the programs in consideration.\n- Well-behavedness ensures that the set of traces for loads and stores is non-empty.\n- Well-behavedness is preserved along traces (cf. the semantics of new()).\n\nThat is, for compound programs with balanced lockings the $L$-component of the abstraction remains immutable (by the end of execution) for both $[\\cdot]^\\alpha$ and the abstraction $\\alpha$ over the concrete semantics. The following lemma delivers the completeness in the intra-procedural case.\n**Lemma 5.11.** For any compound program $C$ with balanced locking and no method calls, the starting components $W_0, L_0, A_0$, and a set of well-formed non-empty traces $T$, such that $\\langle W_0, L_0, A_0 \\rangle = \\alpha(T)$, $\\exists C^* \\langle W_0, L_0, A_0 \\rangle = \\{ \\alpha \\left( \\bigcup_{\\tau \\in T} \\{ \\tau \\uplus \\tau' \\mid \\tau' \\in [C] \\text{ last}(\\tau) \\} \\right) \\text{ if } T \\neq \\emptyset, \\alpha \\left( [C] \\langle S, h, 0 \\rangle \\right) \\text{ otherwise, for any well-behaved } S, h,$\n\nwhere last($\\tau$) is well-defined, as $T$ consists of non-empty traces.\n\n**Proof.** By induction on $C$ and Lemma 5.8. Details are in the Proof in Appendix A. □\n\n### 5.2.2 Inter-procedural case\n\nThe main technical hurdle on the way for extending the statement of Lemma 5.8 to an inter-procedural case (i.e., allowing for method calls) is the gap between the semantic implementation of method calls via stack-management discipline (Figure 5) and treatment of method summaries by the analysis, via explicit substitutions (Figure 7). To address this, we introduce the following convention, enforced by RACERDX’s intermediate language representation:\n\n**Definition 5.12 (ANF).** We say that a method $m(\\overline{\\text{arg}_i, \\ldots, \\overline{\\text{arg}_n}})$ is in Argument-Normal Form (ANF), if for every simple command $c$ in its body, $c$ is not of the form $\\pi := \\overline{\\text{arg}_j}$ for some $\\overline{\\text{arg}_j} \\in \\overline{\\text{arg}}$.\n\nIntuitively, this requirement enforces a “sanitisation” of used arguments from the set $\\overline{\\text{arg}}$, so one could substitute them with some (non-variable) paths without disrupting the syntactic structure of a compound program. Let us denote as $WB(e_1, \\ldots, n)$ the set of paths $\\{e_i, e_j \\mid i \\neq j, e_i \\preceq e_j\\}$ for $i \\in \\{1 \\ldots n\\}$. We will also denote via $\\bigcup_1$ the following operation on $D$:\n\n$$\\langle W', L, A \\rangle \\bigcup_1 W' = \\langle W \\cup W', L, A \\rangle.$$\n\nThe following lemma accounts for the mentioned concrete/abstract discrepancy in treatment of methods, allowing us to reformulate the definition of abstract method summaries returned by the analyzer ($\\langle [m(\\overline{e_i, \\ldots, e_n})]^* \\langle W, L, A \\rangle \\rangle$) via substitutions of their bodies.\n\n**Lemma 5.13 (ANF and method summaries).** For a method $m$, a vector of expressions $e_1, \\ldots, e_n$, a configuration $\\langle S, h, L \\rangle = \\text{last}(\\tau)$ such that\n\n- $\\forall i, 1 \\leq i \\leq n, [e_i], s, h$ are defined, and\n- $\\text{mbody}(m)$ has no nested calls and features well-balanced locking, the following holds:\n\n$$\\langle [m(e_1, \\ldots, e_n)]^* \\langle W, L, A \\rangle \\rangle = \\langle W', L', A' \\rangle \\bigcup_1 \\text{WB}(e_1, \\ldots, n), \\text{ where}$$\n\n$$\\langle W', L', A' \\rangle = \\langle \\text{mbody}(m)\\{e_i/\\overline{\\text{arg}_i}\\})^* \\langle W, L, A \\rangle \\rangle$$\n\nThe first Good Thing afforded by Lemma 5.13 is the removal of substitutions from the $W$ and $A$ components and moving them to the method’s body, which will give the uniformity necessary for conducting the forthcoming proofs. The second Good Thing is the given possibility to “shift” the computation of the method summary from the $\\bot_D = \\langle 0, 0, 0 \\rangle$ (as given by Figure 7) to the actual abstract context $\\langle W, L, A \\rangle$. Finally, notice that in the absence of recursion, the statement of Lemma 5.13 can be generalised to methods with nested calls, with the proof by induction on the size of the call tree.\n\nArmed by Lemma 5.13 (generalised to nested calls), we can prove analogues of Lemmas 5.7–5.11. In the presence of method calls, the formal development first establishes the result for a singleton trace, similar to Lemma 5.7 for a program with no nested method calls, then lifting it, by induction on the size of the call graph, to arbitrary non-recursive call hierarchies. It is then further generalised for sets of traces, in a way similar to the proof of Lemma 5.7. For the sake of saving space, we do not present the statements of these lemmas here (as they are not particularly remarkable or pretty) and refer the reader to Appendix A for auxiliary definitions and proofs. This arc of formal results concludes with the following statement, similar to Lemma 5.11:\nLemma 5.14. For any compound program $C$ with balanced locking and all methods in ANF, the analysis domain components $W_0$, $L_0$, $A_0$, and a set of well-formed non-empty traces $T$, such that $\\langle W_0, L_0, A_0 \\rangle = \\alpha(T)$,\n\n$$[C]^{\\ast} \\langle W_0, L_0, A_0 \\rangle = \\begin{cases} \\alpha \\left( \\bigcup_{T \\in \\mathcal{T}} \\{ \\tau \\mapsto \\tau' | \\tau' \\in [C] \\text{ last(}\\tau\\text{)} \\} \\right) & \\text{if } T \\neq 0, \\\\ \\alpha ([C] \\langle S, h, 0 \\rangle) & \\text{otherwise, for any well-behaved } S, h, \\end{cases}$$\n\nwhere last($\\tau$) is well-defined, as $T$ consists of non-empty traces.\n\n5.2.3 Main completeness result. We are now ready to establish the completeness of the abstract semantics $[\\cdot]^{\\ast}$ of our analysis wrt. trace-collecting semantics $[\\cdot]$ and abstraction $\\alpha$.\n\nTheorem 5.15 (Completeness of RacerDX analysis.). For any compound program $C$ with all methods in ANF, balanced locking, and well-behaved $S, h$,\n\n$$[C]^{\\ast} \\perp_D = \\alpha ([C] \\langle S, h, 0 \\rangle).$$\n\nProof. Follows immediately from Lemma 5.14 by taking $\\langle W_0, L_0, A_0 \\rangle = \\perp_D$, $T = \\emptyset$. ☐\n\n6 TOWARDS TP THEOREM, PART II: RECONSTRUCTING RACY TRACES\n\nHere we show how, given a pair of programs $C_1$, $C_2$ for which RacerDX reports a race, we construct a concurrent trace (as defined in Figure 6) that exhibits the race, in the sense of Definition 3.5.\n\nWe crucially rely on the notion of stability (non-wobblyness): an access path $\\pi$ is stable if no proper prefix of $\\pi$ is ever read or written. We track the negation of this property through the $W$ component of the abstract state, which is slightly complicated by our need to track accesses to proper prefixes of $\\pi$ even inside procedure calls, and thus employ substitutions of actuals over formals (cf. the definition of exec for load/stores and calls). Note that stability does not preclude accesses to the path itself. Stability allows us to prove that the backbone of a path (the domain of its heap-image) is preserved during execution, and thus when the path is accessed at the end of a trace for $C_1/C_2$, the same address in both threads is accessed.\n\nHowever, not all traces of $C_1/C_2$ will allow us to do this. For this reason we introduce the notions of path disconnectedness and acyclicity, two semantic restrictions that ensure that accesses through paths syntactically distinct to $\\pi$, and suffixes of $\\pi$ respectively, do not affect the heap-image of $\\pi$.\n\nDefinition 6.1 (Prefix). An access path $\\pi = x.\\bar{f}$ is a prefix of $\\pi' = y.\\bar{g}$ if $x = y$ and the sequence $fs$ is a prefix of $gs$. We denote this fact by $\\pi \\preceq \\pi'$. The notion of proper prefix ($<$) is straightforward. We lift this to expressions by fixing $x < x.\\bar{f}$ and $x \\ll x$.\n\nThe root of an access path $x.\\bar{f}s$ is $x$, i.e., $\\text{root}(x.\\bar{f}) = x$. If $\\pi = x.\\bar{f}$, we may write $\\pi.g$ or $x.\\bar{f}.g$ to mean $x.(\\bar{f}.g)$. We set $|x.\\bar{f}| = |\\bar{f}|$, i.e., the length of the field list.\n\nDefinition 6.2 (Path Footprint). Let $s, h$ be a state where $[\\pi]_{s, h}$ is defined. Define the footprint of $\\pi$, denoted $h_{\\pi}^s$, as\n\n$$h_{\\pi}^s = \\bigcup_{\\pi' \\ll \\pi} \\{ [\\pi']_{s, h} \\mapsto h([\\pi']_{s, h}) \\}.$$\n\nIntuitively, the footprint of an access path contains all addresses necessary to resolve the address of the path, inclusive. It’s easy to see that\n\n$$\\text{dom}(h_{\\pi}^s) = \\{ [\\pi']_{s, h} | \\pi' \\ll \\pi \\}.$$ \n\nDefinition 6.3 (Disconnectedness). A path $\\pi$ is disconnected in a state $s, h$ if $[\\pi]_{s, h}$ is defined, and\n\n- for any $x \\neq \\text{root}(\\pi)$, $s(x) \\notin \\text{locn}(h_{\\pi}^s)$;\n- for all $\\alpha \\in \\text{dom}(h)$, if $h(\\alpha) \\in \\text{locn}(h_{\\pi}^s)$ then $\\alpha \\in \\text{dom}(h_{\\pi}^s)$.\nA True Positives Theorem for a Static Race Detector\n\n\\[ \\tau \\]\n\nDefinition 6.4 (Acyclicity). A path \\( \\pi \\) is acyclic in state \\( s, h \\) if \\([\\pi]_{s, h}\\) is defined, and for any two paths \\( \\pi'', \\pi' \\preceq \\pi \\), \\( h([\\pi']_{s, h}) \\neq \\text{locn}([\\pi'']_{s, h}) \\).\n\nDefinition 6.5 (Path preservation). Let \\( \\pi \\) be a path, and \\( s, h \\) and \\( s', h' \\) two states. We say that \\( \\pi \\) is preserved from \\( s, h \\) to \\( s', h' \\) if\n\n1. \\( \\pi \\) is disconnected and acyclic in \\( s, h \\) and \\( s', h' \\);\n2. \\( s(\\text{root}(\\pi)) = s'(\\text{root}(\\pi)) \\);\n3. \\( \\text{dom}(\\pi_{s, h}^+) = \\text{dom}(\\pi_{s', h'}^+) \\);\n4. \\( \\forall \\alpha \\in \\text{dom}(\\pi_{s, h}^+) \\setminus \\{[\\pi]_{s, h}\\}, h(\\alpha) = h'(\\alpha) \\).\n\nLemma 6.6. Let \\( \\tau \\) be an access path and \\( \\tau \\) a WF, non-empty trace without any push()\\text{}/\\text{pop()} commands, whose starting state \\( \\langle \\text{skip}, s_0 :: S, h_{\\text{root}} \\rangle \\) is well-behaved, and where \\( \\pi \\) is acyclic and disconnected in \\( s_0, h_0 \\). Let the last state of \\( \\tau \\) be \\( \\langle \\_, s' :: S, h', \\_ \\rangle \\).\n\nIf it is the case that \\( \\forall e \\in \\alpha(\\{\\tau\\}) \\text{\\_\\_}. e \\not\\in \\pi \\), then \\( \\pi \\) is preserved from \\( s_0, h_0 \\) to \\( s', h' \\).\n\nProof. By induction on the length of \\( \\tau \\) and results on stability. See Appendix B for details of the proof. \\( \\square \\)\n\nWe can now lift this up to the trace of a single, non-nested procedure call.\n\nLemma 6.7. Suppose that \\( \\text{mbody}(m) \\) has no procedure calls, that \\( \\pi \\) is an access path which is disconnected and acyclic in the well-behaved state \\( s, h \\), that \\( \\tau \\in [\\text{skip}; m(e)](s, h, L) \\) is a non-empty trace, that last(\\( \\tau \\)) = \\( \\langle \\text{pop()}, s, h', \\_ \\rangle \\), that \\( \\alpha(\\{\\tau\\}) = \\langle W, \\_\\_ \\rangle \\), and that \\( \\forall e \\in W. e \\notin \\pi \\).\n\nThen, \\( \\pi \\) is preserved from \\( s, h \\) to \\( s', h' \\).\n\nProof. First, notice that \\( \\forall e \\in W. e \\notin \\pi \\) and the definition of \\( \\text{exec} \\) implies there is at most one \\( e_i \\) such that \\( e_i = z \\), or \\( e_i = \\pi_1 < \\pi \\). We then analyse the three cases separately: no \\( e_i < \\pi \\), \\( e_i = \\text{root}(\\pi) \\) and \\( e_i < \\pi \\). The most interesting is the last one, where we cut out the subheap of \\( h \\) reachable from the arguments, apply Lemma 6.6 to it, and then restore the facts we prove back to the top-level stack. Notably, here we use the frame property at the semantics level (Yang and O’Hearn 2002). \\( \\square \\)\n\nWe can further lift the preservation result to traces that have arbitrarily nested procedure calls.\n\nLemma 6.8. Let \\( \\tau \\) be a WF, non-empty trace with matched push()\\text{}/\\text{pop()} pairs, whose first state is \\( \\langle \\text{skip}, s, h', \\_ \\rangle \\) and last(\\( \\tau \\)) = \\( \\langle \\_, s' :: S, h', \\_ \\rangle \\). Let \\( \\pi \\) be an access path which is disconnected and acyclic in the well-behaved state \\( s, h \\), that \\( \\alpha(\\{\\tau\\}) = \\langle W, \\_\\_ \\rangle \\), and that \\( \\forall e \\in W. e \\notin \\pi \\).\n\nThen, \\( \\pi \\) is preserved from \\( s, h \\) to \\( s', h' \\).\n\nProof. By induction over subtraces corresponding to method calls, using Lemma 6.7. \\( \\square \\)\n\nWhile we have shown that a stable path is preserved along a trace, this only applies to balanced pairs of push()\\text{}/\\text{pop()} commands in the trace. However, the racy access may occur inside a chain of procedure calls, thus we need to further show that a stable path propagated through the call stack is also preserved, up to the point of access.\n\nLemma 6.9. Let \\( \\tau \\) be a (prefix) trace produced by Lemma 5.6. If additionally it is the case that \\( \\forall e \\in \\alpha(\\{\\tau\\}) \\text{\\_\\_}. e \\notin \\pi \\) then \\([\\pi]_{s, h} = [\\pi']_{s', h'} \\).\n\nProof. We split \\( \\tau = \\tau_1 + \\tau_\\text{push} + \\tau_0 \\) on the last unmatched push() command, and apply Lemma 6.8 to \\( \\tau_0 \\), showing that \\( \\pi' \\) is preserved. Then, we lift \\([\\pi']_{s', h'} \\) to the parent call stack and identify the\n\nargument \\( e_j \\) such that \\( \\text{root}(\\pi') = \\text{arg}_j \\). Then, we repeat the process for \\( e_j \\) as \\( \\pi' \\) up to the top-level stack. See Appendix B for details of the proof.\n\nWe are ready to state the main result of this section and the whole paper.\n\n**Theorem 6.10 (True Positives Theorem).** Let \\( C_1, C_2 \\) be two programs such that \\([C_i]^* \\downarrow_D = \\langle W_i, \\ldots, A_i \\rangle \\). Let \\( \\pi_i \\) be two paths and \\( c_i \\) two commands such that \\( \\langle c_i, L_i \\rangle \\in A_i \\), and,\n\n- \\( \\pi_1 = \\pi_1 \\hat{c} \\) and \\( \\pi_2 = \\pi_2 \\hat{c} \\) (i.e., the field sequences are the same);\n- \\( \\forall e_i \\in W_i, e_i \\not\\prec \\pi_i \\) (for \\( i \\in \\{1, 2\\} \\));\n- \\( c_1 = (\\pi_1 := x) \\) and \\( c_2 = (\\pi_2 := y) \\), or, \\( c_1 = (\\pi_1 := x) \\) and \\( c_2 = (y := \\pi_2) \\);\n- \\( L_1 + L_2 \\leq 1 \\).\n\nThen there exists a well-behaved state \\( \\zeta = \\langle (s_1, s_2), h, (0, 0) \\rangle \\) and a concurrent trace \\( \\tau \\rangle \\in \\langle [C_1 || C_2] \\rangle \\) that races.\n\n**Proof.** We sketch the important intuitions behind the proof. For more details, see Appendix B.\n\nBy assumption, one of \\( L_1 = 0 \\) or \\( L_2 = 0 \\), so w.l.o.g., we set \\( L_1 = 0 \\). This means that when \\( C_1 \\) accesses the path \\( \\pi \\), it is not holding the lock.\n\nWe first construct a special initial state, where both programs “see” the same path on the shared heap, and where that path is acyclic and disconnected.\n\nWe then obtain a partial trace \\( \\tau_1 \\) of \\( C_1 \\) as ordained by Lemma 5.6, that ends just before committing an access to \\( \\pi \\).\n\nWe further show that the final state of that trace satisfies the preconditions of Lemma 5.6 for \\( C_2 \\) thus obtaining a trace \\( \\tau_2 \\) that picks up from where \\( \\tau_1 \\) finished.\n\nWe weave \\( \\tau_1 \\) and \\( \\tau_2 \\) into a concurrent trace by letting \\( C_1 \\) progress until it reaches the end of \\( \\tau_1 \\), and then \\( C_2 \\) progresses until the end of \\( \\tau_2 \\). Crucially, this schedule is realisable because of the above observation that \\( C_1 \\) isn’t holding the lock.\n\nWe finally use Lemmas 6.8–6.9 to show that the path is preserved to the concurrent trace’ final state, and that the path each thread sees through its call stack resolves to the same address.\n\n7 IMPLEMENTATION AND EVALUATION\n\nIn the previous sections we laid out the design of a theoretical analyser that is similar to RacerD, but which enjoys the True Positives property: under certain assumptions, reports from the theoretical analyser proposed here, are true positives. But that still does not address the effectiveness of the new analyser: we would like to know would an implementation of RacerDX be\n\n1. effective, in that it reports a sufficient proportion of reports which RacerD generates;\n2. efficient, in that it is not significantly slower than RacerD.\n\nWe implemented the proposed analyser as a modification of RacerD. The implementation was relatively straightforward: it required less than 1kLOC of OCaml code, and used data structures and algorithms that are either standard or come with the Infer analyser.\n\nWe next discuss the differences between the two analysers.\n\n7.1 Differences between RacerD and RacerDX\n\nThe main difference between RacerD and RacerDX is in substituting the ownership domain of the former with that of stability.\n\nNewly allocated objects in Java are known only to the caller of `new`. Thus, it is not possible for two threads to race on a newly allocated object, unless the address of that object flows into some shared location (basically, the heap). In addition, accesses to fields of the newly allocated object cannot possibly participate in a data race, for much the same reasons. RacerD uses a notion of\nownership typing to track access paths which have been obtained through allocation, in an effort to avoid the associated false positives.\n\nRACERDX swaps the whole abstract domain of ownership for that of stability. This substitution is logically warranted by the fact that allocation immediately destabilises all paths extending that of the receiver. For instance, in the code `x.b = new Bloop(); x.b.f = 1;` the access at `x.b.f` will not be reported by RACERDX because `x.b ≺ x.b.f`, and `x.b` will have been recorded in the `W` component of the analysis state.\n\n7.2 Differences between Theoretical Analyser and its Implementation\n\nMathematical formulations of static analysers typically deal with a simplified language and a simplified semantics for reasons of simplicity and clarity. Their implementations, in so far as the target is a real programming language on a real concrete semantics, usually are not one-to-one renditions of the math in code. Here we examine some of the differences between the formal model of RACERDX and its implementation. Some of these differences are directly inherited from RACERD; these include a treatment of pure procedures (aided by programmer annotations); support for confining a set of accesses in a specific thread (for instance, a UI thread) such that no lock is required to avoid interference; static and volatile types; inheritance, and others.\n\nThe parts of RACERD we had to specifically modify for stability, and which constitute a complex feature not present in the formal model of RACERDX include:\n\n- **Global variables:** These clearly do not fit the model of RACERDX, as they do not behave as formals. We model them in the implementation as paths that never undergo substitution, and are never destabilised. This means that any access to them not under synchronisation may be reported in the context of a race.\n\n- **Constructors:** A constructor cannot normally race on the freshly created object. To avoid the obvious false positives, we treat `this` as always unstable when inside a constructor. Thus, `this ∈ W` and therefore any statement that initialises a member field will not be reported because `this ≺ this.f` for any field `f`. Note that this allows potential false negatives in the case where the address of `this` (or some path starting at `this`) escapes the constructor.\n\n- **Containers:** Such objects are treated specially by RACERD, because they are usually opaque (live in libraries) and because the model they expose is much simpler than their implementation. For instance, an addition of an element to an `ArrayList` at the path `this.arrayList` will be treated as a store, for the purposes of thread safety. However, RACERDX needs to distinguish between accesses to the container itself and accesses that manipulate the contents, for instance `this.arrayList = f()` and `this.arrayList.get(0)`. The way this is achieved is through a dummy field that is read/written to when an element is read/added from/to the container.\n\n7.2.1 Analysing Open-Source Projects. We obtained six open-source Java projects and run them under RACERD and RACERDX, recorded their total CPU time cost and data race reports. The test environment was Linux 4.11, running on a server with 56Gb of RAM, on an Intel CPU at 2.5GHz. Results are shown in Table 1b. The total CPU time of each tool (in seconds) and the proportion of their difference are given in the columns \"D CPU\", \"DX CPU\", \"CPU ±%\".\n\nAn access path may be accessed at a set of locations. In the worst case where these accesses are racy, we may end up with a number of reports that is quadratic in the number of locations. RACERD and RACERDX both have de-duplication capacities to avoid spamming developers, thus selecting a subset of races. Since, for the purposes of the evaluation, this selection is arbitrary, we deactivated de-duplication in both tools to ease the comparison. We checked that RACERDX never introduces reports, that is, if RACERDX makes a particular report then RACERD always makes the\n(a) Evaluation targets.\n\n<table>\n<thead>\n<tr>\n<th>Project</th>\n<th>Description</th>\n<th>URL</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>avrora</td>\n<td>An AVR emulator</td>\n<td><a href=\"https://github.com/ibr-cm/avrora\">https://github.com/ibr-cm/avrora</a></td>\n</tr>\n<tr>\n<td>Chronicle-Map</td>\n<td>A non-blocking key-value store</td>\n<td><a href=\"https://github.com/OpenHFT/Chronicle-Map\">https://github.com/OpenHFT/Chronicle-Map</a></td>\n</tr>\n<tr>\n<td>jvm-tools</td>\n<td>Tool for JVM troubleshooting and profiling</td>\n<td><a href=\"https://github.com/aragozin/jvm-tools\">https://github.com/aragozin/jvm-tools</a></td>\n</tr>\n<tr>\n<td>RxJava</td>\n<td>Library for asynchronous and event-based programs</td>\n<td><a href=\"https://github.com/ReactiveX/RxJava\">https://github.com/ReactiveX/RxJava</a></td>\n</tr>\n<tr>\n<td>sunflow</td>\n<td>Rendering system for photo-realistic image synthesis</td>\n<td><a href=\"https://github.com/fpsunflower/sunflow\">https://github.com/fpsunflower/sunflow</a></td>\n</tr>\n<tr>\n<td>xalan-j</td>\n<td>XSLT processor</td>\n<td><a href=\"https://github.com/apache/xalan-j\">https://github.com/apache/xalan-j</a></td>\n</tr>\n</tbody>\n</table>\n\n(b) Evaluation results. CPU columns are in seconds; Reps are distinct reports; $\\pi$ are distinct paths.\n\n<table>\n<thead>\n<tr>\n<th>Target</th>\n<th>LOC</th>\n<th>D CPU</th>\n<th>DX CPU</th>\n<th>CPU ±%</th>\n<th>D Reps</th>\n<th>DX Reps</th>\n<th>Reps ±%</th>\n<th>D $#\\pi$</th>\n<th>DX $#\\pi$</th>\n<th>$#\\pi$ ±%</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>avrora</td>\n<td>76k</td>\n<td>103</td>\n<td>102</td>\n<td>0.4%</td>\n<td>143</td>\n<td>92</td>\n<td>36%</td>\n<td>78</td>\n<td>38</td>\n<td>51%</td>\n</tr>\n<tr>\n<td>Chronicle-Map</td>\n<td>45k</td>\n<td>196</td>\n<td>196</td>\n<td>0.1%</td>\n<td>2</td>\n<td>2</td>\n<td>0%</td>\n<td>2</td>\n<td>2</td>\n<td>0%</td>\n</tr>\n<tr>\n<td>jvm-tools</td>\n<td>33k</td>\n<td>106</td>\n<td>109</td>\n<td>-3.6%</td>\n<td>30</td>\n<td>26</td>\n<td>13%</td>\n<td>14</td>\n<td>11</td>\n<td>21%</td>\n</tr>\n<tr>\n<td>RxJava</td>\n<td>273k</td>\n<td>76</td>\n<td>69</td>\n<td>9.2%</td>\n<td>166</td>\n<td>134</td>\n<td>19%</td>\n<td>65</td>\n<td>44</td>\n<td>32%</td>\n</tr>\n<tr>\n<td>sunflow</td>\n<td>25k</td>\n<td>44</td>\n<td>44</td>\n<td>-1.4%</td>\n<td>97</td>\n<td>42</td>\n<td>57%</td>\n<td>116</td>\n<td>38</td>\n<td>67%</td>\n</tr>\n<tr>\n<td>xalan-j</td>\n<td>175k</td>\n<td>144</td>\n<td>137</td>\n<td>5.0%</td>\n<td>326</td>\n<td>295</td>\n<td>10%</td>\n<td>135</td>\n<td>94</td>\n<td>30%</td>\n</tr>\n</tbody>\n</table>\n\nThe same report too. We show the number of race reports for both tools and the proportion of the difference in the columns “D Reps”, “DX Reps” and “Reps ±%”.\n\nTo further elucidate the fundamental differences, we extracted the access path $\\pi$ a race report identifies, and counted how many unique paths are reported by each tool. Again, we found that RACERDX never reports a path not also reported by RACERD. We show the number of paths reported in the columns “D $\\#\\pi$”, “DX $\\#\\pi$” and the proportion of the difference in “$\\#\\pi$ ±%”.\n\nWe can make the following observations:\n\n- The difference between runtimes is largely within the noise margins, especially given that a large percentage of these runtimes is spent compiling Java source into bytecode, as Infer extracts an AST from the compiled artefact.\n- The loss in terms of number of reports ranges between 10% and 57% (we exclude Chronicle-Map as there are too few reports to start with), and the loss in terms of number of distinct access paths ranges from 21% to 67%.\n\n7.2.2 The Causes for Deterioration of Reporting Rate. We triaged a sample of reports that RACERD made but RACERDX didn’t. We discerned two main classes of reports:\n\n- In a call this.foo(this.f), the check whether one of the actuals is a proper prefix of another (Figure 7, method call case) fails because this≺this.f. Thus, this is marked as unstable (is added to the W component of the abstract state). But this means that all accesses in the caller method will not be considered in data race reports, leading to potential false negatives.\n- Inner (nested) classes are common in Java, and allow methods of an inner class object to reference fields and methods of the containing class. To achieve this, the compiler inserts in the inner class a hidden reference to the outer class object, and initialises this appropriately at construction. Unfortunately, this also means that the this reference of the outer class is marked as unstable whenever an inner class object is constructed, thus precluding accesses occurring in the enclosing method from being reported.\nFig. 9. The aspects of a race analyzer: abstraction coverage, language features, and semantic assumptions.\n\nRemarkably, all the reports we triaged were true positives. Both of these classes of missing reports may benefit from elaborating the stability abstract domain to track escaping references, i.e., when a path is read it is not immediately marked as unstable, but only when the address read ends up being stored somewhere. This is something we will investigate in further work.\n\n8 DISCUSSION AND RELATED WORK\n\nIn this section we place RacerDX in the field of static race detectors that have been subjected to formal analysis. Since the majority of the static race analyzers used in industry—ThreaDSafe (Atkey and Sannella 2015), Coverity’s analysis suite (Chou 2014), and RacerD (Blackshear et al. 2018)—despite being impactful in practice, do not come with any formal theorem about their algorithm, we focus on the only two race analyzers we know of, for which a formal statement has been made: Chord (Naik et al. 2006; Raghothaman et al. 2018) and RacerDX.\n\nChord is a tool which strives to be sound, or to favour reduction of false negatives over false positives. Note that our discussion should not be interpreted as providing value judgements on RacerDX versus Chord. Neither tool has been proven to be effective in engineering practice; we think of both as exemplars of points in the design space which might be built upon or learned from in the construction of new analyzers that are useful in practice in the future.\n\nThe notion of soundness is a standard one: the results of an analysis model all possible executions of the program wrt. certain behaviors of interest, e.g., uncaught exceptions, memory leaks, etc. This is the concept of over-approximation. A consequence of an over-approximation result is that if an analyzer claims that there are no bugs then there are none. However, if the program is buggy, soundness does not guarantee that all bugs will be reported. Type systems are good examples of sound analyses that do not report all type errors for buggy programs.\n\nRacerDX, on the other hand, is an example of a static analysis that favours reduction of false positives over false negatives. It aims to be complete, to report only true races, under certain assumptions. A series of diagrams, shown in Figure 9, illustrate specific aspects of the analysis design space and depict the notions of over-of-under and under-of-over approximation from the introduction. We discuss each of the diagrams.\n\n• Abstraction Coverage. The left part of Figure 9 demonstrates the relative positioning of claims by Chord and RacerDX. Chord strives to compute an over-approximation, so that its data race reports should be a superset of the races than can occur in program executions. In contrast,\nRACERDX targets under-approximation, computing a subset of the real races, which is what our True Positives Theorem addresses.\n\n- **Language Features.** Claims about unconditional absence of false negatives or false positives made with regard to an industrial-scale project and a realistic programming language (e.g., Java), are often false for particular analyzers, even if their designs are guided by considerations of soundness or completeness. The set of choices of which language features to model faithfully or to ignore, which we refer to as context, affects both the soundness and completeness claims, and frame the analysis’ claims, serving as signs of warning to the analysis’ users. The “Soundiness” movement (Livshits et al. 2015) mandates the designers of new static analyses to make the context explicit and offers a list of likely causes of unsoundness in popular languages and runtimes. Similarly, for analyzers aiming at completeness the context should be made explicit. As an example, the central part of Figure 9 shows a selection of features, framing the claims made for Chord (with extensions to its points-to analysis component by Naik and Aiken (2007)) and RACERDX, correspondingly. In the latter case, it corresponds to the assumptions A1–A5 we made in Section 3.\n\n- **Semantic Assumptions.** The main reasons for having the claims framed properly with regard to the context, is to make sure that the class of the programs satisfying the context assumptions, can be faithfully represented by a semantics, with respect to which the soundness or completeness claims were established. But the choice of the semantics itself, as well as non-language-specific assumptions, is rarely questioned, or exercised to the advantage of the analysis designer. For instance, a soundness result for a data race analysis, proven modulo a rigorously stated context, can be invalidated if, for instance, one assumes a version of a relaxed-memory semantics (Kang et al. 2017) instead of more traditional sequential consistency (Lamport 1979). At the same time, a completeness result would be simpler to establish in this setting, as it would allow one to choose from more program behaviors! The right part of Figure 9 depicts this remarkable variance of the soundness/completeness results with regard to the chosen foundations, determining the set of allowed behaviors and inputs.\n\nAn analysis aiming for soundness will be easier to prove in a more restrictive semantics and in closed-world assumptions, which is the case for CHORD. In contrast, a formal result for an analysis aiming for completeness (e.g., RACERDX) will be easier (or even possible) to state in a less restrictive, possibly non-deterministic semantics (such as what we assumed via A6), in the presence of an open world assumption (which, in our case, was actively exploited in proofs in Sections 5 and 6).\n\nAs far as we are aware, this observation is novel, although in retrospect not very surprising.\n\nIn the framework of Figure 9, our True Positives Theorem delivers wrt. claims on relating to the set of unwelcome behaviors (No-False-Positives), framed within a particular context wrt. supported language features (assumptions A1–A5) for carefully chosen relaxed semantic assumptions A6.\n\n**Over-of-Under and Under-of-Over.** In the light of the suggested classification the over-of-under and under-of-over characterization of an analyzer is a matter of positioning the claims and choosing the foundations. Analyzers claiming a version of soundness to prevent bugs, such as CHORD, typically establish this in somewhat restricted foundations (e.g., sequentially-consistent semantics with no non-determinism, closed-world assumptions), but over-approximates the set of unwelcome behaviors, therefore delivering the over-of-under result. Conversely, analyzers aiming for completeness to detect bugs, such as RACERDX, choose to consider a more relaxed semantics, while\n\n---\n\n7 However, we avoid inventing a new term, as both soundiness and completeness-relative-to-assumptions are special cases of use of existing concepts (under- and over-approximations) from abstract interpretation.\nunder-approximating the set of the bugs that they can report, going only for high-confidence ones, which corresponds to the under-of-over result.\n\nRegardless of whether the over-of-under or under-of-over approach is chosen, how can one rigorously validate the set of choices made with regard to the supported features and semantic assumptions? In the case of soundness claims, one can instrument code with checks that reflect the sources of deliberate unsoundness (Christakis et al. 2015) and compute the fraction of the code that is analyzed soundly. Another way, which, in our experience, worked well for completeness/TP claims, is to instrument the analysis itself, so that it would not report bugs that it is not absolutely adamant about—precisely what is achieved by our notion of wobbliness/stability from Section 4.8\n\nRelevance of Theory. How can we establish that the formal analysis of an analyzer is relevant in practice, especially when the contextual assumptions for its theorems might be violated?\n\nFor analyzers that come with a proof of soundness, the criterion often used is that of precision, i.e., that the analyzer does not report too many false positives. The rate of true positives can be improved by chaining the main analysis with a suitably tailored pre-analysis (Oh et al. 2014), or by involving a user into the loop and taking her feedback into account (Raghothaman et al. 2018).\n\nOur approach, which addresses this challenge for a completeness-style analyzer, is a complementary one and assesses whether the analysis’s generality does not deteriorate (i.e., whether it does not ignore too many plausible bugs). To do this, we conducted an empirical comparison to an already deployed tool, which has been considered highly impactful by industry standards (Blackshear et al. 2018), and demonstrate that a rigorously proven version does not do too much worse (Section 7).\n\n8.1 Theorems for Completeness-oriented Race Detectors\n\nSeveral results on proven dynamic concurrency analyses have been published recently. The pioneering work by Sadowski et al. (2008) described a partial verification of some properties of the Velodrome (Flanagan et al. 2008) dynamic atomicity checker, but considered only a model of the algorithm, not its actual implementation. The work by Mansky et al. (2017) formalized the notion of run-time data races on memory locations and proved the soundness and completeness of the specification rules for a number of idealized implementations of race detection analyses, including FastTrack (Flanagan and Freund 2009). Finally, Wilcox et al. (2018) verified a more realistic implementation of FastTrack, showing that it is as fast as or faster than existing state-of-the-art non-verified FastTrack implementation.\n\nThe paper (Blackshear et al. 2018) compares RacerD to several dynamic analyses. We are not making claims here about the relative usefulness of the dynamic and static techniques, except to say that they have often been found to be complementary.\n\nTo the best of our knowledge, our result is the first formal proof of a No-False-Positives property for a static concurrency analysis. In this section we have not compared to data race detectors such as Coverity and RacerD which are purposely unsound and which do not come with a formal statement clarifying the properties that they establish. However, these analyzers deliver useful results, and Coverity’s usefulness has been substantially proven in engineering practice. Like RacerD and RacerDX, they favour reduction of false positives over false negatives. Unlike RacerD and RacerDX, they employ heuristics to weed out likely false positives. But, we see no reason why analysis techniques similar to Coverity and RacerD could not be accompanied by formal statements about their algorithms and even heuristics, perhaps in the standard setup of abstract interpretation via sequences of over- and under-approximations as here.\n\n8That said, wobbliness does not account for all of our language features, such as, e.g., well-scoped locking (A2).\n8.2 Proving Static Analyzers Complete\n\nThe subject of completeness is well-studied in the Abstract Interpretation community in the context of over-approximating (soundness) analyzers. For instance, the work by Ranzato (2013) demonstrates how completeness can be crucial for designing static analyzers for a number of common intra-procedural properties (e.g., signs, constant propagation, polyhedra domains, etc), encouraging one to reason about the completeness properties of their underlying abstract domains. Giacobazzi et al. (2015) go even further, providing a proof system for showing that the result of a certain analysis on a particular given program is precise. Those works address mostly numerical properties. As far as we know, our work is the first to address completeness of an abstraction and a single-threaded abstract semantics for detection of concurrent races.\n\n9 CONCLUSIONS\n\nIn this paper we have formulated and proven a True Positives Theorem for an idealized static race detector, motivated by one that has been proven to be effective in production at Facebook. We have also provided an empirical evaluation of the distance between the idealized analyzer and the in-production version.\n\nIt is important to emphasize that we don’t view the True Positives Theorem as something that provides guarantees to programmers. Rather, it clarifies to the analysis designer the nature of the analysis algorithm: its purpose is to provide understanding and guide design of current and future analyzers. This kind of role of semantics is complementary to the goal of providing guarantees for analyses after they have been set in stone. Indeed, the theorem was not formulated before Blackshear et al. (2018) implemented RacerD, as a specification for them to meet. Rather, the theorem arose in response to the fact that the tool did not satisfy a standard over-approximation (soundness for bug prevention) or under-approximation (completeness, or soundness for testing) result, and yet was effective in practice. And, as we mentioned, the statement of the theorem did apparently even have some impact on the further development of RacerD.\n\nWe have not formulated a general theory for the TPT theorem, into which many analyzers would fit. The reason is not that we can’t see how to make some such theory, but rather that we are being careful not to engage in quick generalisation from few examples from practice. Beyond the shape of the TPT theorem (over-of-under), the more significant issue of the nature of the assumptions needed for a meaningful theorem is one that we would like to see validated by other in-production analyses, before generalization.\n\nFormal theorems about static analyses for data race detection have concentrated on soundness results, where here we considered completeness. In both cases contextual assumptions often need to be stated which concern, e.g., language features treated and ignored or other assumptions reflected in the abstractions.\n\nThe way we compose over- and under-approximations is consistent with the spirit of abstract interpretation. Although abstract interpretation can be used to formulate and prove vanilla soundness and completeness results (over and under on their own), perhaps its greater value comes from composing and comparing different abstractions, to give finer insight on the nature of analyses than the vanilla results (which often do not literally hold) would do. It is obvious that one might consider any sequence of over- and under-approximations. A modest suggestion of this work is that perhaps under-of-over is deserving of more attention, as a way to study static analyses that are designed for bug catching rather than prevention.9\n\n9This suggestion is consistent with bounded model checking and symbolic execution for testing, which can often be seen as computing either over-of-under or under-of-over.\nREFERENCES\n\nA PROOFS FOR SECTION 5 (ANALYSIS COMPLETENESS)\n\nLEMMA 5.5. \\( \\alpha \\) is additive (i.e., preserves lub’s) with respect to \\( \\bigcup_{\\varphi(T)} \\) and \\( \\sqcup_D \\).\n\nProof. Both \\( \\varphi(T) \\) and \\( D \\) are complete lattices. For any \\( T_1, T_2 \\in \\varphi(T) \\), we have:\n\n\\[\n\\alpha(T_1 \\cup T_2) = \\bigcup_{\\tau \\in T_1 \\cup T_2} (\\text{fst}(\\text{exec} \\hat{\\tau} \\perp D)) = \\bigcup_{\\tau \\in T_1} (\\text{fst}(\\text{exec} \\hat{\\tau} \\perp D)) \\cup \\bigcup_{\\tau \\in T_2} (\\text{fst}(\\text{exec} \\hat{\\tau} \\perp D)) = \\alpha(T_1) \\cup \\alpha(T_2)\n\\]\n\n\\[\\square\\]\n\nLEMMA 5.7. For any non-empty WF trace \\( \\tau \\in T \\), sets \\( W, A \\), number \\( L \\), and a simple command \\( c \\), which is not \\( \\text{pop}() \\), such that (a) \\( \\langle W, L, A \\rangle = \\alpha(\\{\\tau\\}) \\), (b) \\( \\varphi[c] \\) last(\\( \\tau \\)) = \\( \\{[\\xi] \\mid \\xi \\) is an execution state \\( \\) where last(\\( \\tau \\)) is the configuration \\( \\langle S, h, L \\rangle \\) of the last element of \\( \\tau \\), the following holds:\n\n\\[\n[c]^\\# \\langle W, L, A \\rangle = \\alpha \\left( \\bigcup \\{ \\tau : \\xi \\mid [\\xi] \\in \\varphi[c] \\text{ last}(\\tau) \\} \\right).\n\\]\n\nProof. If \\( c = \\text{skip} \\), the proof is trivial, as \\( \\varphi[c] \\text{ last}(\\tau) = \\{\\} \\), so the side condition \\( \\varphi[c] \\text{ last}(\\tau) = \\{[\\xi] \\} \\) does not hold. For other simple commands, let us notice that the condition \\( \\varphi[c] \\text{ last}(\\tau) = \\{[\\xi] \\mid \\ldots \\} \\) literally means that for any \\( \\xi \\), the trace \\( \\tau : \\xi \\) (since \\( c \\) is a simple command, the result of its successful execution is always a set of a single-state traces, an infinite one in the case of \\( \\text{new}() \\) — cf. Figure 5) is well-formed.\n\nWe therefore proceed by case analysis of the clauses of the \\textsc{RacerD} analysis definition in Figure 7 and trace-collecting semantics in Figure 5, assuming \\( \\langle W', L', A' \\rangle = \\text{fst}(\\text{exec} \\hat{\\tau} \\perp D) \\), so by the assumptions \\( \\langle W, L, A \\rangle = \\langle W', L', A' \\rangle \\), so \\( L = L' \\) etc. Since there are no \\( \\text{push}() / \\text{pop}() \\) in \\( \\hat{\\tau} \\), we do not have to account for the effect of a substitution \\( \\theta \\), “accumulated” by exec while processing \\( \\hat{\\tau} \\).\n\nCase: \\( c = (x := y) \\). In this case, there is exactly one resulting state \\( \\xi \\), and \\( \\hat{\\tau} : \\xi = \\hat{\\tau} : (x := y) \\).\n\nTherefore, \\( \\alpha(\\{\\tau : \\xi\\}) = \\text{fst}(\\text{exec} \\hat{\\tau} : (x := y) \\perp D) = \\langle W' \\cup \\{x, y\\}, L, A' \\rangle \\). At the same time, by the definition in Figure 7, \\( \\varphi[c] \\) last(\\( \\tau \\)) = \\( \\{[\\xi] \\mid \\xi \\) is an execution state \\( \\) where last(\\( \\tau \\)) is the configuration \\( \\langle S, h, L \\rangle \\) of the last element of \\( \\tau \\), the following holds:\n\n\\[\n[c]^\\# \\langle W, L, A \\rangle = \\alpha \\left( \\bigcup \\{ \\tau : \\xi \\mid [\\xi] \\in \\varphi[c] \\text{ last}(\\tau) \\} \\right).\n\\]\n\nProof. If \\( c = \\text{skip} \\), the proof is trivial, as \\( \\varphi[c] \\text{ last}(\\tau) = \\{\\} \\), so the side condition \\( \\varphi[c] \\text{ last}(\\tau) = \\{[\\xi] \\} \\) does not hold. For other simple commands, let us notice that the condition \\( \\varphi[c] \\text{ last}(\\tau) = \\{[\\xi] \\mid \\ldots \\} \\) literally means that for any \\( \\xi \\), the trace \\( \\tau : \\xi \\) (since \\( c \\) is a simple command, the result of its successful execution is always a set of a single-state traces, an infinite one in the case of \\( \\text{new}() \\) — cf. Figure 5) is well-formed.\n\nCase: \\( c = (x := \\pi) \\). There is exactly one resulting state \\( \\xi \\), \\( \\alpha(\\{\\tau : \\xi\\}) = \\text{fst}(\\text{exec} \\hat{\\tau} : (x := \\pi) \\perp D) = \\langle W' \\cup \\{x, \\pi\\}, L, A' \\rangle \\). Since \\( \\varphi[c] \\) last(\\( \\tau \\)) = \\( \\{[\\xi] \\mid \\xi \\) is an execution state \\( \\) where last(\\( \\tau \\)) is the configuration \\( \\langle S, h, L \\rangle \\) of the last element of \\( \\tau \\), the desired equality holds.\n\nCase: \\( c = (x := \\text{new}()) \\). Due to the non-determinism of object allocation, there is an infinite set of resulting states \\( \\xi \\), yet the abstraction \\( \\alpha \\) collapses all of them into the same syntactic statement \\( \\langle x := \\text{new}() \\rangle \\). Therefore,\n\n\\[\n\\alpha \\left( \\bigcup_{\\xi, [\\xi] \\in \\varphi[c] \\text{ last}(\\tau)} \\{ \\tau : \\xi \\} \\right) = \\text{fst}(\\text{exec} \\hat{\\tau} : (x := \\text{new}()) \\langle W', L, A' \\rangle) = \\langle W' \\cup \\{x\\}, L, A' \\rangle.\n\\]\n\nBy the definition 7, \\( \\varphi[c] \\) last(\\( \\tau \\)) = \\( \\{[\\xi] \\mid \\xi \\) is an execution state \\( \\) where last(\\( \\tau \\)) is the configuration \\( \\langle S, h, L \\rangle \\) of the last element of \\( \\tau \\), the following holds.\n\nCase: \\( c = \\text{lock}() \\). There is exactly one resulting state \\( \\xi \\); \\( \\alpha(\\{\\tau : \\xi\\}) = \\text{fst}(\\text{exec} \\hat{\\tau} : \\langle \\text{lock}() \\rangle \\perp D) = \\langle W', \\text{add}(L, 1), A' \\rangle \\). By the definition, \\( \\varphi[c] \\) last(\\( \\tau \\)) = \\( \\{[\\xi] \\mid \\xi \\) is an execution state \\( \\) where last(\\( \\tau \\)) is the configuration \\( \\langle S, h, L \\rangle \\) of the last element of \\( \\tau \\), the desired equality holds.\n\nCase: \\( c = \\text{unlock}() \\). For the only resulting state \\( \\xi \\), \\( \\alpha(\\{\\tau : \\xi\\}) = \\text{fst}(\\text{exec} \\hat{\\tau} : \\langle \\text{unlock}() \\rangle \\perp D) = \\langle W', \\text{max}(L - 1, 0), A' \\rangle \\). Since \\( \\varphi[c] \\) last(\\( \\tau \\)) = \\( \\{[\\xi] \\mid \\xi \\) is an execution state \\( \\) where last(\\( \\tau \\)) is the configuration \\( \\langle S, h, L \\rangle \\) of the last element of \\( \\tau \\), the desired equality holds.\n\n\\[\\square\\]\nLEMMA A.1 ($[\\cdot]^*$ distributes over $\\sqcup$). Let $\\langle W, A, L \\rangle = \\bigsqcup_{i \\in I} \\langle W_i, A_i, L_i \\rangle$ for some index set $I$. Then for any simple command $c$,\n\n$$[c]^* \\langle W, A, L \\rangle = \\bigsqcup_{i \\in I} ([c]^* \\langle W_i, A_i, L_i \\rangle).$$\n\nProof. The proof is by case analysis on the command $c$. In general, let us notice that, as defined, $[\\cdot]^*$ only adds elements to the $W$ and $A$.\n\nIn the case of $A$-component, the locking set $L'$ to be paired with $c$ (as in $\\langle c, L' \\rangle$ added by the analysis) is taken from the initial $L$ component. Since the $\\sqcup$ on $L$ is defined as max there should exist $j \\in I$, such that $L_i = L$. Therefore, no element $\\langle L', A \\rangle$ will be “missed” on the left hand side of the equality in question for $L' \\in \\{ L, \\max(L + 1, L), \\min(L - 1, L) \\}$, depending on $c$, matching the corresponding entry on the right.\n\nFinally, for the same reason, the $L$-component on the left side of the equality being proven is no large than the one on the right, as per definition of the locking subroutine (which does not depend on $W$ and $A$) and taking $\\sqcup$ to be the max. □\n\nLEMMA 5.8. For any set $T$ of non-empty well-formed traces, $W, L, A$, and simple command $c$, which is not $\\text{pop}()$, such that (a) $\\langle W, L, A \\rangle = \\alpha(T)$, (b) for any $\\tau \\in T$, $[c]$ last($\\tau$) = $[[c] | \\xi \\text{ is an execution state}]$, then the following holds:\n\n$$[c]^* \\langle W, L, A \\rangle = \\alpha \\left( \\bigcup \\{ \\tau : \\xi | \\tau \\in T, [c] \\in [c] \\text{ last}(\\tau) \\} \\right).$$\n\nProof. The proof is by case analysis of the clauses of the RACERDX analysis definition in Figure 7 and trace-collecting semantics in Figure 5, assuming $\\langle W', L', A' \\rangle = \\alpha(T) = \\bigsqcup_{\\tau \\in T} (\\text{fst}(\\text{exec} \\tau \\sqsubseteq \\perp))$, so by the assumptions $\\langle W, L, A \\rangle = \\langle W', L', A' \\rangle$. Also, any trace $\\tau \\sqsubseteq \\xi$ (where $\\xi$ is and state from the lemma assumptions) is well-formed.\n\nFrom Lemma 5.5 and Definition 5.4, we have\n\n$$\\alpha \\left( \\bigcup_{\\tau \\in T, [c] \\in [c] \\text{ last}(\\tau)} \\{ \\tau : \\xi \\} \\right) = \\bigsqcup_{\\tau \\in T, [c] \\in [c] \\text{ last}(\\tau)} \\text{fst}(\\text{exec} (\\tau \\sqsubseteq \\xi)).$$\n\nLet us notice now that for any $p \\in W'$ there exists $\\tau \\in T$, such that $p \\in (\\text{fst}(\\text{exec} \\tau \\sqsubseteq \\perp))_W$ (where $X_W$ is the projection to the $W$-component of an abstract domain element $X$). Similarly, for any $\\langle c, L \\rangle \\in A'$ there exists $\\tau \\in T$, such that $\\langle c, L \\rangle \\in (\\text{fst}(\\text{exec} \\tau \\sqsubseteq \\perp))_A$. Finally, since $\\sqcup$ is defined as max on $L$, there exists $\\tau \\in T$, such that $L = (\\text{fst}(\\text{exec} \\tau \\sqsubseteq \\perp))_L$. Therefore, we can represent, $\\langle W, L, A \\rangle$ as follows:\n\n$$\\langle W, L, A \\rangle = \\bigsqcup_{\\tau \\in T} \\langle W \\cap W_{\\tau}, \\min(L, L_{\\tau}), A \\cap A_{\\tau} \\rangle,$$\n\nwhere $\\langle W_{\\tau}, L_{\\tau}, A_{\\tau} \\rangle = \\text{fst}(\\text{exec} \\tau \\sqsubseteq \\perp)$. Now, let us denote via $\\langle W^\\tau, L^\\tau, A^\\tau \\rangle$ the individual “$\\tau$-projected fragments” of $\\langle W, L, A \\rangle$ so that for any $\\tau \\in T$, $\\langle W^\\tau, L^\\tau, A^\\tau \\rangle = \\langle W \\cap W_{\\tau}, \\min(L, L_{\\tau}), A \\cap A_{\\tau} \\rangle$. Altogether $\\langle W^\\tau, L^\\tau, A^\\tau \\rangle$s deliver the overall value $\\langle W, L, A \\rangle$ in the $\\bigsqcup$-union above. This way, for each $\\tau \\in T$, $\\langle W^\\tau, L^\\tau, A^\\tau \\rangle \\sqsubseteq \\text{fst}(\\text{exec} \\tau \\sqsubseteq \\perp) = \\alpha(\\{ \\tau \\})$ and $L^\\tau = \\alpha(\\{ \\tau \\})_L$ (since $L^\\tau \\leq L$). Via Lemma 5.7, we obtain, for each $\\tau \\in T$:\n\n$$[c]^* \\langle W^\\tau, L^\\tau, A^\\tau \\rangle \\sqsubseteq \\alpha \\left( \\bigcup_{\\xi, [c] \\in [c] \\text{ last}(\\tau)} \\{ \\tau : \\xi \\} \\right)$$\n\n(1)\nTherefore, via Lemma A.1, we have\n\\[ [c]^* \\langle W, L, A \\rangle = \\bigsqcup_{r \\in T} \\{ \\alpha \\langle \\tau \\rhd \\tau' | \\tau' \\in [c] \\, \\text{last}(r) \\rangle \\} \\]\nvia Lemma A.1\n\\[ = \\bigsqcup_{r \\in T} \\alpha \\left( \\{ \\tau \\rhd \\tau' | \\tau' \\in [c] \\, \\text{last}(r) \\} \\right) \\]\nvia (1) and properties of \\( \\sqcup \\)\n\\[ = \\alpha \\left( \\bigcup_{r \\in T, \\tau' \\in [c] \\, \\text{last}(r)} \\{ \\tau \\rhd \\tau' \\} \\right) \\]\nvia Lemma 5.5.\n\n\\[ \\square \\]\n\n**Lemma 5.9.** If \\( C \\) is a compound program with balanced locking, and \\( \\langle W', L', A' \\rangle = [C]^* \\langle W, L, A \\rangle \\). Then \\( L' = L \\).\n\n**Proof.** By induction on the shape of \\( C \\) and the definition in Figure 7, counting the number of “pending” un\\text{lock}()/\\text{lock}() statements, which eventually balance each other, so all additions/subtractions to the \\( L \\) component of the abstract state cancel each other.\n\n**Lemma 5.11.** For any compound program \\( C \\) with balanced locking and no method calls, the initial components \\( W_0, L_0, A_0 \\), and a set of well-formed non-empty traces \\( T \\), such that \\( \\langle W_0, L_0, A_0 \\rangle = \\alpha(T) \\),\n\\[ [C]^* \\langle W_0, L_0, A_0 \\rangle = \\begin{cases} \\alpha \\left( \\bigcup_{r \\in T} \\{ \\tau \\rhd \\tau' | \\tau' \\in [C] \\, \\text{last}(r) \\} \\right) & \\text{if } T \\neq \\emptyset, \\\\ \\alpha \\left( [C] \\langle S, h, 0 \\rangle \\right) & \\text{otherwise, for any well-behaved } S, h, \\end{cases} \\]\nwhere \\( \\text{last}(r) \\) is well-defined, as \\( T \\) consists of non-empty traces.\n\n**Proof.** The proof is by the backwards induction on the shape of the program \\( C \\), with the use of Lemma 5.8 for simple commands.\n\n**Case:** \\( C = c \\) (simple command). The proof follows Lemma 5.8 for the subcase \\( T \\neq \\emptyset \\). Otherwise, \\( \\alpha(T) = \\perp_D \\) and as \\( \\langle W_0, L_0, A_0 \\rangle = \\alpha(T) \\), \\( \\langle W_0, L_0, A_0 \\rangle = \\perp_D \\). Then, the proof is similar, but simpler, as the statement of interest reduces to \\( [c]^* \\perp_D = \\alpha([c] \\langle S, h, 0 \\rangle) \\), which is established by case analysis on \\( c \\) and the observation that due to well-behavedness, \\( [c] \\langle S, h, 0 \\rangle \\neq \\emptyset \\).\n\n**Case:** \\( C = C'; c \\) (c is not a method call). For the first sub-case, follows immediately from Lemma 5.8 with \\( T = \\bigcup_{r \\in T} [C'] \\, \\text{last}(r) \\) and \\( \\langle W, L, A \\rangle = [C']^* \\langle W_0, L_0, A_0 \\rangle \\). For the second sub-case, it is similar, via Lemma 5.8 with \\( T = [C'] \\), \\( \\langle S, h, 0 \\rangle \\) and \\( \\langle W, L, A \\rangle = [C']^* \\langle W_0, L_0, A_0 \\rangle \\). Notice that while \\( C \\) and, by consequently, \\( C' \\) enjoy balanced locking (which only matters for control-flow constructs), both \\( C \\) and \\( C' \\) may have non-matched \\text{lock}()-statements.\n\n**Case:** \\( C = C'; (\\text{if } * \\text{ then } C_1 \\text{ else } C_2) \\). Let \\( \\langle W, L, A \\rangle = [C']^* \\langle W_0, L_0, A_0 \\rangle \\), \\( \\langle W_i, L, A_i \\rangle = [C_i]^* \\langle W, L, A \\rangle \\) for \\( i \\in \\{1, 2\\} \\) (the equality of \\( L \\)-components is thanks to the balancing locking assumptions and Lemma 5.9). Let us focus on the resulting abstract state \\( \\langle W_1, L, A_1 \\rangle \\sqcup \\langle W_2, L, A_2 \\rangle \\). By induction hypothesis, every element of \\( W_i \\) is also in \\( [C_i] \\) . . . ; the inclusion also holds for elements of \\( A_1 \\), and similarly for the corresponding result of the second branch \\( C_2 \\). By Definition 4.3 of \\( \\sqcup \\) in the desired equality indeed holds (i.e., the analysis correctly under-approximates the abstraction of the concrete semantics). Remarkably, even though it takes the minimum of \\( L \\)-components, the analysis does not lose soundness in the presence of conditionals because of the balanced locking assumption.\n\n**Case:** \\( C = C'; (\\text{while } * \\text{ do } C') \\). For this case, we will employ the enforced requirement that \\text{lock}() and un\\text{lock}() only appear in balanced pairs. First, let us pose \\( \\langle W, L, A \\rangle = [C']^* \\langle W_0, L_0, A_0 \\rangle \\) and Let \\( \\langle W', L', A' \\rangle = [C''']^* \\langle W, L, A \\rangle \\) (thanks to well-scoped locking). Notice that, while our analysis functional \\([\\cdot]^{*}\\) is not monotone in general, it is monotone on programs with balanced locks,\nbecause it is monotone wrt. the first and the last components of the abstract state, and preserves the second component, as established by Lemma 5.9. Furthermore, we can see that after taking just one execution of \\([C']^* W, L, A\\) we already reach a fixed point: no further accesses are going to be added (ang by inductive hypothesis, all concretely occurring accesses are recorded) and the \\(L\\)-component will not change. Therefore, the analysis represents precisely computation of the fixpoint of \\(\\bar{F} = \\lambda D. [C']^* D\\), so the desired equality holds.\n\nThe following lemma ensures that an abstract execution of ANF methods can be modelled via direct substitutions rather with stack manipulation:\n\n**Lemma A.2 (ANF, substitution, and abstraction).** For any non-empty well-formed trace \\(\\tau \\in \\mathcal{T}\\), a method \\(m\\), a vector of expressions \\(e_1, \\ldots, e_n\\), a configuration \\(\\langle s :: S, h, L \\rangle = \\text{last}(\\tau)\\), such that\n(a) \\(\\forall i, 1 \\leq i \\leq n, [e_i]_{s, h}\\) are defined, and\n(b) \\(\\hat{s} = s\\text{nil}[\\text{arg}_1 \\mapsto [e_1]_{s, h}] \\cdots [\\text{arg}_n \\mapsto [e_n]_{s, h}]\\),\n(c) \\(\\tau_{\\text{push}} = \\langle \\langle \\text{push}(e_1, \\ldots, e_n), \\hat{s} :: s :: S, h, L \\rangle \\rangle\\), and\n(d) \\(\\text{mbody}(m)\\) has no nested calls and features well-balanced locking, the following holds:\n\n\\[\n\\begin{align*}\n\\alpha \\left( \\bigcup \\{ \\tau + \\tau_{\\text{push}} \\downarrow \\tau' \\mid \\tau' \\in [\\text{mbody}(m); \\text{pop()}] \\langle \\hat{s} :: s :: S, h, L \\rangle \\} \\right) = \\\\\n\\alpha \\left( \\bigcup \\{ \\tau + \\tau' \\mid \\tau' \\in \\text{mbody}(m)[\\hat{e}_{i/\\text{arg}_i}] \\text{last}(\\tau) \\} \\right) \\cup_1 \\text{WB}(e_1 \\ldots n)\n\\end{align*}\n\\]\n\nIn other words, one can replace computation of the method \\(m\\)'s call abstraction via computing the abstraction of the \\(m\\)'s body with substituted expressions.\n\n**Proof.** Starting from the expression on the left hand side of the equality, let us notice that\n\\[\n\\begin{align*}\n\\alpha \\left( \\bigcup \\{ \\tau + \\tau_{\\text{push}} \\downarrow \\tau' \\mid \\tau' \\in [\\text{mbody}(m); \\text{pop()}] \\langle \\hat{s} :: s :: S, h, L \\rangle \\} \\right) = & \\quad \\text{(via Def. 5.4)} \\\\\n\\alpha \\left( \\bigcup \\{ \\tau + \\tau_{\\text{push}} \\downarrow \\tau' \\mid \\tau' \\in [\\text{mbody}(m)](s :: s :: S, h, L) \\} \\right) = & \\quad \\text{(via Def. 5.4)} \\\\\n\\alpha \\left( \\bigcup \\{ \\tau + \\tau' \\mid \\tau' \\in [\\text{mbody}(m)[\\hat{e}_{i/\\text{arg}_i}]](s :: S, h, L) \\} \\right) \\cup_1 \\text{WB}(e_1 \\ldots n) = & \\quad \\text{(by assumption)} \\\\\n\\alpha \\left( \\bigcup \\{ \\tau + \\tau' \\mid \\tau' \\in [\\text{mbody}(m)[\\hat{e}_{i/\\text{arg}_i}]] \\text{last}(\\tau) \\} \\right) \\cup_1 \\text{WB}(e_1 \\ldots n)\n\\end{align*}\n\\]\n\n**Lemma 5.13.** For a method \\(m\\), a vector of expressions \\(e_1, \\ldots, e_n\\), a configuration \\(\\langle s :: S, h, L \\rangle = \\text{last}(\\tau)\\) such that\n- \\(\\forall i, 1 \\leq i \\leq n, [e_i]_{s, h}\\) are defined, and\n- \\(\\text{mbody}(m)\\) has no nested calls and features well-balanced locking, the following holds:\n\n\\[\n[m(e_1, \\ldots, e_n)]^* (W, L, A) = \\langle W', L', A' \\rangle \\cup_1 \\text{WB}(e_1 \\ldots n),\n\\]\n\nwhere\n\\[\n\\langle W', L', A' \\rangle = [\\text{mbody}(m)[\\hat{e}_{i/\\text{arg}_i}]]^* (W, L, A)\n\\]\n\n**Proof.** By induction on the shape of \\(\\text{mbody}(m)\\) as a compound command (Figure 7).\n\n**Lemma A.3 (Analysis is complete for method calls (per-trace)).** For any non-empty well-formed trace \\(\\tau \\in \\mathcal{T}\\), sets \\(W, A\\), number \\(L\\), a method \\(m\\) in ANF, a vector of expressions \\(e_1, \\ldots, e_n\\), a configuration \\(\\langle s :: S, h, L \\rangle = \\text{last}(\\tau)\\) such that\n- \\(\\forall i, 1 \\leq i \\leq n, [e_i]_{s, h}\\) are defined,\n- \\(\\langle W, L, A \\rangle = \\alpha(\\{\\tau\\})\\),\n- \\(\\tau_{\\text{push}} = \\langle \\langle \\text{push}(e_1, \\ldots, e_n), \\hat{s} :: s :: S, h, L \\rangle \\rangle\\)\n- \\(\\hat{s} = s\\text{nil}[\\text{arg}_1 \\mapsto [e_1]_{s, h}] \\cdots [\\text{arg}_n \\mapsto [e_n]_{s, h}]\\),\n- \\(\\text{mbody}(m)\\) has no nested calls and enjoys the well-scoped locking.\n\nThen the following holds:\n\\[\n[m(e_1, \\ldots, e_n)]^* (W, L, A) = \\alpha \\left( \\bigcup \\{ \\tau + \\tau_{\\text{push}} \\downarrow \\tau' \\mid \\tau' \\in [\\text{mbody}(m); \\text{pop()}] \\langle \\hat{s} :: s :: S, h, L \\rangle \\} \\right).\n\\]\nThis is precisely the conclusion of Lemma 5.11, for\nThen the following holds:\n\n\\[ \\alpha \\left( \\bigcup \\{ \\tau + \\tau' \\mid \\tau' \\in [C] \\text{ last}(\\tau) \\} \\right) \\cup_1 \\text{WB}(e_1 \\ldots n), \\]\n\nwhich almost matches the statement of Lemma 5.11 if we take \\( C := \\text{mbody}(m)[e_i/\\text{arg}_i] \\). By Lemma 5.13, we need to prove that\n\n\\[ ([C]^* \\langle W, L, A \\rangle) \\cup_1 \\text{WB}(e_1 \\ldots n) = \\alpha \\left( \\bigcup \\{ \\tau + \\tau' \\mid \\tau' \\in [C] \\text{ last}(\\tau) \\} \\right) \\cup_1 \\text{WB}(e_1 \\ldots n), \\]\n\nfor \\( C = \\text{mbody}(m)[e_i/\\text{arg}_i] \\). That is, now it is sufficient to prove the following goal\n\n\\[ ([C]^* \\langle W, L, A \\rangle) = \\alpha \\left( \\bigcup \\{ \\tau + \\tau' \\mid \\tau' \\in [C] \\text{ last}(\\tau) \\} \\right). \\]\n\nThis is precisely the conclusion of Lemma 5.11, for \\( T = \\{ \\tau \\} \\), so applying it completes the proof. \\( \\square \\)\n\n**Lemma A.4 (Analysis is complete for nested method calls (per-trace)).** For any non-empty well-formed trace \\( \\tau \\in T \\), sets \\( W, A \\), number \\( L \\), a method \\( m \\), a vector of expressions \\( e_1, \\ldots, e_n \\), a configuration \\( \\langle s :: S, h, L \\rangle = \\text{last}(\\tau) \\) such that\n\n- \\( \\forall i, 1 \\leq i \\leq n, [e_i]_{s,h} \\) are defined,\n- \\( \\langle W, L, A \\rangle = \\alpha(\\{ \\tau \\}) \\),\n- \\( \\tau \\text{push} = [\\langle \\text{push}(e_1, \\ldots, e_n), \\hat{s} :: s :: S, h, L \\rangle] \\)\n- \\( \\hat{s} = s_{\\text{null}}[\\text{arg}_1 \\mapsto [e_1]_{s,h}] \\cdot \\ldots \\cdot [\\text{arg}_n \\mapsto [e_n]_{s,h}] \\),\n- \\( \\text{mbody}(m) \\) and all its callees are in ANF and enjoy the well-scoped locking.\n\nThen the following holds:\n\n\\[ [m(e_1, \\ldots, e_n)^* \\langle W, L, A \\rangle = \\alpha \\left( \\bigcup \\{ \\tau + \\tau_{\\text{push}} + \\tau' \\mid \\tau' \\in [\\text{mbody}(m); \\text{pop}] \\langle \\hat{s} :: s :: S, h, L \\rangle \\} \\right). \\]\n\n**Proof.** By top-level induction on the size of the call tree and per-call induction on the structure of the body, with the base case delivered by Lemma 5.7. \\( \\square \\)\n\n**Lemma A.5 (Analysis is complete for nested method calls (for sets of traces)).** For any set \\( T \\) of non-empty well-formed traces, sets \\( W, A \\), number \\( L \\), a method \\( m \\), a vector of expressions \\( e_1, \\ldots, e_n \\), such that\n\n- \\( \\forall i, 1 \\leq i \\leq n, [e_i]_{s,h} \\) are defined,\n- \\( \\langle W, L, A \\rangle = \\alpha(T) \\),\n- for any \\( \\tau \\in T \\), \\( \\text{last}(\\tau) = \\langle s :: S, h, L \\rangle \\) for some \\( s, S \\),\n- \\( \\text{mbody}(m) \\) and all its callees are in ANF and enjoy the well-scoped locking.\n\nThen the following holds:\n\n\\[ [m(e_1, \\ldots, e_n)^* \\langle W, L, A \\rangle = \\alpha \\left( \\bigcup_{\\tau \\in T} \\left\\{ \\tau + \\tau_{\\text{push}} + \\tau' \\mid \\begin{array}{l} \\text{last}(\\tau) = \\langle s :: S, h, L \\rangle \\\\ \\hat{s} = s_{\\text{null}}[\\text{arg}_1 \\mapsto [e_1]_{s,h}] \\cdot \\ldots \\cdot [\\text{arg}_n \\mapsto [e_n]_{s,h}] \\\\ \\tau_{\\text{push}} = [\\langle \\text{push}(e_1, \\ldots, e_n), \\hat{s} :: s :: S, h, L \\rangle] \\\\ \\tau' \\in [\\text{mbody}(m); \\text{pop}] \\langle \\hat{s} :: s :: S, h, L \\rangle \\end{array} \\right\\} \\right). \\]\n\n**Proof.** Similar to Lemma 5.8. \\( \\square \\)\n\n**Lemma 5.14.** For any compound program \\( C \\) with balanced locking and all methods in ANF, the analysis domain components \\( W_0, L_0, A_0 \\), and a set of well-formed non-empty traces \\( T \\), such that \\( \\langle W_0, L_0, A_0 \\rangle = \\alpha(T) \\),\n\n\\[ [C]^* \\langle W_0, L_0, A_0 \\rangle = \\begin{cases} \\alpha \\left( \\bigcup_{\\tau \\in T} \\{ \\tau + \\tau' \\mid \\tau' \\in [C] \\text{ last}(\\tau) \\} \\right) & \\text{if } T \\neq \\emptyset, \\\\ \\alpha ([C] \\langle S, h, 0 \\rangle) & \\text{otherwise, for any well-behaved } S, h, \\end{cases} \\]\n\nwhere \\( \\text{last}(\\tau) \\) is well-defined, as \\( T \\) consists of non-empty traces.\nA True Positives Theorem for a Static Race Detector\n\n**Proof.** The proof is by the backwards induction on the shape of the program \\( C \\) similarly to the proof of Lemma 5.11, with the use of Lemma 5.8 for simple commands and Lemma A.5 for method calls. Let us consider the only new case of method calls:\n\n**Case:** \\( C = C'; \\) \\( m(e_1, \\ldots, e_n) \\) By the definition from Figure 5, the call \\( m(e_1, \\ldots, e_n) \\) is “unfolded” into \\( \\text{push}(e_1, \\ldots, e_n); \\text{mbody}(m); \\text{pop}() \\), so the statement of Lemma A.5 applies. For the first sub-case, follows immediately from Lemma A.5 with \\( T = \\bigcup_{\\tau \\in \\mathcal{E}}[C'] \\) last(\\( \\tau \\)) and \\( (W, L, A) = [C']^* (W_0, L_0, A_0) \\). For the second sub-case, it is similar, via Lemma A.5 with \\( T = [C'] \\) \\( (S, h, 0) \\) and \\( (W, L, A) = [C']^* (W_0, L_0, A_0) \\).\n\n\\[ \\Box \\]\n\n### B PROOFS FOR SECTION 6 (RACY TRACE RECONSTRUCTION)\n\nFor a path \\( \\pi \\) such that \\( |\\pi| > 1 \\) we fix \\( \\text{trunc}(\\pi) \\) to be the proper prefix of \\( \\pi \\) such that is \\( |\\text{trunc}(\\pi)| = |\\pi| - 1 \\).\n\n**Lemma B.1.** Let \\( \\tilde{\\pi} \\) be a non-empty sequence of fields, and \\( x, y \\) two variables. Let \\( \\pi = x.\\tilde{\\pi} \\) and \\( \\rho = y.\\tilde{\\pi} \\).\n\nIf \\( s(x) = s'(y) \\) and \\( h \\leq h' \\) then \\( h^*_{x.\\tilde{\\pi}} = h'^*_{y.\\tilde{\\pi}} \\) and \\( [x.\\tilde{g}]_{s, h} = [y.\\tilde{g}]_{s', h'} \\) for any \\( \\tilde{g} \\leq \\tilde{\\pi} \\) (and therefore \\( [\\pi]_{s, h} = [\\rho]_{s', h'} \\)).\n\n**Proof.** By induction on the structure of \\( \\tilde{g} \\leq \\tilde{\\pi} \\).\n\nIf \\( \\tilde{g} = g \\) then \\( [x.\\tilde{g}]_{s, h} = (s(x), g) = (s'(y), g) = [y.\\tilde{g}]_{s', h'} \\). Therefore, \\( h^*_{x.\\tilde{g}} = \\{[x.g]_{s, h} \\mapsto h([x.g]_{s, h})\\} \\) for \\( h \\leq h' \\) this means \\( h^*_{x.\\tilde{g}} = \\{[y.g]_{s', h'} \\mapsto h'([y.g]_{s', h'})\\} = h'^*_{y.\\tilde{g}} \\).\n\nLet \\( \\tilde{g} = g.\\tilde{g}' \\). Then \\( [x.\\tilde{g}]_{s, h} = h([x.g]_{s, h}, g) \\). By the inductive hypothesis, this is equal to \\( h([y.g']_{s', h'}, g) \\) and \\( h \\leq h' \\), equal to \\( h'([y.g']_{s', h'}) \\). Thus, given that \\( [x.g]_{s, h} = [y.g']_{s', h'} \\), we have \\( h^*_{x.\\tilde{g}} = h'^*_{y.\\tilde{g}} \\).\n\n**Lemma B.2.** If \\( \\pi \\) is acyclic in \\( s, h \\), \\( s(\\text{root}(\\pi)) = s'(\\text{root}(\\pi)) \\) and \\( h^*_{\\pi} = h'^*_{\\pi} \\) then \\( \\pi \\) is acyclic in \\( s', h' \\).\n\n**Proof.** First we show that if \\( s(\\text{root}(\\pi)) = s'(\\text{root}(\\pi)) \\) and \\( h^*_{\\pi} = h'^*_{\\pi} \\), then for any \\( \\pi'' \\preceq \\pi \\), \\( [\\pi'']_{s, h} = [\\pi'']_{s', h'} \\). We do this by induction on \\( \\pi' \\). The base case is immediate, given \\( s(\\text{root}(\\pi)) = s'(\\text{root}(\\pi)) \\).\n\nIf \\( \\pi' = \\pi''.f \\preceq \\pi \\), we need to show that \\( h([\\pi'']_{s, h}, f) = h'([\\pi'']_{s', h'}, f) \\), or more simply that \\( h([\\pi'']_{s, h}, f) = h'([\\pi'']_{s', h'}) \\). By the inductive hypothesis, \\( [\\pi'']_{s, h} = [\\pi'']_{s', h'} \\). By the definition of \\( h^*_{\\pi} \\), we have that \\( [\\pi'']_{s, h} \\in \\text{dom}(h^*_{\\pi}) \\), and the required result follows from the assumption that \\( h^*_{\\pi} = h'^*_{\\pi} \\).\n\nTo show acyclicity in \\( s', h' \\) we need to show that for any \\( \\pi'' \\preceq \\pi' \\preceq \\pi \\), \\( h'([\\pi'']_{s', h'}) \\neq \\text{locn}([\\pi'']_{s', h'}) \\).\n\n**Lemma B.3.** Let \\( \\pi, \\pi' \\) be two access paths such that \\( \\pi' \\neq \\pi \\). In addition, \\( \\pi \\) is acyclic and disconnected in \\( s, h \\). Then, \\( [\\pi']_{s, h} \\not\\in \\text{dom}(h^*_{\\pi}) \\).\n\n**Proof.** By induction on the structure of \\( \\pi \\).\n\nBase case: suppose \\( \\pi = x.f \\). Suppose, for a contradiction, that \\( [\\pi']_{s, h} \\in \\text{dom}(h^*_{\\pi}) \\), meaning \\( [\\pi']_{s, h} = [\\pi]_{s, h} = (s(x), f) \\).\n\nIf \\( |\\pi'| = 1 \\) then it is easy to see that \\( s(\\text{root}(\\pi')) = s(\\text{root}(\\pi)) \\). If \\( \\text{root}(\\pi') \\neq \\text{root}(\\pi) \\), then this contradicts the first clause of the disconnectedness of \\( \\pi \\). Otherwise, \\( \\pi' = \\pi \\), contradicting the assumption that \\( \\pi' \\neq \\pi \\).\n\nIf \\( |\\pi'| > 1 \\) then \\( \\text{trunc}(\\pi') \\) is defined, and in particular, \\( [\\pi']_{s, h} = h([\\text{trunc}(\\pi')_{s, h}], f) \\), meaning that \\( h([\\text{trunc}(\\pi')_{s, h}] = s(x) \\) and furthermore, \\( h([\\text{trunc}(\\pi')_{s, h}] \\in \\text{locn}(h^*_{\\pi}) \\). By the second\nclause of disconnectedness, it follows that $[\\text{trunc}(\\pi')]_{s,h} \\in \\text{dom}(h'\\downarrow^s_{\\pi'})$. Therefore, $[\\text{trunc}(\\pi')]_{s,h} = (s(x), f)$ again. As such, $h(s(x), f) = s(x)$, contradicting the acyclicity of $\\pi$.\n\nInductive case: let $\\pi = \\rho.f$. Since $\\pi' \\nleq \\pi$ it will also be the case that $\\pi' \\nleq \\rho$. It is not hard to see that $\\rho$ is disconnected and acyclic in $s, h$, because $\\pi$ is, therefore the inductive hypothesis applies, completing the proof.\n\n**Lemma B.4.** Suppose $\\pi$ is acyclic in $s, h$, that $s(\\text{root}(\\pi)) = s'(\\text{root}(\\pi))$, that $\\text{dom}(h'\\downarrow^s_{\\pi'}) \\subseteq \\text{dom}(h')$ and that for all $\\alpha \\in \\text{dom}(h'\\downarrow^s_{\\pi'}) \\setminus \\{s\\}_s h, [\\pi(\\alpha)]_{s,h} = h'(\\alpha)$. Then, for any $\\pi' \\leq \\pi$, $[\\pi']_{s,h} = [\\pi']_{s',h'}$, and $\\text{dom}(h'\\downarrow^s_{\\pi'}) = \\text{dom}(h'\\downarrow^s_{\\pi'})$.\n\n**Proof.** If $|\\pi| = 1$ then the result follows trivially.\n\nLet $|\\pi| > 1$ and fix some path $\\pi' < \\pi$. First, observe that $[\\pi']_{s,h} \\neq [\\pi']_{s,h}$, because otherwise $\\text{locn}([\\pi']_{s,h}) = \\text{locn}([\\pi']_{s,h}) = h([\\text{trunc}(\\pi)]_{s,h})$, contradicting acyclicity. This means that for all $\\pi' < \\pi$, $h([\\pi']_{s,h}) = h'([\\pi']_{s,h})$. Lemma B.5 can now be used on $\\text{trunc}(\\pi)$, giving us that $h\\downarrow^s_{\\text{trunc}(\\pi)} = h'\\downarrow^s_{\\text{trunc}(\\pi)}$. Applying Lemma B.1 to the restricted heap $h\\downarrow^s_{\\text{trunc}(\\pi)}$ lets us conclude that $[\\pi']_{s,h} = [\\pi']_{s',h'}$. Finally, this gives $[\\pi]_{s,h} = [\\pi]_{s',h'}$ and $\\text{dom}(h'\\downarrow^s_{\\pi'}) = \\text{dom}(h'\\downarrow^s_{\\pi'})$, completing the proof.\n\n**Lemma B.5.** Suppose that $s(\\text{root}(\\pi)) = s'(\\text{root}(\\pi))$, that $\\text{dom}(h'\\downarrow^s_{\\pi'}) \\subseteq \\text{dom}(h')$, and that for all addresses $\\alpha \\in \\text{dom}(h'\\downarrow^s_{\\pi'})$, $h'(\\alpha) = h'(\\alpha)$. Then $h\\downarrow^s_{\\pi'} = h'\\downarrow^s_{\\pi'}$ and $[\\pi]_{s,h} = [\\pi]_{s',h'}$.\n\n**Proof.** By induction on $\\pi$. If $\\pi = x.f$ then $h\\downarrow^s_{\\pi'} = \\{(s(x), f) \\mapsto h(s(x), f)\\} = \\{(s'(x), f) \\mapsto h(s'(x), f)\\}$. By assumption, $h(s(x), f) = h'(s(x), f)$, thus $h\\downarrow^s_{\\pi'} = h'\\downarrow^s_{\\pi'}$, and $[\\pi]_{s,h} = [\\pi']_{s',h'}$.\n\nLet $\\pi = \\pi'.f$. Then, $h\\downarrow^s_{\\pi'} = h\\downarrow^s_{\\pi'} \\cup \\{(\\pi]_{s,h} \\mapsto h([\\pi]_{s,h})\\}$, and $\\text{dom}(h\\downarrow^s_{\\pi'}) \\subseteq \\text{dom}(h')$. By the inductive hypothesis, $h\\downarrow^{\\pi'}_{\\pi'} = h'\\downarrow^{\\pi'}_{\\pi'}$, and $[\\pi']_{s,h} = [\\pi']_{s',h'}$. Also, $[\\pi']_{s,h} \\in \\text{dom}(h\\downarrow^s_{\\pi'})$, thus $h([\\pi']_{s,h}) = h'([\\pi']_{s,h}) = h'([\\pi']_{s',h'})$, meaning $h\\downarrow^s_{\\pi'} = h'\\downarrow^s_{\\pi'}$, and $[\\pi]_{s,h} = [\\pi]_{s',h'}$.\n\n**Lemma 6.6.** Let $\\pi$ be an access path and $\\tau$ a WF, non-empty trace without any push()/pop() commands, whose starting state $(\\text{skip}, s_0 :: S, h_0, \\_)$ is well-behaved, and where $\\pi$ is acyclic and disconnected in $s_0, h_0$. Let the last state of $\\tau$ be $(\\_, s' :: S, h', \\_)$.\n\nIf it is the case that $\\forall e \\in \\alpha(\\pi\\\\tau) E \\not\\in \\pi$, then $\\pi$ is preserved from $s_0, h_0$ to $s', h'$.\n\n**Proof.** By induction on the length of $\\tau$. The base case is trivial (traces always start with skip). For the inductive case, let $(\\_, s :: S, h, \\_)$ be the penultimate state in $\\tau$. By the inductive hypothesis, $\\pi$ is preserved from $s_0, h_0$ to $s, h$. Thus it suffices to show that $\\pi$ is preserved from $s, h$ to $s', h'$. The cases for lock()/unlock() are trivial.\n\nWe call the assumption that $\\forall e \\in \\alpha(\\pi\\\\tau) E \\not\\in \\pi$, the stability assumption.\n\n**Case:** $c = (x := y)$ or $c = (x := \\pi')$ or $c = (x := \\text{new()})$.\n\nClearly, $[\\pi]_{s',h'}$ is defined.\n\nBy the stability assumption and Definition 5.4 (exec), it follows that $x \\neq \\text{root}(\\pi')$. Therefore, by the concrete semantics of $c$, $s(\\text{root}(\\pi)) = s'(\\text{root}(\\pi'))$, and in all cases, $h \\subseteq h'$. Thus, by Lemma B.1, it follows that $h'\\downarrow^s_{\\pi'} = h\\downarrow^s_{\\pi'}$ and $\\forall \\alpha \\in \\text{dom}(h\\downarrow^s_{\\pi'})$, $h'(\\alpha) = h(\\alpha)$.\n\nThe acyclicity of $\\pi$ in $s', h'$ follows from Lemma B.2 and the fact that $h'\\downarrow^s_{\\pi'} = h\\downarrow^s_{\\pi'}$.\n\nWe show that $\\pi$ is disconnected in $s', h'$. Given $h\\downarrow^s_{\\pi'} = h'\\downarrow^s_{\\pi'}$, the second clause of the disconnectiveness definition carries over directly from the disconnectedness of $\\pi$ in $s, h$ whenever $c$ is $x := y$ or $x := \\pi'$ (because $h = h'$). The case where $c = x := \\text{new()}$ follows by the same reasoning, plus the fact that all newly-allocated addresses point to the newly allocated location, and therefore by construction, cannot alias addresses in $h$.\nGiven the disconnectedness of $\\pi$ in $s, h$ and the fact that for all variables $w \\neq x, s(w) = s'(w)$, we only need to show $s'(x) \\notin \\text{locn}(h|_{\\pi}^{s'})$ for the first clause.\n\nIf $c = (x := y)$ then $s'(x) = s(y)$. Given that $y \\neq \\text{root}(\\pi)$, due to the stability assumption, and the first clause of the definition of disconnectedness for $\\pi$ in $s, h$, we have that $s(y) \\notin \\text{locn}(h|_{\\pi}^{s}) = \\text{locn}(h|_{\\pi}^{s'})$ (since $h|_{\\pi}^{s} = h|_{\\pi}^{s'}$), as required.\n\nIf $c = (x := \\pi')$ then $s'(x) = h(\\lfloor \\pi' \\rfloor_{s,h})$. Given that $h = h'$ and that $h|_{\\pi}^{s} = h'|_{\\pi}^{s'}$, it suffices to show $h(\\lfloor \\pi' \\rfloor_{s,h}) \\notin \\text{locn}(h|_{\\pi}^{s'})$. By the stability assumption, $\\pi' \\neq \\pi$, thus applying Lemma B.3, we obtain $[\\pi']_{s,h} \\notin \\text{dom}(h|_{\\pi}^{s'})$. By the contrapositive of the second clause of disconnectedness of $\\pi$ in $s, h$ follows that $h(\\lfloor \\pi' \\rfloor_{s,h}) \\notin \\text{dom}(h|_{\\pi}^{s'})$, as required.\n\nIf $c = (x := \\text{new}())$ then $s'(x) = \\ell$ for some $\\ell \\notin \\text{dom}(h)$. Clearly, $\\ell \\notin \\text{locn}(h|_{\\pi}^{s'})$ and since $h|_{\\pi}^{s} = h'|_{\\pi}^{s'}$, it follows that $s'(x) = \\ell \\notin \\text{locn}(h|_{\\pi}^{s'})$, as required.\n\nCase: $c = (\\pi' := x)$, where $\\pi' \\neq \\pi$.\n\nBy the preservation of well-behavedness $c$ is safe to execute, thus, $[\\pi']_{s,h} \\in \\text{dom}(h)$. Also, $s = s'$.\n\nThe stability assumption forces $\\pi' \\neq \\pi$, thus by Lemma B.3 we have that $[\\pi']_{s,h} \\notin \\text{dom}(h|_{\\pi}^{s'})$. This, in addition with the semantics of the assignment to $\\pi'$, means that for all addresses $\\alpha \\in \\text{dom}(h|_{\\pi}^{s'})$, $h(\\alpha) = h'(\\alpha)$. Thus Lemma B.5 applies, giving $[\\pi]_{s,h} = [\\pi]_{s',h'}$, $h|_{\\pi}^{s} = h'|_{\\pi}^{s'}$ and $\\forall \\alpha \\in \\text{dom}(h|_{\\pi}^{s'})$ . $h(\\alpha) = h'(\\alpha)$, thus, $\\text{dom}(h|_{\\pi}^{s'}) = \\text{dom}(h|_{\\pi}^{s'})$.\n\nFor disconnectedness, first, $[\\pi]_{s',h'}$ is clearly defined; the first clause holds due to the fact that $s = s'$, $h|_{\\pi}^{s} = h'|_{\\pi}^{s'}$, and the assumption of disconnectedness of $\\pi$ in $s, h$.\n\nBy the semantics of the command, $\\text{locn}(h) = \\text{locn}(h')$. Therefore, the second clause of disconnectedness in $s', h'$ holds for all addresses $\\alpha \\neq [\\pi']_{s,h}$, by the second clause of the disconnectedness in $s, h$. By the first clause and stability ($x \\neq \\text{root}(\\pi)$) follows that $h'(\\lfloor \\pi' \\rfloor_{s,h}) = s(x) \\notin \\text{locn}(h|_{\\pi}^{s'}) = \\text{locn}(h'|_{\\pi}^{s'})$.\n\nAs before, acyclicity follows from the fact that $h'|_{\\pi}^{s} = h'|_{\\pi}^{s'}$, the acyclicity in $s, h$ and Lemma B.2.\n\nCase: $c = (\\pi := x)$.\n\nBy the acyclicity of $\\pi$ in $s, h$ and the semantics of the store it follows that $\\forall \\alpha \\in \\text{dom}(h|_{\\pi}^{s}) \\setminus [\\pi]_{s,h}, h(\\alpha) = h'(\\alpha)$. Thus, Lemma B.4 applies and we have $[\\pi]_{s,h} = [\\pi]_{s',h'}$ and $\\text{dom}(h|_{\\pi}^{s'}) = \\text{dom}(h|_{\\pi}^{s'})$.\n\nDisconnectedness: The first clause follows from the disconnectedness in $s, h, s = s'$ and $\\text{locn}(h|_{\\pi}^{s'}) = \\text{locn}(h'|_{\\pi}^{s'})$ (because $\\text{dom}(h|_{\\pi}^{s'}) = \\text{dom}(h'|_{\\pi}^{s'})$).\n\nFor the second clause, we need to show that for all $\\alpha \\in \\text{dom}(h')$, if $h'(\\alpha) \\in \\text{locn}(h|_{\\pi}^{s'})$, then $\\alpha \\in \\text{dom}(h|_{\\pi}^{s'})$. As $\\text{dom}(h|_{\\pi}^{s'}) = \\text{dom}(h'|_{\\pi}^{s'})$ and $\\text{dom}(h') = \\text{dom}(h)$, this is equivalent to showing that for all $\\alpha \\in \\text{dom}(h)$, if $h'(\\alpha) \\in \\text{locn}(h|_{\\pi}^{s'})$, then $\\alpha \\in \\text{dom}(h|_{\\pi}^{s'})$.\n\nIf $\\alpha = [\\pi]_{s,h} = [\\pi]_{s',h'}$, then $h'(\\alpha) = h'(\\alpha)$. Thus, if $h'(\\alpha) \\in \\text{locn}(h|_{\\pi}^{s'})$ then $h'(\\alpha) \\in \\text{locn}(h|_{\\pi}^{s'})$ thus $\\alpha \\in \\text{dom}(h|_{\\pi}^{s'})$ (by disconnectedness in $s, h$).\n\nIf $\\alpha = [\\pi]_{s,h} = [\\pi]_{s',h'}$, then $h'(\\alpha) = s(x)$. By stability, $x \\neq \\text{root}(\\pi)$, thus by the first clause of disconnectedness, $s(x) \\notin \\text{locn}(h|_{\\pi}^{s'})$, as required.\n\nAcyclicity: we wish to prove that for every $\\pi'' \\preceq \\pi' \\preceq \\pi$, $h'(\\lfloor \\pi'' \\rfloor_{s',h'}) \\neq \\text{locn}(\\lfloor \\pi'' \\rfloor_{s',h'})$. Using Lemma B.4, this reduces to showing $h'(\\lfloor \\pi'' \\rfloor_{s,h}) \\neq \\text{locn}(\\lfloor \\pi'' \\rfloor_{s,h})$ (because for any path $\\pi' \\preceq \\pi$, $[\\pi]_{s,h} = [\\pi]_{s',h'}$). We distinguish two cases.\n\nLet $[\\pi'']_{s,h} \\neq [\\pi]_{s,h}$. Then $h'(\\lfloor \\pi'' \\rfloor_{s,h}) = h(\\lfloor \\pi'' \\rfloor_{s,h}) \\neq \\text{locn}(\\lfloor \\pi'' \\rfloor_{s,h})$, by the acyclicity in of $\\pi$ in $s, h$.\n\nLet $[\\pi'']_{s',h'} = [\\pi]_{s',h'}$. This means $h'(\\lfloor \\pi'' \\rfloor_{s',h'}) = s(x) \\neq \\text{locn}(\\lfloor \\pi'' \\rfloor_{s,h})$. by stability and the disconnectedness in $s, h$.\n\n\\[\\Box\\]\nLemma B.6 (Frame Property). Let $h = h_0 \\cup h_F$ (where $\\cup$ is disjoint union), and let $\\tau \\in [C] \\langle s, h, L \\rangle$ such that $\\text{last}(\\tau) = \\langle s', h', L' \\rangle$. If $[C] \\langle s, h, F, L \\rangle \\neq \\emptyset$ then there exists $\\tau' \\in [C] \\langle s, h, F, L \\rangle$ such that $\\text{last}(\\tau') = \\langle s', h', L' \\rangle$, and $h' = h_0 \\cup h_F$.\n\nProof. By the semantics of the language and standard separation-logic style reasoning.\n\nLemma 6.7. Suppose that $mbody(m)$ has no procedure calls, that $\\pi$ is an access path which is disconnected and acyclic in the well-behaved state $s, h$, that $\\tau \\in [skip; m(\\bar{e})] \\langle s, h, L \\rangle$ is a non-empty trace, that $\\text{last}(\\tau) = \\langle \\text{pop}(), s, h', L \\rangle$, that $\\alpha(\\{\\tau\\}) = \\langle W, \\_, \\_ \\rangle$, and that $\\forall e \\in W. e \\neq \\pi$.\n\nThen, $\\pi$ is preserved from $s, h$ to $s, h'$.\n\nProof. Let $e = (e_1, \\ldots, e_n)$ and let $\\pi = z.\\tilde{f}$. Since $\\tau$ is non-empty, for all $i \\leq n$, $\\langle e_i \\rangle_{s, h} = \\ell_i$ (and is defined). By the semantics for method calls and those for simple commands ($\\text{pop}()$) we have $\\tau = \\tau_{\\text{push}} + \\tau' + \\tau_{\\text{pop}}$ where\n\n- $\\tau_{\\text{push}} = [\\langle \\text{push}(e_1, \\ldots, e_n), \\tilde{s} :: s, h, L \\rangle]$\n- $\\tau' = [mbody(m)] \\langle \\tilde{s} :: s, h, L \\rangle$, where $\\text{last}(\\tau') = \\langle , \\tilde{s}' :: s, h', L' \\rangle$\n- $\\tau_{\\text{pop}} = [\\langle \\text{pop} () \\rangle, s, h', L' \\rangle$\n\nwhere $\\tilde{s} = \\text{def} s_{n} = \\bar{e}_1 \\rightarrow \\ell_1 \\cdot \\cdots \\cdot \\bar{e}_n = \\ell_n$.\n\nBy the assumption that $\\forall e \\in W. e \\neq \\pi$ (we call this the stability assumption) and the definition of how exec modifies the $W$ component for the method call case, we can assume there is at most one $e_i$ such that $e_i = z$, or $e_i = \\pi_i \\neq \\pi$.\n\nCase: there is no $i \\leq n$ such that $e_i = z$, or $e_i = \\pi_i \\neq \\pi$. Fix the stacks $\\tilde{s} = \\text{def} \\tilde{s}[\\bar{ar} g_{n+1} \\mapsto s(z)]$ and $\\tilde{s}' = \\text{def} \\tilde{s}'[\\bar{ar} g_{n+1} \\mapsto s(z)]$. Recall that, by convention, $mbody(m)$ does not use $\\bar{ar} g_{n+1}$; thus, since $\\tau' \\in [mbody(m)] \\langle \\tilde{s} :: s, h, L \\rangle$ and where $\\text{last}(\\tau') = \\langle , \\tilde{s}' :: s, h', L' \\rangle$, it will also be the case that there is another “isomorphic” trace $\\tau''$ such that $\\tau'' \\in [mbody(m)] \\langle \\tilde{s} :: s, h, L \\rangle$, where $\\text{last}(\\tau'') = \\langle , \\tilde{s} :: s, h', L' \\rangle$.\n\nWe now show that $\\rho = \\bar{ar} g_{n+1} = \\tilde{s}$ is disconnected and acyclic in $s, h$. Note that by Lemma B.1, $h_{\\pi}^{s} = h_{\\rho}^{\\tilde{s}}$ and $[\\pi]_{s, h} = [\\rho]_{\\tilde{s}, h}$, therefore also $\\text{dom}(h_{\\pi}^{s}) = \\text{dom}(h_{\\rho}^{\\tilde{s}})$.\n\n(1) First clause of disconnectedness: We need to show that for all variables $x \\neq \\bar{ar} g_{n+1}, \\bar{s}(x) \\notin \\text{locn}(h_{\\rho}^{\\tilde{s}})$. By the definition of $\\tilde{s}$, this means showing that for all $i \\leq n$, $\\bar{s}(\\bar{ar} g_{i}) = \\tilde{s}(\\bar{ar} g_{i}) \\notin \\text{locn}(h_{\\rho}^{\\tilde{s}})$. But $\\tilde{s}(\\bar{ar} g_{i}) = \\tilde{s}_{e_i, s, h}$. We have two cases:\n\na) If $e_i = x$ for some variable $x$, then $\\tilde{s}_{e_i, s, h} = h(x)$. By the stability assumption, we have that $x \\neq z$ and by the disconnectedness of $\\pi$ in $s, h$ we have that $h(x) \\notin \\text{locn}(h_{\\pi}^{s})$. This completes the proof through the fact that $h_{\\rho}^{\\tilde{s}} = h_{\\tilde{s}}^{\\rho}$.\n\nb) If $e_i = \\pi'$ then $\\tilde{s}_{e_i, s, h} = h([\\pi']_{s, h})$. By the stability assumption, we have that $\\pi' \\neq \\pi$. If $\\pi' \\neq \\pi$ then by Lemma B.3, we have that $[\\pi']_{s, h} \\notin \\text{dom}(h_{\\pi}^{s})$. This directly means (through the fact that $h_{\\pi}^{s} = h_{\\tilde{s}}^{\\rho}$) that $\\tilde{s}(\\bar{ar} g_{i}) \\notin \\text{locn}(h_{\\rho}^{\\tilde{s}})$, completing the proof. If $\\pi' = \\pi$, then $\\tilde{s}_{e_i, s, h} = h([\\pi]_{s, h})$. By acyclicity of $\\pi$ in $s, h$ we have that $\\tilde{s}(\\bar{ar} g_{i}) = h([\\pi]_{s, h}) \\notin \\text{locn}(h_{\\rho}^{\\tilde{s}}) = \\text{locn}(h_{\\pi}^{s})$.\n\n(2) Second clause of disconnectedness: We need to show that for all $\\alpha \\in \\text{dom}(h)$, if $h(\\alpha) \\in \\text{locn}(h_{\\pi}^{s})$, then $\\alpha \\in \\text{dom}(h_{\\rho}^{\\tilde{s}})$. or, if that $h(\\alpha) \\in \\text{locn}(h_{\\rho}^{\\tilde{s}})$, then $\\alpha \\in \\text{dom}(h_{\\pi}^{s})$. This is immediate by the disconnectedness of $\\pi$ in $s, h$.\n\nAcyclicity of $\\rho$ in $\\tilde{s}, h$ follows from Lemma B.2, noting that $h_{\\pi}^{s} = h_{\\rho}^{\\tilde{s}}$ as shown above.\n\nWe now can apply Lemma 6.6 to obtain that $\\rho$ is preserved from $\\tilde{s}, h$ to $\\tilde{s}', h'$ (note that since there are no accesses to $\\bar{ar} g_{n+1}$ in $mbody(m)$, and no procedure calls, trivially $\\forall e \\in \\alpha([\\tau''])_{W. e \\neq \\rho}$).\n\nLemma B.1 yields $[\\rho]_{s', h'} = [\\pi]_{s, h'}$, and $h_{\\rho}^{s'} = h_{\\pi}^{s}$, therefore also $\\text{dom}(h_{\\rho}^{s'}) = \\text{dom}(h_{\\rho}^{s})$.\n\nLemma B.2 yields the acyclicity of $\\pi$ in $s, h'$.\nFinally, we also need to finally show that $\\pi$ is disconnected in $s, h'$. This follows from the fact that $\\text{dom}(h'_{\\pi}) = \\text{dom}(h'_{\\pi})$ and the disconnectedness of $\\rho$ in $s', h'$.\n\n**Case: for exactly one** $j \\leq n$, $e_j < \\pi$, and $e_j = \\pi$. This case proceeds almost identically, but for the following differences: we don’t use $\\text{arg}g_{n+1}$, nor “jump” to another trace $\\tau''$ as above, but operate directly on $\\tau'$; the definitions $\\tilde{s} \\triangleq s$ and $\\tilde{s}' \\triangleq s'$ are trivial; and $\\rho \\triangleq \\text{arg}g_j.\\tilde{f}$.\n\nApplication of Lemma 6.6: Note that $\\alpha(\\cdot)$ is monotonic: $\\tau' \\leq \\pi'$, thus $\\alpha(\\{\\tau'_\\text{push} \\triangleright \\pi'\\})_W \\subseteq \\alpha(\\{\\pi\\})_W$. Thus, from the top-level assumption about the $W$ component of the abstraction of $\\tau$ follows that, also, $\\forall \\epsilon \\in \\alpha(\\{\\tau'_\\text{push} \\triangleright \\pi'\\})_W. \\epsilon \\neq \\pi$. By the definition of exec for $\\text{push}()$, this means $\\forall \\epsilon \\in \\alpha(\\{\\pi'\\})_W[\\text{arg}g_{i-\\pi'_{l-1}}]. \\epsilon \\neq \\rho$, by the properties of substitutions, the definition of exec for load/stores, the fact that there are no procedure calls in $m$, and the fact that the root of $\\rho$ is $\\text{arg}g_j$ and thus not a local.\n\n**Case: for exactly one** $j \\leq n$, $e_j < \\pi$, and $e_j = z.\\tilde{g}$ where $\\tilde{g} < \\tilde{f}$ and $\\tilde{g} \\neq \\epsilon$. Again, we don’t use $\\text{arg}g_{n+1}$; the definitions of $\\tilde{s} \\triangleq s$ and $\\tilde{s}' \\triangleq s'$ are again trivial. Let $\\tilde{h}$ be such that $\\pi = z.\\tilde{g}; \\tilde{h}$; it is easy to see that $\\tilde{h} \\neq \\epsilon$. We set $\\rho = \\text{def} \\text{arg}g_j.\\tilde{f}.$\n\nWe define a heap $\\tilde{h}$ as the subheap of $h$, reachable from any $e_i$; that is, $\\tilde{h}$ is the smallest subheap of $h$ whose domain includes any address of the form $(e_i)_{s, h, f}$ and which is closed under the image of $h$. This is well-defined to the well-behavedness of $s, h$. We fix as $h_\\circ \\triangleq \\overline{h}$ and, i.e., the remainder heap after removing $\\tilde{h}$. It should be easy to see that $[\\rho]_{\\tilde{s}, \\tilde{h}}$ is defined. By Lemma B.6, there exists a trace $\\tau'' \\in [\\text{mbody}(m)](\\tilde{s} :: s, \\tilde{h}, l)$ such that $\\text{last}(\\tau'') = (\\tilde{s'} :: s, h', l')$ and $h' = h_0 \\cup \\tilde{h}'$.\n\nWe now show that $\\rho = \\text{arg}g_j.\\tilde{f}$, $\\tilde{h}$ is disconnected and acyclic in $\\tilde{s}, \\tilde{h}$.\n\nIt is easily seen by the definition of $\\tilde{h}$ that $h_{\\pi}' \\supset h_{\\pi}' \\circ \\overline{h}_\\circ = h_{\\pi}' \\circ h_{\\pi}' \\circ \\overline{h} \\circ$ and $[\\pi]_{s, h} = [\\rho]_{s, h}$$\\circ [\\rho]_{s, h}$, therefore also $\\text{dom}(h_{\\pi}') \\supset \\text{dom}(h_{\\pi}') = \\text{dom}(h_{\\pi}')$.\n\n1. First case of disconnectedness: We need to show that for all variables $x \\neq \\text{arg}g_j$, $\\tilde{s}(x) \\notin \\text{locn}(h_{\\pi})$, or, that for all $i \\leq n$ and $i \\neq j$, $\\tilde{s}(\\text{arg}g_j) = [e_i]_{s, h} \\notin \\text{locn}(h_{\\pi}) = \\text{locn}(h_{\\pi})$. By the assumption of this case, for all $i \\neq j$, $i \\leq n$ it is the case that $e_i \\neq \\pi$. If $e_i$ is a variable, then by the disconnectedness of $\\pi$ we have $[e_i]_{s, h} \\notin \\text{locn}(h_{\\pi})$. If $e_i$ is a path, by Lemma B.3, it follows that $[e_i]_{s, h} \\notin \\text{dom}(h_{\\pi})$. Thus, by the contrapositive of the 2nd clause of disconnectedness of $\\pi$, $[e_i]_{s, h} = h([e_i]_{s, h}) \\notin \\text{locn}(h_{\\pi})$. This suffices because $\\text{dom}(h_{\\pi}) \\supset \\text{dom}(h_{\\pi})$.\n\n2. Second case of disconnectedness: We need to show that for all $\\alpha \\in \\text{dom}(\\tilde{h})$, if $\\tilde{h}(\\alpha) \\in \\text{locn}(h_{\\pi})$, then $\\alpha \\in \\text{dom}(h_{\\pi})$. This is true by the construction of $\\tilde{h}$ and the disconnectedness of $\\pi$ in $s, h$.\n\nAcyclicity of $\\rho$ in $\\tilde{s}, \\tilde{h}$ follows the acyclicity of $\\pi$ in $s, h$ and the fact that $\\tilde{h} \\subseteq h$.\n\nApplication of Lemma 6.6: Note that $\\alpha(\\cdot)$ is monotonic: $\\tau' \\preceq \\tau$, thus $\\alpha(\\{\\tau'_\\text{push} \\triangleright \\tau'\\})_W \\subseteq \\alpha(\\{\\tau\\})_W$. Thus, from the top-level assumption about the $W$ component of the abstraction of $\\tau$ follows that, also, $\\forall \\epsilon \\in \\alpha(\\{\\tau'_\\text{push} \\triangleright \\tau'\\})_W. \\epsilon \\neq \\pi$. By the definition of exec for $\\text{push}()$, this means $\\forall \\epsilon \\in \\alpha(\\{\\tau'\\})_W[\\text{arg}g_{i-\\pi'_{l-1}}]. \\epsilon \\neq \\pi$, but $\\alpha(\\tau')_W = \\alpha(\\tau'')_W$ (because $\\tau' = \\tau''$), thus $\\forall \\epsilon \\in \\alpha(\\{\\tau''\\})_W[\\text{arg}g_{i-\\pi'_{l-1}}]. \\epsilon \\neq \\pi$. This means $\\forall \\epsilon \\in \\alpha(\\{\\tau''\\})_W. \\epsilon \\neq \\rho$, by the properties of substitutions, the definition of exec for load/stores, the fact that there are no procedure calls in $m$, and the fact that the root of $\\rho$ is $\\text{arg}g_j$ and thus not a local.\n\nWe now can apply Lemma 6.6 to obtain that $\\rho$ is preserved from $\\tilde{s}, \\tilde{h}$ to $\\tilde{s}', \\tilde{h}'$. Also, due to the stability assumption, it is clear that $\\tilde{s}(\\text{arg}g_j) = \\tilde{s'}(\\text{arg}g_j)$, thus $[\\rho]_{\\tilde{s}, \\tilde{h}} = [\\rho]_{\\tilde{s}, \\tilde{h}}$. Because $h' = h_0 \\cup \\tilde{h}'$, it is easy to check that $[\\rho]_{\\tilde{s}, \\tilde{h}} = [\\rho]_{\\tilde{s}, \\tilde{h}} = [\\pi]_{s, h'}$. By the same token, it can be shown that $\\text{dom}(h_{\\pi}') = \\text{dom}(h_{\\pi}')$ and that $\\pi$ is acyclic and disconnected in $s, h'$. □\nLemma 6.9. Let \\( \\tau \\) be a (prefix) trace produced by Lemma 5.6. If additionally it is the case that \\( \\forall e \\in \\alpha(\\{\\tau\\})_W. e \\neq \\pi \\) then \\( [\\pi]_{s,h} = [\\pi']_{s',h'} \\).\n\nProof. We prove by backwards induction on the prefixes \\( \\tau' \\prec \\tau \\) we show the following: Let \\( \\tau' = \\tau_1 \\uplus \\tau_{\\text{push}} \\uplus \\tau_0 \\) such that \\( \\tau_{\\text{push}} \\) is the last push() command in \\( \\tau' \\) that is unmatched by a pop(). Let \\( \\tau_{\\text{push}} = [(\\text{push}(e_1,\\ldots,e_n),s_0 :: s_1 :: S,h_0)] \\) and last(\\( \\tau' \\)) = \\( (\\ldots,s' :: s_1 :: S,h') \\). Let \\( \\pi' \\) be some path such that \\( \\pi'[\\theta] \\prec \\pi \\), where \\( \\theta = \\theta_0 :: \\_ \\) is the sequence of substitutions induced by the active calls at the end of \\( \\tau' \\). Then, \\( [\\pi']_{s',h'} = [e_j,\\bar{f}]_{s_0,h_0} \\) where \\( \\bar{f} \\) is such that \\( \\pi'[\\theta_0] = e_j \\).\n\nBy the definition of exec, the assumption \\( \\forall e \\in \\alpha(\\{\\tau\\})_W. e \\neq \\pi \\) and the fact that \\( \\pi'[\\theta] \\prec \\pi \\), we can conclude that \\( \\forall e \\in \\alpha(\\{\\tau_0\\})_W. e \\neq \\pi' \\). Thus, the trace \\( \\tau_0 \\) satisfies the conditions of Lemma 6.8, thus \\( \\pi' \\) is preserved from \\( s_0, h_0 \\) to \\( s_0, h' \\). It is easy to see that \\( s_0(\\text{root}(\\pi')) = s'(\\text{root}(\\pi')) \\), thus by Lemma B.5 \\( \\pi' \\) is preserved from \\( s_0, h_0 \\) to \\( s', h' \\). By the observation that \\( s_0(\\text{arg}_j) = [e_j]_{s_0,h_0} \\), and setting \\( \\bar{f} \\) to be such that \\( \\pi'[\\theta_0] = e_j \\), it can be seen that \\( [\\pi']_{s',h'} = [e_j,\\bar{f}]_{s_0,h_0} \\).\n\nAt the last step, \\( \\pi' = \\pi \\) and we are done. \\( \\square \\)\n\nLemma B.7. Given paths \\( \\pi_1 = x, \\bar{f} \\) and \\( \\pi_2 = y, \\bar{f} \\) (ie., paths with the same field sequence). Let \\( s_1, s_2 \\) be two stacks such that \\( s_1(x) = s_2(y) \\). Let \\( h, h' \\) be two heaps such that \\( h(\\cdot) \\subseteq \\text{dom}(h') \\) and, in addition, \\( \\forall \\alpha \\in \\text{dom}(h_{\\pi_1}^i) \\setminus \\{[\\pi_1]_{s_1, h} \\}, h(\\alpha) = h'(\\alpha) \\). Assume \\( \\pi_1 \\) is acyclic in \\( s_1, h \\). Then, \\( [\\pi_2]_{s_2, h} = [\\pi_2]_{s_2, h'} \\).\n\nProof. We apply Lemma B.1 letting \\( s = s_1 \\), \\( s' = s_2 \\) and \\( h = h' \\), obtaining \\( h_{\\pi_1}^i = h_{\\pi_2}^i \\).\n\nAs \\( \\pi_1 \\) is acyclic in \\( s_1, h \\), \\( s_1(x) = s_2(y) \\), we can easily conclude that \\( \\pi_2 \\) is acyclic in \\( s_2, h \\).\n\nFrom \\( h_{\\pi_1}^i = h_{\\pi_2}^i \\), we can conclude \\( \\text{dom}(h_{\\pi_1}^i) \\subseteq \\text{dom}(h') \\), since \\( h_{\\pi_1}^i \\subseteq \\text{dom}(h) \\subseteq \\text{dom}(h') \\).\n\nFrom the facts \\( \\forall \\alpha \\in \\text{dom}(h_{\\pi_1}^i) \\setminus \\{[\\pi_1]_{s_1, h} \\}, h(\\alpha) = h'(\\alpha) \\) and \\( h_{\\pi_1}^i = h_{\\pi_2}^i \\) and \\( [\\pi_1]_{s_1, h} = [\\pi_2]_{s_2, h} \\), we obtain by simple substitution \\( \\forall \\alpha \\in \\text{dom}(h_{\\pi_1}^i) \\setminus \\{[\\pi_1]_{s_1, h} \\}, h(\\alpha) = h'(\\alpha) \\).\n\nWe apply Lemma B.4 letting \\( \\pi = \\pi_2, s_2 = s = s' \\) and \\( h, h' \\) as here to obtain \\( [\\pi_2]_{s_2, h} = [\\pi_2]_{s_2, h'} \\). \\( \\square \\)\n\nLemma B.10. Let \\( \\pi_1 = x, \\bar{f} \\) and \\( \\pi_2 = y, \\bar{f} \\) such that \\( s_1(x) = s_2(y) \\) and \\( [\\pi_1]_{s_1, h} \\) is defined. Then for any \\( \\bar{g} \\leq \\bar{f}, [x, \\bar{g}]_{s_1, h} = [y, \\bar{g}]_{s_2, h} \\) and \\( h_{\\pi_1}^i \\downarrow x, \\bar{g} = h_{\\pi_2}^i \\downarrow y, \\bar{g} \\).\n\nProof. By induction on the length of \\( \\bar{g} \\), the fact that \\( s_1(x) = s_2(y) \\) and that \\( h \\) is a function. \\( \\square \\)\n\nLemma B.11. Let \\( \\pi_1 = x, \\bar{f} \\) and \\( \\pi_2 = y, \\bar{f} \\) such that \\( s_1(x) = s_2(y) \\). Let also \\( h, h' \\) be such that \\( \\text{dom}(h_{\\pi_1}^i) = \\text{dom}(h_{\\pi_2}^i) \\). If \\( \\pi_1 \\) is disconnected in \\( s_1, h' \\), then \\( \\pi_2 \\) is in \\( s_2, h' \\).\n\nProof. We need to show that (a) for any \\( v \\neq y, s_2(v) \\notin \\text{locn}(h_{\\pi_2}^i) \\), and (b) that for all \\( \\alpha \\) in \\( \\text{dom}(h') \\), if \\( h'(\\alpha) \\in \\text{locn}(h_{\\pi_2}^i) \\) then \\( \\alpha \\) is in \\( \\text{dom}(h_{\\pi_2}^i) \\).\n\nFor (a), note that \\( \\pi_2 \\) is disconnected in \\( s_2, h \\) so for any \\( v \\neq y, s_2(v) \\notin \\text{locn}(h_{\\pi_2}^i) \\). But \\( \\text{locn}(h_{\\pi_2}^i) = \\text{locn}(h_{\\pi_2}^i) \\) because \\( \\text{dom}(h_{\\pi_2}^i) = \\text{dom}(h_{\\pi_2}^i) \\), completing the proof.\nFor (b) observe that by Lemma B.10, $h'_{\\gamma_{s_1}} = h'_{\\gamma_{s_2}}$, thus we only need to show that for all $\\alpha \\in \\text{dom}(h')$, if $h'(\\alpha) \\in \\text{locn}(h'_{\\gamma_{s_1}})$ then $\\alpha \\in \\text{dom}(h'_{\\gamma_{s_2}})$. This is immediate by the disconnectedness of $\\pi_1$ in $s_1, h'$.\n\n**Lemma B.12.** Let $\\pi_1 = x.\\tilde{t}$ and $\\pi_2 = y.\\tilde{t}$ such that $s_1(x) = s_2(y)$. If $\\pi_1$ is acyclic in $s_1, h$ then so is $\\pi_2$ in $s_2, h$.\n\n**Proof.** Since $\\pi_1$ is acyclic in $s_1, h$ we know that for any $\\tilde{t}' \\preceq \\tilde{t}, h([x.\\tilde{t}']_{s_1, h}) \\neq \\text{locn}([y.\\tilde{t}']_{s_2, h})$. By Lemma B.10, we know that $[x.\\tilde{t}']_{s_1, h} = [y.\\tilde{t}']_{s_2, h}$ and $[x.\\tilde{t}'']_{s_1, h} = [y.\\tilde{t}''']_{s_2, h}$, thus $h([y.\\tilde{t}''']_{s_2, h}) \\neq \\text{locn}([y.\\tilde{t}''']_{s_2, h})$, as required.\n\n**Theorem 6.10.** Let $C_1, C_2$ be two programs such that $\\llbracket C_1 \\rrbracket_{\\perp_D} = \\langle W_1, \\ldots, A_1 \\rangle$. Let $\\pi_1$ be two paths and $c_1$ two commands such that $(c_1, L_1) \\in A_1$, and,\n\n- $\\pi_1 = v_1.\\tilde{t}$ and $\\pi_2 = v_2.\\tilde{t}$ (i.e., the field sequences are the same);\n- $\\forall e_i \\in W_i, c_i \\neq \\pi_i$ (for $i \\in \\{1, 2\\}$);\n- $c_1 = (\\pi_1 := x)$ and $c_2 = (\\pi_2 := y)$, or, $c_1 = (\\pi_1 := x)$ and $c_2 = (y := \\pi_2)$;\n- $L_1 + L_2 \\leq 1$.\n\nThen there exists a well-behaved state $\\zeta = \\langle s_1, s_2, h, (0, 0) \\rangle$ and a concurrent trace $\\tau \\parallel \\in \\llbracket C_1 \\| C_2 \\rrbracket \\zeta$ that races.\n\n**Proof.** w.l.o.g. we take $L_1 = 0$, as at least one of $L_1, L_2$ must be zero.\n\nGiven the two paths share the same field accesses ($\\tilde{t}$), Lemma B.7 provides a a well-behaved state $\\zeta = \\langle (s_1, s_2), h, (0, 0) \\rangle$ such that $[\\pi_1]_{s_1, h} = [\\pi_2]_{s_2, h}$ and where $\\pi_i$ is disconnected and acyclic in $s_i', h$.\n\nBy assumption, $\\llbracket C_1 \\rrbracket_{\\perp_D} = \\langle W_1, \\ldots, A_1 \\rangle$, thus by Theorem 5.15, $\\llbracket W_1, \\ldots, A_1 \\rrbracket = \\alpha([C_1] \\langle s_1, h, 0 \\rangle)$. Thus Lemma 5.6 implies there is a trace in $\\llbracket C_1 \\rrbracket \\langle s_1, h, 0 \\rangle$ and a shortest prefix $\\tau_1$ of that trace, whose last state is $\\langle c'_1, \\ldots, L_1 \\rangle$, and:\n\n- $c'_1, c_1$ are both stores or loads;\n- $\\exists \\pi_1' \\in A'_1$ such that $\\pi_1' = \\langle \\ldots, \\langle c'_1, \\ldots, L_1 \\rangle, \\delta_1 \\rangle$ where $\\pi_1 \\in A'_1$;\n- a path $\\pi_1'$ such that $c' = (x := \\pi_1')$ or $c' = (\\pi_1' := x)$, and $\\{\\pi_1'\\} = \\{\\pi_1\\} \\delta_1$.\n\nDefine the following functions. Each maps a single-thread state to a two-thread trace, with the given parameter as the stack of the \"other\" thread, and zero as its lock context.\n\n- left($\\langle c, S, h, L \\rangle, S' \\rangle = \\langle c \\parallel e, (S, S'), (L, 0) \\rangle$\n- right($\\langle c, S, h, L \\rangle, S' \\rangle = \\langle e \\parallel c, (S', S), (0, L) \\rangle$\n\nWe construct a concurrent trace $\\tau_1 \\parallel$ and its last state as follows:\n\n$$\\tau_1 \\parallel = \\langle \\text{left}(\\zeta_i, s_2) \\mid \\zeta_i \\text{ is the } i\\text{-th state in } \\tau_1, 1 \\leq i < |\\tau_1| \\rangle$$\n\n$$\\text{last}(\\tau_1) = \\langle \\ldots, (s'_1 \\:: \\ldots, s_2, h', (L'_1, 0)) \\rangle$$\n\nthat is, $C_1$ progresses along $\\tau_1$, but without executing the instruction $c'_1$, while $C_2$ never takes a step. Observe that by construction, $L_1' = 0$, as $c'_1$ is not an unlock() instruction (thus $L_1' = L_1$), and by assumption $L_1 = 0$.\n\nWe show that the state $s_2, h'$ is well-behaved. We know that $s_1, h'$ is well-behaved, by Lemma 5.3. Thus, for any address $\\alpha \\in \\text{dom}(h')$, $h'(\\alpha) \\in \\text{locn}(h')$, taking care of the second clause of well-behavedness. For the first clause, observe that $s_2, h$ is well-behaved thus for any variable $x, s_2(x) \\in \\text{locn}(h)$. But as $\\text{dom}(h) \\subseteq \\text{dom}(h')$ by Lemma B.8, it follows that $\\text{locn}(h) \\subseteq \\text{locn}(h')$, thus $s_2(x) \\in \\text{locn}(h')$ too.\n\nThus, we have $\\llbracket C_2 \\rrbracket_{\\perp_D} = \\langle W_2, \\ldots, A_2 \\rangle = \\alpha([C_2] \\langle s_2, h', 0 \\rangle)$. By identical reasoning as with $C_1$ we obtain a trace in $\\llbracket C_2 \\rrbracket \\langle s_2, h', 0 \\rangle$ and a shortest prefix trace $\\tau_2$ of that, whose last state is $\\langle c'_2, \\ldots, L_2 \\rangle$ where\nWe argue that π is also acyclic in \\(\\pi\\) and by Lemma B.10 and the fact that \\(\\tau\\) semantically (Figure 6) and the observation that as \\(\\tau\\) \\(\\parallel\\) ends at a state with lock context (0, 0), the side-condition for lock commands in \\(\\tau\\) \\(\\parallel\\) is satisfied by construction. 10\n\nWe now show that \\([\\pi_1]_{s_i', h'\\parallel\\tau_2} = [\\pi_2]_{s_2', h''}\\parallel\\tau_2\\), establishing that the next instruction following \\(\\tau\\) \\(\\parallel\\) will necessarily access the same address. By construction we have\n\n\\[\n[\\pi_1]_{s_i, h} = [\\pi_2]_{s_2, h} \\\\\n\\}\n\\]\n\nBy assumption, \\(\\forall e \\in W_i, e \\neq \\pi_i\\). We apply Lemma 6.8 on \\(\\tau_1\\) to obtain that \\(\\pi_1\\) is preserved from \\(s_i, h\\) to \\(s_i', h'\\),\n\n\\[\\pi_1 \\text{ is preserved from } s_i, h \\text{ to } s_i', h'\\] (3)\n\nLemma 6.9 gives us\n\n\\[\\pi_1 \\text{ is preserved from } s_i, h \\text{ to } s_i', h'\\] (4)\n\nFrom (3) we have \\(\\forall \\alpha \\in \\text{dom } (h_{\\pi_1}^{s_1}) \\setminus \\{[\\pi_1]_{s_1, h}\\}, h(\\alpha) = h'(\\alpha). By (2) we have \\(h_{\\pi_2}^{s_2} = h_{\\pi_2}^{s_2}\\) and \\([\\pi_1]_{s_1, h} = [\\pi_2]_{s_2, h}\\), thus \\(\\forall \\alpha \\in \\text{dom } (h_{\\pi_2}^{s_2}) \\setminus \\{[\\pi_2]_{s_2, h}\\}, h(\\alpha) = h'(\\alpha). In addition, by (2), \\pi_2\\) is acyclic in \\(s_2, h\\). Clearly, \\(\\text{dom } (h') \\subseteq \\text{dom } (h')\\) by Lemma B.8. Thus Lemma B.9 gives\n\n\\[\\pi_2 \\text{ is preserved from } s_2, h \\text{ to } s_2', h'\\] (5)\n\nThe state \\(s_2, h'\\) is well-behaved as shown above. Since \\(\\pi_1\\) is acyclic in \\(s_1, h'\\) (3), by Lemma B.12, \\(\\pi_2\\) is also acyclic in \\(s_2, h'\\). Observe that \\(\\text{dom } (h_{\\pi_2}^{s_2}) = \\text{dom } (h_{\\pi_2}^{s_2})\\) (2), \\(\\text{dom } (h_{\\pi_2}^{s_2}) = \\text{dom } (h_{\\pi_2}^{s_2})\\) (3), and by Lemma B.10 and the fact that \\(s_2(\\text{root } (\\pi_2)) = s_1(\\text{root } (\\pi_1))\\),\n\n\\[h_{\\pi_2}^{s_2} = h_{\\pi_2}^{s_2}\\] (6)\n\nthus \\(\\text{dom } (h_{\\pi_2}^{s_2}) = \\text{dom } (h_{\\pi_2}^{s_2})\\). Lemma B.11 applies, therefore \\(\\pi_2\\) is disconnected in \\(s_2, h'\\). Thus,\n\n\\[\\pi_2 \\text{ is preserved from } s_2, h \\text{ to } s_2', h'\\] (7)\n\nThis means we can apply Lemma 6.8 to \\(\\tau_2\\) and obtain that\n\n\\[\\pi_2 \\text{ is preserved from } s_2, h' \\text{ to } s_2, h''\\] (8)\n\nand Lemma 6.9 yields\n\n\\[\\pi_2 \\text{ is preserved from } s_2, h' \\text{ to } s_2, h''\\] (9)\n\nChaining (4), (3), (2), (5) and (9), we conclude \\([\\pi_1']_{s_1', h''} = [\\pi_2]_{s_1', h''}\\), thus establishing the existence of a race as per Definition 3.5.\n\n\\[\\square\\]\n\nFigure 6 defines a prefix-closed semantics so we need not concern ourselves with what happens after the race."}}},{"rowIdx":192,"cells":{"id":{"kind":"string","value":"1f4b7458cd40bf3901714ee14765f04ed1978de6"},"text":{"kind":"string","value":"StarSQL™ for UNIX\nUser’s Guide\n\nVersion 6.5\nStatement of Limitations on Warranty & Liability\n\nStelo makes no representations or warranties about the suitability of the software and documentation, either expressed or implied, including but not limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement. Stelo shall not be liable for any damages suffered by licensee as a result of using, modifying, or distributing this software or its derivatives.\n\nStarSQL™ is a trademark of StarQuest Ventures, Inc. All trademarks or registered trademarks are the property of their respective owners.\n## Contents\n\n### Introduction\n- StarSQL for UNIX Driver .................................................. 9\n- The ODBC Driver Manager .................................................. 10\n\n### Network Requirements\n- Network Protocols ............................................................ 11\n- Supported Db2 Host Systems ............................................... 11\n\n### Data Type Mappings\n- Data Type Mappings .......................................................... 12\n\n### Documentation\n- Quick Path to Using StarSQL .............................................. 13\n- StarSQL Product Documentation ........................................... 14\n - User’s Guide ...................................................................... 14\n - Release Notes ..................................................................... 14\n - Command Manual Pages. .................................................... 14\n\n### Contacting Stelo\n- Contacting Stelo ................................................................. 15\n- Support ................................................................................. 15\n- Sales and Service ............................................................... 15\n\n### Installing 32-bit StarSQL for UNIX ..................................... 17\n\n### Installing 64-bit\n- StarSQL for UNIX ............................................................... 19\n- Client Computer Requirements ............................................ 19\n- Determining Application Architecture ................................. 19\n- StarSQL for UNIX 64-bit Driver Installation ......................... 20\n- Removing StarSQL ............................................................. 20\n\n### Using StarSQL for UNIX ..................................................... 21\n- Licensing Stelo Products ..................................................... 21\n - Node-Locked License ....................................................... 21\n - Floating License .............................................................. 21\n - Configuring a StarSQL License .......................................... 22\nCustomizing the unixODBC Driver Manager Configuration ................. 23\nConfiguring Data Sources .................................................. 24\nTesting the StarSQL/Db2 Connection ...................................... 25\n Testing the Network Connection ........................................ 25\n Testing the Connection .................................................. 26\n Using the isql Utility to Test Connections ............................ 26\nUsing StarSQL with ODBC Applications ................................... 27\nDeveloping ODBC Applications for StarSQL ............................. 27\nSupporting Two-Phase Commit ............................................. 27\n\nPreparing Hosts for StarSQL Access .................................... 29\nPreparation Required for All Hosts ...................................... 29\n User Accounts ............................................................ 30\n Permissions ............................................................... 31\nPreparing Db2 on an z/OS Host .......................................... 31\n Configuring DDF .......................................................... 31\n Starting DDF .............................................................. 32\n Supporting Password Management Using DRDA Flows ............... 32\nUsing StarSQL with Stored Procedures ................................. 33\n Registering Stored Procedures ....................................... 33\n Calling Stored Procedures ........................................... 34\n Configuring SSL for Db2 for z/OS .................................. 34\nPreparing a Db2 for i Host ................................................. 34\n Creating a Library for SQL Packages ................................ 35\n Determining the RDB Name ............................................. 35\n Enabling DRDA Over TCP/IP .......................................... 35\n Configuring SSL on Db2 for i ........................................ 37\n Registering Stored Procedures on IBM i ............................. 38\n Considerations for Specific IBM i Releases ........................ 38\nPreparing a Db2 for LUW Host ............................................. 38\n Enabling DRDA Support for TCP/IP .................................. 38\n Using db2 Commands to Specify the DRDA Port .................... 39\n Configuring SSL for Db2 UDB 9.7 & later: .......................... 40\n Configuring SSL for DB2 UDB 9.1 & 9.5: ............................ 41\n Enabling Encryption .................................................... 41\n Using db2 Commands to Enable Encryption ........................ 41\n Locating the Database Name ........................................... 42\nPreparing a Derby Network Server Host ................................. 42\nContents\n\nSetting Network Server Properties ............................................. 42\nEnabling Remote Connections .................................................. 43\nConfiguring Support for the SSL Protocol ................................. 43\n\nBinding Packages ............................................................... 45\nCompatibility Among SQL Catalog Packages ............................... 45\nBinding Packages with the Explain Option Enabled ....................... 46\nCatalog Package ....................................................................... 47\nDynamic SQL Packages .......................................................... 47\nPermissions for Packages ........................................................ 49\nStatic and Catalog Packages ..................................................... 50\nDynamic SQL Packages .......................................................... 50\nGranting Use Permissions ......................................................... 50\nFor Db2 for z/OS ...................................................................... 50\nFor Db2 LUW (Linux, Unix & Windows) ....................................... 51\nFor Db2 for i ........................................................................... 51\nAutoBind Option ..................................................................... 51\n\nManually Installing 32-bit StarSQL for UNIX ............................... 53\nThe 32-bit StarSQL for UNIX is now deprecated ......................... 53\n\nManually Installing 64-bit StarSQL for Linux ............................... 55\n\nStarSQL for UNIX Command Reference ...................................... 57\nsimpleconn .............................................................................. 58\nstarlic-clientcfg ................................................................. 60\nstarping ............................................................................... 62\ntrcstart ................................................................................. 63\n\nCustomizing the StarSQL for UNIX Configuration ....................... 65\nSetting Global DSN Parameters ................................................. 65\nGlobal DSN Keywords ............................................................ 66\n AlwUpd ............................................................................ 66\n AutoTypDefOvr .............................................................. 66\n CacheUID ......................................................................... 67\nContents\n\nExplain........................................................................... 67\nSetting Up System and User DSN Files .............................. 67\nSample DSN File ................................................................ 69\nSystem and User DSN Keywords ...................................... 71\n Accounting ..................................................................... 71\n AllowSynonyms ............................................................. 72\n AlwaysWide ................................................................... 72\n AutoBind ....................................................................... 72\n AutoSqlSet ..................................................................... 73\n AutoTypDefOvr .............................................................. 74\n BinaryCCSID .................................................................. 74\n BindRules ....................................................................... 74\n CacheUID ...................................................................... 75\n CatFilters ...................................................................... 75\n CatQual ......................................................................... 75\n CharacterSubstituion ..................................................... 76\n CreateTable ..................................................................... 76\n CustomizePrdid .............................................................. 77\n DefaultQualifier ............................................................ 77\n Description .................................................................... 77\n FetchAhead ..................................................................... 77\n FoldUIDPWD ................................................................... 77\n GetInfoCatalogUsage .................................................... 78\n HeldCursors ................................................................... 78\n HideTsScale ................................................................... 79\n IncludeSynonyms ........................................................... 79\n IsolationLevel .................................................................. 79\n KeepDynamic ................................................................... 81\n LongStrParams ............................................................... 81\n MaxRows ......................................................................... 81\n OverrideCodeset ............................................................ 82\n PkgOwnID ...................................................................... 82\n QryBufSiz ....................................................................... 82\n ReadOnly ......................................................................... 82\n SpecialColumns .............................................................. 83\n SSL ................................................................................. 83\n SSLOptions ..................................................................... 83\n StrictParsing .................................................................... 83\n<table>\n<thead>\n<tr>\n<th>Contents</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>TrustedConnection</td>\n<td>84</td>\n</tr>\n<tr>\n<td>TwoPC</td>\n<td>84</td>\n</tr>\n<tr>\n<td>TypDefOvr</td>\n<td>84</td>\n</tr>\n<tr>\n<td>UseDSCLRDBTBL</td>\n<td>85</td>\n</tr>\n<tr>\n<td>UseDynamicCatalogSQL</td>\n<td>85</td>\n</tr>\n<tr>\n<td>UseEncryption</td>\n<td>85</td>\n</tr>\n<tr>\n<td>UseJumboPackages</td>\n<td>86</td>\n</tr>\n<tr>\n<td>UseSYSDUMMYAEU</td>\n<td>86</td>\n</tr>\n<tr>\n<td>StarLicense Client Configuration Utility</td>\n<td>89</td>\n</tr>\n<tr>\n<td>Adding a Node-locked License</td>\n<td>90</td>\n</tr>\n<tr>\n<td>Adding a Connection to a StarLicense Server</td>\n<td>90</td>\n</tr>\n<tr>\n<td>Removing a StarLicense Server Definition</td>\n<td>91</td>\n</tr>\n<tr>\n<td>Testing License Checkout</td>\n<td>91</td>\n</tr>\n<tr>\n<td>Displaying the StarLicense Configuration</td>\n<td>91</td>\n</tr>\n<tr>\n<td>Setting the StarLicense Client Logging Level</td>\n<td>92</td>\n</tr>\n<tr>\n<td>StarSQL National Language Support</td>\n<td>93</td>\n</tr>\n<tr>\n<td>Character Encoding of Data Across Systems</td>\n<td>94</td>\n</tr>\n<tr>\n<td>StarSQL and Unicode</td>\n<td>94</td>\n</tr>\n<tr>\n<td>Determining and Setting the Client Code Page</td>\n<td>95</td>\n</tr>\n<tr>\n<td>Determining the Host Code Page</td>\n<td>95</td>\n</tr>\n<tr>\n<td>StarSQL Implementation Details</td>\n<td>95</td>\n</tr>\n<tr>\n<td>Customizing StarSQL for National Language Support.</td>\n<td>96</td>\n</tr>\n<tr>\n<td>Connecting an MBCS Client to an SBCS Host</td>\n<td>97</td>\n</tr>\n<tr>\n<td>Supporting Asian Languages with Extended EBCDIC</td>\n<td>97</td>\n</tr>\n<tr>\n<td>Currently Supported CCSIDs</td>\n<td>98</td>\n</tr>\n<tr>\n<td>Glossary</td>\n<td>99</td>\n</tr>\n<tr>\n<td>Index</td>\n<td>103</td>\n</tr>\n</tbody>\n</table>\nStarSQL is available as an ODBC driver for Windows- and UNIX-based computers, and as a JDBC driver for any computer that has the Java Runtime Engine (JRE) or Java Virtual Machine (JVM) installed.\n\nThe StarSQL software is not copy protected, rather the usage is limited based upon the maximum number of concurrent connections (“CCs”) licensed. The Stelo license allows for you to install and run any of the StarSQL drivers on any number of client computers, subject to terms of the license grant. CCs may be made available for clients on a single computer (“Node-locked License”) or any computer on the network (“Floating License”).\n\nThe StarSQL for UNIX Driver\n\nThe StarSQL for UNIX driver is an Unicode driver that is compliant with the ODBC v3.0 specification. The StarSQL driver resides on the UNIX client computer, and the data resides in a Db2 database on a host computer.\n\nThe StarSQL driver performs the following functions to enable ODBC applications to communicate with a Db2 host:\n\n- provides a programmatic interface for executing dynamic SQL functions\n- provides transparent translation of character encoding between different client and host operating systems\n\nStarSQL for UNIX supports directly connecting to a Db2 host in a TCP/IP or SSL-encrypted network.\nBeginning with v6.5, StarSQL for UNIX is available only as a 64-bit version. Contact Stelo Support for a legacy version if you need 32-bit support.\n\nThis User’s Guide describes how to install, configure, and use the StarSQL for UNIX driver. Refer to the product documentation that is included with the StarSQL for Java or StarSQL for Windows driver to install, configure, and use those versions of the driver.\n\nThe ODBC Driver Manager\n\nAn ODBC driver manager works with an ODBC driver to provide interoperability among multiple types of databases (such as Db2 and Oracle), and runtime binding to a data source. This allows an application to link only with the driver manager shared object (such as libodbc.so on Linux), eliminating dependencies on which ODBC driver will be used.\n\nStarSQL for UNIX uses the unixODBC driver manager that is distributed with recent Linux distributions. unixODBC is an open source project available under the GNU Library General Public License (LGPL). For more information about unixODBC, see http://www.unixodbc.org.\n\nThe ODBC Driver Manager maintains a repository of the installed ODBC drivers, including the StarSQL driver, in a file named odbcinst.ini. The configuration information for system data sources, including those used by the StarSQL driver, are stored in a file named odbc.ini. As shown in the following illustration, the ODBC Driver Manager uses the information in the driver repository and the data source configuration to load the appropriate driver. The StarSQL driver manages the data that is sent between the client and host computers.\n\nFigure 1. StarSQL Driver and ODBC Driver Manager Enable UNIX Client to Communicate with Db2 Host\nThe ODBC driver manager resolves data source names and ensures that the proper driver is loaded and unloaded at the appropriate time. The driver manager also maps calls from applications developed to the ODBC v2 API to the ODBC v3 API so the applications based on v2 can run under the v3 standard without modification.\n\nNetwork Requirements\n\nThe network requirements for using StarSQL and a list of the supported Db2 hosts are provided below. Because the StarSQL configuration involves the client computer, the network, and the host, several individuals may be involved with setting up the StarSQL environment.\n\nNetwork Protocols\n\nStarSQL for UNIX supports TCP/IP or SSL access to a Db2 host. Connections can also be made through a StarPipes gateway.\n\nSupported Db2 Host Systems\n\nBefore using StarSQL on the UNIX computer, the host must be prepared as described in \"Preparing Hosts for StarSQL Access\" on page 29. You will need information about the network and the host databases, as described in \"Preparation Required for All Hosts\" on page 29, to configure StarSQL data sources after StarSQL is installed. Refer to the Release Notes (readme) for the latest information about which Db2 versions are supported.\n\nStarSQL for UNIX can connect to any of the following host databases:\n\n- Db2 for z/OS\n- Db2 for i (formerly known as DB2/400, DB2 UDB for iSeries, and DB2 for i5/OS)\n- Db2 for Linux, UNIX, and Windows (Db2 LUW)\nData Type Mappings\n\nStarSQL v5 added support for Db2 LOB data types. The Db2 types are mapped to ODBC SQL types as shown in Table 1:\n\nTable 1. Mapping of Db2 Data Types to ODBC SQL Data Types\n\n<table>\n<thead>\n<tr>\n<th>Db2 Type</th>\n<th>StarSQL ODBC SQL Type</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>BLOB</td>\n<td>SQL_LONGVARBINARY</td>\n</tr>\n<tr>\n<td>CLOB</td>\n<td>SQL_LONGVARCHAR</td>\n</tr>\n<tr>\n<td>DBCLOB</td>\n<td>SQL_LONGVARCHAR</td>\n</tr>\n</tbody>\n</table>\n\nAs shown in Table 2, StarSQL v5 changes the mapping for Db2 long strings—they are no longer differentiated from short strings:\n\nTable 2. Mapping of Db2 Strings\n\n<table>\n<thead>\n<tr>\n<th>Db2 Type</th>\n<th>StarSQL v4.x ODBC SQL Type</th>\n<th>StarSQL v5 and v6 ODBC SQL Type</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>VARCHAR</td>\n<td>SQLVARCHAR</td>\n<td>SQLVARCHAR</td>\n</tr>\n<tr>\n<td>LONG VARCHAR</td>\n<td>SQL_LONGVARCHAR</td>\n<td>SQLVARCHAR</td>\n</tr>\n<tr>\n<td>VARGRAPHIC</td>\n<td>SQLVARCHAR</td>\n<td>SQLVARCHAR</td>\n</tr>\n<tr>\n<td>LONG VARGRAPHIC</td>\n<td>SQL_LONGVARCHAR</td>\n<td>SQLVARCHAR</td>\n</tr>\n<tr>\n<td>VARCHAR FOR BIT DATA</td>\n<td>SQLVARBINARY</td>\n<td>SQLVARBINARY</td>\n</tr>\n<tr>\n<td>LONG VARCHAR FOR BIT DATA</td>\n<td>SQL_LONGVARBINARY</td>\n<td>SQLVARBINARY</td>\n</tr>\n</tbody>\n</table>\nThese new mappings affect ODBC SQL catalog query results. For example, SQLColumns for a Db2 LONG VARCHAR returns ODBC type SQL_VARCHAR for a package bound by StarSQL v5. If StarSQL v4.x uses packages bound by StarSQL v5, catalog queries will return the new StarSQL v5 results, but otherwise the driver should run as before.\n\nParameters for SQL statements are also affected. If an application binds a parameter as SQL type SQL_LONGVARCHAR, it is sent as a Db2 CLOB. StarSQL v4.x sends SQL_LONGVARCHAR as a Db2 VARCHAR string.\n\nStarSQL has an optional data source setting, LongStrParams (see \"LongStrParams\" on page 81), for applications that require backwards compatibility for SQL_LONGVARCHAR (or SQL_LONGVARBINARY) parameters. This data source setting does not affect the types returned for result set columns, or for types returned by catalog queries.\n\nStarSQL no longer returns type SQL_FLOAT from SQLGetTypeInfo. StarSQL maps Db2 REAL to SQL_REAL, and Db2 DOUBLE to SQL_DOUBLE, and only these two floating point types are returned by SQLGetInfo. StarSQL still accepts SQL_FLOAT, as a synonym for SQL_DOUBLE, as a type, for example, for SQLBindCol.\n\nFor an introduction to LOB support in Db2 for z/OS, see the IBM Redbook \"Large Objects with DB2 for z/OS and OS/390\" (SG24-6571), available at http://www.redbooks.ibm.com.\n\n**Documentation**\n\nThere are many sources of information that can help you install, configure, and use the StarSQL driver. The following sections describe the information available from Stelo and provides references to other information that may be particularly useful.\n\n**Quick Path to Using StarSQL**\n\nStelo provides StarSQL Quick Start Guides that provide step-by-step instructions for quickly installing and using the StarSQL ODBC and JDBC driver on a particular computing platform. The procedures in the Quick Start Guides are appropriate for the most common environments and describe the fastest way to install and configure the software you need to begin using the driver. If you need to customize the StarSQL driver settings or have an environment for which the default values are not appropriate you can refer to the product documentation for details.\n\nAll the Quick Start Guides are listed at http://docs.stelodata.com/Supportdocs/browseQuickStarts.shtml.\nStarSQL Product Documentation\n\nThe StarSQL for UNIX product documentation consists of the following components:\n\n• this User’s Guide\n• Release Notes\n• Command Manual Pages\n• Technical documents in the Info Center (website)\n\nUser’s Guide\n\nThis User’s Guide provides information about installing the StarSQL software, and configuring a client license to use the driver. It also describes how to use the StarSQL driver and the utilities and programs that are included with it. Licensing is managed by StarLicense server software, which includes separate documentation for installing and configuring a StarLicense server.\n\nConventions\n\nThe StarSQL driver can be installed to a user-defined location. The User’s Guide shows $STARDIR to indicate the location where the StarSQL software is installed. Substitute the $STARDIR variable with the full pathname to the installation directory.\n\nRelease Notes\n\nThe Release Notes contain important information about using StarSQL for UNIX in specific environments, known limitations, and a history of changes to the driver software.\n\nCommand Manual Pages\n\nStarSQL for UNIX provides commands for viewing packages, testing connections, administering licenses, and troubleshooting. These commands are described in Appendix C on page 57 of this User’s Guide. You also can obtain information about the commands in the form of man pages, which are located in $STARDIR/man. Change to the $STARDIR/man directory and then enter the man command along with the name of the StarSQL command you want to display information about. The following example would display the man page for the starping command.\n\n# cd $STARDIR/man\n# man starping\nContacting Stelo\n\nPlease use the following methods to contact Stelo if you need to obtain a license key, or have suggestions or need information about Stelo products.\n\nSupport\n\nYou can obtain a license key for a Stelo product by sending an email to support@stelodata.com with the following information:\n\n- TCP/IP address or Host ID of the computer on which the license will be installed\n- Number of connections purchased\n- Company Name\n- Contact Name\n- Phone Number\n- Email Address\n\nStelo Support will send a reply email that provides the license key for your organization's use of the product. Since the license is unique to the computer on which it will be installed, you must contact Stelo should you need to move the license from one computer to another.\n\nAdditional technical support may be available subject to the prices, terms, and conditions specified in your organization's maintenance contract with Stelo.\n\nSales and Service\n\nIf you have ideas for product enhancements or need more information about Stelo products, please contact us via any of the following methods.\n\n<table>\n<thead>\n<tr>\n<th>Address</th>\n<th>Stelo, a StarQuest company.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>548 Market St, #22938</td>\n</tr>\n<tr>\n<td></td>\n<td>San Francisco, CA 94104-5401</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Telephone</th>\n<th>415-669-9619</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Option 1: Sales</td>\n</tr>\n<tr>\n<td></td>\n<td>Option 2: Technical Support</td>\n</tr>\n</tbody>\n</table>\n\n| Contact form | https://www.stelodata.com/contact-stelo |\n\n| World Wide Web | www.stelodata.com |\nIntroduction\nThe 32-bit version of StarSQL for UNIX has been deprecated.\nInstalling 32-bit StarSQL for UNIX\nThis chapter describes how to install and configure StarSQL for UNIX on a 64-bit computer. Be sure to review the Release Notes included in the distribution for important information about installing or upgrading the StarSQL for UNIX driver.\n\nStarSQL requires a license key to successfully connect to a Db2 host. You may want to obtain license keys, and install and configure the StarLicense software, before you install StarSQL. Licensing is further discussed in \"Licensing Stelo Products\" on page 21.\n\n**Client Computer Requirements**\n\nStarSQL for UNIX has been tested with the following UNIX operating systems:\n- Red Hat Enterprise or Oracle Linux 8.x and later (x64)\n- Other distributions of Linux may also work with the StarSQL driver.\n\n**Determining Application Architecture**\n\nBecause 32-bit and 64-bit applications can coexist on a 64-bit system, it can sometimes be difficult to determine whether an application is 64-bit or 32-bit. It’s important to know the application architecture because 32-bit applications require a 32-bit DSN and ODBC driver manager and 64-bit applications require a 64-bit DSN and ODBC driver manager.\n\nOn UNIX systems, you can use the file command to tell whether an application is 32-bit or 64-bit. To do this, locate the application binary and then run `file <application_binary>`. If the file is 64-bit, the command output will contain \"ELF 64-bit LSB executable\". If the file is 32-bit, the command output will contain \"ELF 32-bit LSB executable\".\nInstalling 64-bit StarSQL for UNIX\n\nStarSQL for UNIX 64-bit Driver Installation\n\nAfter you have downloaded StarSQL, follow the steps in this section to install the software.\n\n1. Logon to UNIX as root user.\n2. Change to the directory that contains the StarSQL installer.\n3. Enter the following command\n\n # rpm -U starsql64-version-1.x86_64.rpm\n\nThis command installs or updates StarSQL in the default location, /opt/stelo/starsql64 and adds [StarSQL64] and [StarSQL (64-bit)] sections to odbcinst.ini file to define the driver to the unixODBC driver manager.\n\nRemoving StarSQL\n\nTo remove StarSQL using the RPM Package Manager, issue the following command:\n\n# rpm -e starsql64\nStarSQL requires a license to successfully connect to a Db2 host. This chapter describes how to license and use StarSQL for UNIX.\n\n**Licensing Stelo Products**\n\nAll Stelo products are licensed for use. Each product setup contains a client module used to configure the specific license option used to enforce the use of the product. The licensing options allow you to use a node-locked license or a floating license.\n\n**Node-Locked License**\n\nA node-locked license allows you to use the Product on a single computer: The system must be using a static IP address.\n\n**Floating License**\n\nA floating license allows multiple computers using a Stelo product to share use of the software license. The software license can be used on any computer within a network provided that the number of concurrent requests does not exceed the limit allowed by the license. Generally, only one license server need be installed on a network, to service any number of clients.\n\nFor a floating license, in addition to the setup of Stelo product you will be provided with a StarLicense Server setup and a unique registration code to activate the license server. The *StarLicense Server for UNIX User’s Guide* contains details about installing and configuring the server software, but in general:\n\n- The StarLicense Server software should be installed on a network server.\n- The network server is usually identified by a unique, static IP address.\nThe StarLicense Server should be configured with license keys for one or more Stelo products.\n\nThe StarLicense Server controls the total number of concurrent connections within the network.\n\nFor a client to obtain a license from a StarLicense server the parameters of the network server where the StarLicense Server is installed are specified in the appropriate client license module on any computer using the Stelo product.\n\n### Configuring a StarSQL License\n\nWhen using a floating license, the StarLicense Server software can be located on a remote host or co-located on the same computer as the StarSQL driver. To configure StarSQL for UNIX to check out a license from a StarLicense server, you will need to specify:\n\n- the hostname or IP address of the StarLicense Server\n- the port on which the StarLicense Server is listening for license requests\n- the product ID of the license installed on the StarLicense Server\n\nThe hostname, port, and product ID specified for the client must match how that server is configured—contact the administrator responsible for configuring the StarLicense server(s) if you need details about how the server is configured.\n\nFor UNIX-based computers the necessary StarLicense client software is installed when you install the StarSQL driver.\n\nA StarLicense Client Configuration utility allows you to easily specify which StarLicense server to use when the UNIX client computer needs a connection.\n\n1. Log into the computer as `root` user.\n2. Change to the directory where StarSQL is installed.\n3. Enter the following command to start the configuration utility.\n \n ```bash\n # ./config-lic\n ```\n4. From the StarLicense Client Configuration Menu, select option 1, “Configure local StarLicense client to use a License Server.”\n\n5. Enter the hostname or IP address of the StarLicense server. (If the StarLicense server software is installed on the local computer you can specify the loopback address 127.0.0.1 or “localhost”.)\n\n6. Enter the number of the port on which the StarLicense server is listening for license requests.\n\n7. Enter the product ID of the license that is configured on the StarLicense server.\n\n8. After the connection to the StarLicense server has been added, select Option 3, “Test licensing checkout,” to verify that a license can be checked out.\n\nRefer to \"StarLicense Client Configuration Utility\" on page 89 for information about all the options available from the StarLicense Client Configuration Menu.\n\n**Customizing the unixODBC Driver Manager Configuration**\n\nThe unixODBC driver manager uses the file `odbcinst.ini` to keep track of which ODBC drivers are installed. The location of this file can vary, but typically is `/etc/odbcinst.ini`. You can locate the `odbcinst.ini` file using the `odbcinst` program provided with the unixODBC driver manager, as shown below.\n\n```\n$ odbcinst -j\n```\n\nThe `odbcinst` program shows the version of unixODBC that is installed, and the location of the files that specify the ODBC drivers (`odbcinst.ini`), the system DSNs (`odbc.ini`), and the user DSNs (`.odbc.ini`).\nConfiguring Data Sources\n\nA Data Source Name (DSN) definition controls how the StarSQL driver interacts with a specific data source. Each data source to which you want to connect using StarSQL must be defined in a text file named `odbc.ini` for system DSNs, and `~odbc.ini` for user DSNs. If there is a user DSN and system DSN with the same name, the user DSN is used.\n\nWhere possible, StarSQL supplies default configuration values in the example `odbc.ini` file that is distributed in the `$STARDIR/etc` directory. However, there are some values, such as specific names used in your environment, which you must configure.\n\n**Table 3. Minimum Data Source Configuration Parameters**\n\n<table>\n<thead>\n<tr>\n<th>Keyword</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>HostName=</td>\n<td>The host name refers to the name of the Db2 host system. Set the HostName field to either a TCP/IP host name (such as host5.mydomain.com) or a static IP address in dotted decimal notation (such as 198.147.235.1).</td>\n</tr>\n<tr>\n<td>PkgColID=</td>\n<td><em>optional</em> The SQL Package Collection ID indicates the location on the Db2 host of the packages required by StarSQL to execute Dynamic SQL. On Db2 for i, the SQL Package Collection ID is the name of the collection or library that contains the packages. On all other platforms, the Package Collection ID is the name of the virtual collection associated with these packages. If necessary, obtain the package collection ID from your Database Administrator. The default package collection ID is STARSQ.</td>\n</tr>\n<tr>\n<td>Port=</td>\n<td><em>optional</em> The Port designates the IP port on which the Db2 host is listening for incoming TCP/IP connection requests. The default port for DRDA communications is 446. For SSL communications, the typical port is 448.</td>\n</tr>\n</tbody>\n</table>\nRefer to \"Customizing the StarSQL for UNIX Configuration\" on page 65 for information about configuring global data source settings and a complete list of the DSN settings that are available for customizing the behavior of the StarSQL driver.\n\n### Testing the StarSQL/Db2 Connection\n\nAfter you install and configure StarSQL for UNIX, perform the procedures in this section to test that the client can connect to the Db2 host using StarSQL. To establish connectivity to a Db2 database, the host must be configured to accept connections from StarSQL. Refer to \"Preparing Hosts for StarSQL Access\" on page 29 if your host is not already configured for StarSQL connections.\n\n### Testing the Network Connection\n\nYou can use the `starping` command to test the network connection between StarSQL and the Db2 host. The `starping` command tests only the ability to connect to the Db2 host—it does not bind packages on the host or test that you have a valid license. Use the `simpleconn` command, described in the next section, to test for connectivity and proper configuration of StarLicense and the ODBC data source.\n\nTo run the `starping` command, enter the command and respond to the prompts for the data source name, user name, and password:\n\n```bash\n$ starping\nEnter Data Source: data source name\nEnter User Name: userid\nEnter Password: password\n```\nA successful connection returns the following message:\nConnection Succeeded!\n\nSee page 62 for more information about the starping command. If the connection does not succeed, make sure that the host has been properly configured for StarSQL connections, as described in \"Preparing Hosts for StarSQL Access\" on page 29. Contact Technical Support if you need further assistance.\n\nTesting the Connection\n\nStarSQL for UNIX includes a program named simpleconn that allows you to test that StarSQL can connect to a data source using the unixODBC driver manager. You must specify a user name and password of an account that is valid on the host and has permission to access the database. (See \"Preparation Required for All Hosts\" on page 29 for more information about user accounts and permissions.)\n\nEnter the following command, specifying a Data Source Name (DSN) and user account that is valid in your environment:\n\n```\nsimpleconn DSN UserId Password\n```\n\nFor example:\n\n```\n$ simpleconn DSN1 staruser starpass\nConnection #1\n Driver Name: libswodbc.a\n Driver Version: 5.30.1903\n Database Name: DB2 Universal DataBase\n Database Version: 08.021.0007\n\nConnection #2\n Driver Name: libswodbc.a\n Driver Version: 5.30.1903\n Database Name: DB2 Universal DataBase\n Database Version: 08.021.0007\n```\n\nUpon successful connection, the simpleconn command returns the database name, platform, and version, and the driver name and version. Refer to page 58 for more information about using the simpleconn command.\n\nUsing the isql Utility to Test Connections\n\nunixODBC includes the isql command line utility. You can use isql to test a connection but it is designed to be used by those experienced with the Structured Query Language (SQL). The isql utility allows you to:\n\n1. connect to a Data Source (using a DSN)\n2. send SQL commands to the Data Source\n3. receive results from the Data Source\n\nIn addition to supplying ad-hoc query commands such as `SELECT * FROM MYTABLE`, the \"help\" command can be used to make catalog calls. Type \"help help\" to see a list of available commands.\n\nA Unicode version of the utility “iusql” is also supplied.\n\nUsing StarSQL with ODBC Applications\n\nAfter you have configured data sources and tested that the StarSQL driver can use the unixODBC driver manager and check out a license, you can use StarSQL with any ODBC application to connect to a Db2 host. The method for selecting which data source to use from a specific application varies with each application; refer to the documentation for your application if you need details about how to configure the application to use a particular data source.\n\nDeveloping ODBC Applications for StarSQL\n\nThis section describes how to integrate an ODBC application to use the StarSQL driver and unixODBC driver manager.\n\nInstall the unixODBC-devel RPM package, which contains header files needed for building ODBC applications\n\n```\n# rpm -i unixODBC-devel\n```\n\nSince the header files are installed to /usr/include, and the libraries reside in /usr/lib64, you do not need to specify the include or lib directives.\n\nFollowing is an example:\n\n```\n$ cc myprog.c -lodbc -lc -o myprog\n```\n\nSee the shell script \"build\" in $STARDIR/samples/simpconn for examples of building a simple ODBC application that uses StarSQL to connect to a host.\n\nSupporting Two-Phase Commit\n\nIn a distributed processing environment where a unit of work spans more than one database, using the two-phase commit protocol can help ensure the integrity of the transaction and databases. When the two-phase commit protocol is in effect, the\ntransaction must complete successfully before it is committed. If the transaction fails, all of the updates are rolled back and the databases remain in the state they were before the transaction was begun.\n\nStarSQL for UNIX 6.40 and later support for the Open Group XA (eXtended Architecure). The interface for this support is based upon Microsoft’s ODBC XA Implementation as described here:\n\n\nUsing XA Transactions\n\nThis implementation may be further “wrapped” in a struct xa_switch_t style interface in the future.\n\nContact Stelo for an sample application that illustrates the use of the XA interface.\n\n**StarSQL configuration:**\n\nAdd the property 2PC=XA to your ODBC datasource by editing ~/.odbc.ini or adding it to the connection string,\n\nValues of 2PC are:\n\n- No\n- XA\n- Note that the value TCP/IP - “classic” 2PC support for Microsoft DTC is available only for StarSQL for Windows\nThis chapter describes how to prepare host systems to enable StarSQL to provide access to the host databases.\n\nIt covers:\n\n- Preparation required for all hosts\n- Preparing a Db2 for z/OS host\n- Preparing a Db2 for i host\n- Preparing a Db2 for Linux, UNIX, and Windows host\n- Preparing a Derby Network Server Host\n\nThese sections cover details of the Db2 environment that are pertinent to StarSQL. For complete documentation of installation and configuration on the host, consult IBM’s Db2 documentation, especially IBM’s DRDA Connectivity Guide (see \"Contacting Stelo\" on page 15 for details).\n\n**Preparation Required for All Hosts**\n\nRegardless of the host platform, you will need the information described in Table 4 to configure an ODBC data source that will use StarSQL to access the Db2 host. You may need to obtain this information from the Db2 administrator. The section \"Sample DSN File\" on page 69 contains details about configuring data sources.\nPreparing Hosts for StarSQL Access\n\n### Table 4. Host Information Required for Data Source Configuration\n\n<table>\n<thead>\n<tr>\n<th>Data Source Information Item</th>\n<th>Information Needed</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Package Collection Name</td>\n<td>The location of the SQL packages that StarSQL requires. The Package Collection Name on a Db2 for i host is the name of the library that contains the StarSQL packages. For Db2 for z/OS, it is the name of the virtual collection associated with these packages.</td>\n</tr>\n<tr>\n<td>Database Server Name</td>\n<td>The relational database name. On different Db2 hosts this may be referred to as Location Name, Global Resource Name, RDB name, Database Name, or dbname.</td>\n</tr>\n<tr>\n<td>User ID and Password</td>\n<td>A valid user id and password for logging into the database. The user account information is not stored in the DSN.</td>\n</tr>\n<tr>\n<td>TCP/IP Connection Information</td>\n<td>The host name and the port used for DRDA communications.</td>\n</tr>\n</tbody>\n</table>\n\nIn addition to properly preparing the host, each StarSQL user must have an account on the host and have permission to access the necessary packages.\n\n### User Accounts\n\nTo connect to a Db2 database, each StarSQL user needs an account on the host database. An account consists of a user ID and password.\n\nYou need to provide the user account information to each StarSQL user who needs to connect to the database.\nPermissions\n\nUsually a database administrator (DBA) is responsible for packages on the host, including binding them and granting permissions to use them. Depending on the host platform and the type of package used by the ODBC application, the DBA may need to grant StarSQL users explicit permissions to access data used by the application.\n\nPreparing Db2 on an z/OS Host\n\nPreparing Db2 on a z/OS host for access with StarSQL primarily involves configuring the Distributed Data Facility (DDF), which is a component of Db2 for z/OS. Its primary task is to process DRDA requests. DDF must be active for a desktop to connect to Db2 using StarSQL or any other DRDA requestor or client.\n\nConfiguring DDF\n\nIf your organization has not implemented distributed database capabilities, DDF may not be configured and activated. The DSNTINST CLIST provides two panels—DSNTIPR and DSNTIP5 for customizing a Db2 for z/OS subsystem to use native DRDA TCP/IP support. The DSNTIP5 panel is specific for TCP/IP.\n\nThe values specified on these panels are used to generate the JCL that stores them in the Db2 bootstrap data set (BSDS) communication record.\n\nIf you are installing Db2, use the DDF panel DSNTIPR and DSNTIP5 to provide the following parameters. To change the DDF parameters after installation, run a customized configuration job DSNTIJUZ to update the BSDS.\n\n- DDF Location Name. This name must be specified for the Database Server Name of the ODBC data source that StarSQL uses to connect to the host.\n- Password used when connecting Db2 to VTAM, if a password is required.\n- IP port to use for TCP/IP access. To enable support for TCP/IP, set the DRDA port in the DDF to 446.\n- IP port to use for two-phase commit. The RESYNC PORT parameter in the DSNTIP5 panel specifies a TCP/IP port number for processing requests for two-phase commit re synchronization. The RESYNC PORT must be different than the DRDA PORT, and it must match the port number specified for two-phase-commit recovery operations in the StarSQL Resource Manager. The StarSQL Resource Manager uses a default port value of 5020.\nFor more information about establishing connectivity between your desktop and Db2 for z/OS with TCP/IP, consult the Installation Guide for your version of Db2 for z/OS (see \"Documentation\" on page 13 for document details).\n\nFor more information about configuring DDF, consult IBM’s Db2 for z/OS installation documentation and the IBM Redbook, *Distributed Functions of DB2 for z/OS and OS/390*. For more information about establishing connectivity between client computers and Db2 for z/OS over a TCP/IP network, the IBM Redbook, *WOW! DRDA Supports TCP/IP: DB2 Server for OS/390 and DB2 Universal Database*, may be particularly useful.\n\n**Starting DDF**\n\nUse the following command, which requires authority of SYSOPR or higher, to start DDF:\n\n```\n-START DDF\n```\n\nWhen DDF starts successfully, the following messages are displayed:\n\n```\nDSNL003I - DDF IS STARTING\nDSNL004I - DDF START COMPLETE LOCATION locname LU\n netname.luname\n```\n\nIf DDF has not been properly installed, the START DDF command fails and displays the following message:\n\n```\nDSN9032I - REQUESTED FUNCTION IS NOT AVAILABLE\n```\n\nIf DDF has already been started, the START DDF command fails and displays the following message:\n\n```\nDSNL001I - DDF IS ALREADY STARTED\n```\n\nThe following command shows whether DDF is running and, if so, the parameters that it is using:\n\n```\n-DIS DDF\n```\n\n**Supporting Password Management Using DRDA Flows**\n\nPassword Management using DRDA flows is supported for a network using the TCP/IP protocol. Users can change their host passwords through StarSQL if Db2 is configured as follows:\n\nSet Extended Security to YES (EXTSEC=YES). This can be done using either\n\n- the DSNTIPR (DDF) panel on the Db2 installation dialog.\n- a customized configuration job DSNTIJUZ, with the option EXTSEC=YES specified.\nUsing StarSQL with Stored Procedures\n\nStored procedures are application programs that reside on the host and are invoked via Db2. They are usually written in a traditional programming language like COBOL, RPG, or C. They may contain SQL statements for accessing the Db2 database or they may be used to access non-Db2 resources.\n\nYou invoke a stored procedure using the SQL Call statement and receive output data in a result set or in output parameters. The Call statement is executed as any other SQL, using SQLExecute or SQLExecDirect.\n\nRegistering Stored Procedures\n\nThe stored procedure should be registered on the host so that calling application can obtain information using the SQLProcedures and SQLProcedureColumns functions.\n\nUse the CREATE PROCEDURE command to register the stored procedure in the system. The CREATE PROCEDURE command automatically updates the SYSIBM.SYSROUTINES catalog table.\n\n```sql\nCREATE PROCEDURE SYSPROC.STARPING ( \n IN REGION CHAR(8) CCSID EBCDIC, \n IN PROGRAM CHAR(8) CCSID EBCDIC, \n IN TRANSID CHAR(4) CCSID EBCDIC, \n IN COMMLEN SMALLINT, \n INOUT COMMAREA VARCHAR(32700) FOR BIT DATA, \n OUT RC INTEGER, \n OUT ABCODE CHAR(4) CCSID EBCDIC \n) \nPARAMETER STYLE GENERAL \nLANGUAGE C \nEXTERNAL NAME 'STARPING' \nRESULT SETS 0 \nDETERMINISTIC \nNO SQL \nNO DBINFO \nNO COLLID \nASUTIME NO LIMIT \nNO WLM ENVIRONMENT \nSTAY RESIDENT NO \nPROGRAM TYPE MAIN \nSECURITY DB2 \nCOMMIT ON RETURN YES\n```\nPreparing Hosts for StarSQL Access\n\nCalling Stored Procedures\n\nEach of the following SQL statements for calling the sample stored procedure is valid:\n\n- Call MyProc (1, 'A', ?, ?)\n- Call MyProc( parm1=1, parm2='A', parm3=?, parm4=?)\n- Call MyProc( parm1=1, parm2='A', ?, ?)\n- Call MyProc( ?, ?, ?, ?)\n- Call MyProc( 1, 'A', parm3=?, parm4=?)\n\nConfiguring SSL for Db2 for z/OS\n\nTo configure a Db2 for z/OS host system for SSL communications, you must be using Db2 for z/OS 9.1 or later. Refer to the section Encrypting your data with Secure Socket Layer support in the Db2 for z/OS documentation.\n\nYou must configure AT-TLS (z/OS® Communications Server IP Application Transparent Transport Layer Security) as well as configuring the Db2 server.\n\nThe listening port number (typically 448) is specified in the DRDA SECURE PORT field of the Distributed Data Facility Panel 2 (DSNTIP5) during Db2 installation. After initial installation, you can update the SECPORT parameter of the DDF statement in the BSDS with the change log inventory (DSNJU003) stand-alone utility.\n\nThe following IBM Redbooks may also be of assistance:\n\n- Securing and Auditing Data on DB2 for z/OS (SG24-7720)\n- DB2 9 for z/OS: Distributed Functions (SG24-6952-01)\n\nPreparing a Db2 for i Host\n\nThis section discusses setting up a Db2 for i host for supporting a connection through StarSQL.\n\nIt covers:\n\n- creating a library/collection for SQL packages\n- determining the RDB name\n- enabling DRDA over TCP/IP for IBM i\n- supporting password encryption, LOB data types, and two-phase commit transactions\n\nFor complete information about setting up Db2 for i, consult IBM’s Db2 for i installation documentation.\nCreating a Library for SQL Packages\n\nOn Db2 for i, required SQL packages are stored in a collection, or library. You may need to create the collection or library on the host.\n\nUse the CRTLIB command to create a new library for the SQL packages used by StarSQL. You can do this from a 5250 terminal session with a user ID that has QSECOFR privileges. The library does not have to be a SQL collection, but it must be accessible to all StarSQL users.\n\nFor example, the following command creates a new library named STARSQ:\n\n```\nCRTLIB STARSQ\n```\n\nRecord the name of the library as it must be specified as the SQL Package Collection ID in the data source configuration.\n\nDetermining the RDB Name\n\nDetermine the Relational Database (RDB) name of the Db2 for i host. From the IBM i command line, enter:\n\n```\nWRKRDBDIRE\n```\n\nLook for an entry with a Remote Location value of *LOCAL. If such an entry does not exist, create it with the 1=ADD option. A common convention is to use the same name as the Db2 for i system name for the RDB name.\n\nMake a note of the RDB name as you need to specify it as the Server in the data source configuration.\n\nEnabling DRDA Over TCP/IP\n\nThe Distributed Data Management (DDM) server allows client computers to access the Db2 functions. The DDM server supports remote SQL access, record level access, and remote journals. To initiate a DDM server job using TCP/IP communications a DRDA\napplication or DDM source system connects to the well-known port number for TCP/IP, port 446 or 447. The DDM listener program, upon accepting the connection request, issues an internal request to attach the client’s connection to a DDM server job.\n\nThe DDM listener program runs in a batch job in the QSYSWRK subsystem. There is one listener program that serves potentially many DDM server jobs. If you have access to iSeries Navigator you can verify whether DDM is configured by selecting TCP/IP from the Network— Servers menu.\n\nFollow the steps below if you need to configure an IBM i host to accept DRDA requests over TCP/IP:\n\n1. Log on to the IBM i host.\n2. Change the DDM TCP/IP Attributes to automatically start the listener program by entering:\n \\[ \\text{CHGDDMTCPA AUTOSTART(*YES)} \\]\n3. Start the TCPIP DDM Server by entering:\n \\[ \\text{STRTCPSVR SERVER(*DDM)} \\]\n\nWhen you are logged on to the Db2 for i host, you can examine which port Db2 for i is using to listen for DRDA requests using either the WRKSRVTBLE or the WRKTCPSTS command.\n\nTo use the WRKSRVTBLE command:\n\n1. Enter WRKSRVTBLE.\n2. Look for the DRDA entry with the port number.\n\nTo use the WRKTCPSTS command:\n\n1. Enter WRKTCPSTS.\n2. Choose option 3, “Work with TCP/IP connection status.”\n3. Find the entry with port “drda” and press “F14=Display port numbers.” The default port number for DRDA is 446.\nPreparing Hosts for StarSQL Access\n\nConfiguring SSL on Db2 for i\n\nTo configure an IBM i host system to use the Secure Sockets Layer (SSL) protocol you must have the following components:\n\n- Digital Certificate Manager - 5722-SS1 (v5rx), 5761-SS1 (6.1), or 5770-SS1(7.x) option 34\n- TCP/IP Connectivity Utilities - 5722-TC1(v5r4), 5761-TC1 (6.1), or 5770-SS1 (7.x)\n- IBM HTTP Server - 5722-DG1 (v5rx), 5761-DG1 (v6r1) or 5770-DG1 (7.1)\n\nFollowing are general procedures for configuring SSL on the IBM i host. Refer to your IBM documentation for details, especially the IBM i documentation and the IBM Redbook *IBM iSeries Wired Network Security OS/400 V5R1 DCM and Cryptography Enhancements* (GSG24-6168).\n\n1. Start the Admin HTTP instance and use a browser to configure the Digital Certificate Manager.\n2. Create a local Certificate Authority or obtain a certificate from a public Internet Certificate Authority.\n3. Create a *SYSTEM certificate store.\n4. Use “Manage Applications” to assign a server certificate to the IBM i DDM/DRDA server.\n5. After you assign the certificate, restart the DDM/DRDA server:\n \n ```\n ENDTCPVR *DDM\n STRTCPVR *DDM\n ```\n6. If necessary, set the port on which the DDM/DRDA server listens for SSL conversations. Use WRKSRVTBLE to view and modify service table entries; the entry for SSL is ddm-ssl, and the default value is 448.\nRegistering Stored Procedures on IBM i\n\nThis section describes issues regarding stored procedures that are specific to IBM i hosts. Refer to \"Using StarSQL with Stored Procedures\" on page 33 for general information about using stored procedures.\n\nFollowing is sample SQL for registering a stored procedure on an IBM i system. It assumes that the COBOL program MYLIB.MYPRGM already exists on the IBM i system. This statement modifies the QSYS2.SYSPROCS and QSYS2.SYSPARMS catalog tables for you.\n\n```sql\nCREATE PROCEDURE MYLIB.MYPROC (INOUT PARM1 CHAR(10))\nEXTERNAL NAME MYLIB.MYPGM LANGUAGE COBOL GENERAL\n```\n\nIn the above example, the procedure name is MYLIB.MYPROC, which references the COBOL program MYLIB.MYPGM. The program takes one input parameter called PARM1 which is a char field of length 10. This procedure does not return a result set.\n\nRefer to the IBM SQL Reference and SQL Programming Guide for the appropriate version of IBM i for more information on registering a stored procedure and the full syntax of the CREATE PROCEDURE statement.\n\nConsiderations for Specific IBM i Releases\n\nIn general, it is a good idea to stay current on PTF packages and the Db2 Group PTF, and to use the latest version of StarSQL. Refer to the StarSQL Release Notes (readunix.html) for specific issues for particular versions of IBM i.\n\nPreparing a Db2 for LUW Host\n\nThis section provides details for setting up a Db2 for Linux, UNIX, and Windows host to support a connection through StarSQL for Windows. It covers:\n\n- Enabling DRDA Support for TCP/IP\n- Locating the Database Name\n\nFor complete information about setting up Db2 LUW, consult IBM’s Db2 LUW installation documentation.\n\nEnabling DRDA Support for TCP/IP\n\nWhen using TCP/IP to connect to a Db2 LUW host, make sure that the host has a static IP address. You may experience problems installing Db2 LUW on a computer using DHCP. To be recognized, Db2 LUW requires an entry in the DNS (Domain Name Server) or an entry in the HOSTS file.\nAlthough you can configure StarSQL to communicate with Db2 using any available port, port 446 is the standard port used for DRDA communications and is the default value that StarSQL uses if another is not specified. Db2 LUW uses a default value of 50000 for DRDA communications (25000 for Db2 LUW 11.5.6 & later). You can either change the DRDA listening port of the Db2 server or (more commonly) use port 50000 when configuring StarSQL.\n\nIf there is a firewall that monitors network traffic to the Db2 host, be sure that it allows DRDA communications to pass through the port that you configure for DRDA requests.\n\n**Using db2 Commands to Specify the DRDA Port**\n\nIssue the following db2 commands to change the port that Db2 uses for DRDA communications.\n\n1. Enter the following command to determine on which port Db2 is listening to for TCP/IP communications.\n \n ```\n db2 get dbm configuration\n ```\n\n In the dbm configuration, look for “TPC/IP Service Name (SVCENAME).” It will have a value similar to “db2c_DB2.” This is the symbolic name of the connection port.\n\n2. Find the symbolic name of the connection ports in the services file, which is typically located in `/etc/services`.\n\n3. Edit the services field and change the value of the TCP/IP connection port to 446 and set the interrupt port to 447.\n\n4. Restart the Db2 instance for the changes to take effect.\n\nTo verify that Db2 is listening on the correct port, from either the client or the server enter:\n\n```\n telnet <host> <port>\n```\n\nIf Db2 is listening on that port, no error is returned to the telnet window. If Db2 is not listening on that port, you will see an error similar to the following and may need to contact your Db2 administrator for the correct port number to use:\n\n```\n Could not open connection to the host, on port 446: Connect failed.\n```\n\nClick the Close (X) icon to close the telnet window.\nPreparing Hosts for StarSQL Access\n\nConfiguring SSL for Db2 UDB 9.7 & later:\n\nRefer to the Configuring Secure Sockets Layer (SSL) support in a Db2 instance chapter in the Db2 documentation for details.\n\nThe following is an example of using self-signed certificates.\n\nUse GSKit to create a keystore file (certificate database) and a certificate. Export the certificate if desired:\n\nC> cd C:\\Program Files\\ibm\\gsk8\\bin\\gsk8capicmd\n\nC> gsk8capicmd -keydb -create -db \"mydbserver.kdb\" -pw \"mypassword\" -stash\n\nC> gsk8capicmd -cert -create -db \"mydbserver.kdb\" -pw \"mypassword\" -label \"SelfSigned\" -dn \"CN=myhost.mydomain.com,O=MyCompany,OU=CustomerSupport,L=California,ST=ON,C=CA\"\n\nC> gsk8capicmd -cert -extract -db \"mydbserver.kdb\" -pw \"mypassword\" -label \"SelfSigned\" -target \"MYHOSTserver.arm\" -format ascii -fips\n\nOn UNIX, make sure that the Db2 instance owner has read access to the keystore file.\n\nUpdate Db2 and restart it:\n\nC> db2 update dbm cfg using SSL_SVR_KEYDB \"C:\\Program Files\\ibm\\gsk8\\bin\\mydbserver.kdb\"\n\nC> db2 update dbm cfg using SSL_SVR_LABEL SelfSigned\n\nC> db2 update dbm cfg using SSL_SVR_STASH \"C:\\Program Files\\ibm\\gsk8\\bin\\mydbserver.sth\"\n\nC> db2 update dbm cfg using SSL_SVCENAME 50029\n\nC> db2set -i db2 DB2COMM=SSL,TCPIP\n\nC> db2stop\n\nC> db2start\n\nNote that there is a problem in DB2 UDB 9.7 fp3 (resolved in fp4); see IC72728: THE PORT NUMBER FOR SSL_SVCENAME IN THE SERVICE FILE IS USED FOR SVCENAME. The value specified for SSL_SVCENAME is being used for both SSL and non-SSL listeners, causing a conflict. The workaround is to set the SVCENAME parameter using an explicit port number:\n\nC> db2 update dbm cfg using SVCENAME 50000\nConfiguring SSL for DB2 UDB 9.1 & 9.5:\n\nThe procedure is similar to the above instructions for DB2 UDB 9.7, except:\n\n- The gskit is v7 rather than v8 (e.g. run `C:\\Program Files\\ibm\\gsk7\\bin\\gsk7capicmd` instead of `C:\\Program Files\\ibm\\gsk8\\bin\\gsk8capicmd`)\n- Rather than using DBM configuration, the DB2 SSL parameters are stored in a configuration file `sslconfig.ini` located in the following directory:\n - Linux and UNIX: `INSTHOME/cfg/SSLconfig.ini`\n - Windows: `INSTHOME/SSLconfig.ini`\n\nwhere `INSTHOME` is the home directory of the instance.\n\nHere is a sample `sslconfig.ini`:\n\n```ini\nDB2_SSL_KEYSTORE_FILE=C:\\Program Files\\ibm\\gsk7\\bin\\mydbserver.kdb\nDB2_SSL_LISTENER=50448\nDB2_SSL_KEYSTORE_PW=mypassword\nDB2_SSL_KEYSTORE_LABEL=SelfSigned\n```\n\nAfter configuring gsk7 and creating `sslconfig.ini`, enter `db2set -i db2 DB2COMM=SSL,TCPIP` and restart DB2\n\nEnabling Encryption\n\nIf you configure the StarSQL driver to send encrypted user IDs and passwords (see \"UseEncryption\" on page 85), be sure to enable the database for encryption. On a Db2 for Linux, UNIX, and Windows host you enable encryption by setting the Server Connection Authentication (SRVCON_AUTH) parameter to “Server encrypt” and restarting the instance.\n\nUsing db2 Commands to Enable Encryption\n\nIssue the following db2 commands to enable encryption.\n\n1. To enable encryption from a db2 command window, enter the following command:\n ```\n db2 update dbm cfg using SRVCON_AUTH\n SERVER_ENCRYPT\n ```\n2. Stop and restart the instance by issuing the following commands:\n\n db2stop\n db2start\n\nLocating the Database Name\n\nWhen an administrator sets up a Db2 LUW system, they assign names to Db2 databases. You will need to enter the Database Server Name when you configure data sources on the desktop. You can display a list of the databases that have been created by issuing the following command:\n\n db2 list database directory\n\nContact your database administrator if you need to determine which databases should be accessible to StarSQL clients.\n\nPreparing a Derby Network Server Host\n\nThe Derby Network Server is part of the Derby software distribution and provides a framework for multi-user connectivity to Derby databases across a network. Derby must be started in the Network Server mode (vs. the embedded mode) for client computers to connect to a Derby database using StarSQL.\n\nThe default of the Derby Network Server is to start with user authentication disabled. Refer to the Derby documentation for information about enabling user authentication and running under the Java security manager to help avoid security problems.\n\nSetting Network Server Properties\n\nTypically the Java system property derby.system.home specifies the system directory, which contains subdirectories that hold the databases that are available to the Derby Network Server. If you do not explicitly set the derby.system.home property when starting Derby, the default is the directory in which Derby was started. You need to specify at least the name of the database you want to access with the StarSQL driver and which port to use. Contact your database administrator if you do not know which Derby databases should be accessible to StarSQL clients.\n\nThe Network Server properties can be specified three ways:\n\n- on the command line\n- in the .bat or .ksh files, loading the properties by executing java -D\n- in the derby.properties file\nProperties in the command line or in the .bat or .ksh files take precedence over the properties in the derby.properties file. Arguments included on commands that are issued on the command line take precedence over property values.\n\nThe properties that are particularly of interest for using the StarSQL driver are those that allow remote connections and determine which protocol to use.\n\n```\nderby.drda.host=hostname\nderby.drda.portNumber=portnumber\nderby.drda.sslMode=SSL | TLS | SSLv3 | TLSv1\n```\n\n**Enabling Remote Connections**\n\nThe default of the Derby Network Server is to start with user authentication disabled. Before you enable remote connections ensure that you are running under the security manager and that user authorization is enabled. Refer to the Derby documentation for details about enabling user authentication and running under the Java security manager.\n\nThe `derby.drda.host` property causes the Network Server to listen on a specific interface, allowing multiple instances of Network Server to run on a single computer with a unique host:port combination. By default the Derby Network Server listens only on the loopback IP address (127.0.0.1) and port 1527, which restricts access to the local computer. To make the Derby Network Server accessible to other computers on the network, specify a particular interface (host name or IP address) and specify a port number other than 1527 on which to listen for connections. The Derby Network Server must listen for connections on the same port that the StarSQL driver is configured to use, which is port 446 by default.\n\nThe following shows how to use a java command to start the Derby Network Server to listen on port 446 for connection requests from any host name or IP address.\n\n```\njava -jar $DERBY_HOME%\\lib\\derbyrun.jar server start\n -h 0.0.0.0 -p 446\n```\n\nThe `-h` and `-p` options can be specified regardless of how you choose to start Derby Network Server. Refer to the Derby documentation for details about the additional methods, such as running the startNetworkServer script or using a java command to directly invoke the NetworkServerControl class.\n\n**Configuring Support for the SSL Protocol**\n\nThe Derby Network Server supports network security with Secure Socket Layer/Transport Layer Security (SSL/TLS). With SSL/TLS the client-server communication protocol is encrypted and both the client and the server may, independently of each other, require certificate-based authentication of the other part. You can configure SSL for the Derby Network Server to be Off, or to use SSL encryption with no peer authentication (basic), or to use SSL encryption and peer\nauthentication (peerAuthentication). To enable SSL support, use the \\texttt{ssl} option on the command line when you start Derby or specify the \\texttt{derby.drda.sslMode} property in \\texttt{derby.properties}.\n\nFor example, the following command would start Derby Network Server using the “basic” SSL encryption option:\n\n\\[ \\texttt{java -jar derbyrun.jar server start -ssl basic} \\]\n\nYou also need to use the \\texttt{keytool} to create a server key pair, and specify the key store and password when starting the server. For SSL operation the server always needs a key pair. If the server runs in peer authentication mode, then each client needs its own key pair. The \\texttt{keytool} is located in the JRE bin directory. Entering the following command prompts for the information needed to generate a key pair.\n\n\\[ \\texttt{keytool -genkey myDatabase -keystore serverKeyStore.key} \\]\n\nThe key pair is located in a file which is called a key store and the JDK’s SSL provider needs the system properties \\texttt{javax.net.ssl.keyStore} and \\texttt{javax.net.ssl.keyStorePassword} to access the key store. Specify the key store and password when starting the server, such as shown below:\n\n\\[ \\texttt{java -Djavax.net.ssl.keyStore=serverKeyStore.key -Djavax.net.ssl.keyStorePassword=myPassword -jar %DERBY_HOME%\\lib\\derbyrun.jar server start -h 0.0.0.0 -p 446 -ssl basic} \\]\n\nRefer to the Derby documentation at \\url{http://db.apache.org/derby/docs/10.4/adminguide/cadminsslkeys.html} for additional details about key and certificate handling.\nA SQL package is an object that Db2 uses to process a SQL statement. Different packages are required to execute dynamic SQL and ODBC catalog functions.\n\nStarSQL assumes that the dynamic SQL package and the catalog package already exist in the host database. On the initial connection with the host, StarSQL searches for the required packages, and if it does not find them, it creates them automatically.\n\nThe names and locations of the packages that are bound vary, depending on how the data source is configured when the initial connection is made.\n\nThe StarSQL user requires certain permissions to bind and use packages on the host. Typically, the package will be created by a database administrator and other users will be granted permission to use the packages.\n\nYou can use the StarAdmin utility, which is available from Stelo, to bind packages on a host. Packages that are bound using StarAdmin can be used by any 32-bit or 64-bit version (Java, Linux, UNIX, or Windows) of the StarSQL driver.\n\nThere is no need to bind packages when using an Apache Derby database.\n\n**Compatibility Among SQL Catalog Packages**\n\nMajor releases of StarSQL also may require changes to SQL catalog packages on the host. StarSQL uses the SQL packages to provide added functionality. (Point releases and hot-fixes usually do not involve changes to the SQL packages.) It is recommended that the SQL packages be rebound when a major version of StarSQL is deployed throughout an organization, or when directed by the instructions included in the Release Notes included with all StarSQL installation images.\nSignificant changes were made to catalog packages and dynamic SQL packages with the v5.1 and v5.3 releases of StarSQL. Users may get different results from ODBC catalog functions when using a version of StarSQL prior to v5.1 with packages bound that are bound with StarSQL v5.1 or later.\n\nTable 5 shows the level of functionality supported with SQL packages created by different versions of StarSQL. In general, packages bound by later versions of StarSQL are backward compatible with earlier versions of StarSQL, unless specifically noted. If an earlier version of StarSQL cannot function properly with packages that are bound with a later release of StarSQL, you can maintain separate package collections or upgrade all clients to use the latest version of the driver.\n\n### Table 5. Functional Package Differences Among StarSQL Versions\n\n<table>\n<thead>\n<tr>\n<th>From</th>\n<th>To</th>\n<th>New Functionality</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>v4</td>\n<td>v5.1</td>\n<td>Packages must be rebound to use LOB data types. Upgrade all clients or maintain a separate package collection for clients running a StarSQL release prior to v5.1</td>\n</tr>\n<tr>\n<td>v5.1</td>\n<td>v5.3</td>\n<td>Backwards compatible. Rebind packages to support use of jumbo packages, or to access DB2 for z/OS when the host is configured to use a multi-byte character set. Refer to the descriptions for UseJumboPackages and CustomizePrdid in "Sample DSN File" on page 69 for additional information.</td>\n</tr>\n<tr>\n<td>v5.3</td>\n<td>v5.5</td>\n<td>Rebind packages if you upgrade from a release earlier than v5.38. Client computers that use StarSQL v5.1 or earlier should be upgraded to v5.5 or use a different package collection.</td>\n</tr>\n</tbody>\n</table>\n\nStarSQL for UNIX automatically binds host packages upon the initial connection to the host. To explicitly rebind packages, drop the packages on the host and reconnect with the new version of StarSQL for UNIX.\n\n### Binding Packages with the Explain Option Enabled\n\nDb2 provides an explain facility that provides detailed information about the access plan and environment of static or dynamic SQL statements. Beginning with v5.4 the StarSQL driver includes support for a new keyword in the swodbc.ini initialization file that binds all the StarSQL packages with the EXPLAIN bind option set to ALL.\nRefer to \"Explain\" on page 67 if you want to enable the EXPLAIN bind option for all packages that are bound by StarSQL.\n\nCatalog Package\n\nThe catalog package is needed to execute ODBC functions that query the system catalogs. The value of the CatQual keyword (see page 75) in the data source configuration indicates the name of the catalog package.\n\nDynamic SQL Packages\n\nThere are several packages used for executing dynamic SQL. The default dynamic package varies by host platform; other dynamic packages will be used based on the IsolationLevel, HeldCursors, KeepDynamic, and BindRules keywords in the data source configuration. See \"Customizing the StarSQL for UNIX Configuration\" on page 65 for more information about these keywords.\n\nTable 6 shows the dynamic packages that can be bound; the default packages vary for different hosts and are shown in boldface type.\n\nTable 6. Dynamic Packages\n\n<table>\n<thead>\n<tr>\n<th>Package Name</th>\n<th>IsolationLevel and HeldCursors Setting</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SWNC0000</td>\n<td>No Commit/Held Cursors=No (default on Db2 for i)</td>\n</tr>\n<tr>\n<td>SWRC0000</td>\n<td>Read Committed / HeldCursors=No (default on Db2 LUW)</td>\n</tr>\n<tr>\n<td>SWRR0000</td>\n<td>Repeatable Read / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWRU0000</td>\n<td>Read Uncommitted / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWT0000</td>\n<td>Serializable / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWRC1000</td>\n<td>Read Committed / HeldCursors=Yes (default on Db2 for z/OS)</td>\n</tr>\n<tr>\n<td>SWRR1000</td>\n<td>Repeatable Read / HeldCursors=Yes</td>\n</tr>\n<tr>\n<td>SWRU1000</td>\n<td>Read Uncommitted / HeldCursors=Yes</td>\n</tr>\n<tr>\n<td>SWT1000</td>\n<td>Serializable / HeldCursors=Yes</td>\n</tr>\n</tbody>\n</table>\nTable 7 through Table 9 show the packages that can be bound when using the KeepDynamic option, or if the BindRules keyword is set to BIND. These tables are only applicable for hosts running DB2 for OS/390 v5.1 and later.\n\n**Table 7. Dynamic Packages on Db2 for z/OS with KeepDynamic=Yes**\n\n<table>\n<thead>\n<tr>\n<th>Package Name</th>\n<th>IsolationLevel and HeldCursors Setting</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SWNC4000</td>\n<td>No Commit/Held Cursors=No</td>\n</tr>\n<tr>\n<td>SWRC4000</td>\n<td>Read Committed / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWRR4000</td>\n<td>Repeatable Read / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWRU4000</td>\n<td>Read Uncommitted / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWTS4000</td>\n<td>Serializable / HeldCursors=No</td>\n</tr>\n<tr>\n<td><strong>SWRC5000</strong></td>\n<td>Read Committed / HeldCursors=Yes (default on <strong>Db2 for z/OS</strong>)</td>\n</tr>\n<tr>\n<td>SWRR5000</td>\n<td>Repeatable Read / HeldCursors=Yes</td>\n</tr>\n<tr>\n<td>SWRU5000</td>\n<td>Read Uncommitted / HeldCursors=Yes</td>\n</tr>\n<tr>\n<td>SWTS5000</td>\n<td>Serializable / HeldCursors=Yes</td>\n</tr>\n</tbody>\n</table>\n\n**Table 8. Dynamic Packages on DB2 for z/OS with BindRules=BIND and KeepDynamic=No**\n\n<table>\n<thead>\n<tr>\n<th>Package Name</th>\n<th>IsolationLevel and HeldCursors Setting</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SWRC2000</td>\n<td>Read Committed / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWRR2000</td>\n<td>Repeatable Read / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWRU2000</td>\n<td>Read Uncommitted / HeldCursors=No</td>\n</tr>\n<tr>\n<td>SWTS2000</td>\n<td>Serializable / HeldCursors=No</td>\n</tr>\n</tbody>\n</table>\nPermissions for Packages\n\nAfter the packages have been bound, StarSQL users must be granted permission to execute them. On Db2 for i, users must be granted *USE permission on the packages, which can usually be done by the package owner. On other hosts, the DBA must grant StarSQL users EXECUTE or RUN permissions on the packages.\nStatic and Catalog Packages\n\nThe StarSQL user executes applications that use the catalog package and any static SQL packages under the permissions of the package owner. No additional permissions are required to use these packages.\n\nDynamic SQL Packages\n\nOn all hosts, except for Db2 for z/OS, for applications that use dynamic SQL, the StarSQL user needs explicit permissions to read (SELECT) and write (UPDATE/INSERT/DELETE) the columns and tables accessed by the application. The DBA needs to grant these permissions to “public” or to the various groups.\n\nOn Db2 for z/OS, the required permissions depend on the setting of the BindRules keyword. If the BindRules keyword is set to RUN, which is the default, the StarSQL user needs explicit permissions to read and write the columns and tables accessed by the application. If the BindRules option is set to BIND, the user has the permissions of the package owner, except that the following SQL statements cannot be executed regardless of the permissions of the package owner:\n\n- SET CURRENT SQLID\n- GRANT\n- REVOKE\n- ALTER\n- CREATE\n- DROP\n- Any SQL statement that cannot be prepared as a dynamic SQL statement.\n\nGranting Use Permissions\n\nTo grant EXECUTE authority on the SQL packages, you can use the StarAdmin application if you have a Windows-based StarSQL computer, or you can execute SQL statements similar to those shown in the following sections.\n\nFor Db2 for z/OS\n\nUsing SPUFI on the host or the SQL pass through mode of an ODBC-enabled application, execute the following SQL statements:\n\n```\nGRANT EXECUTE ON PACKAGE\nSTARSQ.L.SYSIBM, STARSQ.L.SWRC5000\nTO PUBLIC\n```\nFor Db2 LUW (Linux, Unix & Windows)\n\nUsing the Db2 Command Line Processor or the SQL pass through mode of an ODBC-enabled application, execute the following SQL statements:\n\n```\nGRANT EXECUTE ON PACKAGE\nSTARSQL.SYSCAT, STARSQL.SWRC0000\nTO PUBLIC\n```\n\nFor Db2 for i\n\nUsing STRSQL (which is the interactive SQL interpreter, available in the IBM DB2 Query Manager and SQL Development Kit, Licensed Program 5xxx-ST1), or using the SQL pass through mode of an ODBC-enabled application, execute the following SQL statements:\n\n```\nGRANT EXECUTE ON PACKAGE\nSTARSQL.QSYS2, STARSQL.SWNC0000\nTO PUBLIC\n```\n\nIn addition, you can use IBM i authority commands to grant *USE authority for all users (*PUBLIC) to the library packages:\n\n1. From a 5250 session, enter `WRKLIB <package library name>`.\n2. Select Option 12 (work with objects).\n3. Select Option 2 (edit authority on each object one at a time).\n4. Change `PUBLIC *EXCLUDE` to `PUBLIC *USE`.\n\nAnother alternative is to use the GRTOBJAUT command from a 5250 session to grant *USE authority for the library and EXECUTE authority for the packages to all users. The following example assumes that the package library is named “STARSQL.”\n\n```\nGRTOBJAUT OBJ(STARSQL) OBJTYPE(*LIB) USER(*PUBLIC)\nAUT(*USE)\nGRTOBJAUT OBJ(STARSQL/*ALL) OBJTYPE(*ALL)\nUSER(*PUBLIC) AUT(*USE)\n```\n\nAutoBind Option\n\nThe AutoBind configuration keyword forces SQL packages to be bound at connect time (SQLConnect or SQLDriverConnect). You can set AutoBind in the DSN definition (see page 72) or pass it in the connect string to `SQLDriverConnect()`.\nCaution\n\nThe use of AutoBind always causes binding to occur and adversely affects connect time performance.\n\nThe AutoBind option settings are described in Table 10.\n\nTable 10. AutoBind Keyword Settings\n\n<table>\n<thead>\n<tr>\n<th>AutoBind Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0 (Default)</td>\n<td>No auto-bind at connect time. The driver still binds packages on-the-fly if it does not find them on the server when it needs them.</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Binds packages at connect time, but uses NO REPLACE option on bind. If the packages already exist they will not be replaced. In the current version of StarSQL, AutoBind=1 ignores the NO REPLACE option and functions in the same manner as AutoBind=2.</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Binds packages at connect time and always replaces current packages, if there are any.</td>\n</tr>\n<tr>\n<td>Y</td>\n<td>Same as 2.</td>\n</tr>\n<tr>\n<td>N</td>\n<td>Same as 0.</td>\n</tr>\n</tbody>\n</table>\n\nRegardless of the AutoBind setting, the StarSQL driver binds packages dynamically if it does not find them on the host at the time they are needed.\n\nThe packages that may be bound by AutoBind=1 and AutoBind=2 are:\n- the dynamic package for the current transaction isolation level\n- the catalog package\nThe 32-bit StarSQL for UNIX is now deprecated.\nAppendix B\n\nManually Installing 64-bit StarSQL for Linux\n\nThis chapter is no longer relevant.\nThis chapter provides a reference for using the following StarSQL for UNIX commands:\n\n- `simpleconn`, page 58\n- `starlic-clientcfg`, page 60\n- `starping`, page 62\n- `trcstart`, page 63\nsimpleconn\n\n**Purpose**\n\nTests that StarSQL can use the unixODBC driver manager to connect to a specific data source on the host.\n\n**Synopsis**\n\n```\nsimpleconn DSN UserId Password [#Connections] [-wait]\n | [-pool] | [-nopool] [# of pooled connections]\n```\n\n**Options**\n\n- **DSN**: The data source name to which you want to connect.\n- **UserId**: A valid user ID for a user account on the host.\n- **Password**: The valid password for the userid.\n- **#Connections**: The number of times to connect to the data source.\n- **-wait**: The application will establish the connections, then wait until you hit enter to continue before releasing them.\n- **-pool #pooled-connections**: enables connection pooling and connects/disconnects N times\n- **-nopool #pooled-connections**: connects/disconnects N times without enabling pooling\n\nArguments are position-sensitive.\n\n- **-wait**, **-pool** and **-nopool** are mutually exclusive.\n\nIf you use **-pool** or **-nopool**, you should supply a value for **# of pooled connections**.\n\n**Description**\n\nYou can use the `simpleconn` command to test that StarSQL can use the unixODBC driver manager to successfully connect to a specified data source on the host. Upon successful connection, the simpleconn command returns the database name, platform, and version, and the driver name and version.\n\nYou must specify a username and password of an account that is valid on the host and has permission to access the database. (See \"Preparation Required for All Hosts\" on page 29 for more information about user accounts and permissions.)\nThe #Connections option lets you specify how many connections you want to establish. The default is 1. If you specify more than one connection, the simpleconn program establishes that number of connections, and then releases them before the command returns.\n\nThis command invokes the simpconn example program included with StarSQL in the $STARDIR/samples directory. The simpleconn program is compiled with unixODBC include files and libraries.\n\n**Example**\n\nThe following command example tests that StarSQL can establish two connections to a data source named DSN1 using the unixODBC driver manager.\n\n$ simpleconn DSN1 staruser starpass 2\n\nConnection #1\n\nDriver Name: libswodbc.a\nDriver Version: 5.50.nnnn\nDatabase Name: DB2 Universal DataBase\nDatabase Version: 08.021.0007\n\nConnection #2\n\nDriver Name: libswodbc.a\nDriver Version: 5.50.nnnn\nDatabase Name: DB2 Universal DataBase\nDatabase Version: 08.021.0007\n\n**See Also**\n\nstarping, page 62\n**starlic-clientcfg**\n\n**Purpose**\n\nConfigure and manage StarLicense client computer.\n\n**Synopsis**\n\n```\nstarlic-clientcfg [options]\n```\n\n**Options**\n\nSome of the more commonly-used options for configuring a client computer are shown below. Note that the StarLicense Client Configuration Menu provides an easier method for managing StarLicense client-server connections. Refer to page 89 for information about using the StarLicense Client Configuration Menu.\n\n- `client-loglevel-set [0 | FFFFFFFF]`\n Setting the log level to 0 (zero) disables logging. Set the log level to FFFFFFFF (eight F’s) to enable logging of activity between the client and license service. The log file is created in the /tmp directory with the filename format `starliccli.<processID>.log`.\n\n- `client-loglevel-show`\n Displays the log level value, which indicates whether logging is enabled (FFFFFFF) or disabled (0).\n\n- `client-server-show`\n Shows information about the license server(s) the client is configured to use.\n\n- `client-server-add <product_ID> <hostname> <port> [PRI|SEC]`\n Configures the client to check out a license for the specified Stelo product on the specified host. The product ID must match the product ID specified on the StarLicense server. The `hostname` can be the DNS name or TCP/IP address of the StarLicense server and the `port` variable is the number of the port on which the server is listening for license requests. Specify the option PRI to add the server as a Primary server, or SEC to add it as a Secondary server.\n\n- `client-server-remove <product_ID> <hostname> <port> [PRI | SEC]`\n Removes the specified StarLicense server from the client license configuration.\nDescription\n\nUse the `client-server` options to configure the client computer to use one or more StarLicense servers. The StarLicense server software can be co-located on the same computer as the StarSQL driver, or it can be installed on a network server.\n\nExample\n\nThe following example configures the computer to checkout StarSQL licenses from a StarLicense server named `starlic` that is listening for license requests on port 4999.\n\n```\n# ./starlic-clientcfg client-server-add SQ starlic 4999 PRI\n```\n\nThe following example configures the client computer to use a StarLicense server named `starlic2` as a Secondary server if the Primary license server cannot satisfy the license request. The starlic2 server listens for license requests on port 5001.\n\n```\n# ./starlic-clientcfg client-server-add SQ starlic2 5001 SEC\n```\n\nSee Also\n\n\"Licensing Stelo Products\" on page 21\n\"StarLicense Client Configuration Utility\" on page 89\nstarping\n\nstarping\n\nPurpose\n\nTests the StarSQL connection to a specific data source.\n\nSynopsis\n\nstarping [DSN UserID Password]\n\nOptions\n\n- **DSN**: The data source to which you want to connect.\n- **UserID**: A valid user ID for an account on the host.\n- **Password**: The valid password for the user ID.\n\nDescription\n\nThe `starping` command connects to the specified DSN using a user ID and password. If you enter the command without the required parameters, the command prompts for the data source name, user ID, and password before it attempts the connection.\n\nAfter a successful connection, the command returns “Connection Succeeded!” and the data source name (DSN) and database platform version number.\n\nExample\n\nstarping DSN1 staruser starpass\n\nSee Also\n\n`simpleconn`, page 58\n**trcstart**\n\n**Purpose**\n\nStarts and ends DRDA tracing.\n\n**Synopsis**\n\n```\ntrcstart {-off|-on TraceFile.sqd}\n```\n\n**Options**\n\n- `-off` Turns off the DRDA trace recording currently in progress.\n- `-on TraceFile.sqd` Turns on DRDA trace recording to the specified trace file.\n\n**Description**\n\nThe `trcstart` command allows a user to capture the DRDA data streams that the StarSQL driver is sending and receiving.\n\nTo enable DRDA tracing the `.swodbc.ini` file must be in the user’s home directory and the user must have permission to write to the file.\n\nTo view the trace file, transfer the file (with a .sqd extension) to a Windows computer in binary mode and use the StarSQL Trace Viewer application installed as a custom selection by StarSQL for Windows.\n\n**Examples**\n\nTo copy swodbc.ini to the user home directory and make it writable:\n\n```\n$ cp $STARSQL/etc/swodbc.ini .swodbc.ini\n$ ls -l .swodbc.ini\n$ chmod 644 .swodbc.ini\n```\n\nTo enable DRDA tracing:\n\n```\n$ trcstart -on /tmp/mytrace.sqd\n```\n\nTo turn off tracing:\n\n```\n$ trcstart -off\n```\nYou can control how the StarSQL driver interacts with a data source by modifying the data source configuration settings. There are several methods for defining an ODBC data source:\n\n- edit the System DSN file (odbc.ini) or the User DSN file (.odbc.ini)\n- create a File DSN\n\nFor a StarSQL data source you can specify Global Settings, which determine how the StarSQL driver behaves with all data sources, and you can define specific data source settings, which control how StarSQL interacts with a particular Data Source Name (DSN).\n\nYou can also use DSN-less connection strings.\n\n### Setting Global DSN Parameters\n\nThe Global Settings are defined in a file named .swodbc64.ini. The swodbc64.ini file can be located in the program directory ($STARDIR/etc/swodbc64.ini), in a shared network location with a symbolic link from the $HOME directory (as .swodbc64.ini) for users to find it, or a personal copy can be maintained in the $HOME directory ($HOME/.swodbc64.ini).\n\nThe global DSN parameters are described within a stanza of the swodbc64.ini configuration file and affect all DSNs. Within each stanza you specify keywords and values in the format shown below:\n\n```\nKeyword=value\n```\n\nThe next section provides details about each configuration keyword you can specify in the .swodbc64.ini global settings file.\nGlobal DSN Keywords\n\nFor most users, the default values for the global data source settings, which are stored in the $STARDIR/swodbc64.ini file, are adequate. However, you can implement special behavior by modifying the global settings.\n\n**AlwUpd**\n\nAll database transactions are read/write by default (AlwUpd=Yes). Setting AlwUpd=No restricts the driver to read-only transactions.\n\nYou also can control whether transactions can be updated with the specific DSN configuration ReadOnly keyword (see \"ReadOnly\" on page 82). If both the AlwUpd global setting and the ReadOnly DSN setting are specified, the StarSQL driver uses the most restrictive setting. A global setting that allows read/write transactions (AlwUpd=Yes) can be overridden by a specific DSN setting that allows just read-only transactions (ReadOnly=Yes). Likewise, a transaction to a data source is restricted to read-only if the global setting restricts the driver to read-only (AlwUpd=No), even if the specific DSN configuration allows read/write (ReadOnly=No).\n\n**AutoTypDefOvr**\n\nThe AutoTypDefOvr setting stores the Coded Character Set Identifiers (CCSIDs) that the Db2 host provides to StarSQL upon connection. After the connection with the host is established, StarSQL uses the CCSID values specified for AutoTypDefOvr to send SQL statement and parameter data to the host unless the TypDefOvr value specifies to use different CCSIDs. The TypDefOvr setting takes precedence over values specified in the AutoTypDefOvr setting. However, if the AutoTypDefOvr CCSID values are appropriate, TypDefOvr values do not need to be sent with each DRDA request.\n\nThe AutoTypDefOvr keyword value consists of three comma-separated CCSID values for the single-byte character set (SBCS), the double-byte character set (DBCS), and the mixed-byte character set (MBCS), respectively.\n\nSBCS CCSID>,<DBCS CCSID>,<MBCS CCSID>\n\nIf the host returns a different CCSID than you want to use for the connection, or you want to override a multi-byte client code page with a MBCS CCSID, set the TypDefOvr to send a particular CCSID value with each DRDA request. (See \"TypDefOvr\" on page 84 for more information about the TypDefOvr setting.)\nCacheUID\n\nIf you set CacheUID=Yes (the default), the username to connect using StarSQL is displayed in the connect dialog and the user only needs to enter their password. Set CacheUID=No to require users to enter both their username and their password to connect to the Db2 host using StarSQL.\n\nExplain\n\nDb2 provides an explain facility that provides detailed information about the access plan and environment of static or dynamic SQL statements. The captured information can help administrators understand how individual SQL statements are executed so the statement and database configuration can be tuned for performance. You can use a command-line tool or Db2 Visual Explain to display explain information.\n\nThe keyword Explain keyword in the swodbc64.ini initialization file instructs StarSQL to bind all StarSQL packages with the EXPLAIN bind option set to ALL. This includes dynamic SQL packages that are bound with StarAdmin Classic and packages that are created and bound as needed by the StarSQL driver. If you are using StarAdmin (Java-based), the Explain option can be found in Advanced properties.\n\nTo enable the EXPLAIN bind option for all packages that are bound by StarSQL, add the following line to the [Defaults] section of the .swodbc64.ini file:\n\n```\n[Defaults]\nExplain=All\n```\n\nAfter you modify the initialization file to include the Explain=All statement, the explain information for packages that are subsequently bound by StarSQL can be displayed.\n\nSetting Up System and User DSN Files\n\nSystem DSN settings are defined in odbc.ini, and user DSN settings are defined in /etc/.odbc.ini. The system DSN file uses the same format and keywords as for a user DSN file. The following procedures describe how to set up and edit the sample odbc.ini file included in the StarSQL distribution to create a system or user DSN file with the required settings.\n\n1. To create a system DSN, edit the odbc.ini file. The location of the file varies depending on which version of UNIX the computer is running, but is typically located in /etc/odbc or /usr/local/etc.\n\n To create a user DSN, copy the odbc.ini file from $STARDIR/etc to your home directory and rename it .odbc.ini (preceded with a period):\n\n ```bash\n $ cp $STARDIR/etc/odbc.ini $HOME/.odbc.ini\n ```\n2. Make sure the system or user initialization file can be written to.\n To change the permissions for the system DSN file:\n \n $ chmod 644 $STARDIR/etc/odbc.ini\n\n To change permissions for the user DSN file:\n \n $ chmod 644 $HOME/.odbc.ini\n\n3. Using a text editor such as vi or emacs, edit the required keywords, described\n in Table 11, with values appropriate to your environment. You can further\n customize the DSN configuration with any of the keywords and values\n described in \"Sample DSN File\" on page 69.\n\n### Table 11. Required Data Source Configuration Parameters\n\n<table>\n<thead>\n<tr>\n<th>Keyword</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Driver=</td>\n<td>If you install StarSQL to a location other than the default directory, specify the fully qualified path to the driver. You also can specify the name of the driver as it appears in the section head of the odbcinst.ini file, such as Driver=StarSQL (64-bit) or Driver=StarSQL64, to automatically use the location specified in the driver manager repository.</td>\n</tr>\n<tr>\n<td>HostName=</td>\n<td>The host name refers to the name of the Db2 host system. Set the HostName field to either a TCP/IP host name (such as host5.mydomain.com) or a static IP address in dotted decimal notation (such as 198.147.235.1).</td>\n</tr>\n<tr>\n<td>PkgColID=</td>\n<td>The SQL Package Collection ID indicates the location on the Db2 host of the packages required by StarSQL to execute Dynamic SQL. On Db2 for i, the SQL Package Collection ID is the name of the collection or library that contains the packages. On all other platforms, the Package Collection ID is the name of the virtual collection associated with these packages. If necessary, obtain the package collection ID from your Database Administrator.</td>\n</tr>\n</tbody>\n</table>\nThe next section provides details about the configuration keywords you can specify in the `odbc.ini` system DSN file or the `.odbc.ini` user DSN file to customize the behavior of the StarSQL driver. The information for a particular DSN is described within a stanza of the configuration file. Within each stanza you specify keywords and values for the DSN in the format shown below:\n\n```\nKeyword=value\n```\n\n### Sample DSN File\n\nSpecific data source settings, which are stored in `$HOME/.odbc.ini` for user DSNs and in `/etc/odbc.ini` for system DSNs, control how StarSQL interacts with a particular data source. Below is a sample `.odbc.ini` file that provides a DSN definition for a data source named SAMPLEDSN. The parameters listed at the beginning of the `[SAMPLEDSN]` section in **bold** are the minimum required for connectivity and are described in the table \"Required Data Source Configuration Parameters\" on page 68.\n\n```\n[ODBC Data Sources]\nSAMPLEDSN=StarSQL (64-bit)\n\n[SAMPLEDSN]\nDriver=/opt/stelo/starsql64/lib/libSWODBC.so\nHostName=host.domain.com\nPkgColId=STARSQL\nPort=446\nServer=RDBNAME\nAccounting=\"\"\n```\nCustomizing the StarSQL for UNIX Configuration\n\nAllowSynonyms=Yes\nAlwaysWide=No\nAutoBind=No\nAutoSqlSet=D\nAutoTypDefOvr=1252, 0, 0\nBinaryCCSID=37\nBindRules=Run\nCacheUID=Yes\nCatFilters=’NAME1’,’NAME2’\nCatQual=SYSIBM\nCharacterSubstitution=Warning\nCreateTable=IN DATABASE DSNDB04\nCustomizePrdid=\nDefaultQualifier=STARUSER\nDescriptions=Sample DSN Configuration\nFetchAhead=Yes\nFoldUIDPWD=No\nGetInfoCatalogUsage=\nHeldCursors=Default\nHideTsScale=No\nIncludeSynonyms=Yes\nIsolationLevel=<default>\nKeepDynamic=Yes\nLongStrParams=No\nMaxRows=\nOverrideCodeset=1252,S,Windows-1252,MYCODESETNAME\nPkgOwnID=\nQryBufSiz=2097151\nReadOnly=No\nSpecialColumns=Yes\nSSL=No\nSSLOptions=<64-bit hex string>\nStrictParsing=Yes\nTrustedConnection=No\nTwoPC=No\nTypDefOvr=1252,0,0\nUseDSCRDBTBL=Yes\nUseDynamicCatalogSQL=Yes\nUseEncryption=Any\nUseJumboPackages=No\nUseSYSDUMMYAEU=Yes\n\nThe following sections describe the keywords you can specify in the DSN definition should you need to further customize how the StarSQL driver connects to a data source.\nSystem and User DSN Keywords\n\nFor most users, the default values that StarSQL uses for connecting to a data source are adequate. However, you can implement special behavior by adding or modifying the keywords described in this section.\n\nAccounting\n\nz/OS allows you to specify an accounting string for charging back the mainframe resources that particular users consume while connected to Db2 databases through StarSQL. The accounting string is passed in the PRDDTA parameter of the ACCRDB DRDA command. It is stored as an accounting record on the mainframe.\n\nAn accounting string contains a system-generated prefix and a user-generated suffix, which together provide the information needed to associate resource usage with a user's access for the purpose of charge-back accounting. The value you specify for the Accounting keyword provides the user-defined suffix of the full accounting string.\n\nThe accounting string prefix consists of 56 bytes generated by StarSQL. The fields are right-padded and are described in Table 12.\n\nTable 12. Accounting String Prefix\n\n<table>\n<thead>\n<tr>\n<th>Field</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>acct_str_len</td>\n<td>1 byte, length of the accounting string minus 1 in hexadecimal format</td>\n</tr>\n<tr>\n<td>client_prdid</td>\n<td>8 bytes, product ID for the driver</td>\n</tr>\n<tr>\n<td>client_platform</td>\n<td>18 bytes, client operating system</td>\n</tr>\n<tr>\n<td>client_appl_name</td>\n<td>20 bytes, client application</td>\n</tr>\n<tr>\n<td>client_authid</td>\n<td>8 bytes, authorization id of the StarSQL user</td>\n</tr>\n<tr>\n<td>suffix_len</td>\n<td>1 byte, length of the accounting string suffix in hexadecimal format</td>\n</tr>\n</tbody>\n</table>\nThe user-defined suffix is used to further refine the accounting record. The user enters the suffix in the accounting string field in the data source setup. In the following example accounting string, the user-supplied suffix is SALES:\n\n```\n\"x'3C'STARSQL2UNIX mypgm BARNES x'05'SALES\"\n```\n\nIf there is no value specified for the Accounting keyword, the accounting string will have a null suffix, as shown in the following example:\n\n```\n\"x'3C'STARSQL2UNIX mypgm BARNES\"\n```\n\nFor information about interpreting the accounting record on DB2, see the IBM documentation for your version of DB2 for z/OS.\n\n**AllowSynonyms**\n\nThe default behavior of StarSQL is to retrieve index information for synonyms from Db2 for z/OS. To disable synonym support, enter `AllowSynonyms=No` in the data source configuration. If you set `AllowSynonyms` to No, StarSQL uses the default qualifier to qualify unqualified table references in catalog calls, such as with `SQLStatistics()`.\n\n**AlwaysWide**\n\nSetting this option to Yes will force all SQL parameters and resultset columns of “character-type” to be described as their “WIDE” equivalents.\n\n**AutoBind**\n\nThe AutoBind keyword forces SQL packages to be bound at connect time. Normally the use of AutoBind is not recommended, because it always causes binding to occur and thus adversely affects connect time performance.\n\nThe AutoBind option settings are described in Table 13.\nTable 13. AutoBind Keyword Settings\n\n<table>\n<thead>\n<tr>\n<th>AutoBind Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0 (Default)</td>\n<td>No auto-bind at connect time. The driver still binds packages on-the-fly if it does not find them on the server when it needs them.</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Binds packages at connect time, but uses NO REPLACE option on bind. If the packages already exist they will not be replaced. In the current version of StarSQL, AutoBind=1 ignores the NO REPLACE option and functions in the same manner as AutoBind=2.</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Binds packages at connect time and always replaces current packages, if there are any.</td>\n</tr>\n<tr>\n<td>Y</td>\n<td>Same as 2.</td>\n</tr>\n<tr>\n<td>N</td>\n<td>Same as 0.</td>\n</tr>\n</tbody>\n</table>\n\nRegardless of the AutoBind setting, the driver still binds packages dynamically if it does not find them on the host at the time they are needed. The packages that may be bound by 1 and 2 are: the dynamic package for the current transaction isolation level and the catalog package.\n\n**AutoSqlSet**\n\nSome DBMS systems accept information that identifies the client connection---user ID, computer name, and application name. Set AutoSqlSet to No if the host does not support this functionality or you do not want to send this client connection information to the DBMS.\n\nIf StarSQL detects that the host supports the client connection information, it automatically sets the AutoSqlSet setting to Yes. Set AutoSqlSet to D (for \"disabled\") if you do not want StarSQL to change the AutoSqlSet setting to Yes for hosts that accept client connection information.\nAutoTypDefOvr\n\nYou can set a value for AutoTypDefOvr in the global DSN .swodbc.ini file, for a system DSN in the odbc.ini file, or for a user DSN in the .odbc.ini file. The AutoTypDefOvr setting stores the Coded Character Set Identifiers (CCSIDs) that the DB2 host provides to StarSQL upon connection.\n\nAfter the connection with the host is established, StarSQL uses the CCSID values specified for AutoTypDefOvr to send SQL statement and parameter data to the host unless the TypDefOvr value specifies to use different CCSIDs. The TypDefOvr setting takes precedence over values specified in the AutoTypDefOvr setting. However, if the AutoTypDefOvr CCSID values are appropriate, TypDefOvr values do not need to be sent with each DRDA request.\n\nThe AutoTypDefOvr keyword value consists of three comma-separated CCSID values for the single-byte character set (SBCS), the double-byte character set (DBCS), and the mixed-byte character set (MBCS), respectively.\n\n\\[<\\text{SBCS CCSID}>,<\\text{DBCS CCSID}>,<\\text{MBCS CCSID}>\\]\n\nIf the host returns a different CCSID than you want to use for the connection, or you want to override a multi-byte client code page with a MBCS CCSID, set the TypDefOvr to send a particular CCSID value with each DRDA request. (See \"TypDefOvr\" on page 84 for more information about the TypDefOvr setting.)\n\nBinaryCCSID\n\nIf you are experiencing problems with character data being returned as binary data from DB2 for i, specify the CCSID for the character set you want to use in the BinaryCCSID field. This instructs StarSQL to treat binary data as character data using the specified CCSID. For the complete list of supported CCSIDs, refer to the “StarSQL Character Conversion and National Language Support” document in the StarSQL technical documents of the Stelo Web site.\n\nBindRules\n\nThe default value for the BindRules setting is RUN. This setting applies only to applications that use dynamic SQL on a data source on Db2 for z/OS. Set this option to RUN or BIND as desired.\n\nOn DB2 for z/OS, the permissions required to run applications that use dynamic SQL depend on the value of the BindRules option. If it is set to RUN, the StarSQL user needs to have explicit permissions granted by the administrator to read and write the columns and tables accessed by the application. If it is set to BIND, the StarSQL user executes with the permissions of the owner of the dynamic SQL package.\nIf the option is set to BIND, the following SQL statements cannot be executed, regardless of the actual permissions of the package owner:\n\n- SET CURRENT SQLID\n- GRANT\n- REVOKE\n- ALTER\n- CREATE\n- DROP\n- Any SQL statement that cannot be prepared as dynamic SQL\n\n**CacheUID**\n\nIf you set CacheUID=Yes (the default), the username to connect using StarSQL is displayed in the connect dialog and the user only needs to enter their password. Set CacheUID=No to require users to enter both their username and their password to connect to the DB2 host using StarSQL.\n\n**CatFilters**\n\nThe CatFilters setting restricts the amount of data retrieved by ODBC catalog functions when a NULL or ‘%’ is passed as the schema name. Set CatFilters to the name of a particular library or collection to limit the amount of data retrieved from the specified library or collection when a catalog function is executed. You can specify a maximum of 10 names for filtering the data. The names must be enclosed in single quotation marks and separated by a comma (such as ‘name1’, ‘name2’, ‘name3’, ...).\n\nThis feature is supported by the following DB2 hosts:\n\n- Db2 for z/OS\n- Db2 for i\n- Db2 for Linux, UNIX & Windows\n\n**CatQual**\n\nSet the catalog qualifier to the location of the Db2 system tables that StarSQL uses when an application calls an ODBC catalog function. Set the catalog qualifier to SYSIBM for Db2 for z/OS, SYSCAT for Db2 LUW, or QSYS2 for Db2 for i.\nCharacterSubstitution\n\nIf one or more characters cannot be converted between the host and client character sets, StarSQL substitutes a question mark, ?, in place of the character(s). The CharacterSubstitution parameter determines whether a warning is generated when characters are replaced (parameter value of Warning), or the characters are substituted without generating a warning (parameter value of Silent).\n\nCreateTable\n\nSet the CreateTable string to contain a directive that you want to append to SQL CREATE TABLE statements. The directive indicates where you want the table to be created.\n\nFor example, if `CreateTable=IN DATABASE DSNTEST` and an application passes the following statement:\n\n```\ncreate table test (num integer)\n```\n\nthe StarSQL driver passes the statement to Db2 as:\n\n```\ncreate table test (num integer) IN DATABASE DSNTEST\n```\n\nValid values for the CreateTable keyword depend on the host where the data source is located, as shown in Table 14.\n\nTable 14. Supported CreateTable Directives\n\n<table>\n<thead>\n<tr>\n<th>DB2 Host</th>\n<th>Valid Table Creation Directives</th>\n<th>Comment</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Db2 for z/OS</td>\n<td>IN DATABASE <code>DATABASE_NAME</code> IN DATABASE <code>DATABASE_NAME.TABLESPACE</code></td>\n<td>A node group name is a qualified or unqualified name that designates a nodegroup, which is a group of Db2 for i systems across which a table is distributed.</td>\n</tr>\n<tr>\n<td>Db2 for i</td>\n<td>IN NODE <code>GROUP_NAME</code></td>\n<td>A tablespace name is a long qualifier that identifies a distinct table space that is described in the Db2 catalog.</td>\n</tr>\n<tr>\n<td>Db2 LUW</td>\n<td>IN <code>TABLESPACE_NAME</code></td>\n<td></td>\n</tr>\n</tbody>\n</table>\nCustomizePrdid\n\nThe CustomizePrdid parameter customizes the behavior of a DB2 for z/OS host that is using a double-byte character set (DBCS). Db2 for z/OS does not support the ESCAPE clause in SQL syntax when the LIKE argument uses a mixed-byte character set.\n\nWhen the CustomizePrdid parameter is set to M (for Mixed), StarSQL will strip the backslash escape character (\\) from both the catalog SQL that is used to bind catalog packages and from dynamic catalog SQL calls. The CustomizePrdid parameter must be enabled prior to binding packages, and it must be enabled in the DSN that is used to connect to the host from the StarSQL client.\n\nThe escape character precedes a special character, such as the underscore (_) character, to treat the character as a literal. To work with tables that include an underscore in the name, such as MY_TABLE, create an ALIAS, SYNONYM, or VIEW for the table with a name that includes no special characters instead of working directly with the table.\n\nDefaultQualifier\n\nSet DefaultQualifier to a value that you want to use to qualify all unqualified SQL statements. On DB2 for i, this qualifier refers to an IBM i library. On other Db2 hosts it refers to an Owner or Authorization Identifier.\n\nDescription\n\nThis is an optional keyword to provide a textual description of the data source.\n\nFetchAhead\n\nFetchAhead is a means of retrieving data from the host before the application needs it. This data is fetched from the host, stored in the driver, and returned to the application on request. This improves performance by reducing delays in receiving data from the host. The default for FetchAhead is Yes.\n\nFoldUIDPWD\n\nSet FoldUIDPWD to Yes if you want StarSQL to force the UserID and Password to uppercase letters if the user is connecting using Microsoft SNA. When FoldUIDPWD is set to No, user IDs and passwords are sent in the case they were entered.\nGetInfoCatalogUsage\n\nApplications can call SQLGetInfo with the SQL_CATALOG_USAGE option to determine the classes of SQL statements in which catalog and schema names can be used to qualify objects of SQL statements. Setting the GetInfoCatalogUsage parameter of the StarSQL driver allows you to customize the bitmask that is returned by SQLGetInfo() for SQL_CATALOG_USAGE.\n\nSet GetInfoCatalogUsage to 0 to force StarSQL to report that it does not support three-part naming (no Catalog). This may be necessary in some situations, such as when using StarSQL to perform queries to a SQL Server linked server. If GetInfoCatalogUsage contains an empty string or -1, the normal bitmask is returned.\n\nHeld.Cursors\n\nYou can set the HeldCursors keyword to No, Yes, or Default. Yes enables held cursors. No disables held cursors. The behavior of held cursors when the value is Default depends on the host platform, as shown in Table 15. If the host does not support held cursors, the HeldCursors keyword is ignored.\n\n<table>\n<thead>\n<tr>\n<th>Host</th>\n<th>Behavior if HeldCursors=Default</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DB2 for z/OS</td>\n<td>Enables held cursors (equivalent of HeldCursors=Yes)</td>\n</tr>\n<tr>\n<td>DB2 for i and DB2 LUW</td>\n<td>Disables held cursors (equivalent of HeldCursors=No)</td>\n</tr>\n</tbody>\n</table>\n\nNormally, a cursor is closed when its transaction commits. If the HeldCursors keyword is enabled, the cursor remains open after the commit. This allows an application to fetch rows from a result set, commit the transaction, and then continue fetching additional rows on the same result set.\n\nUsing held cursors, an application can commit immediately after opening the result set to allow locks normally needed to maintain a prepared statement to be freed early. If the application is in auto-commit mode, StarSQL automatically issues a commit at the time the result set is opened and at the time the result set is closed.\n\nAn application that uses held cursors should turn off SQL_AUTOCOMMIT_MODE before executing a prepared statement multiple times. Otherwise, StarSQL prepares the SQL statement after each SQLExecute, resulting in slower performance.\nBefore enabling HeldCursors, manually delete any existing SQL package used for catalog information on DB2. This is the package with the same name as the catalog schema. A new SQL package will be created the next time you establish a connection using the updated StarSQL driver.\n\nIf you are upgrading from a previous version of StarSQL, you may need to delete and rebind the SQL catalog package if you change the HeldCursors setting.\n\n**HideTsScale**\n\nIStarSQL 6.34 & later supports (and properly describes) TIMESTAMP columns with a scale between 0 and 12. We have chosen to expose Db2's default timestamp precision of 6 as a separate data type name in SQLGetTypeInfo(), named \"TIMESTAMP(6)\", the type name \"TIMESTAMP\" is now described as having variable scale from 0 to 12.\n\nSetting the data source option HideTsScale=Yes will instruct StarSQL to revert to pre-6.34 behavior and hide the variable scale version of TIMESTAMP in SQLGetTypeInfo().\n\n**IncludeSynonyms**\n\nIncludeSynonyms support is enabled by default. Set IncludeSynonyms to No if you do not want to support SYNONYMS in catalog calls. When AllowSynonyms or IncludeSynonyms is disabled, synonyms are not returned in results and are not found when passed as input parameters. When AllowSynonyms or IncludeSynonyms is set to Yes, synonyms are supported, as both input and output, in catalog calls.\n\n**IsolationLevel**\n\nIsolationLevel refers to the degree of concurrency allowed when multiple transactions try to access the same data. You can set the isolation levels for StarSQL using an integer that represents the level, as described in Table 16. The StarSQL driver uses a default isolation level of 0 for the Db2 for i host and a default of 2 for the other supported hosts.\nTable 16. **IsolationLevel Values**\n\n<table>\n<thead>\n<tr>\n<th>IsolationLevel Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><Default></td>\n<td>The default is dependent on the host platform. On Db2 for i, the default is None. For most host platforms, the default is Read Committed, which allows the StarSQL driver to access non-journaled files.</td>\n</tr>\n<tr>\n<td>0</td>\n<td><strong>None</strong>: No isolation of concurrent application processes.</td>\n</tr>\n<tr>\n<td>1</td>\n<td><strong>Read_Uncommitted</strong>: For a SELECT INTO, FETCH with a read-only cursor, subquery, or subselect used in an INSERT statement, allows any row read during the unit of work to be changed by other application processes and any row changed by another application process to be read even if the change has not been committed by that application process. For other operations, behaves like Read Committed.</td>\n</tr>\n<tr>\n<td>2</td>\n<td><strong>Read_Committed</strong>: Similar to Repeatable Read in that a unit of work cannot be changed by another process until it has completed, and a row changed by another application process cannot be read until it has been committed. However, with Read Committed, an application process that executes the same query more than once may see newly committed rows inserted by another application process that were not present in the original read.</td>\n</tr>\n<tr>\n<td>4</td>\n<td><strong>Repeatable_Read</strong>: Ensures that any row read during a unit of work can not be changed by other application processes until the unit of work has completed. Also ensures that any row changed by another application process cannot be read until it has been committed. At this level, a process is completely isolated from the effects of concurrent application processes.</td>\n</tr>\n<tr>\n<td>8</td>\n<td><strong>Serializable</strong>: Ensures that any row changed by another application process cannot be read until it is committed by that application process. Ensures only that the current row of every updateable cursor is not changed by other application processes. Rows read during a unit of work can be changed by other application processes.</td>\n</tr>\n</tbody>\n</table>\nKeepDynamic\n\nThe KeepDynamic keyword enables or disables optimization for prepared statements by tuning the KeepDynamic bind option (Db2 for z/OS and Db2 LUW). The default for KeepDynamic is Yes.\n\nLongStrParams\n\nStarSQL v5 added support for Db2 LOB (large object) data types. The LongStrParams setting provides backwards compatibility to use StarSQL v5 with hosts that do not support LOBs and applications that rely on the previous ODBC data types.\n\nAs shown in Table 2 on page 22, StarSQL v5 changes the mapping for DB2 long strings—they are no longer differentiated from short strings:\n\nThe new data type mappings affect ODBC catalog query results. For example, SQLColumns for a DB2 LONG VARCHAR now returns ODBC type SQL_VARCHAR instead of SQL_LONGVARCHAR. The new mappings also affect parameters for SQL statements. If an application binds a parameter as SQL type SQL_LONGVARCHAR, it is sent as a DB2 CLOB instead of as a DB2 VARCHAR string.\n\nWhen LongStrParams is set to Yes, then SQL_LONGVARCHAR is sent as VARCHAR instead of CLOB, and SQL_LONGVARBINARY is sent as VARCHAR FOR BIT DATA instead of BLOB. This LongStrParams setting does not affect the types returned for result set columns, or for types returned by catalog queries.\n\nWhen StarSQL v5 or later connects to an older version of Db2 that does not support LOB data types, the LongStrParams data source setting is forced to Yes and SQL_LONGVARCHAR and SQL_LONGVARBINARY parameters are sent as strings. Catalog queries, however, will not return SQL_LONGVARCHAR or SQL_LONGVARBINARY for long string types.\n\nMaxRows\n\nSet the MaxRows keyword to the maximum number of rows that can be returned by a result set. Set this value to limit the number of rows returned in queries that do not call SQLSetStmtOption with the SQL_MAX_ROWS parameter.\n\nIf you do not want to set an upper limit, enter zero or leave the field blank.\nOverrideCodeset\n\nThe OverrideCodeset parameter allows you to override the name of the local codeset that StarSQL uses to convert outbound character data. The codeset names are defined in the library that contains the conversion routines.\n\nStarSQL obtains the locale (Linux, UNIX) or code page (Windows) that is set on the client computer and performs a lookup of the corresponding codeset name in the ccsid.csv table to find the corresponding CCSID value to use. For example, if the code page for a Windows client is set to 1252, StarSQL looks for a codeset name of “WINDOWS-1252” in the ccsid.csv file.\n\nThe OverrideCodeset parameter can be useful if you want to send data encoded using a different codeset, or to match a local codeset name that is not in the ccsid.csv file to one that is. The value for the OverrideCodeset parameter can be any string.\n\nPkgOwnID\n\nThe SQL Package Owner ID (PkgOwnID) specifies the owner ID to associate with the StarSQL driver packages that reside on the host. The target DBMS host uses the PkgOwnID value to validate whether the user has authority to perform the functions represented by the SQL statements in the bound package. This option can be useful in situations where an administrator needs to bind the driver packages but does not want to be the owner of the packages.\n\nThe default package owner is the user ID that is used to establish the ODBC connection when a package is bound. Enter up to 8 characters for the PkgOwnID option to specify a different user ID as the package owner. After you set the PkgOwnID option, run StarAdmin to bind the desired StarSQL packages with the package owner that was specified for PkgOwnID.\n\nQryBufSiz\n\nSet the size of the query buffer. The buffer size can be between 512 bytes and 10485760 bytes. The default is 2097151. A large query buffer can improve performance for large queries.\n\nReadOnly\n\nSet to Yes if the data source is read only. This prevents users from attempting to update the host database. Set to No if you want the StarSQL user to be able to update the host database (to the extent allowed by the host security).\n**SpecialColumns**\n\nThe SQLSpecialColumns function retrieves the following information about columns in a specific table:\n\n- the optimal set of columns that uniquely identify a row\n- columns that are automatically updated when any value in the row is updated\n\nBy default the SpecialColumns function is enabled (set to Yes). To disable the function, set the SpecialColumns keyword to No, which returns an empty results set if the SpecialColumns function is invoked.\n\n**SSL**\n\nSetting this option to Yes will cause StarSQL to establish a secure connection using SSL/TLS protocols. The following requirements apply:\n\n- SSL support requires certain versions of Linux and OpenSSL. Refer to the System Requirements section of the Release Notes for the supported versions of Linux and OpenSSL\n- The Db2 host must be enabled for SSL communications. If the host is not enabled for SSL, you can use a Stelo StarPipes Gateway to provide SSL support.\n- Set the Port property to the appropriate value for your Db2 host (typically 448)\n- Install the CA certificate for the Certificate Authority that issued the server certificate being used by the DB2 host into the certificate store used by OpenSSL. This may not be necessary if the certificate was issued by a public certificate authority that is already known by OpenSSL,\n\n**SSLOptions**\n\nThe value of this parameter is a 64-bit hexadecimal string that can be used to supply advanced options for SSL/TLS communications. Contact Stelo Support for usage.\n\n**StrictParsing**\n\nWhen StrictParsing is enabled, which is the default, the SQL sent by an application must be acceptable to the StarSQL parser. If the SQL does not comply, StarSQL generates an error message and does not send the SQL.\nIf StrictParsing is disabled, StarSQL passes the SQL to the host database as-is. Some functionality, such as SQLDescribeParam(), may not be available to the application if StrictParsing is disabled.\n\n**TrustedConnection**\n\nSetting this option to YES will cause StarSQL to attempt to establish a \"Trusted Connection\". That connection can then be used to switch between active User Ids, optionally using \"Identity Propagation\".\n\nCurrently, this option is supported only for connections to Db2 for z/OS (v9 and later); contact Stelo support if you plan to use this option for connections to DB2 for LUW.\n\nFor further details, see the technical note “Using TrustedConnection and Identity Propagation” on the Stelo Info Center website.\n\n**TwoPC**\n\nSet the TwoPC keyword to `XA` to use XA Distributed Transactions. The default value is `No`. The value `TCP/IP`, used for Two-Phase Commit with Microsoft Transaction Server (MTS) and Distributed Transaction Coordinator (DTC), is supported by StarSQL for Windows and is not available for StarSQL for UNIX.\n\n**TypDefOvr**\n\nUse the TypDefOvr keyword to explicitly set the SBCS CCSID that StarSQL uses to send character data to the Db2 host. When TypDefOvr is set, StarSQL sends the data using the CCSID specified in the TypDefOvr with each DRDA request.\n\nThe CCSID specified for TypDefOvr overrides the CCSID values specified for AutoTypDefOvr (see page 66). The TypDefOvr keyword value can be any SBCS CCSID that StarSQL supports. (For the complete list of supported CCSIDs, refer to the “StarSQL Character Conversion and National Language Support” document in the StarSQL technical documents of the Stelo Info Center website.)\n\nIf the CCSID specified for TypDefOvr is for a single-byte character set, StarSQL sends all SQL statements and parameters only as single-byte character strings defined by that CCSID. The section \"Connecting an MBCS Client to an SBCS Host\" on page 97 provides additional information about customizing StarSQL to support specific client and host configurations.\nUseDSCRDBTBL\n\nIf the UseDSCRDBTBL setting is Yes, the default, StarSQL uses the DRDA DSCRDBTBL command to implement the SQLColumns ODBC function.\n\nFor hosts that do not support the DRDA DSCRDBTBL command, such as Db2 LUW, or any host in a double-byte environment, set UseDSCRDBTBL to No. In this case, StarSQL implements SQLColumns by preparing and executing a SELECT command.\n\nUseDynamicCatalogSQL\n\nSet the UseDynamicCatalogSQL to Yes if you want the StarSQL driver to use dynamic rather than static SQL for catalog functions when connected to Db2 for zOS servers. The default value is Yes, causing dynamic SQL to be used when it's available.\n\nUseEncryption\n\nThe UseEncryption setting determines whether the login user ID and/or password is sent to the host encrypted or in clear text. When a user logs into the host or changes their host password using a StarSQL connection, StarSQL sends the user ID and password in clear text unless the UseEncryption keyword is set to Yes or Any. To send the user ID and/or password encrypted, you must set the UseEncryption keyword to Yes or Any and the host must support encryption.\n\nDb2 for z/OS supports or successfully negotiates password encryption. DB2 for i supports password encryption, but does not support encrypted user IDs; therefore the UseEncryption setting must be Any or No (note - this may be obsolete information). Db2 LUW supports encrypted passwords if you enable the database for encryption as described in \"Enabling Encryption\" on page 41.\n\nYou can specify Any, Yes, and No for the UseEncryption setting, as described in the following table. The default value is Any.\n\nTable 17. UseEncryption Keyword Values\n\n<table>\n<thead>\n<tr>\n<th>UseEncryption Setting</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Any</td>\n<td>StarSQL sends the user ID in clear text and the password encrypted. If the login fails, StarSQL then sends both the user ID and password in clear text.</td>\n</tr>\n</tbody>\n</table>\nUseJumboPackages\n\nThe UseJumboPackages variable affects:\n\n• how dynamic SQL packages are bound, and\n• how many SQL statements handles are available when using the StarSQL driver to connect to a Db2 host.\n\nIf you configure the StarSQL DSN to use jumbo packages (UseJumboPackages=Yes), StarSQL sets the maximum active statement handle limit to 1,314. Each handle can each be used by one ODBC statement at a time. If you set UseJumboPackages to No, StarSQL binds the packages with a maximum of 64 statement handles.\n\nTo take full advantage of this option you must enable the UseJumboPackages variable before you bind StarSQL packages, and it must be enabled in the StarSQL data source that is used to connect to the database.\n\nIf a dynamic package that is bound with 64 sections (UseJumboPackages=No) receives 65 or more active statements because the StarSQL data source is configured to use jumbo packages, Db2 may report an error that the sections cannot be found. If packages are bound with the jumbo option enabled (UseJumboPackages=Yes), users can connect to DB2 using a StarSQL data source that is configured to use either the typical (64 statement handles) or jumbo-sized (1,314 statement handles) packages.\n\nUseSYSDUMMYAEU\n\nThe UseSYSDUMMYAEU keyword affects how LOB data is processed on a Db2 for z/OS host. The default setting of Yes indicates that the Db2 for z/OS system catalog contains the system tables SYSDUMMYA, SYSDUMMYE, and SYSDUMMYU, and StarSQL will use these tables instead of the standard SYSDUMMY1 table to avoid unnecessary conversion of LOB data that has a CCSID associated with it.\n\nThe SYSDUMMYA, SYSDUMMYE, and SYSDUMMYU tables are created by applying PTFs that IBM made available in APAR PQ85495. You can verify whether these tables exist on the host by entering the following statement:\n\nSELECT * FROM SYSTABLES WHERE NAME LIKE ‘SYSDUMMY%’\nNote that only the SYSDUMMYA and SYSDUMMYE tables are created when applying the PTF to DB2 for z/OS v6—the SYSDUMMYU table is not created for that version. If your system has only the standard SYSDUMMY1 table and your database contains LOB data, the following error may be returned at runtime when users try to access LOB data:\n\n```\nSQLSTATE 42704 (-204) *[StarSQL][StarSQL ODBC Driver][DB2] IS AN UNDEFINED NAME*\n```\n\nTo resolve this error you can:\n\n- set the UseSYSDUMMYAEU keyword to No, or\n- apply the PTFs from IBM APAR PQ85495 (http://www-1.ibm.com/support/docview.wss?uid=swg1PQ85495) to create the new SYSDUMMY tables.\n\nIf you set the UseSYSDUMMYAEU keyword to No, any double-byte EBCDIC or ASCII GRAPHIC data will be converted to UNICODE on the host before it is sent to StarSQL. If host performance is an issue, apply the PTFs and set UseSYSDUMMYAEU to Yes to avoid the unnecessary conversion.\nAppendix E\n\nStarLicense Client Configuration Utility\n\nYou can use the StarLicense Client Configuration utility to manage which StarLicense server or servers are used to check out a license. The StarLicense Client Configuration utility allows you to:\n\n- test that a license can be checked out\n- configure a node-locked license or configure which license server to use for connections from the local computer to a database\n- remove a license server or a node-locked license from the local configuration\n\nFollow the steps below to start the StarLicense Client Configuration utility.\n\n1. Log on to the computer as root user.\n2. Change to the $STARDIR/bin directory where the StarLicense Client Configuration utility is installed.\n3. Enter the following command to execute the startup script and display the StarLicense Client Configuration Menu.\n \n # ./config-lic\n\n The StarLicense Client Configuration Menu appears.\n\nFigure 3. StarLicense Client Configuration Menu\n\nStarLicense Client Configuration Menu\n1) Configure local StarLicense client to use a License Server\n2) Remove a client-server connection from local StarLicense configuration\n3) Display StarLicense client/server configuration\n\n4) Add a node-locked license\n5) Display node-locked licenses\n6) Remove a node-locked license\n\n7) Test licensing checkout\n8) Set StarLicense client logging level\n\n9) Exit\n\nEnter selection (or \"exit\" to quit):\n\nAdding a Node-locked License\nOption 4 of the StarLicense Client Configuration Menu lets you enter a Node-locked license key. Note that the computer must be using a static IP address.\n\nOption 5 will display any configured node-locked licenses, and option 6 will remove them.\n\nAdding a Connection to a StarLicense Server\nOption 1 of the StarLicense Client Configuration Menu lets you define a connection to a StarLicense server. The StarLicense Server software can be installed on a remote computer or the local computer. After you select Option 1 a screen appears so you can specify information about the StarLicense server you want the client to use for licensing.\n\n1. Enter the hostname or TCP/IP address of the StarLicense server. (If the StarLicense Server software is installed on the local computer you can specify the loopback address 127.0.0.1 or “localhost”.)\n2. Enter the port number that the server is using to listen for license requests. The default port number is 4999.\n3. Enter the product ID for the license.\nAfter you provide the StarLicense server information the StarLicense Client Configuration utility shows the client-server connection being added.\n\n### Removing a StarLicense Server Definition\n\nOption 2 of the StarLicense Client Configuration Menu lets you remove a StarLicense server from the local computer’s configuration. After you select Option 2 a screen appears with information similar to the following:\n\n```\nHostname=127.0.0.1 Port=4999 ProductID=SQ PRIMARY\nDelete this connection (y/n)?\n```\n\nIf there is more than one connection defined, respond with N until the connection that you want to remove appears and then enter Y to confirm you want to remove the connection.\n\n### Testing License Checkout\n\nOption 3 of the StarLicense Configuration Menu lets you test that one or more licenses can be checked out. After you configure a license it is good practice to execute this option to verify that licenses can be checked out.\n\nAfter you select Option 3 a prompt appears so you can enter the number of licenses to check out. The default is 1 license, but you can enter any number. After you specify the number of licenses, the utility attempts to check out that number of licenses for the particular product ID and displays the results. Press Enter to check the license(s) back in so they will be available for other connections.\n\n### Displaying the StarLicense Configuration\n\nOptions 4 and 5 of the StarLicense Client Configuration Menu displays information about the current configuration of StarLicense. The information is categorized by Client License Servers, Client License Keys, Server License Keys, and Primary Server Entries, some of which may not be applicable to StarSQL for UNIX licensing. Configuration details include:\n\n- the license keys that have been configured\n- which Stelo product the key is for\n- when the license expires\n- how many connections the license allows\n- the IP address and port that listeners are configured to use\n- the primary and secondary servers if more than one remote StarLicense server has been configured\n• the logging level configured for the server\n• the journaling level configured for the server\n• the number of days that the server journal entries are retained\n\nSetting the StarLicense Client Logging Level\n\nOption 5 of the StarLicense Client Configuration Menu allows you to enable logging of the client license activity. Logging information may be needed by Stelo Customer Support to help troubleshoot a problem with client licensing. If licensing is working fine there is no need to change the logging level from the default value of 0 (zero).\n\nThe valid values for the logging level are:\n\n0 no logging\nFFFFFFFFFF log all license activity\n\nA new log file is created for each process and written to the /tmp directory. The filename format for the log file is:\n\n starliccli.<processID>.log\n\nThe log file contains the timestamp, a message class identifier, and a text string that describes the activity of the license service. Be sure to set the logging level back to 0 (zero) when you no longer need to capture license service activity to avoid creating unnecessary log files.\nStarSQL is a v3.0-compliant Unicode ODBC driver that provides connectivity to any database that is compliant with the Distributed Relational Database Architecture (DRDA). This includes all of IBM’s Db2 family of database products running on mainframe, midrange and workstation-based platforms. StarSQL allows connecting to Db2 from all modern Microsoft Windows and most popular UNIX- and Linux-based computers.\n\nTo support a wide range of host systems, StarSQL includes conversion support for character encoding based upon Unicode, IBM EBCDIC (including Extended EBCDIC) and ANSI (ASCII) standards. In addition, StarSQL supports legacy UNIX encoding, such as Extended UNIX Coding (EUC) and the International Standards Organization (ISO) encoding.\n\nThis appendix provides background of how characters are encoded and data is converted from one system to another, and how StarSQL supports using different languages and character encoding schemes. It is intended for any reader who is interested in character conversion, but is especially pertinent for StarSQL users who are:\n\n- running a client that is configured with a code page for one of the Group 2 languages (Japanese, Chinese, or Korean) that needs to connect to a host that does not support these languages.\n- accessing a Db2 for z/OS system that is supporting one of the Group 2 languages using extended EBCDIC.\n\nThe section \"Customizing StarSQL for National Language Support\" on page 96 specifically addresses using StarSQL in the above situations.\nCharacter Encoding of Data Across Systems\n\nMost legacy (pre-Unicode) client environments use the ASCII-derived character encoding that was developed by the ANSI standards body to store and manipulate character strings. ASCII encoding allowed each ASCII character to be stored as a byte, with the initial version of ASCII using only 7 of the 8 bits available in a byte. This allowed applications to use 128 different characters. ASCII was subsequently extended to support most European characters by using the eighth bit to expand the total range of characters to 256. Currently ASCII refers to either the 7-bit or 8-bit encoding of characters. The Group 2 languages require many more characters than can be encoded by a single byte. These languages typically employ a variety of extensions to 7-bit ASCII, using the high-order bit to designate the use of an additional byte to encode more characters (approximately 32K). Such encoding schemes are termed “multi-byte” character encoding and several distinct dejure standards exist, including ANSI and ISO, in addition to defacto standards such as EUC and IBM’s Extended EBCDIC.\n\nToday most Windows systems provide support for ANSI or Unicode encoding schemes, and most UNIX systems provide support for ISO or Unicode. Most IBM host systems support EBCDIC and Unicode. StarSQL is designed to support connectivity among these different platforms.\n\nTo distinguish various encoding schemes, IBM created a standard enumeration of virtually all character encoding using a 16-bit value. This unique value is called the Coded Character Set Identifier (CCSID), and it is used to tag all character data exchanges between StarSQL and the host DBMS. The CCSID is just a number that identifies a particular code page. For example, a host in the U.S. or Canada would typically use the US-English code page denoted by a CCSID of 37, whereas a host in Germany may use a code page represented by CCSID 273.\n\nCharacter data in most Linux, UNIX, and Windows environments is represented only by a code page, which StarSQL treats as a CCSID. For example, the U.S. form of English using ANSI encoding is CCSID 1252.\n\nStarSQL uses the CCSID to identify client and host encoding schemes in a variety of ways, including for Expert Settings that modify the behavior of the driver.\n\nStarSQL and Unicode\n\nStarSQL uses Unicode internally to parse SQL statements and as the basis for converting unlike data encoding between connected systems. This use of Unicode internally also allows StarSQL to efficiently receive Unicode from modern host systems that use Unicode as the native encoding scheme.\nDetermining and Setting the Client Code Page\n\nStarSQL determines the local client’s code page by a variety of system calls—the value is normally returned as part of the “locale” API support.\n\nOn a Windows-based computer the system language is specified in the Regional and Language Options of the Control Panel. The code pages that determine how non-Unicode characters are converted are represented by a numeric string, such as 1252 for US-English code page. StarSQL converts the code page number to a string that the conversion routines can process, such as WINDOWS-1252.\n\nOn a Linux- or UNIX-based computer, you specify what code page to use by setting the locale, which is specified by the LANG environment variable. You can modify the locale using the LANG, LC-CTYPE, or LC_ALL environment variables.\n\nDetermining the Host Code Page\n\nThe code pages that are specified for the host to use are detected as part of the initial exchange between StarSQL and Db2. You can determine the CCSIDs that the host is returning to StarSQL by connecting to DB2 using a StarSQL data source. After you connect to the Db2 host, look at the AutoTypDefOvr parameter in the .odbc.ini file to see the CCSID values that the host returned to StarSQL. Use the view command, as shown below, or any text editor, to display the contents of the initialization file.\n\n```\n> view .odbc.ini\n```\n\nThe AutoTypDefOvr setting is three comma-separated values of the CCSID for SBCS, DBCS, and MBCS, respectively. For example, the following AutoTypDefOvr value indicates that the DB2 host returned CCSID 37, with no CCSID value set for DBCS or MBCS.\n\n```\nAutoTypDefOvr=37,0,0\n```\n\nTo control the SBCS CCSID that StarSQL uses to send outbound data, you can modify the TypDefOvr value of the StarSQL data source as described in \"Customizing StarSQL for National Language Support\" on page 96.\n\nStarSQL Implementation Details\n\nThe default behavior of the StarSQL driver typically involves the following steps when connecting to a Db2 host and exchanging SQL data.\n\n1. StarSQL connects to Db2 and obtains the CCSID values that the host expects for SBCS, DBCS, and MBCS data. These CCSID values are stored in the AutoTypDefOvr setting of the StarSQL data source for future use.\n2. StarSQL sends SQL statements and input data to Db2, converting SBCS data to the host-specified CCSID for single-byte data. Mixed-byte data is sent using the client code page, and the host is responsible for converting it to the host-specified CCSID for DBCS and MBCS data.\n\n3. Db2 converts the data to the host server’s code page, if necessary, and then processes the data.\n\n4. Db2 sends the result back to the StarSQL client.\n\n5. StarSQL converts the result to the code page of the client computer.\n\nStarSQL performs inbound data conversion from the host system based upon the mappings that are defined in the `ccsid.csv` table that is installed with StarSQL. The `ccsid.csv` table is platform-specific, and is installed to the `\\Programs` directory of a Windows-based computer or to the `$STARDIR/etc/conf` subdirectory of a Linux- or UNIX-based computer.\n\nIn order for StarSQL to convert data from one character set to another, there must be a mapping defined in the `ccsid.csv` table for all the CCSIDs used in the exchange. If there is no mapping defined for a specified CCSID, an error is reported. Support for additional character conversions may be requested from Stelo Customer Support, and you also may be able to customize the StarSQL data source to use a different CCSID that is supported as explained in the next section, “Customizing StarSQL for National Language Support.”\n\nIf one or more characters cannot be converted between the host and client character sets, StarSQL substitutes a question mark, ?, in place of the character(s). You can configure whether the substitution generates a warning by setting the `CharacterSubstitution` parameter of the StarSQL data source (see page 76).\n\n### Customizing StarSQL for National Language Support\n\nThis section addresses situations that may require customizing StarSQL to support a specific client connecting to a specific Db2 host: StarSQL may need to be customized in order to:\n\n- establish a connection between a client that is configured with a code page for one of the Group 2 languages (Japanese, Chinese, or Korean) and a host that does not support these languages.\n\n- access a Db2 for z/OS system that is supporting one of the Group 2 languages using extended EBCDIC.\nConnecting an MBCS Client to an SBCS Host\n\nIBM encoding of the MBCS support recognizes two distinct CCSIDs for SBCS and DBCS encoded characters. Typically only characters encoded using the SBCS component are used in SQL statements, while both DBCS and MBCS data can be the output of the SQL statements. If a host is not configured to support mixed-byte character sets it can receive only SBCS data.\n\nTypically StarSQL sends SBCS data to the host with characters encoded according to the CCSID value that the host indicates it is using for SBCS data when it returns the AutoTypDefOvr to StarSQL. You can specify a particular CCSID to use for converting SQL data by setting the TypDefOvr parameter of the data source that StarSQL uses to connect to the host.\n\nThe TypDefOvr setting overrides the SBCS CCSID value that is specified in the AutoTypDefOvr setting. When converting SQL data to a form the host can use, StarSQL will use the conversion routine that is associated with the CCSID in the TypDefOvr setting, regardless of the client computer’s character encoding scheme (SBCS or MBCS) or the AutoTypDefOvr values.\n\nIf a host reports to StarSQL that a CCSID being used by the client is not acceptable, useful connectivity may still be achieved by specifying an SBCS CCSID that is supported by the host, which restricts the SQL character data to only single-byte character strings. For example, when connecting a client computer that is using a Japanese character set to a U.S.-based host that does not support Japanese mixed-byte character set, you can force a specific SBCS CCSID to be used by setting the TypDefOvr setting of the StarSQL data source.\n\nSupporting Asian Languages with Extended EBCDIC\n\nSome multi-byte host environments have restrictions regarding the type of SQL phrases which may be used. Specifically, hosts that are running DB2 for z/OS with support for Group-2 languages may not handle the default SQL statements used by StarSQL to fulfill ODBC catalog calls.\n\nWhen using Extended EBCDIC client encoding, StarSQL packages must be bound with the CustomizePrdid parameter enabled for “Mixed” (see page 77). Setting the CustomizePrdid parameter to M (Mixed) disables use of the backslash character, \\\\, as an escape character in arguments passed to catalog functions. The escape character precedes a special character, such as the underscore (_) character, to treat the character as a literal. To work with tables that include an underscore in the name, such as MY_TABLE, create an ALIAS, SYNONYM, or VIEW for the table with a name that includes no special characters instead of working directly with the table.\nStarSQL National Language Support\n\nStarSQL packages are normally bound using the StarAdmin utility that is included with the Windows version of StarSQL. Be sure that the DSN has CustomizePrdid set to Mixed before binding packages with the StarAdmin utility. The ODBC DSN that StarSQL clients use to connect to the host also must be configured with CustomizePrdid set to Mixed to use the packages that are bound with CustomizePrdid set to Mixed.\n\nCurrently Supported CCSIDs\n\nStarSQL supports converting character data between a wide range of CCSID-to-CCSID pairs and CCSID-to-code-page pairs. It supports Group 1, Group 1A, and Group 2 character sets as defined by CDRA.\n\n- Group 1 covers the Roman Alphabet Number 1, which includes Australia, Hong Kong, New Zealand, North and South America, and Western Europe.\n- Group 1A covers multilingual scripts Cyrillic, Hebrew, Greek, and Turkish. The Latin 2 character set associated with Central Europe is supported in this group.\n- Group 2 covers double-byte coding for Japan, Korea, the People’s Republic of China, the Republic of China, and Thailand.\n\nFor the complete list of supported CCSIDs, refer to the “StarSQL Character Conversion and National Language Support” document in the StarSQL technical documents of the Stelo Info Center web site.\nGlossary\n\nAPAR - Authorized Program Analysis Report A request for correction of a problem caused by a defect in a current unaltered release of a program.\n\nAPPL An APPL statement defines the Db2 subsystem to VTAM for the purposes of remote access. It is required for any configuration that involves a Db2 host on an IBM mainframe (z/OS).\n\nauthorization identifier On Db2 for z/OS, the authorization identifier is user's login ID or an assigned Authorization Identifier, which corresponds to a group with which the user is associated.\n\nBSDS The BSDS (bootstrap data set) is a VSAM data set that contains name and status information for Db2, as well as RBA range specifications, for all active and archive log data sets, passwords for the Db2 directory and catalog, and lists of conditional restart and checkpoint records.\n\nCCSID CCSID (Coded Character Set Identifier) represents a character set, code page, encoding scheme, and additional coding-related information. Used to support international code sets.\n\ncollection A collection is a location on the host for database objects, such as user tables and catalog tables, which are collected together under a single qualifying name.\n\nCoS Class of Service (CoS) is the ability of switches and routers to prioritize traffic into different queues and classes.\n\ndata source A data source describes a connection to a database from an ODBC application.\n\nDDF DDF (Distributed Data Facility) is the vehicle that Db2 uses to send and receive remote procedure calls.\nDRDA DRDA (Distributed Relational database Architecture) supports access to\ndistributed data by which an application can explicitly connect to another location,\nusing an SQL statement, to execute packages that have been previously bound at\nthat location.\n\nDSN A DSN (Data Source Name) is an ODBC definition that refers to a particular\ndatabase.\n\nDynamic SQL Dynamic SQL refers to SQL statements that are prepared and executed\nwithin an application program while the program is executing. A dynamic SQL\nstatement can change during program execution. Contrasted with Static SQL.\n\nheld cursor A held cursor is a cursor that is not automatically closed when its\ntransaction commits.\n\ninstallable image An installable image is an image of a StarSQL installation that can\nbe installed on multiple desktops over the network.\n\nisolation level The isolation level refers to the degree of concurrency permitted in a\ntransaction.\n\nODBC ODBC (Open Database Connectivity) is a call-level interface developed by\nMicrosoft Corporation that allows a single application to access DBMSs from\ndifferent vendors using a single interface.\n\nOpen Edition Open Edition is a component of the z/OS operating system that provides\na UNIX-like environment and supports TCP/IP processing.\n\npackage A package is an object on the host containing a set of SQL statements that\nhave been bound statically and are available for processing.\n\nPTF Program Temporary Fix - a method used by IBM for distributing fixes quickly.\n\nRDB Name An RDB name is a unique identifier for an RDBMS within a network.\n\nStatic SQL Static SQL refers to SQL statements in an application program that are\ncreated before the application executes. After being created, a static SQL statement\ndoes not change, although values of host variables specified by the statement might\nchange. Contrasted with Dynamic SQL.\n\nsystem catalogs The system catalogs are tables in the host database that Db2 uses to\nkeep track of the system. On some RDBMSs, they are called the system tables.\n\nTCP/IP TCP/IP (Transmission Control Protocol / Internet Protocol) is a commonly-\nused network protocol.\n\nuser id A user id is a unique identifier that enables a user to logon to a host.\nVTAM VTAM (Virtual Telecommunications Access Method) provides network communications on IBM z/OS systems.\n\nVSAM Virtual Storage Access Method - A data storage system used in IBM z/OS. VSAM was designed to organize data more efficiently and to improve access time by searching indexes instead of actual files.\nGlossary\nIndex\n\n_ character, limitations for 77, 97\n? substitution character 76, 96\n\nSymbols\n$STARDIR 14\n\nA\naccess rights 66, 82\nAccounting 71\nAccounting keyword 71\naccounts, user 30\nAIX\n versions supported 19\nAllowSynonyms 72\nAllowSynonyms keyword 72\nAlwaysWide 72\nAlwUpd keyword 66\napplications, developing StarSQL 27\nAS/400 host 34\nASCII 93\nAsian language support 97\nauthentication 44\nAutoBind keyword 51, 72\nAutoSqlSet 73\nAutoSqlSet keyword 73\nAutoTypDefOvr keyword 66, 74, 95\n\nB\nbinary data 74\n\nBinaryCCSID 74\nBinaryCCSID keyword 74\nbind option, EXPLAIN 67\nbinding packages 46, 47, 72\nBindRules 74\nBindRules keyword 74\nBLOB data type 12\nbuffer\n query 82\n\nC\nCacheUID 75\nCacheUID keyword 67, 75\ncapturing explain information 46, 67\ncatalog functions\n filtering 75\n query results 13\n system tables for 75\ncatalog package 47\nCatFilters 75\nCatFilters keyword 75\nCatQual keyword 75\nCCSID\n binary data 74\n conversion table 96\n for national language support 93\n in AutoTypDefOvr 66, 74\n in TypDefOvr 83, 84\nIndex\n\nlist of currently supported 98\noverriding 97\nvalues, host 95\nccsid.csv table 96\ncharacter encoding 93, 94\ncharacter sets, international 93\ncharacter substitution 96\nCharacterSubstitution keyword 76, 96\ncharge-back accounting 71\ncheckout, testing license 91\nclient code page 95\nclient connection information 73\nCLOB data type 12\ncode page\nclient 95\nhost 95\nCoded Character Set Identifiers\nsee CCSD\ncodeset name, overriding the 82\ncollection of packages 24, 68\ncommand(s)\n CRTLIB 35\n simpleconn.odbc 26, 58\n starlic-clientcfg 60\n starping 25, 62\n trcstart 63\n trcviewer 64\n WRDSRVTABLE 36\n WRKTCPSTS 36\ncompatibility\nfor LOBs, backwards 81\npackage 46\nconcurrency, controlling 79\nconfiguration files 65, 91\nconfiguration keywords\n Accounting 71\n AllowSynonyms 72\n AlwUpd 66\n AutoBind 51, 72\n AutoSqlSet 73\n AutoTypDefOvr 66, 74\n BinaryCCSID 74\n BindRules 74\n CacheUID 67, 75\n CatFilters 75\n CatQual 75\n CharacterSubstitution 76\n CreateTable 76\n CustomizePrdid 77\n DefaultQualifier 77\n Description 77\n Driver 68\n Explain 67\n FetchAhead 77\n FoldUIDPWD 77\n GetInfoCatalogUsage 78\n HeldCursors 78\n HostName 24, 68\n IncludeSynonyms 79\n IsolationLevel 79\n KeepDynamic 81\n LongStrParams 81\n MaxRows 81\n OverrideCodeset 82\n PkgColID 24, 68\n PkgOwnID 82\n Port 24, 69\n QryBufSiz 82\n ReadOnly 82\n Server 25, 69\n SpecialColumns 83\n StrictParsing 83\n TypDefOvr 83, 84\n UseDSRDBTBL 85\n useDynamicCatalogSQL 85\n UseEncryption 85\n UseJumboPackages 86\n UseSYSDUMMYAEU 86\nconfiguring\ndata sources 24, 29, 65\nhost system for SSL 43\nlicenses 89\nNational Language Support 96\nrequired DSN parameters 68\nStarLicense 89\nunixODBC driver manager 23\nconnecting to StarLicense server 90\nconnection\n enabling remote Derby 43\n security for 67, 75\n testing the StarSQL/DB2 25\ncontacting StarQuest 15\nconversion table for CCSIDs 96\nconversion tables 93\nconversion, character 76\nCreateTable keyword 76\nCRTLIB command 35\nCustomizePridid keyword 77, 97\n\nD\ndata formats 93\ndata source(s)\n access rights to 82\n configuration parameters 68, 69\n configuring 24, 65\n description 77\n file location 24\n global data settings 66, 71\n host information for 29\n name 24\ndata types 12\ndata, converting 93\ndatabase\n access rights to 82\n name, determining 35\n name, specifying 25, 69\n names, listing 42\n server name 24, 25, 68, 69\nDB2 host(s)\n DRDA port on 39\n enabling DRDA on a 36\n on MVS 31\n preparing an AS/400 34\n RDB name on 35\n supported 11\n system tables 75\ntesting connection to 25\nDBCLOB data type 12\nDDF record\n starting 32\nDefaultQualifier 77\nDefaultQualifier keyword 77\nDerby\n configuring SSL support for 43\n enabling remote connections 43\n host, preparing a 42\nderby.drda.host property 43\nderby.drda.portNumber property 43\nderby.drda.sslMode property 43\nderby.system.home property 43\nDescription keyword 77\ndescription, data source 77\ndirective, table 76\ndocumentation, list of IBM 14\nDRDA 36\n standard 93\n tracing 63, 64\nDriver keyword 68\ndriver manager, unixODBC 23\ndriver pathname 68\nDSCRDBTBL command 85\nDSN\n configuration 24, 69\n configuration file 67\n definition 24\nDSNJU003 utility 31\nDSNTIPR panel 31\ndynamic SQL 45, 47, 74\ndynamic SQL, using 85\nE\nEBCDIC 93, 97\nenabling DRDA 36\nencoding, character 93\nencrypting logins 85\nenvironment variable\n LANG 95\nExplain facility 46, 67\nExtended UNIX Coding (EUC) 93\n\nF\nfeatures, new 9\nFetchAhead keyword 77\nfile(s)\n data source configuration 65\n .odbc.ini 65, 67\n path to driver 68\n .swodbc.ini 65, 67\nFoldUIDPWD 77\nFoldUIDPWD keyword 77\nFreeBSD\n versions supported 19\n\nG\nGetInfoCatalogUsage 78\nGetInfoCatalogUsage keyword 78\nglobal configuration file 67\nglobal data source settings 66, 71\nGroup-2 languages 94, 97\n\nH\nheader files, StarSQL 27\nHeldCursors 78\nHeldCursors keyword 78\nhost(s)\n configuring SSL support on a 43\n DB2 for i 34, 36\n Derby 42\ndetermining the code page for 95\ninformation for data sources 29\nMVS 31\npasswords, changing 32\npermissions to 31\npreparation of 29\nsupported DB2 11\nUDB 38\nuser accounts 30\nHostName keyword 24, 68\nHP-UX\n versions supported 19\n\nI\nIBM documentation 14\nIDs, user 30\nIncludeSynonyms 79\nIncludeSynonyms keyword 79\ninstalling\n StarSQL 20\ninternational language support 93\nInternational Standards Organization (ISO)\n encoding 93\nIP port, setting the 39\nIsolationLevel 79\nIsolationLevel keyword 79\n\nK\nKeepDynamic keyword 81\nkey pair 44\nkey store 44\nkeytool 44\n\nL\nLANG environment variable 95\nlanguage support, international 93\nlevel, concurrency 79\nlibrary, package 35\nlicense\n checkout, testing 91\n configuring 89\n using a server 22\nlicensing StarSQL 60\nlinked servers, sending queries to a 78\nLinux\n removing StarSQL from 20\n system requirements 19\n versions supported 19\nlisting database names 42\nLOB data types 46, 81\nLOB data, processing 86\nlocal code page 95\nlocale 95\nlocation name 25, 69\nlogins, encrypting 85\nLongStrParams keyword 13, 81\n\nM\nmanagement, password 32\nmanager, driver 23\nMaxRows 81\nMaxRows keyword 81\nmixed-byte character sets 97\nmixed-byte client computers 97\nMVS host\n charge-back accounting for 71\n preparing DB2 on an 31\n\nN\nname, overriding the codeset 82\nnames, using catalog and schema 78\nnational languages, support for 93\nnetwork\n connection, testing the 25\nnew features 9\n\nO\nODBC\n catalog functions 45, 75\n compliance 93\n SQLColumns function 85\n SQLSpecialColumns function 83\n .odbc.ini file 65, 67\nOS/390, charge-back accounting for 71\nOverrideCodeset keyword 82\noverriding the CCSID 97\n\nP\npackage owner ID 82\npackage(s) 45\n automatic binding of 51, 72\n binding 46\n binding with Explain 46, 67\n catalog 47\n collection ID 24, 68\n compatibility 46\n dynamic SQL 47\n libraries for 35\n permissions for 31, 49\n page, code 95\n parsing SQL statements 83\n password management 32\n password, encrypting 85\n password, folding to uppercase 77\n passwords, user 30\n pathname, driver 68\n performance, improving 77, 82\n permissions for packages 31, 49\n PkgColID keyword 24, 68\n PkgOwnID 82\n PkgOwnID keyword 82\n port\n for DRDA requests 36\n for TCP/IP connections 24, 39, 69\n Port keyword 24, 69\npreparing\n a DB2 for i host 34\n a DB2/UDB host 38\n a Derby host 42\n DB2 on an MVS host 31\n hosts for StarSQL 29\n protocol, supporting the SSL 43\n\nQ\nQryBufSiz 82\nQryBufSiz keyword 82\nqualifying objects 78\nqualifying SQL statements 77\nquery buffer 82\n\nR\nRDB name 35\nReadOnly keyword 82\nrequirements\n host 11\n workstation 19\nresults set\n empty 83\n limiting 81\nIndex\n\nS\nsecurity, connection 67, 75\nserver key pair 44\nServer keyword 25, 69\nserver, connecting to StarLicense 90\nsilent character substitution 76\nsimpleconn.odbc command 26, 58\nSolaris\n installing StarSQL on 53\n versions supported 19\nSpecialColumns 83\nSpecialColumns keyword 83\nSQL Server\n linked servers, using 78\nSQL statement(s)\n dynamic 47\n improving performance of 82\n parsing 83\n prepared 81\n qualifying 77\n table directive 76\nSQLColumns function 85\nSQLGetInfo() 78\nSQLSpecialColumns function, enabling 83\nSSL protocol 43\n configuring on Derby 43\nstarlic-clientcfg command 60\nStarLicense\n configuration 91\n Configuration Menu 89\n server 90\nStarLicense server 22\nstarping command 25, 62\nStarQuest, contacting 15\nStarSQL\n and Unicode 94\n applications, developing 27\n data exchange 95\n header files 27\n installing 20\n licensing 60\n manually installing 55\n national language support 93\n overview 9\n preparing hosts for 29\n removing 20\n testing 25, 58, 62\n versions comparison 9\nstarting DDF 32\nstatement handle limit 86\nstatic SQL 45\nStrictParsing 83\nStrictParsing keyword 83\nstrings, mapping of DB2 12\n.swodbc.ini file 65, 67\nsynonyms, retrieving 72\nsystem data sources 24\nT\ntables, creating 76\nTCP/IP\n connections, port for 24, 69\n enabling DRDA over 36\n setting the IP port 39\n UDB host address for 38\ntechnical support, StarQuest 15\ntesting licenses 91\ntesting StarSQL 25, 58, 62\ntracing\n DRDA 63, 64\ntransactions\n access rights to 66\n controlling concurrency of 79\ntrcstart command 63\ntrcviewer command 64\nTrustedConnection 84\nTwo-phase commit 27\nTypDefOvr keyword 83, 84, 97\nU\nUDB host 38\nunderscore character, limitations for 97\nUnicode 94\nunixODBC driver manager 10\nconfiguring the 23\ntesting the 26, 58\nuppercase, folding UserID and Password to 77\nUseDSCRDBTBL 85\nUseDSCRDBTBL keyword 85\nUseDynamicCatalogSQL 85\nUseDynamicCatalogSQL keyword 85\nUseEncryption keyword 85\nUseJumboPackages keyword 86\nuser\naccounts 30\nuser data sources 24\nUserID, folding to uppercase 77\nUseSYSDUMMYAEU 86\nUseSYSDUMMYAEU keyword 86\nutility\nODBCConfig 24\nStarAdmin 46\nV\nverifying license checkout 91\nversions, StarSQL 9\nW\nworkstation requirements 19\nWRDSRVTBL command 36\nWRKTCPSTS command 36"}}},{"rowIdx":193,"cells":{"id":{"kind":"string","value":"9748f9ed343a15bd46f13de19a80d2ecf6a5b1a8"},"text":{"kind":"string","value":"PLEASE NOTE\n\nAlthough every care has been taken with the production of this book to ensure that any projects, designs, modifications and/or programs etc. contained herein, operate in a correct and safe manner and also that any components specified are normally available in Great Britain, the Publishers do not accept responsibility in any way for the failure, including fault in design, of any project, design, modification or program to work correctly or to cause damage to any other equipment that it may be connected to or used in conjunction with, or in respect of any other damage or injury that may be so caused, nor do the Publishers accept responsibility in any way for the failure to obtain specified components.\n\nNotice is also given that if equipment that is still under warranty is modified in any way or used or connected with home-built equipment then that warranty may be void.\n\n© 1983 BERNARD BABANI (publishing) LTD\n\nFirst Published – July 1983\nReprinted – July 1986\nReprinted – October 1989\n\nBritish Library Cataloguing in Publication Data\nParr, E. A.\nA Z-80 workshop manual. – (BP112)\n1. INTEL Z-80 (Computer)\n1. Title\n001.64°04 QA76.8.I/\n\nISBN 0 85934 087 2\n\nPrinted and bound in Great Britain by Cox & Wyman Ltd, Reading\nINTRODUCTION\n\nAlthough there are many contenders for the title of “most successful micro”, the Z-80 has been universally acclaimed as the most powerful and versatile 8 bit microprocessor. It is found in many popular microcomputers, including the Nascom, TRS-80, ZX-80/81, Spectrum, Video Genie, Sharp MZ-80K and Cromenco machines.\n\nThis book has been written for owners of Z-80 based machines who have become reasonably proficient in BASIC, and wish to progress to machine code and assembler language programming. This can be a rather daunting task, as most Z-80 literature has been designed for computer professionals and is not readily understandable.\n\nThe book has also been designed to be a general introduction to machine code programming. All the popular microprocessors such as the 6502, 6800 etc. use similar techniques to the Z-80. Once the Z-80 has been mastered, the reader will have little problem with its simpler cousins. It is therefore hoped that the book will also prove useful to anyone who is simply interested in computing.\nACKNOWLEDGEMENTS\n\nThis book is about the Zilog Z-80 microprocessor, and contains all the detail necessary for the average enthusiast to gain insight into any Z-80 based microcomputer. It follows that much of the information given has been obtained from Zilog, and their assistance is greatly appreciated.\n\nIt should be noted that Zilog, Z-80 and the various microcomputers and assembler/monitor names referred to in the text are registered trade marks.\n\nMy wife Alison, has, as usual, been long suffering; not only putting up with the computers in the house, but also doing my typing despite a house move over the length of the United Kingdom.\n\nAndrew Parr.\nMinster,\nIsle of Sheppey.\n# CONTENTS\n\n<table>\n<thead>\n<tr>\n<th>Chapter One: THE MICROCOMPUTER</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1.1 Introduction</td>\n<td>1</td>\n</tr>\n<tr>\n<td>1.2 Computer Architecture</td>\n<td>1</td>\n</tr>\n<tr>\n<td>1.3 The Store</td>\n<td>2</td>\n</tr>\n<tr>\n<td>1.4 The Central Processor Unit (or CPU)</td>\n<td>5</td>\n</tr>\n<tr>\n<td>1.5 Input and Output</td>\n<td>9</td>\n</tr>\n<tr>\n<td>1.6 Instructions and Programs</td>\n<td>11</td>\n</tr>\n<tr>\n<td>1.6.1 Fetch</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.6.2 Store</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.6.3 Add</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.6.4 Subtract</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.6.5 Logical</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.6.6 Shifts</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.6.7 Jumps</td>\n<td>13</td>\n</tr>\n<tr>\n<td>1.6.8 Conditional Jump</td>\n<td>13</td>\n</tr>\n<tr>\n<td>1.6.9 Subroutine Call and Return</td>\n<td>13</td>\n</tr>\n<tr>\n<td>1.6.10 Input/Output Instructions</td>\n<td>13</td>\n</tr>\n<tr>\n<td>1.6.11 Control Instructions</td>\n<td>14</td>\n</tr>\n<tr>\n<td>1.7 Why Machine Code?</td>\n<td>15</td>\n</tr>\n<tr>\n<td>1.8 Machine Code and Assemblers</td>\n<td>15</td>\n</tr>\n<tr>\n<td>1.9 Further Reading</td>\n<td>16</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Chapter Two: Z-80 ARCHITECTURE</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2.1 Introduction</td>\n<td>17</td>\n</tr>\n<tr>\n<td>2.2 General Architecture</td>\n<td>17</td>\n</tr>\n<tr>\n<td>2.2.1 The Z-80 Registers</td>\n<td>17</td>\n</tr>\n<tr>\n<td>2.2.2 Flag Registers (F)</td>\n<td>20</td>\n</tr>\n<tr>\n<td>2.2.3 General Purpose Registers (B, C, D, E, H, L)</td>\n<td>22</td>\n</tr>\n<tr>\n<td>2.2.4 Special Purpose Registers (I, R, PC, IX, IY, SP)</td>\n<td>23</td>\n</tr>\n<tr>\n<td>2.3 External Connections</td>\n<td>27</td>\n</tr>\n<tr>\n<td>2.3.1 Address Bus</td>\n<td>27</td>\n</tr>\n<tr>\n<td>2.3.2 Data Bus</td>\n<td>27</td>\n</tr>\n<tr>\n<td>2.3.3 Control Bus Outputs</td>\n<td>27</td>\n</tr>\n<tr>\n<td>2.3.4 Control Bus Inputs</td>\n<td>30</td>\n</tr>\n<tr>\n<td>2.3.5 Bus Control</td>\n<td>30</td>\n</tr>\n<tr>\n<td>2.3.6 Other Signals</td>\n<td>31</td>\n</tr>\n<tr>\n<td>2.4 Bus Timing</td>\n<td>31</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Chapter Three: INTRODUCTION TO Z-80 SOFTWARE</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>3.1 Introduction</td>\n<td>34</td>\n</tr>\n<tr>\n<td>3.2 Hex Representation</td>\n<td>34</td>\n</tr>\n<tr>\n<td>3.3 Address Modes</td>\n<td>36</td>\n</tr>\n</tbody>\n</table>\n1.1 INTRODUCTION\n\nA computer based on the Z-80 operates in the same manner as any other machine be it micro, mini or mainframe. Before we can discuss the Z-80 and its use in any detail, it is first necessary to describe the operation of a typical microcomputer. This will serve to define the terms used in the rest of the book, and place the Z-80 in its role as the central processor of a powerful, but conventional computer.\n\n1.2 COMPUTER ARCHITECTURE\n\nAll computers can be represented by the block diagram of Fig. 1.1, and can be considered as manipulators of data. The actual form of the data will depend on the application. In commercial computing the data will be VAT returns, sales figures, bank accounts and similar information. In industrial control, the data will be plant sensors and actuators. In a computer game the data will be the players hand controls and the video display. The data can be split into input data, which is to be processed, and the output data, which is the result of the processing. To produce the output data, the computer follows a set of procedures, called instructions, which define the operations that are to be performed on the input data.\n\nThe computer can be represented in more detail by Fig. 1.2, and can be considered to consist of three basic units; a store, an input/output unit and a central processor unit, all interconnected by a common highway. The input and output unit obviously receives and transmits data from and to the outside world. The store is used to hold instructions and data. The central processor unit controls the operation of the machine, and performs the logic and arithmetic operations required by the instructions.\n1.3 THE STORE\n\nThe store is used to hold the instructions and temporary data in the form of numbers. It can best be considered as an array of pigeon holes, each of which can hold one number called (rather confusingly) a Word. Each pigeon hole is known as a store location, and has a unique address (similar to a house address) by which it can be identified. We can thus say, for example, \"store location 3220 contains 127\". This means that the pigeon hole whose address is 3220 has the number 127 stored in it.\n\nA typical microcomputer will have over 16000 store locations (although small machines may have less than 1000). All common microprocessors deal basically with 8 bit numbers, often called Bytes. The numbers stored will therefore be in the range 0 to 255. As will be seen later, this is not the restriction that it might at first appear.\nFig. 1.2 Basic components of a computer\nThe store does not differentiate between instructions and data; both are held in exactly the same form. The central processor unit determines whether the number in a particular store location is considered to be an instruction or data.\n\nThe store connects to the rest of the computer in a manner similar to Fig. 1.3. The three groups of signals are known as the address bus, the data bus and the control bus. (The term bus is short for busbar, sometimes the term highway is used.)\n\nThe address bus is used by the central processor to identify which store address is to be accessed. Usually, up to 65,536 (called 64K) locations can be used with a microprocessor, necessitating a 16 bit address bus.\n\nThe data bus is used to transfer data and instruction between the store and the central processor unit. Movement\n\nFig. 1.3 Store connections\ncan take place from store to CPU, or CPU to store, so the data bus is bidirectional. All common microprocessors use an 8 bit data bus.\n\nThe control bus contains the timing signals to sequence the movement of data or instructions. In the majority of systems there are basically two signals. A read/write line is used to indicate if a number is to be loaded into or read from, the addressed location, and a strobe signal indicates when the number on the data bus is valid (i.e. the transients due to different propagation delays, reflections etc. have died away). Different microprocessors use slightly different signals.\n\nFig.1.4a summarises the signals used to write a store location, and Fig.1.4b the signals used to read from a store location.\n\nWhen a number is written to a store location, the previous contents are obviously overwritten. When a number is read from a store location, the store location contents are unaltered; the number put onto the data bus is merely a COPY of the store contents.\n\nThe store in Fig.1.3 is known as a RAM or Random Access Memory. This is a term that causes some confusion, but simply means that each store location can be accessed in exactly the same time. Bulk storage devices, such as tapes and discs, have a variable access time which depends on where the information is stored and where the tape or disc currently is when the information is needed.\n\nAnother form of storage commonly encountered is a ROM, for Read Only Memory. This is a conventional store whose contents are fixed and cannot be altered by the computer. Usually a ROM is used to hold a fixed program (such as the BASIC interpreter or an Assembler as described later). To the central processor, a ROM behaves in exactly the same manner as the rest of the store.\n\n1.4 THE CENTRAL PROCESSOR UNIT (or CPU)\n\nThe computer follows instructions held in the store (in the form of numbers). Normally, instructions are held in\nFig. 1.4 Address & data bus timings & signals,\n(a) Typical write signals\n(b) Typical read signals\nsequential store locations. To obey an instruction we must go through the following steps:\n\ni. Address the store to get the next instruction.\nii. Decode the instruction to decide what needs to be done\niii. Obey the instruction. This will usually involve the store again to read, or write, data and will often require simple arithmetic operations\niv. Decide where the next instruction is held in the store, and go back to step i.\n\nMost instructions therefore require two operations on the store; the first to read the instruction, the second to read the data to be used or write a result back to the store. Sometimes the operations above are referred to as three steps:\n\nFetch cycle (instruction is fetched, steps i and ii)\nExecute cycle (instruction is obeyed, step iii)\nReset cycle (the internal logic is reset for the next instruction, step iv)\n\nThe FER sequence has been called the heartbeat of a computer.\n\nThe component parts of a central processor unit are shown on Fig.1.5. For simplification, internal connections are omitted.\n\nThe program counter (PC, also known as an instruction counter, IC) holds the address of the current instruction. Because most microcomputers can address up to 64K, the PC will usually be a 16 bit register. With the exception of JUMP instructions (the machine code equivalent of a BASIC GOTO instruction), the program will be held in sequential store locations. This means that the PC can literally be a counter which is pulsed by the control logic at step iv above.\n\nIn addition to the storage provided by the RAM, fast storage (for temporary scribbling pad purposes) is provided by registers in the CPU. These can hold one number to the same word length as the store (8 bits for all common micros). Some microprocessors (such as the 6502) have only one register, whereas some (such as the Z-80) have as many as sixteen. Fig.1.5 shows four registers for illustrative purposes.\nFig. 1.5 Components of a CPU\nThe use of registers will be described later.\n\nAssociated with the registers is the Arithmetic and Logic Unit (or ALU). There are actually very few machine code instructions; as we shall see later, most are variations on:\n\n- Fetch a number from a store location (or input port) to a register\n- Write a number to a store location (or output port) from a register\n- Add (or subtract) a number from a store location to a register, result to a register.\n\nThe ALU performs the arithmetical operations (and some logical operations such as AND, OR) required by the instructions.\n\nFinally, we have the block labelled control/timing logic. This contains the logic to decode the instructions and sequence the steps i to iv above. This involves selecting routes between the store, the ALU, the registers and the highways. The control/timing logic is usually the most complex part of a computer.\n\nAssociated with the control logic is a simple clock oscillator which provides the basic timing pulses. Usually this is a crystal oscillator in the range 1 to 4MHz.\n\nA microprocessor is often thought of as a computer, but is, in fact, simply the CPU of a computer. A microprocessor contains the elements of Fig.1.5, but needs external RAM/ROM and Input/Output equipment to be useful.\n\n1.5 INPUT AND OUTPUT\n\nA computer connects to a variety of I/O equipment, printers, keyboards, VDUs, cassette recorders etc. These connect to the computer highway as shown on Fig.1.6. Each I/O device is identified by an address. I/O addresses are commonly known as 'Ports', so we could have, say, a printer connected to Port 3 and a keyboard to Port 5.\n\nData is transferred to and from an I/O port via the highway. The port address is placed on the address highway, the read/\nFig. 1.6 Input/output connections\nwrite control line used to identify the direction of the transfer, and the I/O control line used to signify that the address is a port address, not a store address. Data transfer then takes place via the data highway. Some microprocessors (such as the 6800) do not have an I/O control line and literally deal with I/O addresses in the same ways and with the same instructions, as store addresses. With these microprocessors a store and a port cannot have the same address.\n\nMost microprocessors allow data to be transferred between I/O ports and registers or between I/O ports and store locations. We shall discuss later the techniques used to resolve the vast difference in speed between slow speed devices (such as printers) and the computer itself.\n\n1.6 INSTRUCTIONS AND PROGRAMS\n\nAs anyone who has written a program in BASIC will know, a computer simply obeys a sequence of instructions called a program. In a high level language such as BASIC or PASCAL, these instructions are written in 'English'. A computer actually obeys instructions represented by numbers called a machine code program. When a high level program is obeyed, a special program built into the computer (called a compiler or an interpreter) converts the high level language program to an equivalent machine code program. This action is invisible to the high level language user.\n\nA machine code instruction must specify:\n\ni. What is to be done (e.g. Add, fetch data, store data, etc.)\nii. Where the data is to be found, and where the result is to be placed (e.g. \"Fetch the data from store location 2000 to Register B\", or \"Add the data in store location 1575 to the data in Register A putting the result in Register A\").\n\nIn following chapters we will see how these ideas are actually specified given the limitations of an 8 bit word.\n\nThere are actually a very limited set of instructions in a computer, and most are variations on:\n1.6.1 Fetch\n\n\"Fetch data from a specified store location (or register) to a specified register\".\n\n1.6.2 Store\n\n\"Store data from a specified register to a specified store location\". Sometimes Fetch and Store are collectively called \"Moves\" or \"Loads\".\n\n1.6.3 Add\n\n\"Add data from a specified store location (or register) to the data in another specified store location (or register) the result to go to a specified store location (or register)\".\n\nUsually Adds take the simpler form, \"Add data from a specified store location to the data in register A, the result to go to Register A\".\n\n1.6.4 Subtract\n\nAs 1.6.3 but subtraction is performed. Note that multiplication and division are not available on any common microprocessor.\n\n1.6.5 Logical\n\nAs 1.6.3, but logical operations such as AND, OR, NEV are performed between the data.\n\n1.6.6 Shifts\n\nData in a microprocessor is held as 8 bit binary numbers. A shift instruction moves the data in a register up, or down by one place. If we have the bit pattern 10110101, a simple shift up would produce 01101010, and simple shift down would produce 01011010. A shift up multiplies a number by two, a shift down divides by two. As will be seen later, there are\nmany variations on the shift instruction.\n\n1.6.7 Jumps\n\nNormally, instructions are held in sequential store locations. A Jump instruction is the machine code equivalent of the BASIC GOTO, and specifies where the next instruction is to be found (e.g. Jump to location 3220).\n\n1.6.8 Conditional Jump\n\nA conditional jump tests the condition of a register, the results of which determine if a jump instruction is to be obeyed (e.g. Jump to 4057 if register A is zero). This is the machine code equivalent to the BASIC IF condition THEN GOTO (line number).\n\n1.6.9 Subroutine Call and Return\n\nProgrammers in BASIC will be familiar with the concept of a subroutine with the GOSUB and RETURN instructions. A subroutine allows a piece of program that is used frequently to be written once and called when needed by the rest of the program. This is best shown by Fig.1.7. Machine code subroutine calls work in exactly the same way. A subroutine call acts like a jump to the start of the subroutine (e.g. Call 7087 would take us to the subroutine starting at location 7087). A Return instruction is placed at the end of the subroutine, to take us back to the location in the main program immediately after the subroutine call. Subroutines can call subroutines (called Nesting). A Binary to BCD subroutine, for example, would need to use multiplication and division subroutines. In most microprocessors, conditional subroutine calls, and conditional returns are provided as well as the simple call and return described above.\n\n1.6.10 Input/Output Instructions\n\nInput/output instructions must specify the I/O port address,\nthe direction (in or out) and the source (or destination) of the data (i.e. which register or which store location).\n\n1.6.11 Control Instructions\nMost microprocessors have a small number of control instruc-\ntions such as STOP, Disable Interrupts and similar operations. These do not involve data.\n\nAt first sight, the vast array of instructions available on a microprocessor can be rather awe inspiring (the Z-80 has 158 different instruction types). Much of the inevitable feeling of confusion can be assuaged by remembering that most instructions are simple variations of the ten types outlined above.\n\n1.7 WHY MACHINE CODE?\n\nProgramming in BASIC is simple and straightforward, so it is not unreasonable to ask why one should bother with the trials, tribulations and complexity of machine code programming. There are really three reasons.\n\nThe first is that it is possible to perform operations in machine code that are impossible (or difficult) to achieve in BASIC. Control of external items like a model railway would be difficult in simple BASIC for example.\n\nThe second reason concerns speed. BASIC is notoriously slow, and is quite unsuited to, say dynamic video games. Machine code programs operate many times faster than BASIC programs.\n\nThe final and most compelling, reason is that machine code programming is an intellectual challenge akin to chess or bridge. The mental exercise of programming (in any form) is very addictive and this is particularly true of machine code programs.\n\n1.8 MACHINE CODE AND ASSEMBLERS\n\nThe instructions a computer actually obeys are held in the form of binary numbers. To assist human beings to read these numbers, it is usual to express them in Hex, so 1010 0111 becomes A7 (see Appendix A).\n\nA machine code program therefore looks something like:\nwhich is still fairly incomprehensible.\n\nIt is easier to follow a machine code program if simple mnemonics are used to represent the instructions. The actual mnemonics used on the Z-80 will be described later, but in general they are simple to understand. A program written in mnemonics is said to be written in Assembler Language, and looks more understandable.\n\nLD A, 33\nINC HL\nJP NZ, LOOP\n\nEach of these corresponds directly to a single machine code instruction, LD A, 33 for example, means put the number 33 into register A.\n\nThe program written in Assembler Mnemonics is converted to machine code by a program called (surprise, surprise) an Assembler. The Assembler has editing facilities similar to those found in BASIC and makes machine code programming much less infuriating. In later chapters, examples of Assembler programs will be given. Assemblers are not usually provided with computers, and have to be purchased separately.\n\n1.9 FURTHER READING\n\nThe description of computer architecture in this chapter has, of necessity, been rather brief. More detailed discussions can be found in the following books also published by Bernard Babani (publishing) Ltd:\n\nBook No. BP72 – A Microprocessor Primer\nBook No. BP78 – Practical Computer Experiments\nBook No. BP66 – Beginners Guide to Microprocessors\nBook No. BP77 – Elements of Electronics - Book 4, Microprocessing Systems and Circuits\nChapter Two\n\nZ-80 ARCHITECTURE\n\n2.1 INTRODUCTION\n\nThis chapter introduces the Z-80 microprocessor, describing its architecture and role in the construction of a microcomputer. The Z-80, like all microprocessors, is the CPU of a perfectly conventional computer, and needs store and I/O before it can be useful. The connection of these items is discussed. This chapter is therefore concerned with equipment. Chapter 3 will describe the Z-80 instruction set and will be concerned with software.\n\n2.2 GENERAL ARCHITECTURE\n\n2.2.1 The Z-80 registers\n\nThe Z-80 can be represented by the block diagram of Fig.2.1 which is very similar to the generalised CPU diagram of Fig.1.5 in Chapter 1. The Z-80 is an 8 bit microprocessor, and can address 64K of store. It therefore utilises an 8 bit data bus and a 16 bit address bus. There are also 13 control signals in the control bus.\n\nThe registers, PC, instruction decode, ALU and control fulfill the same functions as described for Fig.1.5. The instruction register simply holds the instruction currently being obeyed.\n\nThe user of the Z-80 is interested in the block labelled “registers”. This is shown expanded on Fig.2.2. The Z-80 has an impressive array of registers, 17 8 bit registers, one 7 bit register and 4 16 bit registers. The first point of note is that these registers are in three groups, main register set, alternate register set, and special purpose.\n\nThe main register set and alternate register set are identical. The programmer chooses which set he wishes to work with at\nFig. 2.1 The Z-80 microprocessor\nFig. 2.2 The Z-80 registers\nany time by the use of \"Exchange\" instructions which switch sets. This is, admittedly, a bit of a nuisance but it is necessary to allow access to the 16 registers whilst minimising the number of instructions in the Z-80. Full access would have nearly doubled the size of the Z-80 instruction set.\n\nEach register set has an 8 bit accumulator (A), an 8 bit flag register (F) and six 8 bit general purpose registers (B,C,D,E,H,L). The accumulators are used for arithmetic and logic purposes; the other 6 G.P. registers cannot (with a few exceptions) be used with the ALU and simply provide fast temporary storage. The results of almost all arithmetic operations go to the accumulators.\n\n2.2.2 Flag Registers (F)\n\nThe flag registers are 8 bit registers used to indicate certain conditions that arise in arithmetic and logical operations. These are used as tests for conditional jumps. Each condition is represented by a bit, as shown on Fig.2.3. The flags operate as below.\n\nThe carry flag (C) is simply the carry from the highest bit of the accumulator, and is set if a \"carry\" is generated during an add, or a \"borrow\" during a subtraction. The carry bit is also altered by some shift operations. If twos complement\n\n\narithmetic (see Appendix A) is being used, the carry does not necessarily indicate if an overflow has occurred. The P/V flag should be used for this purpose.\n\nThe zero flag (Z) is set when the last instruction affecting the flags resulted in zero contents of the accumulator. Any non zero contents resets the flag.\n\nThe sign flag (S) is used with twos complement arithmetic, and simply indicates if the accumulator is positive (S=0) or negative (S=1), because bit 7 of an 8 bit twos complement number indicates the sign. The S flag is simply a copy of bit 7. Note that zero is a positive number.\n\nThe parity/overflow flag (P/V) serves two purposes. After a logical operation (AND, OR, Exclusive OR) the flag indicates the parity of the result, being set for an even parity and reset for an odd parity. The second use requires a little more explanation. If twos complement arithmetic is being used, an 8 bit word represents a \\textit{Signed} number in the range $-128$ to $+127$. Bit 7 indicates the sign, being 0 for positive numbers and 1 for negative numbers. With twos complement arithmetic, the carry bit does not reliably indicate if an overflow has occurred. Consider the two examples below:\n\n\\[\n\\begin{array}{c}\n123 = 01111011 \\\\\n+ 106 = 01101010 \\\\\nC=0 \\quad 11100101 = -91\n\\end{array}\n\\]\n\nThe result is an incorrect negative number, but the carry bit has not been set.\n\n\\[\n\\begin{array}{c}\n-5 \\quad 11111011 \\\\\n-16 \\quad 11110000 \\\\\nC=1 \\quad 11101011 = -21\n\\end{array}\n\\]\n\nIn this case, the result is correct, but the carry bit has been set.\n\nThe P/V flag indicates correctly if an overflow has occurred during a twos complement arithmetical operation. In the two above examples, the P/V flag would be set for the first (overflow has occurred) and reset for the second (overflow has not occurred). It follows that the carry flag is used for unsigned 8\nbit arithmetic, and the P/V flag for signed two's complement arithmetic.\n\nThe C, Z, S, P/V flags are used with conditional jumps and conditional subroutine calls. The Z-80 uses the following conditions.\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>Carry</td>\n<td>$C = 1$</td>\n</tr>\n<tr>\n<td>Non Carry</td>\n<td>$C = 0$</td>\n</tr>\n<tr>\n<td>Zero</td>\n<td>$Z = 1$</td>\n</tr>\n<tr>\n<td>Non Zero</td>\n<td>$Z = 0$</td>\n</tr>\n<tr>\n<td>Parity Even</td>\n<td>$P/V = 1$</td>\n</tr>\n<tr>\n<td>Parity Odd</td>\n<td>$P/V = 0$</td>\n</tr>\n<tr>\n<td>Sign Negative</td>\n<td>$S = 1$</td>\n</tr>\n<tr>\n<td>Sign Positive</td>\n<td>$S = 0$</td>\n</tr>\n</tbody>\n</table>\n\nThe four flags above can be used directly for conditional jumps. There are also two flags which are used by the internal logic of the Z-80 when BCD operations are being performed. These cannot be used directly in conditional jumps, but can be accessed as any other bit in any other register.\n\nThe first of these flags is the half carry (H) used to indicate the BCD carry or borrow result from the least significant four bits of the accumulator. This flag is used by the Decimal Adjust instruction, described later.\n\nThe Add/Subtract flag (N) indicates if the last instruction was an addition or subtraction. The algorithm used by the Decimal Adjust instruction is different for addition or subtraction, the correct algorithm being selected by the N flag.\n\nThe flags are not altered by all instructions. In general, the flags are altered by all arithmetical and logical operations. Load instructions (store reads and writes and inter register transfers) leave the flags unaffected.\n\n2.2.3 General Purpose Registers (B, C, D, E, H, L)\n\nEach register set has six general purpose registers (B, C, D, E, H, L). These provide fast temporary storage. They can also be grouped as 16 bit register pairs (BC, DE, HL) providing 16 bit arithmetic facilities and a powerful method of addressing\nknown as register indirect (to be described later in section 3.3.6).\n\n2.2.4 Special Purpose Registers (I, R, PC, IX, IY, SP)\n\nThere are six special purpose registers, denoted I, R, PC, IX, IY, SP. Although these are usually dedicated to one task they can, in general, be accessed like any other register.\n\nPC is the 16 bit program counter, operating exactly as described in Chapter 1. A 16 bit program counter is necessary to address 64K of store.\n\nIX and IY are two 16 bit registers used in a useful method of addressing the store known as Indexed Addressing. This is described further in section 3.3.7.\n\nSP stands for Stack Pointer, and is another 16 bit register. To understand the use of the stack pointer we must first describe the concept of the “stack”. We described the idea of subroutines in the previous chapter. When a subroutine is called, we must somehow save the contents of the PC, and substitute the address of the subroutine. At the end of the subroutine we must reinstate the PC to its original value.\n\nTo achieve this, an area of store is designated to hold PC addresses during subroutine calls. Normally the stack starts at the top of the store and comes down. The SP holds the current position of the end of the stack. Because addresses are 16 bits, each address takes two store locations on the stack.\n\nThe operation of the stack is best demonstrated by an example. Let us assume we are obeying the instruction at location 0C50, and it is a call to a subroutine at 1D00. The stack pointer is currently at 2F05, indicating that the stack ends at 2F05. The sequence below is then followed:\n\ni. PC contents are put into 2F05 and 2F04. (i.e. the address of the subroutine call is put onto the stack)\nii. PC contents are replaced by 1D00 (the address of the subroutine)\niii. The SP is decremented to 2F03 (to allow for nesting of subroutines. The stack can be of any length)\niv. The subroutine is obeyed.\nAt the end of the subroutine, a return instruction initiates the following sequence:\n\ni. The SP is incremented and used to bring a 16 bit number back from the stack to the PC. If addresses have been placed and read from the stack in sequence, this will bring 0C50 back to the PC.\n\nii. The PC is incremented to step onto the instruction following the subroutine call.\n\niii. The main program continues.\n\nPutting an address onto the stack is known as a PUSH. Getting an address from the stack is known as a PULL. The important point to remember about a stack is Last In, First Out.\n\nThe stack can also be used to store data from register pairs. This must be done with care, as the programmer must ensure that the data comes off the stack in the expected order. The sequence in Fig.2.4 will NOT work as expected because the data brought to BC will be the last data pushed onto the stack; the address of the instruction calling the subroutine call. The address replaced in the PC by the return instruction will be the contents of BC pushed onto the stack earlier. Remember, Last In, First Out.\n\nThe two final registers are denoted I (for interrupt) and R (for refresh). The I register is known as the Interrupt Page Address Register, and is used when the Z-80 is controlling external devices. There is a vast difference in speed between computers and peripheral devices, which is reconciled by a technique known as Interrupts. This will be described in detail in Chapter 6, but for the present an interrupt can best be considered as a subroutine call initiated by an external device. The device supplies the low byte of the subroutine address, the I register supplies the high byte.\n\nThe 7 bit R register is used when the store is constructed with dynamic memory ICs. (Such as the popular 4116). These store the data as charges on capacitors (see Fig.2.5) which have to be refreshed every few milliseconds. Normally this refreshing is performed by external logic which grabs control of the highway at regular intervals to perform the refresh operation. The\nZ-80 is unique amongst micros in containing its own refresh logic. The R register contains the current refresh address. The contents of the R register are placed on the lower 7 bits of the address bus along with a refresh signal on the control bus when the bus is free. After each refresh the R register is automatically incremented. The whole refresh operation is totally invisible to the user.\n\nChapter 3 will describe how data is moved and manipulated in the registers and store.\n\nFig. 2.4 Incorrect use of stack\nFig. 2.5 Static & dynamic memories (a) Static storage cell, (b) Dynamic storage cell\n2.3 EXTERNAL CONNECTIONS\n\nA typical small Z-80 system is shown on Fig. 2.6. This should be compared with Fig. 1.2. The Z-80 itself is a standard 40 pin dual in line IC with connections shown on Fig. 2.7. It will be seen that the connections form the address bus, data bus and control bus described earlier.\n\n2.3.1 Address Bus\n\nThe address bus is A0–A15, A0 being the least significant bit and A15 the most significant bit. The address bus can address up to 64K of store. The least significant 8 bits (A0 – A7) are also used to address I/O ports, allowing up to 256 I/O addresses. The address highway conveys the address in “true” form.\n\n2.3.2 Data Bus\n\nThe data bus is D0 – D7, D0 being the least significant bit. This is a bidirectional highway, conveying data between store, I/O ports and the Z-80.\n\n2.3.3 Control Bus Outputs\n\nThe control bus contains 13 signals; 8 outputs and 5 inputs. The first of these is RD, memory read. This indicates that the CPU wants to read data from a memory location or I/O port. The signal is active low, and is present whilst the address bus holds a valid address. RD is used by the addressed location or port to gate data onto the data bus.\n\nWR, write, indicates that the CPU requires to send data to a store location or I/O port. The signal is active low, and is present whilst the address bus holds a valid address and the data bus valid data. WR and RD are effectively strobe signals similar to those on Fig. 1.3.\n\nMREQ, memory request, is an active low signal indicating that the address bus holds a valid address. MREQ appears in conjunction with RD or WR.\nFig. 2.6 Z-80 based microcomputer\nIORQ denotes input/output. This active low signal indicates that the address on A0 – A7 is the address of an I/O port, and an input/output transfer is to be performed. IORQ allows memory locations and I/O ports to share the same address. IORQ appears with RD or WR to indicate if data is to be input or output. IORQ is also used in the timing of interrupts, to be described later in section 6.4.\n\nRFSH stands for refresh and is an active low signal indicating that A0 – A6 contain an address that can be used to refresh dynamic memories. MREQ appears with RFSH.\n\nHALT indicates simply that the CPU has halted following a HALT instruction. The signal is active low. The memory refresh for dynamic memories continues even though the processor is halted.\nstands for machine cycle one. It was explained in Chapter 1 that obeying an instruction consists of a fetch of the instruction from the store followed by a data read and/or a data write. In the Z-80 the instruction fetch is known as M1, the memory read as M2 and the memory write as M3. M1 is an active low signal indicating that the CPU is in the M1 state. The signal is used in timing some I/O operations.\n\n2.3.4 Control Bus Inputs\n\nThe first control input is the WAIT signal. The Z-80 is faster than some memory and I/O control devices, particularly when a 4MHz clock is used. The WAIT signal is used by an addressed memory or I/O port to indicate that the required data transfer can not yet take place. On receipt of a WAIT signal the CPU simply pauses. The WAIT signal is active low. During the WAIT state the memory refresh is not maintained.\n\nRESET is used to force the CPU to a known state, and is normally used at power up or to regain control if a program has gone off the rails. The RESET input is active low and has the following effects.\n\ni. PC, I and R are reset to zero\n\nii. Interrupts are disabled and interrupt Mode 0 is set.\n\nInterrupts are described later in section 6.4. Resetting the PC has the effect of an unconditional jump to location zero.\n\nINT is also an interrupt request from an external device. A “low” on this line initiates the interrupt sequence.\n\nNMI is also an interrupt request, but is a higher priority than INT. The CPU can ignore the INT signal, but NMI, standing for Non Maskable Interrupt, is always recognised. NMI effects a subroutine call to location Hex 66. The NMI is negative edge triggered.\n\n2.3.5 Bus Control\n\nIn large systems, the address data and control buses can be shared with another CPU or devices such as disc controllers which require access to the memory without the CPU. Under\nthese circumstances, the CPU is occasionally required to release the buses for use by the other devices requesting access. This is achieved by two signals on the control bus.\n\nBUSRQ (Bus request) is an input from an external device requesting control of the buses. The signal is active low. On receipt of BUSRQ the Z-80 sets all its bus signals to a high impedance state, allowing the requesting device to use the buses. The Z-80 then takes BUSAK to a 'low' to indicate that the requesting device can use the buses. Whilst the Z-80 has released the buses, memory refreshing obviously ceases.\n\n2.3.6 Other Signals\n\nThe Z-80 needs a 5 volt supply (Vcc and 0V) and a clock (ϕ). The clock is usually provided by a simple crystal oscillator and can be 1, 2, or 4MHz dependent on the version of Z-80 and the application.\n\n2.4 BUS TIMING\n\nThe actual timing of the bus signals is usually of little concern to the amateur. Fig. 2.8 and 2.9 show, somewhat simplified, the timing of a memory read and a memory write operation.\nFig. 2.8 Read timing\nFig. 2.9 Write timing\n3.1 INTRODUCTION\n\nThe previous chapters have been largely concerned with the mechanics of a Z-80 based microcomputer. We can now start to discuss how programs are written for the Z-80. This chapter will describe the Z-80 instruction set in general terms and explain the various terms used in later sections. Chapter 4 will describe the Z-80 instruction set in detail.\n\n3.2 HEX REPRESENTATION\n\nThe Z-80 deals with 8 bit numbers; each store location and GP register can hold a number in the range 0 to 255. The numbers are in binary, so a typical register could hold the number\n\n1010 0111\n\nwhich at first sight, means little to anyone. We could, with a little trouble, convert it to decimal (167 actually) but it is usually preferable to represent a store location and register contents in a form that can easily be converted back to binary. Most microprocessors, including the Z-80, use a system called Hex (for hexadecimal).\n\nHex is based on four bits, which can represent a number in the range 0 to 15. These are represented by the symbols 0 to 9 followed by A to F\n\n<table>\n<thead>\n<tr>\n<th>Binary</th>\n<th>Hex</th>\n<th>Decimal</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0000</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0001</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>0010</td>\n<td>2</td>\n<td>2</td>\n</tr>\n<tr>\n<td>0011</td>\n<td>3</td>\n<td>3</td>\n</tr>\n<tr>\n<td>0100</td>\n<td>4</td>\n<td>4</td>\n</tr>\n<tr>\n<td>0101</td>\n<td>5</td>\n<td>5</td>\n</tr>\n<tr>\n<td>Binary</td>\n<td>Hex</td>\n<td>Decimal</td>\n</tr>\n<tr>\n<td>-------</td>\n<td>-----</td>\n<td>--------</td>\n</tr>\n<tr>\n<td>0110</td>\n<td>6</td>\n<td>6</td>\n</tr>\n<tr>\n<td>0111</td>\n<td>7</td>\n<td>7</td>\n</tr>\n<tr>\n<td>1000</td>\n<td>8</td>\n<td>8</td>\n</tr>\n<tr>\n<td>1001</td>\n<td>9</td>\n<td>9</td>\n</tr>\n<tr>\n<td>1010</td>\n<td>A</td>\n<td>10</td>\n</tr>\n<tr>\n<td>1011</td>\n<td>B</td>\n<td>11</td>\n</tr>\n<tr>\n<td>1100</td>\n<td>C</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1101</td>\n<td>D</td>\n<td>13</td>\n</tr>\n<tr>\n<td>1110</td>\n<td>E</td>\n<td>14</td>\n</tr>\n<tr>\n<td>1111</td>\n<td>F</td>\n<td>15</td>\n</tr>\n</tbody>\n</table>\n\nTo represent a binary number in Hex, you simply split it into 4 bit chunks, and put the Hex equivalent underneath. For example:\n\n\\[10100111\\]\n\nbecomes \\[1010\\] \\[0111\\]\ngiving \\[A\\] \\[7\\]\n\nSo the binary word \\(10100111\\) is A7 in Hex.\n\nAnother example \\(01001100\\) becomes \\(0100\\) \\(1100\\) giving \\(4\\) \\(C\\).\n\nIt is equally easy to go from Hex to binary. The four bit pattern for the Hex number is simply written underneath. For example D2 becomes\n\n\\[D\\] \\[2\\]\n\\[1101\\] \\[0010\\]\ngiving \\(11010010\\) as the binary equivalent of Hex D2.\n\nAnother example \\(FA\\) gives \\(1111\\) \\(1010\\)\n\nThe Z-80 instruction set is given in Chapter 4 in Hex form. 8A, for example, is the instruction that will make the Z-80 add the contents of register D to the Accumulator.\n\nHex representation can also be used on 16 bit numbers such as store addresses), for example:\n1110 0101 1010 1001\nbecomes E 5 A 9\nand in reverse\n\n0 C 5 7\nbecomes 0000 1100 0101 0111\n\nStore addresses in Z-80 microcomputers are usually given in Hex.\nHex can be a bit daunting at first, but it should be remembered that it is just a convenient shorthand method of representing binary numbers. With a little practice, binary to Hex and Hex to binary becomes second nature.\n\n3.3 ADDRESS MODES\n\n3.3.1 Introduction\nAn instruction will normally involve data in one or two locations or registers. This data will be moved or manipulated in some form (e.g. Add Subtract, etc.). An instruction therefore must usually specify two things:\n\ni. What is to be done (e.g. move, add, subtract)\n\nii. Where the data is to be found (e.g. Register A, location 3220)\n\nIn older computers, which used a 16 bit word length, it was common to allocate the op code (specifying what is to be done) to the top few bits, and the address of the data to the remainder of the word as shown on Fig.3.1. This is known as direct addressing, because the number representing the instruction directly indicates the store location where the data is to be found or stored.\n\nThere is a problem, however, with all 8 bit microprocessors. An 8 bit word can represent a number in the range of 0 – 255. The Z-80 has 158 different instructions, so it will take all 8 bits of a microprocessor word simply to specify the Op Code. To specify a 64K address requires an additional 16 bits.\nObviously direct addressing cannot be used, at least not in the simple form of Fig. 3.1. All 8 bit microprocessors use a collection of ingenious methods called address modes to address the store.\n\n![Diagram of Instruction on a Minicomputer]\n\n**Fig. 3.1 Instruction on a minicomputer**\n\nThe first, slightly confusing, idea is the use of different lengths of instruction. A Z-80 instruction can be 8, 16, 24 or 32 bits in length (occupying respectively 1, 2, 3 and 4 store locations). The first location will always be an Op Code. Subsequent locations define where the data is to be found. The following are typical Hex coded Z-80 instructions:\n\n- **7A** Move the contents of register D to the accumulator\n- **06 FF** Put the Hex value FF into Register B\n- **C3 50 0C** Jump to location 0C50\n- **ED 43 FE IF** Store the 16 bit number in Register Pair BC to store locations IF FE and IF FF\n\nIn each case the first 8 bits define the Op Code (7A, 06, C3, ED). In the latter case the full Op Code actually occupies two locations (ED 43) but the ED portion specifies the form of the instruction, and 43 the register pair.\n\nIf the 4 instructions above were stored from location Hex 1000 we would have:\n\n37\nThere are many different address modes used in computers in general, and microprocessors in particular. The Z-80 uses ten different address modes.\n\n### 3.3.2 Register Addressing\n\nMany instructions in the Z-80 set only involve data held in the registers. Examples are “move the contents of Register B to Register A” or “Move the contents of Register D to Register C”. These, and similar instructions are said to use Register Addressing. Most of these instructions are a single byte (8 bits) in length and occupy one location. The Op Code for “Move the contents of Register B to Register A” is the single byte instruction 78.\n\n### 3.3.3 Immediate Addressing\n\nImmediate addressing is used where the data to be manipulated is fixed. For example “Load Register B with 42” or “Add 7 to Register A”. These instructions take the form:\n\n\\[\n\\begin{align*}\n\\text{Op Code} & \\quad \\text{One or two bytes} \\\\\n\\text{Data} & \\quad \\text{Data}\n\\end{align*}\n\\]\n\n“Add 7 to Register A” is actually C6 07, C6 being the Op Code and 07 the data.\n3.3.4 Extended Addressing\n\nExtended addressing is almost identical to direct addressing described earlier. The store address for the data is given in full 16 bits in the instruction. Examples are “Move the contents of store location 0C50 to Register A” or “Call the subroutine at location 1DF5”. The address occupies two locations in the instruction, and the Op Code one or two locations. Extended Address instructions therefore occupy three or four locations:\n\n<table>\n<thead>\n<tr>\n<th>Location</th>\n<th>Contents</th>\n<th>One or two bytes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>N</td>\n<td>CD</td>\n<td></td>\n</tr>\n<tr>\n<td>N + 1</td>\n<td>F5</td>\n<td>address low byte</td>\n</tr>\n<tr>\n<td>N + 2</td>\n<td>1D</td>\n<td>address high byte</td>\n</tr>\n</tbody>\n</table>\n\nThe Z-80 code for “Call the subroutine at location 1DF5” is CD F5 1D. CD is the Op Code and F5 1D indicates the address 1DF5. It might seem more logical to have the instruction written CD 1D F5, but consider how the instruction is stored:\n\n<table>\n<thead>\n<tr>\n<th>Location</th>\n<th>Contents</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>N</td>\n<td>CD</td>\n</tr>\n<tr>\n<td>N + 1</td>\n<td>F5 address low byte</td>\n</tr>\n<tr>\n<td>N + 2</td>\n<td>1D address high byte</td>\n</tr>\n</tbody>\n</table>\n\nThe address is stored in two locations, N + 1, N + 2. The low byte of the address is simply stored in the low byte of the instruction (N + 1) and the high byte of the address in the high byte of the instruction (N + 2).\n\n3.3.5 Immediate Extended Addressing\n\nThis addressing mode is used with 16 bit data in two successive store locations, register pairs (BC, DE, HL) and the index registers. For example, we could have “Load register pair BC with 0C50”. An immediate extended instruction takes the form of a three of four location instructions:\n\n- Op Code (one or two bytes)\n- Data Low Byte\n- Data High Byte\n“Load register BC with 0C50” is actually 01 50 0C with 01 the Op Code and 0C50 the data. As with extended Addressing, it might be thought more logical to have coded this 01 0C 50, but in fact the low byte of the data goes to the low byte of the instruction.\n\nWhen register pairs are used, high and low bytes are allocated\n\n<table>\n<thead>\n<tr>\n<th>High</th>\n<th>Low</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>B</td>\n<td>C</td>\n</tr>\n<tr>\n<td>D</td>\n<td>E</td>\n</tr>\n<tr>\n<td>H</td>\n<td>L</td>\n</tr>\n</tbody>\n</table>\n\n### 3.3.6 Register Indirect Addressing\n\nA register pair, being 16 bits in length, can hold a 16 bit address and therefore can be used to indicate a store location. In register indirect addressing a register pair is used to indicate the store location for the data. An example would be “Store the contents of register A in store location whose address is to be found in register pair BC”. Suppose A contains 2D (in Hex) and BC contains 1C72 (B is high byte, C is low byte). The number 2D would be stored in location 1C72. This is summarised by Fig.3.2.\n\nBecause the address is provided by a register pair, a register direct instruction consists only of an Op Code one or two bytes in length. The code for “Store the contents of A in the store location whose address is to be found in register pair BC” is actually 02.\n\n### 3.3.7 Indexed Addressing\n\nIndexed addressing is a special form of register indirect addressing that is particularly useful where tables of data held in successive store locations have to be processed. The Z-80 has two index registers, each 16 bits in length, which provide a base 16 bit address. The instruction contains a twos complement offset known as the displacement (in the range $-127$ to $+128$) which is added to the base address in an index register.\nto give the address to be used for the data. For example, we could have “Store register B, index addressed with IX, displacement 05”. Let us assume register B contains FE, index register X contains 2D10. The instruction would store FE in location 2D15.\n\nAn index address instruction always occupies three locations and consists of a 2 byte Op Code and a 1 Byte displacement:\n\nOp Code (two bytes) \nDisplacement (one byte)\n\nThe coding for “Store register B, index addresses with IX, displace 05” is actually DD 70 05. DD 70 is the Op code, 05 the displacement. (See Fig. 3.3)\n3.3.8 Relative Addressing\n\nRelative addressing is used only for jumps in the Z-80. The current instruction address is used as a base address, and the instruction contains a twos complement displacement (in the range $-128$ to $+127$) to give the jump destination. In the Z-80, slightly confusingly the base address is actually the current location +2. A typical relative addressed instruction is “Jump relative +16” (remember, the displacement 16 is Hex). If we were at location OC50, the base address is OC52 and we would jump to the instruction at OC68. Note that because a twos complement displacement is used we can jump both forward and backward from the current location. All relative addressed instructions use two locations, one for the Op Code and one for the displacement:\n\n<table>\n<thead>\n<tr>\n<th>Op Code</th>\n<th>One byte</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Displacement</td>\n<td>One byte</td>\n</tr>\n</tbody>\n</table>\n\nFig. 3.3 Indexed addressing\nThe code for “Jump Relative +16” is 18 16, with 18 the Op Code and 16 the displacement.\n\nRelative addressing is very useful. Apart from being a neat and compact way of writing jumps, it allows programs to be written that can be placed anywhere in the store. These are known as relocatable programs. Usually a programmer builds up a library of relocatable subroutines for common items such as multiplication, division, outputs to printers etc. which can be plugged into each new program as needed. The disadvantage of relative addressing is the tedious recalculation of the displacements if debugging requires the insertion or removal of instructions.\n\n3.3.9 Modified Page Zero Addressing\n\nThere are 8 page zero addressed instructions. All are subroutine calls known as restarts to addresses below Hex 100. All consist of a single byte Op Code. DF, for example, is “Call subroutine at location Hex 18”. The 8 Restart subroutine calls are a very compact way of calling frequently used subroutines.\n\n3.3.10 Implied Addressing\n\nSome instructions inherently imply where the data is to be found. Exchange instructions (which switch register sets) are typical implied instructions.\n\n3.3.11 Bit Addressing\n\nIn data processing and control engineering, single bits in an 8 bit word are used to indicate an event being present or not. A bit could be used, for example, to represent a limit switch being open or closed. In file applications a bit could represent the sex of a person; ‘1’ for male, ‘0’ for female.\n\nThe Z-80 has a comprehensive range of bit addressed instructions that allow a single bit in a register or store location to be set, reset or tested (via the flag register, F).\n3.3.12 General Observations\n\nWe have described ten different address modes, and it is quite possible that the reader is feeling a bit punchdrunk. For completeness, we will list them:\n\ni. Register Addressing\nii. Immediate Addressing\niii. Extended Addressing\niv. Immediate Extended Addressing\nv. Register Indirect Addressing\nvi. Indexed Addressing\nvii. Relative Addressing\nviii. Modified Page Zero Addressing\nix. Implied Addressing\nx. Bit Addressing\n\nIt is worth noting that almost any program can be written using only the first four modes, and most programs using the first three. The resulting program will certainly not be elegant, fast, or short, but it will work. It is suggested that the would-be programmer simply masters the first three modes, and writes simple programs using them until he (or she) is reasonably competent. At that point mastery of the remainder of the addressing modes should be quite easy, and the programmer can produce more elegant programs.\n\nNot every addressing mode is available on every instruction, so the tables in Chapter 4 should be consulted until the reader is familiar with the Z-80 instruction set.\n\n3.4 INSTRUCTION TYPES\n\n3.4.1 Introduction\n\nChapter 4 gives the complete Z-80 instruction set in tabular form. This section describes the types of instruction available in a less formal manner. There are just 8 groups of instruction in the Z-80:\ni. Loads\nii. Arithmetic and Logic\niii. Jumps and Subroutine calls\niv. Shifts\nv. Block Transfers\nvi. Bit Manipulation\nvii. Input/Output\nviii. Control\n\nThese 8 groups of instructions are combined with the addressing modes described in section 3.3 to give the 158 different instruction types available on the Z-80.\n\n3.4.2 Load Instructions\n\nIn Chapter 1 we described the read and write instructions which moved data between registers and the store. In the Z-80, read and write operations and data movements between individual registers are collectively known as “Loads”. The following are therefore examples of “Load instructions”.\n\n- Store the data from register A into store location 0C50.\n- Read the data from store location 12FA to register A.\n- Store the data from register B into the store location whose address is held in register pair HL.\n- Move the data in register D to register C.\n\n3.4.3 Arithmetic and Logic Instructions\n\nAlmost all Z-80 arithmetic instructions are performed on data in Register A (the accumulator) and data in a store or another register. The result invariably goes to register A. The Z-80 can perform the following 8 bit operations:\n\ni. Add\nii. Add with Carry (ADC)\niii. Subtract\niv. Sub with Carry (SBC)\nv. AND\nvi. Exclusive OR (XOR)\n\nvii. Compare (CP)\n\nviii. Increment\n\nix. Decrement\n\nAdd and Subtract with carry include the carry flag in the operation. Suppose we obey “Add register B to Register A with carry”, and register A contains 0101 1010 (5A in Hex), register B contains 0010 0011 (23 in Hex) with the carry flag set we would get:\n\n\\[\n\\begin{array}{c}\n0 & 1 & 0 & 1 & 1 & 0 & 1 & 0 \\\\\n0 & 0 & 1 & 0 & 0 & 0 & 1 & 1 \\\\\n\\hline\n1 & 1 & 1 & 1 & 1 & 1 & 0 & 0\n\\end{array}\n\\]\n\nResult to A\n\nIf the carry flag is not set we would get:\n\n\\[\n\\begin{array}{c}\n0 & 1 & 0 & 1 & 1 & 0 & 1 & 0 \\\\\n0 & 0 & 1 & 0 & 0 & 0 & 1 & 1 \\\\\n\\hline\n0 & 1 & 1 & 1 & 1 & 1 & 0 & 1\n\\end{array}\n\\]\n\nResult to A\n\nIncorporating the carry flag into the operation simplifies the writing of the programs with 16 bit numbers.\n\nThe simple Add and Subtract instructions ignore the state of the carry flag, and just operate on the two 8 bit words.\n\nAll arithmetic operations set (or reset) the S, Z, H, V, N, C flags according to the result of the operations. The P/V flag works on the overflow.\n\nThe logical operations AND, OR and XOR are performed bit by bit between data in register A and data in another register, Suppose we have:\n\n\\[\n\\begin{array}{c}\n1 & 0 & 1 & 0 & 0 & 1 & 0 & 1 \\\\\n1 & 0 & 0 & 1 & 1 & 1 & 0 & 1\n\\end{array}\n\\]\n\nRegister A (A5 in Hex)\n\nRegister B (9D in Hex)\n\nthe result of AND is 1 0 0 0 0 1 0 1 (85 in Hex)\nthe result of OR is 1 0 1 1 1 1 0 1 (BD in Hex)\nthe result of XOR is 0 0 1 1 1 0 0 0 (38 in Hex)\n\nIn all three operations the result goes to register A, and the\nS, Z and P/V flags are set or reset according to the result. The P/V flag works on the parity of the result.\n\nThe compare operations is used to compare the data in register A with some other specified data. The operations does not affect the data itself, but sets (or resets) the S, Z, H, V and C flags according to the result (Contents A – Specified Data). If we ask for the instruction Compare Register A, Register B for the data below the flags set would be:\n\n<table>\n<thead>\n<tr>\n<th>A</th>\n<th>B</th>\n<th>Flags</th>\n<th>Comments</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>06</td>\n<td>07</td>\n<td>SHNC</td>\n<td>A < B</td>\n</tr>\n<tr>\n<td>07</td>\n<td>06</td>\n<td>N</td>\n<td>A > B</td>\n</tr>\n<tr>\n<td>06</td>\n<td>06</td>\n<td>ZN</td>\n<td>A = B</td>\n</tr>\n</tbody>\n</table>\n\nCare should be taken if one of the numbers is using bit 8 as a sign bit e.g.\n\n<table>\n<thead>\n<tr>\n<th>A</th>\n<th>B</th>\n<th>Flags</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>FF</td>\n<td>01</td>\n<td>SN</td>\n</tr>\n<tr>\n<td>01</td>\n<td>FF</td>\n<td>HNC</td>\n</tr>\n</tbody>\n</table>\n\nUsually the compare instruction is used to test for equality (e.g. the Z flag set) and is invariably followed by a conditional jump or subroutine call on the state of the Z flag.\n\nIncrement and Decrement are useful instructions. Increment takes some specified data, adds '1' to it and places the result back again. Decrement operates in a similar manner except that '1' is subtracted. The data can be obtained from any register or (using register indirect or indexed addressing) any store location. The following are typical increment instructions:\n\nAdd 1 to Register C\nAdd 1 to the contents of the store location whose address is in HL\n\nThe following are typical decrement instructions:\n\nSubtract 1 from Register E\nSubtract 1 from the contents of the store location (index register X + 5)\nNote that unlike all other arithmetic operations, the result goes back to the source of the data and *NOT* to register A. Increment and decrement instructions are a convenient way of counting events.\n\n### 3.4.4 Jumps and Subroutine Calls\n\nThe idea of jump instructions and subroutine calls was introduced in Chapter 1. The Z-80 has a very useful range of conditional jumps and subroutine calls and returns. The conditions tested are based on the flags in the F register and are:\n\n- Carry Set, Carry Not Set, Accumulator Zero, Accumulator Non Zero, Parity Even, Parity Odd, Sign Negative, Sign Positive.\n\nThe majority of these instructions use extended addressing (e.g. CC 70 0F, call subroutine starting at location 0F 70 if the accumulator is zero). There are also a few jump instructions using relative addressing and three unconditional jump instructions using register indirect addressing.\n\nSubroutine calls use the stack pointer to store the current value of the program counter, and return instructions reinstate the value from the stack back to the program counter at the end of the subroutine. The stack operation was described in section 2.2.4.\n\n### 3.4.5 Rotates and Shifts\n\nA shift instruction simply moves the bit pattern in a register one place to the left or right. Suppose we had\n\n\\[\n1 \\ 0 \\ 1 \\ 0 \\ 0 \\ 1 \\ 1 \\ 1 \\ 1 \\quad (A7 \\text{ in Hex})\n\\]\n\nA simple shift to the left would give\n\n\\[\n0 \\ 1 \\ 0 \\ 0 \\ 1 \\ 1 \\ 1 \\ 0 \\quad (4E \\text{ in Hex})\n\\]\n\nA simple shift to the right would give\n\n\\[\n0 \\ 1 \\ 0 \\ 1 \\ 0 \\ 0 \\ 1 \\ 1 \\quad (53 \\text{ in Hex})\n\\]\n\nIn each case the bit pushed off the end is \"lost\", and a zero\nplaced at the other end. These are known as a logical shift.\n\nConsider the simple bit pattern 0101, which is five in decimal. If the pattern is shifted one place to the left (called shifting up) we get 1010 which is ten in decimal. A shift up is equivalent to multiplying by two providing the top bit is not shifted off the end.\n\nSimilarly, if we have the bit pattern 1100, which is twelve in decimal and shift it one place to the right (called shifting down) we get 0110 which is six in decimal. A shift down is equivalent to a division by two.\n\nA simple shift will, however, give the wrong result on signed number. If twos complement representation is used, bit 7 represents the sign, being a ‘1’ for negative numbers and ‘0’ for positive numbers. We thus have:\n\n\\[\n\\begin{align*}\n11111000 & \\quad (-8 \\text{ decimal}) \\\\\n11111100 & \\quad (-4 \\text{ decimal}) \\\\\n11111110 & \\quad (-2 \\text{ decimal}) \\\\\n11111111 & \\quad (-1 \\text{ decimal})\n\\end{align*}\n\\]\n\nAlthough we are dividing by two by shifting to the right, it is not a simple shift because the sign bit must be maintained. This is known as an arithmetic shift, and can be summarised by Fig. 3.4.\n\nRotate instructions are very similar to shifts. In a rotate instruction the ‘lost’ bit is simply fed into the opposite end of the register as shown on Fig.3.5. The effect of successive rotate rights would therefore be:\n\n\\[\n\\begin{align*}\n\\text{start} & \\quad 0110 \\ 0101 \\\\\n\\text{rotate right} & \\quad 1011 \\ 0010 \\\\\n\\text{rotate right} & \\quad 0101 \\ 1001 \\\\\n\\text{rotate right} & \\quad 1010 \\ 1100\n\\end{align*}\n\\]\n\nThe Z-80 has seven types of rotate and shift instructions. These all incorporate the carry flag as shown on Fig.3.6. These operations can be performed on every general purpose register and (using register indirect or indexed addressing) on store contents.\n\nShift instructions are the basis for writing multiplication\nand division routines, and both shifts and rotates are widely used where individual bits are used to represent data in control applications or data processing as described in section 3.3.11.\nFig. 3.6 Z-80 shift & rotate instructions\n'0' = zero\nCY = carry flag\n(HL) = store location whose address is held in HL\nACC = register A (i.e. Accumulator)\n\nFig. 3.6 (b)\n\n3.4.6 Block Transfer\n\nThe Z-80 has a unique set of block transfer instructions. These allow \"blocks\" of data to be moved around the store with just a few instructions. These instructions all involve the register pairs HL, DE, BC.\n\nRegister pair HL contains the 16 bit address where the first item of data is to be found.\n\nRegister pair DE contains the 16 bit address where the first item is to be stored.\n\nRegister pair BC is a 16 bit counter used to define how many words are to be moved.\n\nIf HL contained, say, 0C50, DE, 2000 and BC 100, a block transfer instruction would move 100 (Hex) words from 0C50 to 2000 and succeeding locations as summarised on Fig.3.7.\n\nThe contents of 0C50 would go to 2000\n0C51 to 2001\n0C52 to 2002 and so on for 100 locations.\n\nThere are four block transfer instructions. The first two operate as above, and are known as \"load increment repeat, (LDIR)\" and \"load decrement repeat, (LDDR)\". These operate as above, except LDIR works up the store and LDDR works down the store allowing data to be transferred between overlapping locations as shown on Fig.3.8.\n\nThe two remaining block transfer instructions transfer one word each time the instruction is obeyed, but set up HL, DE and BC ready for the next transfer. These allow other instructions to be incorporated in the block transfer operation. An\nexample is shown on Fig. 3.9 which is a flow chart for an operation which transfers a block of data, terminating either when the full block is transferred or a word containing \"FF\" (Hex) is found. As before, an incrementing and decrementing instruction is provided to allow data to be transferred between overlapping locations. The instructions are known as \"Load decrement (LDD)\" and \"Load increment (LDI)\".\n\nThe Z-80 also has four powerful block search instructions which allow an area of store to be compared with the accumulator contents. HL contains the start address, and BC is a counter indicating the number of locations to be searched. As before, the search can be conducted up or down the store, and can be conducted one word at a time (compare increment (CPI) and compare decrement (CPD)) or at one go with one\nFig. 3.9 Example of use of block transfer\ninstruction (compare increment repeat (CPIR) and compare decrement repeat (CPDR)). If a match is found, HL indicates the address.\n\nThe block transfer and search instructions are a somewhat advanced technique, but are very useful for handling files and text.\n\n3.4.7 Bit Manipulation\n\nThe Z-80 has a comprehensive range of instructions to allow individual bits in registers and store locations to be set, reset and tested. These instructions are particularly useful in control and data handling applications. Register indirect (using HL) and indexed addressing is used for accessing store locations. Bit tests set or reset the zero flag in the F register (Z flag set if tested bit is zero). An example of a bit manipulation instruction is CB 5E which tests bit 3 in the store location whose address is held in register pair HL.\n\n3.4.8 Input/Output\n\nThe basis of input/output instructions were described in section 1.5. In a Z-80 based microcomputer, up to 256 I/O ports can be addressed. An I/O instruction has to define:\n\ni. The port address (8 bits)\nii. The direction (input or output)\niii. The store location or register which is the source (or destination) of the data.\n\nThe Z-80 uses direct addressing and register indirect addressing to specify the port number. D3 05, for example is “output one word to port 5 from register A” (using direct addressing). All indirect addressing is done with register C holding the address. An example of an indirect addressed I/O instruction is ED 60 which is “Input one word from the port whose address is held in register C to register H”.\n\nThere are also a useful range of block transfer I/O instructions which transfer large chunks of data between sequential store locations and an I/O port. These operate in a similar\nmanner to the block transfer instructions described previously in section 3.4.6.\n\nRegister pair HL contains the store address\nRegister B contains the byte counter\nRegister C contains the port address\n\nThe block transfer instructions are particularly useful for inputting data from (say) a tape recorder or sending data to a printer.\n\nWe will return to I/O instructions again in Chapter 6 where I/O support devices are described and section 6.4 where the operation of interrupts is discussed.\n\n3.4.9 Control Instructions\n\nThere are six Z-80 control instructions. Four of these are concerned with the operations of interrupts (described further in section 6.4). The remaining two are \"Halt\" and the dummy \"No operation\".\n\n3.4.10 General Observations\n\nWe have described the Z-80 instructions in very general terms. In Chapter 4 the full instructions set is given in a formal manner.\n\n3.5 SYMBOLIC REPRESENTATION\n\nIt is very laborious to describe instructions in a descriptive manner such as \"Fetch to register A the contents of the store location whose address is held in register pair HL\". A simple, logical symbolism is used to represent instructions in the Z-80 (and other) microprocessors. Typical instructions are represented as.\n\n\\[\nA \\leftarrow A + 1 \\\\\nA \\leftarrow A + (HL)\n\\]\n\nLet us see what these symbols mean, and how they\nrepresent an instruction.\n\nRegisters are represented by their letters (A, B, C, etc.). Numbers are simply represented by their hex equivalent; 19, C5 for example. The arrow ← shows the data movement, so:\n\n\\[\nA \\leftarrow B \\text{ means move the contents of register } B \\text{ to register } A \\\\\nC \\leftarrow 37 \\text{ means load register } C \\text{ with the hex number 37 (immediate addressing)}\n\\]\n\nArithmetic operations are represented by these symbols:\n\n\\[\n+ \\quad \\text{addition} \\\\\n- \\quad \\text{subtraction} \\\\\n\\wedge \\quad \\text{and} \\\\\n\\lor \\quad \\text{or} \\\\\n\\oplus \\quad \\text{exclusive or}\n\\]\n\nWe can thus write:\n\n\\[\nA \\leftarrow A + 1 \\quad \\text{Add 1 to the contents of register } A \\\\\nA \\leftarrow A + B \\quad \\text{Add the contents of register } A \\text{ and } B, \\text{ result to register } A\n\\]\n\nThe contents of store locations are represented by brackets ( ). We therefore interpret \\((0C50)\\) to mean the contents of store location \\(0C50\\). Care should be taken, since \\(FFE1\\) means a 16 bit number as in:\n\n\\[\nHL \\leftarrow FFE1 \\text{ means load register pair } HL \\text{ with hex number } FFE1 \\text{ (immediate addressing)}\n\\]\n\n\\((FFE1)\\) means the contents of store location \\(FFE1\\) as in:\n\n\\[\n(FFE1) \\leftarrow B \\quad \\text{which is store the contents of register } B \\text{ in store location } FFE1.\n\\]\n\nRegister indirect and indexed addressing are also represented by ( ) since they refer to store locations. For example:\n\n\\[\nB \\leftarrow (HL) \\quad \\text{is bring contents of the store location whose address is held in register pair } HL \\text{ to register } B \\text{ (register indirect addressing)}\n\\]\nA ← A + (IX + 3) Add the contents of register A to the contents of the store location whose address is given by adding 3 to the contents of the index register, the result to go to register A.\n\nThe last example shows the simplicity of the symbolism! Even jump instructions can be represented. A simple jump is:\n\nPC ← 1DAF Jump to location 1DAF (PC stands for program counter)\n\nA subroutine call to a subroutine at F6000 is represented by the three symbols:\n\n(SP − 1) ← PC_H, (SP − 2) ← PC_L; PC ← F6000\n\nSP refers to the stack pointer, PC_H is the high byte of the program counter, PC_L is the low byte of the program counter. The symbolism cannot be used to represent shift instruction and control instructions.\n\n3.6 CONCLUSION\n\nIn this chapter we have described the Z-80 instructions and addressing modes in a descriptive manner. In chapter 4 the complete instruction set is given formally in a manner suitable for reference by a programmer.\nChapter Four\n\nTHE Z-80 INSTRUCTION SET\n\n4.1 INTRODUCTION\n\nIn Chapter 3 the Z-80 instruction set was described in narrative fashion. In this chapter the full instruction set is given in a formal fashion. The most convenient way to do this is in tabular form. Most instructions involve data from some source (a register, a port or a store location) and the result goes to a destination. The instructions are represented in the form of tables with the data source across the top and the destination down the side. The instruction (in Hex code) can then be read off like a car mileage chart. On Table 4.1, for example, the code to move data from register E to register B is 43.\n\nIn the tables, “n” refers to a single byte hex number (i.e. two hex digits) “n” is used for immediate data and port addressing. “nn” refers to a double byte hex number (i.e. four hex digits) “nn” is used for extended addressing and 16 bit immediate data. “d” is used for the (single byte) offset in indexed instructions (representing a signed twos complement number, remember) “e” is used for the displacement in relative addressing.\n\nWhere two byte numbers “nn” are used, it should be remembered that the low byte comes first. C3 50 0C is a jump instruction to 0C 50, for example.\n\nIt should also be remembered that brackets ( ) refer to store locations, so (BC) indicates register indirect addressing, with register pair BC holding the store location.\n\nAssembler mnemonics are also given with the tables, although Z-80 assembly language is not described until chapter 5. The tables are intended for reference purposes, and would not be complete without the assembler mnemonics.\n\nThe Z-80 is a development of the Intel 8080 microprocessor, and all 8080 instructions are available on the Z-80. These instructions have a small identifier in the top left hand corner.\nof the instruction box in the table.\n\n4.2 LOAD INSTRUCTIONS\n\n4.2.1 8 bit Loads\n\nThe full set of 8 bit load instructions is shown on Table 4.1. As explained previously, the source of the data is given across the top, and the destination down the side. The code for D ← H, for example, is 54, and the code for A ← 15 is 3E 15.\n\nAll load mnemonics have the form:\n\nLD Destination, Source\n\nfor example, LD A,(HL) which has the code 7E.\n\nNote that the instructions to load immediate data into an indexed address occupies four locations (DD 36 d n and FD 36 d n).\n\n4.2.2 16 bit Loads\n\nThe Z-80 can also move 16 bit (2 byte) data between register pairs and two successive store locations. These 16 bit load instructions are given on Table 4.2. This is driven in a similar manner to Table 4.1.\n\nSP refers to the stack pointer. The use of the stack was explained earlier in section 2.2.4. The PUSH instructions put data onto the stack, and the POP instruction retrieves data from the stack. When register pairs are pushed onto the stack, the order is as below:\n\n<table>\n<thead>\n<tr>\n<th>First (High)</th>\n<th>Second (Low)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A</td>\n<td>F</td>\n</tr>\n<tr>\n<td>B</td>\n<td>C</td>\n</tr>\n<tr>\n<td>D</td>\n<td>E</td>\n</tr>\n<tr>\n<td>H</td>\n<td>L</td>\n</tr>\n</tbody>\n</table>\n\nWhen a push instruction is obeyed, the sequence of events is.\nTable 4.1 8 Bit Load Group\nInstruction Mnemonics are all LD destination, source\n\n<table>\n<thead>\n<tr>\n<th>REG. INDIRECT</th>\n<th>REGISTER</th>\n<th>IMPLIED</th>\n<th>REGISTER</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>(HL)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(BC)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(DE)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(IX+d)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(IY+d)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>EXT. ADD.</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(nn)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>IMPLIED</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>R</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nNote: Reg. Indirect, Indexed & Ext. Addressing access the store\n<table>\n<thead>\n<tr>\n<th>SOURCE</th>\n<th>REG. INDIRECT</th>\n<th>INDEXED</th>\n<th>EXT. ADDR.</th>\n<th>IMMED.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>H</td>\n<td>L</td>\n<td>(HL)</td>\n<td>(BC)</td>\n<td>(DE)</td>\n</tr>\n<tr>\n<td>7C</td>\n<td>7D</td>\n<td>7E</td>\n<td>0A</td>\n<td>1A</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td>d</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>44</td>\n<td>45</td>\n<td>46</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>d</td>\n</tr>\n<tr>\n<td>4C</td>\n<td>4D</td>\n<td>4E</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>d</td>\n</tr>\n<tr>\n<td>54</td>\n<td>55</td>\n<td>56</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>d</td>\n</tr>\n<tr>\n<td>5C</td>\n<td>5D</td>\n<td>5E</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>d</td>\n</tr>\n<tr>\n<td>64</td>\n<td>63</td>\n<td>66</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>d</td>\n</tr>\n<tr>\n<td>6C</td>\n<td>6D</td>\n<td>6E</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>d</td>\n</tr>\n<tr>\n<td>74</td>\n<td>75</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>DD</td>\n<td>DD</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>74</td>\n<td>75</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>d</td>\n<td>d</td>\n<td></td>\n<td></td>\n<td>d</td>\n</tr>\n<tr>\n<td>FD</td>\n<td>FD</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>74</td>\n<td>75</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>d</td>\n<td>d</td>\n<td></td>\n<td></td>\n<td>d</td>\n</tr>\n</tbody>\n</table>\n\n63\nTable 4.2 16 Bit Load Group (includes PUSH & POP)\nInstruction Mnemonics are: LD destination, source; POP register pair; PUSH register pair\n\n<table>\n<thead>\n<tr>\n<th>SOURCE</th>\n<th>REGISTER</th>\n<th>IMM. EXT.</th>\n<th>EXT. ADDRL</th>\n<th>REG. INDIR</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>AF</td>\n<td>BC</td>\n<td>DE</td>\n<td>HL</td>\n<td>SP</td>\n</tr>\n<tr>\n<td>AF</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>BC</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>DE</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>HL</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>IX</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>IY</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>EXT. ADDR (mm)</td>\n<td></td>\n<td>ED</td>\n<td>ED</td>\n<td>ED</td>\n</tr>\n<tr>\n<td>REG. INDIR (SP)</td>\n<td></td>\n<td>F5</td>\n<td>C5</td>\n<td>D5</td>\n</tr>\n</tbody>\n</table>\n\nNote: Push subtracts 2 from SP; Pop adds 2 to SP; LDs to & from store use 2 locations for data; Ext. and Reg. Indir. access the store\n\nDecrement SP\nStore High byte in (SP)\nDecrement SP\nStore Low byte in (SP)\n\nWhen a pop instruction is obeyed, the sequence is:\n\nRetrieve Low Byte from (SP)\nIncrement SP\nRetrieve High Byte from (SP)\nIncrement SP\n\n16 bit loads have the same assembler mnemonic as the 8 bit loads. LD Destination, Source. The push instruction mnemonics have the form Push Register Pair (e.g. PUSH AF).\nThe Pop instructions mnemonics have the form POP Register Pair (e.g. POP HL).\n\n4.2.3 Exchanges\n\nThe Z-80 has two register sets as explained in section 2.2. The exchange instructions switch between these with two instructions. The first interchanges AF and AF'. The second interchanges BC, BC'; DE, DE'; HL, HL'. Both are one byte instructions.\n\nThere are four other exchange instructions which interchange data between register pairs, or a register pair and the stack. The contents of HL and DE can be interchanged, and contents of HL, IX, IY interchanged with the bottom two bytes of the stack (leaving the stack pointer unchanged).\n\nTable 4.3 shows the six exchange instructions.\n\nTable 4.3 Exchanges\nInstruction Mnemonics EX, EXX\n\n<table>\n<thead>\n<tr>\n<th>IMPLIED ADDRESSING</th>\n<th>AF'</th>\n<th>BC', DE' & HL'</th>\n<th>HL</th>\n<th>IX</th>\n<th>IY</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>AF</td>\n<td>08</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>BC, DE & HL</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>DE</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Reg. Indir. (SP)</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nExchanges data with stack\n4.3 ARITHMETIC AND LOGIC INSTRUCTIONS\n\n4.3.1 8 Bit Instructions\n\nThe Z-80 arithmetic and logic instructions were described informally in section 3.4.3. The full range is shown on Table 4.4. Note that with the exception of CP, INC and DEC instructions the result always goes to Register A. Data can only be obtained from store locations with register indirect (HL as pointer) or indexed addressing.\n4.3.2 General Purpose Operations on AF\n\nThere are five instructions shown on Table 4.5 which operate on the accumulator (register A) and the flag register. Each of these require a little explanation.\n\n<table>\n<thead>\n<tr>\n<th>Table 4.5 General Purpose AF Group</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Decimal Adjust Acc, ‘DAA’</td>\n</tr>\n<tr>\n<td>Complement Acc, ‘CPL’</td>\n</tr>\n<tr>\n<td>Negate Acc, ‘NEG’ (2’s complement)</td>\n</tr>\n<tr>\n<td>Complement Carry Flag, ‘CCF’</td>\n</tr>\n<tr>\n<td>Set Carry Flag, ‘SCF’</td>\n</tr>\n</tbody>\n</table>\n\n4.3.2.1 Decimal Adjust Accumulator (DAA)\n\nIt is often convenient to represent numbers in Binary Coded Decimal (BCD). This represents each decade by four bits, e.g. decimal 79 would be represented by 0111 1001. Four bits can represent 0 – 15, so binary codes 1010 to 1111 are not used in BCD, and one byte can only represent 0 to 99 decimal.\n\nIf the arithmetic operations in Table 4.4 are used with BCD coded data the wrong answer will result. If, for example, register A contains decimal 47 in BCD (0100 0111), register B contains decimal 26 in BCD (0010 0110) addition will give:\n\nA | 0 1 0 0 0 1 1 1\nB | 0 0 1 0 0 1 1 0\nResult | 0 1 1 0 1 1 0 1\n\nwhich is Hex 6D and is not decimal 73 in either BCD or binary!\nThe decimal adjust instruction corrects the result of a BCD addition or subtraction instruction to give a BCD result. In the example above a DAA instruction on 6D would give the correct BCD result 73. The DAA does NOT convert a Hex or binary number to its BCD equivalent.\n\nThe DAA corrects the result of a subtraction and addition in a different way, and uses the N flag to determine if the last instruction was an add or subtract. It is therefore very important to use the DAA instruction immediately after the add or subtract instruction which it is to correct.\n\nThe DAA instruction itself sets the flags according to the BCD result obtained after the adjustment. For example, if A contained BCD 87 and B contained BCD 26, adding A and B would give Hex AD. A DAA would then give BCD 13 with the carry flag set (decimal 87 + decimal 26 = decimal 113).\n\n4.3.2.2 Complement Accumulator (CPL)\nThe complement accumulator instruction simply replaces '1's by '0's and vice versa in the accumulator. For example:\n\n\\[\n\\begin{align*}\n1011 & \\quad 0111 \\text{ (B7 hex)} \\\\\n0101 & \\quad 0001 \\text{ (51 hex)}\n\\end{align*}\n\\]\n\nbecomes\n\n\\[\n\\begin{align*}\n0100 & \\quad 1000 \\text{ (48 hex)} \\\\\n1010 & \\quad 1110 \\text{ (AE hex)}\n\\end{align*}\n\\]\n\nCPL is a useful single byte instruction.\n\n4.3.2.3 Negate Accumulator (NEG)\nThe negate instruction replaces the data in the accumulator by the twos complement number of opposite sign. +23, for example becomes -23.\n\nFor example:\n\n\\[\n\\begin{align*}\n04 \\text{ Hex becomes FC Hex (} -4 \\text{)} \\\\\nE7 \\text{ Hex (} -19 \\text{ Hex) becomes 19 Hex}\n\\end{align*}\n\\]\n\n4.3.2.4 Complement Carry Flag (CCF), Set Carry Flag (SCF)\nThese instructions simply allow the state of the carry flag to be changed (CCF) or forced to a '1' (SCF). All other flags remain unchanged.\n4.3.3 16 Bit Arithmetic\n\nTable 4.6 shows the range of 16 bit arithmetic instructions available on the Z-80. These operate solely on the register pairs, stack pointer and index register contents. It is not possible to perform (directly) arithmetic operations on 16 bit data in two successive store locations. All register pairs can be incremented and decremented.\n\nTable 4.6 16 Bit Arithmetic Group\n\n<table>\n<thead>\n<tr>\n<th>SOURCE</th>\n<th>BC</th>\n<th>DE</th>\n<th>HL</th>\n<th>SP</th>\n<th>IX</th>\n<th>IY</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>'ADD'</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>HL</td>\n<td>09</td>\n<td>19</td>\n<td>29</td>\n<td>39</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>IX</td>\n<td>DD 09</td>\n<td>DD 19</td>\n<td>DD 39</td>\n<td>DD 29</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>IY</td>\n<td>FD 09</td>\n<td>FD 19</td>\n<td>FD 39</td>\n<td>FD 29</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>Add with Carry and Set Flags 'ADC'</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>HL</td>\n<td>ED 4A</td>\n<td>ED 5A</td>\n<td>ED 6A</td>\n<td>ED 7A</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Sub with Carry and Set Flags 'SBC'</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>HL</td>\n<td>ED 42</td>\n<td>ED 52</td>\n<td>ED 62</td>\n<td>ED 72</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>INC 'INC'</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>HL</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>DECREMENT 'DEC'</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\n4.4 JUMP CALL AND RETURN GROUP\n\nThe principles of jumps and subroutine calls were outlined in section 3.4.4. The full range is given in Table 4.7. There are 9 conditions available based on the states of the various flags, although not all conditions are available with every addressing mode.\nRelative addressing can cause some confusion. The offset is calculated from two locations further on from the current location. Twos complement notation is used allowing jumps both forward and backward.\n\nA particularly useful conditional relative jump is the \"dec B, jump non zero\" (DJNZ) which allows B to be used as a counter when a block of instructions is to be performed a specific number of times. This is called a loop, and is summarised on Fig. 4.1.\n\nSubroutine calls are available with 9 conditions, but are only available with extended addressing. Returns from sub-\nroutines are again available with 9 conditions (the return address is, of course, obtained from the stack pointer).\n\nThe two remaining return instructions are concerned with interrupts, a topic discussed further in section 6.4.\n\n4.5 SHIFTS AND ROTATES\n\nThere are 7 types of shift and rotate instructions summarised on Fig. 4.2.\nFig. 4.2 Z-80 rotate & shift instructions\nTable 4.8 Rotate & Shifts Group\n\n<table>\n<thead>\n<tr>\n<th>TYPE OF ROTATE or SHIFT</th>\n<th>SOURCE & DESTINATION</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>A</td>\n</tr>\n<tr>\n<td>'RLC'</td>\n<td>CB 07</td>\n</tr>\n<tr>\n<td>'RRC'</td>\n<td>CB 0F</td>\n</tr>\n<tr>\n<td>'RL'</td>\n<td>CB 17</td>\n</tr>\n<tr>\n<td>'RR'</td>\n<td>CB 1F</td>\n</tr>\n<tr>\n<td>'SLA'</td>\n<td>CB 27</td>\n</tr>\n<tr>\n<td>'SRA'</td>\n<td>CB 2F</td>\n</tr>\n<tr>\n<td>'SRL'</td>\n<td>CB 3F</td>\n</tr>\n<tr>\n<td>'RLD'</td>\n<td></td>\n</tr>\n<tr>\n<td>'RRD'</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n† Mnemonic\nSee Fig. 4.2 for operation\n'0' = zero\nCY = carry flag\n(HL) = store location whose address is held in HL\nACC = register A (i.e. Accumulator)\n\nFig. 4.2 (b)\nThese operate as described in section 3.4.5 and are relatively straightforward.\n\nThe rotate digit left (RLD) and rotate digit right (RRD) are intended for use with BCD arithmetic and shift four bits between the bottom half of the accumulator and a store location obtained by register indirect addressing with HL containing the address.\n\nFour instructions are duplicated (RLCA, RRCA, RLA, RRA) to include original Intel 8080 instructions.\n\n<table>\n<thead>\n<tr>\n<th>REG, INDIR.</th>\n<th>(HL)</th>\n<th>SOURCE</th>\n<th>(DE)</th>\n<th>DESTINATION</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>REG, INDIR.</td>\n<td>(HL)</td>\n<td>ED A0</td>\n<td>(DE)</td>\n<td>REG, INDIR.</td>\n</tr>\n<tr>\n<td>None available on 8080</td>\n<td>Inc HL & DE, Dec BC</td>\n<td>Inc HL & DE, Dec BC</td>\n<td>Dec HL & DE, Dec BC, Repeat until BC=0</td>\n<td>Dec HL & DE, Dec BC, Repeat until BC=0</td>\n</tr>\n<tr>\n<td>Reg DE</td>\n<td>Reg BC</td>\n<td>Reg BC</td>\n<td>Reg BC</td>\n<td>Reg BC</td>\n</tr>\n</tbody>\n</table>\n4.6 BLOCK TRANSFERS AND SEARCHES\n\nTable 4.9 shows the powerful block transfer instructions. As explained in section 3.4.6, HL is used to hold the source address, DE holds the data address, and BC is a byte counter. Table 4.10 shows the block search instructions.\n\n### Table 4.10 Block Search Group\n\n<table>\n<thead>\n<tr>\n<th>Search Location</th>\n<th>REG. INDIR.</th>\n<th>(HL)</th>\n<th>ED A1</th>\n<th>'CPI' Inc HL, Dec BC</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ED B1</td>\n<td>'CPI', Inc HL, Dec BC repeat until BC=0 or find match</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ED A9</td>\n<td>'CPD' Dec HL & BC</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ED B9</td>\n<td>'CPDR' Dec HL & BC Repeat until BC=0 or find match</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nNone available on 8080\n\nHL points to location in memory to be compared with accumulator contents\nBC is byte counter\n4.7 BIT MANIPULATION\n\nThe range of bit manipulation instructions are shown on Table 4.11. These allow any bit to be set, reset or tested in any register or (using indirect or indexed addressing) any store location. The test instructions set the Zero Flag if the tested bit is zero.\n\n4.8 INPUT AND OUTPUT GROUP\n\nAn input instruction needs to specify the port address and the destination for the data. The Z-80 input instructions, shown on Table 4.12, all have registers as the destination, and the port address specified either by immediate addressing or register indirect with register C holding the port address. A single byte is used as a port address, so 256 ports can be addressed. The contents of register A appear on the top 8 bits of the address bus giving 64K of port addressing for more ambitious users!\n\nThere are also a useful range of block input instructions. These operate in a similar manner to the block transfer instructions, and are used to input a block of data from a port to sequential store locations. Register pair HL holds the store address, register B is used as a counter and register C holds the port address.\n\nThe output instructions, shown on Table 4.13, transfer data from registers to a specified port address. As above, immediate and indirect addressing is used.\n\nThere is again a range of block output instructions which output a block of data from sequential store locations to a specified port. Register pair HL holds the store address, register B is used as a counter and register C holds the port address.\n\nInput/Output is a somewhat involved topic that is dealt with further in chapter 6 where actual I/O devices are described along with the operation of interrupts.\n### Table 4.11 Bit Manipulation Group\n\n<table>\n<thead>\n<tr>\n<th>TEST 'BIT'</th>\n<th>Bit</th>\n<th>REGISTER ADDRESSING</th>\n<th>REG. INDIR.</th>\n<th>INDEXED</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td>A</td>\n<td>B</td>\n<td>C</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>CB 47</td>\n<td>CB 40</td>\n<td>CB 41</td>\n</tr>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>CB 4F</td>\n<td>CB 48</td>\n<td>CB 49</td>\n</tr>\n<tr>\n<td>2</td>\n<td>2</td>\n<td>CB 57</td>\n<td>CB 50</td>\n<td>CB 51</td>\n</tr>\n<tr>\n<td>3</td>\n<td>3</td>\n<td>CB 5F</td>\n<td>CB 58</td>\n<td>CB 59</td>\n</tr>\n</tbody>\n</table>\n\nCont...\n<table>\n<thead>\n<tr>\n<th>TEST 'BIT'</th>\n<th>0</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<th>8</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>CB87</td>\n<td>CB8F</td>\n<td>CB97</td>\n<td>CB97</td>\n<td>CB67</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n</tr>\n<tr>\n<td>1</td>\n<td>CB8F</td>\n<td>CB89</td>\n<td>CB97</td>\n<td>CB97</td>\n<td>CB67</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n</tr>\n<tr>\n<td>2</td>\n<td>CB87</td>\n<td>CB88</td>\n<td>CB97</td>\n<td>CB97</td>\n<td>CB67</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n</tr>\n<tr>\n<td>3</td>\n<td>CB87</td>\n<td>CB88</td>\n<td>CB97</td>\n<td>CB97</td>\n<td>CB67</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n</tr>\n<tr>\n<td>4</td>\n<td>CB6F</td>\n<td>CB69</td>\n<td>CB6A</td>\n<td>CB6B</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n<td>CB6D</td>\n</tr>\n<tr>\n<td>5</td>\n<td>CB77</td>\n<td>CB71</td>\n<td>CB72</td>\n<td>CB73</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n</tr>\n<tr>\n<td>6</td>\n<td>CB77</td>\n<td>CB71</td>\n<td>CB72</td>\n<td>CB73</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n</tr>\n<tr>\n<td>7</td>\n<td>CB7F</td>\n<td>CB79</td>\n<td>CB7A</td>\n<td>CB7B</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n<td>CB7D</td>\n</tr>\n<tr>\n<td>8</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>9</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>10</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>11</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>12</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>13</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>14</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>15</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>16</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>17</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>18</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>19</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>20</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>21</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>22</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>23</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>24</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>25</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>26</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>27</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>28</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>29</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>30</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>31</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>32</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>33</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>34</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>35</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>36</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>37</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>38</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>39</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>40</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>41</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>42</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>43</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>44</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>45</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>46</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>47</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>48</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>49</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>50</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>51</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>52</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>53</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>54</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>55</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>56</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>57</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>58</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>59</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>60</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>61</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>62</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>63</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>64</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>65</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n<tr>\n<td>66</td>\n<td>CB87</td>\n<td>CB81</td>\n<td>CB82</td>\n<td>CB83</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n<td>CB8D</td>\n</tr>\n</tbody>\n</table>\n\nCont. . .\n| SET BIT 'SET' | 0 | CB | C7 | CB | C0 | CB | C1 | CB | C2 | CB | C3 | CB | C4 | CB | C5 | CB | C6 | DD | CB | dE | FD | CB | dE |\n|---------------|----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|\n| 1 | CB | CF | CB | C8 | CB | C9 | CB | CA | CB | CB | CC | CB | CC | CB | CD | CB | CE | DD | CB | dE | FD | CB | dE |\n| 7 | CB | BF | CB | B8 | CB | B9 | CB | BA | CB | BB | CB | BC | CB | BD | CB | BE | DD | CB | dE | FD | CB | dE |\n| 6 | CB | B7 | CB | B0 | CB | A1 | CB | A2 | CB | A3 | CB | A4 | CB | A5 | CB | A6 | DD | CB | dA | FD | CB | dA |\n| 5 | CB | A7 | CB | A0 | CB | A8 | CB | A9 | CB | AA | CB | AB | CB | AC | CB | AD | CB | AE | DD | CB | dE | FD | CB | dE |\n| 4 | CB | 9F | CB | 98 | CB | 99 | CB | 9A | CB | 9B | CB | 9C | CB | 9D | CB | 9E | DD | CB | dE | FD | CB | dE |\n| 3 | | | | | | | | | | | | | | | | | | | | | | |\n\nCont...\n<table>\n<thead>\n<tr>\n<th></th>\n<th>CB D7</th>\n<th>CB D0</th>\n<th>CB D1</th>\n<th>CB D2</th>\n<th>CB D3</th>\n<th>CB D4</th>\n<th>CB D5</th>\n<th>CB D6</th>\n<th>DD CB d D6</th>\n<th>FD CB d D6</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2</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>3</td>\n<td>CB DF</td>\n<td>CB D8</td>\n<td>CB D9</td>\n<td>CB DA</td>\n<td>CB DB</td>\n<td>CB DC</td>\n<td>CB DD</td>\n<td>CB DE</td>\n<td>DD CB d DE</td>\n<td>FD CB d DE</td>\n</tr>\n<tr>\n<td>4</td>\n<td>CB E7</td>\n<td>CB E0</td>\n<td>CB E1</td>\n<td>CB E2</td>\n<td>CB E3</td>\n<td>CB E4</td>\n<td>CB E5</td>\n<td>CB E6</td>\n<td>DD CB d E6</td>\n<td>FD CB d E6</td>\n</tr>\n<tr>\n<td>5</td>\n<td>CB EF</td>\n<td>CB E8</td>\n<td>CB E9</td>\n<td>CB EA</td>\n<td>CB EB</td>\n<td>CB EC</td>\n<td>CB ED</td>\n<td>CB EE</td>\n<td>DD CB d EE</td>\n<td>FD CB d EE</td>\n</tr>\n<tr>\n<td>6</td>\n<td>CB F7</td>\n<td>CB F0</td>\n<td>CB F1</td>\n<td>CB F2</td>\n<td>CB F3</td>\n<td>CB F4</td>\n<td>CB F5</td>\n<td>CB F6</td>\n<td>DD CB d F6</td>\n<td>FD CB d F6</td>\n</tr>\n<tr>\n<td>7</td>\n<td>CB FF</td>\n<td>CB F8</td>\n<td>CB F9</td>\n<td>CB FA</td>\n<td>CB FB</td>\n<td>CB FC</td>\n<td>CB FD</td>\n<td>CB FE</td>\n<td>DD CB d FE</td>\n<td>FD CB d FE</td>\n</tr>\n</tbody>\n</table>\n\nNone available on 8080\n\nInstruction Mnemonic have form\n- BIT n, source\n- RES n, source\n- SET n, source\n<table>\n<thead>\n<tr>\n<th>INPUT ADDRESSING</th>\n<th>PORT ADDRESS</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>INPUT 'IN'</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>IMMED REG. INDIR.</td>\n</tr>\n<tr>\n<td></td>\n<td>n (C)</td>\n</tr>\n<tr>\n<td>A</td>\n<td>DB n ED 78</td>\n</tr>\n<tr>\n<td>B</td>\n<td>ED 40</td>\n</tr>\n<tr>\n<td>C</td>\n<td>ED 48</td>\n</tr>\n<tr>\n<td>D</td>\n<td>ED 50</td>\n</tr>\n<tr>\n<td>E</td>\n<td>ED 58</td>\n</tr>\n<tr>\n<td>H</td>\n<td>ED 60</td>\n</tr>\n<tr>\n<td>L</td>\n<td>ED 68</td>\n</tr>\n</tbody>\n</table>\n\n**Command Table**\n\n- **'INI'** – INPUT & Inc HL, Dec B\n- **'INIR'** – INP, inc HL, Dec B, Repeat if B ≠ 0\n- **'IND'** – INPUT & Dec HL, Dec B\n- **'INDR'** – INPUT, Dec HL, Dec B, Repeat if B ≠ 0\n\n**Block Input Commands**\n\n- ED A2\n- ED B2\n- ED AA\n- ED BA\nTable 4.13 Output Group\n\n<table>\n<thead>\n<tr>\n<th>Source</th>\n<th>Immed.</th>\n<th>( n )</th>\n<th>D3 ( n )</th>\n<th>ED 79</th>\n<th>ED 41</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>'OUT'</td>\n<td>Reg. Ind.</td>\n<td>(C)</td>\n<td></td>\n<td>ED 79</td>\n<td>ED 41</td>\n</tr>\n<tr>\n<td>'OUTI' - OUTPUT</td>\n<td>Reg. Ind.</td>\n<td>(C)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Inc. HL, Dec B</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>'OTIR' - OUTPUT, Inc HL</td>\n<td>Reg. Ind.</td>\n<td>(C)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Dec. B, Repeat if ( B \\neq 0 )</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>'OUTD' - OUTPUT</td>\n<td>Reg. Ind.</td>\n<td>(C)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Dec HL & B</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>'OTDR' - OUTPUT, Dec HL</td>\n<td>Reg. Ind.</td>\n<td>(C)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>& B, Repeat if ( B \\neq 0 )</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n4.9 RESTARTS\n\nThe restart instructions are a special group of subroutine calls. The 8 restart instructions, shown on Table 4.14, call subroutines at hex addresses 0, 8, 10, 18, 20, 28, 30, and 38. Commonly used subroutines can be placed at these addresses and called with single byte instructions.\n\n<table>\n<thead>\n<tr>\n<th>CALL ADDRESS</th>\n<th>OP CODE</th>\n<th>DESCRIPTION</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0000H</td>\n<td>C7</td>\n<td>'RST 0'</td>\n</tr>\n<tr>\n<td>0008H</td>\n<td>CF</td>\n<td>'RST 8'</td>\n</tr>\n<tr>\n<td>0010H</td>\n<td>D7</td>\n<td>'RST 16'</td>\n</tr>\n<tr>\n<td>0018H</td>\n<td>DF</td>\n<td>'RST 24'</td>\n</tr>\n<tr>\n<td>0020H</td>\n<td>E7</td>\n<td>'RST 32'</td>\n</tr>\n<tr>\n<td>0028H</td>\n<td>EF</td>\n<td>'RST 40'</td>\n</tr>\n<tr>\n<td>0030H</td>\n<td>F7</td>\n<td>'RST 48'</td>\n</tr>\n<tr>\n<td>0038H</td>\n<td>FF</td>\n<td>'RST 56'</td>\n</tr>\n</tbody>\n</table>\n4.10 CONTROL INSTRUCTIONS\n\nThe 6 Z-80 control instructions are shown on Table 4.15. The no-operation instruction is simply skipped. This is actually more useful than might be first thought, as it allows gaps (for corrections) to be left in programs. HALT, stops the operation of the processor until an interrupt is received or the reset signal (pin 26) is given. The remaining control instructions are concerned with interrupts and are described in section 6.4.\n\nTable 4.15 CPU Control Group\n\n<table>\n<thead>\n<tr>\n<th>Control Instruction</th>\n<th>Opcode</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>'NOP'</td>\n<td>00</td>\n</tr>\n<tr>\n<td>'HALT'</td>\n<td>76</td>\n</tr>\n<tr>\n<td>DISABLE INT '(DI)'</td>\n<td>F3</td>\n</tr>\n<tr>\n<td>ENABLE INT '(EI)'</td>\n<td>FB</td>\n</tr>\n<tr>\n<td>SET INT MODE 0 'IMO'</td>\n<td>ED 46</td>\n</tr>\n<tr>\n<td>SET INT MODE 1 'IM1'</td>\n<td>ED 56</td>\n</tr>\n<tr>\n<td>SET INT MODE 2 'IM2'</td>\n<td>ED 5E</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Mode</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8080A Mode</td>\n<td>Call to Location 0038H</td>\n</tr>\n<tr>\n<td>8080A Mode</td>\n<td>Indirect Call using Register I and 8 bits from Interrupting Device as a Pointer.</td>\n</tr>\n</tbody>\n</table>\n4.11 GENERAL OBSERVATIONS\n\nWe have now covered all the Z-80 instructions. It cannot be over-emphasised that it is not practical (or even desirable) to learn them by heart. It is best for the beginner to start by writing very simple programs using just a small selection from the Z-80 repertoire to gain experience. Do not start by writing a 32K adventure program!\n\nIn the following chapter we will describe the Z-80 Assembler Language which simplifies machine code programming.\nChapter Five\n\nASSEMBLY LANGUAGE PROGRAMMING\n\n5.1 INTRODUCTION\n\nProgramming in the actual hex machine code is tedious and error prone. It is not difficult to see why working in machine code causes problems. Consider the simple program below:\n\n3A 50 0C A1 FE 01 C2 00 1D\n\nTo find out what this does we must determine where each instruction starts and finishes. By laborious reference to chapter 4 we get:\n\n3A 50 0C Load A from location 0C50\nA1 And with the contents of register C\nFE 01 Compare with ‘01’\nC2 00 1D Jump if zero flag is not set to instruction at 1D00\n\nUnderstanding a bald Hex program is not easy, and is doubly difficult with a program written by someone else.\n\nAnother problem occurs when a program requires to be modified due either to a fault or to changed requirements. Unlike BASIC, the simple insertion of one instruction to a machine code program will affect the addresses of all subsequent instructions, with unfortunate repercussions on the destination of jump instructions. This problem can be alleviated to some extent by leaving gaps at strategic places in a program, but the requirement to insert an instruction will always make a programmer wince.\n\nMachine code programs can be made comprehensible and easy to modify if the programmer uses a programming aid called an Assembler, which allows machine code programs initially to be written in a form closer to a high level language such as BASIC.\n\nIn assembly language, programs are written using mnemonics for each and every machine code instruction.\nExamples of these mnemonics are:\n\n<table>\n<thead>\n<tr>\n<th>Mnemonic</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>LD</td>\n<td>Load, i.e. data movement</td>\n</tr>\n<tr>\n<td>CALL</td>\n<td>Subroutine Call</td>\n</tr>\n<tr>\n<td>JP</td>\n<td>Jump</td>\n</tr>\n<tr>\n<td>ADD</td>\n<td>Arithmetic Additions</td>\n</tr>\n</tbody>\n</table>\n\nThe program written in mnemonics is called the source program. The programmer loads a special program called an Assembler into his computer, followed by his source program. The assembler converts the source program mnemonics into their machine code equivalent (not a particularly difficult operation, actually, as there is a one to one relationship between the mnemonics and their Hex coding). The resultant machine code program is called the object program, and can usually be saved on cassette, disc or paper tape, or transferred direct to the computer store.\n\nWriting a program in assembly language is therefore very similar to writing a program in BASIC, except that one BASIC instruction will be the equivalent of many machine code instructions, whereas one instruction in the source program will represent one, and only one, machine code instruction.\n\nAssembly language programming is much easier than straight machine code. The use of mnemonics makes the program easier to understand, and the assembler allows instructions to be added or deleted during debugging, with the computer adjusting all the jump instructions. Anyone seriously contemplating machine code programming should therefore aim to obtain an assembler.\n\nThere are many different assemblers for the Z-80 with slight differences in syntax, as there are many slightly different versions of BASIC. This chapter is therefore a non formal introduction to the principles of assembly language programming. With the background provided in this chapter, the reader should have little difficulty in following the formal presentation of any assembler language instruction manual.\n5.2 THE SOURCE PROGRAM\n\n5.2.1 Introduction\n\nThere are slight differences between manufacturers assemblers as there are between different BASICs, but in general, one source program instruction has the form:\n\n<table>\n<thead>\n<tr>\n<th>Line Number</th>\n<th>Label</th>\n<th>Instruction Mnemonic</th>\n<th>Comments</th>\n</tr>\n</thead>\n</table>\n\nFor example, we could have:\n\n```\n70 LOOP ADD HL,DE;ADD MULTICAND TO RESULT\n```\n\nThe line number is 70\nThe label identifying the location holding the instruction is LOOP.\nLabels are optional.\nThe instruction mnemonic is ADD HL,DE (add the contents of register pairs HL and DE, result to HL)\nThe comments always follow after a semicolon and are optional. Although they are not used by the assembler as such, good comments are essential to the understanding of the program at a later date.\n\nIt is most important to remember that one source code instruction represents one machine code instruction. The above example would be converted to the machine code instruction 19 (see Table 4.6).\n\nWe will now consider each item in a source program instruction in more detail.\n\n5.2.2 Line Numbers\n\nEach source program instruction starts with a line number. Users of BASIC will be familiar with the idea of line numbers, and will be pleased to know that line numbers in assembly language programming are used to identify the order of the instructions in the same way as BASIC.\n\nIf we were to type:\n10 START LD B, 16; INITIALISE REGISTER B\n20 LD HL, 0; CLEAR REGISTER PAIR HL\netc.\n\nDuring debugging, suppose we found that we should also have cleared register A. We would then reload the source program from tape (or disc) and add:\n\n15 LD A, 0; CLEAR REGISTER A\n\nThe source program would now be:\n\n10 START LD B, 16; INITIALISE REGISTER B\n15 LD A, 0; CLEAR REGISTER A\n20 LD HL, 0; CLEAR REGISTER PAIR HL\n\nwith line number 15 having been inserted between line numbers 10 and 20. (As an aside LD A,0 gives the machine code instruction 3E 00; two bytes. A shorter instruction with the same result is XOR A, exclusive OR of A with itself, which gives the machine code instruction AF, just one byte). A new object program could now be produced.\n\nThe use of line numbers allows instructions to be added, deleted and edited in a similar manner to BASIC. Line numbers are not, however, used in jump instructions (e.g. the BASIC instruction GOTO 120). Labels described in the next section, are used for this purpose.\n\n5.2.3 Labels\n\nLabels are used to identify a store location for use by other instructions (usually jumps and subroutine calls, although any instruction can use a label). We could for example have:\n\nJP RESET\nCALL KBD\nLD A, DATA\n\nwhere RESET, KBD, DATA are labels defined elsewhere in the program.\nThe label can usually be up to 6 letters long, and are chosen to be meaningful to the programmer. There are a few restrictions on labels; usually they must start with a letter and must not contain an instruction mnemonic. Individual assemblers will define allowed formats for labels.\n\nLabels can also be used in an expression to define a store location. For example JP TABLE+7 is a jump instruction to the location seven locations further on from the instruction whose label is TABLE. A special label often used with relative jumps is $ for “this location”. For example JRNC Start – $ is a conditional relative jump to Start.\n\nIt is not essential (or even desirable) for each and every instruction to be given labels.\n\n### 5.2.4 Instruction Mnemonic\n\nThe instruction mnemonic defines the actual instruction. In chapter 3 we saw that most Z-80 instructions define three things:\n\ni. The operation to be performed\nii. The source (s) for the data to be manipulated\niii. The destination for the result.\n\nThe operation to be performed is defined by a simple easy to remember mnemonic. Examples are:\n\n- LD for load instructions; CALL for subroutine calls;\n- ADC for Add with carry; JP for jump; INC for increment.\n\nThere are actually only a small number of these mnemonics, as shown on Table 5.1.\n\n**Table 5.1 Z-80 MNEMONICS IN ALPHABETICAL ORDER**\n\n<table>\n<thead>\n<tr>\n<th>mnemonic</th>\n<th>description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ADC</td>\n<td>Add with Carry</td>\n</tr>\n<tr>\n<td>ADD</td>\n<td>Add</td>\n</tr>\n<tr>\n<td>AND</td>\n<td>Logical AND</td>\n</tr>\n<tr>\n<td>BIT</td>\n<td>Test Bit</td>\n</tr>\n<tr>\n<td>CALL</td>\n<td>Call Subroutine</td>\n</tr>\n<tr>\n<td>Code</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>------</td>\n<td>-------------</td>\n</tr>\n<tr>\n<td>CCF</td>\n<td>Complement Carry Flag</td>\n</tr>\n<tr>\n<td>CP</td>\n<td>Compare</td>\n</tr>\n<tr>\n<td>CPD</td>\n<td>Block Search</td>\n</tr>\n<tr>\n<td>CPDR</td>\n<td></td>\n</tr>\n<tr>\n<td>CPI</td>\n<td></td>\n</tr>\n<tr>\n<td>CPIR</td>\n<td></td>\n</tr>\n<tr>\n<td>CPL</td>\n<td>Complement Acc</td>\n</tr>\n<tr>\n<td>DAA</td>\n<td>Decimal Adjust</td>\n</tr>\n<tr>\n<td>DEC</td>\n<td>Decrement</td>\n</tr>\n<tr>\n<td>DI</td>\n<td>Disable Interrupts</td>\n</tr>\n<tr>\n<td>DJNZ</td>\n<td>Dec B Jump Non Zero</td>\n</tr>\n<tr>\n<td>EI</td>\n<td>Enable Interrupts</td>\n</tr>\n<tr>\n<td>EX</td>\n<td>Exchange</td>\n</tr>\n<tr>\n<td>HALT</td>\n<td>HALT</td>\n</tr>\n<tr>\n<td>IM</td>\n<td>Set Interrupt Mode</td>\n</tr>\n<tr>\n<td>IN</td>\n<td>Input from port</td>\n</tr>\n<tr>\n<td>INC</td>\n<td>Increment</td>\n</tr>\n<tr>\n<td>IND</td>\n<td></td>\n</tr>\n<tr>\n<td>INDR</td>\n<td>Block Input</td>\n</tr>\n<tr>\n<td>INI</td>\n<td></td>\n</tr>\n<tr>\n<td>INIR</td>\n<td></td>\n</tr>\n<tr>\n<td>JP</td>\n<td>Jump</td>\n</tr>\n<tr>\n<td>JR</td>\n<td>Jump Relative</td>\n</tr>\n<tr>\n<td>LD</td>\n<td>Load (Data Movement)</td>\n</tr>\n<tr>\n<td>LDD</td>\n<td></td>\n</tr>\n<tr>\n<td>LDDR</td>\n<td>Block Load</td>\n</tr>\n<tr>\n<td>LDI</td>\n<td></td>\n</tr>\n<tr>\n<td>LDIR</td>\n<td></td>\n</tr>\n<tr>\n<td>NEG</td>\n<td>Negate Acc</td>\n</tr>\n<tr>\n<td>NOP</td>\n<td>No operation</td>\n</tr>\n<tr>\n<td>OR</td>\n<td>Logical OR</td>\n</tr>\n<tr>\n<td>OTDR</td>\n<td>Block Output</td>\n</tr>\n<tr>\n<td>OTIR</td>\n<td></td>\n</tr>\n<tr>\n<td>OUT</td>\n<td>Output to port</td>\n</tr>\n<tr>\n<td>OUTD</td>\n<td>Block Output</td>\n</tr>\n<tr>\n<td>OUTI</td>\n<td></td>\n</tr>\n<tr>\n<td>POP</td>\n<td>Data from stack</td>\n</tr>\n<tr>\n<td>PUSH</td>\n<td>Data to stack</td>\n</tr>\n<tr>\n<td>RES</td>\n<td>Reset Bit</td>\n</tr>\n</tbody>\n</table>\nRET Return from subroutine \nRETI Return from interrupt \nRETN Return from NMI \nRL Rotate Left \nRR Rotate Right \nRST Restart \nSBC Subtract with carry \nSCF Set Carry Flag \nSET Set Bit \nSLA Shift left arithmetic \nSRA Shift right arithmetic \nSRL Shift right logical \nSUB Subtract \nXOR Exclusive OR\n\nThe full list of mnemonics is given in Appendix B.\n\nThe source and destination are represented in a similar manner to the symbolism outlined in section 3.5. Registers and register pairs are represented by their letters; A, B, HL etc. Store locations are represented by brackets ( ). We thus get:\n\nLD A, D Load register A with the contents of register D \nLD (HL), A Load the store location whose address is held in register pair HL with the contents of register A (register indirect addressing) \nADD B Add the contents of register B to the contents of register A (all arithmetic operation results go to register A, so the destination is not specified) \nSUB 15 Subtract decimal 15 from register A (Immediate addressing) \n\nAll numbers in an assembler source program are assumed to be in decimal. Hex numbers are usually preceeded by a Pound (£) sign.\n\n1972 is thus a decimal number \n£1972 is thus a hexadecimal number\nSome advanced assemblers also allow representation of numbers in octal (base 8) or binary, but these are rather uncommon.\n\nLabels can also be used with the mnemonics to specify store locations as explained in the previous section.\n\nAppendix B gives all the instruction mnemonics used by Z-80 assemblers.\n\n5.2.5 Comments\n\nComments are usually preceded by a ; to tell the assembler where the instruction mnemonic finishes and the comment starts (cf. the REM in BASIC). Comments, although optional should be used liberally and intelligently. In particular, the comments should say what the instruction is doing, and not be just an expanded version of the mnemonic. For example:\n\n120 SETUP LD HL, £0C50; START OF STRING 0C50\n130 LD B, 36 ; 36 CHARACTERS TO BE SENT\n\nmeans a lot more than a simple\n\n120 SETUP LD HL, £0C50 ; LOAD HL WITH £0C50\n130 LD B, 36 ; LOAD B WITH 36\n\nThe only problem with comments is that (like all the source program) they have to be stored in the computer prior to assembly. Extensive comments will cause the source program to occupy considerably more store than the resulting object program. This could be a problem in computers with a small store.\n\n5.3 PSEUDO OP CODES\n\nAppendix B defines all the mnemonics corresponding to the Z-80 machine code instructions. In addition to these, assemblers have several pseudo mnemonics which are directions to the assembler itself rather than Z-80 instructions. These are known as pseudo op codes, and are used to indicate\nwhere the object code program is to be placed in memory, load alphanumeric strings (i.e. messages) directly and similar operations.\n\nThe first of these pseudo op codes is ORG for Origin, which indicates to the assembler where the object program is to start. For example, with\n\n```\n100 ORG £4000 ; PROGRAM STARTS 4000\n110 PROG LD A,£FF;MAKE A MINUS ONE\n```\n\nThe ORG instruction tells the assembler that the program is to be loaded from Hex 4000 onwards. The LD A,£FF (3E FF) will go into locations 4000 and 4001, followed by the rest of the program.\n\nSeveral ORG statements can be used in one program.\n\nThe second pseudo op code is EQU, for Equate, which is used to equate a label and a value.\n\nAn example of the use of EQU occurs where useful subroutines are provided in the ROM of the computer. Let us assume that there is a keyboard reading subroutine in the ROM at Hex 01AF. We would put somewhere at the start of the source program:\n\n```\n(line number) KBD EQU £01AF\n```\n\nThereafter, when we wish to call the keyboard subroutine we simply write:\n\n```\n(line number) CALL KBD\n```\n\nwhich the assembler interprets as CALL £01AF. Note how the use of the label KBD assists the comprehensibility.\n\nDEFS (for define space) is the third pseudo op code, and is used to reserve a number of store locations. For example, with:\n\n```\n320 JP KBD\n330 SPARE DEFS £100; 100 PLACES FOR DATA\n340 CALL LOOP\n```\nthe assembler will leave Hex 100 locations between the jump instruction and the subroutine call.\n\nDEFM (for define message) allows the user to load ASCII values direct from the keyboard. For example:\n\n100 ORG $3000\n110 DATA DEFM \"ABCD\"\n\nwill put Hex 41 into location 3000 (i.e. ASCII A)\nHex 42 into location 3001 (i.e. ASCII B)\nHex 43 into location 3002 (i.e. ASCII C)\nHex 44 into location 3003 (i.e. ASCII D)\n\nDEFM is very useful for loading fixed messages.\n\nDEFB (define byte) and DEFW (define word) allow the user to define an 8 bit byte or a 16 bit word respectively.\n\nSuperficially these are similar to EQU, but the DEF instructions cause data to be loaded as part of the program, whereas the EQU has no action outside of the assembler.\n\n5.4 ASSEMBLER DIRECTIVES\n\nDirectives are instructions to the assembler (in the same way as LIST, RUN, EDIT etc. are directives in BASIC). There are, of course, differences between assemblers on different machines, but most will have the following:\n\ni. Enter a source program\nii. List a source program to VDU or printer\niii. Edit a source program (add, delete or modify lines)\niv. Search for a specific instruction\nv. Renumber a source program (i.e. put all the line numbers in increments of ten)\nvi. Assemble the source program to produce an object program which can be sent to tape, disc or printer or placed directly in the store if space permits.\n\nThese directives are selected by keywords from the keyboard in a similar manner to BASIC.\n5.5 USING AN ASSEMBLER\n\nTo demonstrate how an assembler is used, we shall write a small subroutine using a Z-80 assembler called ZEAP on a Nascom microcomputer. The subroutine is a simple Bubble Sort which sorts data in successive store locations into numerical order. First let us describe the subroutine operation.\n\nThe subroutine is entered with register pair HL containing the first address of the data to be sorted, and register C containing the number of items to be sorted. The data is to be left in the original area of store after the sort has been completed, with the smallest number in the lowest store location.\n\nA bubble sort is the simplest and least efficient method of performing a sort, but is relatively easy to understand. The algorithm for a bubble sort can be expressed:\n\ni. Set Marker = 0\nii. Go through the list comparing adjacent pairs. If a pair is in the wrong order interchange them and set Marker = 1\niii. Repeat step ii. until the end of the list\niv. If, at the end of the list, Marker = 1 go back to step i. If Marker = 0 (indicating no changes have been made) the sort is complete\n\nThe algorithm might be a bit indigestible for a first reading, and is given in flowchart form in Fig.5.1.\n\nWe must now convert this simply expressed flow chart to a machine code program. The routine is entered with the address of the first item in the list held in register pair HL, and the number of items held in register C. The list is accessed using indexed addressing. The items for comparison are held in registers A and E. Register B is used as a counter to see if all the list has been tested (this allows the useful DJNZ (Dec B jump not zero) instruction to be used. Bit 0 in register H is used as the marker to indicate if an exchange has occurred and another pass through the list is required.\n\nThe general flow chart of Fig.5.1 is redrawn in a form suitable for machine code programming on Fig.5.2. This can be converted more or less directly to an assembler source program as follows. The reader should carefully compare this\n\n96\nFig. 5.1 Flowchart for bubble sort\nwith Fig. 5.2 before reading further.\n\n```assembly\n0010 ;*** BUBBLE SORT ROUTINE ***\n0020 ;ENTER WITH FIRST ITEM ADDRESS IN HL\n0030 ;NUMBER OF ITEMS IN C (2 TO 255)\n0040 ;EXIT WITH:\n0050 ;ITEMS SORTED IN SAME STORE BLOCK\n0060 ;HL AND C UNCHANGED\n0070 ;REGISTERS A B E IX USED\n0080 ;OTHER REGISTERS UNCHANGED\n0090 ;\n0100 SORT ORG £5000; ADDRESS FOR ROUTINE\n0110 LD (FIRST), HL; SAVE ADDRESS TO FREE H\n0120 MAIN RES MARK, H; CLEAR EXCHANGE MARKER\n0130 LD B, C; SET UP COUNTER FOR TESTS\n0140 DEC B; COMPARISONS 1 LESS THAN ITEMS\n0150 LD IX, (FIRST); SET IX TO START OF LIST\n0160 NEXT LD A, (IX+0); GET FIRST OF PAIR\n0170 LD E, (IX+1); GET SECOND OF PAIR\n0180 CMP E; COMPARE THEM\n0190 JR NOEX-; EXCHANGE NEEDED?\n0200 LD (IX+0), E; YES, PUT BACK EXCHANGED\n0210 LD (IX+1), A; DITTO\n0220 SET MARK, H; MARKER SHOWS EXCHANGE MADE\n0230 NOEX INC IX; SET IX FOR NEXT PAIR\n0240 DJNZ NEXT-; JUMP BACK IF NOT END LIST\n0250 BIT MARK, H; END REACHED, EXCHANGE MADE?\n0260 JR NZ, MAIN-; GO BACK IF EXCHANGE MADE\n0270 LD HL, (FIRST); SORT DONE, RESTORE HL\n0280 RET; EXIT FROM SUBROUTINE\n0290 ; DEFINITIONS\n0300 MARK EQU 8; NAME FOR EXCHANGE MARKER\n0310 FIRST DEFS 2; TEMP STORE FIRST ADDRESS\n0320 ;\n0330 ;\n0340 ;\n0350 ;\n0360 ;\n0370 ;\n0380 ;\n0390 ;\n```\n\nThe above listing has three errors in it; two grammatical that the assembler will reject as not being a valid instruction. The third is a logical error. As written the routine will not perform a bubble sort correctly under all conditions. “Unaware” of these errors let us see how the program operates.\n\nLines 10 to 90 are simply comments to explain the routine and the registers is uses. This is essential if the routine is to be held as part of a subroutine library. Line 100 says where the routine is to go in the store, and is given a label SORT so that a main program could simply CALL SORT.\n\nLine 110 saves the list start address in a store location called FIRST, defined in line 310. The exchange occurred marker is actually bit 0 in register H and this is cleared at line 120.\n\n98\nFig. 5.2 Detailed bubble sort flow chart\nThe counter to see when the end of the list is reached is held in register B to allow the DJNZ instruction to be used. Lines 130 and 140 initialise B. The number of comparisons is one less than the number of items, hence the need for line 140.\n\nThe index register IX is used to address the list, and this is initialised at line 150. Lines 160 and 170 bring pairs from the list which are compared at line 180. Line 190 skips lines 200 to 220 inclusive if no exchange is needed. If an exchange is needed, lines 200 and 210 put the data back in the list reversed and line 220 sets the exchange marker.\n\nLine 230 increments the index register ready for the next pair, and the counter in B is decremented at line 240. If the end of the list has not been reached, we jump back to line 160 (the label NEXT) for the next pair.\n\nAt the end of the list we look at the exchange marker at line 250. If this is set, line 260 takes us back to line 220 (the label MAIN) for another pass through the list.\n\nWhen the list has been sorted, line 270 puts HL back to the address at the start of the (now sorted) list so the routine exits with registers C and HL unaltered.\n\nLines 300 and 310 define labels. Line 300 says that MARK means 0, so we can say, for example, SET MARK, H rather than the less obvious SET 0, H. Line 310 reserves two locations with the labels FIRST (used to hold the start address of the list).\n\nThe first step in using an assembler is to load the assembler itself from tape or disc (or call it if you are lucky enough to have an assembler resident in ROM). The source program is then typed in.\n\nIt is a good idea to immediately save the source program on tape, to prevent teeth gnashing if the computer crashes or the mains fails during testing.\n\nWith the protection of a back up source program, we now ask the assembler to convert the source program to a machine code object program. Not surprisingly, this is known as assembling. In our case we get:\nThis indicates that we have grammatical errors in our program. Different assemblers indicate errors in different ways, but ZEAP uses error codes.\n\nOn line 160 an error 30 was given. This indicates a label not found. In fact, IX + 0 has been incorrectly entered with letter O instead of a figure 0. The assembler has looked unsuccessfully for a label letter O. A typical typing error.\n\nOne line 180 we have error 20. This indicates that the assembler could not recognize the mnemonic. The correct mnemonic for compare is CP not CMP. A typical pilot error.\n\nWith these errors corrected, we ask for another assembly which gives\n\n```assembly\n0010: *** BUBBLE SORT ROUTINE ***\n0020: ; ENTER WITH FIRST ITEM ADDRESS IN HL\n0030: ; NUMBER OF ITEMS IN C (2 TO 255)\n0040: ; EXIT WITH:\n0050: ; ITEMS SORTED IN SAME STORE BLOCK\n0060: ; HL AND C UNCHANGED\n0070: ; REGISTERS A, B, E IX USED\n0080: ; OTHER REGISTERS UNCHANGED\n0090:\n\n5000: ORG $5000, ADDRESS FOR ROUTINE\n5000 222850 0110 LD (FIRST), HL; SAVE ADDRESS TO FREE H\n5003 C884 0120 MAIN RES MARK, H; CLEAR EXCHANGE MARKER\n5005 41 0130 LD B, C; SET UP COUNTER FOR TESTS\n5006 05 0140 DEC B; COMPARISONS 1 LESS THAN ITEMS\n5007 D22A2850 0150 LD IX, (FIRST); SET IX TO START OF LIST\n5008 DD7E00 0160 NEXT LD A, (IX+0); GET FIRST OF PAIR\n500E D5E8E1 0170 LD E, (IX+1); GET SECOND OF PAIR\n5011 B8 0180 CP E; COMPARE THEM\n5012 3000 0190 JR NC NOEX-, EXCHANGE NEEDED?\n5014 DD7300 0200 LD (IX+0), E; YES, PUT BACK EXCHANGED\n5017 DD7F01 0210 LD (IX+1), A; DITTO\n501A CBC4 0220 SET MARK; H; MARKER SHOWS EXCHANGE MADE\n501C D023 0230 NOEX INC IX; SET IX FOR NEXT PAIR\n501E 10E8 0240 DJNZ NEXT-, JUMP BACK IF NOT END LIST\n5020 CB44 0250 BIT MARK; H; END REACHED; EXCHANGE MADE?\n5022 28DF 0260 JR NZ, MAIN-; GO BACK IF EXCHANGE MADE\n5024 2A2950 0270 LD HL, (FIRST); SORT DONE; RESTORE HL\n5027 C9 0280 ; EXIT FROM SUBROUTINE\n0280 ; DEFINITIONS\n0000 0300 MARK EQU 0; NAME FOR EXCHANGE MARKER\n0002 0310 FIRST DEFS 2; TEMP STORE FIRST ADDRESS\n0320 ;\n0330 ;\n```\n\nThis produced no errors, so it is a legitimate source program. This does NOT mean it will necessarily do what we want, it simply means there are no grammatical errors (as men-\ntioned earlier, there is a logical error in the program which we will discover later).\n\nThe print out gives us for each source line in order from left to right:\n\ni. The store location an instruction is stored at\nii. The actual Hex object code\niii. The source line number\niv. Label (if present)\nv. The instruction mnemonic or pseudo op code.\nvi. Comments (if present)\n\nThe reader should check the object code against the tables in the previous chapter to see that the method works! It is also useful in getting a ‘feel’ for the operation.\n\nWe now need to test our routine. Before we can do this we need to discuss the debugging aid known as a “Monitor”.\n\n5.6 MONITORS AND BUGS\n\n5.6.1 Introduction\n\nAn assembler allows machine code programs to be written, but does not allow them to be run or tested. To do this we need another programming aid known as a Monitor or Bug.\n\nA monitor is a small program (typically 1 — 2K) that allows the programmer to examine the store and register contents and check a program by stopping it at a strategic point or running a program with a pause between each instruction (known as single stepping).\n\nA monitor can exist in ROM (as does the Nascom NASBUG and NASYS monitors) or be loaded via tape (as the TRS-80 T-BUG). Monitors are often called BUGs because they are used to de-bug a program.\n\nThe facilities offered by different monitors vary considerably, but all will have the following (although the terms used may differ). The examples below are for a NASBUG monitor.\n5.6.2 Modify\n\nThis allows the programmer to examine (and if necessary modify) a store location. If, for example, the programmer wanted to examine location 0C50, he would type:\n\nM 0C50 Newline;\n\nand the computer would reply:\n\n0C50 A5\n\nmeaning location 0C50 contains Hex A5. The programmer can now type in a new value to go into the location. It is thus possible to load a whole machine code program in Hex by the modify command, although it is more usually applied for small corrections.\n\n5.6.3 Execute\n\nThis option is used to start a machine code program. The user types E followed by the start location.\n\nE F600 Newline\n\nwill execute a machine code program starting at location F600. Note that this is a \"Kamikaze\" dive into a program, and unlike BASIC could easily corrupt the store if the program contains an error.\n\n5.6.4 Breakpoint\n\nThis option stops the program at a pre-determined point and displays the register contents. It is an invaluable aid for fault finding. The breakpoint is set by typing B followed by the locations.\n\nB 1A 92 Newline\n\nwill set the breakpoint at location 1A92. The register display on a NASBUG is:\n\n<table>\n<thead>\n<tr>\n<th>SP</th>\n<th>PC</th>\n<th>AF</th>\n<th>HL</th>\n<th>DE</th>\n<th>BC</th>\n<th>I</th>\n<th>IX</th>\n<th>IY</th>\n<th>Flags</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<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n103\nso a typical display for B1002 could be\n\n1000 1002 C59A 7C80 817E 7A81 00 234D 0FFE SHN\n\nshowing that register A, for example, contains Hex C5.\n\nThe usefulness of the breakpoint cannot be overemphasised.\n\n5.6.5 Tabulate\n\nThe tabulate function displays the store contents between two specified points, with a NASBUG:\n\nT 3000 3040 Newline\n\nCould produce\n\n```plaintext\n> T 3000 3040\n3000 3E 01 0E 05 81 07 FE 1F\n3002 C2 20 30 CD 69 00 DD E1\n3010 30 F7 FE 1F 28 0F DD E5\n3018 CD 3B 01 DD E1 DD 77 00\n3020 DD 23 0C 19 E4 21 00 40\n3028 CD 00 50 21 00 40 41 7E\n3030 CD 3B 01 23 10 F9 18 C0\n3038 FF 00 FF 00 FF 00 FF 00\n```\n\nThe first few instructions are actually:\n\n```plaintext\n3000 0010 ORG €3000\n3000 3E01 0020 LD A.1; ONE IN REGISTER A\n3002 0E05 0030 LD C.5; FIVE IN REGISTER C\n3004 81 0040 ADD A,C; ADD REGISTERS A AND C\n3005 07 0050 RLCA ; ROTATE REGISTER A\n3006 FE1F 0060 CP E1F; COMPARE REGISTER A WITH HEX 1F\n3008 C22030 0070 JP NZ,E3020; JUMP TO HEX 3020 IF NON Z\n```\n\nwhich should correspond with the listing.\n\n5.6.6 Single Step\n\nSingle step is similar to Execute, except that the computer pauses between each instruction and displays the register contents with the same layout as the breakpoint display. A typical display might be:\nThe above steps are actually the instructions above. The reader should check the register contents against the program at each stage.\n\n5.6.7 Conclusion\n\nThe five functions described above are provided on all monitors. Other functions commonly available are write a program to tape or disc, read a program from tape or disc, search for a specified data string, copy data from one part of the store to another. The instruction manuals should be consulted for specific details.\n\nIt is possible to write, check and run machine code programs with a monitor only. It is not possible to check machine code programs with just an assembler. Although ideally an assembler and monitor should be obtained, if funds are tight, a monitor alone will suffice.\n\nSome machines (such as the NASCOM) come with a monitor already provided in ROM.\n\n5.7 TESTING A MACHINE CODE PROGRAM\n\nIn section 5.5 we wrote a bubble sort subroutine. We will now write a small program to test it. This program will take a series of characters from the keyboard and store them. The characters are then sorted by our subroutine and displayed, sorted, on the VDU screen. Alphanumeric characters are obtained from the keyboard in Hex (A is 41H, B is 42H etc.) so they\nwill be sorted into alphabetical order. The test program can be represented in simple form by the flow chart of Fig.5.3.\n\nMost monitors contain useful subroutines that can be called by the users program. In a NASBUG we have:\n\ni. Keyboard at Hex 0069. This returns with the carry flag set and the Hex code for the character in register A if a key has been pressed. If no key is pressed, the subroutine returns with the carry flag reset.\n\nii. CRT at Hex 013B. This takes the contents of register A and displays the equivalent character on the VDU.\n\nThese two NASBUG routines allow us to produce the detailed flow chart of Fig.5.4 which becomes the source program below:\n\n```\n0400 ;TEST PROGRAM FOR BUBBLE SORT\n0410 KBD EQU $69;NASBUG KEYBOARD ROUTINE\n0420 CRT EQU $13B;NASBUG CRT ROUTINE\n0430 SORT EQU $5800;BUBBLE SORT ROUTINE\n0448 ;\n0450 ORG $3000\n0460 LD SP $5FFF;SETUP STACK POINTER\n0470 BEG LD C,0;CLEAR C FOR COUNTER\n0480 LD IX,$4000;STRING TO GO FROM 4000\n0482 INP PUSH IX;IX USED IN KBD ROUTINE\n0490 CALL KBD;GET CHARACTER\n0494 POP IX;GET IX BACK AFTER KBD ROUTINE\n0500 JR NC INP-#;JUMP BACK NO KEY PRESS\n0510 CP $1F;WAS CHARACTER NEW LINE?\n0520 JR Z BUBB-#;IF SO GOTO BUBBLE SORT\n0522 INP IX;IX USED IN CRT ROUTINE\n0530 CALL CRT;DISPLAY CHARACTER\n0534 POP IX;GET IX BACK AFTER CRT ROUTINE\n0540 LD (IX),A;STORE IT\n0550 INC IX;READY FOR NEXT CHARACTER\n0560 INC C;INC CHARACTER COUNTER\n0570 JR INP-#;GET NEXT CHARACTER\n0580 ;\n0590 ;\n0600 BUBB LD HL,$4000;START ADDRESS OF LIST\n0610 CALL SORT\n0620 ;\n0630 ;\n0640 ;DISPLAY SORTED LIST\n0650 LD HL,$4000;START OF SORTED LIST\n0660 LD B,C;NUMBER IN LIST FOR COUNT\n0670 LP LD A,(HL);GET CHARACTER FOR DISPLAY\n0680 CALL CRT;AND DISPLAY IT\n0690 INC HL;NEXT ADDRESS\n0700 DJNZ LP-#;END OF LIST?JUMP BACK IF NO\n0710 JR BEG-#;GO BACK FOR ANOTHER LIST\n```\n\nNote that the line numbers follow on from the bubble sort routine in section 5.5 so that the subroutine and the test\nFig. 5.3 Flow chart for bubble sort test program\nHousekeeping:\nLd IX with Hex 4000\nSet up stack pointer\nClear register C\n\nIX pointer to next item in list, starts at Hex 4000. Reg C counts number of items\n\nCall KBD\n\nKey pressed?\n\nNo\n\nYes\n\nWas it Newline?\n\nNo\n\nCall CRT\n\nAdd character to list\n\nIncrement pointer & counter\n\nA\n\nKBD is routine in Nasbug which scans keyboard & returns with character in reg A\n\ni.e. jump on requisite flag\n\ni.e. compare “Newline” & jump on requisite flag\n\nCRT is routine in Nasbug which displays character in A on VDU\n\ni.e. (IX + 0) ← A\n\ni.e. inc IX\ninc C\n\nFig. 5.4 (a) Detailed flow chart for bubble sort test program\nSet HL to Hex 4000\n\nCall SORT\n\nSet HL to 4000\nSet B to number of items\n\nNext character to A\n\nCall CRT\n\nIncrement pointer\n\n---\n\nList now entered\n\n4000 is start of list\n\ni.e. Call fig. 5.2\n\nList now sorted\n\nHL used as pointer\nB used as pointer\n\ni.e. A ← (HL)\n\nNasbug routine as above\n\ni.e. inc HL\n\ni.e. decrement counter B & jump if non zero DJNZ\n\nFig. 5.4 (b)\nprogram can be assembled together.\n\nThe program is relatively straightforward. The input portion occupies lines 400 - 570 and the output portion lines 640 - 710. Between these we call the bubble sort routine. The first lines define the labels KBD and CRT to call the NASBUG routines and say where the test program is to go (Hex 3000).\n\nA character is obtained from the keyboard at lines 482 - 500, and stored using indexed addressing in locations from 540. Register C is used to count how many characters have been input. When a newline character is detected, the bubble sort routine is called. A typed character is displayed at line 530.\n\nThe output routine works up the sorted list using register indirect addressing, sending characters to the Nasbug CRT routine to display them. Register B is used as a counter.\n\nThe test program and routine are assembled together, and the assembler directed to load the resulting object program to store and to tape (the latter as a precaution in the not unlikely event that a programming error causes the computer to crash. Remember, unlike BASIC, a machine code program can self destruct). We now have:\n\n```\n0010 ;*** BUBBLE SORT ROUTINE ***\n0020 ;ENTER WITH FIRST ITEM ADDRESS IN HL\n0030 ;NUMBER OF ITEMS IN C (2 TO 255)\n0040 ;EXIT WITH\n0050 ;ITEMS SORTED IN SAME STORE BLOCK\n0060 ;HL AND C UNCHANGED\n0070 ;REGISTERS A B E IX USED\n0080 ;OTHER REGISTERS UNCHANGED\n5000\n0100 SORT ORG 5000, ADDRESS FOR ROUTINE\n5000 222050 0110 LD (FIRST), HL, SAVE ADDRESS TO FREE H\n5003 CB84 0120 MAIN RES MARK.H; CLEAR EXCHANGE MARKER\n5005 41 0130 LD B, C; SET COUNTER FOR TESTS\n5006 05 0140 DEC B, COMPARISONS 1 LESS THAN ITEMS\n5007 DD2A2850 0150 LD IX, (FIRST), SET IX TO START OF LIST\n500B DD7E00 0160 NEXT LD A, (IX+0), GET FIRST OF PAIR\n500E DD5E01 0170 LD E, (IX+1), GET SECOND OF PAIR\n5011 BB 0180 CP E, COMPARISON THEM\n5012 3008 0190 JR NC NOEX-$, EXCHANGE NEEDED?\n5014 DD7300 0200 LD (IX+0), E, YES, PUT BACK EXCHANGED\n5017 DD7701 0210 LD (IX+1), A, DITTO\n501A CBC4 0220 SET MARK.H; MARKER SHOWS EXCHANGE MADE\n501C DD23 0230 NOEX INC IX, SET IX FOR NEXT PAIR\n501E 18EB 0240 DJNZ NEXT-$, JUMP BACK IF NOT END LIST\n5020 CB44 0250 BIT MARK.H; END REACHED, EXCHANGE MADE?\n5022 28DF 0260 JR NZ. MAIN-$, GO BACK IF EXCHANGE MADE\n5024 2A2850 0270 LD HL, (FIRST), SORT DONE, RESTORE HL\n```\n\n110\nTo run this, we call up the monitor and type E3000 to enter our test program. As expected we get the VDU prompt from the KBD routine. Full of optimism we type:\n\n```\nQWERTYUIOP\n```\n\nand on the screen comes:\n\n```\nEIOPRTUQWY\n```\n\n**WHICH IS WHAT WE WOULD EXPECT.** We now try:\nNothing happens. The computer does not reply with a sorted string (or for that matter anything). Our logical bug has surfaced.\n\nExamining the store with the monitor tabulate function shows the store to be uncorrupted. The program is run again with the breakpoint set for the first location in the output portion of the test program (i.e. B 302B). Running the program again, we find that the breakpoint is not reached; the bubble sort routine is tied up in a permanently running loop.\n\nFurther checks with the breakpoint shows that the bubble sort routine does not work correctly where there are duplicate characters. As written it will sort D F A X Y but not D F F A X Y. In the original source program, the test at line 190 not only exchanges numbers that are out of order, but also exchanges numbers that are the same. A list with duplicates will therefore never finish; the routine will continue for ever interchanging the duplicates!\n\nThis can easily be cured. If we add a line 195, to the source program to jump to NOEX if the characters are the same, the routine will not run for ever with duplicate numbers. The assembler is instructed to re-assemble the source program, (and takes care of all the new locations and relative jumps).\nThe resulting program is tested as before. This time:\n\nTHE QUICK BROWN FOX\n\nnewline\ngives:\n\nBCEFHIKNOOQRTUWX\n\nNote the four spaces come at the start of the sorted list.\n\n5.8 CONCLUSION\n\nThe writing and testing of our bubble test program should serve to show the basics of assembly language programming. There are dialect variations between different assemblers, so it is advisable to check carefully how individual assemblers and monitors differ from those described above.\n\nA bubble sort is rather an inefficient way of sorting, and the routine above has been written for ease of comprehension rather than speed or elegance. It would be a useful exercise for the reader to consider how faster sort routines could be implemented.\nChapter Six\n\nINTERFACING THE Z-80\n\n6.1 INTRODUCTION\n\nTo be useful, a computer must be able to communicate with the outside world. At the simplest level we need to be able to input from a keyboard and cassette recorder, and output to a TV screen and tape recorder. More ambitious systems will have printers, discs and possible control external items such as laboratory experiments or industrial plant.\n\nIn this chapter we will describe how the Z-80 communicates with its external devices.\n\n6.2 SERIAL AND PARALLEL COMMUNICATION\n\nAll communication between micros and the outside world takes place in the form of 8 bit words. If the data is alphanumeric, the 8 bits will usually represent a character in the ASCII code (see Appendix C). If the data is used in instrumentation the 8 bits will represent the value of a variable such as temperatures or pressure. If the data is being used for control, individual bits in the word will be used to represent the states of limit switches, valves, lamps etc.\n\nIf we are to send 8 bit words from place to place, there are two methods we can use. In Fig. 6.1a we simply send the data down 8 wires simultaneously. This is known as parallel transmission and is (in essence) the method used inside a microcomputer. It can, of course, be used to transmit data outside the computer.\n\nIn Fig. 6.1b the data is sent as a serial pulse train down a single wire. This is known as serial transmission. Obviously, serial transmission is slower, but cheaper, than parallel transmission.\n\nInternally, all data movement in a microcomputer is done in parallel. I/O ports therefore communicate with the\nFig. 6.1 (a) Parallel & (b) Serial data transmission\ncomputer in parallel. If serial communication is being used, some form of parallel/serial and serial/parallel logic is required as shown on Fig. 6.2. This is really little more than an 8 bit shift register with some control logic. Fig. 6.2 is usually implemented with a device called a UART (for Universal Synchronous Receiver Transmitter) or SIO (for Serial Input Output). These are described further in section 6.6.\n\n6.3 PORT ADDRESSING AND LOGIC\n\nThe fundamentals of port addressing was outlined in section 1.5. I/O addressing is done via bits 0 – 7 of the address bus, allowing 256 port addresses in the range 0 – 255. A control signal IORQ is used to indicate that an address is a port address rather than a store address. The data direction signal RD is used to indicate whether an input or output is required.\n\nA simple parallel output port can therefore be constructed along the lines of Fig. 6.3. The bottom 8 bits of the address bus are decoded by some logic decoder (such as a 74138) to give a port select signal. This is gated with the timing signals to produce a clock signal for the 8 D types flip flops. The data on the data bus is stored in the D types for use by the device connected to the port.\n\nA simple parallel input port is shown on Fig. 6.4. Data from the device is gated into the 8 D types by a strobe signal. This strobe can be generated by the device itself (e.g. an ADC saying it has completed its digitisation (see Section 6.9) ) or by the computer wanting a ‘snapshot’ of the port state (e.g. reading limit switch states on an industrial control application). This loading of the D types can take place at any time and need not necessarily involve the computer.\n\nThe state of the D types is read into the processor by the rest of the logic. The port address is decoded and gated with the timing signals to enable the 8 tristate buffers. The data from the D types is then available on the data bus for use by the processor.\n\nIt is possible to construct ports with discrete logic similar to Figs. 6.3 and 6.4, but it is usually simpler to use the ICs\nFig. 6.2 Parallel/serial/parallel conversion\nFig. 6.3 Simple parallel output port\nFig. 6.4 Simple parallel input port\ndesigned specifically for the I/O applications. The Z-80 PIO chip is described in section 6.5.\n\n6.4 INTERRUPTS\n\n6.4.1 Introduction\n\nThere is a vast speed difference between a microcomputer and even a high speed printer. If, say, the computer is to send a string of characters to the printer, some method must be used to inform the computer when the last character has been printed and the printer is ready to accept the next character.\n\nA similar problem occurs where the computer is used for control purposes. If an alarm condition is required to be detected within, say, 0.2 seconds the corresponding input must be monitored every 0.2 seconds even though the alarm might only occur once every five years.\n\nA technique where the computer goes round its inputs at regular intervals seeing if the printer is ready for another character or an alarm condition has occurred is called “polling”. Although it is acceptable for small systems, polling ties up the processor in unnecessary operations. In larger systems it may be impossible to obtain the required response time by polling, as the time taken to poll and service inputs obviously increases with the number of inputs.\n\nThe ideal solution would allow a device requiring attention to signal directly to the processor without the need for polling. This is known, for obvious reasons, as an “interrupt”.\n\nWhen a device requires the attention of the processor, it requests an interrupt. The processor completes its current instruction and acknowledges the interrupt. The processor now identifies the interrupting device, and goes to a servicing routine. This is performed in a similar manner to a normal sub-routine, with the PC being pushed onto the stack.\n\nAt the completion of the servicing routine, the PC is restored from the stack, and the main program continues from the point at which the interrupt occurred.\n\nNormally an interrupt hierarchy is established to allow a\nmore urgent interrupt to interrupt a lower priority servicing routine. A typical sequence of events is shown on Fig. 6.5.\n\n6.4.2 Servicing an Interrupt\n\nThere are basically three different ways of responding to an interrupt, but all have the same objective of identifying the device initiating the interrupt, and calling the servicing routine.\n\nThe simplest method, used on early microprocessors, has a common interrupt servicing routine. When an interrupt occurs, this common routine polls all the devices (\"who said that?\") and then calls the correct servicing routine.\n\nThe 8080 uses a more elegant method. When the processor has pushed the PC onto the stack it acknowledges the interrupt request and releases control of the data bus. The interrupting device now forces an instruction onto the bus which is almost always a subroutine call to its servicing routine. The RST instructions (see section 4.9) are particularly useful for this purpose.\n\nThe Z-80 can use the simple \"who said that\" method, the 8080 method (for compatibility) and a powerful method of its own. The flexibility and sophistication of its interrupt handling is one of the Z-80's best features.\n\nThe Z-80's own method uses the 8 bit 'I' register. This contains the top 8 bits of a store address. When an interrupt is acknowledged, the device supplies the bottom 8 bits. The 16 bits together indicate two store locations which contain the address of the servicing subroutine. This operation sounds more complex than it actually is, and possibly is best summarised by Fig.6.6. The I register actually designates an area of store to be used as a table to hold the addresses of the interrupt service routine.\n\n6.4.3 Z-80 Interrupts\n\nThe Z-80 can handle interrupts in three different ways, called, not surprisingly, Mode 0, Mode 1, Mode 2. The mode is selected by control instructions (see table 4.15). The mnemonics for these are 'IM0', 'IM1', 'IM2'. Only one\n**Fig. 6.5 Interrupt servicing**\ninterrupt mode can be used at once.\n\nMode 0 is the 8080 mode. On receipt of an interrupt the Z-80 releases the data bus, then obeys an instruction provided by the device.\n\nMode 1 is the simple polled response. On receipt of an interrupt the processor calls a subroutine located at Hex 38. This address is \"built into\" the instruction.\n\nMode 2 is the Z-80's own powerful mode, and operates as outlined above. It should be apparent that the programmer must ensure the I register and address table are loaded correctly. We shall see in later sections how the interrupting device obtains its half of the data table address.\n\nThe interrupts described above are detected via pin 16 of the Z-80 CPU chip (see Fig. 2.7 and section 2.3). These are known as Maskable Interrupts because the programmer can enable or disable the processors response. This is achieved by two control instructions; Enable Interrupt '(EI)', and Disable Interrupts '(DI)'. (See table 4.15).\n\nThere is also another interrupt facility on the Z-80. Pin 17 provides a non maskable interrupt. As its name implies, a non maskable interrupt cannot be ignored by the CPU. Usually NMI is used for interrupt functions such as powerfail detection.\n\nAn NMI has only one response mode, a call to Hex 66. An NMI automatically disables the maskable interrupts to prevent its (presumably top priority) routine from being interrupted. A special \"return from non maskable interrupt\" instruction ('REIN') reinstates the status of the maskable interrupts after the NMI routine whilst returning the PC to its previous value.\n\nReturn from maskable interrupts should use the \"return from maskable interrupt\" instruction (RETI). This reinstates PC from the stack and allows further interrupts from lower priority devices. The normal subroutine return instruction (RET) should not be used to return from an interrupt service routine.\n\nThe timing and operation of an interrupt is shown, somewhat simplified form, on Fig. 6.7. The sequence starts by a device requesting an interrupt by pulling the wired OR INT line low. The CPU completes its current instruction then pulls\nMI low. This freezes the priority status, preventing further interrupts tripping over each other during the short time whilst the PC is put on the stack. After PC is put onto the stack, IORQ is taken low which signals to the device that the low byte for the address table is required. When this is provided the CPU jumps to the address provided by the table. IORQ and MI go back high and the service routine is being obeyed. The priority is unfrozen and further interrupts can take place. The interrupting device watches the data bus for a RETI instruction signifying the end of the service routine. When this occurs the device then allows interrupts from lower priority devices on the daisy chain.\n\nFig. 6.7 Simplified interrupt timing\n6.4.4 INTERRUPT PRIORITY\n\nThe priority of interrupting devices is determined by a simple daisy chain. Each port has an input called \"Interrupt Enable In\" and an output called \"Interrupt Enable Out\". The input allows the port to signal an interrupt. The output indicates if the port is currently engaged in an interrupt OR the port is disabled from interrupting by the enable input.\n\n\"Enable interrupt\" is high to enable, and the \"Interrupt Enable Out\" signal is low when the port is disabled or engaged in an interrupt. By daisy chaining these signals, as shown on Fig. 6.8, the priority increases to the left of the chain, port 6 having the highest priority, and port 1 the lowest. As drawn, port 4 is currently engaged in an interrupt, and ports 1,2,3 are disabled. An interrupt from port 5 or 6 would be allowed, and would interrupt the service routine for port 4.\n\n6.5 THE Z-80 PIO\n\n6.5.1 Introduction\n\nMost microprocessor manufacturers provide special IC’s to simplify the design of parallel ports. The Z-80 chip is known as a PIO (for parallel input output, what else?) and gives the user two 8 bit ports which can be configured to be input ports, output ports or bidirectional. Interrupt logic is also included.\n\nA block diagram of the Z-80 PIO is shown on Fig. 6.9. The PIO connects to the CPU via the usual address, data and control highways. External logic is required to decode the PIO address and select the chip via the chip enable input. We will describe the other control signals later.\n\nThe two ports are known as A and B. The ports can be used in four modes.\n\ni. Input, 8 bit input port with full handshake\nii. Output, 8 bit output with full handshake\niii. Bidirectional (port A only). The port responds to both input and output commands. This mode is used where\nFig. 6.8 Daisy chaining to determine priority\nFig. 6.9 PIO block diagram\nthe PIO feeds onto an external I/O bus in, for example, data logging applications. Full handshake is provided.\n\niv. Bit mode. The user specifies which bits in a port are to be inputs and which are to be outputs. These bits then respond respectively to input and output commands. No handshaking is provided.\n\nInterrupts can be generated on inputs or on the successful completion of an output. The “interrupt request” signal is given by an open collector output to give the single “interrupt request” to the processor. “Interrupt Enable” and “Interrupt in progress” operate as above.\n\nBefore the PIO can be used, therefore, the user has to perform a considerable setting up operation. Briefly, the user must specify for both A and B ports:\n\ni. The operating mode (as above)\n\nii. If Bit Mode is selected, which bits are inputs and which are outputs.\n\niii. If interrupts are to be used\n\niv. The interrupt conditions\n\nv. The interrupt table address low byte, known as the interrupt vector (see sections 6.4.2 and 6.4.3)\n\nThis information is loaded into the PIO at the start of the users program.\n\nThe PIO must obviously need to distinguish between set up data and data to be sent to the outside world. This is achieved by a control signal called “C/D select”. If this is high during an output command, the data on the data bus is interpreted as set up data in a manner described later. If the C/D select is low during an output command, the data on the data bus is passed onto the outside world.\n\nThe PIO also needs to be told if an input or output command is for the A port or the B port. A control signal called “A/B select” is provided for this purpose. If this input is high, port A is being used. If the input is low, port B is select.\n\nIt is usual to connect A/B select to bit A0 on the address bus and C/D select to bit A1 on the address bus, and decode bits A2 to A7 to select the PIO via the chip enable. On\nFig. 6.10 the chip is selected when A2 is high and A3 – A7 are low. The PIO then uses four addresses as below:\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Address</th>\n<th>Port</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>4</td>\n<td></td>\n<td>Port B</td>\n<td>data transfer</td>\n</tr>\n<tr>\n<td>5</td>\n<td></td>\n<td>Port A</td>\n<td>data transfer</td>\n</tr>\n<tr>\n<td>6</td>\n<td></td>\n<td>Port B</td>\n<td>set up data</td>\n</tr>\n<tr>\n<td>7</td>\n<td></td>\n<td>Port A</td>\n<td>set up data</td>\n</tr>\n</tbody>\n</table>\n\n6.5.2 Set Up Data\n\nThe PIO must be initialised before any data can be transferred. This involves several stages. First, an operating mode must be defined for port A and B. This is done by sending a control word for each port with the format in Fig. 6.11.\n\nBits D0 to D3 define that a mode is being selected, and bits D6, D7 define the mode. Bits D4, D5 are unused and are conventionally reset. We therefore have:\n\n<table>\n<thead>\n<tr>\n<th>M1</th>\n<th>M0</th>\n<th>Hex</th>\n<th>Mode</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0F</td>\n<td>output</td>\n</tr>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>4F</td>\n<td>input</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>8F</td>\n<td>bidirectional</td>\n</tr>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>FF</td>\n<td>bit</td>\n</tr>\n</tbody>\n</table>\n\nThe instructions to set port A to be an input port would therefore be (for the PIO in Fig. 6.10)\n\nLD A £4F ; 4F is the code for input mode\nOUT 7 ; Port 7 set up for port A\n\nWhen the bit mode is selected, a second set up word must be sent to define which bits are to be inputs and which are outputs. A ‘1’ means that the corresponding data bit will be used as an input. If, for example, we sent:\n\n1 0 1 1 0 0 1 1 (Hex B3)\n\nBits 0, 1, 4, 5 and 7 are inputs\nBits 2, 3 and 6 are outputs\n\nTo set up a bit mode operation with the above pattern we would write\nLD A, £FF ; Code for Bit Mode\nOUT 7 ; Port 7 set up for port A\nLD A, £B3 ; Directional data\nOUT 7 ; Set up direction of data lines\n\n6.5.3 Handshaking\n\nThere are two handshake lines with each port. Those are used to generate an interrupt when an output has been completed (output mode) an input is requested (input mode) or a specific bit pattern appears at the port as data.\n\nFig. 6.12 shows the timing for an output. At point A the composite WR* signal goes low to signal that new data is present and can be latched into the PIO. Shortly after the PIO changes the port output, WR* goes high again, and Ready goes high to signal to the peripheral device that new data is present (point B). When the device has accepted the data it takes the strobe line low (point D) and high (point E). This rising edge is used by the PIO to clear the Ready line and generate an interrupt.\n\nInput timing is shown on Fig.6.13. This operation is initiated\nFig. 6.13 Input handshaking & timing\nby the peripheral device which presents data to the input port and takes the strobe line low. This latches the data into the PIO. The rising edge of the strobe (point B) causes the Ready line to go low and an interrupt to be generated. When the CPU reads from the port, the composite signal $RD^*$ is generated inside the PIO, and the rising edge of this takes Ready high to signal to the peripheral device that another input can be made.\n\nBidirectional operation is simply a combination of input and output operation, but suffers from the restriction of a 40 pin chip. Bidirectional operation requires four handshake lines, two for input and two for output. Pin limitation means that only two handshake lines are provided per port. Bidirectional operation is therefore only available on port A, with port A handshakes used for the outputs, and port B handshakes for the inputs. Port B itself must be used in the bit mode which does not use handshaking. Care must obviously be taken with the peripheral device logic to ensure that it is not writing to a bidirectional port whilst the CPU is performing an output.\n\nIn bit mode, no handshaking is used. Data output from the CPU appears at the port output. An input from the port takes a \"snapshot\" of the inputs. The current state of output lines are read along with the input. Interrupts are generated on the presence of a predetermined bit pattern as described in the section following.\n\nIt should be noted that Figs.6.12 and 6.13, whilst adequate for most purposes, are slightly simplified in that the relationship to the clock signal are ignored. For full timing details the Z-80 PIO Technical Manual should be consulted.\n\n6.5.4 Interrupts\n\nTo use interrupts in the PIO we must set up the interrupt vector (see section 6.4.3). This is done by writing a set up word with the format of Fig.6.14. Bit 0 being a zero indicates that this set up data is an interrupt vector. The low byte of the table address is always zero.\n\nIf, for example, the I register in the Z-80 contained Hex 1D, and the user wrote to the PIO the set up word C4, the service address for the PIO would be found in location 1DC4\nIf input, output or bidirectional modes are being used, interrupts are generated automatically by the handshaking (see above). In the bit mode, an interrupt will be generated if a previously specified bit pattern occurs.\n\nTo do this, we first send an interrupt control word as Fig. 6.15. Bits 0 – 3 indicate that this is an interrupt control word. Bit 7 is used to enable and disable interrupts (1 to enable, 0 to disable). This control interrupts in all modes (input, output, bidirectional and bit). Bits 4–6 are only relevant in the bit mode. We will shortly be sending a bit pattern to indicate which bits we want to monitor for an interrupt. Bit 6 indicates if an interrupt is to be generated if ANY of the specified bits is present (called OR) or when ALL are present called (AND). If Bit 6 is a ‘1’ the AND operation is specified.\n\nBit 5 is used to indicate if the data lines are to be used to generate an interrupt when they are a ‘0’ or a ‘1’. If bit 5 is a ‘1’, interrupts will be generated when the specified bits go to a ‘1’, if bit 5 is an ‘0’, interrupts will be generated when the specified bits go to a ‘0’.\n\nIf bit 4 is a ‘1’, the next set up word MUST be a mask. A ‘0’\nFig. 6.15 Interrupt control word\nin this word means that the corresponding bit will be checked for generating an input in accordance with the conditions set up via Fig.6.15. If, for example, we sent the mask:\n\n\\[ 01100011 \\]\n\nwe would check for interrupts on bits 2, 3, 4 and 7.\n\n### 6.5.5 Set Up Summary\n\nThe procedure for setting up a PIO at first sight seems rather involved. Fig.6.16 shows the procedure in flow chart form, and hopefully will make the matter clearer. It should be remembered that usually only one set up is needed, and this should be placed at the start of the program.\n\n### 6.5.6 Power Up Problems\n\nAt power up, the PIO sets itself into a reset state. Usually, though, the PIO seems to end up in some indeterminate state due to glitches as the supplies come up. Often the PIO seems to set itself into the condition where it is expecting interrupt mask or a data direction word for mode 3. To be certain that a PIO is correctly initialised, a dummy set up data word should be sent to each port before following the procedure in Fig.6.16.\n\n### 6.5.7 Pinning\n\nThe PIO pin connections are shown on Fig.6.17. These operate as below:\n\ni. D0 – D7 Tristate Data Bus \nii. A/B Select. A low selects port A, a high selects port B. Usually connected to Address Bus A0. \niii. C/D Select. Determines whether data on the data bus is to be used as set up data, or port data. A high indicates that set up data is present. Usually connected to A1. \niv. CE Chip enable. Low to select the chip. Usually derived from external decoding logic connected to the address bus.\nFig. 6.16 Set-up summary for PIO\nNote: A, B are port outputs; A is NOT CPU data bus\n\n**Fig. 6.17 PIO pin connections**\n\nv. $\\phi$ System clock.\n\nvi. M1 Timing signal from the CPU used to synchronise the PIO.\n\nvii. IORQ Input/output request. When low indicates that the address bus refers to an I/O port.\n\nviii. RD Read. Used to indicate if an input or output is requested. When RD is low an input is required from the port.\n\nix. IE1 Interrupt Enable In. Part of the daisy chain. When high, interrupts are allowed.\n\nx. IEO Interrupt Enable Out. When low, blocks lower priority devices from generating an interrupt.\n\nxi. INT Interrupt Request. An open collector signal, low to request an interrupt.\nxiii. A0 – A7, B0 – B7. Data connections to outside world.\nxiii. A STB, B STB. Strobe signals for handshake FROM peripheral device.\nxiv. A READY, B READY. Handshake signals TO peripheral device.\n\nThe PIO requires a single 5V supply at 100mA.\n\n6.6 SERIAL COMMUNICATION & UARTS\n\n6.6.1 Introduction\nSerial outputs are commonly used to communicate with printers and other peripherals. Because a computer internally works in parallel, a serial port must incorporate parallel/serial and serial/parallel conversion logic as outlined in section 6.2. This is usually achieved with a special chip called a UART (Universal Asynchronous Receiver Transmitter). The Z-80 UART is also known as an SIO (for Serial Input Output). Although described for outputs from a computer, the circuits described are, of course, also used to input data serially from a peripheral.\n\n6.6.2 Signals and Standards\nBefore we can describe how a UART works, we must first establish how a serial signal is transmitted. Although there are several different transmissions standards (V24, RS232, 20mA) the actual data format used is the same as Fig.6.18 regardless of the standard used.\n\nWhen no signal is being sent, the line is a ‘1’. The first bit is a ‘0’ to indicate the start of a character. The data now follows, seven or eight bits according to the peripheral used. The data is followed by a parity bit. The end of the character is indicated by one (or two) ‘1’ bits (known as the stop bit(s)). Depending on the system, the word length and the number of stop bits, nine to twelve bits can be used to transmit a single character.\n\nA UART is therefore required to convert 8 bit data from\nthe computer to the serial format of Fig.6.18.\n\n\n\n**Fig. 6.18 Serial data format**\n\n6.6.3 UARTs\n\nIn describing a UART, a small problem becomes apparent. The Z-80 family contains a UART (called a SIO) but this is a relatively new device, rather sophisticated (being designed for modems) and a wee bit expensive. Most Z-80 based microcomputers therefore use the cheaper and less sophisticated 6402 UART which has become an industry standard. It was therefore decided to describe the 6402 in detail rather than the Z-80 SIO.\n\nThe UART block diagram is shown on Fig.6.19. Because a UART handles both transmitted and received data it has independent transmit and receive sections. These are linked by common control logic which selects the operating mode (i.e. the number of data bits, the parity sign, the number of stop bits). The mode is selected by the five inputs CLS2, CLS1, PI, EPE, SBS in accordance with Table 6.1. These will be hard-wired, and are not normally selected by the processor.\n\nThe transmitter section is simplest and will be described first. Data is loaded into a data buffer when TBRL (transmitter buffer load) goes low. When TBRL goes high, the output\nFig. 6.19 The UART, (a) Transmit logic\nFig. 6.19, (b) Receive logic\nFig. 6.20 Pin connections for 6402 UART\n\nTable 6.1 Mode Selection for 6402 UART\n\n<table>\n<thead>\n<tr>\n<th>CONTROL WORD</th>\n<th>CHARACTER FORMAT</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>C C L L P E S</td>\n<td>START DATA PARITY STOP</td>\n</tr>\n<tr>\n<td>S S I P B</td>\n<td>BIT BITS BIT BITS</td>\n</tr>\n<tr>\n<td>2 I</td>\n<td></td>\n</tr>\n<tr>\n<td>0 0 0 0 0 0</td>\n<td>1 5 ODD 1</td>\n</tr>\n<tr>\n<td>0 0 0 0 0 1</td>\n<td>1 5 ODD 1.5</td>\n</tr>\n<tr>\n<td>0 0 0 1 0 0</td>\n<td>1 5 EVEN 1</td>\n</tr>\n<tr>\n<td>0 0 0 1 1 1</td>\n<td>1 5 EVEN 1.5</td>\n</tr>\n<tr>\n<td>0 0 1 X 0 0</td>\n<td>1 5 NONE 1</td>\n</tr>\n<tr>\n<td>0 0 1 X 1 1</td>\n<td>1 5 NONE 1.5</td>\n</tr>\n</tbody>\n</table>\n\n145\n### CONTROL WORD\n\n<table>\n<thead>\n<tr>\n<th>C</th>\n<th>C</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>L</td>\n<td>L</td>\n</tr>\n<tr>\n<td>P</td>\n<td>E</td>\n</tr>\n<tr>\n<td>S</td>\n<td>S</td>\n</tr>\n</tbody>\n</table>\n\n### CHARACTER FORMAT\n\n<table>\n<thead>\n<tr>\n<th>S</th>\n<th>I</th>\n<th>P</th>\n<th>B</th>\n<th>START</th>\n<th>DATA</th>\n<th>PARITY</th>\n<th>STOP</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2</td>\n<td>l</td>\n<td>E</td>\n<td>S</td>\n<td>BIT</td>\n<td>BITS</td>\n<td>BIT</td>\n<td>BITS</td>\n</tr>\n</tbody>\n</table>\n\n| 0 | 1 | 0 | 0 | 0 | 1 | 6 | ODD | 1 |\n| 0 | 1 | 0 | 0 | 1 | 1 | 6 | ODD | 2 |\n| 0 | 1 | 0 | 1 | 0 | 1 | 6 | EVEN | 1 |\n| 0 | 1 | 0 | 1 | 1 | 1 | 6 | EVEN | 2 |\n| 0 | 1 | 1 | X | 0 | 1 | 6 | NONE | 1 |\n| 0 | 1 | 1 | X | 1 | 1 | 6 | NONE | 2 |\n| 1 | 0 | 0 | 0 | 0 | 1 | 7 | ODD | 1 |\n| 1 | 0 | 0 | 0 | 1 | 1 | 7 | ODD | 2 |\n| 1 | 0 | 0 | 1 | 0 | 1 | 7 | EVEN | 1 |\n| 1 | 0 | 0 | 1 | 1 | 1 | 7 | EVEN | 2 |\n| 1 | 0 | 1 | X | 0 | 1 | 7 | NONE | 1 |\n| 1 | 0 | 1 | X | 1 | 1 | 7 | NONE | 2 |\n| 1 | 1 | 0 | 0 | 0 | 1 | 8 | ODD | 1 |\n| 1 | 1 | 0 | 0 | 1 | 1 | 8 | ODD | 2 |\n| 1 | 1 | 0 | 1 | 0 | 1 | 8 | EVEN | 1 |\n| 1 | 1 | 0 | 1 | 1 | 1 | 8 | EVEN | 2 |\n| 1 | 1 | 1 | X | 0 | 1 | 8 | NONE | 1 |\n| 1 | 1 | 1 | X | 1 | 1 | 8 | NONE | 2 |\n\nTBRE (transmitter buffer empty) goes low.\n\nWhen the transmitter register is empty, the data automatically transfers from the buffer to the register. An output TRE (transmitter register empty) shows the state of the register, being low when the register is in use. The data from the register is now shifted out onto the line with the start, parity and stop bits provided by the UART. The transmission rate is determined by the transmit clock, which should be 16 times the transmit bit rate (e.g. 1760Hz for 110 baud).\n\nThe use of a transmit register and buffer and the TBRL, TBRE, TRE signals allows the computer to transmit a continuous data stream with minimum software.\n\nReceive data arrives on RR1 in serial form. The trans-\nmission rate is determined by the receive clock which, again, is 16 times the bit rate. The data format is again determined by the mode selection lines. When the character is received, it is loaded into the receive register. Data Ready goes high, and the parity and format are checked. The data can now be read by enabling the tristate output which places the data onto the computer bus. When the data has been read, the processor causes Data Ready Reset to go low which clears Data Ready. The UART is now ready for another character.\n\nThere are three error indications. Parity error, obviously indicates that the parity was incorrect (e.g. no stop bit). Over-run indicates that DDR was not set before the next character was received, i.e. the processor was not keeping up with the character stream. Framing Error indicates that the format was wrong (e.g. no stop bit).\n\nThe UART needs a certain amount of external logic to decode the port addresses, generate the interrupts on DBE and DR, and handle the various error signals.\n\n6.6.4 The Z-80 SIO\n\nThe Z-80 SIO chip is similar in principle to the UART described in the previous section, but has additional facilities. It is designed for interfacing directly to the Z-80 bus, and all the control signals brought out to pins in Fig.6.19 are loaded or read by the CPU via the data bus. Two independent channels are provided, with extra control signals for modems.\n\nThe SIO suffers from the pin constraints of the 40 pin package, and no less than three versions are provided with different control signals brought out. All can be used directly with the Z-80 interrupt daisy chain.\n\nAt the time of writing (early 1983) the SIO is a rare device in popular microcomputers, the 6402 UART in section 6.6.3 being used instead. In the interests of brevity, no further details of the SIO are given.\n6.7 COUNTER TIMER CHIP (CTC)\n\n6.7.1 Introduction\n\nThe CTC is a particularly useful member of the Z-80 family. It is used to free the processor of the chore of counting or timing external events. It can be told, for example, \"Interrupt the processor in 250mS\", or \"Interrupt the processor every second\", or \"Interrupt the processor when 144 items have passed the photocell connected to the CTC counter input\". The CTC is therefore ideal for control applications and schemes where timing is important.\n\nThe CTC contains four independent circuits, each of which can be used as a counter or a timer.\n\n6.7.2 Channel Operation\n\nThe block diagram of one channel is shown on Fig.6.20. The heart of the channel is an 8 bit down counter. An 8 bit number is loaded by the CPU to the time constant register from where it is transferred to the counter.\n\nThe counter is decremented either by the system clock or by an external event or clock. When the counter reaches zero, an interrupt is generated, a signal is given to the outside world (to drive a batch counter for example) and the counter reloaded from the time constant register.\n\nIf the counter is being used as a timer from the system clock, a pre-scaler is provided to divide the system clock by 256 or 16, selectable by the CPU. With a prescale factor of 256 and the time constant register set for 256, the CTC chip would provide an interrupt every 65.536mS with a 1MHz clock.\n\nThe channel control register is loaded by the CPU, and determines the operating mode (external count/clock or system clock, pre-scaler value, positive or negative edge count, interrupt enable/disable etc.).\n\nThe full device block diagram is shown on Fig.6.21. The four channels are identical to Fig.6.20, except that channel 3 does not have a zero count output for pin limitations reasons.\nEach channel is totally independent and has its own interrupt vector.\n\nA channel is configured by writing data to the corresponding channel control register. The channel is selected by two control signals CSO and CSI. These select the channel as follows:\nFig. 6.21 CTC block diagram\n\nN.B. no zero count o/p on channel 3\nConnected to AO and CSI connected to Al. Address lines A2 – A7 are decoded to select the CTC chip, so channels 0 – 3 occupy four successive port addresses.\n\n<table>\n<thead>\n<tr>\n<th>Channel</th>\n<th>CSI</th>\n<th>CSO</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>3</td>\n<td>1</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\n\nNormally the CTC is wired as Fig.6.22, with CSO connected to A0 and CSI connected to Al. Address lines A2 – A7 are decoded to select the CTC chip, so channels 0 – 3 occupy four successive port addresses.\n\n\n\n### 6.7.3 Programming the CTC\n\nBefore the CTC can operate, the channel control register (CCR), time constant register and the interrupt vector have to\nbe loaded for each channel. The channel control register is loaded by writing a word to the channel address (see above) with the format of Fig.6.23.\n\nBit 0 = ‘1’ shows that this word contains set up data for the CCR. Bit 1 = ‘1’ resets the channel. The channel stops counting or timing until a new time constraint is loaded. The status of the other bits in the CCR is unchanged. This is not the same as a hardware (pin 17) reset. Bit 2 = ‘1’ denotes that the next word written to this channel will be the time constant word.\n\nBit 6 selects whether the channel is to be used as a counter or a timer. If bit 6 is a ‘1’, the channel is a counter, and decrements on the external input. The prescaler is not used. If Bit 6 is a ‘0’ timer mode is selected based on the system clock. The channels zero count output is a pulse train of period\n\n\\[ t_c \\times P \\times TC \\]\n\nwhere \\( t_c \\) is the period of the system clock, \\( P \\) is the prescaler factor (16 or 256) and TC the time constant (in the range 1 to 256).\n\nBit 5 selects the prescaler factor. With Bit 5 a ‘1’ the prescaler factor is 256. With Bit 5 a ‘0’ the prescaler factor is 16. Obviously Bit 5 is only relevant if timer mode is selected (Bit 6 = ‘0’).\n\nBit 3 is called “trigger” and is only used in timer mode. If Bit 3 is a ‘0’, timing starts as soon as the time constant register is loaded. If Bit 3 is a ‘1’ timing starts with a trigger edge on the channels clock/trigger input.\n\nBit 4 is called slope and determines which edge of the clock/trigger input decrements the counter (in count mode) or starts the timer (in timer mode with Bit 3 at a ‘1’). With Bit 4 a ‘1’, the positive edge of the input is used. With Bit 4 at a ‘0’, the negative edge is used.\n\nBit 7 is used to enable or disable the interrupt request. With Bit 7 at a ‘0’ the interrupt is disabled. With Bit 7 at a ‘1’, the interrupt is enabled.\n\nAfter loading the CCR with Bit 2 = ‘1’, the next word written to a channel must be the time constant. This is an 8 bit number in the range 0 – 256. Numbers 1 – 255 give time\nFig. 6.23 Channel control register word (CCR)\nconstants 1 — 255. If zero is written, a time constant of 256 is assumed. The time constant can therefore be in the range 1 — 256.\n\n6.7.4 Interrupts\n\nThe CTC can be used on the daisy chain with IEI, IEO and INT in the same manner as described in section 6.4.4. Within the CTC, channel 0 has the highest priority.\n\nThe CTC is designed to be used with the CPU in mode 2 (see section 6.4). This requires the I register to be loaded with the high byte of a table address, and the device to supply the low byte (called the interrupt vector).\n\nOne interrupt vector is written to the CTC by writing a word to channel 0 with Bit 0 = ‘0’ as shown on Fig. 6.24 (Bit 1 = ‘1’ denotes a CCR word). This interrupt vector is modified in Bits 1 and 2 as shown for each channel.\n\nSuppose I is loaded with IE, and the vector written to\n\n![Diagram of CTC interrupt vector]\n\n*Fig. 6.24 CTC interrupt vector*\nchannel 0 is Hex 38 (binary 00111000). The corresponding vectors and table addresses are:\n\n<table>\n<thead>\n<tr>\n<th>Channel</th>\n<th>Vector</th>\n<th>Table Address</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>38</td>\n<td>IE38 and IE39</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3A</td>\n<td>IE3A and IE3B</td>\n</tr>\n<tr>\n<td>3</td>\n<td>3C</td>\n<td>IE3C and IE3D</td>\n</tr>\n<tr>\n<td>4</td>\n<td>3E</td>\n<td>IE3E and IE3F</td>\n</tr>\n</tbody>\n</table>\n\nInterrupts are generated when a channel counter reaches zero.\n\n6.7.5 Pin Connections\n\nThe CTC pin connections are shown on Fig.6.25. The function of the data bus, M1, RD, IORQ, φ, CE, INT, IE1, IEO are identical to the PIO pins in section 6.5.8. CSO and CSI select the channel as outlined above.\n\nFig. 6.25 CTC pin connections\nEach channel (except 3) has a zero count output (ZC) which strobes high when zero count is reached. Each channel has an input which triggers the counter or initiates the timer.\n\nA low signal to the Reset pin stops all counting and timing, and clears the internal logic. A reset strobe is required on power up to ensure correct operation.\n\nThe CTC operates on a single 5 volt rail and draws about 100mA.\n\n6.8 ANALOG INTERFACING\n\n6.8.1 Introduction\n\nAnalog signals (i.e. variable voltages) are required for measurement and control applications. There are no specific Z-80 chips, but typical analog input and output circuits are described briefly below.\n\n6.8.2 Digital to Analog Converter (DAC)\n\nAs its name implies, the circuit converts a digital output signal from a parallel port to a voltage. Most DACs are based on the R–2R network of Fig.6.26. The output voltage is a representation of the binary state of the switches. In a practical DAC, transistors or FETs are used as switches.\n\nA practical IC is the Ferranti ZN427 DAC. This gives an output in the range 0 to 2.55 volts for a corresponding binary input. The output can, of course, be amplified to any desired level.\n\n6.8.3 Analog to Digital Converter (ADC)\n\nAn ADC converts an analog signal to a digital form that can be read by a computer parallel port. A block diagram of a simple ADC is shown on Fig.6.27. A DAC is connected to a counter. The counter is reset by the start pulse which sets FF1, gating pulses to the counter. The DAC output will then be a ramp, which is compared with the input voltage. When the two\nFig. 6.26 8 bit digital to analog converter (DAC)\nFig. 6.27 Block diagram of 8 bit DAC\nvoltages are equal, the comparator resets FF1, thereby freezing the counter. The counter state is now a digital representation of the input voltage. Ready and Overspill signals are provided which indicate the ADC state to the computer. Usually the port will generate an interrupt on the Ready signal. The Ferranti ZN427 DAC is particularly useful as it contains an 8 bit counter and DAC.\n\n6.8.4 General Observations\n\nThe topic of analog interfacing is a very wide one, and cannot be fully covered in a book of this size which is (after all) concerned with the Z-80. Practical DAC and ADC circuits are given in the author's book \"Practical Computer Experiments\", BP78.\n\n6.9 KEYBOARDS\n\nEvery popular microcomputer has a keyboard. These are generally arranged on the matrix principle similar to Fig.6.28. The computer has two I/O ports, an output port driving strobe lines and an input port reading the sense lines.\n\nTo read the keyboard, the computer outputs to each strobe line in turn reading back the sense lines for each strobe. On Fig.6.28, for example, if the D key was pressed, we would get the signal on sense line 2 when strobe line 6 was strobed.\n\nObviously considerable programming effort is needed to scan, read and decode the keyboard. Usually the computer monitor program will have a keyboard read subroutine which can be called by the user. In section 5.8 we used the NASBUG KBD routine as part of our test program.\n\nKeyboards can be scanned by an I/O port address (e.g. Nascom), or by appearing as memory locations (e.g. TRS 80, where store addresses Hex 3801, 3802, 3804, 3808, 3810, 3820, 3840, 3880 provide the strobes and give the keys pressed. There are no actual RAM locations with these addresses).\n\nAn alternative approach is to use discrete logic to strobe the\nFig 6.28 Keyboard matrix\nkeys and scan the sense lines. If a key is pressed, the logic handles the key decoding, and simply presents a 8 bit ASCII code for the computer to read via a parallel port. This method simplifies the programming, but uses quite complex (and hence expensive) logic.\n\n6.10 VDUs\n\nMost microcomputers incorporate a VDU, either built in, using an external monitor or driving a domestic TV. To describe the operation of a VDU in detail would require many pages, involving, as it does, detailed knowledge of how a TV picture is built up. The description below is therefore somewhat simplified, but adequate for a user who wishes to drive a VDU rather than construct one.\n\nA typical VDU will display 16 rows of characters with 48 characters per row. These characters must be stored in the VDU, so the first requirement is some form of store to hold these 744 characters. This will be scanned by some logic to produce the TV picture as Fig.6.29.\n\nTo be any use, these store locations must have data written into them. If the VDU is a true peripheral, data will be sent down a serial link (see sections 6.2 and 6.6) and loaded into the store. Control words such as New Line, Carriage Return, Backspace, Cursor Down etc. are sent to determine where characters are placed on the screen.\n\nMost microcomputers, however, use a technique called a Memory Mapped VDU. The character store, shown on Fig.6.30, is a part of the computer store \\( \\text{AND} \\) can be accessed by the VDU logic. The address and data bus can be switched to the computer or VDU display logic, with the computer having priority.\n\nThis approach has many advantages. Because the character store is accessed directly by the computer, the VDU is very fast. Each character position on the screen corresponds to one store location, so dynamic display are easily drawn. Less obviously, data can be read back from the screen for use by the program.\nThe Nascom uses a memory mapped VDU, with store locations from Hex 080A (top left) to 0BF9 (bottom right). To display a letter E at the centre of the screen we would write in assembler:\n\n\\[\n\\text{LD A, } £45 ; 45 \\text{ is ASCII E} \\\\\n\\text{LD (£0980), A ; Write to centre of screen}\n\\]\n\nWhere a message is to be written, it is usually easier to use the computer monitors VDU subroutine. In the example in section 5.7 the Nascom VDU routine was used.\nFig. 6.30 The memory mapped VDU, (a) VDU memory as part of store, (b) detailed drawing of logic\nChapter Seven\n\nA MISCELLANY OF DATA\n\n7.1 INTRODUCTION\n\nThis chapter collects together a rag tag bundle of information about the Z-80, its manufacturers, its support chips and other useful facts.\n\n7.2 SUPPORT CHIPS\n\nThe Z-80 has a family of support chips. The commoner ones have been described in earlier chapters. The full (early 1983) family is:\n\n7.2.1 Z-80 CPU\n\nThe microprocessor chip itself.\n\n7.2.2 PIO\n\nThe parallel input output device described in section 6.5.\n\n7.2.3 CTC\n\nThe counter timer chip described in section 6.7.\n\n7.2.4 SIO\n\nA serial input/output controller for use in asynchronous and synchronous applications. Two channels are provided with special control for use with modems. Unlike the commoner UARTs, the SIO can work directly with the Z-80 interrupt daisy chain.\n7.2.5 SIÖ/9\nA single channel version of the SIÖ.\n\n7.2.6 DART\nA dual UART for asynchronous serial links.\n\n7.2.7 DMA Controller\nDMA stands for direct memory access, and is used where an external device (such as a disc controller or another processor) requires direct access to a computer's memory without the intervention of the main processor. A DMA controller handles this transfer. This is not a technique to try without some programming and hardware experience.\n\n7.2.8 FIFO Buffer\nThe FIFO (for first in/first out) can be considered as a parallel shift register. It is used to provide a 128 word buffer for incoming and outgoing data in I/O and multiprocessor systems. It's use allows the processor to quickly read a “burst” of data that arrived at random intervals of time.\n\n7.2.9 CIO/U\nThis chip combines the functions of a PIO and CTC chip. It provides two 8 bit parallel ports and a four bit port, plus three counter timer circuits.\n\n7.2.10 Future Developments\nAs the Z-80 is a development of the 8080, so the Z8000 16 bit micro is a development of the Z-80. Many devices planned for the Z8000 can be used with the Z-80.\n7.2.11 Speed\n\nMost Z-80 chips are available in 2MHz or 4MHz versions. The latter are denoted by the suffix A. A lower power version (suffix L) is also available.\n\n7.3 MANUFACTURERS\n\nThe original manufacturer is Zilog. The following companies are second source manufacturers:\n\n- MOSTEK (typical device code MK3880)\n- NEC (typical device code PD780C)\n- SGS-ATES (typical device code Z-80 CPU)\n- Fairchild (typical device code F3880)\n\n7.4 TECHNICAL PUBLICATIONS\n\nThis book has described the Z-80 in a descriptive, rather than a formal manner. The Zilog publications below give the Z-80 technical and software data in a complete and formal manner, and include details such as bus timing which were considered outside the remit of an introductory book:\n\nc. PIO Technical Manual\nd. CTC Technical Manual\ne. Zilog Microcomputer Components Data Book\n\nThese are all published by Zilog and the second source suppliers.\n\n7.5 Z-80 BASED MICROCOMPUTERS\n\nThe following machines use a Z-80 microprocessor:\nAltos\nCompelec\nCromenco\nExidy Sorceror\nNascom 1 and 2\nNorth Star Horizon\nNEC PC-8000\nOKI-800\nResearch Machines 380-Z\nSharp MZ-80\nShelton Signet\nSinclair ZX-80/ZX81/Spectrum\nSuperbrain\nTransam Tuscam\nTRS-80\nVideo Genie\n\nNo claim is made for completeness, as new machines are appearing all the time.\n\n7.6 WRITING A PROGRAM\n\nThe beginner should not start by writing a 16K machine code program; that way lies madness and divorce! It is better to first start by writing simple programs to, say, add two numbers and display the result on the screen. When confidence is gained, progress to more ambitious programs can be made.\n\nThe stages in writing a program are usually as follows:\n\na. Define what needs to be done, and if possible break the program down into digestible blocks (e.g. Keyboard Input, Update Members Addresses, Identify Overdue Accounts). This stops the task overwhelming the programmer!\n\nb. Draw up flowcharts as we did in section 5.5. These should start off relatively simple, then be made more detailed until they can be translated to program instructions. Try to identify useful subroutines (e.g. multipli-\ncation, division, sorts, searches, etc.), and build up a sub-\nroutine library. Do not re-invent the wheel with every\nprogram!\n\nc. With detailed flow charts, draw up a source program in\nAssembler Code *EVEN* if you are using a monitor to\nload the machine code program. It is worth it for the\nclear documentation it provides when the inevitable\nde-bugging occurs.\n\nd. Translate the source program to an object program,\neither with an assembler or by hand.\n\ne. *MAKE A COPY OF THE OBJECT PROGRAM* on tape\nor disc before attempting to run it. Very few machine\ncode programs run first time, and a single error can cause\na program to self destruct.\n\nf. Cross your fingers and run your program. Do not be dis-\nheartened if it does not run first time. Use the monitor\nprogram’s breakpoint and single step routines to check\nthe program operation.\n\n7.7 BASIC and PEEK and POKE\n\nIt is possible to intermingle BASIC and machine code\nprograms, and the technique is particularly useful where a pro-\ngram requires complex calculations (which are done in BASIC)\nand fast I/O or VDU graphics (which are done in machine\ncode).\n\nMost BASICs allow the program to call a machine code sub-\nroutine. The commonest BASIC instructions are CALL and\nUSR. There are differences between dialects of BASIC, but,\nfor example, the BASIC instruction:\n\n`CALL 1519`\n\nwill call the machine code program at decimal address 1519.\nThe machine code program is required to be terminated with a\nRET instruction which resumes BASIC at the instruction after\nthe CALL.\n\nIt is possible, but laborious, to load a machine code\nprogram via BASIC using the POKE instruction. An object program is converted, by hand, a location at a time from Hex to decimal, then included as DATA statements in the BASIC program. These are READ and POKE'd by a FOR-NEXT loop.\n\nData in store locations that have been used by the machine code program can be examined by the BASIC program via the PEEK function.\n\nSetting up a machine code program via BASIC is obviously tedious, but is useful for small subroutines and obviates the need to load a BASIC and machine code program separately.\n\nWhen deciding where a machine code program is to reside along with BASIC, due care should be taken to avoid a clash. Most computers have a \"Memory Map\" which shows what store addresses are used for what. Usually the store used by BASIC can be restricted with a SIZE or similar statement.\n\n7.8 THE INTEL 8080\n\nAs explained earlier, the Z-80 is a development of the 8080, and as a result 8080 programs will run on a Z-80. The reverse is not, however, necessarily true. The tables in Chapter 4 identify the 8080 compatible instructions.\n\nThe programmers model of the 8080 is shown on Fig.7.1. As can be seen it is almost a half Z-80, having no alternate register set, no I or R registers, and no index registers. Needless to say, the 8080 has fewer instructions.\n\nAlthough 8080 programs will run on the Z-80, there are usually a few practical problems. The first concerns the running of even Z-80 programs on different machines. All computers use different ways of driving keyboards, VDUs etc., so there are problems moving a Z-80 machine code program, from, say, a TRS-80 to a Nascom. This problem is compounded with the 8080, as the whole configuration of the original computer may be different.\n\nThe second problem concerns 8080 source programs. Unfortunately 8080 Assembler Mnemonics bear little, if any, resemblance to Z-80 Mnemonics. For example:\nAlthough the resulting object program will be the same, translating an 8080 source program to a Z-80 source program can be an infuriating experience. Out of fairness, it should be said that the Zilog designers did not instigate change for changes sake. The Z-80 mnemonics are far more logical and easier to remember than the 8080 mnemonics.\n\nIntel have produced their own enhanced version of the 8080, called the 8085. There is very little compatibility between the 8085 and the Z-80.\nWe are so used to working in decimal numbers that we tend to take it for granted, and consider our way of counting to be the only way possible. Basically we count in \"tens\", and our number system is said to operate to a \"base\" of ten. The number, 4059, for example means:\n\n\\[\n\\begin{align*}\n4 \\text{ thousands} & \\quad \\text{i.e. } 4 \\times 10 \\times 10 \\times 10 \\\\\n+ 0 \\text{ hundreds,} & \\quad \\text{i.e. } 0 \\times 10 \\times 10 \\\\\n+ 5 \\text{ tens,} & \\quad \\text{i.e. } 5 \\times 10 \\\\\n+ 9 \\text{ units,} & \\quad \\text{i.e. } 9 \\times 1\n\\end{align*}\n\\]\n\nThere is no reason why we should count to a base of ten except, of course, that we have ten fingers. A counting system can be devised to any base. Ten is, actually, a rather bad choice as ten can only be divided by five and two. Trade would have been simpler if we had twelve fingers, as twelve can be divided by four, three, two and six, and is a \"packable\" number in that twelve items can be neatly packed four by three or two by two by three.\n\nTwo number systems are of particular interest in computing; Base two, known as Binary, and Base sixteen, known as Hexadecimal, or Hex for short. We will deal with Hex first as it is conceptually the simplest.\n\nTo count in Hex we need sixteen symbols (including zero). These are the numerals 0 – 9 and the letters A – F.\n\n<table>\n<thead>\n<tr>\n<th>Decimal</th>\n<th>0</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<th>8</th>\n<th>9</th>\n<th>10</th>\n<th>11</th>\n<th>12</th>\n<th>13</th>\n<th>14</th>\n<th>15</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Hex</td>\n<td>0</td>\n<td>1</td>\n<td>2</td>\n<td>3</td>\n<td>4</td>\n<td>5</td>\n<td>6</td>\n<td>7</td>\n<td>8</td>\n<td>9</td>\n<td>A</td>\n<td>B</td>\n<td>C</td>\n<td>D</td>\n<td>E</td>\n<td>F</td>\n</tr>\n</tbody>\n</table>\n\nWhat happens now? We simply start a new Hex column:\n\n<table>\n<thead>\n<tr>\n<th>Decimal</th>\n<th>16</th>\n<th>17</th>\n<th>18</th>\n<th>19</th>\n<th>20</th>\n<th>21</th>\n<th>. . . .</th>\n<th>29</th>\n<th>30</th>\n<th>31</th>\n<th>32</th>\n<th>33</th>\n<th>etc.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Hex</td>\n<td>10</td>\n<td>11</td>\n<td>12</td>\n<td>13</td>\n<td>14</td>\n<td>15</td>\n<td>. . . .</td>\n<td>1D</td>\n<td>1E</td>\n<td>1F</td>\n<td>20</td>\n<td>21</td>\n<td>etc.</td>\n</tr>\n</tbody>\n</table>\n1DF6, for example, means\n\n1 x sixteen x sixteen x sixteen = 4096\n+ D (thirteen) x sixteen x sixteen = 3328\n+ F (fifteen) x sixteen = 240\n+ 6 = 7670 in decimal\n\nThere are many ways of converting from decimal to Hex, but one of the simplest is to note the powers of 16 up to 65536:\n\n16, 256, 4096\n\nConversions of numbers above 65536 are rarely required in computing. The method is best described by example:\n\ne.g. 53156\nFirst divide by 4096 gives 12 (C) remainder 4004\nNow divide 4004 by 256, which gives 15 (F) remainder 164\nNow divide 164 by 16, which gives 10 (A) remainder 4\n\nThe Hex equivalent of 53156 is therefore CFA4.\n\nHex is, itself, little more than a mathematical curiosity, but as we shall see later, it can be used as a convenient way to represent binary numbers.\n\nBinary is a number system to a base of two. It has only two symbols: 0 and 1. As each column in a decimal number represents a power of ten, so each column in a binary number represents a power of two (1, 2, 4, 8, 16 etc.)\n\nWe thus count:\n\n<table>\n<thead>\n<tr>\n<th>Decimal</th>\n<th>Binary</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>0000</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0001</td>\n</tr>\n<tr>\n<td>2</td>\n<td>0010</td>\n</tr>\n<tr>\n<td>3</td>\n<td>0011</td>\n</tr>\n<tr>\n<td>4</td>\n<td>0100</td>\n</tr>\n<tr>\n<td>5</td>\n<td>0101</td>\n</tr>\n</tbody>\n</table>\nA typical binary number is therefore 1 0 1 1 0 1 1 0 (conventionally, the least significant end is to the right, the same as decimal numbers). To convert this to decimal we simply write the corresponding powers of two:\n\n<p>| | | | | | | | |</p>\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</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\nThe decimal equivalent of 1 0 1 1 0 1 1 0 is therefore 182.\n\nThe simplest way to convert from decimal to binary is to use repeated division by two, noting the remainder each time. For example, to convert decimal 57 to binary:\n\nDividing by two each time we get:\n\n57 28 remainder 1\n28 14 remainder 0\n14 7 remainder 0\n 7 3 remainder 1\n 3 1 remainder 1\n 1 0 remainder 1\n\nThe remainders are read with least significant at the top to give the binary number 1 1 1 0 0 1 which is equivalent to decimal 57.\n\nThe 1s and 0s of binary are particularly easy to represent with electronic circuits, so all computers work internally in binary. Unfortunately, large binary numbers such as:\n\n1 0 1 1 0 0 1 1 0 1 1 1 0 0 1\nare difficult to comprehend, and even more difficult to remember. This is where Hex is useful.\n\nConversion between binary and Hex is very easy. The binary number is split into groups of four bits. Each group of four bits can represent a number from 0 to fifteen, or Hex 0 to F. The Hex representation of each group is then written down to give the corresponding Hex number. Taking our example above\n\n\\[10110011011111001\\]\n\nSplit into groups of four\n\\[1011 \\ 0011 \\ 0111 \\ 1001\\]\nHex equivalents\n\\[B \\ 3 \\ 7 \\ 9\\]\nThe Hex number is therefore B379\n\nThe reverse conversion is equally easy. The Hex number is written down and the four binary bits corresponding to each digit put below, e.g. 85F6\n\n\\[8 \\ 5 \\ F \\ 6\\]\n\\[1000 \\ 0101 \\ 1111 \\ 0110\\]\nThe binary number is therefore 1000010111110110\n\nMost microprocessor instructions are usually given in Hex. This is purely for the convenience of the programmer, the computer itself works in binary.\n\nThe microprocessor user usually need not concern himself with the mechanics of binary arithmetic. Full details (and circuit) are given in \"Practical Computer Experiments\" BP 78. A few practical points, however, are worth noting.\n\nThe rules of binary addition are very simple:\n\n\\[\n\\begin{align*}\n0 &+ 1 = 1 \\\\\n1 &+ 0 = 1 \\\\\n0 &+ 0 = 0 \\\\\n1 &+ 1 = 0 \\text{ plus carry to next bit}\n\\end{align*}\n\\]\n\nFor example\n\n\\[\n\\begin{array}{c}\n10110011 \\\\\n+00100101 \\\\\n\\hline\n11011000\n\\end{array}\n\\]\n\nThe carry flag in the flag register is set if an arithmetic\noperation overspills 8 bits. For example:\n\n\\[\n\\begin{array}{c}\n10110011 \\\\\n+ \\hspace{1cm} 10100101 \\\\\n\\hline\n\\text{Carry} \\hspace{1cm} 101011000\n\\end{array}\n\\]\n\nThis allows 16 bit arithmetic to be performed.\n\nAn 8 bit number can be used to represent a decimal number in the range 0 to 255, or, by designating the top bit to indicate sign, a number in the range \\(-128\\) to \\(+127\\).\n\nBefore we see how this is done, let us consider a decimal analogy. Consider the sum:\n\n\\[\n\\begin{array}{c}\n023 \\\\\n+ \\hspace{1cm} 994 \\\\\n\\hline\n1017\n\\end{array}\n\\]\n\nIf we ignore the thousand column, the answer is 17. The number 994 thus looks like minus 6. Another example:\n\n\\[\n\\begin{array}{c}\n251 \\\\\n+ \\hspace{1cm} 827 \\\\\n\\hline\n1078\n\\end{array}\n\\]\n\nAgain, ignoring the thousand column, the answer is 78. The number 827 looks like minus 173.\n\nA three digit decimal negative number is formed by subtraction from one thousand. Minus 6 is then \\(1000 - 6 = 994\\).\n\nNegative binary numbers can be formed in a similar manner. Consider the sum:\n\n\\[\n\\begin{array}{c}\n0110 \\hspace{1cm} 6 \\\\\n\\hline\n1100 \\\\\n10010 \\hspace{1cm} 2\n\\end{array}\n\\]\n\nThe number 1100 thus represents minus 4.\n\nIt is very easy to produce a negative number in binary. Take the number, complement it (i.e. replace ‘1’s by ‘0’s and vice versa) then add 1.\n\n\\[\n\\begin{array}{c}\ne.g. \\hspace{1cm} 00000110 \\hspace{1cm} 6 \\text{ (to 8 bits)} \\\\\n11111001 \\hspace{1cm} \\text{Complemented} \\\\\n11111010 \\hspace{1cm} \\text{Add 1}\n\\end{array}\n\\]\n\n175\n11111010 thus represents minus 6 in 8 bits.\n\nIn general, the top bit is a ‘1’ if the number is negative, and ‘0’ if it is positive.\n\nThe above representation is known as twos complement arithmetic.\n\nIt should be emphasised that the programmer can use an 8 bit number as an 8 bit unsigned number or an 8 bit twos complement number to suit his needs.\nAppendix B\n\nZ-80 INSTRUCTION SET\n\nThis appendix gives the complete Z-80 instructions set in Assembler Mnemonic Form. Reference should also be made to the tables in Chapter 4.\n\nThe following notation is used:\n\nN Single Byte Data\nNN Double Byte Data\n( ) Store Address or I/O Address\nR Register\nA Accumulator\nD Offset (not available on some instructions)\nSS Register Pair\nCC Conditions\n\n<table>\n<thead>\n<tr>\n<th>Conditions</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>C</td>\n</tr>\n<tr>\n<td>NC</td>\n</tr>\n<tr>\n<td>Z</td>\n</tr>\n<tr>\n<td>NZ</td>\n</tr>\n<tr>\n<td>PE</td>\n</tr>\n<tr>\n<td>PO</td>\n</tr>\n<tr>\n<td>M</td>\n</tr>\n<tr>\n<td>P</td>\n</tr>\n</tbody>\n</table>\n\n---\n\n<table>\n<thead>\n<tr>\n<th>Instruction</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ADC HL,SS</td>\n<td>Add with Carry Reg. Pair SS to HL</td>\n</tr>\n<tr>\n<td>ADC A,S</td>\n<td>Add with Carry Operand S to Acc</td>\n</tr>\n<tr>\n<td>ADD A,N</td>\n<td>Add Value N to Acc</td>\n</tr>\n<tr>\n<td>ADD A,R</td>\n<td>Add Reg. R to Acc</td>\n</tr>\n<tr>\n<td>ADD A,(HL)</td>\n<td>Add Location (HL) to Acc</td>\n</tr>\n<tr>\n<td>ADD A,(IX+D)</td>\n<td>Add Location (IX+D) to Acc</td>\n</tr>\n<tr>\n<td>ADD A,(IY+D)</td>\n<td>Add Location (IY+D) to Acc</td>\n</tr>\n<tr>\n<td>ADD IX,SS</td>\n<td>Add Reg. Pair SS to IX</td>\n</tr>\n<tr>\n<td>ADD IY,SS</td>\n<td>Add Reg. Pair SS to IY</td>\n</tr>\n<tr>\n<td>ADD IY,RR</td>\n<td>Add Reg. Pair RR to IY</td>\n</tr>\n<tr>\n<td>AND S</td>\n<td>Logical 'AND' of Operand S and Acc</td>\n</tr>\n<tr>\n<td>BIT B,(HL)</td>\n<td>Test Bit B of Location (HL)</td>\n</tr>\n<tr>\n<td>BIT B,(IX+D)</td>\n<td>Test Bit B of Location (IX+D)</td>\n</tr>\n<tr>\n<td>BIT B,(IY+D)</td>\n<td>Test Bit B of Location (IY+D)</td>\n</tr>\n<tr>\n<td>Command</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>---------</td>\n<td>-------------</td>\n</tr>\n<tr>\n<td>BIT B,R</td>\n<td>Test Bit B of Reg. R</td>\n</tr>\n<tr>\n<td>CALL CC,NN</td>\n<td>Call subroutine at Location NN if Condition CC is true</td>\n</tr>\n<tr>\n<td>CALL NN</td>\n<td>Unconditional Call subroutine at Location NN</td>\n</tr>\n<tr>\n<td>CCF NN</td>\n<td>Complement Carry Flag</td>\n</tr>\n<tr>\n<td>CP S</td>\n<td>Compare Operand S with Acc</td>\n</tr>\n<tr>\n<td>CPD</td>\n<td>Compare Location (HL) and Acc Decrement HL and BC until CB=0</td>\n</tr>\n<tr>\n<td>CPDR</td>\n<td>Compare Location (HL) and Acc Decrement HL and BC, repeat</td>\n</tr>\n<tr>\n<td>CPI</td>\n<td>Compare Location (HL) and Acc. Increment HL and Decrement BC</td>\n</tr>\n<tr>\n<td>CPIR</td>\n<td>Compare Location (HL) and Acc. Increment HL, Decrement BC Repeat until BC=0</td>\n</tr>\n<tr>\n<td>CPL</td>\n<td>Complement Acc. (1’s comp)</td>\n</tr>\n<tr>\n<td>DAA</td>\n<td>Decimal Adjust Acc</td>\n</tr>\n<tr>\n<td>DEC M</td>\n<td>Decrement Operand M</td>\n</tr>\n<tr>\n<td>DEC IX</td>\n<td>Decrement IX</td>\n</tr>\n<tr>\n<td>DEC IY</td>\n<td>Decrement IY</td>\n</tr>\n<tr>\n<td>DEC SS</td>\n<td>Decrement Reg. Pair SS</td>\n</tr>\n<tr>\n<td>DI</td>\n<td>Disable Interrupts</td>\n</tr>\n<tr>\n<td>DJNZ B</td>\n<td>Decrement B and Jump Relative if B=0</td>\n</tr>\n<tr>\n<td>EI</td>\n<td>Enable Interrupts</td>\n</tr>\n<tr>\n<td>EX (SP),HL</td>\n<td>Exchange the Location (SP) and HL</td>\n</tr>\n<tr>\n<td>EX (SP),IX</td>\n<td>Exchange the Location (SP) and IX</td>\n</tr>\n<tr>\n<td>EX (SP),IY</td>\n<td>Exchange the Location (SP) and IY</td>\n</tr>\n<tr>\n<td>EX AF,AF'</td>\n<td>Exchange the contents of AF and AF'</td>\n</tr>\n<tr>\n<td>EX DE,HL</td>\n<td>Exchange the contents of DE and HL</td>\n</tr>\n<tr>\n<td>EXX</td>\n<td>Exchange the contents of BC, DE, HL with contents of BC', DE', HL' respectively</td>\n</tr>\n<tr>\n<td>HALT</td>\n<td>Halt (wait for Interrupt or Reset)</td>\n</tr>\n<tr>\n<td>IM 0</td>\n<td>Set Interrupt Mode 0</td>\n</tr>\n<tr>\n<td>IM 1</td>\n<td>Set Interrupt Mode 1</td>\n</tr>\n<tr>\n<td>IM 2</td>\n<td>Set Interrupt Mode 2</td>\n</tr>\n<tr>\n<td>IN A,(N)</td>\n<td>Load the Acc. with input from device N</td>\n</tr>\n<tr>\n<td>IN R,(C)</td>\n<td>Load the Reg. R with input from device (C)</td>\n</tr>\n<tr>\n<td>INC (HL)</td>\n<td>Increment Location (HL)</td>\n</tr>\n<tr>\n<td>INC IX</td>\n<td>Increment IX</td>\n</tr>\n</tbody>\n</table>\nINC (IX+D) Increment Location (IX+D)\nINC IY Increment IY\nINC (IY+D) Increment Location (IY+D)\nINC R Increment Reg. R.\nINC SS Increment Reg. Pair SS\nIND Load Location (HL) with input from Port (C), Decrement HL and B\nINDR Load Location (HL) with input from Port (C), Decrement HL and Decrement B, repeat until B=0\nINI Load Location (HL) with input from Port (C), and Increment HL and Decrement B\nINIR Load Location (HL) with input from Port (C), and Increment HL and Decrement B, repeat until B=0\nJP (HL) Unconditional Jump to (HL)\nJP (IX) Unconditional Jump to (IX)\nJP (IY) Unconditional Jump to (IY)\nJP CC,NN Jump to Location NN if condition CC is true\nJP NN Unconditional Jump to Location NN\nJP C,E Jump relative to PC+E if Carry =1\nJR E Unconditional Jump relative to PC+E\nJR NC,E Jump relative to PC+E if Carry =0\nJR NZ,E Jump relative to PC+E if Non Zero (Z=0)\nJR Z,E Jump relative to PC+E if Zero (Z=1)\nLD A,(BC) Load Acc, with Location (BC)\nLD A,(DE) Load Acc. with Location (DE)\nLD A,I Load Acc. with I\nLD A,(NN) Load Acc. with Location NN\nLD A,R Load Acc. with Reg. R\nLD (BC),A Load Location (BC) with Acc.\nLD (DE),A Load Location (DE) with Acc.\nLD (HL),N Load Location (HL) with value N\nLD DD,NN Load Reg. Pair DD with value NN\nLD HL,(NN) Load HL with Location (NN)\nLD (HL),R Load location (HL) with Reg. R\nLD I,A Load I with Acc.\nLD IX,NN Load IX with value NN\nLD IX,(NN) Load IX with Location (NN)\nLD (IX+D),N Load Location (IX+D) with value N\nLD (IX+D),R Load Location (IX+D) with Reg. R\nLD IY,NN Load IY with value NN\nLD IY,(NN) Load IY with Location (NN)\nLD (IY+D),N Load Location (IY+D) with value N\nLD (IY+D),R Load Location (IY+D) with Reg. R\nLD (NN),A Load Location (NN) with Acc.\nLD (NN),DD Load Location (NN) with Reg. Pair DD\nLD (NN),HL Load Location (NN) with HL\nLD (NN),IX Load Location (NN) with IX\nLD (NN),IY Load Location (NN) with IY\nLD R,A Load R with Acc.\nLD R,(HL) Load Reg. R with Location (HL)\nLD R,(IX+D) Load Reg. R with Location (IX+D)\nLD R,(IY+D) Load Reg. R with Location (IY+D)\nLD R,N Load Reg. R with value N\nLD R,R' Load Reg. R with Reg. R'\nLD SP,HL Load SP with HL\nLD SP,IX Load SP with IX\nLD SP,IY Load SP with IY\nLDD Load Location (DE) with Location (HL),\n Decrement DE, HL and BC\nLDDR Load Location (DE) with Location (HL),\n Decrement DE, HL and BC, repeat until\n BC=0\nLDI Load Location (DE) with Location (HL),\n Increment DE, HL, Decrement BC\nLDIR Load Location (DE) with Location (HL),\n Increment DE, HL, Decrement BC and\n repeat until BC=0\nNEG Negate Acc. (2's complement)\nNOP No Operation\nOR S Logical 'OR' of operand S and Acc.\nOTDR Load Output Port (C) with Location (HL),\n Decrement HL and B, repeat until B=0\nOTIR Load Output Port (C) with Location (HL),\n Increment HL, Decrement B, repeat until\n B=0\nOUT (C),R Load Output Port (C) with Reg. R\nOUT (N), A\nLoad Output Port (N) with Acc.\n\nOUTD\nLoad Output Port (C) with Location (HL),\nDecrement HL and B\n\nOUTI\nLoad Output Port (C) with Location (HL),\nIncrement HL and Decrement B\n\nPOP IX\nLoad IX with top of stack\n\nPOP IY\nLoad IY with top of stack\n\nPOP SS\nLoad Reg. Pair SS with top of stack\n\nPUSH IX\nLoad IX onto stack\n\nPUSH IY\nLoad IY onto stack\n\nPUSH SS\nLoad Reg. Pair SS onto stack\n\nRES B,M\nReset Bit B of Operand M\n\nRET\nReturn from subroutine\n\nRET CC\nReturn from subroutine if condition CC is true\n\nRETI\nReturn from Interrupt\n\nRETN\nReturn from Non Maskable Interrupt\n\nRL M\nRotate Left through Carry Operand M\n\nRL\nRotate Left Acc. through Carry\n\nRLC (HL)\nRotate Location (HL) left circular\n\nRLC (IX+D)\nRotate Location (IX+D) left circular\n\nRLC (IY+D)\nRotate Location (IY+D) left circular\n\nRLC R\nRotate Reg. R left circular\n\nRLCA\nRotate left circular Acc.\n\nRLD\nRotate Digit left and right between Acc. and Location (HL)\n\nRR M\nRotate right through Carry Operand M\n\nRRA\nRotate right Acc. through Carry\n\nRRC M\nRotate Operand M right circular\n\nRRCA\nRotate right circular Acc.\n\nRRD\nRotate digit right and left between Acc. and Location (HL)\n\nRST P\nRestart to Location P\n\nSBC A,S\nSubtract operand S from Acc. with Carry\n\nSBC HL,SS\nSubtract Reg. pair SS from HL with Carry\n\nSCF\nSet Carry Flag (C=1)\n\nSET B,(HL)\nSet Bit B of Location (HL)\n\nSET B,(IX+D)\nSet Bit B of Location (IX+D)\n\nSET B,(IY+D)\nSet Bit B of Location (IY+D)\n<table>\n<thead>\n<tr>\n<th>Instruction</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SET B,R</td>\n<td>Set Bit B of Reg. R</td>\n</tr>\n<tr>\n<td>SLA M</td>\n<td>Shift operand M left arithmetic</td>\n</tr>\n<tr>\n<td>SRA M</td>\n<td>Shift operand M right arithmetic</td>\n</tr>\n<tr>\n<td>SRL M</td>\n<td>Shift operand M right logical</td>\n</tr>\n<tr>\n<td>SUB S</td>\n<td>Subtract operand S from Acc.</td>\n</tr>\n<tr>\n<td>XOR S</td>\n<td>Exclusive ‘OR’ operand S and Acc.</td>\n</tr>\n</tbody>\n</table>\n\n**Pseudo Instructions**\n\n<table>\n<thead>\n<tr>\n<th>Instruction</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ORG NN</td>\n<td>Sets Location counter (LC) to NN</td>\n</tr>\n<tr>\n<td>EQU NN</td>\n<td>Assigns value NN to Label</td>\n</tr>\n<tr>\n<td>DEFS E</td>\n<td>Increments LC by value of expression E</td>\n</tr>\n<tr>\n<td>DEFB E,E...</td>\n<td>Defines Byte (s) as E</td>\n</tr>\n<tr>\n<td>DEFW E,E...</td>\n<td>Defines Word (s) as E</td>\n</tr>\n<tr>\n<td>DEFM /S/</td>\n<td>Assigns String S to label</td>\n</tr>\n</tbody>\n</table>\n## Appendix C\n\n### ASCII CHARACTER CODES\n\n<table>\n<thead>\n<tr>\n<th>DEC</th>\n<th>HEX</th>\n<th>CHAR</th>\n<th>DEC</th>\n<th>HEX</th>\n<th>CHAR</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>32</td>\n<td>20</td>\n<td></td>\n<td>64</td>\n<td>40</td>\n<td></td>\n</tr>\n<tr>\n<td>33</td>\n<td>21</td>\n<td>!</td>\n<td>65</td>\n<td>41</td>\n<td>A</td>\n</tr>\n<tr>\n<td>34</td>\n<td>22</td>\n<td>"</td>\n<td>66</td>\n<td>42</td>\n<td>B</td>\n</tr>\n<tr>\n<td>35</td>\n<td>23</td>\n<td>#</td>\n<td>67</td>\n<td>43</td>\n<td>C</td>\n</tr>\n<tr>\n<td>36</td>\n<td>24</td>\n<td>$</td>\n<td>68</td>\n<td>44</td>\n<td>D</td>\n</tr>\n<tr>\n<td>37</td>\n<td>25</td>\n<td>%</td>\n<td>69</td>\n<td>45</td>\n<td>E</td>\n</tr>\n<tr>\n<td>38</td>\n<td>26</td>\n<td>&</td>\n<td>70</td>\n<td>46</td>\n<td>F</td>\n</tr>\n<tr>\n<td>39</td>\n<td>27</td>\n<td>'</td>\n<td>71</td>\n<td>47</td>\n<td>G</td>\n</tr>\n<tr>\n<td>40</td>\n<td>28</td>\n<td>(</td>\n<td>72</td>\n<td>48</td>\n<td>H</td>\n</tr>\n<tr>\n<td>41</td>\n<td>29</td>\n<td>)</td>\n<td>73</td>\n<td>49</td>\n<td>I</td>\n</tr>\n<tr>\n<td>42</td>\n<td>2A</td>\n<td>*</td>\n<td>74</td>\n<td>4A</td>\n<td>J</td>\n</tr>\n<tr>\n<td>43</td>\n<td>2B</td>\n<td>+</td>\n<td>75</td>\n<td>4B</td>\n<td>K</td>\n</tr>\n<tr>\n<td>44</td>\n<td>2C</td>\n<td>,</td>\n<td>76</td>\n<td>4C</td>\n<td>L</td>\n</tr>\n<tr>\n<td>45</td>\n<td>2D</td>\n<td>-</td>\n<td>77</td>\n<td>4D</td>\n<td>M</td>\n</tr>\n<tr>\n<td>46</td>\n<td>2E</td>\n<td>.</td>\n<td>78</td>\n<td>4E</td>\n<td>N</td>\n</tr>\n<tr>\n<td>47</td>\n<td>2F</td>\n<td>/</td>\n<td>79</td>\n<td>4F</td>\n<td>O</td>\n</tr>\n<tr>\n<td>48</td>\n<td>30</td>\n<td>0</td>\n<td>80</td>\n<td>50</td>\n<td>P</td>\n</tr>\n<tr>\n<td>49</td>\n<td>31</td>\n<td>1</td>\n<td>81</td>\n<td>51</td>\n<td>Q</td>\n</tr>\n<tr>\n<td>50</td>\n<td>32</td>\n<td>2</td>\n<td>82</td>\n<td>52</td>\n<td>R</td>\n</tr>\n<tr>\n<td>51</td>\n<td>33</td>\n<td>3</td>\n<td>83</td>\n<td>53</td>\n<td>S</td>\n</tr>\n<tr>\n<td>52</td>\n<td>34</td>\n<td>4</td>\n<td>84</td>\n<td>54</td>\n<td>T</td>\n</tr>\n<tr>\n<td>53</td>\n<td>35</td>\n<td>5</td>\n<td>85</td>\n<td>55</td>\n<td>U</td>\n</tr>\n<tr>\n<td>54</td>\n<td>36</td>\n<td>6</td>\n<td>86</td>\n<td>56</td>\n<td>V</td>\n</tr>\n<tr>\n<td>55</td>\n<td>37</td>\n<td>7</td>\n<td>87</td>\n<td>57</td>\n<td>W</td>\n</tr>\n<tr>\n<td>56</td>\n<td>38</td>\n<td>8</td>\n<td>88</td>\n<td>58</td>\n<td>X</td>\n</tr>\n<tr>\n<td>57</td>\n<td>39</td>\n<td>9</td>\n<td>89</td>\n<td>59</td>\n<td>Y</td>\n</tr>\n<tr>\n<td>58</td>\n<td>3A</td>\n<td>:</td>\n<td>90</td>\n<td>5A</td>\n<td>Z</td>\n</tr>\n<tr>\n<td>59</td>\n<td>3B</td>\n<td>;</td>\n<td>91</td>\n<td>5B</td>\n<td>E</td>\n</tr>\n<tr>\n<td>60</td>\n<td>3C</td>\n<td><</td>\n<td>92</td>\n<td>5C</td>\n<td>\\</td>\n</tr>\n<tr>\n<td>61</td>\n<td>3D</td>\n<td>=</td>\n<td>93</td>\n<td>5D</td>\n<td>J</td>\n</tr>\n<tr>\n<td>62</td>\n<td>3E</td>\n<td>></td>\n<td>94</td>\n<td>5E</td>\n<td>^</td>\n</tr>\n<tr>\n<td>63</td>\n<td>3F</td>\n<td>?</td>\n<td>95</td>\n<td>5F</td>\n<td>_</td>\n</tr>\n<tr>\n<td>DEC</td>\n<td>HEX</td>\n<td>CHAR</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</tr>\n<tr>\n<td>96</td>\n<td>60</td>\n<td>'</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>97</td>\n<td>61</td>\n<td>a</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>98</td>\n<td>62</td>\n<td>b</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>99</td>\n<td>63</td>\n<td>c</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>100</td>\n<td>64</td>\n<td>d</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>101</td>\n<td>65</td>\n<td>e</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>102</td>\n<td>66</td>\n<td>f</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>103</td>\n<td>67</td>\n<td>g</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>104</td>\n<td>68</td>\n<td>h</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>105</td>\n<td>69</td>\n<td>i</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>106</td>\n<td>6A</td>\n<td>j</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>107</td>\n<td>6B</td>\n<td>k</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>108</td>\n<td>6C</td>\n<td>l</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>109</td>\n<td>6D</td>\n<td>m</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>110</td>\n<td>6E</td>\n<td>n</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>111</td>\n<td>6F</td>\n<td>o</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>DEC</th>\n<th>HEX</th>\n<th>CHAR</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>112</td>\n<td>70</td>\n<td>p</td>\n</tr>\n<tr>\n<td>113</td>\n<td>71</td>\n<td>q</td>\n</tr>\n<tr>\n<td>114</td>\n<td>72</td>\n<td>r</td>\n</tr>\n<tr>\n<td>115</td>\n<td>73</td>\n<td>s</td>\n</tr>\n<tr>\n<td>116</td>\n<td>74</td>\n<td>t</td>\n</tr>\n<tr>\n<td>117</td>\n<td>75</td>\n<td>u</td>\n</tr>\n<tr>\n<td>118</td>\n<td>76</td>\n<td>v</td>\n</tr>\n<tr>\n<td>119</td>\n<td>77</td>\n<td>w</td>\n</tr>\n<tr>\n<td>120</td>\n<td>78</td>\n<td>x</td>\n</tr>\n<tr>\n<td>121</td>\n<td>79</td>\n<td>y</td>\n</tr>\n<tr>\n<td>122</td>\n<td>7A</td>\n<td>z</td>\n</tr>\n<tr>\n<td>123</td>\n<td>7B</td>\n<td><</td>\n</tr>\n<tr>\n<td>124</td>\n<td>7C</td>\n<td></td>\n</tr>\n<tr>\n<td>125</td>\n<td>7D</td>\n<td>></td>\n</tr>\n<tr>\n<td>126</td>\n<td>7E</td>\n<td>~</td>\n</tr>\n<tr>\n<td>127</td>\n<td>7F</td>\n<td>$</td>\n</tr>\n</tbody>\n</table>\n\nCodes less than Decimal 32 are control codes\nCommon are (in Decimal):\n\n07 Bell\n10 Line Feed\n12 Form Feed\n13 Carraige Return\nBernard Babani BP112\n\nA Z-80 Workshop Manual\n\n- The Z-80 is generally acknowledged to be one of the most powerful 8-bit microprocessors available, and is used in many popular microcomputers including the TRS-80, Spectrum, ZX81 and Nascom machines, etc.\n\n- This book is intended for people who wish to progress beyond the stage of Basic programming to topics such as machine-code and assembly-language programming or need hardware details of the Z-80 based computer.\n\n- Starting with a review of computer principles, the book describes typical machine-code instructions followed by a detailed description of the Z-80 instruction set. Assembly language programming is discussed with examples.\n\n- Also given are hardware details of the Z-80 and the use of associated I/O devices such as UARTs, PIOs and CTCs.\n\n- This book is not purely a descriptive text, however, Z-80 hex machine-code and assembler instructions are given in tabular form, along with in-out connections for the Z-80 and the associated devices. It will therefore also be a useful reference book for the more experienced user."}}},{"rowIdx":194,"cells":{"id":{"kind":"string","value":"a552e0a6a7f84f7dd646c9ac91b18369cb5c2990"},"text":{"kind":"string","value":"YAWL - Technical Manual\n\nVersion 4.3\n\n© 2004–2020 The YAWL Foundation\n## Contents\n\n1 Introduction .................................................. 7\n 1.1 What is YAWL? ............................................ 7\n 1.2 Obtaining the Latest Version of YAWL .................... 8\n 1.3 The YAWL Foundation .................................... 8\n 1.4 Documentation ........................................... 8\n\n2 The Main Engine Classes .................................. 11\n 2.1 Elements Package [org.yawlfoundation.yawl.elements] .......... 11\n 2.2 State Package [org.yawlfoundation.yawl.elements.state] .......... 12\n 2.3 Engine Package [org.yawlfoundation.yawl.engine] ............. 12\n\n3 YAWL Custom Services: Creation and Deployment .......... 13\n 3.1 Fundamentals ............................................ 13\n 3.2 A Simple Custom Service ................................ 17\n 3.3 Deployment .............................................. 23\n 3.4 Additional Topics ....................................... 28\n 3.5 Other Engine Interfaces .................................. 33\n\n4 Implementing In-Process Custom Services .................. 43\n 4.1 Introduction ............................................ 43\n 4.2 The InterfaceB Observer Gateway ......................... 44\n 4.3 Interface Design ........................................ 44\n 4.4 Custom Service URLs .................................... 45\n 4.5 Implementing the Manager Class ......................... 46\n 4.6 Registering with the YAWL Engine ....................... 50\n\n5 The Resource Service ....................................... 51\n 5.1 Custom Forms ............................................ 51\n\n6 The Worklet Service ........................................ 55\n 6.1 Worklet Gateway Client .................................. 55\n 6.2 Worklet Event Listeners .................................. 61\n\n7 The Editor .................................................. 65\nDocument Control\n\n<table>\n<thead>\n<tr>\n<th>Author</th>\n<th>Version</th>\n<th>Date</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Arthur ter Hofstede</td>\n<td>version 1.9</td>\n<td>September 2008</td>\n<td>Consolidation of ten previous documents, conversion to LATEX of nine of them, general cleaning and extensions.</td>\n</tr>\n<tr>\n<td>Stephan Clemens</td>\n<td>version 1.91</td>\n<td>September 2008</td>\n<td>Input for installation section.</td>\n</tr>\n<tr>\n<td>Michael Adams</td>\n<td>version 2.1</td>\n<td>August 2010</td>\n<td>Major rewrite and upgrade for 2.1. First public release of manual.</td>\n</tr>\n<tr>\n<td>Michael Adams</td>\n<td>version 2.2</td>\n<td>August 2011</td>\n<td>Enhancement and upgrade for 2.2.</td>\n</tr>\n<tr>\n<td>Michael Adams</td>\n<td>version 4.3</td>\n<td>February 2020</td>\n<td>Updates for YAWL version 4.</td>\n</tr>\n</tbody>\n</table>\n\nOriginal Sources\n\nThe first version of this document (1.9) combined the following earlier documents:\n\n1. A “Connecting Custom Services to the YAWL Engine” (Beta 7 Release) document by Marlon Dumas, Tore Fjellheim and Lachlan Aldred. This document has been entirely replaced by Chapter 3, written by Michael Adams.\n\n2. A “YAWL Core Classes Cheat Sheet - A Short Architectural Introduction” (Beta 7 Release) by Lachlan Aldred. This forms the basis for Chapter 2.\n\n3. A “Implementing In-Process Custom Services” document created by Andrew Hastie, subsequently reviewed and refined by Lachlan Aldred, and later refined and updated by Michael Adams. This forms the basis for Chapter 4.\n\n4. A “YAWL - Time Service Manual” (Beta 7 Release) document first created by Sean Kneipp with later updates by Tore Fjellheim and Lachlan Aldred. The Time Service has since been deprecated and so this document has been removed from the manual.\n\n5. An “Installation Manual” (Engine Beta 8.2 - Editor 1.5) first created by Sean Kneipp and with subsequent changes/corrections/extensions by Guy Redding, Lachlan Aldred, Petia Wohed, Michael Adams, Moe Wynn, and Marcello La Rosa. An extract forms the basis for Chapter ?? (a large part was transferred to the User Manual). Its introduction forms the basis for Chapter 1.\n\n6. A document on Interface B first created by Michael Adams with a later addition by Tore Fjellheim. Parts of the document have been folded into Chapter 3.\n\n7. A document on Interface D created by Guy Redding. Interface D has since been deprecated and so this document has been removed from the manual.\n8. A document on Interface X created by Michael Adams. This forms the basis for Section 3.5.3 of Chapter 3.\n\n9. A “YAWLEditor Technical Manual” created by Lindsay Bradford. This document was modified by Michael Adams and became Chapter 7.\n\n10. A “newYAWL Resource Perspective Requirements Analysis” document created by Lindsay Bradford. This document was copied into Appendix B.\nChapter 1\n\nIntroduction\n\nThis chapter provides a brief background introduction to YAWL and the YAWL Foundation.\n\n1.1 What is YAWL?\n\nBased on a rigorous analysis of existing workflow management systems and workflow languages, a new workflow language called YAWL (Yet Another Workflow Language) was developed by Wil van der Aalst (Eindhoven University of Technology, the Netherlands) and Arthur ter Hofstede (Queensland University of Technology, Australia) in 2002. This language was based on the one hand on Petri nets, a well-established concurrency theory with a graphical representation, and on the other hand on the well-known Workflow Patterns (www.workflowpatterns.com). The Workflow Patterns form a generally accepted benchmark for the suitability of a process specification language. Petri nets can capture quite a few of the identified control-flow patterns, but they lack support for the multiple instance patterns, the cancellation patterns and the generalised OR-join. YAWL therefore extends Petri nets with dedicated constructs to deal with these patterns.\n\nYAWL offers the following distinctive features:\n\n- YAWL offers comprehensive support for the control-flow patterns. It is the most powerful process specification language for capturing control-flow dependencies.\n- The data perspective in YAWL is captured through the use of XML Schema, XPath and XQuery.\n- YAWL offers comprehensive support for the resource patterns. It is the most powerful process specification language for capturing resourcing requirements.\n- YAWL has a proper formal foundation. This makes its specifications unambiguous and automated verification becomes possible (YAWL offers two distinct approaches to verification, one based on Reset nets, the other based on transition invariants through the WofYAWL editor plug-in).\n- YAWL has been developed independent from any commercial interests. It simply aims to be the most powerful language for process specification.\n- For its expressiveness, YAWL offers relatively few constructs (compare this e.g. to BPMN!).\n- YAWL offers unique support for exceptional handling, both those that were and those that were not anticipated at design time.\n- YAWL offers unique support for dynamic workflow through the Worklets approach. Workflows can thus evolve over time to meet new and changing requirements.\n• YAWL aims to be straightforward to deploy. It offers a number of automatic installers and an intuitive graphical design environment.\n\n• Through the BPMN2YAWL component, BPMN models can be mapped to the YAWL environment for execution.\n\n• The Declare component (released through declare.sf.net) provides unique support for specifying workflows in terms of constraints. This approach can be combined with the Worklet approach thus providing very powerful flexibility support.\n\n• YAWL’s architecture is Service-oriented and hence one can replace existing components with one’s own or extend the environment with newly developed components.\n\n• The YAWL environments supports the automated generation of forms. This is particularly useful for rapid prototyping purposes.\n\n• Tasks in YAWL can be mapped to human participants, Web Services, external applications or to Java classes.\n\n• Through the C-YAWL approach a theory has been developed for the configuration of YAWL models. For more information on process configuration visit www.processconfiguration.com.\n\n• Simulation support is offered through a link with the ProM (www.processmining.org) environment. Through this environment it is also possible to conduct post-execution analysis of YAWL processes (e.g. in order to identify bottlenecks).\n\n1.2 Obtaining the Latest Version of YAWL\n\nAs new versions of the YAWL Environment are released to the public, they will be available for download at the YAWL Github website (https://github.com/yawlfoundation/yawl). From this site it is also possible to access and/or clone the source code of all components for development purposes.\n\n1.3 The YAWL Foundation\n\nFor up-to-the-minute information on any aspect of the YAWL Initiative, visit the YAWL Foundation Homepage (yawlfoundation.org). The YAWL Foundation is a non-profit organisation that acts as custodian of all intellectual property (IP) related to YAWL and its support environment.\n\n1.4 Documentation\n\nApart from this technical manual, there is a user manual on YAWL and a number of case studies. These studies provide detailed examples that you may wish to consult in order to obtain a deeper understanding of the application of YAWL.\n\nThis manual does not really cover the control-flow concepts of YAWL in detail. One reason for this is that there are quite a few papers out there that do provide this information. We refer the reader to e.g. [4] for a justification of the extensions of Petri nets introduced for YAWL on the basis of the original control-flow patterns. The main paper on YAWL, from a language point of view, is [5]. In this paper you find a formalisation of the control-flow concepts of YAWL. More recently, a CPN formalisation of newYAWL (control-flow, data and resource perspectives) was presented in [17]. For a formalisation of the OR-join, a complex synchronisation concept in YAWL, we refer to [21]. This definition supersedes the definition provided in [5].\nAs mentioned above, YAWL extends Petri nets. There are a number of general introductions to Petri nets in the literature. We refer the interested reader to [13, 11].\n\nWil van der Aalst has written much about the application of Petri nets to workflow, see e.g. [1]. The subclass of Petri nets introduced by him, Workflow-nets, is a predecessor of YAWL. The textbook that he wrote together with Kees van Hee is highly recommended reading [3].\n\nA recent textbook on Business Process Management (BPM), which covers the original control-flow patterns and also YAWL, was written by Mathias Weske [19]. This textbook also covers other approaches, such as the modelling standard BPMN (note that the BPMN2YAWL tool can convert these specifications to YAWL).\n\nOn the YAWL web site (yawlfoundation.org) it can be seen how the original control-flow patterns can be realised in YAWL (follow the link on Resources and then click ‘patterns’). For control-flow patterns in newYAWL the reader can consult appendix A.1 of Nick Russell’s PhD thesis [17].\n\nIf you would like to know more about how verification of YAWL specifications really works, we refer you to [18] and to [20]. This work forms the theoretical basis of how the verification mechanisms are realised in the YAWL editor.\n\nIn-depth discussion of YAWL’s exception handling framework from a conceptual point of view can be found in [17, 15] and from an implementation aspect in [6, 7]. YAWL’s worklet approach to dealing with on-the-fly changes to workflows is discussed in [6, 8].\n\nThe reader that is interested in declarative specification of workflow is referred to [12]. On the Declare web site, declare.sf.net, the Declare service for YAWL can be downloaded. Further documentation about this approach can also be found there.\n\nYAWL has a close link to the Process Mining environment ProM [2], www.processmining.org. This link is for example exploited in [14] to provide simulation support for YAWL. There exists support for exporting YAWL logs to ProM which can subsequently be analysed by one of the many mining plug-ins available in this environment.\n\nAlternative ways of presenting work lists have been addressed in [9]. In this Visualiser framework users can choose a map (not just a geographical map, but also e.g. a timeline or a YAWL specification) and work items can be positioned on this map and be shown in a colour that reflects their level of urgency (a context-specific notion which can be defined for the user). Support for the visualiser framework is provided via the default YAWL worklist handler.\n\nFinally, a textbook on YAWL, called Modern Business Process Automation: YAWL and its Support Environment has been published by Springer (2010; ISBN: 978-3-642-03120-5) [10]. The book provides a comprehensive treatment of the field of Business Process Management (BPM) with a focus on Business Process Automation. It achieves this by covering a wide range of topics, both introductory and advanced, illustrated through and grounded in the YAWL language and support environment.\nChapter 2\n\nThe Main Engine Classes\n\nThis chapter is a very brief overview of the main YAWL engine classes and packages, which is designed to sufficiently orient the reader so that he/she can get started. It is not intended to be comprehensive, but as a starting point from which further exploring can take place.\n\nThis chapter is intended for developers who are directly interacting with the core engine classes and packages. The reader is assumed to already have some proficiency in defining a business process specification in YAWL.\n\n2.1 Elements Package [org.yawlfoundation.yawl.elements]\n\nThis package contains the elements of a yawl process model, i.e. those things that a process modeller thinks about when designing a process, such as the Atomic Tasks, Composite Tasks etc. The most important classes are:\n\nYSpecification: objects of this class are the outer container of a process model. Such an object is a process specification/model. A process specification in YAWL basically contains a set of YNets (process nets).\n\nYDecomposition: an abstract class sub-classed by YNet and YAWLServiceGateway. These classes are the equivalent of a net and task decomposition respectively.\n\nYNet: an object of this class contains a set of inter-connected tasks (action elements) and conditions (stateful elements). In addition to the parameter definitions inherited from its superclass (YDecomposition) YNet allows local variables to be defined.\n\nYTask: This abstract class is the superclass of the two types of concrete task (YAtomicTask & YCompositeTask). This class contains possibly the lion’s share of the business process execution logic. It also contains many internal state elements (such as YInternalCondition).\n\nYAtomicTask: an atomic task represents an atomic unit of work (from the perspective of the workflow engine).\n\nYCompositeTask: a composite task represents a task that decomposes down to a sub-net (i.e. another YNet object).\n\nYAWLServiceGateway: in order for an atomic task to actually do something it needs to decompose to a YAWLServiceGateway. Think of this a special kind of decomposition for an atomic task. It is basically used to define the input parameters and output parameters of the task, and it can optionally define which YAWL Custom Service must be invoked when its task is enabled.\n\nYCondition: a condition is like a place in Petri nets. It is a sibling member to the tasks inside any net. They typically sit between tasks, and store the process state ‘identifiers’ (‘tokens’ in Petri speak). When two tasks are directly connected together in a YAWL process model (in the XML syntax), an “invisible” condition is created between the tasks, when the process is loaded into the engine.\n**YFlow:** objects of this class represent the arcs that join tasks to conditions in a process model. They refer to both their preceding task/condition and to their succeeding task/condition. Likewise each task/condition is “aware” of the flows preceding it, and the flows succeeding it. Therefore tasks/conditions, and their flows form up a bi-directional linked list, of sorts (except it’s more of a graph than a list, but you get the idea).\n\n### 2.2 State Package [org.yawlfoundation.yawl.elements.state]\n\nThis is an important package and contains classes used to store and process the state of the process control flow. Therefore, state does not refer to the variables and parameters of the process, but state as in which tasks are active, enabled etc. Important classes include:\n\n- **YIdentifier:** objects of this class represent the things that flow through the YNets indicating its process state. If you are familiar with Petri nets then consider the references to objects of this class the tokens. Due to the fact that composite tasks contain nets of their own the identifiers are capable of creating children. The children pass through the subordinate nets. This idea is fully described in the YAWL Book [10].\n\n### 2.3 Engine Package [org.yawlfoundation.yawl.engine]\n\nThis is the package responsible for running the process and progressing it through its elements as per its control flow. Important classes of this package are:\n\n- **YEngine:** this singleton is responsible for storing all of the active process specifications in object format. It is also a single control point for all operations over running process instances, e.g. launching cases, starting work-items (check-out), completing work-items (check-in), cancelling cases etc. It delegates some of these process instance controlling operations to some YNetRunner (see below) objects, however the engine stores and aggregates each YNetRunner instance and correlates it with the YIdentifier object running through it.\n\n- **YNetRunner:** Executes its YNet instance. Each YNet instance is essentially scheduled and controlled by YNetRunner. When an XML process specification gets loaded into the engine some instances of YNet get created. Collectively, these YNet instances form the process template. When a process instance (case) is launched, each YNet instance gets deep-cloned by the engine, and the copy is then wrapped by the YNetRunner, which executes it.\n\n- **YWorkItem:** objects of this class are created when a task is enabled. Their identification consists of the net based YIdentifier and the Task identifier. When an enabled task is checked out a new workitem is spawned off from the enabled workitem. It is not just a matter of changing state from ‘enabled’ to ‘fired’ due to the fact that some tasks are multi-instance. Therefore all ‘fired’ work items are children of their previously enabled parents.\n\n- **YWorkItemRepository:** is a store of work-item instances for the engine.\n\n- **YNetRunnerRepository:** is a store of YNetRunner instances for the engine.\nChapter 3\n\nYAWL Custom Services: Creation and Deployment\n\nDuring the execution of a YAWL specification instance, the YAWL Workflow Enactment Engine (the Engine, for short) is essentially responsible for two things:\n\n1. The correct scheduling of tasks, according to the control-flow defined within the specification; that is, determining the order of task execution.\n2. The management of the data input into, and output from, each task, and its interplay with the task’s containing net and/or the external environment.\n\nHowever, the Engine is not responsible for the actual execution of the task. For each and every atomic task scheduled by the Engine for execution, responsibility for its execution is delegated by the Engine to a so-called YAWL Custom Service.\n\nA YAWL Custom Service may be defined as a web-based service that is able to (i) receive notifications from the Engine when a task is scheduled to be delegated to it; (ii) inform the Engine that it has taken responsibility for its execution; (iii) perform the task’s activities, as appropriate; and then (iv) inform the Engine that the task’s execution has completed, allowing the Engine to continue processing the specification instance and determine the next task(s) for scheduling (if the instance has not completed). This service-oriented, delegated execution framework is the extensibility cornerstone of the YAWL System.\n\nAt design time, each and every atomic task in a specification is associated with a Custom Service. The association is either explicitly set by a designer, or else implicitly with whatever Custom Service is configured in the Engine to be the “Default Worklist Handler” (which by default is the Resource Service). At runtime, when a task is scheduled, the Engine will notify whichever Custom Service has been associated with the task that there is a task ready to be delegated to it.\n\nThis chapter describes how to create and deploy a YAWL Custom Service. Note that Custom Services are defined as services that are responsible for runtime task execution, and thus form a subset of a more general class of services and applications that may interact with the YAWL Engine, such as the YAWL Monitor Service and the YAWL Editor, both of which do not execute tasks. While the description that follows focusses on YAWL Custom Services, much of what is discussed is also applicable to the interactions of those more general services and applications.\n\n3.1 Fundamentals\n\nCustom Services interact with the YAWL Engine through XML/HTTP messages processed by certain endpoints, some located on the Engine side and others on the service side. In principle, Custom Services can\nbe developed in any programming language and can be deployed on any platform capable of sending and receiving HTTP messages, and may be deployed locally or remotely to the Engine. Custom Services are registered with the Engine by specifying basic authentication credentials, and a location in the form of a “base URL”. Once registered, a Custom Service may receive XML messages from the Engine at endpoints identified by URLs derived from the base URL provided at registration. On the other hand, the Custom Service can send XML messages to the Engine at endpoints identified by URLs that the Custom Service is assumed to know.\n\nA collection of Java classes included in the YAWL distribution provide several APIs that can be used to implement the required endpoints without requiring any knowledge about the URL encoding and XML formatting used. Specifically, a Custom Service will use an API known collectively as *Interface B* to define the interactions involved in taking responsibility for and performing the execution of a task’s activities. Four basic interactions are particularly relevant at this stage (Figure 3.1):\n\n1. The interaction that the engine initiates to notify that a task is scheduled for execution. Immediately prior to the notification, the Engine creates a new work item, using the task definition as a template, and marks its status as enabled. The notification message generated by the Engine contains various identifiers describing the work item, such as case id, name, specification identifiers and so on.\n\n2. The interaction that the service initiates to inform the Engine that it is ready to perform the work item, known as a check-out of the work item. When this occurs, the Engine processes the work item’s input data, and includes it in the data structure returned to the Custom Service. The Engine also moves the work item state from “enabled” to “executing”, denoting that a Custom Service is currently executing the work item (i.e. the work item is “in progress”).\n\n3. The interaction that the Engine may initiate to notify a Custom Service that a work item in the “executing” state should be cancelled.\n\n4. The interaction that the Custom Service initiates to indicate that it has completed execution of the work item, known as a check-in of the work item and its output data back to the engine, which moves the work item from “executing” to “completed” state.\n\n\nAn overview of the various interfaces in the YAWL Environment is shown in Figure 3.2. This Chapter describes the interfaces between the YAWL Engine and external services (i.e. Interfaces A, B, E and X). The interfaces managed by the Resource Service are discussed in Chapter 5.\n\nBefore delving further into Custom Services, it is important to have a clear understanding of the following points:\n\n1. The Difference Between Atomic and Composite Tasks\n An atomic task represents a unit of work that typically is to be performed by an external entity, such as a person, web service or application, and is executed by delegating its activities to a Custom Service. A composite task represents a placeholder for a sub-net, and is executed by decomposing (or unfolding) into the sub-net contained within it, and scheduling the contents of the sub-net as per its control-flow. A composite task is never delegated to a Custom Service.\n\n2. The Difference Between a Task and a Work Item\n Amongst other elements, a YAWL process specification contains a number of atomic tasks which describe a unit of work to be performed as a part of the overall process. That is, each atomic task is a definition of the work to be performed, and includes definitions of its\n\n---\n\n1For the inquiring reader, the concepts discussed here and throughout this chapter are covered in much greater detail in [10]\ncontrol-flow, data and resourcing aspects. At runtime, each atomic task definition acts as a template for the creation of one or more work items. That is, a work item is a runtime instance derived from an atomic task definition. An analogy might be: an atomic task is to a work item as a blueprint is to a house constructed from that blueprint. The lifetime of a task is equal to the lifetime of its containing process specification. The lifetime of a work item always falls within its containing process instance.\n\n**Task Decompositions** A task decomposition is essentially a ‘contract’ between an atomic task and the external environment. That is, each atomic task that is required to interact with an external entity (external to the Engine, such as a person, application or service) must reference a decomposition. Amongst other things, a decomposition is responsible for the definition of task-level input and output variables, and for specifying which Custom Service will be responsible for the task’s execution at runtime. Several atomic tasks in a process may reference the same decomposition. A task without a decomposition is a so-called empty task and is handled entirely within the Engine itself.\n\n**Work Item Creation** When the Engine determines that an atomic task is ready to be scheduled, it creates a work item derived from the task definition, sets the work item’s status to ‘Enabled’, and announces the work item’s enablement to the Custom Service specified in the task’s decomposition. Along with the announcement, an XML representation of the work item is passed to the Custom Service. An enabled work item does not contain instantiated data values for its input variables, since data mappings only take place immediately before the work item begins execution.\n\n**Work Item Check-out** When a Custom Service indicates to the Engine that it is ready to check-out a work item, the Engine takes the enabled work item and creates a clone of it. The status of the original work item is changed to ‘IsParent’, while the cloned work item (known as a child work item) is given the status ‘Executing’ and has its data values instantiated (the reasons for this mechanism will become clearer in the discussion of multiple-instance tasks later in this chapter). An XML representation of the child work item, including instantiated data values for its input variables, is returned to the Custom Service as the result of a successful check-out.\n\n**Work Item Identifiers** Each work item created by the Engine is given a unique identifier, which consists of two parts, a case index and a task identifier, separated by a colon (:). The task identifier also consists of two parts, the task’s name and a numeric string suffix assigned by the engine to ensure task identifier uniqueness, separated by an underscore (_). Thus, an example work item id for a task named ‘Enrol’ might be 123:Enrol_5. The case index value of an enabled work item equates to the case identifier of its containing net (thus ‘123’ in the example also refers to the case id of the root (or only) net of the process). When a task is set to ‘Executing’ status, a unique digit is added to its case index, using a dotted notation. So, for example, a parent work item with an identifier of 123:Enrol_5 may have an executing child with identifier 123.1:Enrol_5, to denote the first child work item created. Consequently, the work item passed to a Custom Service with a notification of enablement, and the work item returned to a Custom Service as the result of a successful check-out, refer to two different work items.\n\n**A Note on Resourcing** While the Engine is responsible for the control-flow and data perspectives of a process instance, it has no involvement in the resource perspective. That is, the Engine has no concept of how a work item is to be resourced, but delegates responsibility for that to a Custom Service (for example, the YAWL Resource Service). Therefore, concepts such as offering and allocation of work items do not exist within the Engine. Rather, the Engine merely schedules (enables) work items, and delegates their execution to Custom Services. How a Custom Service handles the delegation is entirely up to the Custom Service involved; for example, the Resource Service adds the necessary “semantic layers” on top of an enabled work item to denote it as ‘offered’ or ‘allocated’, but other Custom Services have no need for or knowledge of these added semantics.\n\nWith those points covered, the next section describes the creation of a simple Custom Service.\n3.2 A Simple Custom Service\n\nThis section describes the steps to follow to create a basic Custom Service. The YAWL Twitter Service will be used as a running example. The Twitter Service, which may be used to send a status update to Twitter, is an example of a very simple Custom Service; the entire service consists of a single class compiled from about 140 lines of Java code.\n\nAt the core of each Custom Service are the following Interface B classes:\n\n- **org.yawlfoundation.yawl.engine.interfce.interfaceB.InterfaceBEnvironmentBasedServer**\n This class is a Java servlet and is responsible for receiving event notifications from the Engine.\n\n- **org.yawlfoundation.yawl.engine.interfce.interfaceB.InterfaceBEnvironmentBasedClient**\n This class provides methods that allow a Custom Service to call specific endpoints on the engine side.\n\n- **org.yawlfoundation.yawl.engine.interfce.interfaceB.InterfaceBWebsideController**\n An abstract utility class that encapsulates much of the functionality of the other two classes, and is designed to be extended by the primary class of each Custom Service.\n\nThese classes (and their dependent classes, as explained later) may be sourced from the YAWL engine distribution (.war file), or any existing Custom Service distribution, or the yawl-lib jar, or the YAWL Standalone jar file.\n\n3.2.1 Creating the Service’s Primary Class\n\nThe first step is to create a new class that extends from **InterfaceBWebsideController** – this will be the main class (and in the case of the Twitter Service, the only class) of the new Custom Service. Besides a number of helper methods and data members that the Custom Service inherits, **InterfaceBWebsideController** contains two abstract methods that all Custom Services must implement:\n\n- **public void handleEnabledWorkItemEvent(WorkItemRecord workItemRecord)**\n This method is the endpoint of an Engine enabled work item event notification; that is, it is called when the Engine creates a new work item and places it in the enabled state, and the Custom Service containing the method is the one associated at design time with the work item.\n\n- **public void handleCancelledWorkItemEvent(WorkItemRecord workItemRecord)**\n This method is invoked when an enabled or executing work item is cancelled by the engine (e.g. due to a cancellation occurring within the process control-flow). In principle, after this method has been invoked, a Custom Service should not attempt to check-out or check-in the work item, and if the work item is in progress, its processing should be stopped².\n\nNote that only the Custom Service associated with a particular work item will receive notifications via these two methods.\n\nNotice that both methods pass a **WorkItemRecord** object to the Custom Service. As noted earlier, the Engine side of the API passes an XML String representation of a work item together with these event notifications; **InterfaceBWebsideController** unmarshals the XML String, using its values to construct an **org.yawlfoundation.yawl.engine.interfce.WorkItemRecord** object. **WorkItemRecord** is a convenience class designed to make it easier to interrogate the work item descriptors received without having to parse the XML itself. Table 3.1 contains the descriptors of a **WorkItemRecord** object; each has corresponding get and set methods, and each is stored as a String value, except for ‘datalist’, which is a JDOM Element. These members will be discussed as they arise later in this chapter.\n\n²Note that YAWL does not support any notion of “atomic execution”, so no “rollback” is required when a work item is cancelled.\nTable 3.1: Data members of a WorkItemRecord\n\n<table>\n<thead>\n<tr>\n<th>Data Member</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>allowsDynamicCreation</td>\n<td>‘true’ if dynamic work item creation is supported (multiple instance tasks only)</td>\n</tr>\n<tr>\n<td>caseID</td>\n<td>case index of the work item</td>\n</tr>\n<tr>\n<td>codelet</td>\n<td>codelet to invoke for this work item</td>\n</tr>\n<tr>\n<td>completedBy</td>\n<td>name of the service that checked the work item in</td>\n</tr>\n<tr>\n<td>completionTime</td>\n<td>date/time stamp of the work item’s completion time</td>\n</tr>\n<tr>\n<td>completionTimeMs</td>\n<td>work item’s completion time in milliseconds (as a String)</td>\n</tr>\n<tr>\n<td>customFormURL</td>\n<td>URL of the custom form to display for this work item</td>\n</tr>\n<tr>\n<td>dataList</td>\n<td>original data list Element (executing work items only)</td>\n</tr>\n<tr>\n<td>dataListString</td>\n<td>the data list as an XML String</td>\n</tr>\n<tr>\n<td>dataListUpdated</td>\n<td>updated data list element (executing work items only)</td>\n</tr>\n<tr>\n<td>dataListUpdatedString</td>\n<td>updated data list as an XML String</td>\n</tr>\n<tr>\n<td>edited</td>\n<td>‘true’ if data has been updated</td>\n</tr>\n<tr>\n<td>enablementTime</td>\n<td>date/time stamp of the work item’s enabled time</td>\n</tr>\n<tr>\n<td>enablementTimeMs</td>\n<td>work item’s enabled time in milliseconds (as a String)</td>\n</tr>\n<tr>\n<td>extendedAttributes</td>\n<td>work item’s task-level extended attributes</td>\n</tr>\n<tr>\n<td>firingTime</td>\n<td>date/time stamp of the work item’s firing time</td>\n</tr>\n<tr>\n<td>firingTimeMs</td>\n<td>work item’s firing time in milliseconds (as a String)</td>\n</tr>\n<tr>\n<td>logPredicateCompleted</td>\n<td>configurable log value for work item’s completion</td>\n</tr>\n<tr>\n<td>logPredicateStarted</td>\n<td>configurable log value for work item’s starting</td>\n</tr>\n<tr>\n<td>requiresManualResourcing</td>\n<td>‘true’ if work item requires resourcing</td>\n</tr>\n<tr>\n<td>resourceStatus</td>\n<td>current resourcing status of the work item</td>\n</tr>\n<tr>\n<td>specIdentifier</td>\n<td>the unique key value of the specification that contains this work item</td>\n</tr>\n<tr>\n<td>specURI</td>\n<td>the name of the specification that contains this work item</td>\n</tr>\n<tr>\n<td>specVersion</td>\n<td>the version of the specification that contains this work item</td>\n</tr>\n<tr>\n<td>startedBy</td>\n<td>name of the service that checked the work item out</td>\n</tr>\n<tr>\n<td>startTime</td>\n<td>date/time stamp of the work item’s start time</td>\n</tr>\n<tr>\n<td>startTimeMs</td>\n<td>work item’s start time in milliseconds (as a String)</td>\n</tr>\n<tr>\n<td>status</td>\n<td>current work item status</td>\n</tr>\n<tr>\n<td>tag</td>\n<td>user-defined value</td>\n</tr>\n<tr>\n<td>taskID</td>\n<td>the work item’s task identifier</td>\n</tr>\n<tr>\n<td>taskName</td>\n<td>the name of the task this work item was created from</td>\n</tr>\n<tr>\n<td>timerExpiry</td>\n<td>date/time stamp when the work item’s time will expire (if any)</td>\n</tr>\n<tr>\n<td>timerTrigger</td>\n<td>when the work item’s timer was or will be triggered</td>\n</tr>\n<tr>\n<td>uniqueID</td>\n<td>an added unique identifier (deprecated).</td>\n</tr>\n</tbody>\n</table>\n3.2.2 Implementing the handleEnabledWorkItemEvent method\n\nA Custom Service is responsible for ensuring that each work item delegated to it is checked out of the engine, and later returned to the Engine, together with its updated data as required, when it is deemed complete. The actions that a Custom Service performs between check-out and check-in are entirely in the hands of its developer. For simpler services, the basic technique is to encapsulate this behaviour within the implementation of the handleEnabledWorkItemEvent method, so that it checks out the enabled work item, performs the desired action, and then checks the work item back into the engine.\n\nBefore a Custom Service can successfully check out a work item (or perform any other action via the API), it must first establish a valid session with the Engine. There are two API methods inherited from InterfaceBWebSideController that serve this purpose:\n\n- **public String connect(String userID, String password)**\n Attempts to create a session with the engine by passing authentication credentials and returning a unique **session handle**.\n\n- **public boolean checkConnection(String sessionHandle)**\n Returns true if the session handle is currently valid.\n\nThe credentials passed to the connect method must match those entered for the Custom Service when it is registered with the Engine (see Section 3.3.4 for details). If successful, a session handle (String) is returned that should be stored by the service for subsequent use whenever an API method is called. The session will be maintained by the Engine for 60 minutes of inactivity (by default, or as configured); that is, a session handle will expire if it is not used in an API call within 60 consecutive minutes (each API call restarts the timer). The checkConnection method should therefore be called immediately before each API method call to ensure the session is still active.\n\nAs an illustration of what’s been discussed so far, Listing 3.1 shows the Twitter Service’s entire public-facing code, including the two abstract method implementations. Note the following:\n\n- The TwitterService class extends InterfaceBWebsideController (line 1).\n\n- A global String variable to store a session handle is declared (line 4).\n\n- Final userid and password variables are declared (lines 6 & 7). These credentials must match those registered for the service within the Engine. Note that InterfaceBWebsideController encrypts the password before it is sent across the API.\n\n- The two abstract ‘event’ methods mentioned above are implemented (lines 9–25, and line 27). Note that in this example the cancelled work item event is implemented as an empty method for simplicity (In the unlikely event that a cancel event is received while the handleEnabledWorkItemEvent method is still processing, it will be handled by catching the exception that will be thrown later by the checkinWorkItem method). More complex Custom Services would implement this method to stop processing of the work item and take any required compensatory actions.\n\n- The first thing the handleEnabledWorkItemEvent method does is to ensure it has a valid connection to the Engine. It does that by first calling its own connected method, and if that returns false, calls the connect method with the userid and password declared above, which if successful will assign a valid session handle value to the _handle variable. Again for simplicity, the handle is not checked again after the call to connect, since an invalid session handle will be caught by the checkOut method throwing an exception.\n\n- The connected method calls the checkConnection method only if the session handle is not currently null (lines 43–45).\n\n- Again for simplicity, the catch block (lines 21–23) handles any Exception generically; it is recommended, of course, that each of the exceptions that may be thrown in the try block is handled in a more appropriate way.\npublic class TwitterService extends InterfaceBWebsideController {\n\n // holds a session handle to the engine\n private String _handle = null;\n\n private final String _engineUser = \"twitterService\";\n private final String _enginePassword = \"yTwitter\";\n\n public void handleEnabledWorkItemEvent(WorkItemRecord wir) {\n try {\n // connect only if not already connected\n if (!connected()) _handle = connect(_engineUser, _enginePassword);\n\n // checkout ... process ... checkin\n wir = checkOut(wir.getID(), _handle);\n String result = updateStatus(wir);\n checkInWorkItem(wir.getID(), wir.getDataList(),\n getOutputData(wir.getTaskID(), result), null, _handle);\n }\n catch (Exception ioe) {\n ioe.printStackTrace();\n }\n }\n\n public void handleCancelledWorkItemEvent(WorkItemRecord workItemRecord) {\n }\n\n // have to implement abstract method, but have no need for this event\n public void describeRequiredParams() {\n YParameter[] params = new YParameter[2];\n params[0] = new YParameter(null, YParameter.INPUT_PARAM_TYPE);\n params[0].setDataTypeAndName(\"string\", \"status\", XSD_NAMESPACE);\n params[0].setDocumentation(\"The status message to post to Twitter\");\n\n params[1] = new YParameter(null, YParameter.OUTPUT_PARAM_TYPE);\n params[1].setDataTypeAndName(\"string\", \"result\", XSD_NAMESPACE);\n params[1].setDocumentation(\"The status result or error message returned\");\n return params;\n }\n\n private boolean connected() throws IOException {\n return _handle != null && checkConnection(_handle);\n }\n}\n\nListing 3.1: The Twitter Service’s public methods\nAfter the connection has been established and/or checked, the method `checkOut` is invoked to check out the enabled work item. This method requires two parameters: the enabled work item’s ID, which is retrieved by using the `WorkItemRecord#getID()` method, and a valid session handle (see Listing 3.1, line 16). If successful, the `checkOut` method returns a `WorkItemRecord` representing the executing, child work item. Remember, the `WorkItemRecord` returned by the `checkout` method represents a different work item instance from the one passed to the `handleEnabledWorkItemEvent` method:\n\n- their identifiers are different.\n- the checked-out work item has ‘Executing’ status (instead of ‘Enabled’).\n- the checked-out work item has an instantiated `datalist`.\n\n**ASIDE:** The TwitterService, like most simpler Custom Services, reuses the same `WorkItemRecord` object to store the checked-out work item, effectively discarding the original, since it has no further need to reference the initial, enabled work item. More complex Custom Services may need to keep the original work item as well, in which case the distinction between them becomes very important.\n\nOnce the work item has been checked-out, the Custom Service can perform the appropriate actions for it. In our example, an `updateStatus` method is called (line 17 of Listing 3.1), which takes the data contained in the work item and uses it to connect to Twitter, pass it the specified status update and retrieve the resulting message (the actual machinations of how this is achieved is not of concern here).\n\nWhen the appropriate action has been completed, the work item can be checked back into the Engine by calling the `checkInWorkItem` method. The method has five parameters:\n\n- **String `itemid`**: the identifier of the work item being checked in. Note that this must be the identifier of the checked-out work item, and not that of the work item passed to the `handleEnabledWorkItemEvent` method.\n- **Element `inputData`**: the set of input data variables and values as contained in the checked-out work item. In almost all cases, a call to the `WorkItemRecord`’s `getDataList` method is used to fulfil this parameter.\n- **Element `outputData`**: the set of output data variables and values required (see below for more).\n- **String `logPredicate`**: a piece of configured text to be logged in the Engine’s process logs along with other logged values representing this work item’s completion. A `null` argument is acceptable if there is no log predicate.\n- **String `handle`**: a valid session handle.\n\nThe `outputData` parameter requires a correctly formatted JDOM Element containing a complete list of output data variables and values expected by the Engine for this work item. Our TwitterService example uses a `getOutputData` method to construct an appropriate Element; that method can be seen in Listing 3.2.\n\nNote that the `getOutputData` method receives two parameters: the name of the task (retrieved by calling the checked-out `WorkItemRecord#getTaskID` method on line 19 of Listing 3.1) and the result returned from the Twitter Service. The `getOutputData` method creates a containing Element with the same name as the task (line 2); it is a mandatory requirement that the output data Element has the same name as the task represented by the work item. Next, it creates another Element called “result” — this is the name of only output variable for work items handled by the Twitter Service — and assigns the value contained in the variable `data` to it. Finally, it adds the “result” Element (representing the output variable and its value) as a child to the `taskName` Element (representing the container) and returns the constructed Element to be passed back to the Engine via the `checkInWorkItem` method. An example of how the Element would appear as XML can be seen in Listing 3.3.\n\n**ASIDE:** In our TwitterService example, we have assumed that each API method call is successful and thus returns the expected result. In reality, if an API method does not succeed, it may throw an exception or\nprivate Element getOutputData(String taskName, String data) {\n Element output = new Element(taskName);\n Element result = new Element(\"result\");\n result.setText(data);\n output.addContent(result);\n return output;\n}\n\nListing 3.2: The Twitter Service's getOutputData method\n\nListing 3.3: Example contents of an Element produced by the Twitter Service's getOutputData method\n\nreturn a diagnostic message describing the problem encountered. Methods that return a String value (for example, the connect and checkInWorkItem methods) should have their returned value checked instead of simply assuming the call was successful. A convenience method called successful is inherited from InterfaceBWebsideController by Custom Services that, when passed the result of an API call that returns a String value, will return a boolean false if the result contains a diagnostic method rather than the expected result. An example on the use of the successful method can be see in in Listing 3.4. For API methods that return objects to Custom Services, an exception is thrown containing a diagnostic message if the call is unsuccessful. For example, the checkOut method throws a YAWLException if the check-out was unsuccessful. Additionally, each API method call will throw an IOException if the Engine can’t be reached.\n\n3.2.3 Implementing the handleCancelledWorkItemEvent method\n\nSometimes, a work item that is being handled by a Custom Service is cancelled by the Engine before the service has checked it out or before it has completed processing it. Cancellation may occur when a work item is a member of another task’s cancellation set, or when it is a member of a deferred choice construct, or when an administrator cancels a case, or as a result of an exception handling routine. In any event, when a work item is cancelled the Engine notifies the appropriate Custom Service by calling its handleCancelledWorkItemEvent method. The Custom Service can then take whatever action is appropriate by implementing the method (as one of two InterfaceBWebsideController’s abstract methods, it must be implemented by each Custom Service).\n\nFor example, the Twitter Service takes no action at all, implementing the method with an empty body. On the other hand, the Worklet Service, which launches whole case instances for the work items it handles, needs to take appropriate action to cancel any cases it may have launched on behalf of the cancelled work item; the Resource Service must take action to remove the work item from any work queues it resides in, clean up its internal caches and so on.\n\n3.2.4 Overriding the describeRequiredParams method\n\nA well behaved Custom Service, which expects to receive particular data variables in order to perform the actions of a work item, will override the describeRequiredParams method. The purpose of this method is to allow Custom Services to specify exactly what input and output variables it requires. At design time, when a designer chooses the Custom Service to associate with a task in the Editor, the Editor will call the service’s describeRequiredParams method (using the Interface B API) and populate the task with the specified data variables, saving the designer the effort of manually creating the required variables and thereby greatly reducing the margin for errors occurring at runtime.\n```java\npublic void handleEnabledWorkItemEvent(WorkItemRecord wir) {\n try {\n // connect only if not already connected\n if (!connected()) {\n _handle = connect(_engineUser, _enginePassword);\n if (successful(_handle)) {\n wir = checkout(wir.getID(), _handle);\n // and so on...\n } else {\n _log.error(_handle);\n }\n }\n }\n}\n```\n\nListing 3.4: The successful method example\n\nOur TwitterService example overrides the `describeRequiredParams` method to specify one input variable (status) and one output variable (result) that it expects all work items that are passed to it for handling will contain (Listing 3.1, lines 31–41). The method returns an array of `YParameter` objects, each one representing a data variable. In line 32 of our example, the method declares an array of size 2 (since there are two variables to specify). For each variable:\n\n- It first constructs a `YParameter` object, specifying the desired usage type (which must be either `YParameter.INPUT_PARAM_TYPE` or `YParameter.OUTPUT_PARAM_TYPE`). If an `Input & Output` variable is required, two parameters must be created, one input and one output, with the same name and datatype; they will be merged at runtime. The first argument of the `YParameter` constructor refers to the variable’s containing task, which has not yet been assigned, so a `null` is passed.\n\n- Next, the variable’s datatype, name and namespace are set. Unless the variable has a user-defined data type with its own namespace, the default `XSD_NAMESPACE` should be used for the namespace value.\n\n- Next, the variable’s documentation is set (optional).\n\nThe effects of the `describeRequiredParams` method can be seen in the example in Figure 3.3. It is only necessary for a developer to choose an appropriate Custom Service for the task from the drop-down list of services, its required variables then populate the list automatically.\n\n### 3.3 Deployment\n\nOur simple Custom Service class is complete, and so now needs to be bundled inside a Web Application (war) file and loaded into a servlet container (for example, Apache Tomcat) for execution. A number of other files and required libraries will also need to be placed inside the war file, in the correct structure. This section will walk through the deployment process.\n\n#### 3.3.1 Internal Structure of a WAR File\n\nThe general internal structure of a war file for deployment to Tomcat is briefly described below. For more detailed information, please refer to Chapter 3 of the Tomcat Application Developer’s Guide³.\n\n³tomcat.apache.org/tomcat-6.0-doc/appdev/index.html\nA Web Application file is a compressed file that is unpacked by Tomcat, when it is placed in the Tomcat webapps directory, into a sub-directory structure based on its internal organisation. Every war file will, at a minimum, conform internally to the following basic structure:\n\n- a root directory, which typically contains any html and jsp files (and supporting files like JavaScript and style sheet files) used by the service, although more complex services may have these files arranged in sub-directories.\n\n- a sub-directory of the root called WEB-INF, which contains:\n \n - a web.xml file, more formally referred to as a Web Application Deployment Descriptor. This file is an XML file containing configuration information for the application, and is discussed in more detail below.\n \n - a sub-directory called classes, where any required class files, that are not contained in jar libraries, are placed. The directory structure under the classes directory must match the package structure of any classes placed here. For example, any YAWL classes should be placed in a sub-directory structure beginning with /org/yawlfoundation/yawl.\n \n - a sub-directory called lib, where any jar libraries that the application requires are to be placed.\n\n### 3.3.2 Required Files\n\nThis section describes the absolute minimum set of files (classes and jars) required to be bundled with a basic Custom Service. Of course, particular Custom Services will require other files, depending on what the service actually does and how it is realised. These class files can be found in any of the installed YAWL\nCustom Services, or within the `yawl-lib-xx.jar` library (which, if placed in the classpath of a service, negates the need to explicitly include these files in the service).\n\nFirstly, these YAWL Interface B client side classes are mandatory inclusions for all Custom Services (package `org.yawlfoundation.yawl.engine.interface.interfaceB`):\n\n- **IBControllerCache**: caches recently accessed engine objects on the client side (specifications, task information, work items, and so on).\n- **InterfaceB_EnvironmentBasedClient**: the service side API for service to engine calls.\n- **InterfaceB_EnvironmentBasedServer**: the service side receiver of event notifications from the engine, which are passed on to the Custom Service’s primary class.\n- **InterfaceBWebsideController**: the base class of the Custom Service’s primary class.\n\nThe above classes require the inclusion of these dependent classes:\n\n- **Package** `org.yawlfoundation.yawl.elements`:\n - `YAttributeMap`: a map of attributes (key=value pairs).\n - `YSpecVersion`: stores the version descriptors for a YAWL specification.\n - `YVerifiable`: a Java interface implemented by several required classes; provides for self-verification of a class’s data structures.\n\n- **Package** `org.yawlfoundation.yawl.elements.data`:\n - `YParameter`: stores variable types and descriptors.\n - `YVariable`: a variable of a net or task, and the base class of YParameter.\n\n- **Package** `org.yawlfoundation.yawl.engine`:\n - `YSpecification`: the container for a YAWL specification.\n - `YSpecificationID`: a unique identifier for each specification.\n\n- **Package** `org.yawlfoundation.yawl.engine.interface`:\n - `Interface_Client`: the base class of all YAWL API’s; provides the basis for HTTP communication between the Engine and Custom Services.\n - `Marshaller`: converts XML Strings to their equivalent YAWL objects and vice versa.\n - `ServletUtils`: some generic servlet utility methods.\n - `SpecificationData`: stores specification definition data and descriptors on behalf of services.\n - `TaskInformation`: stores task definition descriptors, including task parameters, on behalf of services.\n - `WorkItemRecord`: stores information describing a work item on behalf of services.\n - `YParametersSchema`: stores descriptors of task-level parameter sets.\n\n- **Package** `org.yawlfoundation.yawl.engine.logging`:\n - `YLogDataItem`: definition of an item to be added to the logging of a process event.\n - `YLogDataItemList`: a list of the above items.\n\n- **Package** `org.yawlfoundation.yawl.util`:\n\n---\n\n*where xx refers to the current YAWL release version (e.g. yawl-lib-2.2.jar).*\n– CharSetFilter: ensures all strings passed via HTTP communications between the Engine and services use UTF-8 encoding.\n– JDOMUtil: various utility methods for converting Strings to JDOM objects and vice versa.\n– PasswordEncryptor: hashes passwords on the service side for passing to the engine.\n– StringUtil: various String manipulation methods.\n\nIn addition, the above classes require these external jar libraries to be available to the Custom Service, either in the Service’s `/WEB-INF/lib` directory, or elsewhere on the classpath:\n\n- commons-codec-1.4.jar\n- jdom.jar\n- log4j.jar\n- xercesImpl.jar\n\nThese jar files can be copied from the `/WEB-INF/lib` directory of any of the default custom services. Finally, the file `log4j.properties` needs to be copied to the `/WEB-INF/classes` directory from the same location in any of the default services.\n\nOf course, war files representing any but the most basic of Custom Services can (and often do) include other directories, class and jar files, and other contents besides those stated. A good idea is to browse the structures of the various YAWL services to gain some insight into how things are typically arranged.\n\n### 3.3.3 The Deployment Descriptor File (web.xml)\n\nEvery Custom Service must include a `web.xml` file in its `WEB-INF` directory. The file contains the necessary deployment configuration values for the service. As an example, the Twitter Service’s `web.xml` is shown in Listing 3.5. This example may be copied for use by basic Custom Services - only a few values need to be changed in most cases, as described below.\n\nIn the basic `web.xml` file example:\n\n- The name the Custom Service (line 4) and a brief description (line 5) are provided. These values are used only by the Tomcat Manager tool (YAWL doesn’t refer to them). The values should be set to match those of your Custom Service.\n\n- A context parameter named `InterfaceBWebsideController` is defined (lines 7–12). The value of this parameter must match the fully qualified name of your service’s primary class (which extends from `InterfaceBWebsideController` class). At startup, an instance of the primary class referred to is created.\n\n- A second context parameter named `InterfaceB_Backend` is defined (lines 14–17). The value of this parameter must match the URL of the Engine’s Interface B API. For a locally installed Engine, this parameter value can be left unchanged; if the Engine is installed remotely, the URL’s host name should be changed to that of the remote Engine. The standard tomcat port (`:8080`) should be changed only if the Engine’s Tomcat container has modified its port from the default. In all cases, the URL must end in `/yawl/ib` – the path of the Engine’s Interface B endpoint.\n\n- A servlet character set filter and mapping is provided (lines 19–31), which should be included as-is in all Custom Service `web.xml` files. The filter ensures that all Strings passed between the Engine and Services will be encoded with the UTF-8 character set.\n\n- The definition of the servlet for the Custom Service is at lines 33–39. The `servlet-class` value should not be changed - it defines the fully qualified name of the class that receives notifications from the Engine (and is inherited in your service’s primary class, as it extends from `InterfaceBWebsideController`). The `servlet-name` value may be changed to match that of your service.\nListing 3.5: The Twitter Service’s web.xml file\n• The definition of the servlet mapping for the Custom Service is at lines 41–44. The servlet-name value here and the servlet-name value provided in the servlet definition (in the previous point) must match. The url-pattern value must match the path part of the URI provided to the Engine when the Custom Service was registered; by convention, Custom Services use the path /ib. For example, the Twitter Service is registered with the Engine with the URI http://localhost:8080/twitterService/ib. The twitterService part matches the name of the war file deployed. The /ib part matches the url-pattern value provided here. The result is that when the Engine sends a notification to the URI it has registered for your service, that URI is mapped by Tomcat to the Servlet class defined in the previous point, allowing your Custom Service to receive those notification events.\n\nThe Twitter Service example is a minimal web.xml that suits the requirements of most Custom Services, but a web.xml can contain any number of context parameters, servlet definitions, filters and so on. For a more complex example, see the Resource Service’s web.xml file.\n\n3.3.4 Registering the Service with the Engine\n\nThe Engine requires each Custom Service wishing to communicate with it to first be registered. Registration is achieved via the Services administration web form (Figure 3.4), which is available to all users with administrative access. A service can be added by providing a name, a password and confirmation, a URI and a Description. The password and confirmation password must match each other, and name and password must also exactly match the credentials that will be used by the service to log onto the Engine. For example, the credentials for the Twitter Service are declared in the service’s code (Listing 3.1, lines 6–7); they are used by the Service when it connects to the Engine.\n\nThe URI entered is validated by contacting it and waiting for an appropriate response, so care should be taken that (1) the Service’s war file is already deployed in Tomcat, and (2) the URI provided exactly matches that specified by the service (i.e. the first part of the path matches the name of the Service’s war file, and the last part matches the servlet-mapping parameter value for the InterfaceB_EnvironmentBasedServer servlet class as defined in the Service’s web.xml – by convention the last part of the path is /ib).\n\nWhen the Add button is clicked, if the credentials and URI entered are correct, the service will be successfully registered with the Engine. If not, an explanatory error message will be displayed, with more information on the problem to be found in the localhost and catalina.out log files (found in the logs directory of your Tomcat installation).\n\n3.4 Additional Topics\n\nWe’ve now covered all the fundamentals of creating and deploying a basic YAWL Custom Service. In this section, we will examine some additional topics that extend the capabilities of Custom Services.\n\n3.4.1 Handling Multiple-Instance Atomic Tasks\n\nIn the YAWL language, there are two kinds of atomic tasks: ordinary single-instance tasks, each of which creates one executable (child) work item, and multiple-instance tasks, each of which creates multiple executable (child) work items.\n\nAs described in Section 3.1, when a single-instance atomic task is checked out by a Custom Service, a child work item is created by the Engine, given the status ‘Executing’, and returned to the service. When a multiple-instance atomic task is checked out by a Custom Service, the mechanism is similar, but a little more involved:\n\n• A (specified at design time) number of child work items are created by the Engine;\n• One of the children, chosen indiscriminately, is given a status of ‘Executing’ and returned to service; and\n• The remainder of the child work items are given a status of ‘Fired’ and remain in the Engine.\n\nA ‘Fired’ status indicates that the work item has progressed beyond the ‘Enabled’ state but is not yet ‘Executing’. However, the task cannot complete until all of its child work items (or a specified threshold of those created) have been started, performed and completed by a Custom Service. It is therefore the responsibility of the Custom Service that checked out the original child work item to start, perform and complete the remaining child work items.\n\nIf your service is to handle multiple-instance tasks, there are two methods that can be used to achieve that goal:\n\n**Individual Check Outs**\n\nAfter the initial checkout, a Custom Service may work through the list of child work items created and check-out each of the ‘Fired’ items individually, as shown in Listing 3.6. Line 2 uses the inherited `getChildren` method to get a list of all the work items created. At this stage, one of the child items has a status of ‘Executing’ (the one returned by the initial `checkOut` call), the rest are ‘Fired’. Note also in line 2 we use the id of the enabled work item rather than the one checked out, since the enabled item has the same id as the one that is now the parent of the created children (the parent work item is retained within the Engine). Each child item that has a status of ‘Fired’ is checked out in turn (lines 3–5) and added to the list of checked out children, except one (the one that already has ‘Executing’ status), which is added to the checked out list directly.\n\n**Encapsulated Method**\n\nFor convenience, a method inherited from `InterfaceBWebsideController` is available to Custom Services that encapsulates the functionality of the code in listing 3.6. The method, `checkOutAllInstancesOfThisTask`,\nmay be used as an alternative to the `checkOut` method and, as the name implies, takes care of checking out every child work item, including the first one. That is, there is no need to check out the original enabled item first before working through the other child items, as in the previous method. Indeed, the `checkOutAllInstancesOfThisTask` method is passed the entire enabled `WorkItemRecord` as an argument, and it will throw an Exception if its status is anything other than 'Enabled'. The method can be used for single-instance atomic tasks, too. The usage of the method is demonstrated in Listing 3.7, which shows an alternate `handleEnabledWorkItemEvent` implementation to the one in Listing 3.1.\n\nEach work item created for a multiple-instance task may contain different data values, so each is used in a `updateStatus` call (line 10), and each is checked in individually.\n\nA multiple instance task is not considered complete until all (or a specified threshold) of its child work items have been checked in to the Engine, which keeps track of the children checked out and back in via the internally-held parent work item from which the child items were created. Therefore, a Custom Service does not need to concern itself with the number of child work items checked out or checked in for a task, only that it eventually checks in each item that it checks out.\n\n### 3.4.2 Other Interface B Events\n\nWhile the two mandatory events discussed earlier must be implemented by all Custom Services, there are a number of other events generated by the Engine that a Custom Service may choose to optionally implement. They are:\nhandleEngineInitialisationCompletedEvent()\n\nThe Engine sends this event to all registered Custom Services immediately after it is started and completes all of its initialisation tasks. The notification of this event is useful to Custom Services because typically, since Tomcat starts web applications in alphabetical order, a Custom Service will be started before the Engine (contained in `yawl.war`). Thus, a Custom Service may use this event to undertake any final initialisation tasks that depend on the availability of a running Engine.\n\nhandleTimerExpiryEvent(WorkItemRecord item)\n\nAny atomic task may be associated with a timer. If the timer expires before its child work items have completed, the Engine will fire this event, allowing a Custom Service that has checked out the task to perform the appropriate action.\n\nhandleCompleteCaseEvent(String caseID, String caseData)\n\nNotifies either one or all registered Custom Services when a process instance completes. The caseData argument is an XML String of the case’s output data. Some Custom Services need to be aware of case completions, for example the Worklet Service, which launches cases as substitutes for checked out work items, and checks the work items back in when the launched case completes. Whether one or all Custom Services are notified of a case completion is dependent on how the case is launched – see Launching a Case in the next section for more details.\n\nhandleCancelledCaseEvent(String caseID)\n\nNotifies all registered Custom Services when a process instance is cancelled. Any Custom Service that monitors running cases will use this event to take whatever action is appropriate for the service. For example, the Resource Service uses this event to remove any work items associated with the case from its work queues, and to remove the case from the list of running cases in the Case Management form.\n\nhandleWorkItemStatusChangeEvent(WorkItemRecord item, String oldStatus, String newStatus)\n\nNotifies all registered Custom Services when the status of a work item changes. Services may choose to handle this event to take any action appropriate – usually this means reacting to a status change caused by another Custom Service (since the service would already know of any changes it instigated). Note that initial statuses are not announced via this method (e.g. ‘Enabled’ or ‘Fired’), since they are the statuses a work item begins with, a status change is not represented by a work item creation. Note also that the work item passed via this method does not contain the item’s output data when a work item completes, because the output data is never incorporated into the work item, rather it is submitted separately to the Engine (via the checkInWorkItem method).\n\nFor examples of implementations of each of these event handlers, review those of the ResourceManager class of the Resource Service.\n\n3.4.3 Launching a Case\n\nA case (process instance) can be launched by a Custom Service via Interface B. Listing 3.8 shows a typical implementation. On line 4, the launchCase method of the _interfaceBClient object, inherited directly from InterfaceBWebsideController, is called with the following arguments:\n```java\npublic String launchCase(YSpecificationID specID, String caseData)\n throws IOException {\n YLogDataItemList logData = getLogData();\n String caseID = _interfaceBClient.launchCase(specID, caseData,\n _sessionHandle, logData);\n if (!successful(caseID)) {\n // let the user know there's a problem\n }\n return caseID;\n}\n```\n\nListing 3.8: Launching a new case\n\n```java\nString caseID = _interfaceBClient.launchCase(specID, caseData,\n _sessionHandle, logData, myServiceURI);\n```\n\nListing 3.9: Launching a new case with a case observer\n\n- **YSpecificationID specid**: The ID of the specification from which to launch a case. There is an assumption that the specification has already been loaded into the Engine.\n\n- **String caseData**: An XML String containing values for any net-level input variables. The root name of the XML structure must match either the name of the root net or the URI (name) of the specification, while its contents must include the correct name and valid data value for each input variable expected. If the specification has no net-level input variables, a null may be passed for this argument.\n\n- **String sessionHandle**: A valid and active session handle previously obtained from the Engine.\n\n- **YLogDataItemList logData**: A list of log predicate Strings to insert into the Engine’s process logs when the case starts, over and above the default case launch log events. If there are no log predicates to be logged for the case launch, a null may be passed for this argument (in which case line 3 of Listing 3.8 can be ignored).\n\nThe call to _interfaceBClient.launchCase will return either the case ID of the newly launched case if the launch was successful, or a diagnostic error message if it was not. Line 6 of Listing 3.8 uses the inherited successful method to determine if the returned value represents a successful case launch – if it does not, the returned String can be used to construct an informative error message for the user.\n\nThere is a second form of the launchCase method, as shown in Listing 3.9, that takes one extra argument – the URI String of the Custom Service launching the case (in most cases) – known as the ‘case observer’. The difference between the two methods is the effect on case completion notifications:\n\n- For a case launched via the first method (without a case observer), *all* registered services are notified of the completion of the case;\n\n- For a case launched via the second method (with a case observer), the observer is the *only* service notified of the completion of the case.\n\nNote that it is acceptable for the case observer URI to differ from the URI of the Custom Service launching the case, if it is desired that a different service handles the case completion event.\n3.5 Other Engine Interfaces\n\nBesides Interface B, there are three other interfaces through which services and applications can interact with the YAWL Engine. This section introduces those three interfaces.\n\n3.5.1 Interface A\n\nThe focus of Interface A is to provide support for two fundamental functions:\n\n- The uploading and unloading of specifications; and\n- Registering, modifying and removing Custom Service and Client Application accounts.\n\nTo use Interface A, a service must access the class `InterfaceA_EnvironmentBasedClient`, found in the `org.yawlfoundation.yawl.engine.interfce.interfaceA` package, together with the dependent files listed in Section 3.3.2, either within its own war file, or via its classpath. Since the Engine does not generate any event notification on Interface A, no other inclusions are necessary.\n\nUploading and Unloading Specifications\n\nUploading a specification is quite straightforward, as shown in Listing 3.10. First, an interface client is created, by passing to its constructor the URI of the Engine’s Interface A endpoint (`/yawl/ia`) on lines 2–3, then calling the client’s `uploadSpecification` method with a `File` object that references a specification file (line 4). The String returned from the method will contain an diagnostic error message if there was an error uploading the specification. These diagnostic messages can be quite informative, since the Engine verifies the syntax of the specification and reports any errors or warnings found.\n\nA second version of the `uploadSpecification` method accepts the specification as an XML String, instead of a `File` object.\n\nTo unload a specification from the Engine, call the `unloadSpecification` method, passing the specification identifier and a valid session handle.\n\nASIDE: `InterfaceA_EnvironmentBasedClient` contains identical `connect` and `checkConnection` methods to the ones found in Interface B. Either interface’s methods can be used to establish and check a connection, and the handle returned via a `connect` call on one interface can be successfully passed with the methods of the other (i.e. there is no need to have a separate session handle for each interface).\n\nService and Application Account Maintenance\n\nEach Custom Service and Client Application must have its credentials registered with the Engine before they can connect to it through one of its interfaces. Interface A provides the necessary methods to enable service and application registration and maintenance programmatically, rather than via the administration pages.\n\nListing 3.10: Uploading a Specification\n\n```\npublic String uploadSpecification(File specFile) throws IOException {\n InterfaceA_EnvironmentBasedClient client =\n new InterfaceA_EnvironmentBasedClient(\"http://localhost:8080/yawl/ia\");\n return client.uploadSpecification(specFile, _sessionHandle);\n}\n```\nWhat makes a service a YAWL Custom Service is its ability to have the execution of a work item delegated to it. That is, every YAWL Custom Service implements Interface B and so is able to receive event notifications of work item enablements, and consequently is able to be associated with tasks at design time (in the Editor). Any web service that does not implement Interface B, and all standalone applications and tools, do not meet this criterion, but nevertheless may connect with the Engine as a Client Application, rather than as a Custom Service. For example, while the Monitor Service is a web service, deployed via a war file in Tomcat in the same way as Custom Services, it does not implement Interface B and so is regarded as a Client Application. The Editor is an example of a standalone Client Application that communicates with the Engine.\n\nASIDE: YAWL has always supported a generic administrative logon account called ‘admin’, which can be used by individuals to logon to the default administrator worklist, and by services and applications to connect to the YAWL Engine. Since the use of a generic logon may be quite insecure, from version 2.1 onwards its use has been discouraged, in favour of the unique logon credentials for each service and application as discussed in this section. While enabled by default, which allows for connections from unregistered services using the generic ‘admin’ account to succeed, the account may be disabled via a context-param in the Engine’s web.xml file. Once one or more administrative level participants have been added to YAWL, and once it is determined that there are no Custom Services relying on the generic logon, you are encouraged to disable it. All of the services and applications deployed with a YAWL release use their own unique credentials.\n\nCustom Service Registration and Maintenance\n\nTo use Interface A to register a Custom Service, the following additional classes are first required:\n\n- org.yawlfoundation.yawl.authentication.YClient: the base class of the YAWLServiceReference and the YExternalClient classes.\n\nAn example of how a Custom Service may be registered with the Engine can be seen in Listing 3.11. First, an Interface A client is created (lines 3–4), then on lines 5–6 a new service reference object is constructed. The YAWLServiceReference constructor receives five arguments:\n\n- uri: The absolute URI of the Custom Service.\n- gateway: This argument is only relevant on the Engine side. All client side services should use null for this argument.\n- name: The logon name for the service.\n- pw: The logon password for the service. The password is supplied in plain text – it will be encrypted on the client side of the interface call.\n- doco: A description of the Custom Service. This is the description that appears in the drop down list of services in the Editor.\n\nThe addYAWLService method is called on line 7, returning a diagnostic String describing the success or otherwise of the add attempt.\n\nTo remove a registered Custom Service, use the removeYAWLService(serviceURI, sessionHandle) method.\n\nClient Application Registration and Maintenance\n\nClient Application accounts are added, maintained and removed in a similar way to Custom Services. Listing 3.12 shows the basic methods.\n```java\npublic String addRegisteredService(String name, String pw,\n String uri, String doco) throws IOException {\n InterfaceA_EnvironmentBasedClient client =\n new InterfaceA_EnvironmentBasedClient(\"http://localhost:8080/yawl/ia\");\n YAWLServiceReference service =\n new YAWLServiceReference(uri, null, name, pw, doco);\n return client.addYAWLService(service, _sessionHandle);\n}\n```\n\nListing 3.11: Registering a Custom Service with the Engine\n\n```java\nInterfaceA_EnvironmentBasedClient client =\n new InterfaceA_EnvironmentBasedClient(\"http://localhost:8080/yawl/ia\");\nString msg = client.addClientAccount(name, password, doco, sessionHandle);\nmsg = client.updateClientAccount(name, password, doco, sessionHandle);\nmsg = client.removeClientAccount(name, sessionHandle);\n```\n\nListing 3.12: Interface A operations with Client Applications\n\nWhen adding or updating, the password argument should be passed as plain text, as it will be encrypted by the Interface A client. When using the updateClientAccount method, the name argument must match that of an existing client account (i.e. the name of a client account cannot be changed). Each method returns a diagnostic String describing the success or otherwise of the call.\n\nThe generic ‘admin’ logon is made available as a Client Application account, allowing administrators to change its password via the updateClientAccount method. However, the ‘admin’ account cannot be removed via a removeClientAccount call; an attempt to do so will result in an error message being returned. To remove the account, the context parameter AllowGenericAdminID in the Engine’s web.xml needs to be set to disabled.\n\nPlease consult the YAWL javadoc for more details of the complete functionality set offered by Interface A.\n\n### 3.5.2 Interface E\n\nInterface E provides access to the Engine’s process logs. The are two output formats returned by the various methods of the interface, the majority are in plain XML, but case histories can also be retrieved in the OpenXES format, allowing the log output to be directly imported into the ProM process mining tool\\(^6\\).\n\nTo access Interface E, the YLogGatewayClient class needs to be added to your Custom Service (from the package \\texttt{org.yawlfoundation.yawl.engine.interfaceinterfaceE}). An example of using Interface E is shown in Listing 3.13; note in particular that the Engine’s Interface E URI ends with the path /yawl/logGateway. The boolean argument in the getSpecificationXESLog method, when true, includes all variable data value changes in the output returned.\n\nThere are numerous methods to retrieve logged data for such things as:\n\n- all the events of a particular case.\n- all the events for a particular task instance.\n- all the task instances of a particular case.\n- all the task instances of a task definition.\n\n\\(^6\\)www.processmining.org\nYLogGatewayClient client =\n new YLogGatewayClient(\"http://localhost:8080/yawl/logGateway\");\nString xesLog = client.getSpecificationXESLog(specID, true, sessionHandle);\n\nListing 3.13: Interface E primary methods\n\n- the data type for a particular data item (complex types included).\n- all the events of all cases instantiated from a particular specification.\n- all the cases started and/or cancelled by a particular Custom Service.\n- and many more.\n\nPlease consult the Interface E javadoc for more details.\n\n3.5.3 Interface X\n\nThis section provides a technical overview of the structure and use of Interface X - an interface through which certain milestone notifications are passed during the execution of a process instance where a process exception may have occurred or may be tested for.\n\nInterface X has been designed to allow the Engine to notify Custom Services of certain milestone events during the execution of a process instance, providing services the ability to dynamically check for, capture and handle process exceptions and/or take other actions depending on the particular milestone, process state and current data values.\n\nAn example of a service which utilises Interface X is the Worklet Exception Service, which has been part of YAWL distributions since the YAWL Beta 8 release. However, the use of Interface X is not limited to exception handling requirements, but is structured for ‘generic application’ - that is, it can be applied by a variety of services that can make use of milestone notifications during process executions.\n\nSetup\n\nTo receive and react to event notifications via Interface X, a Custom Service needs to:\n\n1. Implement the InterfaceX_Service (java) interface. An example of how to implement the required java interface can be seen in Listing 3.14.\n\n2. Add a servlet section for the Interface X Service side class that receives notifications from the Engine to the Custom Service’s web.xml. The required sections to be added can be seen in Listing 3.15 – these settings can be added as-is. This means that the Engine can find your Custom Service Interface X listening class by using the path: /service_war_file_name/ix. Notice the required sections are very similar to the equivalent entries for Interface B (shown in Listing 3.5).\n\n3. Add the required Interface X service side classes to the Custom Service’s war file: InterfaceX_Service, InterfaceX_ServiceSideClient, and InterfaceX_ServiceSideServer, all found within the package org.yawlfoundation.yawl.engine.interface.interfaceX.\n\n4. Register the Custom Service with the Engine as an InterfaceXListener, which can be achieved in either of the following two ways:\n\n - Statically, in the Engine’s web.xml, by adding your service’s Interface X URI to the InterfaceXListener context-param (see Listing 3.16) – this context-param is commented out by default, so must be uncommented for use.\npublic class MyService implements InterfaceX_Service {\n\nListing 3.14: Implementing the Interface X Java Interface (example)\n\nListing 3.15: The required Interface X entries for the Custom Service’s web.xml\n\n• Dynamically, by calling the Interface X method `addInterfaceXListener`—typically this method is called from the Custom Service’s `handleEngineInitialisationCompletedEvent` (see Listing 3.17). Notice in lines 1–2 that an `InterfaceX_ServiceSideClient` object has been instantiated, with the `Engine`’s Interface X URI, in the service’s initialisation code, while on line 7 the object’s `addInterfaceXListener` method has been called with the `Custom Service’s` Interface X URI.\n\nThe Interface X Package\n\nThe package `org.yawlfoundation.yawl.engine.interfaceX` contains the following entities:\n\n• ExceptionGateway: a java interface that defines the event notifications that pass from the engine side to the custom service side.\n\n• InterfaceX_Service: a java interface that defines the methods that must be implemented by the custom service to receive event notifications.\n\n• InterfaceX_EngineSideClient: implements the ExceptionGateway interface. Receives the event\n\nListing 3.16: Adding an InterfaceXListener via the Engine’s web.xml\nnotifications from the engine, translates them and their data sets to POST messages and passes them across the interface.\n\n- **InterfaceX_ServiceSideServer**: a Java Servlet that receives the POST messages passed across the interface from the EngineSideClient, and translates them and their data sets into method calls to the custom service (i.e., the methods implemented from the InterfaceX_Service interface).\n\n- **InterfaceX_ServiceSideClient**: has a number of methods that are called from the custom service. Translates the method calls and their datasets into POST messages and passes them across the interface.\n\n- **InterfaceX_EngineSideServer**: a Java Servlet that receives the POST messages passed across the interface from the ServiceSideClient, and translates them and their data sets into method calls to the engine.\n\nThe logical layout of the interface can be seen schematically in Figure 3.5.\n\n\n\nOf course, the items of interest to a Custom Service developer are those on the service side. These are described in some detail below.\nBy implementing this interface, a Custom Service must implement eight methods, seven of which are notification announcements from the engine side:\n\n- **handleCheckCaseConstraintEvent(YSpecificationID specID, String caseID, String data, boolean preCheck)**\n \n This method is invoked by the Engine at two points in the lifecycle of a case, firstly when the case is launched and again when it completes. It is designed to allow a Custom Service to check the case’s starting and concluding case-level data to ensure they are valid, and to take appropriate action as required, but of course may be used for other purposes.\n \n - **specID** is the identifier of the specification from which the case was instantiated;\n - **caseID** is the identifier of the case instance;\n - **data** is an XML String containing the current case-level variable values; and\n - **preCheck** denotes whether the case has just been launched (true), or it has just completed (false).\n\n- **handleCheckWorkItemConstraintEvent(WorkItemRecord wir, String data, boolean preCheck)**\n \n This method is invoked by the Engine at two points in the lifecycle of a work item, firstly when the work item is enabled and again when it completes. It is designed to allow a Custom Service to check the work item’s input and output data respectively to ensure it is valid, and to take appropriate action as required before and after the work item is executed, but of course may be used for other purposes.\n \n - **wir** is the work item record of the item in question;\n - **data** is a XML String containing data values of the work item’s variables; and\n - **preCheck** denotes whether the work item has just been enabled (true), or it has just completed (false).\n\n- **handleTimeoutEvent(WorkItemRecord wir, String taskList)**\n \n This method is invoked by the Engine when a work item timer reaches its expiry deadline.\n \n - **wir** is the work item record that has expired; and\n - **tasklist** is a concatenated String of task identifiers of the form “[taskA, taskB, taskX]” representing a list of tasks which had work items running in parallel to the timed work item when the timeout occurred.\n\n- **handleCaseCancellationEvent(String caseID)**\n \n This method is invoked by the Engine when a case is cancelled.\n \n - **caseID** is the identifier of the case instance.\n\n- **handleResourceUnavailableException(WorkItemRecord wir)**\n \n This method is invoked, not by the Engine, but by the Resource Service, whenever a work item is assigned to a resource and that resource is not currently available or does not exist.\n \n - **wir** is the work item record that has an unavailable resource.\n\n- **handleWorkItemAbortException(WorkItemRecord wir)**\n \n handleConstraintViolationException(WorkItemRecord wir)\nThese two methods are included in the interface for future implementation - that is, they are not yet implemented on the Engine side and so are never called. However, since they are included in the interface, any Custom Service that implements it must include these definitions as empty methods.\n\n- `doGet(HttpServletRequest request, HttpServletResponse response)`\n\nHandles the servlet request that occurs when a browser client navigates to the custom service’s URI. Should be used to display a web page.\n\n**InterfaceX_ServiceSideClient**\n\nThe Service-Side Client class provides a number of methods that may be called from the Custom Service to be invoked on the Engine side. The list below provides a brief overview of each. Most require an active session with the engine.\n\n```java\nString addInterfaceXListener(String listenerURI) throws IOException\n```\n\n**Purpose:** Registers the URI of the Custom Service with the engine. If successful, enables the custom service to receive notification of events on Interface X.\n\n**Arguments:**\n- `listenerURI` - the full URI of the custom service (e.g. “http://localhost:8080/myCustomService/ix”)\n\n**Returns:** a String denoting success or failure.\n\n```java\nString removeInterfaceXListener() throws IOException\n```\n\n**Purpose:** Removes the URI of the Custom Service from the engine, effectively ceasing Interface X event notifications.\n\n**Arguments:** nil\n\n**Returns:** a String denoting success or failure.\n\n```java\nvoid updateWorkItemData(WorkItemRecord wir, Element data, String sessionHandle) throws IOException\n```\n\n**Purpose:** Maps the data values passed to the workitem specified on the engine side. Used to update the values of a workitem’s data attributes, stored in the engine, with the values of identically named attributes in the Element passed.\n\n**Arguments:**\n- `wir` - the workitem to update;\n- `data` - a JDOM Element containing data attributes and values;\n- `sessionHandle` - the session handle of an active session.\n\n**Returns:** nil\n\n```java\nvoid updateCaseData(String caseID, Element data, String sessionHandle) throws IOException\n```\n\n**Purpose:** Maps the case level data values specified to the identified case on the Engine side. Used to update the values of case-level data attributes, stored in the Engine, with the values of identically named attributes in the Element passed.\n\n**Arguments:**\n- `caseID` - the identifier of the case to update\n- `data` - a JDOM Element containing data attributes and values\n- `sessionHandle` - the session handle of an active session.\nvoid forceCompleteWorkItem(WorkItemRecord wir, Element data, String sessionHandle) throws IOException\n\n*Purpose:* Force-completes the specified workitem. A force-completed workitem receives a final status of “ForcedComplete” and the process continues to the next task.\n\n*Arguments:* \n- `wir` - the workitem to force-complete; \n- `data` - a JDOM Element containing the workitem’s final data values; \n- `sessionHandle` - the session handle of an active session.\n\n*Returns:* nil\n\nWorkItemRecord unsuspendWorkItem(String workItemID, String sessionHandle) throws IOException\n\n*Purpose:* Continues (i.e. unsuspends) the specified workitem. Does nothing if the workitem is not already suspended.\n\n*Arguments:* \n- `workItemID` - the identifier of the workitem to continue; \n- `sessionHandle` - the session handle of an active session.\n\n*Returns:* A `WorkItemRecord` referring to the updated workitem.\n\nvoid restartWorkItem(String workItemID, String sessionHandle) throws IOException\n\n*Purpose:* Restarts the specified workitem. Sets its status as “Enabled” and resets the item’s data values to those when it was initialised.\n\n*Arguments:* \n- `workItemID` - the identifier of the workitem to restart; \n- `sessionHandle` - the session handle of an active session.\n\n*Returns:* nil\n\nvoid startWorkItem(String workItemID, String sessionHandle) throws IOException\n\n*Purpose:* Starts the specified workitem in the engine.\n\n*Arguments:* \n- `workItemID` - the identifier of the workitem to start; \n- `sessionHandle` - the session handle of an active session.\n\n*Returns:* nil\n\nvoid cancelWorkItem(String workItemID, String sessionHandle) throws IOException\n\n*Purpose:* Cancels the specified workitem. Sets its status as “Failed” - no further processing will occur on the same branch as the failed workitem.\n\n*Arguments:* \n- `workItemID` - the identifier of the workitem to cancel; \n- `sessionHandle` - the session handle of an active session.\n\n*Returns:* nil\n\nAs mentioned previously, the Worklet Exception Service makes extensive use of *Interface X* and so is a good example to browse for tips and pointers.\nThat concludes this guide to creating a basic YAWL Custom Service. However, there are many more methods available via the Engine’s Interfaces to support your Custom Service’s operations. More information can be found in the “YAWL Book” [10], the YAWL javadoc (online at http://www.yawlfoundation.org/javadoc/yawl/), and by examining the code of the existing Custom Services distributed with each YAWL release.\nChapter 4\n\nImplementing In-Process Custom Services\n\n4.1 Introduction\n\nThis chapter describes an architecture, as an alternative to the REST-style, for connecting external applications directly to an instance of the YAWL Engine.\n\n4.1.1 Why Use YAWL?\n\nThe justification for using the YAWL system in order to provide a “process flow controller” is simply that of extreme flexibility. There are numerous examples of coordinated software systems where some form of control flow exists, advancing the overall processing requirement from one stage to the next. A good example of such a control flow is that of a web browser session into a web server over the Internet. A user connects to some website in order to order some goods, and subsequently have them delivered. In this scenario, the user typically searches for and locates a number of items from the online stores catalogue, and then is directed to the payment details web form, and finally to the delivery details web form. Whilst there are several web development frameworks that support the simple routing of web pages, it is considered that such frameworks do not provide the rich set of process routing and data manipulation facilities found within the YAWL system.\n\nIn Enterprise Application Integration (EAI) scenarios, a separate set of features make the use of YAWL extremely attractive, especially when these are coupled with other Java2 Enterprise Edition (J2EE) features such as the Java Message Service (JMS). Traditionally, back-office or batch style applications are executed in some predefined sequence, controlled either manually or via complex shell scripts. In the situation where a Service Oriented Architecture (SOA) model is adopted, it becomes feasible that the sophisticated process control flow features of the YAWL runtime can be utilised to build highly automated and efficient back-office processing systems. In fact the YAWL runtime provides an extremely flexible and powerful routing engine. In an XML-centric integration architecture such as SOAP, the use of YAWL becomes even more beneficial given its comprehensive support for XML with its data manipulation and interrogation layer.\n\nThis chapter describes an architectural model utilising a single instance of the YAWL Engine to control multiple YAWL Custom Services. Each custom service effectively services a request into a back-end office application. The technique outlined in this chapter presents an architecture where each application may execute as a free-standing Java application with no requirement for an external application server. The approach to connecting some custom services with their own external systems is left as an exercise for the\n\n---\n\n1 Whereby a formalised interface is developed to allow external yet controlled access to application system functionality.\n\n2 This is unlike the default architecture for YAWL wherein a J2EE/Servlet container is used to coordinate a set of integrated Web applications.\nreader, although various suggestions are made.\n\n## 4.2 The InterfaceB Observer Gateway\n\n### 4.2.1 Background\n\nThe YAWL Engine provides two primary interfaces that, one way or another, are exposed to the business environment:\n\n<table>\n<thead>\n<tr>\n<th>Interface A</th>\n<th>Management interface for loading and unloading process models, registering client applications and services, and observing case progress.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Interface B</td>\n<td>An execution interface for launching cases (process instances) and worklist style operations such as starting and completing tasks within a case.</td>\n</tr>\n</tbody>\n</table>\n\nThese engine interfaces listen and respond to requests from the business environment. Conversely the “Observer Gateway” interface is designed to allow external systems/modules to listen and respond to the YAWL runtime engine. Once an observer gateway instance is deployed into the YAWL runtime environment, the implementation may receive the notifications normally associated with YAWL custom services. As YAWL custom services typically implement the logic to process work item requests associated with atomic tasks, the events handled by the observer gateway are principally concerned with the scheduling and execution of tasks - like Interface B.\n\nThus, there are two alternative interaction models in communication with the YAWL runtime engine, as alluded to above. First there is a “pull style” model. In this model, the custom service polls the YAWL runtime on demand in order to retrieve, and ultimately display to the end user a list of outstanding work item tasks. The alternative is a “push style” model wherein the YAWL runtime engine can notify external systems of newly scheduled tasks etc. Since the Beta 7 YAWL version this “push style” model has been extended into a plug-in style architecture. The “Observer Gateway” interface forms a primary foundation to this framework. Now there is a conveniently flexible alternative to the XML/HTTP technique used to connect the YAWL runtime engine with custom services.\n\n## 4.3 Interface Design\n\nThe “Observer Gateway” interface is designed to allow multiple Java objects to register interest with an instance of a YAWL Engine in order to receive notification as to when an atomic task’s work item becomes available or unavailable. The object making the registration needs to provide a number of “listener style” methods as demanded by the observer gateway interface. As is usual for listener interfaces, the call into the listener method executes on YAWL’s runtime thread and should not block execution for an extended period of time. It is suggested that the method implementing the listener interface creates and starts a separate worker thread to handle the request, thus allowing the runtime to continue with minimal delay. Whilst the Observer Gateway interface is used to connect with the custom YAWL services that are shipped with the system, it is open to integration with user developed code. Note that the InterfaceB_EngineBasedClient class, which generates event notifications to custom services, also implements the Observer Gateway interface.\n\nIn the existing HTTP based custom service model, (see Chapter 3) a Servlet container is used to host one or more custom services. Each custom service needs to be registered with the runtime via the YAWL Admin-\nistration facility. Once registered, a custom service will be notified of new and cancelled work items via a well defined interface call. The observer gateway interface extends this model in the following ways:\n\n1. The requirement to pre-register a service URL with the runtime is removed.\n\n2. Assuming a suitable manager style application is used to interact with the Engine, custom services can be implemented where communication between it and the Engine (via a suitable manager) can be via any form of wire protocol.\n\n### 4.4 Custom Service URLs\n\nThe existing YAWL custom service implementation utilises the configuration of specific URLs against an atomic task in order to route work requests (and hence notifications) to a specific custom service.\n\nThe same use of URLs is made within the observer gateway, but instead of routing on a one-to-one basis from an atomic task to a specific custom service, the “scheme” component of the URL is used to identify the object listening on the observer interface. Once consumed by the listener, the remainder of the URL specification can be used to forward processing of the work item’s data associated with the atomic task using any scheme required by the user.\n\nThe observer gateway controller (implemented via class `ObserverGatewayController`) within the runtime Engine supports the registration of multiple objects which implement the `ObserverGateway` interface. The gateway then forwards requests to these registered objects using in-process method calls. It is therefore a requirement that both the Engine and all objects registering as observer gateway listeners must be within the JVM instance. Rather than expose the observer gateway to alternate protocols such as RMI, XML-RPC, SOAP, JMS etc., it is left as an implementation issue for the developer of the object which registers with the Engine. It is assumed that developers will design and implement a “Custom Service Manager” style application which is a sophisticated type of “Observer Gateway”. It could perform the following functions:\n\n- Register itself with the runtime specifying some unique “scheme” tag.\n- Manage a pool of objects which implement the custom service processing.\n- Invoke the required custom service calls using whatever protocol is required.\n\nThe advantage of the above approach is that developers are free to utilise whatever protocols they require, be they “standard” protocols found within the J2SE and J2EE stable, or custom protocols such as those required to communicate with legacy systems, possibly utilising non-Java based resources via the Java Native Interface language feature.\n\nThe URL routing between the standard custom service mechanism and that employed by the observer gateway is summarised in Figures 4.1 and 4.2.\n\n---\n\n3 Although pre-registration of such services within the runtime is not required, a warning message will be generated at both design time from within the YAWL Editor, and also at runtime when the containing specification is loaded.\nIn the classic style implementation, there is a one-to-one relationship between an atomic task (and hence work item) in the YAWL Engine and a specific custom service implementation. In addition, the custom service must be invoked using XML over HTTP protocol.\n\nIn the observer gateway architecture, the relationship between work items and custom services is one-to-many. This is achieved by employing a custom developer manager class which utilises some URL parsing scheme to determine which custom service to delegate the request to. How the URL is constructed in terms of path content and number of elements is completely open ended, the only constraint being that of adherence to standard URL formatting in terms of characters utilised. Such a solution generally adheres to the REST design principle, wherein each URI represent a particular resource.\n\nA suggested URL formatting scheme is as follows:\n\n<scheme>://service/interface/operation\n\nThe components are described in the following table:\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>scheme</td>\n<td>This element defines the tag that links this URL to a specific scheme of custom service manager. This is the value that the manager uses when registering itself with the runtime for receipt of notifications on the observer gateway interface.</td>\n</tr>\n<tr>\n<td>service</td>\n<td>Describes the service as offered by the target custom service. “Order Processing” is a suitable example.</td>\n</tr>\n<tr>\n<td>interface</td>\n<td>Describes an interface (i.e. a collection of methods or operations) as supported by the “service”. “Provisioning” is a suitable example.</td>\n</tr>\n<tr>\n<td>operation</td>\n<td>Describes the operation of method to be called within the “interface”. “NewCreditOrder” is a suitable example.</td>\n</tr>\n</tbody>\n</table>\n\n### 4.5 Implementing the Manager Class\n\nThe use of a manager class is optional. Without an intermediate manager class, the object registering with the observer gateway will need to directly implement the business logic required to consume and process all work items where the URL associated with the workitem has the same URL “scheme” as that specified by the registering observer gateway.\n\nFigure 4.2: Observer Gateway YAWL Custom Service Implementation\nFor example, the following work item requests will be forwarded to observer gateways which register with a scheme of “xyz”:\n\n- xyz://sales/order/newOrder\n- xyz://sales/order/cancelOrder\n- xyz://inventory/stockitem/addNewStockItem\n\nBy making the registering Observer Gateway object a form of “manager”, work item requests can be analysed and the work delegated to some other object or even external system. The routing can be performed by parsing the full URL path defined against the work item, or even by inspection of the XML data associated with the work item (this being available once the work item has been checked-out of the runtime - and hence moved from the “enabled” state to the “executing” state).\n\nIf we take the earlier URL examples, the use of a manager allows us for example to route all work requests for the “sales” domain to an external non-Java based system via some JNI wrapper interface. Work requests for the “inventory” domain however could be routed via a JMS interface to some external Java based application.\n\nInternally within the Engine, all calls to register an object implementing the ObserverGateway interface result in a callback reference being stored within a table, and therefore many Observer Gateway objects can register with the Engine. When the Engine enables a new workitem, the atomic task definition associated with that workitem is examined and any associated custom service URL is extracted. The ObserverGatewayController within the Engine then examines all registered Observer Gateways, and if the URL scheme matches, a callback is invoked to inform all gateways for the given scheme (e.g. http) announcing the new workitem.\n\n### 4.5.1 The ObserverGateway Interface\n\nThe custom service manager, or custom service itself (if no manager class is being utilised), must implement the `org.yawlfoundation.yawl.engine.ObserverGateway` interface. The interface is shown for YAWL 2.2 release⁴ is shown in Listing 4.1.\n\n#### getScheme\n\nThis method should return the scheme tag that this custom service manager supports (remember that a number of managers may register with the engine, so that each manages callbacks for one scheme tag). Suggested values are as follows, but are not validated in any way by the YAWL Engine, so that any scheme tag may be used:\n\n<table>\n<thead>\n<tr>\n<th>Scheme</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>jms</td>\n<td>Java Method Call</td>\n</tr>\n<tr>\n<td>rmi</td>\n<td>Remote Method Invocation</td>\n</tr>\n<tr>\n<td>http</td>\n<td>Hyper Text Transfer Protocol</td>\n</tr>\n<tr>\n<td>jms</td>\n<td>Java Message Service</td>\n</tr>\n<tr>\n<td>soap</td>\n<td>Simple Object Access Protocol</td>\n</tr>\n</tbody>\n</table>\n\n#### announceFiredWorkItem\n\nThis method will be called by the YAWL Engine for each new workitem creation, where the scheme component of the service URL associated with that work item at design time matches that returned by a `getScheme()` call on an ObserverGateway. The invocation supplies a reference to a `YAnnouncement` object, a container for the YAWL service URL, the workitem, the event and its context (each has its own accessor method).\n\n⁴Note: YAWL version 2.2 introduced some changes to the ObserverGateway interface.\npublic interface ObserverGateway {\n\n String getScheme();\n\n void announceFiredWorkItem(YAnnouncement announcement);\n\n void announceCancelledWorkItem(YAnnouncement announcement);\n\n void announceTimerExpiry(YAnnouncement announcement);\n\n void announceCaseCompletion(YAWLServiceReference yawlService,\n YIdentifier caseID, Document casedata);\n\n void announceCaseCompletion(Set<YAWLServiceReference> services,\n YIdentifier caseID, Document casedata);\n\n void announceCaseSuspended(Set<YAWLServiceReference> services,\n YIdentifier caseID);\n\n void announceCaseSuspending(Set<YAWLServiceReference> services,\n YIdentifier caseID);\n\n void announceCaseResumption(Set<YAWLServiceReference> services,\n YIdentifier caseID);\n\n void announceWorkItemStatusChange(Set<YAWLServiceReference> services,\n YWorkItem workItem,\n YWorkItemStatus oldStatus, YWorkItemStatus newStatus);\n\n void announceEngineInitialised(Set<YAWLServiceReference> services,\n int maxWaitSeconds);\n\n void announceCaseCancellation(Set<YAWLServiceReference> services,\n YIdentifier id);\n\n void shutdown();\n}\n\nListing 4.1: The Observer Gateway Interface\nannounceCancelledWorkItem\n\nThis method will be called by the YAWL Engine whenever a previously announced work item for this service is cancelled. Again the call is only made where the scheme component of the task URL matches that returned by a getScheme() call on an ObserverGateway.\n\nannounceTimerExpiry\n\nThis method will be called by the YAWL Engine whenever a work item timer expires.\n\nannounceCaseCompletion - with Service Reference\n\nUpon launching a case the caller may elect any Custom YAWL Service to be notified once the case is complete. When doing so, this method gets called by the engine once the case has completed. As usual, the call is only made for ObserverGateway instances where the scheme component of the URL matches that returned by a getScheme() call. The call supplies a reference to the YAWL service from which the URL can be obtained, together with a case ID, and the output case data.\n\nannounceCaseCompletion - without Service Reference\n\nThis version of the case completion method is called for cases where a completion listening service is not specified.\n\nannounceCaseCancellation\n\nThis method is called by the Engine to announce when a case is cancelled.\n\nannounceCaseSuspending\n\nThis method is called by the Engine to announce when a case starts to suspend (i.e. enters the ‘suspending’ state as opposed to entering the fully ‘suspended’ state).\n\nannounceCaseSuspended\n\nThis method is called by the Engine to announce when a case suspends (i.e. becomes fully suspended as opposed to entering the ‘suspending’ state).\n\nannounceCaseResumption\n\nThis method is called by the Engine to announce when a case resumes from a previous ‘suspending’ or ‘suspended’ state.\n\nannounceWorkItemStatusChange\n\nNotifies a change of status for a work item.\n\nannounceEngineInitialised\n\nThis method is called by the Engine post-startup to advise that it has completed its initialisation routines and is in a ‘running’ state.\nYEngine engine = YEngine.getInstance(false);\nengine.registerInterfaceBObserverGateway(this);\n\nListing 4.2: Dynamically registering an Observer Gateway instance\n\nshutdown\n\nThis method is called when the Engine is shutdown (i.e. when its servlet is destroyed); the observer gateway should use this notification to do its own finalisation processing.\n\n4.6 Registering with the YAWL Engine\n\nAny custom service or custom service manager instance needs to register itself with the Engine once it has completed its initialisation and is ready to accept requests. There are two way to register an observer gateway instance with the Engine:\n\n1. In the Engine’s web.xml file, enabling the ObserverGateway context parameter (it is commented out by default) and providing the fully qualified class name of the observer gateway instance as the parameter’s value. Note that several observer gateways can be specified here, with each fully qualified class name separated by semi colons (;).\n\n2. The object which implements the ObserverGateway interface needs to obtain a reference to the YAWL Engine and invoke the registration method as shown in Listing 4.2.\n\nOnce registered, the object will receive notifications for work items as they are generated. It should be noted that work items already posted against the customer service will not be re-notified, it being the responsibility of the manager to retrieve any outstanding work items and re-process these if required. To avoid such a situation, a reliable messaging framework such as JMS could be utilised to ensure requests in the form of messages are delivered to the target custom services, and avoid any requirement to re-post messages after a restart of the YAWL runtime and/or custom service manager instances.\nChapter 5\n\nThe Resource Service\n\n5.1 Custom Forms\n\nWhen a work item is listed in the Started queue of a participant’s work list, the participant may choose to view the work item and, in doing so, review input values and supply output values for the input and output variables associated with the work item. By default, the Resource Service’s Forms component will use the work item’s parameters to compile a data schema of the work item, using the type definitions of the parameters, and use the schema to dynamically generate a suitable web form that the user can interact with. This automated form generation removes the need for designers to consider how work will be displayed to users.\n\nDynamic forms are designed for maximum flexibility and are able to display input fields for work item data of any type. However, the generic look and feel of the generated form may be less than ideal in scenarios where a more professional presentation is required, or where organisations have standardised UI look and feel requirements. While the use of extended attributes goes a long way towards handing some control back to UI designers, there is a limit to what can be achieved.\n\nIn situations where full control over form presentation is required, the Resource Service allows designers to choose a custom form to associate with a task. At runtime, a work item that has a custom form associated with it will present that form to the user, in precedence to a dynamically generated one. While Chapter 4 of the YAWL User Manual describes how to associate a custom form with a task at design time, the purpose of this section is to describe how to implement a custom form so that it can (i) be populated with the relevant task input data; (ii) update the work item’s output data with the form’s contents when it is submitted; and (iii) return control to the calling work list.\n\nA custom form can be written in any language that supports the ability to parse request parameters from a URL, provide user interaction, and make HTTP requests via an interface. The running example in this section uses a JSP form, but the description is not limited to JSP. In fact, the form’s content (layout, input fields, buttons etc.) is irrelevant for the purposes of this section – the focus is on the mechanism to receive, update and return work item data. The example is contained in a file called customformexample.jsp which can be found in the root directory of an unpacked resourceService.war file (i.e. in the directory tomcat/resourceService), and contains detailed comments to describe the various steps.\n\n5.1.1 Step 1: Initialisation\n\nAt design time, a custom form is specified for a task by adding the URL of the form to a task property. At runtime, the Resource Service checks this field and, if populated, redirects the browser to the URL provided. Of course, the form has to actually exist and be accessible at the specified URL at the time the redirection occurs; if there is a problem accessing the form, the service will fall back to a dynamic form for the work item.\nString wqURL = \"http://localhost:8080/resourceService/workqueuegateway\";\nWorkQueueGatewayClient wqClient = new WorkQueueGatewayClient(wqURL);\n\n// get the workitem xml. If the form has refreshed, it will be stored in a session\n// attribute (see below). If not, get it from the gateway\nString itemXML = (String) session.getAttribute(\"itemXML\");\nif (itemXML == null) {\n // The workitem id and user’s session handle are passed as parameters. Use them\n // to get an xml record of the workitem.\n String itemid = request.getParameter(\"workitem\");\n String handle = request.getParameter(\"handle\");\n itemXML = wqClient.getWorkItem(itemid, handle);\n session.setAttribute(\"itemXML\", itemXML);\n session.setAttribute(\"workitem\", itemid);\n session.setAttribute(\"handle\", handle);\n}\n\nListing 5.1: Retrieving the work item record\n\nIn addition to the URL specified at design time, the service adds the following parameters:\n\n1. workitem – the identifier for the work item initialising the custom form.\n\n2. participantid – the identifier of the currently logged on participant (i.e. the one viewing the form). Note that this is an internal identifier, not the participant’s user id.\n\n3. handle – the participant’s current session handle.\n\n4. source – the URL of the work list from which the custom form is being called.\n\nWhere static parameters have added to a custom form URL at design time, the four additional runtime parameters are appended after any static ones.\n\nThe workitem and handle parameters passed to the custom form can be used to access the work item data via the Resource Service’s API. To do so, the form should create a WorkQueueGatewayClient object, then use its getWorkItem method to retrieve the work item record (as an XML String). Listing 5.1 show the relevant code from our JSP example:\n\n- Line 1 defines the gateway URL. Change it from localhost to suit where the resource service is installed remotely.\n\n- Line 2 creates the WorkQueueGatewayClient object. The create instances of this (and any other) required YAWL objects, you should have the YAWL library somewhere on your classpath, either via the yawl.war and resourceService.war files installed in tomcat, or by adding the yawl-lib.jar or the YResourceServiceClient.jar file to your classpath.\n\n- Lines 11–14 get the values for the workitem and handle parameters, and then uses them as arguments in the call to the client’s getWorkItem method, which returns the work item record as an XML String.\n\n- Lines 15–18 stores the form parameters as session attributes, so they can be retrieved if the form is refreshed. Notice that Line 6 first attempts to retrieve the work item XML String from a session attribute first, which would exist if the form has been refreshed, before making the API call.\nElement wir = new SAXBuilder().build(new StringReader(itemXML)).getRootElement();\nElement data = wir.getChild(\"data\");\n\n// one level down from data is the actual workitem data tree\nElement wirData = (Element) data.getChildren().get(0);\n\n// if there was a problem getting the workitem's xml, the xml will contain an\n// error message instead. It can be tested like this:\nString error = null;\nif (!wqClient.successful(itemXML)) {\n // show the message to the user in an appropriate way. In this case, we'll\n // simply show it on the form below\n error = itemXML;\n}\n\nListing 5.2: Parsing the work item record\n\n5.1.2 Step 2: Parsing the work item data\n\nOnce you have accessed the work item data string, you can parse it for the relevant values to display on the\nform. Work item metadata is described in the various elements of the record, while the actual work item\ndata parameters and values are stored in the data element.\n\nTo parse the work item record String into its equivalent XML form, any appropriate XML parser can be\nused. In our example, we convert the String into an JDOM element, which assumes a jdom.jar on the\nclasspath (see Listing 5.2). The data element is a child node of the root element.\nChapter 6\n\nThe Worklet Service\n\nThe Worklet Service provides an API that allows external custom services and applications to interact with it, and an event server that allows listener services to be notified when an worklet is selected or an exception raised.\n\n6.1 Worklet Gateway Client\n\nThe WorkletGatewayClient is a client side class that can be used by custom services to interact with the WorkletService via an API. It provides two main functionalities:\n\n- creating, accessing, updating and evaluating Ripple Down Rules (RDR); and\n- adding and removing worklet event listeners (see Section 6.2).\n\nAn instance of WorkletGatewayClient can be used by custom services and applications to first create a session with the Worklet Service, then use the returned session handle in subsequent API method calls. Any service or application registered with the engine is trusted by the Worklet Service, and so the same credentials can used to establish the connection (see Listing 6.7 for an example of how to connect and use the API). Like the Engine interfaces, the client provides connect, checkConnection and disconnect methods (see also Section 3.2.2).\n\nThe client provides a number of methods for working with RDR maintained within the Worklet Service. Several helper classes are also used by the client, and so your custom service will need access to them. While the individual classes may be included in your service's war file, an easier and more convenient alternative is to place the yawl-lib.jar file, which contains every YAWL class, on your service's classpath (cf. Section 3.3.2).\n\n6.1.1 Working with Ripple Down Rules\n\nTo begin, please see the Worklet Service chapter of the YAWL User Manual for background information on RDR and their use within the Worklet Service.\n\nSince the primary aim of the Worklet Service is to support processes enacted by the YAWL engine, each rule set is uniquely identified by a YSpecificationID (that is each rule set is defined for a particular specification). However, to generalise RDR support for other custom services and applications, rule sets can also be uniquely identified by a process name (in fact, any name string can be used). Thus, for each client method there are several variations, to support the fact that either a specification id or a generalised process name can be used to identify rules. Please see the WorkletGatewayClient javadoc for more details.\npublic void example throws IOException {\n YSpecificationID specID = new YSpecificationID(null, \"0.1\", \"someSpecification\");\n String processName = \"someProcess\";\n RdrMarshal marshal = new RdrMarshal();\n WorkletGatewayClient client = new WorkletGatewayClient();\n String handle = client.connect(\"admin\", \"YAWL\");\n\n // get a Rule Set\n String ruleSetXML = client.getRdrSet(specID, handle);\n if (!successful(ruleSetXML)) throw new IOException(ruleSetXML);\n RdrSet ruleSet = marshal.unmarshalSet(ruleSetXML);\n\n // get a Rule Tree\n String ruleTreeXML = client.getRdrTree(processName, null, RuleType.CasePreconstraint, handle);\n if (!successful(ruleTreeXML)) throw new IOException(ruleTreeXML);\n RdrTree ruleTree1 = marshal.unmarshalTree(ruleTreeXML);\n ruleTreeXML = client.getRdrTree(specID, \"Treat\", RuleType.ItemSelection, handle);\n if (!successful(ruleTreeXML)) throw new IOException(ruleTreeXML);\n RdrTree ruleTree2 = marshal.unmarshalTree(ruleTreeXML);\n\n // get a Rule Node\n String ruleNodeXML = client.getNode(specID, null, RuleType.CasePreconstraint, 1, handle);\n if (!successful(ruleNodeXML)) throw new IOException(ruleNodeXML);\n RdrNode node1 = marshal.unmarshalNode(ruleNodeXML);\n ruleNodeXML = client.getNode(processName, \"Archive\", RuleType.ItemSelection, 4, handle);\n if (!successful(ruleNodeXML)) throw new IOException(ruleNodeXML);\n RdrNode node2 = marshal.unmarshalNode(ruleNodeXML);\n}\n\nListing 6.1: Examples of using the Worklet Gateway Client ‘get’ methods\n\nGet Methods\n\nFirstly, there are a number of get methods, which can be used to retrieve an individual rule node, a rule tree (a set of connected nodes for a particular rule type and task id), or an entire rule set (the set of rule trees for a particular specification or process). Each of the get methods, and in fact all of the client methods, return a String value representing a successful result or an appropriate error message. A successful result for a get method contains an XML String representation of the object retrieved, which can be unmarshalled into the appropriate object using the RdrMarshal class, as shown in the examples in Listing 6.1:\n\n- A new WorkletGatewayClient is instantiated on line 5. Since no URL is passed to the constructor, the default URL for the worklet gateway is used (which assumes the Worklet Service is installed locally).\n- Line 6 establishes a session with the client, and assumes the call will be successful, for simplicity. While the default ‘admin’ credentials have been used in the example, it is of course recommended that you use the actual credentials provided by your service when it was registered with the engine (cf. Section 3.3.4).\n- Lines 9–11 retrieve a rule set for a specification from the Worklet Service, checks that the result was successful, then unmarshals the XML to a RdrSet object. A second version of the getRdrSet method accepts a process name instead of a specification id.\n- Two rule trees are retrieved on lines 14–20. The first uses a processName and gets the CasePreconstraint\n```java\npublic void example throws IOException {\n YSpecificationID specID = new YSpecificationID(null, \"0.1\", \"someSpecification\");\n RdrMarshal marshal = new RdrMarshal();\n WorkletGatewayClient client = new WorkletGatewayClient();\n String handle = client.connect(\"admin\", \"YAWL\");\n\n // evaluate a Rule Type against a data set\n String dataStr = \"<data><Age>40</Age><Fracture>true</Fracture></data>\";\n Element data = JDOMUtil.stringToElement(dataStr);\n String conclusionXML = client.evaluate(specID, \"Treat\", data, RuleType.\n ItemSelection, handle);\n if (!successful(conclusionXML)) throw new IOException(conclusionXML);\n RdrConclusion conclusion = marshal.unmarshalConclusion(conclusionXML);\n}\n```\n\nListing 6.2: Example using the Worklet Gateway Client 'evaluate' method\n\nrule tree for it. Since we are retrieving a case-level rule tree, the second parameter, for task id, is passed a null value. The call on line 18 uses a specification id and gets the ItemSelection rule tree for its Treat task. Since we are retrieving an item-level rule tree, and each task for an item-level rule type has its own rule tree, the required task id value is supplied. There is also a variation of this method that takes a WorkItemRecord parameter, rather than a spec id and task id combination.\n\n- Two rule nodes are retrieved on lines 23–30. Again, the call on line 23 is for a case-level rule type, so no task id is supplied, while one is supplied for the item-level rule call on line 27. We also pass the actual node id (integer) that identifies the node to be returned in each call. Again, there is also a variation of this method that takes a WorkItemRecord parameter, rather than a spec id and task id combination.\n\nEvaluation Methods\n\nThe rule sets maintained by the Worklet Service can be evaluated against a given data set via the client API. Like the get methods, there are variations that accept a specification id or a process name, and if evaluating an item-level rule tree, a task id. There are three possible results when a rule set is evaluated:\n\n1. No rule tree exists for the given specification id or process name, and/or task id, and rule type (as required). An error message to that effect is returned.\n2. A rule tree exists for the given parameters, but none of its nodes’ conditions were satisfied. An error message to that effect is returned.\n3. A rule tree exists for the given parameters, and at least one its nodes’ conditions were satisfied. An RdrConclusion is returned.\n\nThe conclusion of a rule node represents a set of primitives, each comprising an action and a target. For example, the conclusion of an ItemSelection rule node contains one primitive, with an action of ‘select’ and a target naming the worklet to select. The conclusion of an exception rule type may contain any number of primitives (see the Worklet Service chapter of the YAWL User Manual for more information). An RdrConclusion object is a convenience object that stores the primitives and allows you to iterate through them. Of course, if you are using the Worklet Service merely as an RDR store, and don’t intend to have the rules evaluated by the Worklet Service in relation to a YAWL process instance, then the conclusion of a rule node can contain any data of relevance to your service or application.\n\nAn example of an evaluate method call is shown in Listing 6.2.\npublic void example throws IOException {\n YSpecificationID specID = new YSpecificationID(null, \"0.1\", \"someSpecification\");\n RdrMarshal marshal = new RdrMarshal();\n WorkletGatewayClient client = new WorkletGatewayClient();\n String handle = client.connect(\"admin\", \"YAWL\");\n\n // add a Rule Node\n String cornerStr = \"<data><Age><40</Age><Fracture>true</Fracture></data>\";\n Element eCornerstone = JDOMUtil.stringToElement(cornerStr);\n RdrConclusion conclusion = new RdrConclusion();\n conclusion.addCornerstone = JDOMUtil.stringToElement(cornerStr);\n conclusion.addPrimitive(ExletAction.Suspend, ExletTarget.Case);\n conclusion.addCompensationPrimitive(\"myWorklet\");\n conclusion.addPrimitive(ExletAction.Continue, ExletTarget.Case);\n RdrNode node = new RdrNode(\"Age > 75\", conclusion, eCornerstone);\n String newNodeXML = client.addNode(specID, \"Treat\", RuleType.ItemPreConstraint, node, handle);\n if (!successful(newNodeXML)) throw new IOException(newNodeXML);\n node = marshal.unmarshalNode(newNodeXML);\n}\n\nListing 6.3: Example using the Worklet Gateway Client to add a new Rule Node\n\nAdding a Rule Node\n\nRDR are structured in such a way that rule nodes can be added at any time, but never deleted, since deleting a node would ‘break’ the tree’s internal framework (again, more details on this concept can be found in the Worklet Service chapter of the YAWL User Manual). The client API provides a method to add a rule node to a rule set for a specification or process, with similar variations to those mentioned above for the different rule types. An example of adding a node is shown in Listing 6.3.\n\nWhen adding a rule node, please keep in mind the following:\n\n- The node being added requires values for condition, conclusion and cornerstone data only, as shown in lines 8–13 of Listing 6.3. Values for the node’s id, parent, trueChild and falseChild fields are not required, and in any case will be replaced by the Worklet Service in the process of inserting the node in the appropriate location in its rule tree. A value for the description field is optional.\n\n- The condition value is the condition that will be evaluated for the node when it is reached during a tree evaluation. It is important when framing conditions to be aware of how an evaluation traverses the tree, that is when a condition is satisfied for a node, that node’s child node on its true branch (if any) is then evaluated; if it is not satisfied, then its false child (if any) is evaluated. Therefore, each node’s condition forms a ‘unit’ in a larger, conjunctive condition, and so each node’s condition should not repeat those parts that have already been evaluated in higher level nodes of the tree. For example, if a node’s condition “Age > 25” is satisfied, then the node being added as its true child might be “Height < 170”, rather than “Age > 25 and Height < 170”, since the first part of the condition has already been evaluated and satisfied.\n\n- The cornerstone data is very important when adding a node to an existing tree, as it is used to determine the proper location of the node. It must be valid XML, but the name of its root element can be anything – the name ‘data’ is a convention rather than a rule.\n\n- The conclusion creation shown on lines 10–13 follows the required structure for conclusions intended to be executed by the Worklet Service (that is, a series of primitves, each with child ‘action’ and ‘target’ elements), but as stated above if you are using the RDR for other purposes then this format doesn’t need to be followed, but should be a JDOM Element named “conclusion” with content appropriate it the purpose in use.\n• The node returned by the call to the addNode method is the node added, complete with the added value for id.\n\n• If no rule set currently exists for the specification id or process name given, then one is created.\n\n• If no rule tree currently exists for the specification id or process name, and rule type (and task id if required) given, then one is created, and then the node is added as the first node in the tree (after the root node).\n\n6.1.2 User-defined Functions\n\nThe condition defined for each rule node is an expression that must evaluate to a final boolean (true/false) value. Expressions can be formed using the usual numeric, comparison and logical operators (&, !, |), and operands consisting of literal values, and/or the values referenced by the name of case and/or workitem data variables. In more complex expressions, the usual order of precedence applies, and sub-expressions can be grouped with parentheses to override the order.\n\nAlternately, a condition can be defined as an XQuery expression, which is useful if you need to query case or workitem data stored as complex data types. An XQuery should be enclosed in curly braces, for example: \n\n {/myTask/Person/Name/text() = 'John'}.\n\nIn addition, conditional expressions support the use of user-defined functions, that is functions that are defined to evaluate the available data in a particular way, which can then be inserted into expressions. These functions can pass arguments consisting of literal values, and case or workitem data variable names, which will be substituted with their actual runtime values before being passed to the function.\n\nThere are two ways to add user-defined functions to the condition evaluator. The first is detailed in Section 8.7 of the YAWL User Manual, which involves adding code to an existing class and recompiling it. The second, perhaps neater way, is described below.\n\nAdding a Pluggable User-defined Function\n\nThis method involves creating and adding pluggable classes to the service’s classpath.\n\nStep 1. Defining the Function Each function is defined in its own class, which implements the java interface RdrFunction. There are two methods to implement (Listing 6.4):\n\n• String getName(), that should return the name of your function (which can be different to the name of the new class). The name returned will match the name used within a conditional expression for a rule node.\n\n• String execute(Map<String, String> args) is the method where the body of your function is defined. The Map of arguments passed in are String key-value pairs, each pair consisting of the name of the variable stated in the function and its (current) value. Any non-String values are converted to Strings as required. This method must return a String value, which may be any value if the expression uses the function as part of a comparison operation, or “true” or “false” if the expression uses the function as a standalone value or as part of a logical operation. For example, if the expression is myFunc(x) = ‘Confirmed’, then your function should return a String value such as “Confirmed” or “Denied”; if the expression is myFunc(x) | isActive(this) or simply myFunc(x), then your function should return “true” or “false”. If your function is used as part of a numeric comparison, for example myFunc(z) < 50, your function should return its String equivalent, which will be interpreted as a numeric by the Condition Evaluator.\n\nFor work item level rules, a special argument, called this, can be passed via your function call (e.g. myFunc(this)). It’s value will be an XML string of the complete work item record, so that specification and task descriptors, and state and timing values can be used by your function.\npackage com.example;\n\npublic class MyRdrFunction implements RdrFunction {\n public String getName() { return \"myFunc\"; }\n public String execute(Map<String, String> args) {\n String x = args.get(\"x\");\n return x.equals(\"OK\") ? \"Confirmed\" : \"Denied\";\n }\n}\n\nListing 6.4: An example RdrFunction implementation\n\nStep 2. Creating a Jar Once your RdrFunction implementation is complete, it must be bundled up in a jar file, using the format shown in Figure 6.1. Under a working directory (of any name), place the compiled class that implements the RdrFunction interface in its package structure. For example, in Figure 6.1 our class is in the `com.example` package, so it is placed in a `\\com\\example\\MyFuncImpl.class` directory path. Also under the working directory, create a subdirectory called META-INF to contain the manifest file for the jar, then under that create a subdirectory called services.\n\nIn the services file, create a new, plain text file and name it as the full name of the RdrFunction interface, namely `org.yawlfoundation.yawl.worklet.support.RdrFunction` (no txt extension). In that file, enter the full name of your implementing class on a single line (for example, `com.example.MyFuncImpl` – no class extension). That is, the contents of the text file should contain the fully qualified class name of your implementation. If you have implemented several RdrFunction classes, they should each be listed in this same file, one on each line.\n\n\n\nTo compile the directory structure into a jar (of any name), enter this command from a prompt in the working directory: `jar cvf somename.jar -C ./ .`.\n\nStep 3. Jar to classpath The final task is to place the new jar file on the Worklet Service’s classpath. The easiest way to do this is to copy it to the jar to the `tomcat\\webapps\\WEB-INF\\lib` directory (create the lib directory if it doesn’t already exist). Restart the service and your new function will be ready for inclusion in conditional expressions.\npublic class ExampleWorkletListener extends WorkletEventListener {\n \n public void caseLevelExceptionEvent(String caseID, Element caseData, RdrNode node, RuleType ruleType) {\n }\n\n public void itemLevelExceptionEvent(WorkItemRecord wir, Element caseData, RdrNode node, RuleType ruleType) {\n }\n\n public void selectionEvent(WorkItemRecord wir, Map<String, String> caseMap, RdrNode node) {\n }\n\n public void constraintSuccessEvent(String caseID, WorkItemRecord wir, Element caseData, RuleType ruleType) {\n }\n\n public void shutdown() {\n }\n}\n\nListing 6.5: An example Worklet Event Listener implementation\n\n### 6.2 Worklet Event Listeners\n\nEach time the Worklet Service selects a worklet for a work item, or raises an exception for a work item or case, details of the event are announced to registered listener classes. Listeners can use these event announcements to perform additional processing as required, and make it possible to create exception handling service chains. Note that if the Worklet Service’s exception handling facility is configured as disabled, no exception announcements will be generated (see the Worklet Service chapter of the YAWL User Manual for details on configuration).\n\n#### 6.2.1 Creating a Worklet Event Listener\n\nAn abstract class called `WorkletEventListener`, found in the `worklet.support` package, is the base class for all worklet listeners. This class is a `HttpServlet` that handles all of the mechanics involved in receiving notifications from the Worklet Service and transforming them into five abstract method calls that are to be implemented by extending classes. Listing 6.5 shows a basic example of a worklet event listener implementation.\n\nThe five methods are:\n\n- **`caseLevelExceptionEvent`** is called each time a case level exception is raised. The `caseData` parameter contains the case-level data that was current when the exception was raised and was used to determine the rule violation. The `ruleType` parameter describes what type of exception has been raised; it will match one of the three case-level exception types (pre-constraint, post-constraint, external trigger). The `node` parameter is the RdrNode that evaluated to true and so triggered the raising of the exception.\n\n- **`itemLevelExceptionEvent`** is called each time a item level exception is raised. The `ruleType` parameter describes what type of exception has been raised; it will match one of the three case-level exception types (pre-constraint, post-constraint, in situ constraint violation, external trigger, timeout, resource unavailable, work item abort). The `node` parameter is the RdrNode that evaluated to true and so triggered the raising of the exception.\n\n- **`selectionEvent`** is called each time a worklet selection occurs, that is when a worklet is substituted for a work item. The `WorkItemRecord` will contain the usual case, task, work item and data descriptors. The `caseMap` parameter is a map of key-value pairs, each pair consisting of the case id and worklet...\nname for each worklet selected for the work item — one case for single-instance tasks and several cases for multiple-instance tasks (a worklet is selected for each instance of a multiple-instance class, and a different worklet may be selected for each instance). The node parameter is the RdrNode that evaluated to true and so triggered the raising of the selection.\n\n- **constraintSuccessEvent** is called each time a case or work item, that has pre- or post-constraint rules defined, has had these rules evaluated and the case or work item passes the constraints (i.e. no rules were satisfied and so exception was raised).\n\n- **shutdown** is called when the Worklet Service is shutting down, and allows implementers to take any necessary action.\n\nOnce the listener class implementation is complete, an extra servlet definition section needs to be added to the web.xml of your service, as shown in Listing 6.6. The `<servlet-name>` values on lines 2 and 10 can be any name, but must match. On line 4, the fully-qualified name of your service’s event listener implementation class should be entered. Line 11 contains the URL that will form the resource name that references the listener implementation, and again can be any name. For example, if your service is installed locally and is named as per the listing, then the full URL to it will be http://localhost:8080/myService/workletListener.\n\nThe final step is to register your listener with the Worklet Service. Listing 6.7 shows an example of the code required to do that (see also Section 6.1). Regarding the example:\n\n- On line 4, a URL String of our listener is given. Note that it matches the URL defined via our web.xml settings above.\n\n- Line 6 contains the call to add the listener to the Worklet Services set of listeners. The addListener method returns a String containing a success or error message, which is converted to a boolean value via the successful method (which will be available assuming that your custom service extends InterfaceBWebsideController). Added listeners can be removed from the Worklet Service via a removeListener method.\n\nYour service should first ensure that the Worklet Service has completed its initialisation before the registration is attempted. The easiest way to do that is to have your custom service implement Interface B’s handleEngineInitialisationCompletedEvent (see Section 3.4.2) – the Engine completes its initialisation moments after the Worklet Service does.\n\n---\n\n**Listing 6.6**: Listening service’s web.xml addition\n\n```xml\n<servlet>\n <servlet-name>WorkletEventListener</servlet-name>\n <servlet-class>\n org.yawlfoundation.yawl.myService.ExampleWorkletListener\n </servlet-class>\n <load-on-startup>1</load-on-startup>\n</servlet>\n\n<servlet-mapping>\n <servlet-name>WorkletEventListener</servlet-name>\n <url-pattern>/workletListener</url-pattern>\n</servlet-mapping>\n```\npublic boolean registerWorkletListener()\n{\n WorkletGatewayClient client = new WorkletGatewayClient();\n try {\n String url = \"http://localhost:8080/myService/workletlistener\";\n String handle = client.connect(\"admin\", \"YAWL\");\n return successful(client.addListener(url, handle));\n } catch (IOException ioe) {\n log.error(\"Failed to register listener: \" + ioe.getMessage());\n }\n return false;\n}\nChapter 7\n\nThe Editor\n\n7.1 Introduction\n\nThis chapter describes the technical aspects of the YAWL Editor (currently at version 2.1). Knowledge of Java, UML and the semantics of YAWL is assumed. The chapter is intended to give the reader an introduction and insight into the editor’s design. While the reader may find some features of the editor’s design and implementation somewhat “odd”, they are nevertheless that way for sound reasons. Many are legacy concepts from the initial desire to build a quick prototype.\n\n7.2 Foundations\n\nThe editor has been written in such a way that the core graphing library, JGraph, forms the very heart of the application. A decision to replace the core graphing library is a decision to rewrite the editor from scratch. Its reach goes too far, and is too tightly coupled to the rest of the code for the editor to be considered anything other than an “application of JGraph”.\n\nSection 7.2.1 covers the motivation for, and basics of using JGraph. Section 7.2.2 gives a high-level tour of the Java packages of the editor, introducing the nature of classes that are to be found in each package and highlights packages of particular importance. Section 7.2.3 introduces how the base JGraph library has been extended to achieve the YAWL editor’s key graphing functionality. Section 7.2.4 describes interesting aspects of the editor’s build script.\n\n7.2.1 JGraph\n\nAt the inception of the YAWLEditor project, a number of desired requirements for the editor were listed by the drivers of the project. The editor was to be:\n\n- freely available,\n- runnable heterogeneously,\n- easy to develop,\n- inter-operate easily with the YAWL Engine,\n- easy to deliver and run.\n\nThe greatest impediment to delivering a prototype IDE for YAWL was that of an adequately powerful graphing library. The project could only show quick outcomes by relying on a third-party graphing library that also enabled these requirements.\nAt the time, the JGraph drawing package was the only package to meet these requirements from the perspective of a drawing environment for YAWL. A close second was the GEF drawing framework that comes with the Eclipse IDE. The final decider against GEF, however, was the requirement that the editor be a plugin to Eclipse, and that users of the editor would need Eclipse as a base environment to run within. The authors of GEF stated at the time that it might be possible to run GEF independently of Eclipse, but that those who were to try were on their own if they encountered problems. While building standalone Eclipse applications is now commonplace, at the time of the original design of the editor (2004), it was decided that JGraph was the better approach.\n\nThe requirements are re-listed below with a brief description per requirement of JGraph’s match to the requirement:\n\n**Freely available:** Written in Java, released under LGPL. There were no runtime environment licensing costs for the language, and the library was free to use in programming efforts so long as the LGPL requirements were respected.\n\n**Runnable heterogeneously:** Java programs allows a high likelihood that they will run with little to no changes on different operating systems with compatible JREs. Also, few heterogeneous languages besides Java and C# had a rich enough GUI environment to be considered viable.\n\n**Easy to develop:** Again, Java is one of the best supported programming languages in terms of learning and adoption. Though the library was not exactly easy to develop with, it was the only free stand-alone Java library being actively supported at the time.\n\n**Inter-operate easily with the YAWL Engine:** The engine was written in Java, and to leverage as much of what the engine had to offer as possible, the path of least effort was to call engine API methods in the same language.\n\n**Easy to deliver and run:** JGraph could be incorporated into an application to produce a standalone Java application. GEF, which shared many of the above requirements until this point required the Eclipse IDE to run, and expected an application using GEF to be written as an Eclipse plugin. At the time, this was not a trivial exercise to accomplish. Opinion by the project owners at the time was that they also disliked the idea of requiring such a large IDE as a pre-requisite for trying the editor.\n\nJGraph can be a difficult library to understand initially. The reader is directed to the JGraph tutorial for an official discussion of the framework. Below is a brief, bottom-up description of the environment. A small class diagram of the “core” JGraph model primitives is supplied in figure 7.1.\n\nA graphing package at its heart is a convenience package allowing a user to easily connect a set of nodes with lines. In JGraph, a node is made by implementing the abstract GraphCell interface, and a line an Edge. The only way to connect an edge to a node is via another type of cell called a Port. (Nodes, edges and ports are all subtypes of the GraphCell interface). A port must be a child of a node. Thus, to connect one node to another with an edge, you do so via connecting that edge to a child port for each of the nodes. Figure 7.2 illustrates this relationship with a concrete example.\n\nIn figure 7.2, two tasks are connected to each other with a flow. The tasks are YAWLVertex objects that implement the GraphCell interface. The flow is an extension of Edge interface. The edge is selected, making visible the ports connecting the edge to the boundaries of the relevant tasks.\n\nJGraph is an implementation of the MVC (Model-view-controller) software design pattern. An implementation of this pattern requires a model object, a controller object, and a number of view objects. Very basic versions of each type of class are supplied via DefaultGraphModel, JGraph and GraphLayoutCache for the model, controller and views, respectively. Implementations of the interfaces listed in figure 7.1 must be placed within a DefaultGraphModel, to be considered part of that graph.\n\nAn important conceptual note must be made here on how to appropriately use JGraph:\n\n---\n\n1Even then, this is not a faithful representation of the true relationships of classes within JGraph, but does act as a good model of how to view how you’d typically consider these key classes to interact.\nA change to the graph model will only be recognised and responded to if done through key methods of the view, controller or graph model objects. If you directly change the color of a node, say, by programatically updating its colour directly, the controller will not know to inform the various views of that node that the colour has changed, and that they must now redraw themselves.\n\nAll changes made to a graph ultimately must go through one of the three methods of DefaultGraphModel: insert(), remove(), and edit(). As stated earlier, failure to make changes via these methods will leave the views out of sync with the base model. It will also not record those changes as undoable events, which is typically automatically handled by the JGraph framework. Note that these methods are also supplied on the view and controller classes. It is sometimes easier to use one of these classes, if that is the level that your own code has been working on. Note, however, that especially with the view class, things don’t always work as expected. Some attribute changes will not be reflected in the model, if done from the view.\n\nChanging attributes on JGraph objects warrants some explanation. When first building an object for placement in a JGraph, the programmer is expected to load a number of attributes into a HashMap container, and apply these attributes to the object via the map. The object can then be added to the graph via a call to the graph’s insert() method. Example editor code is supplied in listing 7.1 to illustrate the point.\n\n```java\nprivate void buildContent() {\n HashMap map = new HashMap();\n GraphConstants.setLineEnd(map, GraphConstants.ARROW_TECHNICAL);\n GraphConstants.setEndFill(map, true);\n}\n```\nGraphConstants.setLineStyle(map, GraphConstants.STYLE_ORTHOGONAL);\nGraphConstants.setBendable(map, false);\nGraphConstants.setEditable(map, true);\n\nGraphConstants.setDisconnectable(map, true);\nGraphConstants.setConnectable(map, true);\n\ngetAttributes().applyMap(map);\nsetPredicate(\"true()\");\nsetPriority(0);\n}\n\nListing 7.1: Setting attributes on a model object\n\nListing 7.1 shows code for setting key attributes of flow relations, which are a kind of edge within YAWL. The GraphConstants class is used to ensure that the hashmap is built only with type-safe data that is compatible with a given attribute.\n\nNote also that a great deal of the API for JGraph requires that arrays of the most basic Java Object be passed around. The JGraph tutorial lists a number of reasons why they feel this is a necessary part of the framework. However, as a user of the framework, one should be careful not to come to grief by finding objects of an unexpected class mixed into a return set. Another side-effect of this is the large amount of class-casting code required on the boundaries between the editor code and the JGraph library.\n\nThough there is a great deal more to the framework in terms of constructing views, listening for events, and the like, a discussion on such aspects is left until we actually describe key extensions made for YAWL. On a final note for JGraph, the reader is urged to familiarise themselves with the JGraph FAQ, and to become familiar with JGraph’s forums for further support.\n\n7.2.2 Package Contents\n\nThis section briefly describes the Java package hierarchy of the YAWLEditor, giving a basic guide to what a programmer may expect to find in any given editor source package. Any Java code that belongs specifically to the editor will reside in a sub-package of the base editor package org.yawlfoundation.yawl.editor. We assume that this package is reserved specifically for editor code. This base editor package deliberately contains only two classes:\n\nYAWLEditor.java: The bootstrap class that starts the editor running.\n\nTestYAWLEditor.java: This is the core JUnit test class that binds all other JUnit test classes for the editor so that they may be executed as a single unit test.\n\nFigure 7.3 lists the current Java packages that makes up the core editor code, and briefly describes the nature of the classes to be found in each package. If there is a “key” package of the editor, containing classes that do the core job of graph manipulation, that package is org.yawlfoundation.yawl.editor.net. On a darker note, if there is anywhere in the editor where classes have tended toward implementing the god object anti-pattern, this this is the package for the very worst examples.\n\nAnother important package is org.yawlfoundation.yawl.editor.specification. This package, however, is focused on managing an entire specification. There is very little code specific to graphing in this package, but the classes here are responsible for saving and loading a specification, and managing specification-wide events.\n\nIn later sections, key classes from both packages will be described in much more detail.\nFigure 7.3: The Java package hierarchy of the editor\n7.2.3 Extensions to JGraph\n\nWith a basic understanding of how JGraph works from section 7.2.1, we now describe how the basic framework of JGraph has been extended to implement the YAWLEditor. This section describes passive elements in section 7.2.3 and active elements in section 7.2.3 depending on whether they need further processing, or are responsible for the processing, respectively.\n\nPassive Graphing Elements\n\nFigure 7.4 is a class diagram showing how the graphing model constructs of JGraph (see figure 7.1) have been extended to implement the YAWLEditor graphing model. These constructs reside in the package org.yawlfoundation.yawl.editor.elements.model. The package is passive in the sense that it’s not enough to just change attributes on objects in the package and have the change work. The changes must be processed through an active component, described later.\n\nFigure 7.4: A class diagram of the graph model of the YAWLEditor\n\nA few features of figure 7.4 need discussion. We can see from the class diagram that a number of classes inherit from DefaultGraphCell. The most important of these from a design perspective is YAWLVertex. The other three inherited classes (being VertexLabel, VertexContainer and Decorator) play a subservient role to YAWLVertex. For example, if a VertexContainer exists, it can only do so if it contains a YAWLVertex. Though other constructs can be contained within a VertexContainer, they are all optional, and very much depend on the existence of the vertex to have any meaning.\n\nNote that the concept of a VertexContainer, and explicit Decorator classes for splits and joins...\nwas a conscious design decision. An alternative was to have tasks contain all split and join behaviour. This alternative would have been a more natural fit to the engine native XML file format where there is no concept of a decorator for a task to describe a split or a join. After some consideration, it was felt that the complexity of a single Task object (especially view objects, described later) would be too high, and involve far too much coupling to a task’s model and view objects, if it were also to contain split and join logic.\n\nFigure 7.5 shows a concrete example of a VertexContainer, containing an AtomicTask instance, a SplitDecorator, a JoinDecorator and a VertexLabel. The container has been selected, and its boundary is currently visible for the purpose of manipulating the entire set of components within it as a single entity. The container’s purpose is to hold together a number of graph constructs that need to be considered a single conceptual entity by a workflow designer. Again, it should be stressed that without the AtomicTask, there is no purpose to the other constructs that have been bound to it.\n\nFigure 7.5: A concrete example of a VertexContainer binding task elements together.\n\nNote also from figure 7.4, that there are a number of ports bound to certain key objects. A design decision was made to have a number of ports per net graph element, to be positioned along an appropriate boundary of the graph element. The alternative considered was to have a single port at the centre of a node where all flows for that node could be connected, which is more in keeping with packages such as Microsoft Visio. This Visio-style approach has also been occasionally asked for in the past. Two insights led the the approach constructed:\n\n- Splits and joins in YAWL overlap in their representative icons. A single port would allow a great deal of ambiguity over the kind of split or join that a task had (a flow could be drawn running into an or-split, for example, which is also drawn the same way as an or-join). It was decided that to force only outgoing flow from splits, and incoming flows to joins, thus removing a degree of possible confusion around splits and joins.\n\n- The mechanics for having a flow connect to the center of a node, but only drawn to its edge breaks down when a task has a split and a join on adjacent edges. The bounding-box of the entire task element set, including the split and join has a small square of whitespace between the two decorators, and flows would run only to the edge of this whitespace. The result would be a flow that seems to stop short of the task to which it’s connected.\n\nConditions and tasks both have sub-trees of inheritance from YAWLVertex and each encode their own specific required model constraints. Note that the class hierarchy depicted in figure 7.4 introduces a set of methods that allows a particular class to answer questions about what may validly be done with it, meaning that as far as possible, rules are localised to the class involving them. For example, a standard Condition allows both incoming and outgoing flows. If you were to ask an InputCondition, however, if it allowed incoming flows, it would answer in the negative. The reader is directed to the interface YAWLCell for a set of basic methods that all tasks, conditions and flow relations must implement. Further interfaces (see YAWLCompositeTask for example) deeper in the hierarchy introduce more specialised methods to enforce requirements particular to certain workflow elements.\n\nThe corresponding views of the model objects described above can also be viewed as passive. They simply draw on the screen a representation of their corresponding model object equivalents. Figure 7.6 is a class\ndiagram mapping key model classes from figure 7.4 to the view classes responsible for their rendering. The view classes required reside in the package org.yawlfoundation.yawl.editor.elements.view.\n\n\n\n**Figure 7.6:** A class diagram of how model objects are associated with their views\n\nWe note from figure 7.6 that ports, flow relations and vertex containers need no special rendering, and fall back to the basic view classes supplied by JGraph. Other net elements need their own views specified, however. Note the special case of the Decorator and DecoratorView pair. Instances of SplitDecorator and JoinDecorator are ultimately what are placed on the canvas of a Net graph. However, there is significant overlap in how splits and joins graphically represent whether they are OR, XOR, or AND types. Rather than repeat the same rendering code in two classes, the one view object deals with both types of decorator.\n\nJGraph requires that a special type of class be supplied to the view component of the graph that acts as an implementation of the factory pattern. This class is to take model objects, and return corresponding view object for them, and is ultimately invoked by the JGraph view component. We also see from this figure that we need no special view component for the actual graph of a YAWL net. The JGraph supplied DefaultGraphLayoutCache suffices, so long as it has an instance of NetCellViewFactory set as its view factory.\n\n**Active Graphing Elements**\n\nThe package org.yawlfoundation.yawl.editor.net could be considered the heart of the editor. Specifically the two classes NetGraph and NetGraphModel from this package are where the real action for drawing YAWL nets is to be found. Figure 7.7 is a class diagram of the core net package classes and their relationship to each other. The reader should see almost immediately that all roads lead to NetGraph. Following close behind this class in terms of importance to editor behaviour is the class NetGraphModel.\n\nA note should be made on cancellation sets, and their implementation. Every atomic task can potentially have its own cancellation set. However, only one cancellation set can be rendered on the graph at any one time. When that cancellation set is viewable, CancellationSetModel allows additions and removal of elements from the relevant cancellation set. We have one CancellationSetModel per NetGraph, though the actual cancellation set this model manipulates can change with user selection.\n\nFigure 7.8 shows the cancellation set of task $a$ being rendered in red. As $a$ is the cancellation set triggering\nFigure 7.7: A class diagram of the core net package\n\ntask, its background is grey. Whilst the cancellation region of a is visible, extra tooltip buttons become enabled, allowing the user to change the composition of this cancellation set. This is a deliberate design choice that varies somewhat from the \"lasso\" approach described in the YAWL research publications. The lasso concept proved be difficult to implement, especially when some tasks in a rectangular region of a lasso may not be part of the cancellation set.\n\nThere are also a number of classes that register as mouse and keyboard listeners with NetGraph to handle various functionality triggered by these forms of input. Most of these classes are rather trivial, and quickly understandable with a perusal of the actual code. One, however, is rather complex, and deserves further discussion.\n\nThis class is NetMarqueeHandler, and is responsible for dealing with basic drawing on the graph, taking into account a number of factors, such as the currently selected palette button, and the type of element the mouse was hovering over when a user began using the mouse on the graph. The key behaviour of this class is to recognise and react to mouse events for placing tasks and conditions on the graph, to allow flows to be drawn between valid net elements, and to allow for the selection of a number of elements for further processing.\n\nEarlier versions of the editor required a “flow” palette button that had to be selected to allow flows to be drawn between elements. Several users mentioned that they wished to draw flows without having to select the palette button, however. Texts on UI design\\(^2\\) also suggest that removing modal behaviour, such as\n\n\\(^2\\)See “The Humane Interface” by Jef Raskin for one of the better explanation on why modal UI behaviour is to be avoided where possible.\nexplicitly requiring a flow palette button to be depressed for drawing a flow, be removed where possible. Thus, NetMarqueeHandler underwent an overhaul, and implemented a state transition machine that allowed the user to draw flows if their mouse was over a valid port, to drag an element if over the element, or drop a new element onto the graph canvas if there is nothing under the mouse. The state transition diagram used to initially design the desired change in marquee behaviour is shown in figure 7.9. It is supplied here in the hopes of allowing a quick understanding of the state transition machine built into NetMarqueeHandler.\n\nFigure 7.9: A state transition diagram for NetMarqueeHandler\n\n7.2.4 Build Environment\n\nThis section describes the build environment used to create an executable editor, along with issues that developers should be aware of when having to make changes to this build environment. The editor has an\nant build script, which sits within the source directory of the editor. All of the resources required by this script are expressed in terms of relative paths to the script. It’s thus possible to decompress the source zip file anywhere, and expect to have the ant script produce runnable editor jar files. The script has a number of targets, listed below with a brief description of the result when running the script with a given target:\n\nbuildEditorComplete: Compiles, builds and packages a complete YAWLEditor.jar. This target requires the YAWL Engine’s standalone jar in the project’s lib directory.\n\nbuildEditorLite: Compiles, builds and packages a “lite” version of the editor, containing just core editor and JGraph code. A lite editor requires the YAWL Engine’s standalone jar on its classpath, or will have all behaviour relying on the engine deactivated if it cannot find it.\n\nclean: Resets the build environment to just the source, tool and library directories. This target should be run whenever the YAWL Engine’s standalone jar is updated in the project’s lib folder.\n\ncompile: Compiles the editor source, by compiling the core YAWLEditor.java class. This will not compile JUnit tests, as the editor does not reference the unit test classes. Part of the work here involves creating a compiled directory containing all resources that should be packed into a standalone jar file.\n\ncompileTestFiles: Compiles the editor’s JUnit source code, and all the editor code that the JUnit code exercises.\n\ndocument: Generates javadoc from the editor source code.\n\nfull: A convenience target, that invokes the clean target, then builds a lite editor, a complete editor, zipped source code and javadoc.\n\nrelease: A convenience target, that builds a lite editor, a complete editor, zipped source code and javadoc ready for release.\n\nrunTests: Runs JUnit on the compiled JUnit test classes.\n\nzipSourceCode: Generates a zipped source file image, and automatically filtered release notes and change log, all ready for minimal-fuss delivery to sourceforge.\n\nNote the existence of the file build.properties residing in the same directory as the ant build script. The build script uses this properties file to identify current version values and dependencies the editor has on other technologies. The properties file is also used to apply filter across the editor source code, replacing placeholder text with actual text spread throughout the editor text for the current build (such a release numbers, etc.).\n\nThere are two sibling directories to the source directory that are important for generating an executable editor. These directories are lib, which contains the standalone engine jar and other required 3rd party libraries, and tools, which currently contains the JUnit jar. Build file deliverables, such as jar files or source zip files, are output to the project’s distribution directory, created as a sibling to the source directory.\n\nWhen it comes to actually building the editor, one can choose a “lite” or complete version of the editor. The original rationale for a “lite” editor stems from original design belief that the editor and engine should remain as decoupled as possible. A lite editor allows one to quickly ascertain whether the editor will function as intended, even without access to the engine. More will be said on coupling between the editor and engine in later sections.\n7.3 Superstructure\n\nThis section describes superstructure of the editor, which uses features described in section 7.2 as the necessary operational basis for the behaviour described here. Behaviour is named “superstructure”, because in a very real sense, this behaviour relies on the behaviour already described in this earlier section.\n\nThis section is broken into a number of subsections. Section 7.3.1 deals with various aspects to specification management. Section 7.3.2 describes the typical approach that has been taken to interfacing with 3rd-party software. Section 7.3.3 briefly describes Swing undo/redo functionality extensions that were needed above and beyond basic JGraph undo/redo behaviour. Section 7.3.4 describes the general approach taken to JUnit testing of the editor.\n\n7.3.1 Specification Management\n\nSection 7.2.3 covered editor behaviour that involved manipulating a single net’s graph. A specification is composed of several nets, however. This section describes key editor behaviour for manipulating a specification. Note that the editor can currently edit only a single specification at a time. This was a design decision taken early in the life of the editor in order to achieve a usable prototype as quickly as possible. Since then, the desire for editing several specifications has been raised time and again, and will be addressed in an upcoming version. Most of the core model behaviour for specifications described here resides within the package org.yawlfoundation.yawl.editor.specification.\n\nFigure 7.10 is a class diagram of the key classes in the specification package. Associations with classes in related packages are shown where it was thought appropriate.\n\nFigure 7.10: A class diagram of the core specification package\n\n**State Management**\n\nThe two core specification package classes SpecificationModel and SpecificationFileModel operate as state transition machines that listeners can react to upon key state change events.\nState transition in `SpecificationModel` is rather trivial. There are two main states that it toggles between, namely `NO_NETS_EXIST` and `NETS_EXIST`. The first of these states happens only briefly on a reset of a specification model, as a valid specification must always have at least a root net. A number of events are also occasionally fired from this class, but are not states as such, just event notifications that state listeners may also care to know about. These events are `NO_NET_SELECTED`, `SOME_NET_SELECTED`, and `NET_DETAIL_CHANGED`. Classes that implement the `SpecificationModelListener` interface will be notified of these events, and react as they deem most appropriate.\n\nState transition in the class `SpecificationFileModel` is a little more involved. A state transition diagram of it is supplied in figure 7.11.\n\n\n\n**Figure 7.11: A STD describing SpecificationFileModel behaviour**\n\nState transition in `SpecificationFileModel` is one the few areas of the editor that caters for the possibility of having several specifications open. Again, there are two key states, being `IDLE` and `EDITING` representing an editor with no specifications open, and an editor with at least one specification open, respectively. A third state, `BUSY` can be reached at any time from either state. Once the model stops being busy, it reverts to whatever state it was previously in. Whenever `SpecificationFileModel` is busy, it is essentially blocking, allowing a devoted file I/O thread class `ArchivingThread` exclusive access to the filesystem, for the purpose of writing or reading files. Classes implementing `SpecificationFileModelListener` are expected to disallow any behaviour whilst in the busy state that might interfere with the file operations currently underway. File I/O is regulated to a dedicated thread to allow the user to continue using the editor on long file operations.\n\nA third state management class, `SpecificationSelectionListener` has all net selection events delegated to it. In reality only a single net will ever be generating selection events, but no matter which net is currently having nodes selected, events will pass from the net selection listener to this class for processing. This class takes the currently selected set of nodes and interrogates them for patterns of selection that are of interest to listeners implementing the `SpecificationSelectionSubscriber` interface. Listeners can subscribe to be informed of a number of patterns that they may wish to react to. The current set of possible patterns tested for are listed below, and are hopefully self-explanatory:\n\n- `STATE_NO_ELEMENTS_SELECTED`\n- `STATE_COPYABLE_ELEMENTS_SELECTED`\n- `DELETEABLE_ELEMENTS_SELECTED`\n- `STATE_ONE_OR_MORE_ELEMENTS_SELECTED`\n- `STATE_MORE_THAN_ONE_ELEMENT_SELECTED`\n- `STATE_MORE_THAN_ONE_VERTEX_SELECTED`\n- `STATE_SINGLE_TASK_SELECTED`\n- `STATE_SINGLE_ELEMENT_SELECTED`\nBehaviour across the various aspects of the editor is only valid when one or more of the above patterns of selection are true. Such behaviour will implement the previously mentioned interface and subscribe for patterns where that behaviour can be applied. For example, input conditions and output conditions cannot be deleted or copied from a net. If a selection in a net selects only an input condition, the copy menu item will know that it has nothing to copy, and stay disabled until such time as a selection event includes net elements that can be copied.\n\nSaving and Loading\n\nThe class `SpecificationArchiveHandler` is responsible for saving and loading YAWL specification files. Prior to version 2.0, an editor save file (ywl file) was, quite literally, an XML serialization of specification model objects that has been compressed using the popular Winzip compression algorithm. It is thus possible to open a ywl file with Winzip or some other compatible compression utility and interrogate the XML representing the state of model objects in the editor at save-time. Since 2.0, these serialized files have been deprecated, and all loading and saving is done to and from yawl files in plain-old-XML (POX) format.\n\nAs a legacy of the pre-2.0 file serialization formats, each class that was serialized as part of the editor save/load routine uniformly stores its data members in a `HashMap` called `serializationProofAttributeMap`. Without this approach to saving and loading object attributes, the addition of a new attribute to a class would break save-file backward compatibility, stopping the editor from successfully loading older specifications that do not have a newly introduced object attribute. Note also that JGraph employs a similar technique for its core graphing elements.\n\nListing 7.2 shows example code to highlight the way in which state is expected to reside as attributes in these model objects. As they were ultimately to be processed by the Java classes `java.beans.XMLEncoder` and `java.beans.XMLDecoder`, all state saved and loaded needed to conform to those parts of the Java Bean standard needed by these XML utilities. Specifically, a class needs a no-argument constructor, which will be invoked when the class is initially de-serialized, and a get()/set() method pair for each attribute that they wish to serialize.\n\n```java\nprivate HashMap serializationProofAttributeMap = new HashMap();\n\n... \n\npublic void setSerializationProofAttributeMap(HashMap map) {\n this.serializationProofAttributeMap = map;\n}\n\npublic HashMap getSerializationProofAttributeMap() {\n return this.serializationProofAttributeMap;\n}\n\n....\n\n// example serialization-proof attribute bean methods below.\n\npublic void setSize(Dimension size) {\n serializationProofAttributeMap.put(\"size\", size);\n}\n\npublic Dimension getSize() {\n return (Dimension) serializationProofAttributeMap.get(\"size\");\n}\n```\n\nListing 7.2: An example serialization proof attribute’s get/set method pair\n7.3.2 Interfacing with 3rd-party Software\n\nWhenever the editor has to interact with the YAWL engine or resource service, an approach was adopted that allows the editor to function with or without access to this software, granting greater behaviour when it is present, and restricting functionality when it is not. These services have a special proxy gateway constructed for them. The gateway, and associated behaviour for each are assigned a specific sub-package of `org.yawlfoundation.yawl.editor.thirdparty`.\n\nThe engine proxy will be used as a working example to describe how the editor interfaces with an external software entity. A class diagram of key classes within the third-party engine package is presented in figure 7.12. A proxy interface class is supplied for the third-party software, which defines all possible methods that the editor can invoke that will eventually result in an interaction with the third-party software. For the engine, this interface is `YAWLEngineProxyInterface`. Three classes implement this interface: the core proxy class visible to the rest of the editor, `YAWLEngineProxy`, and two classes for supplying appropriate method call response for when the third-party software is present, and when it is not. The proxy class must implement a boolean test to check for the presence of the third-party software, and delegate processing for a particular method to the most relevant proxy implementation. This framework can be viewed has drawing elements from both the proxy design pattern, and the strategy design pattern.\n\nIn this manner, the editor will continue to function in a reduced capacity if it cannot find the desired third-party software. All interfacing between the editor and the third party is now also isolated and managed from the one point, reducing coupling between the products to a minimum. Note from figure 7.12 that the available implementation of the proxy will often rely on further classes for supplying the behaviour required. Here, engine export and import behaviour is separate out into respective classes with the responsibility of mapping between engine and editor Java objects.\n\n\n\n7.3.3 Undo/Redo Functionality\n\nUndo/redo functionality in an editor can be tricky to get right. Prospective developers are warned of potential gotchas to do with undo/redo generally, and certain behaviour will be pointed out to be added to the editor to better support this activity. Note that individual `NetGraph` changes are often automatically handled by JGraph without incident. However, certain changes may alter a number of nets, or are so involved...\nwithin a net that the basic JGraph undo/redo functionality has required some extension. We thus require a “somewhat more powerful than vanilla JGraph” undo/redo framework that spans all nets of a specification. Undoable event classes all reside in the package org.yawlfoundation.yawl.editor.swing.undo. We’ll begin with the warnings.\n\nThe first warning is that, if interacting with the editor causes a visible change to one or more nets, it should be undoable. That is, if you’ve written code to do something a visible change, you must also write code to undo it. Sometimes, for trivial changes, the same code can handle both variants. If you want to change a node’s colour then undo it, all you need do is store the old and new colour, and invoke the same colour changing code with the appropriate colour. Other times, you must write extra code that knows specifically how to undo the change, because the original change had far more long-reaching effects than just a small screen change, but both screen, and hidden changes much remain in lockstep.\n\nThe second warning is that the undo/redo code that needs to be called from the Swing-supplied framework must not have undo/redo side-effects itself. Otherwise, you may run into interesting bugs where every time you undo a change, you add something extra to be undone, that you never did in the first place. Thus, not only may you need to write specific code to undo a change, you may also occasionally have to write it in such a way as to offer two variants, one with undo/redo side-effects, and one without. Listing 7.3 shows an editor class that requires different code for the undo and redo, that must also be side-effect free.\n\n```java\npublic class UndoableNetAddition extends AbstractUndoableEdit {\n\n private static final long serialVersionUID = 1L;\n private NetGraphModel addedNet;\n\n public UndoableNetAddition(NetGraphModel addedNet) {\n this.addedNet = addedNet;\n }\n\n public void redo() {\n SpecificationModel.getInstance().addNetNotUndoable(addedNet);\n addedNet.getGraph().getFrame().setVisible(true);\n }\n\n public void undo() {\n addedNet.getGraph().getFrame().setVisible(false);\n SpecificationModel.getInstance().removeNetNotUndoable(addedNet);\n }\n}\n```\n\nListing 7.3: Example undoable editor class\n\nFigure 7.13 is a class diagram, focusing on the undoable edit presented in listing 7.3. It shows how all NetGraph instances pass their undoable events to SpecificationUndoManager, which is capable of applying changes across several nets if needs be. It also points points out that SpecificationModel creates a new net, and passes a specification-level undoable event for its creation to the undo manager. The event code presented knows to invoke methods on SpecificationModel with no undo/redo side-effects for redoing or undoing the addition of a net to a specification.\n\nThe class SpecificationUndoManager has also been enhanced from a typical JGraph undo manager so that the programmer can:\n\n- Briefly refuse to record undoable events. This is useful for situations where we wish to make a visible change that is controlled by a mechanism other than undo/redo. An example is the toggling of a visible cancellation set. Whether the set is visible or not is controlled by a popup menu-item for a task, and should not be reversed or re-applied via typical changes, as there is no “real” change happening to the specification here, just a visualisation to highlight aspects of existing state.\n\n- Start and stop compounding edits. Sometimes a large change is composed of a number of small changes that by default, JGraph would make all individual undoable events. Convenience methods are supplied here to make it easy to combine a number of edits into a single edit. An example of where\nthis occurs in NetGraph, where re-labeling a task is handled by deleting the old VertexLabel attached to a task, creating a new one, and re-balancing other elements in the task's VertexContainer as appropriate.\n\n### 7.3.4 Unit Testing Classes\n\nA small number of JUnit test classes have been written for the editor. Code coverage is currently not significant, given the general difficulty with attempting to apply unit-tests to a predominately GUI codebases. What unit tests there are typically lie on the border-regions of the interface between the editor and engine, as this has traditionally been where hard-to-solve compatibility issues have arisen.\n\nThe key editor JUnit class is `org.yawlfoundation.yawl.editor.TestYAWLEditor.java`. This class acts to bootstrap other JUnit classes throughout the editor. Note that a convention for JUnit test classes was followed that the reader should be aware of. A JUnit test class limits its focus to a single editor class. It takes the name of the class it tests, and prepends the text `Test` to identify the class it tests. Only JUnit classes can start with `Test`. A JUnit test class also resides in the same package as the class it tests. As described earlier, the ant build script ensures that test classes are not shipped with the final editor, and enables a way of running the JUnit tests outside of an IDE. The build script assumes the above convention in order to correctly identify the test classes.\n\nThe class `TestSpecificationEngineHandler`, sitting in `thirdparty.engine`, is often pivotal to the continued assurance that the engine and editor interact as intended. This class programatically builds a number of specifications, some valid, some deliberately flawed, and asks the available engine-side code to confirm whether the specification is flawed or not.\n\n### 7.4 Future Considerations\n\nThis final section of the manual lists a number of issues that have been raised from time to time in the past, but have not yet been satisfactorily addressed, to finally free the editor of its prototype legacy. A common inhibitor for these items is time. Most of the items listed represent a significant investment in time, and in some cases, with no visible change the the editor’s behaviour to show for the effort.\n7.4.1 Engine and Editor Coupling\n\nCurrently, coupling between the engine and editor is still higher than preferred. In order to validate a specification, the editor builds a set of engine objects from the editor model, turns this into engine XML, and asks the engine validation methods to supply feedback on the engine XML. All of these activities rely on calls directly into core engine model objects. This has allowed for early rapid construction of an editor that can export and validate engine XML, but the necessary cost is a very tight binding between the editor model and engine model.\n\nThe ideal would be to have the editor not rely on engine objects for generating engine XML, but to generate engine compatible XML without the need to call engine library. This would reduce coupling to the engine immensely, allowing a cleaner separation between the two components than is currently possible.\n\n7.4.2 Data Perspective Complexity\n\nThe data perspective of YAWL is complex, and requires deep XMLSchema and XQuery knowledge to successfully define non-trivial constructs. It is often cited by users as the hardest part of YAWL to understand. The editor currently exposes all of the complexity of the data perspective to users, simply because building abstractions to make it easier to wield represents a significant investment in time. Even valid combinations of scope for passing data from a net to a task and back again is not trivial. The reader is directed to DataVariableSet in org.yawlfoundation.yawl.editor.data for a decision table describing valid scope combinations.\n\nApproaches put forward for managing data perspective complexity is to either provide better support for the full complexity of the data perspective through abstractions, or to revisit the data perspective with a view towards simplifying it. For example, converting values as they pass from the net to the task could be removed, and replaced with a simpler approach where the value passes from net to task unchanged. Any changes needed on the data needed is then forced to the task level, which is outside the scope of the engine. A simplified data perspective in the engine will result in simplified definition of that perspective in the editor.\n\n7.4.3 Plugin Framework\n\nSince version 1.5 of the editor, a simple plugin framework has been introduced. At the moment this framework is primitive, but it has the potential to become a potent extension to the editor. Currently, the plugin framework supports only task icons, and property files that describe extended attributes to be attached to task data variables and decompositions. Ideas for extending the plugin framework include:\n\n- As a mechanism to allow for a library of commonly used decompositions for a particular organisation.\n- In a similar vein, to allow a library of common resourcing specifications to be quickly attached to a particular task. For instance, perhaps an organisation typically automatically allocates work to its users via the roles they play in a round-robin fashion, starting the workitem immediately upon allocation. Such a resourcing decision could be pre-generated and available through the organizations plugin mechanism for quickly attaching to typical tasks in their workflows.\n\nNo doubt more behaviour will become candidates for plugin consideration if it represents a typical tightening of generic behavior to fast-track an organizations typical use of the editor.\nAppendix A\n\nThird Party Software Acknowledgements\n\nThe YAWL Foundation gratefully acknowledges the use of the following third party libraries:\n\n- The following libraries from the Apache Software Foundation (www.apache.org), all of which are licensed under the Apache License (http://www.apache.org/licenses/LICENSE-2.0):\n - apacheSoap 2.3.1\n - axis 1.1\n - commons-beanutils\n - commons-codec-1.4\n - commons-collections-3.2\n - commons-digester\n - commons-discovery\n - commons - fileupload-1.2.2\n - commons-io-2.0.1\n - commons-lang-2.3\n - commons-logging-1.1.1\n - derbyclient (JDBC driver for the Derby database system)\n - wsif\n - wsif-j2c\n - xercesImpl\n- The following various libraries which are also licensed under the Apache License (http://www.apache.org/licenses/LICENSE-2.0):\n - ehcache-1.5.0 (Database caching and scalability)\n- The following libraries from the Oracle Technology Framework, all of which are licensed under the general Java licenses which can be found at www.oracle.com/technetwork/java:\n - The JavaBeans Activation Framework v1.1.1\n - JavaServer Faces Technology v1.2\n• The following libraries from the Legion of the Bouncy Castle, licensed under an adaptation of the MIT X11 license which can be found at bouncycastle.org/licence.html:\n – bcprov\n – bcmail\n\n• The following various libraries, licensed under the Lesser General Public License (LGPL) at www.gnu.org/licenses/lgpl.html:\n – c3p0 (JDBC DataSource connection and statement pooling)\n\n• The following various libraries, licensed under the BSD License (BSD) a sample of which can be found at www.opensource.org/licenses/bsd-license.php:\n – dom4j-1.6.1 (XML, XPath and XSLT support)\n\n• The following various libraries, licensed under the Mozilla Public License (MPL) a sample of which can be found at www.mozilla.org/MPL:\n –\n\n• Hibernate Relational Persistence Framework. License http://www.hibernate.org/license\n\n• The Saxon version 7 XSLT Processor from Michael Kay (http://saxon.sourceforge.net). This software is subject to the Mozilla Public License Version 1.0 and may not be used except in compliance with that License (a copy is available at www.mozilla.org/MPL). The source code version of this software is available under the terms of that license.\n\n\n• Antlr 2.7.6 by Terence Parr www.antlr.org License: http://www.antlr.org/license.html\n\n to be completed…\nAppendix B\n\nnewYAWL Resource Perspective\nRequirements Analysis\n\nThis chapter describes the design requirements for the YAWL 2.0 environment as regards comprehensive support for the resource perspective, that were derived from the newYAWL technical report [16], and Nick Russell’s PhD thesis [17].\n\nEach of these requirements has been implemented in the YAWL Resource Service and Editor. This analysis is included in this manual for historical reasons, and for consideration of some of the design decisions taken in the development of the Resource Service and relevant extension to the Editor.\n\nB.1 Introduction\n\nThere are three key perspectives to workflow. Namely control-flow, data, and resourcing, representing the sequencing in which work needs to be done, the data needed to do work, and the participants needed to do that work respectively. The three perspectives each provide a view into the same underlying integrated, and ultimately inseparable whole of a workflow system.\n\nThe newYAWL technical report has identified that the resource perspective is loosely coupled to the control-flow and data perspectives (which themselves are necessarily tightly coupled). Because i) the resource perspective is so loosely coupled, and ii) the resource perspective is currently the weakest of the three perspectives of YAWL, this requirements analysis will be limited in scope to just the proposed resource perspective changes described in the newYAWL technical report. Increased support for the other two perspectives will be considered at some later stage.\n\nThrough the preparation of this analysis, it has become clear that the resource perspective changes could be handled in a two-phase approach. A number of requirements can be identified as core. They must be in place initially. The remaining requirements identified need these core requirements to be in place before they themselves can be implemented. We are therefore capable of building the resource perspective of newYAWL in at least two phases, which will go by the working titles of “core” and “non-core”. Later in this document, the requirements will be allocated one of these two designations.\n\nNote that the newYAWL technical report and its petri-nets capture key concurrency concerns between the system, and the participants and administrators. The technical report is to be viewed as the final authority on the system to be constructed. This document describes the behaviour required in natural language, which necessarily results in some loss of accuracy. Readers should view this document as an introduction to ease them into understanding the requirements which are ultimately encoded within the petri-nets of the technical report.\nB.2 Requirements\n\nThis section forms the heart of the requirements analysis. To aid in streamlining software construction from this document, the requirements have been grouped into subsections, representing major existing components of YAWL. Section B.2.1 contains requirements specific to a workflow designer component. Section B.2.2 contains requirements specific to a YAWL engine component.\n\nWhen new requirements are introduced, they take the following generic form comprised of three parts. Firstly, a requirement reference code of the form \\texttt{REQ-###}. Secondly, a short text description in italics, and finally, a deeper discussion of the requirement is supplied in the paragraph immediately following. Below is an example:\n\n\\begin{center}\n\\texttt{REQ-000} : This is an example requirement comprised of a reference code and description\n\\end{center}\n\nFollowing each requirement is a detailed discussion of the motivations that go into forming the requirement.\n\nThe requirements identified in this document are to ensure that participants interact with the work items offered by YAWL as intended by the newYAWL technical report. The requirements are described in an implementation independent manner, allowing differing implementations of YAWL to support the requirements identified as best suits each implementation.\n\nEach requirement is classified as either \\textit{core} or \\textit{non-core}. The distinction can be rather arbitrary at times. The guiding heuristic for deciding whether a requirement is core or not is whether the requirement supplies necessary support for the concept of \\textit{interaction points} and their ability to be system or user initiated, described later. Non-core requirements can take advantage of this concept but do not necessarily add to the fundamental behaviour of interaction points. At times, this rule has been broken if it was felt by the author that classifying a requirement as non-core would make a system, constructed to only core requirements too limiting to its users.\n\nB.2.1 Workflow Designer Requirements\n\nIn YAWL, \\textit{atomic tasks} and \\textit{multiple-atomic tasks} both represent potential interaction points with workflow participants. If these tasks are allocated a “worklist handler decomposition” at design-time, runtime-instances of these tasks will cause the appropriate worklist handler to offer participants work items where they can receive work data and check new data back into the workflow system. For atomic tasks, there is one work item per task instance. For multiple-atomic tasks, there are a number of work items per multiple-atomic task instance.\n\nA graphical summary of requirements for a YAWL design tool supporting the newYAWL resource perspective is supplied in figure B.1. The requirements are laid out in a hierarchical mind-map. Colour coding is used to isolate a group of requirements that could all belong to the same page of a wizard walk-through type screen that workflow designers could use to construct a complete resourcing definition for a task. If a group of one colour exists closer to the root of the tree, requirements from that group will be needed as prerequisites to requirement groups that appear further out. The requirements listed in figure B.1, along with related design-time requirements are described in further detail next.\n\n\\begin{center}\n\\texttt{REQ-001} : Decompositions are to identify whether they need resourcing.\n\\end{center}\n\nDecompositions describe how a particular task in a workflow must interact with its external environment. Part of the description is what data should be passed to the external environment and what should be received. Interactions with external automated systems to YAWL typically do not allow YAWL to make\nresourcing decisions (such as say, a Web Service invocation). Sometimes, a decision also needs to be made by YAWL on how and when external participants will interact with the work item(s) of a task. Decompositions therefore need to indicate whether they need resourcing decisions made at workflow design time.\n\nThere should always be a default work-list handler decomposition offered by YAWL that is identified as needing resourcing. All decompositions identifying automated external interaction will not need resourcing decisions. All decompositions identifying manual external interaction will need resourcing decisions.\n\nThis requirement is classified as core.\n\nREQ-002: Atomic and Multiple-Atomic Tasks with “resourcing required” decompositions will be allowed to specify necessary resourcing requirements.\n\nFor tasks with decompositions needing resourcing, workflow designers will be able to specify resourcing requirements for those tasks at design time. Note that a number of tasks can share the same decomposition. Each task will require resourcing decisions to be made, but each task may have a different resourcing choice made. The actual resourcing decision made by the designer will thus be per task, not per decomposition.\n\nAs the resourcing decision belongs to a particular task, that decision remains fixed across all work item(s) of a multiple-atomic task, and across all work items of a task that is within a loop. It will not be possible to specify resourcing per sub-instance of a multiple-atomic task, or for each particular iteration of an atomic task work item. However, as the resourcing decision must be re-evaluated upon each work item instantiation at runtime, it will be possible for the resourcing decision to result in a number of work items for a single multiple-atomic task to be spread across a number of participants, for example.\n\nAt a high level, the workflow designer needs to be able to describe whether either users or the system is responsible for resourcing at key interaction points. They will also need to occasionally dictate what runtime privileges a user will be granted for a task. At design time, a task with resourcing required will inherit a “global” resourcing decision default that the designer must override where appropriate.\n\nThis requirement is classified as core.\n\nREQ-003: For tasks requiring resourcing, workflow designers will be able to specify either system or user initiated behaviour for each of its Offer, Allocation, and Start interaction points.\n\nThree interaction points have been identified for where participants and the workflow system can make work-distribution choices. They are listed below in order of execution:\n\n**Offer:** A work item can be offered to a participant. This does not imply that the participant should undertake that work, merely that they could. A number of participants could be offered the same piece of work, for example.\n\n**Allocation:** Allocating a work item to a participant means that participant has been committed (willingly or not) to doing that work item some time in the future. This participant no longer could do the work, but rather should do it. The work item is withdrawn from the offered queues of other participants.\n\n**Start:** A work item goes from allocated to started once work has begun. The participant that once should have been doing the work has now started doing so.\n\nFor relevant tasks, workflow designers will be able to specify how each interaction point should be handled in a running workflow by choosing whether that interaction point will be system initiated or user initiated. System-initiated offers and allocations require further decisions to be made by the workflow designer to guide the running workflow system in its choices.\n\nThis requirement is classified as core.\n\nREQ-004: For tasks requiring resourcing, a workflow designer must be able grant or deny a number of user-task\nprivileges for the task’s work item(s).\n\nA workflow designer will be supplied a number of user-task runtime-privileges, that can be either enabled or disabled for the resourcing-required task. These privileges are so-named because they will only be enabled for a (user, task) combination. The privileges, and their runtime effect when enabled are described below:\n\n**Can Suspend:** When enabled, participants who’ve started work items of the task will be allowed to suspend the execution of the task.\n\n**Can Reallocate Stateless:** When enabled, participants who’ve started work items of the task will be allowed to reallocate the work items to other users. The process of re-allocation will revert the work item to an initial starting state.\n\n**Can Reallocate Stateful:** When enabled, participants who’ve started work items of the task will be allowed to reallocate those work items to other users. The process or re-allocation will preserve the current state of the work item.\n\n**Can Deallocate:** When enabled, participants allocated work items of the task will be allowed to de-allocate themselves from the work items, causing a reallocation of the work item.\n\n**Can Delegate:** When enabled, participants allocated work items of the task will be allowed to reallocate the work items to other users, so long as they have not yet been started.\n\n**Can Skip:** When enabled, participants allocated work items of the task will be allowed to skip (or finish without starting) the work item. Therefore, this privilege will only be grantable on tasks that supply default values for all of their output parameters.\n\n**Can Pile:** When enabled, a participant will be allowed to pile the execution of all work items of this task upon themselves. Instead of the workflow system building a distribution set of viable participants first, it will directly allocate and automatically start new work items for the task against the relevant participant.\n\nTo avoid a combinatorial explosion within a running engine in relation to setting individual permissions against combinations of users and tasks, we also need a switch per enabled-privilege. The switch will indicate whether all users that are allocated the task are granted the privilege by default or not. An administrator will still be free to override the default, but we expect the default to cover the desired behaviour of most users involved in the given workflow.\n\nThe privileges discussed above can be viewed as non-core. Administrative functions described later will be capable of the short-circuiting of work items through to alternate worklist states, which can act as a workaround until such time as non-core requirements can be constructed for many of the privileges here. This will place extra burden on administrators until such the non-core requirements are constructed. Those privileges that have no administrative fall-back behaviour do not contribute to supporting interaction point behaviour, but will result in the loss of some pattern support.\n\n**REQ-005:** To support the Can Skip user-task privilege, tasks will be able to specify default values for their output parameters.\n\nThe workflow designer will be allowed to specify an optional static value for any of its output parameters. If the designer chooses optional, they will also be asked by the design tool to supply a static “default” value for the optional parameter. This optional value will be used to create “completed” data when the work item is automatically completed upon a user-request to skip that work item. Note that all of a task’s output parameters must have optional values specified in order for it to be validly skipped at runtime.\nThis requirement is classified as non-core.\n\nREQ-006: For tasks requiring resourcing, a default decision of user offer, user allocation, user start, will apply for a task's interaction points. No privileges will be granted by default.\n\nAll tasks that require resourcing need a default resourcing decision that a task inherits initially, and that a workflow designer can choose to override as necessary. Defaulting is required for interaction points and runtime privileges.\n\nFor the three interaction points described earlier, the default will be user for each interaction point. This will result in all decisions on resourcing to be manually handled at runtime within a YAWL engine. For the user-task privileges, all privileges will default to being disabled, giving users minimal freedom in their ability to manipulate work items of the task at runtime.\n\nThis requirement is classified as core.\n\nREQ-007: Workflow designer to specify how a System-Initiated Offer will choose participants.\n\nWhen the workflow designer identifies that offers should be system-initiated (regardless of what choices they make for the allocation and starting points), the workflow designer will also be required to specify a distribution strategy for the offer, with ultimately tells the running workflow system how to generate a list of participants to which a work item should be offered.\n\nInitially this will involve having the design tool ask the workflow designer to specifying a number of task routing strategies, and optionally, to specify whether the workflow system will retain a “familiar participant” for allocating a work item to. Both options are described in a number of requirements that follow.\n\nThis requirement is classified as core.\n\nREQ-008: Workflow Designer to be able to specify task routing strategies for a resourcing-required task\n\nWhen a workflow designer has chosen to specify task routing strategies after having specified that offers are to be system-initiated, the design tool will require the following sequence of steps to be followed by the workflow designer:\n\n1. Specification of a base distribution set,\n2. Specification of filters for the base distribution set using organisation, capability and historical data,\n3. Specification of a number of runtime constraints for this filtered distribution set.\n\nEach step is further described in requirements that follow.\n\nThis requirement is classified as core.\n\nREQ-009: Workflow Designer to be able to specify a base distribution set of participants.\n\nA workflow designer begins building a task routing strategy by defining a base distribution set of participants. The designer will be able to do this by selecting participants through a number of mechanisms. The set of participants represented by these selections will be used at runtime to generate a base distribution set of participants to whom work items of the relevant task will be offered. The three mechanisms defined for adding participants to this base distribution set are:\n\n- choose zero or more of the participants registered as users to the workflow system,\n- choose zero or more of the roles defined by the workflow system,\n• choose zero or more of the input parameters to the relevant task, and specify for each of these parameters whether the value of the parameter will contain a set of participants, or a set of roles at runtime.\n\nThis requirement needs the workflow designer and engine to communicate, where the engine supplies a full set of participants, and a full set of roles to the workflow designer. For reasons more fully in the following requirement, the identification of roles and participants must be done in a data storage independent manner to allow a range of technologies to pass resourcing data between the workflow engine and the design tool. This requirement is classified as core.\n\nREQ-010: Workflow Designer to be able to specify filters for a base distribution set of participants using organisation, capability and historical data.\n\nOnce a workflow designer has defined a base distribution set of participants, they can then specify a number of filters that are to apply to the participant set. Three different categories of filter have been defined below:\n\n• Organisation Filter\n• Capability Filter\n• History Filter\n\nAt runtime, all categories of filter will have access to the base distribution set of participants, plus any extra data relevant to their category (detail of which is described in the newYAWL technical report). Regardless of category, the filters constructed will generate a subset of the base distribution set of participants. Only those participants of the base distribution set that are valid members within all of the filters chosen will be included within the filtered distribution set of participants.\n\nThe workflow designer will be offered all filters registered with a running YAWL engine. They may then choose to enable a number of these filters, and supply data for whatever parameters each filter requires to enact its algorithm at runtime within the engine.\n\nThis requirement needs the design tool and engine to communicate, where the engine supplies a the design tool the full set of filters and necessary parameters. It also requires the engine specification to be flexible enough to identify a filter and the parameters values for it. Filters are to be built as plugins into a running engine, and cannot thus be hard-coded into a workflow specification.\n\nInitially, one filter per category will be constructed to offer a “typical” simple filter for a category. These filters will be backed by a relational database that the filters will query. However, We expect alternate filters may need to draw their resourcing data from alternate technologies to relational databases. LDAP servers are often quoted as a typical example.\n\nNote that the backing technology used to house the data needed for these filters will also be the same technology that stores participants and roles. The engine processing that reports participant and role lists to the workflow designer should allow for alternate technologies to relational databases to supply this data, but will be released initially with participants and roles being stored within a default relational database that comes with the engine. It is expected that a particular data storage technology will require its own resourcing plugin to a YAWL engine, and at the very least must offer the ability to retrieve all participants and roles registered within its data storage technology.\n\nAn alternative to the above approach would be to construct a language, catering a large range of possible filtering strategies. The design and implementation of such a language with no clear understanding typical or desired filters is considered to be a poor investment of programming effort at this stage.\n\nThis requirement is classified as non-core. A rudimentary degree of filtering can be achieved by allocating participants to rolls that encode simple organisation or capability detail. It should be noted, however that full pattern support for organisation, capability and history based patterns cannot be claimed until this requirement is implemented.\n\nREQ-011: Workflow Designer to be able to specify of a number of runtime constraints for this filtered distribution\nA workflow designer needs to be able to define two runtime constraints for a filtered distribution set. One constraint, separation of duties, must be enforced on a filtered base distribution set of participants. The other, piled execution, allows the filtered distribution set to be ignored under certain circumstances at runtime. Both runtime constraints are boolean. However, separation of duties also requires a “familiar task” to be chosen whenever it is active. The constraints, and the effect they may exhibit at runtime, are described below:\n\n**Retain Familiar**: When this constraint is enabled, it must also have a “familiar task” chosen to be compared against. This constraint attempts to ensure that at run-time, the last participant that completed a work item of this familiar task within the same process instance will be also allocated work items spawned off the relevant resource-requiring task.\n\n**Separation of Duties**: When this constraint is enabled, it must also have a “familiar task” chosen to be compared against. This constraint ensures that the filtered distribution set will not include any participant who completed work item(s) of the “familiar task” in the current case.\n\n**Piled Execution**: Enabling this constraint will allow a participant to choose at runtime for the task, to receive all work items for the task across all cases of the workflow specification, thereby overriding the distribution set of participants specified for that task. Note that at run-time only one user can be piling the execution of a task’s work items at any one time.\n\nFor the *retain familiar* constraint, The relevant “familiar participant work item” must also have completed before the resourcing required work item for this runtime constraint to be enacted. Thus, only resourcing-required tasks within the that lie on a backward path to the starting net’s input condition from the resource-requiring task will be selectable as the familiar participant task at design time. This rule also holds for separation of duties familiar tasks.\n\nFor the constraints requiring familiar tasks, note that concurrency could still result in the specified familiar task not having a completed work item being ready for determining the familiar participant. In such circumstances, the engine should fall back to typical behaviour where it generates a distribution set of participants to offer the work-item to.\n\nThe separation of duties and retain familiar constraints are to be considered core. The piled execution is to be considered non-core. Piled execution is an alternative to the interaction point behaviour described to date. Its exclusion will deny pattern support, but it can be added into a system once the base interaction point behaviour has been established.\n\n**REQ-012**: Workflow designer to choose System-Initiated Allocation mechanism.\n\nIf the set of participants offered a work item contains only a single participant, the running workflow system does not need to choose between alternatives, and may allocate the work item directly when system-initiated allocation is being used. However, no guarantee can be made at design-time that an offer will be limited to a single participant at runtime. A design-time choice needs to be made to tell the YAWL system how it must choose a single participant from a number of possible alternatives for allocation. Ultimately, so long as an algorithm takes a participant set, and returns only one of those participants, it could be considered a valid automated allocation mechanism.\n\nInitially, three mechanisms will be constructed. A workflow designer may chose from these three mechanisms:\n\n**Round-Robin**: From the identified participants, choose the one who recently completed a work item for the task. In the event that several users are recorded as being equally least-recent, choose one of these randomly.\n\n**Shortest-Queue**: From the identified participants, choose the one whose sum of allocated and started work item queue numbers is shortest. This will be used as the default choice.\nRandom: Choose a participant from the collection identified randomly.\n\nThe mechanisms will be registered with the workflow engine and communicated to the workflow designer when they come to choose an appropriate mechanism for system-initiated allocation. As new mechanisms are programmed and registered with a running engine, they will be subsequently made available to the workflow designer to choose from as well.\n\nThis requirement will need a workflow specification passed from the workflow designer to a newYAWL engine to be sufficiently flexible to allow new mechanisms to be identified within the workflow specification without requiring changes to the specification structure.\n\nThis requirement is classified as core.\n\n**REQ-013**: Resourcing Decisions made must be encoded within the task definition of a YAWL specification.\n\nThe specification generated by a workflow design tool for consumption by a newYAWL resourcing-enabled system must encode the resourcing-required choices made by a workflow designer that have been described in this section. The requirements listed below require special effort to ensure that as new options are made available by an engine for key decisions, the specification does not require structural changes in order to have them identified:\n\n- Workflow Designer to be able to specify filters for a base distribution set of participants using organisation, capability and historical data.\n- Workflow designer to choose System-Initiated Allocation mechanism.\n\nThis requirement is classified as core only so-far as it encodes other core requirements described to date for enactment within a newYAWL resourcing-enabled system.\n\n### B.2.2 Workflow System Requirements\n\nOne of the quintessential elements of a YAWL workflow is the work item, representing a piece of work that an external participant must do in order to progress a workflow. It is through a work item that an external participant and the workflow system must interact. Work items are offered to a participant via the participant’s view into a worklist handler component. Besides the many and varied ways of classifying users of a newYAWL system that have been identified earlier, users can also act as administrators to YAWL. Administrators have an extra responsibility of manually coordinating the placement of work with participants where appropriate.\n\nWe therefore have two basic workflow system roles that users may play in newYAWL, participants and administrators. A workflow system role is not to be confused with organisation roles described earlier. What role(s) a user plays within an organisation matters only so far as they can be used by the workflow system to short-list possible participants that may do a work item. Anybody who does work through YAWL plays the workflow system role of participant, regardless of how they are shortlisted for being offered work items to, be that through an organisational role, or some other mechanism.\n\nFigure B.2 is a mind-map showing a hierarchical view of screens that must be supported to allow both administrators and participants to interact with YAWL in order to support the resource perspective changes of the newYAWL technical report. The requirements that describe user interfacing have also been marked where appropriate.\n\nThis section is broken into three sub-sections. Section B.2.2 describes requirements for YAWL workflow administrators. Section B.2.2 describes requirements for participants doing non-administration duties via the worklist handler. Finally, section B.2.2 describes automated requirements that are independent of those described in the previous sections.\nAdministration Requirements\n\nThis section describes requirements for user interfacing that administrators will need to support the resource perspective of newYAWL.\n\n**REQ-014**: YAWL Administrator to be able to manage user privileges\n\nYAWL administrators will be supplied functionality to select a number of workflow participants and change their user privileges. The default setting for all privileges is to be disabled. The following privileges, when enabled for a participant, will apply across all cases that the participant can be involved in:\n\n**Can Choose Work Item to Start**: When enabled, this privilege allows a participant to choose which work item in their allocated queue they will be allowed to start. When this privilege is disabled, the participant will not be able to select which work item to start. Instead, the work item at the top of the allocated queue of the participant will be started when the participant triggers a start action.\n\n**Can Start Concurrent Work Items**: When enabled, this privilege allows the participant to place new work items in their started queue before they complete existing work items. Note that this does not stop an administrator or the system from placing extra work items on a user’s started queue when they already have started work items. When disabled, a participant will only be able to add a work item to their started queue when the queue is empty.\n\n**Can Reorder Work Items**: When enabled, this privilege allows the participant to reorder the work items in their allocated queue. When disabled, the work items will be added to the end of the queue, meaning that the longer a work item has remained in the allocated queue, the higher to the top of the queue it will be.\n\n**Can View All Offered Work Items**: When enabled, this privilege allows the participant to view the offered queues of all other workflow participants.\n\n**Can View All Allocated Work Items**: When enabled, this privilege allows the participant to view the allocated queues of all other workflow participants.\n\n**Can View All Executing Work Items**: When enabled, this privilege allows the participant to view the started and suspended queues of all other workflow participants.\nCan Chain Work Item Execution: When enabled, this privilege allows the participant chain a number work items together so that a new task in the sequence of work will be allocated to them and automatically started.\n\nThere is some argument that all of the above user privileges should be viewed as non-core, given that they are all dependent on the concept of interaction point behaviour, but do not add to that behaviour. However, the top three privileges are viewed by the author as being highly desirable ways of toggling a particular participant’s way of working that we could reasonably expect to be desired by workflow systems. Therefore, the top three requirements are to be considered core, and the remaining “view all” privileges as non-core.\n\nREQ-015: YAWL Administrator to be able to override default user-task privileges\n\nUser-task privileges are initially configured through settings supplied in the workflow specification as described by a workflow designer. However, an administrator may be required to vary user-task privileges away from the defaults set in the workflow specification.\n\nAdministrators will be supplied a user-task privilege maintenance screen. The aid in navigating a large number of possible tasks, A tree hierarchy of specifications will be supplied. Each specification lodged with the workflow system will be listed and will be openable to reveal individual nets. Each of these nets can be further opened to show all tasks within that net that have resourcing requirements. These tasks can then be further opened to show each user-task privilege, along with the default setting for the privilege. The privilege can then be further opened to reveal a list of participants that explicitly go against the default setting. The administrator will then be allowed to add or remove users from this list as necessary.\n\nThis requirement is classified as non-core.\n\nREQ-016: YAWL Administrator to be allowed management intervention via an Unoffered queue and a Worklisted queue\n\nYAWL Administrators will require a management intervention screen for managing work items in various states of their lifecycle. From the perspective of a YAWL Administrator, work items are either Unoffered, or they are one of the worklist states described later (Offered, Allocated, Started or Suspended). Given the fundamentally different nature of the actions that can be performed between unoffered work items and those that have begun appearing on the worklists of participants, the management intervention screen will separate work items into two separate queues. One queue will contain all Unoffered work items. The other will contain the remaining worklisted work items.\n\nThe actions that can be applied to both queues are described in the succeeding requirements. The petri-net for management intervention is figure 33 of the newYAWL technical report.\n\nThis requirement is classified as core.\n\nREQ-017: YAWL Administrator to be able to enact administrator-initiated offers, allocations and starting of Unoffered work items in the management intervention screen\n\nThose work items whose resource-requirements indicate user-initiated offers, or that have failed to be successfully distributed to a set of participants will appear on the Administrator management intervention screen with a status of Unallocated. The administrator must be able to select a number of these work items and for them, specify a number of participants. Once the participants have been identified, the administrator will be able to enact one of three possible actions on the work item selected:\n\nOffer: Selecting this action will result in the relevant work item being offered to the selected users. In this manner, user-initiated offers are implemented.\n\nAllocate: This action will only be possible when a single participant has been selected. Enacting this action will directly allocate all selected work items to the chosen participant.\nStart: This action will only be possible when a single participant has been selected. Enacting this action will directly allocate all selected work items to the participant and automatically place the work items on the participant’s started queue.\n\nThis requirement is classified as core.\n\nREQ-018 : YAWL Administrator to be able to escalate worklisted work items from the management interventions screen\n\nThe worklisted queue of the management intervention screen will display, by default, all work items that are offered, allocated, started and suspended. To ease the administrative burden of locating desired work items from a potentially very large list, the administrator’s screen will initially display all work items currently worklisted, along with whoever has been assigned the work item, and the work item’s current state. They may then choose to filter the work items on a per-participant basis, and a per-status basis. When an administrator chooses both a participant, and a status, the filter will show only those work items of the required state that have been assigned to to the selected participant.\n\nFrom the queue, the administrator will be able to escalated a number of selected work items to a potentially different set of participants. They will be able to select a number of work items, as well as a number of participants that they may then enact one of the following actions upon:\n\nEscalate Offered, Allocated, Started or Suspended to Offered: All selected work items will be withdrawn from the offered, allocated started and suspended queues that they were initially assigned to. The work items will then be added to the offered queues of the newly selected participants. Started and suspended work items will have their state reset to an initial state.\n\nEscalate Allocated, Started or Suspended to Allocated: This action will only be possible when a single participant has been selected. All selected work items will be withdrawn from the worklists of the participant to whom the work items were assigned. The work items will then be added to the allocated queue of the new participant. Started and suspended work items will have their state reset to an initial state.\n\nEscalate Started to Started: This action will only be possible when a single participant has been selected. All selected work items will be withdrawn from the started or suspended queues of the participants to whom the work item was assigned. The work items will then be added to the started queue of the selected participant, preserving state in the transfer. *Not currently in report.*\n\nThis requirement is classified as core.\n\nWork List Handler Requirements\n\nA participant’s worklist handler is their interface into the various work items that they must interact with in order to contribute to the execution of an overall workflow instance, or case. Where a work item sits within the worklist of participants depends ultimately on the state of the work item. Figure B.3 is a UML Statechart of the lifecycle of the newYAWL work item. Figure B.4 informally describes each state that appears in figure B.3. Note that the state chart does not cover all possible state transitions. It’s primary focus is to describe how the work item changes from the perspective of workflow participants.\n\nTransitions between states in figure B.3 take a general form of “number. transition name”, referring the figure number in the newYAWL technical report and the actual petri-net transition within that figure that causes a work item state change. One thing that immediately becomes obvious is that a work item can only go through a small number of possible states in its lifecycle, but there are many possible valid transitions between those states.\nFigure B.3: Work-Item State Chart\n<table>\n<thead>\n<tr>\n<th>State</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Initial state</td>\n<td>The work item exists, but has not yet had a possible set of participants identified to be distributed to.</td>\n</tr>\n<tr>\n<td>Distributed</td>\n<td>A distribution set of possible workers exists for the work item.</td>\n</tr>\n<tr>\n<td>Offered</td>\n<td>The distribution set of possible participants have been offered the work item to do.</td>\n</tr>\n<tr>\n<td>Allocated</td>\n<td>One of the possible participants that could do the work item’s work has been allocated the work to do.</td>\n</tr>\n<tr>\n<td>Started</td>\n<td>A participant, previously allocated a work item, has begun its work.</td>\n</tr>\n<tr>\n<td>Suspended</td>\n<td>A participant has suspended a work item they started earlier.</td>\n</tr>\n<tr>\n<td>Final state</td>\n<td>The work item is complete.</td>\n</tr>\n</tbody>\n</table>\n\nFigure B.4: State for the Work-Item State Chart\n\nThe requirements in this section spell out how a work list handler for newYAWL must interact with participants in managing work items that participants may work on.\n\n**REQ-019**: Participants are to have login and preferences screens that support specifying chained and piled execution\n\nUpon login, participants will be offered a typical username and password interface. At this time, participants will also be able to toggle whether they wish to pile execution for those tasks have they have been granted the Can Pile privilege. Only one logged-in participant may pile the execution of a task’s work items. Only those tasks that do not have a logged-in participant piling their work items will be offered to the participant for toggling the piling of. The default for the toggle shall be to not pile execution.\n\nIf the participant has also been granted the Can Chain Work Item Execution privilege by an administrator, the login screen will also allow the participant to toggle whether they wish to chain execution of work items. The default for the toggle shall be to not chain execution.\n\nA preferences screen should also be provided to the logged in user, allowing them at any stage whilst they are logged in to toggle these execution mode preferences.\n\nThe petri-net for participant login is figure 71 of the newYAWL technical report.\n\nA participant login screen is considered core. However, this requirement is classified as non-core in that chaining and piling are not core requirements.\n\n**REQ-020**: Participants are to be offered separate queues on their work list handler for work items that are within the states of Offered, Allocated and Started.\n\nLooking at figure B.3, we see that typical workflow participants can only interact with work items when the work items are in the states of Offered, Allocated, Started and Suspended. Collectively, we label these states the worklist states, indicating that whilst within one of these states, participants may interact with a work item in certain ways. Each of these states dictate a limited number of valid interactions that the participant may perform whilst a work item is in a particular state. Interactions per state are described in later requirements.\n\nParticipants will be offered a worklist handler interface that clearly separates work items into their respective states. For screen real-estate concerns, it does not seem necessary for all queues to be visible to the participant simultaneously. A tabbed interface may be most appropriate. However, a special case may be that of the Started and Suspended queues. There is some interface pressure for these two queues to appear on the same screen. It is expected that the state of both the started and suspended work item queues for a user will influence which suspended work they should resume once the participant completes a work item.\n\nA word of warning is offered here on web-based interfaces supporting this requirement. Web-technologies assume a client-pull model (the participant asks the sever for work updates with an explicit screen refresh action made by the participant). It is possible to construct a server-push interaction where the workflow system pushes new or updated work items out to a participant’s web browser, but this requires the use of\nAJAX technologies, which are immature at the time of writing this document, and likely to consume a significant amount of effort to get working across the most popular Web browsers. Client-pull will involve less programming effort, but will not be as user-friendly as server-push.\n\nThis requirement is classified as core.\n\nREQ-021: Workflow Participant to be able to enact self-allocation from their Offered queue, as well as view all offered work items when appropriate.\n\nFor those work items whose resourcing requirements indicate user-initiated allocation, the participant must have a mechanism for self-allocating work items that appear in their offered work item queue. The participant will be able to select a number of the work items on this queue and enact an allocate action upon them.\n\nFor each of the work items that the participant allocates in this manner, if a work item is also user-initiated start, the action will move the work item from their offered queue to their allocated queue and withdraw the work item from the offered queues of other participants. If the work item is instead flagged for system-initiated start, the action will move the work item from the participant’s offered queue directly to their started queue and withdraw the work item from the offered queues of other participants.\n\nThe petri-net requirement for doing this user-initiated allocation is described in the process selection request transition in figure 46 of the newYAWL technical report.\n\nIf the participant has the Can View All Offered Work Items privilege set, the participant will also be supplied a toggling mechanism, allowing them to view (but not otherwise manipulate) all other offered work items in the entire system. So as not to interfere with their own offered work items, these other offered work items will appear in a visually distinct queue on the same screen as the participant’s own offered work items. An indicative screenshot of this requirement is supplied in figure B.5.\n\nThis requirement is classified as core. However, the ability to view all other work items of the same state is non-core.\n\nREQ-022: Workflow Participant to be able to enact self-start, delegation, self-deallocation and toggle viewing all work items from the Allocated queue when appropriate.\n\nFor those work items whose resource-requirements indicate user-initiated start, the participant will have a number of allocated work items available to start. A start action will be made available to allow the participant to move a work item from their allocated queue to their started queue.\n\nUnless the user privilege Can Start Concurrent Work Items is enabled for a participant, they will not be able to activate the start action until their started work item queue is empty. If the user privilege Can Choose Work Item to Start is enabled, the participant will first need to select a work item to enact the start action upon. When this privilege is disabled, the top-most allocated work item will be started. The petri-net requirement for doing this user-initiated start is captured in the start transition in figure 48 of the newYAWL technical report.\n\nWith certain privileges enabled, participants may also be able select a work item from their allocated queue and enact one of the following actions:\n\nDelegate to another: If the combination of participant and work item has the Can Delegate privilege enabled, the participant may chose some other participant to delegate the work item to. The effect of this will be to move a work item from the allocated queue of this participant to the allocated queue of the delegate. Note that only those participants that may be validly offered this work item (i.e., those listed in the distribution set of the work item’s task) will be offered as possible delegates. The petri-net transition for this is named route delegation in figure 51 of the newYAWL technical report.\n\nDeallocate themselves: If the combination of participant and work item has the Can Deallocate privilege enabled, the participant may chose to deallocate themselves from the work item. The effect of this will be to remove the work item from this queue, and place it on the unallocated queue of the admin-\nFigure B.5: A possible offered queue implementation interface\n\nReorder work item: If the participant has the Can Reorder Work Items privilege set, the participant will be allowed to select a work item in the allocated queue and move that work item up or down in their work queue. Work items closer to the top of the queue are expected to be started before work items further down in the queue, which is especially true when the Can Choose Work Item to Start privilege is disabled for the combination of participant and work item.\n\nSkip a work item: If the combination of participant and work item has the Can Skip runtime privilege enabled, they will be allowed to select a work item from the allocated queue and skip it, automatically completing that work item, using default values of data that the work item must output to subsequent work in the case.\n\nToggle view all work items: If the participant has the Can View All Allocated Work Items privilege set, the participant will be supplied a toggling mechanism, allowing them to view (but not otherwise manipulate) all other allocated work items in the entire system. So as not to interfere with their own allocated work items, these other allocated work items will appear in a visually distinct queue on the same screen as the participant’s own allocated work items.\n\nAn indicative screenshot of this requirement is supplied in figure B.6.\n\nThis requirement is classified as core. However, most of the actions listed that are driven off privileges are\nto be considered non-core, except Reorder work item which is core.\n\nREQ-023: Workflow Participant to be able to enact stateful reallocation, stateless reallocation, suspension, completion and viewing all started work items from the Started queue.\n\nParticipants will be able to select a work item from their started queue, and apply one of the following actions (some of which may only be made available when appropriate privileges are granted):\n\n**Stateful Reallocation:** If the combination of participant and work item has the Can Reallocate Stateful privilege enabled, the participant may choose some other participant to reallocate the work item to. The effect of this will be to move a work item, in its current state, to the started queue of the selected participant. The petri-net transition for this is named process stateful reallocation in figure 53 of the newYAWL technical report.\n\n**Stateless Reallocation:** If the combination of participant and work item has the Can Reallocate Stateless privilege enabled, the participant may choose some other participant to reallocate the work item to. The effect of this will be to reset a work item to its initial state, and move it to the started queue of the selected participant. The petri-net transition for this is named process stateless reallocation in figure 53 of the newYAWL technical report.\n\n**Suspend:** If the combination of participant and work item has the Can Suspend privilege enabled, the participant may choose to suspend the work item. The effect of this will be to move the work item from the started queue to the suspended queue of the participant. The petri-net transition for this is named suspend in figure 49 of the newYAWL technical report.\n**Complete:** When a participant chooses to complete a work item, it will be removed from the started queue of the participant, and its state used to complete the work item, progressing the overall workflow as dictated by the specification of the workflow. The petri-net transition for this is named `complete` in figure 50 of the newYAWL technical report.\n\n**Toggle view all work items:** If the participant has the Can View All Executing Work Items privilege set, the participant will be supplied a toggling mechanism, allowing them to view (but not otherwise manipulate) all other started and suspended work items in the entire system. So as not to interfere with their own started and suspended work items, these other work items will appear in a visually distinct queue on the same screen as the participant’s own started and suspended work items.\n\nParticipants will also be able to open a number of their started work items and work on (edit) their state individually. The actions described above will also be made available to the participant whenever they are working with an individual work item. When the suspend action is chosen, the individual work item screen will become read-only and will only behave as described below.\n\nAn indicative screenshot of this requirement is supplied in figure B.7.\n\n\n\nThis requirement is classified as core. The actions listed above except Suspend and Complete are to be considered non-core.\n\n**REQ-024:** Workflow Participant to be able to enact work item resumption from the Suspended queue.\n\nParticipants will be able to select a a work item from their suspended queue, and apply a resume action to that work item. If the participant does not have their Can Start Concurrent Work Items privilege enabled,\nthey may not resume the work item until their started queue is empty. The effect of applying the resume action will be to move the work item from the suspended queue to the started queue of the participant. The petri-net transition for this is named \\textit{resume} in figure 49 of the newYAWL technical report.\n\nParticipants will also be able open a number of the suspended work items to view individually in a read-only capacity. The resume action will also be made available to the participant as they view the work item. Choosing the resume action from this individual work item screen will also activate relevant actions that can be applied to work items in the started queue. Of course, this will also have the effect of the participant no longer being able to resume the work item without suspending it again first.\n\nThis requirement is classified as \\textit{core}.\n\n\\\\textbf{Automated Workflow Requirements}\n\nThis section describes the automated requirements of a resource perspective for YAWL that matches the newYAWL technical report.\n\n\\\\textbf{REQ-025 : System to support automatically piling work items for a particular task to the relevant participant}\n\nWork items for a particular task can be piled onto a single participant, meaning that all work items spawned for a task across all running cases of a workflow specification of that task will be directly allocated to and automatically started for a single logged-in workflow participant. A number of pre-requisites must exist before the system can pile work items to the participant in this manner:\n\n- Design-time enablement of the \\textbf{Can Pile} privilege for the participant and task.\n- A logged in participant who has indicated that they wish to pile all work items for the selected task to themselves, disallowing any other participant from piling work items of the selected task until they either log off, or indicate that they no longer wish to pile work for the task whilst still being logged in.\n- Run-time enablement of the \\textbf{Can Pile} either through design-time defaulting of enablement for the relevant participant or through explicit enablement by an administrator.\n\nIf it is possible for the work item distribution component to pile a work item, it will do so, before it attempts to chain work items, and before it attempts to follow resourcing directives on offering or allocating the work item described at design time. Note that a user logging out will ensure that work will stop being piled to them.\n\nThis requirement is classified as \\textit{non-core}.\n\n\\textit{Check models for what happens when the participant logs out as the piling is being evaluated.}\n\n\\\\textbf{REQ-026 : System to support automatically chaining work items to a relevant participant}\n\nFor a participant to chain work items, they must have the privilege \\textbf{Can Chain Work Item Execution} enabled, and have signaled at logon that they wish to chain the execution of work items. The chaining of work items is the subsequent automatic allocation and starting of work items once the participant finishes some work item. The work item distribution component will need to evaluate the distribution set of possible participants it could have offered new work items to. Should the chaining enabled participant appear in this distribution set, they will be automatically allocated and triggered as having started the new work item. If chaining is not possible for the participant, the work distribution component will default back to offering a new work item to participants in this distribution set.\n\nNote that there is the potential for some subtle unintended side effects in the control flow perspective with a very free applicability of chaining. For example, were we to allow deferred choice through a condition through to two subsequent tasks, one of which does not included the chaining participant, but other does, we have effectively short-circuited workflow, stopping the deferred choice from occurring. Other problems\ncan be described for multiple-instance tasks starting a chain, the last atomic task(s) within a completing net starting a chain, and even splits off a chain beginning task.\n\nTo avoid the above problems, chaining will only be allowed in three basic scenarios:\n\n1. Where one atomic task directly follows another non-branching atomic or multiple-atomic task in a sequence, and the subsequent task is capable of being offered to the chaining participant.\n\n2. Where several atomic tasks follows an atomic or multiple-atomic task with a split, and all of the subsequent tasks attached to the split have exactly the same distribution set definition as the split-task.\n\n3. Where several atomic tasks follows a non-split atomic or multiple-atomic task, through a deferred choice condition. All outgoing branches of the condition must be to an atomic task that has exactly the same distribution set definition as the split-task.\n\nThis requirement is classified as non-core.\n\nCheck models for what happens when the participant logs out as the chaining is being evaluated.\n\nREQ-027: System to support automatically offering work items to relevant participants\n\nWhen the resourcing requirements of a task indicates that its work items must be offered via system-initiated offer, the work distribution component must automatically calculate a distribution set of participants as per the workflow specification, and possibly offer a new work item to the final members of this distribution set.\n\nAs mentioned above, piling and chaining of execution will be attempted first. Should a participant be found via either the piling or chaining mechanism to allocate work to, automated distribution set calculation will not be necessary.\n\nIf automated offering is required, as per the specification discussion in section B.2.1, a base distribution set must be built, filtered with the selected filter algorithms, and finally modified to remove participant(s) who last completed a work item of a selected “familiar task” in the same workflow instance if the Separation of Duties runtime constraint is active.\n\nIn the event that the calculated distribution set is empty (there is nobody to offer the work item to), the work item will be placed on the Unoffered queue of workflow administrator(s) for subsequent processing.\n\nIf the task has resourcing requirements of user-initiated allocation at this point, the work item will appear on the offered queues of all distribution set participant’s worklist handlers. If the task has resourcing requirements of system-initiated allocation, the work item will not appear on any offered queues, but will be subject to the requirement below.\n\nThis requirement is classified as core.\n\nREQ-028: System to support automatically allocating work items to relevant participants\n\nFor those work items whose resource-requirements indicate system-initiated allocation, the work distribution must use the algorithm specified by the workflow designer to automatically choose a single participant from a distribution set of participants, and automatically allocate the work item to that participant.\n\nIf the task has resourcing requirements of user-initiated start at this point, the work item will appear on the allocated queue of the chosen participant’s worklist handler. If the task has resourcing requirements of system-initiated start, the work item will not appear on their allocated queue, but will be subject to the requirement below.\n\nThis requirement is classified as core.\n\nREQ-029: System to support automatically starting work items for relevant participants\n\nIf the task has resourcing requirements of system-initiated start, the moment a work item is allocated to a user, it is also started. It will immediately appear in the started work item queue of that user without having\nfirst gone to their allocated queue.\nThis requirement is classified as **core**.\n\nHierarchical View of Resource Perspective Petri-Nets\nBibliography\n\n\nPage 108 of 108"}}},{"rowIdx":195,"cells":{"id":{"kind":"string","value":"01e1ee165f3d8361cbc09ac14ecf5b2a96c1a7e5"},"text":{"kind":"string","value":"A COALGEBRAIC TREATMENT OF CONDITIONAL TRANSITION SYSTEMS WITH UPGRADES\n\nHARSH BEOHAR \\textsuperscript{a}, BARBARA KÖNIG \\textsuperscript{a,*}, SEBASTIAN KÜPPER \\textsuperscript{a}, ALEXANDRA SILVA \\textsuperscript{b}, AND THORSTEN WISSMANN \\textsuperscript{c,†}\n\n\\textsuperscript{a} Universität Duisburg-Essen, Germany\n\\textit{e-mail address}: {harsh.beohar,barbara.koenig,sebastian.kuepper}@uni-due.de\n\n\\textsuperscript{b} University College London, United Kingdom\n\\textit{e-mail address}: alexandra.silva@ucl.ac.uk\n\n\\textsuperscript{c} Friedrich-Alexander Universität Erlangen-Nürnberg, Germany\n\\textit{e-mail address}: thorsten.wissmann@fau.de\n\n\\textit{Dedicated to Jiří Adámek}\n\n\\textbf{Abstract.} We consider conditional transition systems, that allow to model software product lines with upgrades, in a coalgebraic setting. We show that, by using Birkhoff’s duality for distributive lattices, we obtain two equivalent Kleisli categories in which these coalgebras live: Kleisli categories based on the reader and on the so-called lattice monad over Poset. We study two different functors describing the branching type of the coalgebra and investigate the resulting behavioural equivalence. Furthermore we show how an existing algorithm for coalgebra minimisation can be instantiated to derive behavioural equivalences in this setting.\n\n\\section{Introduction}\n\nJiří Adámek has made many important contributions to category theory, such as the theory of locally presentable and accessible categories and to the theory of coalgebras. The well-known concept of the final (or terminal) chain to construct the final coalgebra \\cite{AK95} will play a key role in this paper. In addition Jiří Adámek wrote, jointly with Herrlich and Strecker, the well-known textbook “Abstract and Concrete Categories – The Joy of Cats” \\cite{AHS90}, which has served as an invaluable guide to us when learning and looking up results on category theory, also for this paper.\n\nThis paper is a continuation of the work that two of the co-authors did jointly with Jiří Adámek \\cite{ABH+12}. In that paper we studied generic versions of minimisation and\n\n\\begin{itemize}\n \\item * Supported by the DFG-funded projects BEMEGA (KO 2185/7-1).\n \\item † Supported by the DFG-funded project COAX (MI 717/5-1).\n\\end{itemize}\ndeterminisation algorithms in the context of coalgebras, especially in Kleisli categories. Here we are studying a novel type of transition system, so-called conditional transition systems, and show how they fit into this framework.\n\nThis example is interesting for several reasons: first, it gives a non-trivial case study in coalgebra which demonstrates the generality of the approach. Second, it studies coalgebras in the category of partially ordered sets, respectively in Kleisli categories over this base category. We use the Birkhoff duality for distributive lattices to show the equivalence of two Kleisli categories over two monads: the reader monad and the so-called lattice monad. This result can be of interest, independently of the coalgebraic theory. Third, we introduce a notion of upgrade into coalgebraic modelling.\n\nThe theory of coalgebras [Rut00] allows uniform modelling and reasoning for a variety of state-based systems. For instance, (non)deterministic finite automata and weighted automata are classical examples often studied in this context (see [Rut00] for more examples). Furthermore, coalgebraic modelling comes with the benefit of offering generic algorithms, capturing the core of algorithms that are similar across different types of automata. In particular, the final-chain based algorithm [AK95] computes quotients on automata up to a chosen notion of behavioural equivalence (such as strong bisimilarity or trace equivalence).\n\nA conditional transition system (CTS) [ABH+12, BKKS17] is an extension of a labelled transition system that is well suited to model software product lines [CN01], an emergent topic of research in the field of software engineering. In contrast to the commonly used featured transition systems [CCS+13], CTSs are not primarily concerned with the individual features of a software product, but mainly with the individual versions that may arise from the given feature combinations.\n\nIn CTSs [BKKS17] transitions are labelled with the elements of a partially ordered set of conditions \\((\\Phi, \\leq)\\), which can be viewed as products in the terminology of software product lines. This gives us a compact representation which merges the transition systems for many different products into one single structure. A transition labelled \\(\\varphi \\in \\Phi\\) can only be taken by instances of product \\(\\varphi\\). Furthermore, with \\(\\varphi' \\leq \\varphi\\) we denote that – during execution – product \\(\\varphi\\) can be upgraded to \\(\\varphi'\\).\n\nIntuitively CTSs evolve in two steps: first, a condition \\(\\varphi \\in \\Phi\\) is chosen at a given state; second, a transition is fired which is guarded by the chosen condition. Over the course of the run of a CTS, it can perform an operation called upgrade in which the system changes from a greater condition \\(\\varphi\\) to a smaller condition \\(\\varphi' \\leq \\varphi\\). This in turn activates additional transitions that may be taken in future steps. Originally, CTSs in [ABH+12] were defined without upgrades, i.e., \\(\\leq\\) is equality.\n\nCTs have ‘monotonous’ upgrading in the sense that one can only go down on the hierarchy of conditions, but not up. As a consequence, CTSs have a special notion of bisimulation consisting of a family of traditional bisimulations \\(\\sim\\) (one for each condition \\(\\varphi \\in \\Phi\\)) such that \\(\\sim \\subseteq \\sim'\\), whenever \\(\\varphi' \\leq \\varphi\\). Roughly, two states are behaviourally equivalent under a condition \\(\\varphi\\) if and only if they are bisimilar (in the traditional sense) for every upgrade \\(\\varphi' \\leq \\varphi\\). An interesting fact about a CTS is that there exists an equivalent model, called lattice transition system (LaTS), which allows for a more compact representation of a CTS using the lattice of downward closed subsets of \\(\\Phi\\) (see [BKKS17] for more details). In essence, this can be viewed as a lifting of the well-known Birkhoff’s representation theorem to the case of transition systems.\n\nThis paper aims at characterising CTS and LaTS coalgebraically. To this end, we define two monads, the reader monad and the lattice monad, which allow for modelling CTS and\nLaTS respectively – provided a matching functor is chosen – in their corresponding Kleisli categories. We will show that these two categories are equivalent (in the categorical sense).\n\nOur next aim is to characterise conditional bisimilarity using the notion of behavioural equivalence, a concept stemming from the theory of coalgebras. Roughly, two states of a system (modelled as a coalgebra) are *behaviourally equivalent* if and only if they are mapped to a common point by a coalgebra homomorphism.\n\nIn this regard, capturing the right notion of behavioural equivalence (conditional bisimilarity in our case) depends on making the right choice of functor modelling CTSs. Working in a Kleisli category, we are interested in establishing a functor via an extension of a functor on the base category \\( \\text{Poset} \\). The usual powerset functor \\( \\mathcal{P} \\) proves to be a viable choice for CTSs without any upgrades, but we will provide a counterexample that shows this functor does not yield conditional bisimulation in the presence of upgrades, no matter how the extension is chosen. However, for an adaptation of the powerset functor, namely allowing \\( \\mathcal{P}(\\_ \\times \\Phi) \\), behavioural equivalence indeed captures conditional bisimilarity in the presence of upgrades. Our approach is not restricted to the treatment of those two specific functors: we introduce so-called *version filters* that add conditions/versions to any \\( \\text{Poset} \\) functor and also develop an abstract machinery to capture conditional bisimilarity coalgebraically.\n\nTo conclude, we show that the minimisation algorithm based on the final chain construction plus factorisation structures [ABH+12] is applicable to the category under investigation and specify how it can be applied to CTSs. CTSs without upgrades have already been considered in [ABH+12], but applicability to CTSs with upgrades is novel.\n\n### 2. Preliminaries\n\nWe assume a basic knowledge of category theory. The primary objects of interest in this work are coalgebras, which we use to model conditional transition systems.\n\n**Definition 2.1** (Coalgebra). Let \\( H : \\mathcal{C} \\to \\mathcal{C} \\) be an endofunctor on a category \\( \\mathcal{C} \\). Then an \\( H \\)-coalgebra is a pair \\( (X, \\alpha) \\), where \\( X \\) is an object of \\( \\mathcal{C} \\) and \\( \\alpha : X \\to HX \\) is an arrow in \\( \\mathcal{C} \\). An \\( H \\)-coalgebra homomorphism between two coalgebras \\( (X, \\alpha) \\) and \\( (Y, \\beta) \\) is an arrow \\( f : X \\to Y \\) in \\( \\mathcal{C} \\) such that \\( \\beta \\cdot f = Hf \\cdot \\alpha \\).\n\nThe \\( H \\)-coalgebras and their homomorphisms form a category. In the sequel, we drop the prefix ‘\\( H \\)-’ whenever it is clear from the context.\n\nIn the theory of coalgebras, bisimilarity [Par81] is captured in more than one way, namely: coalgebraic bisimulation, via an arrow into any coalgebra (so-called cocongruences), via the arrow into the final object of the coalgebra category (if that exists), called final coalgebra, and a related approach that minimises the coalgebra via factorisation (see Section 6). At this stage, we fix the notion of behavioural equivalence in a category \\( \\mathcal{C} \\) structured over the category of sets \\( \\text{Set} \\) using a concretisation functor \\( U : \\mathcal{C} \\to \\text{Set} \\).\n\n**Definition 2.2** (Behavioural Equivalence). Let \\( F \\) be an endofunctor on a concrete category \\( \\mathcal{C} \\) with a faithful functor \\( U : \\mathcal{C} \\to \\text{Set} \\) to the category of sets \\( \\text{Set} \\). Then, two states \\( x \\in UX \\) and \\( x' \\in UX \\) of a coalgebra \\( (X, \\alpha) \\) are *behaviourally equivalent* if there exists a coalgebra homomorphism \\( f : X \\to Y \\) such that \\( Uf(x) = Uf(x') \\).\n\n**Example 2.3.** In the sequel, we work with the concrete category of partially ordered sets (a.k.a. posets), denoted \\( \\text{Poset} \\), as our base category \\( \\mathcal{C} \\). Formally, the objects of \\( \\text{Poset} \\) are\npairs $\\langle X, \\leq_X \\rangle$ of a set $X$ and a partial order $\\leq_X \\subseteq X \\times X$; while its arrows are all the order preserving functions between any two posets.\n\n**Definition 2.4.** Given two functors $F : \\mathcal{C} \\to \\mathcal{D}$ and $U : \\mathcal{D} \\to \\mathcal{C}$, then $F$ is left adjoint to $U$ (or $U$ is right adjoint to $F$), denoted $F \\dashv U$, if there exists a family of isomorphisms\n\n$$\\Psi_{X,Y} : \\mathcal{D}(FX,Y) \\cong \\mathcal{C}(X,UY)$$\n\nnatural in $X$ of $\\mathcal{C}$ and $Y$ of $\\mathcal{D}$. Instead of writing the explicit application of $\\Psi$, we write\n\n$$f : FX \\to Y$$\n$$g : X \\to UY$$\n\nto denote that $g = \\Psi_{X,Y}(f)$.\n\nRecall that a monad on $\\mathcal{C}$ is a functor $T : \\mathcal{C} \\to \\mathcal{C}$ with natural transformations $\\eta : \\text{Id} \\to T$, $\\mu : TT \\to T$ such that $\\mu \\cdot T\\eta = \\text{Id} = \\mu \\cdot \\eta T$ and $\\mu \\cdot T\\mu = \\mu \\cdot \\mu T$.\n\n**Proposition 2.5.** Given a comonad $(L, \\varphi, \\delta)$ on a category $\\mathcal{C}$ and a functor $T : \\mathcal{C} \\to \\mathcal{C}$ such that $L \\dashv T$ with unit and counit $\\rho$ and $\\epsilon$, respectively. Then, this adjunction induces a monad structure on $T$ as follows:\n\n$$\\begin{array}{c c c}\nLX \\xrightarrow{\\delta_X} X & \\quad & LTTX \\xrightarrow{\\delta_{TX}} LTTTX \\xrightarrow{\\text{Lev}_X} LTX \\xrightarrow{\\epsilon_X} X \\\\\nX \\xrightarrow{\\eta_X} TX & \\quad & TTX \\xrightarrow{\\mu_X} TX\n\\end{array}$$\n\nFor instance, the reader monad is defined in terms of a comonad (see e.g. [PG14, Example 3.10]).\n\n**Definition 2.6** (Reader monad). Using $\\_ \\times \\Phi \\dashv \\_^\\Phi$ with the counit $\\text{ev}_X : X^\\Phi \\times \\Phi \\to X$ on $\\text{Poset}$, we have a monad structure on $\\_^\\Phi$ defined by\n\n$$\\begin{array}{c c}\nX \\times \\Phi \\xrightarrow{\\pi_1} X & \\quad & X^\\Phi \\times \\Phi \\xrightarrow{\\chi_{\\Phi} \\times \\Phi} X^\\Phi \\times \\Phi \\xrightarrow{\\text{ev}_X} X \\\\\n\\nu_X : X \\to X^\\Phi & \\quad & \\zeta_X : X^\\Phi \\times \\Phi \\to X^\\Phi\n\\end{array}$$\n\nwhere the diagonal $\\Delta_{\\Phi} : \\Phi \\xrightarrow{(\\text{id}_\\Phi, \\text{id}_\\Phi)} \\Phi \\times \\Phi$ is the the comultiplication of $\\_ \\times \\Phi$. Explicitly, we have:\n\n$$X^\\Phi = (\\text{Poset}(\\Phi, X), \\leq_{X^\\Phi}) \\quad (f : X \\to Y)^\\Phi = \\text{Poset}(\\Phi, f) = (C \\mapsto f \\cdot C),$$\n\nwhere $C \\leq_{X^\\Phi} C'$ if $\\forall \\varphi \\in \\Phi \\; C(\\varphi) \\leq_X C'(\\varphi)$ and\n\n$$\\nu_X(x)(\\varphi) = x \\quad \\text{for} \\; x \\in X, \\varphi \\in \\Phi \\quad \\zeta_X(D)(\\varphi) = D(\\varphi)(\\varphi) \\quad \\text{for} \\; D \\in X^\\Phi, \\varphi \\in \\Phi.$$\n\n**Notation 2.7.** Given an arrow $f : X \\times \\Phi \\to Y$, $\\tilde{f} : X \\to Y^\\Phi$ denotes its curried version. Furthermore, given an arrow $g : X \\to Y^\\Phi$, $\\check{g} : X \\times \\Phi \\to Y$ denotes its uncurried version. Lastly, given a monotone map $f : X \\to Y^\\Phi$ then we fix one argument $\\varphi \\in \\Phi$ by writing $f_\\varphi : X \\to Y$ defined as $f_\\varphi(x) = f(x)(\\varphi)$.\n\nFrom the seminal work of Moggi [Mog91], it is common to model computations with side-effects by a monad. Generally, such a computation with side-effects in $T$ is treated as an arrow in the Kleisli category of $T$.\n\n**Definition 2.8.** Let $(T, \\eta, \\mu)$ be a monad on $\\mathcal{C}$. Then its Kleisli category $\\text{Kl}(T)$ has the same objects as $\\mathcal{C}$ and the arrows $f : X \\to Y$ in $\\text{Kl}(T)$ are the arrows $f : X \\to TY$ in $\\mathcal{C}$. \n\n\nThe identity on \\( X \\) in \\( \\text{Kl}(T) \\) is given by \\( \\eta_X : X \\to X \\) and the composition of two arrows \\( f : X \\to Y, \\ g : Y \\to Z \\) in \\( \\text{Kl}(T) \\) is given by the following composition in \\( \\mathcal{C} \\)\n\n\\[\ng \\circ f := ( X \\xrightarrow{g} TY \\xrightarrow{Tg} TTZ \\xrightarrow{\\mu_Z} TZ ).\n\\]\n\nThroughout the paper, we reserve \\( \\circ \\) for Kleisli composition, whereas \\( \\cdot \\) denotes the composition in the base category \\( \\mathcal{C} \\). The base category is a subcategory of \\( \\text{Kl}(T) \\) witnessed by the inclusion \\( I : \\mathcal{C} \\hookrightarrow \\text{Kl}(T) \\): \\( I(X) = X \\), for each object \\( X \\); \\( I(f) = \\eta_Y \\cdot f \\), for each arrow \\( f : X \\to Y \\) in \\( \\mathcal{C} \\). A Kleisli arrow \\( f : X \\to Y \\) is called pure, if \\( f : X \\to TY \\) factors through \\( \\eta_Y : Y \\to TY \\) in \\( \\mathcal{C} \\), i.e. if there is some arrow \\( f' : X \\to Y \\) with \\( If' = f \\). Intuitively speaking, pure arrows have no side-effects. The subcategory of pure Kleisli arrows is precisely \\( \\mathcal{C} \\). The Kleisli composition of \\( f : X \\to Y \\) with pure maps boils down to the composition in \\( \\mathcal{C} \\):\n\n\\[\n\\begin{align*}\nf \\circ Ip &= f \\cdot p & \\text{for } p : P \\to X \\\\\nIp \\circ f &= Tp \\cdot f & \\text{for } p : X \\to P.\n\\end{align*}\n\\]\n\nWhen considering coalgebras on a Kleisli category, one can distinguish the visible effects of transitions in a system from the side-effects. For instance, when checking the language equivalence of two states in a nondeterministic automaton, one only cares about the final states and the consumed input word, but not about the non-deterministic branching.\n\nWhile determining the behavioural equivalence of interest, the intended observable effects of a transition are encoded in an endofunctor \\( F \\) on the Kleisli category; whereas, the side-effects are encoded via a monad \\( T \\). This is motivated by the previous works in \\([\\text{HJS07, PT99}]\\), where behavioural equivalence in Kleisli categories were used to characterise (trace) language equivalence (rather than bisimulation).\n\nNotwithstanding, the endofunctor \\( F \\) and the monad \\( T \\) of interest are often defined on a base category. Thus, one needs a mechanism to extend the given functor \\( F \\) as an endofunctor \\( \\hat{F} \\) on the Kleisli category \\( \\text{Kl}(T) \\).\n\n**Definition 2.9.** An extension of a functor \\( F : \\mathcal{C} \\to \\mathcal{C} \\) to \\( \\text{Kl}(T) \\) is a functor \\( \\hat{F} : \\text{Kl}(T) \\to \\text{Kl}(T) \\) such that \\( IF = \\hat{F}I \\). A distributive law \\( \\lambda : FT \\to TF \\) is a natural transformation \\( FT \\to TF \\) that preserves the monad structure of \\( T \\) in the obvious way.\n\nWe end this section by recalling a standard result on distributive laws from \\([\\text{HJS07, Mul94}]\\).\n\n**Theorem 2.10.** For a functor \\( \\hat{F} : \\text{Kl}(T) \\to \\text{Kl}(T) \\), the following are equivalent:\n\n1. \\( \\hat{F} \\) preserves pure arrows.\n2. \\( \\hat{F} \\) is the extension of some \\( F : \\mathcal{C} \\to \\mathcal{C} \\).\n3. For some \\( F : \\mathcal{C} \\to \\mathcal{C} \\) there is a distributive law \\( \\lambda \\), such that\n\n\\[\n\\hat{F}(f : X \\to Y) = (FX \\xrightarrow{Ef} FTY \\xrightarrow{\\lambda_Y} TFY).\n\\]\n\n### 3. Conditional and lattice transition systems\n\nHere we recall the definitions of a CTS, a LaTS, and conditional bisimilarity from \\([\\text{BKKS17}]\\).\n\n**Definition 3.1.** A conditional transition system (CTS) is a tuple \\( (X, A, \\Phi, f) \\) consisting of a set of states \\( X \\), a set of actions \\( A \\), a finite set of conditions \\( \\Phi \\), and a transition function \\( f : X \\times A \\to (\\mathcal{P}X, \\supseteq)^{\\Phi, \\subseteq} \\) that maps every pair \\( (x, a) \\in X \\times A \\) to a monotone function of\ntype \\((\\Phi, \\leq_{\\Phi}) \\rightarrow (\\mathcal{P}X, \\supseteq)\\). We write \\(x \\xrightarrow{a,\\varphi} x'\\), whenever \\(x' \\in f(x, a)(\\varphi)\\). In case \\(|A| = 1\\), we omit the action label from a transition.\n\nIntuitively, a CTS evolves as follows: In the beginning, a version of the system \\(\\varphi \\in \\Phi\\) is chosen and the CTS is instantiated to the version \\(\\varphi\\) as the traditional labelled transition system that has a transition \\(x \\xrightarrow{a} x'\\) if and only if the CTS has a transition \\(x \\xrightarrow{a,\\varphi} x'\\). At any point of the execution of this labelled transition system, an upgrade may be performed, i.e., a new version \\(\\varphi' \\leq_{\\Phi} \\varphi\\) of the system may be chosen. The system remains in the state reached up to that point and additional transitions get activated, since now all transitions \\(x \\xrightarrow{a,\\varphi'} x'\\) give rise to a transition \\(x \\xrightarrow{a} x'\\). Note that due to the monotonicity of the transition function \\(f\\) in a CTS, an upgrade will always retain all previous transitions, but may add additional transitions. Symbolically, if \\(x \\xrightarrow{a,\\varphi} x'\\) and \\(\\varphi' \\leq_{\\Phi} \\varphi\\) then \\(x \\xrightarrow{a,\\varphi'} x'\\).\n\nThe notion of behavioural equivalence we are interested in is conditional bisimulation:\n\n**Definition 3.2.** Let \\((X, A, \\Phi, f)\\) be a CTS. Let \\(f_{\\varphi}(x, a) = f(x, a)(\\varphi)\\) (for every \\(\\varphi \\in \\Phi\\)) denote the labelled transition system induced upon choosing the condition \\(\\varphi\\). A conditional bisimulation on the given CTS \\((X, A, \\Phi, f)\\) is a family of relations \\((R_{\\varphi})_{\\varphi \\in \\Phi}\\) satisfying the following conditions:\n\n- Each \\(R_{\\varphi}\\) is a traditional bisimulation relation on the labelled transition system \\(f_{\\varphi}\\).\n- For every \\(\\varphi, \\varphi' \\in \\Phi\\) we have \\(\\varphi' \\leq_{\\Phi} \\varphi \\implies R_{\\varphi} \\subseteq R_{\\varphi'}\\).\n\nFor \\(x, y \\in X\\) we say that \\(x \\sim_{\\varphi} y\\) if there exists a conditional bisimulation such that \\(x R_{\\varphi} y\\).\n\nOriginally, CTS were introduced without a notion of upgrades, these systems can be reobtained by setting the order \\(\\leq_{\\Phi}\\) on the conditions to be the trivial order.\n\nThere is a game characterising conditional bisimulation [BKKS17], in which the upgrades are chosen by the attacker, whose aim is to show that two states are not bisimilar. This also explains Definition 3.2, where we require that \\(R_{\\varphi} \\subseteq R_{\\varphi'}\\) whenever \\(\\varphi' \\leq_{\\Phi} \\varphi\\). This means that the defender still has a winning strategy after the attacker chooses to make an upgrade.\n\nTo get a better feeling of CTS, consider the following example:\n\n**Example 3.3.** Consider a CTS \\((X, \\{a\\}, \\Phi, f)\\) as depicted below, where \\(X = \\{x, y, z, x', y', z'\\}\\) and \\(\\Phi = \\{\\varphi', \\varphi\\}\\) with \\(\\varphi' \\leq_{\\Phi} \\varphi\\). Since the set of actions is singleton, we leave out the action labels in the visual representation.\n\nWe will now detail how the above behavioural description can be represented by a transition function. For instance, the equation \\(f(x, a)(\\varphi) = \\{y, z\\}\\) specifies that the system under the condition \\(\\varphi\\) may move nondeterministically from the state \\(x\\) to \\(y\\) or \\(z\\), additionally, it can also upgrade to the condition \\(\\varphi'\\).\nConsider the labelled transition systems \\( f_\\varphi \\) and \\( f_{\\varphi'} \\) as depicted above in the left and right, respectively. Notice that the states \\( x \\) and \\( x' \\) are bisimilar in both the instantiations with the relations \\( R_\\varphi \\) and \\( R_{\\varphi'} \\) depicted as dotted lines. However, we find that \\( x \\) and \\( x' \\) are not conditionally bisimilar, because \\( y R_\\varphi z' \\), but \\( (y, z') \\notin R_{\\varphi'} \\) and there is no other conditional bisimulation relating \\( x, x' \\). Moreover, the states \\( y \\) and \\( z' \\) in the instantiation \\( \\varphi' \\) can never be related by any bisimulation.\n\nThe corresponding strategy for the attacker is as follows: start with condition \\( \\varphi \\) and make a move from \\( x \\) to \\( y \\). The defender is then forced to take the transition from \\( x' \\) to \\( z' \\). Then the attacker can upgrade to \\( \\varphi' \\) and make a move, starting from \\( y \\), which the defender can not mimic in \\( z' \\).\n\nNext, we recall an equivalent, but more compact representation of a CTS which we call lattice transition system (LaTS). In [BKKS17] we showed that behavioural equivalence checks can be performed more efficiently in the lattice setting, by encoding lattice elements into binary decision diagrams.\n\n\\textbf{Definition 3.4} (Complete Lattice, Frame). A poset \\((L, \\leq_L)\\) is a join-complete lattice if for any subset \\( L \\subseteq L \\) the supremum \\( \\bigvee L \\) and for any finite subset \\( L \\subseteq L, \\bigwedge L \\) exists.\n\nA frame (see e.g. [MLM92]) is a join-complete lattice satisfying the join-infinite distributive law:\n\n\\[ \\ell \\sqcap \\bigvee L = \\bigvee \\{ \\ell \\sqcap \\ell' \\mid \\ell' \\in L \\}, \\quad \\text{(for any } L \\subseteq L) \\quad \\text{(JID)} \\]\n\n\\textbf{Definition 3.5.} A lattice transition system (LaTS) over a finite frame \\( L \\) is a tuple \\((X, A, L, f)\\) consisting of a set of states \\( X \\), a set of actions \\( A \\), and a transition function \\( f : X \\times A \\times X \\to L \\).\n\n\\textbf{Remark 3.6.} LaTS can also serve as an explanation why in a CTS, upgrading means going downwards in the partial order. One special case of LaTS arises when choosing \\( L \\) as the binary Boolean algebra, yielding standard LTS. Using the order and Birkhoff duality as we have done here, the matrix representation of a LaTS over \\( \\{0, 1\\} \\) has the same interpretation as the standard way of writing LTS, i.e. a 1 indicates that a transition is possible, whereas a 0 indicates that no transition is possible. If one were to turn the order around, such that an upgrade means going up in the order, this correspondence gets turned around as well. So in this sense, when LaTS are considered as generalisations of LTS, it is more natural to go down in the partial order to upgrade, rather than to go up.\n\nAs worked out in [BKKS17], a CTS \\((X, A, \\Phi, f)\\) corresponds to a LaTS \\((X, A, L, g)\\) where \\( L = \\mathcal{O}(\\Phi) \\) and \\( g : X \\times A \\times X \\to L \\) with \\( g(x, a, x') = \\{ \\varphi \\in \\Phi \\mid x' \\in f(x, a)(\\varphi) \\} \\) for \\( x, x' \\in X, a \\in A \\). Similarly, a LaTS can be converted into a CTS by using the Birkhoff duality and by taking the join irreducibles as conditions.\n\n\\textbf{Definition 3.7.} Given a poset \\( \\Phi \\), then a subset \\( \\Phi' \\subseteq \\Phi \\) is downward closed if\n\n\\[ \\forall \\varphi, \\varphi' \\left( \\varphi \\leq \\Phi \\varphi' \\wedge \\varphi' \\in \\Phi' \\right) \\implies \\varphi \\in \\Phi. \\]\nGiven a lattice \\( \\mathbb{L} \\) with arbitrary joins, \\( \\ell \\in \\mathbb{L} \\) is called (complete) join irreducible if \\( \\ell = \\bigsqcup L \\) for \\( L \\subseteq \\mathbb{L} \\) implies \\( \\ell \\in L \\).\n\n**Notation 3.8.** We write \\( \\mathcal{O}(\\Phi) \\) and \\( \\mathcal{J}(\\mathbb{L}) \\) to denote the set of downward closed subsets of \\( \\Phi \\) and the set of join irreducible elements of \\( \\mathbb{L} \\), respectively.\n\n**Remark 3.9.** Equivalently, \\( \\mathcal{O} \\) can be defined as the contravariant hom functor \\( \\mathcal{O} := \\text{Poset}(\\_, 2) : \\text{Poset}^{\\text{op}} \\to \\text{Frames} \\), where \\( 2 \\) is the poset/lattice on \\( \\{0, 1\\} \\) with \\( 0 \\leq 1 \\). Similarly, \\( \\mathcal{J} \\) is the contravariant hom functor \\( \\text{Frames}(\\_, 2) : \\text{Frames}^{\\text{op}} \\to \\text{Poset} \\). Taking the respective subcategories of finite posets, resp. frames, the functors \\( \\mathcal{O} \\) and \\( \\mathcal{J} \\) form an equivalence of categories, known as Birkhoff’s theorem:\n\n**Theorem 3.10** (Birkhoff’s representation theorem, [DP02, 5.12]). Let \\( \\mathbb{L} \\) be a finite frame, then \\( (\\mathbb{L}, \\cup, \\cap) \\cong (\\mathcal{O}(\\mathcal{J}(\\mathbb{L})), \\cup, \\cap) \\) via the isomorphism \\( \\eta : \\mathbb{L} \\to \\mathcal{O}(\\mathcal{J}(\\mathbb{L})) \\), defined as \\( \\eta(\\ell) = \\{ \\ell’ \\in \\mathcal{J}(\\mathbb{L}) \\mid \\ell’ \\subseteq \\ell \\} \\). Furthermore, given a finite poset \\( (\\Phi, \\leq_\\Phi) \\), the downward-closed subsets of \\( \\Phi \\), \\( (\\mathcal{O}(\\Phi), \\cup, \\cap) \\) form a frame, with inclusion \\( (\\subseteq) \\) as the partial order. The irreducibles of this frame are all sets of the form \\( \\downarrow \\varphi = \\{ \\varphi’ \\mid \\varphi’ \\leq_\\Phi \\varphi \\} \\) for \\( \\varphi \\in \\Phi \\).\n\nGoing from \\( \\mathbb{L} \\) to the isomorphic \\( \\mathcal{O}(\\mathcal{J}(\\mathbb{L})) \\), each frame element \\( \\ell \\in \\mathbb{L} \\) is mapped to the set of all irreducible elements that are smaller than \\( \\ell \\), i.e. \\( \\{ \\ell’ \\in \\mathcal{J}(\\mathbb{L}) \\mid \\ell’ \\subseteq \\ell \\} \\).\n\nConsequently, a LaTS evolves just like a CTS. At a state, a product, i.e., a join-irreducible element \\( \\ell \\in \\mathbb{L} \\), is chosen and all the transitions that carry a label greater than \\( \\ell \\) remain active, whereas all other transitions are deactivated. At any point of the execution, an upgrade to a smaller join-irreducible element \\( \\ell’ \\) may be performed, activating additional transitions accordingly. A CTS and a LaTS can be transformed into one another by going from the lattice to its dual partial order and vice-versa (see Section 4). More instructively, the CTS defined in Example 3.3 can be turned into a LaTS by simply denoting the depicted conditions inside the curly braces as sets.\n\nA benefit of LaTS over CTS is that now bisimilarity can be stated in more familiar terms. In addition, this view is also helpful in computing the largest conditional bisimilarity via matrix multiplication (see [BKKS17] for more details).\n\n**Definition 3.11.** Let \\( (X, A, \\mathbb{L}, f) \\) be a LaTS and let \\( \\mathcal{J}(\\mathbb{L}) \\) denote the set of all join-irreducible elements of \\( \\mathbb{L} \\). A function \\( R : X \\times X \\to \\mathbb{L} \\) is a **lattice bisimulation** if and only if the following transfer properties are satisfied.\n\n1. For all \\( x, x’, y \\in X \\) \\( a \\in A \\), \\( \\ell \\in \\mathcal{J}(\\mathbb{L}) \\) whenever \\( x \\xrightarrow{a,\\ell} x’ \\) and \\( \\ell \\leq_\\mathbb{L} R(x, y) \\), there exists \\( y’ \\in X \\) such that \\( y \\xrightarrow{a,\\ell} y’ \\) and \\( \\ell \\leq_\\mathbb{L} R(x’, y’) \\).\n2. Symmetric to (1) with the roles of \\( x \\) and \\( y \\) interchanged.\n\nHere, we write \\( x \\xrightarrow{a,\\ell} x’ \\), whenever \\( \\ell \\leq_\\mathbb{L} f(x, a, x’) \\).\n\n**Theorem 3.12** [BKKS17]. Two states are conditionally bisimilar under condition \\( \\varphi \\) if and only if they are related by a lattice bisimulation \\( R \\) with \\( \\varphi \\in R(x, y) \\).\n\n## 4. The Lattice Monad\n\nWhen modelling a LaTS as a coalgebra in the Kleisli category of a monad, the choice of monad is not obvious. One could try to simply use the monad mapping sets to arbitrary lattice-valued functions defined on objects as \\( TX = \\mathbb{L}^X \\) and on arrows as \\( Tf(b)(y) = \\bigsqcup_{f(x) \\leq y} b(x) \\),\nhowever, this would not be equivalent to the reader monad. Given a monotone function \n\\( f : \\Phi \\to X \\), one would like to define a corresponding mapping \\( \\bar{f} : X \\to \\mathbb{L} \\) with \\( \\mathbb{L} = \\mathcal{O}(\\Phi) \\) and \n\\( \\bar{f}(x) = \\bigsqcup \\{ \\varphi \\in \\Phi \\mid f(\\varphi) \\leq x \\} \\). However, this does not result in a bijection, since some arrows \n\\( \\bar{f} : X \\to \\mathbb{L} \\) do not represent a monotone function \\( f : \\Phi \\to X \\). Hence, we start by imposing restrictions on mappings \\( \\mathbb{L}^X \\) and defining a suitable endofunctor in our base category \\( \\text{Poset} \\).\n\nThroughout this section, we consider \\( \\mathbb{L} \\) to be an arbitrary frame.\n\n**Definition 4.1.** For an ordered set \\((X, \\leq_X)\\), define the poset \\( TX = (X \\to \\mathbb{L})^* \\subseteq \\text{Poset}(X, \\mathbb{L}) \\) as the subset containing all those monotone maps \\( b : X \\to \\mathbb{L} \\) such that for any join-irreducible element \\( \\ell \\in \\mathcal{J}(\\mathbb{L}) \\), the minimum of \\( \\{x \\mid \\ell \\leq \\mathbb{L} b(x)\\} \\) exists. This means:\n\\[\n\\exists x \\in X \\quad \\ell \\leq \\mathbb{L} b(x) \\land \\forall x' \\in X \\quad (\\ell \\leq \\mathbb{L} b(x') \\implies x \\leq_X x').\n\\]\n(4.1)\n\nFor functions \\( b, c \\in (X \\to \\mathbb{L})^* \\) we let\n\\[\nb \\leq_{TX} c \\iff \\forall x \\in X \\quad b(x) \\geq \\mathbb{L} c(x).\n\\]\n\nBefore stating \\( T \\) as a functor, we canonically relate the function spaces \\((X \\to \\mathbb{L})^*, \\mathcal{J}(\\mathbb{L})\\).\n\n**Lemma 4.2.** For each \\( X \\) in \\( \\text{Poset} \\), we have a monotone \\( \\tau_X : (X \\to \\mathbb{L})^* \\to \\mathcal{J}(\\mathbb{L}) \\) defined by\n\\[\n\\tau_X(b)(\\ell) = \\min \\{ x \\in X \\mid \\ell \\leq \\mathbb{L} b(x) \\}.\n\\]\n(4.2)\n\n**Proof.** Given \\( b \\in (X \\to \\mathbb{L})^* \\) and \\( \\ell \\in \\mathcal{J}(\\mathbb{L}) \\), the minimum \\( \\tau_X(b)(\\ell) \\) exists.\n\n- Since the minimum is unique if it exists, \\( \\tau_X(b) \\) is a map.\n- The map \\( \\tau_X(b) : \\mathcal{J}(\\mathbb{L}) \\to X \\) is monotone, because for \\( \\ell_1 \\leq \\mathbb{L} \\ell_2 \\in \\mathcal{J}(\\mathbb{L}) \\) with \\( x_1 := \\tau_X(b)(\\ell_1) \\), and \\( x_2 := \\tau_X(b)(\\ell_2) \\) we have \\( \\ell_1 \\leq \\mathbb{L} \\ell_2 \\leq \\mathbb{L} b(x_2) \\) and thus \\( x_1 \\leq x_2 \\) by (4.1) (for \\( x = x_1, x' = x_2 \\)).\n- The map \\( \\tau_X \\) is monotone in \\( b \\in (X \\to \\mathbb{L})^* \\), because for \\( b \\leq_{TX} c \\) and \\( \\ell \\in \\mathbb{L} \\) we have:\n\\[\n\\forall x \\in X \\quad b(x) \\geq \\mathbb{L} c(x) \\implies \\{ x \\in X \\mid \\ell \\leq \\mathbb{L} b(x) \\} \\supseteq \\{ x \\in X \\mid \\ell \\leq \\mathbb{L} c(x) \\} \\implies \\min \\{ x \\in X \\mid \\ell \\leq \\mathbb{L} c(x) \\} \\leq \\min \\{ x \\in X \\mid \\ell \\leq \\mathbb{L} b(x) \\} \\implies \\tau_X(c)(\\ell) \\leq \\tau_X(b)(\\ell).\n\\]\n\n**Lemma 4.3.** We have an adjunction-style situation with \\( b \\) and \\( \\tau_X(b) \\), namely\n\\[\n\\tau_X(b)(\\ell) \\leq_X x \\iff \\ell \\leq \\mathbb{L} b(x) \\quad \\text{for all} \\ x \\in X, \\ell \\in \\mathcal{J}(\\mathbb{L}).\n\\]\n(4.3)\n\n**Proof.** The direction \\( \\Rightarrow \\) holds because by definition of \\( \\tau \\), \\( \\ell \\leq \\mathbb{L} b(\\tau_X(b)(\\ell)) \\) and so \\( \\ell \\leq b(x) \\) by monotonicity of \\( b \\). For \\( \\Leftarrow \\), recall that \\( \\tau_X(b)(\\ell) \\) is the least element in \\( X \\) with \\( \\ell \\leq \\mathbb{L} b(x) \\).\n\nThis correspondence is not a proper adjunction (or in \\( \\text{Poset} \\) equivalently a Galois connection), because \\( \\tau_X(b) \\) is only defined for \\( \\ell \\in \\mathcal{J}(\\mathbb{L}) \\) and not for all elements of \\( \\mathbb{L} \\).\n\n**Lemma 4.4.** \\( \\tau_X \\) is an isomorphism; its inverse \\( \\tau_X^{-1} : \\mathcal{J}(\\mathbb{L}) \\to (X \\to \\mathbb{L})^* \\) is given by\n\\[\n\\tau_X^{-1}(b)(\\ell) = \\bigsqcup \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid B(\\ell) \\leq_X X \\}\n\\]\nand for \\( B : \\mathcal{J}(\\mathbb{L}) \\to X \\),\n\\[\n\\ell \\leq \\mathbb{L} \\tau_X^{-1}(B)(\\ell) \\iff B(\\ell) \\leq_X x \\quad \\text{for all} \\ x \\in X, \\ell \\in \\mathcal{J}(\\mathbb{L}).\n\\]\n(4.4)\n\n**Proof.**\n\n- First of all \\( \\tau_X^{-1}(B) : X \\to \\mathbb{L} \\) is a monotone map, because if \\( x \\leq_X x' \\), then\n\\[\n\\tau_X^{-1}(B)(x) = \\bigsqcup \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid B(\\ell) \\leq x \\} \\leq \\bigsqcup \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid B(\\ell) \\leq x' \\} = \\tau_X^{-1}(B)(x').\n\\]\n• For $B : \\mathcal{J}(\\mathbb{L}) \\to X$, we have (4.4) for all $\\ell \\in \\mathcal{J}(\\mathbb{L})$ and $x \\in X$, because:\n\n\\[\n\\ell \\leq_L \\tau_X^{-1}(B)(x) \\iff \\ell \\leq_{\\mathcal{J}(\\mathbb{L})} \\bigsqcup \\{ \\ell' \\in \\mathcal{J}(\\mathbb{L}) \\mid B(\\ell') \\leq_X x \\} \\\\\n\\iff \\ell = \\ell \\cap \\bigsqcup \\{ \\ell' \\in \\mathcal{J}(\\mathbb{L}) \\mid B(\\ell') \\leq_X x \\} \\\\\n\\iff \\ell = \\bigsqcup \\{ \\ell \\cap \\ell' \\mid \\ell' \\in \\mathcal{J}(\\mathbb{L}), \\ B(\\ell') \\leq_X x \\} \\\\\n\\iff \\exists \\ell' \\in \\mathcal{J}(\\mathbb{L}) \\ell = \\ell \\cap \\ell' \\text{ and } B(\\ell') \\leq_X x \\\\\n\\iff \\exists \\ell' \\in \\mathcal{J}(\\mathbb{L}) \\ell \\leq_L \\ell' \\text{ and } B(\\ell') \\leq_X x \\quad B \\text{ monotone } \\iff B(\\ell) \\leq x\n\\]\n\n• $\\tau^{-1}$ is monotone in $B$, because for any $B \\leq C$ and $x \\in X$\n\n\\[\n\\forall \\ell \\in \\mathcal{J}(\\mathbb{L}) B(\\ell) \\leq_X C(\\ell) \\\\\n\\implies \\bigsqcup \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid B(\\ell) \\leq_X x \\} \\supseteq \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid C(\\ell) \\leq_X x \\} \\\\\n\\implies \\bigsqcup \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid B(\\ell) \\leq_X x \\} \\supseteq \\bigsqcup \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid C(\\ell) \\leq_X x \\} \\\\\n\\implies \\tau_X^{-1}(B)(x) \\supseteq \\tau_X^{-1}(C)(x)\n\\]\n\nand so $\\tau_X^{-1}(B) \\leq_{TX} \\tau_X^{-1}(C)$.\n\n• For $B : \\mathcal{J}(\\mathbb{L}) \\to X$, $b := \\tau_X^{-1}(B)$, and $\\ell \\in \\mathcal{J}(\\mathbb{L})$ the witness for (4.1) is $B(\\ell) \\in X$:\n\n\\[\n\\min\\{ x \\in X \\mid \\ell \\leq_L b(x) \\} \\overset{(4.4)}{=} \\min\\{ x \\in X \\mid B(\\ell) \\leq_X x \\} = B(\\ell) \\quad (4.5)\n\\]\n\nSo $B(\\ell)$ is the desired witness for (4.1).\n\n• We have $\\tau_X(\\tau_X^{-1}(B)) = B$ by (4.5).\n\n• For the converse, if $b \\in (X \\to \\mathbb{L})^*$ then we have for all $x \\in X$:\n\n\\[\n\\tau_X^{-1}(\\tau_X(b))(x) = \\bigsqcup \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid \\tau_X(b)(\\ell) \\leq x \\} \\\\\n= \\bigsqcup \\{ \\ell \\in \\mathcal{J}(\\mathbb{L}) \\mid \\ell \\leq b(x) \\} = b(x)\n\\]\n\nSo we now have an object mapping $T : \\text{obj Poset} \\to \\text{obj Poset}$ and a family of isomorphisms $\\tau_X : TX \\cong X^\\mathcal{J}(\\mathbb{L})$. Since $\\mathcal{J}(\\mathbb{L})$ is already a functor, this induces a mapping on monotone maps for $T$:\n\n**Definition 4.5.** Define $T$ on monotone maps $f : X \\to Y$ by\n\n$$(X \\to \\mathbb{L})^* \\xrightarrow{\\tau_X} X^\\mathcal{J}(\\mathbb{L}) \\xleftarrow{\\tau^\\mathcal{J}} \\mathbb{L} \\xrightarrow{f^\\mathcal{J}} Y^\\mathcal{J}(\\mathbb{L})$$\n\nmaking $T$ a functor.\n\n**Remark 4.6.** Using that $\\mathcal{J}(\\mathbb{L})$ is a functor, $T$ automatically preserves identities and composition. So by definition, $T : \\text{Poset} \\to \\text{Poset}$ is a functor and $\\tau : T \\to \\mathcal{J}(\\mathbb{L})$ is a natural isomorphism.\n\n**Proposition 4.7.** For $f : X \\to Y$, $b \\in (X \\to \\mathbb{L})^*$, $y \\in Y$ we have\n\n$$Tf(b)(y) = \\bigsqcup_{f(x) \\leq_Y y} b(x)$$\nDefinition 4.8. Define the monad structure\n\n\\[\n\\eta_X(x)(x') = \\left\\{ \\begin{array}{ll}\n\\top & \\text{if } x \\leq x' \\\\\n\\bot & \\text{otherwise}\n\\end{array} \\right.\n\\]\n\n\\[\n\\mu_X(h)(x) = \\bigsqcup_{b \\in (X \\to \\mathbb{L})^*} (h(b) \\sqcap b(x)), \\quad \\text{where } h \\in ((X \\to \\mathbb{L})^* \\to \\mathbb{L})^*.\n\\]\n\nProof. For the unit \\( \\eta_X : X \\to (X \\to \\mathbb{L})^* \\) and \\( x, x' \\in X \\) we have directly:\n\n\\[\n\\eta_X(x)(x') = (\\tau_X^{-1} \\cdot \\nu_X(x))(x') = \\bigsqcup_{\\ell \\in \\mathcal{J}(\\mathbb{L})} \\ell \\quad \\text{if } x \\leq x'\n\\]\n\n\\[\n= \\left\\{ \\begin{array}{ll}\n\\bigsqcup_{\\ell \\in \\mathcal{J}(\\mathbb{L})} \\ell & \\text{if } x \\leq x' \\\\\n\\emptyset & \\text{otherwise}\n\\end{array} \\right. = \\left\\{ \\begin{array}{ll}\n\\top & \\text{if } x \\leq x' \\\\\n\\bot & \\text{otherwise}\n\\end{array} \\right.\n\\]\n\nBefore characterising \\( \\mu \\), we first prove that for all \\( h \\in ((X \\to \\mathbb{L})^* \\to \\mathbb{L})^* \\) and \\( x \\in X \\),\n\n\\[\n\\ell \\leq \\bigsqcup_{b \\in (X \\to \\mathbb{L})^*} h(b) \\sqcap b(x) \\iff \\ell \\leq \\tau_{TX} h(x)(\\ell)(x) \\quad \\text{for all } \\ell \\in \\mathcal{J}(\\mathbb{L}).\n\\]\n\n\\((\\Rightarrow)\\) Note that for any \\( L \\subseteq \\mathbb{L} \\), if \\( \\ell \\leq \\bigsqcup_{b \\in (X \\to \\mathbb{L})^*} h(b) \\sqcap b(x) \\), then \\( \\ell \\sqcup L = \\bigsqcup_{b \\in L} \\ell \\sqcup b(x) \\) (using JID), and since \\( \\ell \\) is join-irreducible, there is some \\( \\ell' \\in L \\) with \\( \\ell \\leq \\ell' \\). Hence for the current assumption, there is some \\( b \\in (X \\to \\mathbb{L})^* \\) with \\( \\ell \\leq h(b) \\sqcap b(x) \\). Since in particular \\( \\ell \\leq h(b) \\), we have \\( \\tau_{TX}(h)(\\ell) \\leq \\tau_{TX} b \\) by (4.3) and finally \\( \\ell \\leq \\bigsqcup_{b \\in (X \\to \\mathbb{L})^*} h(b) \\sqcup b(x) \\) by the definition of \\( \\leq_{TX} \\).\n\n\\((\\Leftarrow)\\) For \\( b := \\tau_{TX}(h)(\\ell) = \\min \\{ c \\in TX \\mid \\ell \\leq h(c) \\} \\) we have \\( \\ell \\leq h(b) \\) by the definition of \\( \\tau \\) and \\( \\ell \\leq b(x) \\) by the current assumption; hence \\( \\ell \\leq h(b) \\sqcap b(x) \\).\nNow for \\( h \\in TTX, x \\in X, \\mu_X : ((X \\to \\mathbb{L})^* \\to \\mathbb{L})^* \\to (X \\to \\mathbb{L})^* \\) is characterised as desired:\n\n\\[\n\\begin{align*}\n(\\mu_X(h))(x) &= ((\\tau^{-1}_X \\cdot \\zeta_X \\cdot (\\tau \\cdot \\tau X)(h))(x) \\\\\n&= (\\tau^{-1}_X \\cdot \\zeta_X \\cdot \\tau_{TX})(h))((x) \\\\\n&\\overset{\\text{Def}}{=} \\bigsqcup \\{ \\ell \\in J(\\mathbb{L}) \\mid (\\zeta_X \\cdot \\tau_{TX} J(\\mathbb{L}))((x)) \\leq_X \\}\n\\end{align*}\n\\]\n\n\\[\n\\overset{(4.3)}{=} \\bigsqcup \\{ \\ell \\in J(\\mathbb{L}) \\mid \\ell \\leq \\tau_{TX}(h(x)) \\}\n\\]\n\n\\[\n\\overset{(4.6)}{=} \\bigsqcup \\{ \\ell \\in J(\\mathbb{L}) \\mid \\ell \\leq \\tau_{TX}(h(x)) \\} = \\bigsqcup \\{ b \\in TX \\mid h(b) \\cap b(x) \\}. \n\\]\n\nIt is a standard exercise to see that there is a one-to-one correspondence between monad morphisms and functors between their Kleisli categories [Mog89, Prop. 4.0.10]. So \\( \\tau \\) induces an isomorphism between categories \\( \\text{Kl}(T) \\cong \\text{Kl}(J(\\mathbb{L})) \\), defined as\n\n\\[\n(f : X \\to TY) \\mapsto (a_X \\cdot f : X \\to Y^\\Phi).\n\\]\n\nNow when fixing a finite partially ordered set \\( \\Phi \\) and putting \\( \\mathbb{L} := O(\\Phi) \\), Birkhoff’s theorem (cf. Theorem 3.10) provides \\( \\Phi \\cong J(\\mathbb{L}) \\) and so \\( T \\cong J(\\mathbb{L}) \\cong \\Phi \\).\n\n5. Modelling Conditional Transition Systems as Coalgebras\n\nRecall that once a condition is fixed by a CTS then it behaves like a traditional transition system (until another upgrade). Thus, it is natural to consider the powerset functor to model the set of successor states when the upgrade order is discrete. This way of modelling CTS adapts the approach in [ABH+12], where the set of actions \\( A \\) was fixed to be singleton.\n\n**Definition 5.1.** The powerset functor \\( \\mathcal{P} \\) on \\( \\text{Poset} \\) maps posets \\((X, \\leq_X)\\) to \\((PX, \\subseteq)\\), the subsets of \\( X \\) ordered by inclusion. For \\( f : X \\to Y, \\mathcal{P}f(S) = f[S] \\) is the forward image.\n\n**Remark 5.2.** In other words, \\( \\mathcal{P} \\) on \\( \\text{Poset} \\) is the composition of the forgetful functor \\( \\text{Poset} \\to \\text{Set} \\) with the ordinary powerset \\( \\text{Set} \\to \\text{Poset} \\). Sometimes, the dual functor \\( \\mathcal{D} : \\text{Poset} \\cong \\text{Poset} \\) is required which sends each poset \\((X, \\leq_X)\\) to its dual \\((X, \\geq_X)\\). Then, the composition \\( \\mathcal{D}\\mathcal{P}(X, \\leq_X) \\) contains the subsets of \\( X \\) ordered by inverse inclusion.\n\nNext, we define two functors \\( H : \\text{Poset} \\to \\text{Poset} \\) – based on \\( \\mathcal{P} \\) – for modelling CTS as coalgebras for the extension of \\( H \\) to the Kleisli category \\( \\text{Kl}(\\Phi) \\). The first one closely follows the concrete Definition 3.1 with the reversed inclusion order. However, it turns out that this functor can not be extended to the Kleisli category for non-discrete \\( \\Phi \\) (cf. Example 5.8). Hence, we also consider a second functor, which not only records all the successors for a given condition \\( \\varphi \\), but also all possible successors for conditions \\( \\varphi' \\leq \\varphi \\) via pairs of the form \\((x, \\varphi)\\). In order to faithfully model CTSs, we here need to consider the usual inclusion order (if a condition is larger we have more potential upgrades).\n\n**Remark 5.3.** A CTS \\((X, A, \\Phi, f)\\) defines the following Kleisli morphisms:\n\n1. Considering the sets \\( X \\) and \\( A \\) as discrete posets \\((X, =)\\) and \\((A, =)\\), the map \\( f : X \\times A \\to \\text{Poset}(\\Phi, \\mathcal{D}\\mathcal{P}X) \\) is a morphism\n\n\\[\nf : X \\times A \\to (\\mathcal{D}\\mathcal{P}X)\\Phi \\quad \\text{in} \\ \\text{Poset}.\n\\]\nUp to exponential laws, this corresponds to\n\\[ \\alpha : X \\longrightarrow ((DPX)^A)\\Phi \\]\nin Poset,\nin other words a Kleisli morphism\n\\[ \\alpha : X \\rightarrowto (DPX)^A \\]\nin Kl(\\Phi).\nHowever, this is not necessarily a coalgebra, since we do not have an endofunctor on Kl(\\Phi) yet. In the following, an extension of DP(\\_)^A is provided for discrete \\( \\Phi \\).\nFurthermore, it is shown that there is no meaningful extension for non-discrete \\( \\Phi \\).\nFor discrete \\( \\Phi \\), the order does not make a difference, so we can model CTS as P-coalgebras\n\\[ \\alpha : X \\rightarrowto (PX)^A \\]\nin Kl(\\_ \\Phi) for discrete \\( \\Phi \\).\n\n(2) Another way is to encode the possible upgrades explicitly in the morphism. Therefore, define the monotone map \\( \\alpha : X \\rightarrowto (P(X \\times \\_\\Phi)^A)^\\Phi \\) directly by\n\\[ \\alpha(x)(\\varphi)(a) = \\{(x', \\varphi') \\mid x \\xrightarrow{a, \\varphi'} x' \\land \\varphi' \\leq \\varphi\\}. \\]\nBy the discreteness of \\( X \\) and \\( A \\), \\( \\alpha \\) is trivially monotone in \\( x \\) and \\( a \\).\nFor \\( \\psi \\leq \\varphi \\),\n\\[ (x', \\varphi') \\in \\alpha(x)(\\psi)(a) \\Rightarrow x \\xrightarrow{a, \\varphi'} x' \\text{ and } \\varphi' \\leq \\psi \\]\n\\[ \\Rightarrow x \\xrightarrow{a, \\varphi'} x' \\text{ and } \\varphi' \\leq \\psi \\Rightarrow (x', \\varphi') \\in \\alpha(x)(\\varphi)(a) \\]\nso \\( \\alpha \\) is monotone in \\( \\varphi \\).\nAs for the previous functor, we can read (5.2) as a Kleisli arrow\n\\[ \\alpha : X \\rightarrowto P(X \\times \\_\\Phi)^A \\]\nwhich is a coalgebra as soon as an extension of \\( P(\\_ \\times \\_\\Phi)^A \\) to Kl(\\_ \\Phi) is provided.\n\n5.1. Functor Extensions. Independently from Poset, functor extensions to the Kleisli category of the reader monad are of special shape: it is just a tensorial fixing of one parameter that fulfills two axioms (cf. Lemma 5.4). Actually, we state our characterisation in a even higher generality by recognising that the monad structure on an endofunctor \\( T \\) is induced by a comonad \\( L \\) when \\( L \\dashv T \\) (cf. Proposition 2.5). Notice that this is already the case in our concrete situation \\( \\_ \\times \\Phi \\dashv \\_ \\Phi \\) (cf. Definition 2.6). This characterisation is afterwards used to extend the two functors for CTS to Kl(\\_ \\Phi).\n\n**Lemma 5.4.** Recall from Proposition 2.5 that a comonad \\((L, \\theta, \\delta)\\) induces a monad \\((T, \\eta, \\mu)\\) when \\( L \\dashv T \\) with the unit and the counit of adjunctions as \\( \\rho \\) and \\( \\epsilon \\), respectively. Then, there is a one-to-one correspondence between distributive laws \\( \\lambda : HT \\rightarrow TH \\) and comonad-over-functor distributive laws \\( \\Lambda : LH \\rightarrow HL \\).\n\n**Proof.** The Kleisli category Kl(\\( T \\)) is isomorphic to the co-Kleisli category coKl(\\( L \\)) of \\( L \\):\n\\[ Kl(T)(X, Y) \\cong C(X, TY) \\cong C(LX, Y) \\cong coKl(T)(X, Y) \\]\nSo we have a one to one correspondence between extensions \\( \\hat{H} \\) of \\( H \\) to Kl(\\( T \\)) and extensions \\( \\tilde{H} \\) of \\( H \\) to coKl(\\( L \\)):\n\n\\[ Kl(T) \\xrightarrow{\\hat{H}} Kl(T) \\quad \\text{coKl}(L) \\xrightarrow{\\tilde{H}} \\text{coKl}(L) \\]\n\\[ C \\xrightarrow{H} C \\quad C \\xrightarrow{H} C \\]\n\\[ i \\uparrow \\quad \\text{iff} \\quad i \\uparrow \\]\n\n\\[ i \\uparrow \\quad i \\uparrow \\]\nwhere $\\tilde{I}(f : X \\to Y) = f \\cdot \\vartheta : LX \\to Y$ is just the uncurrying of $I(f)$. Recall from Theorem 2.10 that such extensions $\\tilde{H}$ are in one-to-one correspondence to distributive laws of $H$ over the monad $T$, and dually are such extensions $\\tilde{H}$ in one-to-one correspondence to distributive laws $\\Lambda : LH \\to HL$.\n\n**Remark 5.5.** Concretely, $\\Lambda$ defines a distributive law $\\lambda$ by composition\n\n$$\\lambda_X := \\left( HTX \\xrightarrow{\\Lambda_X} TTHLX \\xrightarrow{TH\\epsilon X} THX \\right).$$\n\nThe functor extension $\\hat{\\epsilon} : Kl(T) \\to Kl(T)$ then is defined as follows, for an $f : X \\to Y$ and its corresponding $\\hat{f} : LX \\to Y$:\n\n$$\\hat{\\epsilon}(f : X \\to Y) := \\left( HX \\xrightarrow{\\hat{\\Lambda}} TTHLX \\xrightarrow{TH\\hat{f}} THY \\right) \\tag{5.3}$$\n\nWe can now apply this to the comonad $\\_ \\times \\Phi$ and the monad $\\_ \\Phi$ on $Poset$.\n\n**Definition 5.6.** For a discrete poset $\\Phi$, the tensorial strength of $\\mathcal{P}$ on $Set$ defines a family of monotone maps:\n\n$$p_X : PX \\times \\Phi \\to \\mathcal{P}(X \\times \\Phi), \\quad p_X(C, \\varphi) = \\{(x, \\varphi) \\mid x \\in C\\}$$\n\nBy the naturality in $Set$, $p$ is a natural transformation in $Poset$. And since $\\Phi$ is discrete, $p$ is monotone in $\\Phi$.\n\n**Lemma 5.7.** The above $p$ is a distributive law of the comonad $\\_ \\times \\Phi$ over $\\mathcal{P}$.\n\n**Proof.** The counit $\\pi_1$ of $\\_ \\times \\Phi$ is preserved by $p$, because\n\n$$\\mathcal{P}(\\pi_1(p_X(C, \\varphi))) = \\mathcal{P}(\\pi_1(\\{(x, \\varphi) \\mid x \\in C\\})) = C = \\pi(C, \\varphi).$$\n\nThe comultiplication $\\delta = \\text{id} \\times \\Delta_{\\Phi}$ of $\\_ \\times \\Phi$ is preserved by $p$, because\n\n$$p_{X \\times \\Phi}((p_X \\times \\Phi)(\\delta_X(C, \\varphi))) = p_{X \\times \\Phi}(p_X \\times \\Phi(C, \\varphi)) = p_X \\times \\Phi(\\{(x, \\varphi) \\mid x \\in C\\}, \\varphi) = \\{(x, \\varphi, \\varphi) \\mid x \\in C\\} = \\mathcal{P}(\\delta_X(\\{(x, \\varphi) \\mid x \\in C\\})) = \\mathcal{P}(\\delta_X(p_X(C, \\varphi))),$$\n\nNow to model CTS with action labels (the case when $|A| > 1$) we use a distributive law between the functor $\\_A$ and $\\_\\Phi$. Recall from [AHS90, Prop 27.8(1)], that any cartesian closed category has the power law $(\\_\\Phi)^A \\cong (\\_A)^\\Phi$. Any natural isomorphism is a distributive law, and so is $\\iota : (\\_\\Phi)^A \\to (\\_A)^\\Phi$.\n\nWe have now completely defined the functor $\\mathcal{P}^A$ on the Kleisli category. A Kleisli arrow $f : X \\leadsto Y$, i.e., $f : X \\to Y^\\Phi$ is mapped to\n\n$$(\\mathcal{P}X)^A \\xrightarrow{\\mathcal{P}(f)^A} \\mathcal{P}(Y^\\Phi)^A \\xrightarrow{\\lambda_A} (\\mathcal{P}(Y^\\Phi)^A)^{\\mathcal{P}(A)} \\xrightarrow{\\iota_{\\mathcal{P}(A)}} ((\\mathcal{P}Y)^A)^{\\mathcal{P}(A)} \\phi,$$\n\nwhich can again be seen as a Kleisli arrow. As a result, the Kleisli arrow $\\alpha : X \\leadsto \\mathcal{P}(X)^A \\tag{5.1}$ induced by a CTS is indeed a coalgebra on $Kl(\\_\\Phi)$ for discrete $\\Phi$.\n\nIn the case of a non-discrete $\\Phi$, the above $\\bar{p}$ is not defined since $p_X$ is not necessarily order preserving (even for discrete poset $X$). But, more generally, it is not possible to extend $\\mathcal{P}$ to $Kl(\\_\\Phi)$ with the right notion of behavioural equivalence.\n\n**Example 5.8.** Consider the set of conditions $\\Phi = \\{\\varphi, \\varphi'\\}$ with $\\varphi' \\leq \\varphi$ and a singleton set of actions $A = \\{\\ast\\}$. Define the CTS $\\alpha : X \\to (\\mathcal{D}PX)^\\Phi$ on the discrete $X = \\{x_1, x_2\\}$\n\n$$\\alpha : \\begin{array}{cc}\n\\varphi & \\varphi' \\\\\n(x_1) & (x_2) \\\\\n\\end{array}$$\nin equations, $\\alpha(x_2)(\\varphi') = \\{x_2\\}$ and $\\emptyset$ elsewhere. Then for any extension $\\widehat{\\mathcal{DP}} : \\text{KL}(\\_ \\Phi) \\to \\text{KL}(\\_ \\Phi)$ of $\\mathcal{DP}$, $x_1$ and $x_2$ are identified in $\\varphi$ by a $\\widehat{\\mathcal{DP}}$-coalgebra homomorphism, even though they are not conditionally bisimilar in $\\varphi$.\n\n**Proof.** Note that $x_1$ and $x_2$ are not bisimilar under $\\varphi'$, because $x_1$ can do a step whereas $x_2$ cannot. So there is no bisimulation $R_{\\varphi'}$ relating $x_1$ and $x_2$ in $\\varphi'$. Consequently, there is no conditional bisimulation with $(x_1, x_2) \\in R_{\\varphi}$, since $R_{\\varphi} \\subseteq R_{\\varphi'}$. However, we can identify $x_1$ and $x_2$ in $\\varphi$ by a $\\widehat{\\mathcal{DP}}$-coalgebra homomorphism $h : (X, \\alpha) \\rightarrow (Y, \\beta)$, where $Y = \\{y_1, y_2\\}$. Hence another functor, namely $\\nu_{\\mathcal{DP}Y_{\\Phi}}$.\n\nWe know that $\\nu_{\\mathcal{DP}Y_{\\Phi}} = \\emptyset$, and since $\\nu_Y$ preserves the unit $\\nu_Y$, \\[ \\lambda_Y(\\emptyset) = \\lambda_Y(\\mathcal{DP} \\nu_Y(\\emptyset)) = \\nu_{\\mathcal{DP}Y_{\\Phi}}(\\emptyset) \\]\nand so we have in total that $\\widehat{\\mathcal{DP}}h(\\emptyset) = \\mathcal{DP}h(\\emptyset)$. Hence, $h$ is indeed a homomorphism:\n\n\\[\n\\begin{array}{c}\n\\xymatrix{\n\\begin{array}{c} x_1 \\ar[r]^-{\\alpha} & \\emptyset \\\\\ny_1 \\ar[u]^{h} \\ar[r]_-{\\beta} & \\emptyset \n\\end{array} & \\begin{array}{c} x_2 \\ar[r]^-{\\alpha} & \\emptyset \\\\\ny_1 \\ar[u]^{h} \\ar[r]_-{\\beta} & \\emptyset \n\\end{array} & \\begin{array}{c} x_2 \\ar[r]^-{\\alpha'} & \\emptyset \\\\\ny_1 \\ar[u]^{h} \\ar[r]_-{\\beta'} & \\emptyset \n\\end{array}\n\\end{array}\n\\]\n\nHence another functor, namely $\\mathcal{V} = \\mathcal{P}(\\_ \\times \\Phi)$, is necessary to model upgrades:\n\n**Proposition 5.9.** The Poset-functor $\\mathcal{P}(\\_ \\times \\Phi)$ extends to $\\text{KL}(\\_ \\Phi)$ using the comonad distributive law:\n\n\\[\n\\Lambda_X : \\mathcal{P}(X \\times \\Phi) \\times \\Phi \\xrightarrow{\\pi_1} \\mathcal{P}(X \\times \\Phi) \\xrightarrow{\\mathcal{P}(\\text{id}_X \\times \\Delta_\\Phi)} \\mathcal{P}(X \\times \\Phi \\times \\Phi)\n\\] \n\n(5.4)\n\nThe corresponding distributive law by Lemma 5.4 is\n\n\\[\n\\lambda_X : \\mathcal{P}(X^\\Phi \\times \\Phi) \\xrightarrow{\\mathcal{P}(\\text{id}_X \\times \\Delta_\\Phi)} \\mathcal{P}(X \\times \\Phi) \\xrightarrow{\\nu_{\\_ \\Phi}} \\mathcal{P}(X \\times \\Phi)^\\Phi\n\\]\n\n**Proof.** The counit $\\pi_1$ of $\\_ \\times \\Phi$ is preserved by $\\Lambda$, i.e. $\\mathcal{P}(\\pi_1 \\times \\Phi) \\cdot \\Lambda = \\pi_1$, because $\\mathcal{P}(\\pi_1 \\times \\Phi) \\cdot \\mathcal{P}(\\text{id}_X \\times \\Delta_\\Phi) = \\mathcal{P}(\\text{id}_X \\times \\text{id}_\\Phi)$\n\nThe comultiplication $\\delta_X = X \\times \\Delta_X$ of $\\_ \\times \\Phi$ is preserved because $\\Lambda_X = \\mathcal{P}(\\delta_X) \\cdot \\pi_1$, of course $\\mathcal{P}(\\delta_X \\times \\Phi) \\cdot \\mathcal{P}(\\delta_X) = \\mathcal{P}(\\delta_X \\times \\Phi) \\cdot \\mathcal{P}(\\delta_X)$, and precomposing this with $\\pi_1$ and using naturality we have that $\\Lambda$ preserves $\\delta$. \\qed\nMoreover, this extension can be composed with $\\phi^A \\simeq (\\phi^A)^\\Phi$ to obtain an extension of $P(\\Phi \\times \\Phi)^A$. So $\\alpha : X \\to P(X \\times \\Phi)^A$ from (5.2) indeed defines a coalgebra on $Kl(\\Phi)$.\n\n**Remark 5.10.** The $Kl(\\Phi)$-extension $\\hat{\\nu}$ of the Poset-functor $P(\\Phi \\times \\Phi)^A$ has the explicit form: for an arrow $f : X \\to Y$ in $Kl(\\Phi)$, $\\hat{\\nu}f : (P(X \\times \\Phi))^A \\to (P(Y \\times \\Phi))^A$ is a function $\\hat{\\nu}f : (P(X \\times \\Phi))^A \\to ((P(Y \\times \\Phi))^A)^\\Phi$, where\n\n$$\\hat{\\nu}f(p)(\\varphi)(a) = \\{(f(x)(\\varphi'), \\varphi') \\mid (x, \\varphi') \\in p(a)\\},$$\n\nfor all $p \\in (P(X \\times \\Phi))^A$, $\\varphi \\in \\Phi$ and $a \\in A$.\n\n### 5.2. Coalgebraic Behavioural Equivalence\n\nHaving defined coalgebras of interests on the Kleisli category $Kl(\\Phi)$, our next motive is to characterise conditional bisimilarity using the notion of behavioural equivalence in $Kl(\\Phi)$. To this end, we first define a coalgebraic generalisation of conditional bisimilarity (Definition 3.2), requiring additional structure on a general functor $H : \\text{Poset} \\to \\text{Poset}$, and then prove that this notion coincides with the coalgebraic behavioural equivalence of coalgebras on $Kl(\\Phi)$.\n\n**Definition 5.11** (constant map). For a poset $X$, there is a unique monotone map $! : X \\to 1$, the final morphism. Also note that for any element $x \\in X$, one has a monotone map $x : 1 \\to X$, mapping the only element in 1 to $x \\in X$. The composition of the above two maps $! : X \\to X$ is the constant map sending any element of $X$ to $x$.\n\n**Remark 5.12.** Recall that a family of morphisms $(f_i : Y \\to Z_i)_{i \\in I}$ is jointly monic, if for morphisms $g, h : X \\to Y$ with $f_i \\cdot g = f_i \\cdot h$ for all $i \\in I$ we have $g = h$. If the category has products, such a family is jointly monic iff $(f_i)_{i \\in I} : Y \\to \\prod_{i \\in I} Z_i$ is monic. For instance, the limit projections form a jointly-monotone family.\n\nFor a Kleisli arrow $f : X \\to Y$ and a condition $\\varphi \\in \\Phi$, recall the notation $f_\\varphi : X \\to Y$, $f_\\varphi(x) = f(x)(\\varphi)$. This simplifies Kleisli composition in the following arguments because\n\n$$(g \\circ f)_\\varphi = g_\\varphi \\cdot f_\\varphi \\quad \\text{for any} \\ f : X \\to Y, \\ g : Y \\to Z.$$\n\n**Definition 5.13.** For a functor $H : \\text{Poset} \\to \\text{Poset}$ with an extension $\\hat{H} : Kl(\\Phi) \\to Kl(\\Phi)$, a version filter is a $\\Phi$-indexed family of natural transformations $(|_X^\\varphi : \\hat{H} \\to \\hat{H})_{\\varphi \\in \\Phi}$ such that for every $\\varphi \\in \\Phi$ the following restriction holds:\n\n$$\\hat{H} X \\xrightarrow{|_X^\\varphi} \\hat{H} (X \\times \\Phi) \\quad \\text{and} \\quad (|_X^\\psi \\circ \\hat{H} X \\to \\hat{H} X)_{\\psi \\in \\Phi} \\text{ jointly monic. (5.5)}$$\n\nRecall that $\\hat{id}_X \\times \\hat{id}_\\Phi : X \\to X \\times \\Phi$ is just the curried version of $\\hat{id}_X \\times \\hat{id}_\\Phi$.\n\nHowever, it should be noted that $|_X^\\varphi$ is not required to be monotone in $\\varphi$. In the second of our main examples, $|_X^\\varphi$ is neither monotone nor antitone in $\\varphi$.\n\nIntuitively, the first part of (5.5) says that each map $|_X^\\varphi$ filters those elements from $\\hat{H} X$ that are associated with the version $\\varphi \\in \\Phi$. For instance, $\\hat{C} \\in P(X \\times \\Phi)$ can contain tuples $(x, \\psi)$ holding an arbitrary versions $\\psi \\in \\Phi$, but after filtering by $|_X^\\varphi : P(X \\times \\Phi) \\to P(X \\times \\Phi)$ only those terms with $\\psi = \\varphi$ remain. The second part of (5.5) expresses that each set of behaviours $b \\in H X$ is fully determined by the restrictions to all possible versions. Here, it\nis not enough to require that the \\((|\\psi\\rangle)_X\\) are jointly monic in \\(\\text{Kl}(\\_\\Phi)\\), because there are monos \\(m : X \\to Y\\) in \\(\\text{Kl}(\\_\\Phi)\\) and \\(\\varphi \\in \\Phi\\) s.t. \\(m_\\varphi\\) is not monic.\\(^1\\)\n\n**Proposition 5.14.** For an extension \\(\\hat{H} : \\text{Kl}(T) \\to \\text{Kl}(T)\\) of \\(H\\), a family of morphisms \\(\\rho_X : HX \\to HTX\\) is a natural transformation \\(\\rho : \\hat{H} \\to \\hat{H}\\) iff \\(\\rho_X\\) is natural in \\(X\\) with:\n\n\\[\n\\begin{array}{ccl}\nHTX & \\xrightarrow{\\hat{H} \\rho_X} & HTX \\\\\n\\downarrow{\\rho_X} & & \\downarrow{\\rho_X} \\\\\nHX & \\xrightarrow{\\rho_X} & HX\n\\end{array}\n\\] (5.6)\n\nwhere \\(\\text{id}_{TX}\\) is considered as \\(\\text{id}_{TX} : TX \\to X\\).\n\nNote that \\(\\hat{H}\\text{id}_{TX} : HTX \\to THX\\) is the corresponding distributive law w.r.t. Theorem 2.10.\n\n**Proof.**\n\n\\((\\Rightarrow)\\) Assume \\(\\rho_X : \\hat{H}X \\to \\hat{H}X\\) is natural in \\(X\\). Then (5.6) is just the naturality square for \\(\\text{id}_{TX} : TX \\to X\\). For any pure \\(f : X \\to Y\\), the extension \\(\\hat{H}\\) ensures \\(\\hat{H}If = IF\\), and so we have\n\n\\[THf \\cdot \\rho_X = IF \\circ \\rho_X = \\rho_Y \\circ IF = \\rho_Y \\cdot f,\\]\n\ni.e. \\(\\rho_X : HX \\to THX\\) is natural in \\(X\\).\n\n\\((\\Leftarrow)\\) For \\(f : X \\to Y\\), \\(\\hat{H}f\\) can be rewritten as\n\n\\[\\hat{H}f = \\hat{H}(\\text{id}_{TY} \\cdot f) = \\hat{H}(\\text{id}_{TY} \\circ IF) = \\hat{H}\\text{id}_{TY} \\circ IIf = \\hat{H}\\text{id}_{TY} \\circ IF\\]\n\nUsing that \\(\\rho_X : HX \\to THX\\) is natural in \\(X\\), we have\n\n\\[\\rho_Y \\circ \\hat{H}f = \\rho_Y \\circ \\hat{H}\\text{id}_{TY} \\circ IIf \\overset{(5.6)}{=} \\hat{H}\\text{id}_{TY} \\circ \\rho_X \\circ IIf = \\hat{H}\\text{id}_{TY} \\circ (\\rho_X \\cdot Hf)\\]\n\n\\[\\text{Naturality} \\Rightarrow \\hat{H}\\text{id}_{TY} \\circ (THf \\cdot \\rho_X) = \\hat{H}\\text{id}_{TY} \\circ IF \\circ \\rho_X = \\hat{H}f \\circ \\rho_X \\]\n\n\\(\\square\\)\n\n**Example 5.15.**\n\n1. For the standard powerset functor \\(\\mathcal{P}(\\_\\Phi)\\), define \\(|\\varphi\\rangle_X : \\mathcal{P}X \\to \\mathcal{P}X\\)\n\n\\[\n(|\\varphi\\rangle_X)(C) = \\begin{cases} \nC & \\text{if } \\varphi = \\psi \\\\\n\\emptyset & \\text{otherwise.}\n\\end{cases}\n\\]\n\nThis is natural in \\(X\\) because for \\(f : X \\to Y^\\Phi\\) we have\n\n\\[\\langle \\hat{H}f \\rangle \\cdot |\\varphi\\rangle_X(C) = \\langle \\hat{H}f \\rangle(C)(\\psi) = (|\\varphi\\rangle_X)(C) = |\\psi\\rangle_X \\cdot (\\hat{H}f)(C)\\]\n\nif \\(\\psi = \\varphi\\)\n\n\\[\\langle \\hat{H}f \\rangle \\cdot |\\varphi\\rangle_X(C) = \\langle \\hat{H}f \\rangle(\\emptyset)(\\psi) = \\emptyset = (|\\varphi\\rangle_X)(C) = |\\varphi\\rangle_X \\cdot (\\hat{H}f)(C)\\]\n\nif \\(\\psi \\neq \\varphi\\)\n\nThe first axiom of (5.5) evaluated for \\(\\psi \\in \\Phi\\) can be checked by case distinction on \\(\\psi = \\varphi\\). If \\(\\psi \\neq \\varphi\\), then \\((\\hat{H}\\text{id}_{X \\times \\Phi}) \\cdot (|\\varphi\\rangle_X)\\) is constantly \\(\\emptyset\\), and so is the other part of the diagram. If \\(\\psi = \\varphi\\) then the diagram (5.5) commutes by definition of \\(\\hat{H}\\):\n\n\\[\\langle \\hat{H}\\text{id}_{X \\times \\Phi} \\rangle \\cdot |\\varphi\\rangle_X(C) = \\langle \\hat{H}\\text{id}_{X \\times \\Phi} \\rangle \\cdot (|\\varphi\\rangle_X)(C) = \\{(x, \\varphi) \\mid x \\in C\\} = H(\\text{id}_X, \\varphi)!\\]\n\nThe family \\((|\\varphi\\rangle_X)_{\\psi \\in \\Phi}\\) is jointly monic, because already \\(|\\varphi\\rangle_X\\) is monic.\n\n\\(^1\\)For instance for \\(\\Phi = \\{\\varphi' \\leq \\varphi\\}\\), \\(m : 2 \\to 2\\_\\) is monic, where \\(2 = \\{0, 1\\}\\) is discrete and \\(2\\_ = \\{0, 1, \\_\\}\\) is 2 with a bottom element; define \\(m_\\varphi = \\text{id}_2, m_{\\varphi'} = \\_\\!).\n(2) Since the previous filter is defined for an extension for discrete \\( \\Phi \\), the previous filter function also is a filter for \\( \\mathcal{DP} \\).\n\n(3) For \\( \\mathcal{P}(\\_ \\times \\Phi) \\), first define the family of natural transformations \\( r^\\psi : \\mathcal{P}(\\_ \\times \\Phi) \\to \\mathcal{P}(\\_ \\times \\Phi) \\)\n\n\\[\nr^\\psi_X(C) = \\{(x, \\varphi') \\in C \\mid \\varphi' = \\varphi\\}\n\\]\n\nand then \\( |^\\psi := \\nu \\cdot r^\\psi \\). That is, the version filter is pure, just like the distributive law for this functor (Prop. 5.9). For \\( f : X \\times \\Phi \\to Y \\)\nwe have\n\n\\[\n|f| \\cdot \\mathcal{P}((f, \\pi_2))(C) = \\{(y, \\varphi') \\in \\mathcal{P}((f, \\pi_2))(C) \\mid \\varphi' = \\varphi\\}\n\\]\n\n\\[\n= \\left\\{(f(x, \\varphi'), \\varphi') \\mid (x, \\varphi') \\in C \\land \\varphi' = \\varphi\\right\\}\n\\]\n\n\\[\n= \\mathcal{P}((f, \\pi_2))\\{(x, \\varphi') \\in C \\mid \\varphi' = \\varphi\\} = \\mathcal{P}((f, \\pi_2)) \\cdot r^\\psi_X(C).\n\\]\n\nSo in particular \\( r^\\psi \\) is natural in \\( X \\) and \\( r^\\psi_X : \\mathcal{P}(\\text{ev}_X, \\text{id}_\\Phi) = \\mathcal{P}(\\text{ev}_X, \\text{id}_\\Phi) \\cdot r^\\psi_X \\). Hence, \\( |^\\psi : \\mathcal{P}(\\_ \\times \\Phi) \\to \\mathcal{P}(\\_ \\times \\Phi) \\) is natural. For the axioms (5.5), we have for all \\( h : \\Phi \\to \\Phi \\)\n\n\\[\n(\\tilde{H} \\cdot \\text{id}_X \\cdot h)_B \\cdot (|^\\psi)|_X(C) = H(\\text{id}_X \\times h) \\cdot (\\tilde{A}_X) \\cdot r^\\psi_X(C)\n\\]\n\n(5) For \\( \\forall X = \\mathcal{P}(X \\times \\Phi)^A \\) apply the previous filter component-wise, i.e. \\( (|^\\psi|)_A \\). When considering a CTS as a coalgebra for \\( \\mathcal{P}(\\_ \\times \\Phi) \\) (5.2), the filter recovers the structure of the underlying transition system for a version \\( \\varphi \\in \\Phi \\) as follows:\n\n\\[\n|^\\psi_X \\cdot \\alpha_{\\varphi}(x)(a) = \\{(x', \\varphi) \\mid x \\xrightarrow{\\varphi,a} x'\\}.\n\\]\n\nDefinition 5.16 (Coequaliser). Recall that for a parallel pair of morphisms \\( f, g : D \\rightrightarrows X \\), the coequaliser of \\( f \\) and \\( g \\) is a morphism \\( e : X \\to Y \\) such that\n\n(1) \\( e \\) merges \\( f \\) and \\( g \\), i.e., \\( e \\cdot f = e \\cdot g \\).\n\n(2) \\( e \\) is the least such morphism, i.e., for any \\( e' : X \\to Y \\) with \\( e' \\cdot f = e' \\cdot g \\), there is a unique \\( u : Y \\to Y' \\) with \\( e' = u \\cdot e \\) as indicated in the following diagram.\n\n\n\nA morphism is called a **regular epimorphism** if it is the coequaliser for a pair of morphisms. In \\( \\textbf{Set} \\) and in preorders, \\( Y \\) is the quotient of \\( X \\) by the reflexive, symmetric, transitive closure of the relation \\( \\{(f(d), g(d)) \\mid d \\in D\\} \\). In \\( \\textbf{Poset} \\), the first step is to construct \\( Y \\) as in preorders, and in a second step, additional elements are identified due to antisymmetry.\nNotation 5.17. Instead of writing a relation \\( E \\subseteq X \\times X \\), we consider its projections \\( \\pi_1, \\pi_2 : E \\Rightarrow X \\) as morphisms, usually by writing a relation as \\( E \\Rightarrow X \\). Then the quotient of \\( X \\) by \\( E \\), denoted by \\( X/E \\), is the coequaliser of the projections \\( E \\Rightarrow X \\). If \\( E \\) is already an equivalence relation, then this is the usual quotient (with additionally identified elements due to antisymmetry in \\( \\text{Poset} \\)).\n\nNext, we lift the notion of conditional bisimulation to the level of coalgebras over the base category \\( \\text{Poset} \\). As a result, one can reason with conditional bisimilarity for any systems whose behavioural functor \\( \\tilde{H} : \\text{Kl}(\\_^\\Phi) \\Rightarrow \\text{Kl}(\\_^\\Phi) \\) comes with a notion of version filter \\( |\\psi| \\).\n\nDefinition 5.18. Given a coalgebra \\( \\alpha : X \\Rightarrow HX^\\Phi \\) for a functor with a version filter.\n\n1. a conditional bisimulation for \\( \\alpha \\) is a \\( \\Phi \\)-indexed family of relations \\( R_\\varphi \\Rightarrow X \\) such that\n (a) \\( \\varphi' \\leq \\varphi \\) implies \\( R_\\varphi' \\supseteq R_\\varphi \\),\n (b) \\( R_\\varphi \\) is a bisimulation for the \\( H \\)-coalgebra \\((|X^\\varphi|)_\\varphi \\cdot \\alpha \\).\n\n2. a conditional congruence is a \\( \\Phi \\)-indexed family of relations \\( R_\\varphi \\Rightarrow X \\) such that\n (a) \\( \\varphi' \\leq \\varphi \\) implies \\( R_\\varphi' \\supseteq R_\\varphi \\),\n (b) the projections \\( R_\\varphi \\Rightarrow X \\) are made equal by the morphism:\n\n\\[\nX \\xrightarrow{\\alpha_\\varphi} HX \\xrightarrow{|X^\\varphi|_\\varphi} HX \\xrightarrow{H\\kappa_\\varphi} HX/R_\\varphi,\n\\]\n\nwhere \\( \\kappa_\\varphi \\) is the coequaliser of the parallel arrows \\( R_\\varphi \\Rightarrow X \\).\n\nJust like in the traditional coalgebraic setup, the notions conditional congruence and conditional bisimulation coincide if the underlying endofunctor \\( H \\) preserves weak pullbacks. This is the case for both \\( \\mathcal{P}(\\_)^A \\) and \\( \\mathcal{P}(\\_ \\times \\Phi)^A \\). Furthermore, it should be noted that the above notion of conditional bisimilarity for both the cases \\( \\mathcal{P}(\\_)^A \\) and \\( \\mathcal{P}(\\_ \\times \\Phi)^A \\) coincides with the concrete definition conditional bisimilarity (cf. Definition 3.2).\n\nDefinition 5.19. We say that a \\( \\tilde{H} \\)-coalgebra \\( \\alpha : X \\Rightarrow \\tilde{H}X \\) preserves upgrades if\n\n\\[\n(|X^\\psi \\circ \\alpha|)_\\varphi = (|X^\\psi \\circ \\alpha|)_\\psi \\quad \\text{for all } \\psi \\leq \\varphi \\text{ in } \\Phi\n\\]\n\n(5.7)\n\n\\[\n(|X^\\psi \\circ \\alpha|)_\\varphi \\text{ is constant} \\quad \\text{for all } \\psi \\not\\leq \\varphi \\text{ in } \\Phi.\n\\]\n\n(5.8)\n\nIntuitively, (5.7) says that a state always has the same \\( \\psi \\) successors in a version \\( \\psi \\), no matter whether the state is already in the version \\( \\psi \\) or can upgrade to the version \\( \\psi \\). The second property in (5.8) asserts that the successors of a state in two different version \\( \\psi, \\psi' \\) (which cannot be upgraded from \\( \\varphi \\)) remain the same. In our working examples, we have \\((|X^\\psi \\circ \\alpha|)_\\varphi = \\emptyset = (|X^\\psi \\circ \\alpha|)_\\psi\\) for any \\( \\psi, \\psi' \\not\\leq \\varphi \\).\n\nExample 5.20. The coalgebras modelling CTS in Remark 5.3 indeed preserve upgrades:\n\n1. For \\( \\mathcal{P}(\\_)^A \\) and discrete \\( \\Phi \\), all coalgebras satisfy the conditions: \\( \\psi \\leq \\varphi \\) in (5.7) boils down to \\( \\psi = \\varphi \\) and (5.7) becomes trivial; similarly, \\( \\psi \\not\\leq \\varphi \\) boils down to \\( \\psi \\neq \\varphi \\), and \\( |X^\\psi \\circ \\alpha| \\cdot \\alpha_\\varphi \\) is constantly \\( \\emptyset \\) by the definition of \\( |\\psi| \\).\n\n2. For the coalgebra modelling a CTS with upgrades\n\n\\[\n\\alpha(x)(\\varphi)(a) = \\{(x', \\varphi') \\mid x \\xrightarrow{\\alpha_\\varphi} x' \\wedge \\varphi' \\leq \\varphi \\}.\n\\]\n\n(5.2)\n\nfor any \\( \\psi, \\varphi \\in \\Phi \\), we have\n\n\\[\n(|X^\\psi \\circ \\alpha_\\varphi|)(a) = \\{(x', \\psi) \\mid x \\xrightarrow{\\alpha_\\psi} x' \\} = (|X^\\psi \\circ \\alpha_\\psi|)(a)\n\\]\n\nif \\( \\psi \\leq \\varphi \\)\n\n\\[\n(|X^\\psi \\circ \\alpha_\\varphi|)(a) = \\emptyset\n\\]\n\nif \\( \\psi \\not\\leq \\varphi \\).\nTheorem 5.22. Let $H : \\text{Poset} \\to \\text{Poset}$ preserve monos and have a version filter. Then for an upgrade preserving $H$-coalgebra $\\alpha : X \\to HX$, states $x_1, x_2 \\in X$ are conditionally congruent in $\\varphi$ iff there is a $H$-coalgebra homomorphism $h$ with $h(x_1)(\\varphi) = h(x_2)(\\varphi)$.\n\nProof.\n\n$(\\Rightarrow)$ Given a conditional behavioural equivalence $(R_\\varphi)_{\\varphi \\in \\Phi}$, define $E \\rightrightarrows X \\times \\Phi$ as the relation\n\n$E := \\{((x_1, \\varphi), (x_2, \\varphi)) \\mid (x_1, x_2) \\in R_\\varphi\\}$\n\nand let $e : X \\times \\Phi \\to Y$ be the coequaliser of the projections of $E$. By definition, $e(x_1, \\varphi) = e(x_2, \\varphi)$ for all $(x_1, x_2) \\in R_\\varphi$. So diagrammatically speaking, the coequaliser\n\\(x/R_\\varphi\\) induces a unique morphism with\n\\[\n\\begin{array}{c}\nX \\xrightarrow{(id_x, \\varphi)} X \\times \\Phi \\\\\n\\kappa_\\varphi \\downarrow \\quad \\downarrow e \\\\\nX/R_\\varphi \\quad \\quad \\quad Y\n\\end{array}\n\\]\nfor all \\(\\varphi \\in \\Phi\\). \\hfill (5.9)\n\nIt remains to show that \\(\\bar{e} : X \\to Y\\) is the carrier of some \\(\\hat{H}\\)-coalgebra homomorphism. The necessary coalgebra structure on \\(Y\\) will be induced by the coequaliser \\(e\\). So fix \\(((x_1, \\varphi), (x_2, \\varphi)) \\in E\\), hence \\(x_1, x_2 \\in R_\\varphi\\) and we have:\n\\[\\begin{align*}\nx_1, x_2 &\\in R_\\psi \\text{ for all } \\psi \\leq \\varphi \\\\\n\\implies &\\quad x_1, x_2 \\text{ are merged by } H\\kappa_\\psi \\circ (|_X^\\psi \\circ \\alpha_\\psi \\text{ for all } \\psi \\leq \\varphi) \\\\\n\\implies &\\quad x_1, x_2 \\text{ are merged by } H\\bar{e}_\\psi \\circ (|_X^\\psi \\circ \\alpha_\\psi \\text{ for all } \\psi \\leq \\varphi) \\\\\n\\implies &\\quad x_1, x_2 \\text{ are merged by } (\\hat{H} \\circ \\alpha_\\varphi \\circ \\alpha_\\varphi) \\\\\n\\end{align*}\\]\nSo, the projections \\(E \\Rightarrow X \\times \\Phi\\) are merged by the uncurried version of the morphism \\(\\hat{H} \\circ \\alpha : X \\to HY\\), i.e., by \\(u(x, \\varphi) := (\\hat{H} \\circ \\alpha_\\varphi)(x)\\). Hence, the coequaliser \\(e\\) induces a unique morphism \\(\\beta : Y \\to HY\\) with:\n\\[\n\\begin{array}{c}\nE \\xrightarrow{\\varepsilon} X \\times \\Phi \\\\\n\\downarrow e \\quad \\quad \\quad \\downarrow u \\\\\nY \\xrightarrow{\\beta} HY \\\\\n\\end{array}\n\\]\n\\[\n\\begin{array}{c}\n\\quad \\\\\n\\xrightarrow{\\varepsilon} \\\\\n\\quad \\\\\n\\xrightarrow{\\hat{H} \\circ \\alpha_\\varphi} \\\\\n\\quad \\\\\n\\xrightarrow{\\hat{H} \\circ \\alpha} \\\\\n\\end{array}\n\\]\n\\[\n\\begin{array}{c}\nX \\xrightarrow{\\alpha} HX \\\\\n\\downarrow \\quad \\downarrow \\delta \\\\\n\\end{array}\n\\]\n\\[\n\\begin{array}{c}\nY \\xrightarrow{\\nu_{HY} \\circ \\beta} HY \\\\\n\\end{array}\n\\]\n\\((\\varepsilon)\\) We prove directly that the family\n\\[\nR_\\varphi := \\{(x_1, x_2) \\in X \\times X \\mid \\text{ there is some } \\hat{H}\\text{-coalgebra } h \\text{ with } h_\\varphi(x_1) = h_\\varphi(x_2)\\}\n\\]\nis a conditional congruence:\n(a) Let \\(\\varphi' \\leq \\varphi\\) and let \\((x_1, x_2) \\in R_\\varphi\\) be witnessed by \\(h : (X, \\alpha) \\to (Y, \\beta)\\). Then \\(x_1, x_2\\) are merged by \\(\\beta_\\varphi \\circ h_\\varphi = (\\hat{H} \\circ \\alpha_\\varphi)\\). Applying Lemma 5.21 first forward, restricting to \\(\\varphi' \\leq \\varphi\\) and then applying Lemma 5.21 backwards again, shows that \\(x_1, x_2\\) are merged by \\((\\hat{H} \\circ \\alpha_\\varphi)\\). Since \\(\\hat{H} \\circ \\alpha = \\beta \\circ h\\), we have the witness for \\((x_1, x_2) \\in R_{\\varphi'}\\).\n(b) Let \\((x_1, x_2) \\in R_\\varphi\\), witnessed by \\(h : (X, \\alpha) \\to (Y, \\beta)\\). So we have \\((p_1, p_2) \\in R_\\varphi\\) for all \\(p_1, p_2\\) with \\(h_\\varphi(p_1) = h_\\varphi(p_2)\\). Then the regular epi part \\(e\\) of \\(h_\\varphi\\) induces a unique \\(u\\) such that:\n\\[\n\\begin{array}{c}\nX \\xrightarrow{e} K \\xrightarrow{m} Y \\\\\n\\kappa_\\varphi \\downarrow \\downarrow u \\\\\nX/R_\\varphi \\quad \\quad \\quad Y\n\\end{array}\n\\]\nDenote the mono part of \\(h_\\varphi\\) by \\(m\\), and so \\(Hm\\) is monic too. Finally:\n\\[\n\\begin{align*}\n(x_1, x_2) &\\in R_\\varphi \\\\\n\\implies x_1, x_2 &\\text{ are merged by } \\beta_\\varphi \\circ h_\\varphi = (\\beta \\circ h)_\\varphi = (\\hat{H} \\circ \\alpha_\\varphi) \\\\\n\\text{Lem. 5.21} &\\implies x_1, x_2 \\text{ are merged by } Hh_\\psi \\circ (|_X^\\psi \\circ \\alpha_\\psi \\text{ for all } \\psi \\leq \\varphi) \\\\\n\\text{\\(Hm\\) monic} &\\implies x_1, x_2 \\text{ are merged by } He \\circ (|_X^\\psi \\circ \\alpha_\\psi \\text{ for all } \\psi \\leq \\varphi) \\\\\n\\kappa_\\varphi \\circ u &\\implies x_1, x_2 \\text{ are merged by } H\\kappa_\\varphi \\circ (|_X^\\psi \\circ \\alpha_\\psi \\text{ for all } \\psi \\leq \\varphi)\n\\end{align*}\n\\]\nNote that both \\( P \\) and \\( P(\\_ \\times \\Phi) \\) preserve monos, i.e. monotone maps with injective carrier, in \\( \\text{Poset} \\). Hence, Theorem 5.22 holds for both functors and so coalgebraic behavioural equivalence coincides with conditional bisimilarity.\n\n6. Computing Behavioural Equivalence\n\nIn this section, we concentrate on algorithms to obtain a minimal CTS from a given CTS up to conditional bisimilarity. Therefore, the final chain algorithm for minimisation from [ABH+12] is applied to the CTS functors \\( DP \\) and \\( P(\\_ \\times \\Phi) \\). The algorithm performs minimisation and determinisation for coalgebras on a Kleisli category, in which the pure arrows form a reflective subcategory:\n\n**Definition 6.1.** A subcategory \\( S \\) of \\( A \\) is called reflective, if the inclusion functor \\( I : S \\hookrightarrow A \\) has a left-adjoint \\( R \\):\n\n\\[\nS \\xleftarrow{I} \\xrightarrow{R} A\n\\]\n\nThe spelled out adjunction means: For each \\( X \\in A \\) there is an \\( S \\)-object \\( RX \\) and an \\( A \\)-arrow \\( \\rho_X : X \\to IRX \\) such that for any \\( A \\)-arrow \\( f : X \\to IY \\) into some object \\( Y \\) of \\( S \\), there exists a unique \\( S \\)-arrow \\( f' : RX \\to Y \\) (called \\( \\rho \\)-reflection of \\( f \\)) such that:\n\n\\[\n\\begin{array}{ccc}\nIRX & \\xrightarrow{f'} & IY \\\\\n\\rho_X & \\downarrow & \\ \\\\\nX & \\xrightarrow{f} & Y\n\\end{array}\n\\]\n\nNote that for such a mapping \\( R : \\text{obj} A \\to \\text{obj} S \\) on objects, \\( R \\) uniquely extends to a functor \\( R : A \\to S \\), and is called reflector.\n\n**Remark 6.2.** Here, the definition of [AHS90] is followed and thus the subcategory \\( S \\hookrightarrow A \\) is not required to be full. This is important, because the pure arrows need to form a reflective subcategory of the Kleisli category, i.e. that we have a reflective subcategory \\( C \\hookrightarrow \\text{Kl}(T) \\) for a monad \\( T : C \\to C \\). And this subcategory is full if and only if \\( T \\) is the identity monad.\n\nFor the reader monad \\( _\\_ \\times \\Phi \\) on \\( \\text{Poset} \\), we have a non-full reflective subcategory:\n\n**Lemma 6.3.** For a monad \\( (T : C \\to C, \\eta, \\mu) \\), the base category \\( C \\hookrightarrow \\text{Kl}(T) \\) is a reflective subcategory iff \\( T \\) has a left-adjoint \\( L : C \\to C \\). Furthermore, the unit \\( \\rho_X : X \\to LX \\) of the adjunction \\( L \\dashv T \\) is the universal arrow of the reflection.\n\n**Proof.**\n\n(\\( \\Leftarrow \\)) For \\( L \\dashv T \\) with unit \\( \\rho \\), for all \\( \\hat{f} : X \\to Y \\), and \\( g : LX \\to Y \\), we have \\( Ig \\circ \\rho_X = \\hat{f} \\) iff \\( Tg \\circ \\rho_X = \\hat{f} \\), because\n\n\\[\n\\begin{array}{ccc}\nLX & \\xrightarrow{Ig = \\eta_Y \\circ g} & Y \\\\\n\\rho_X & \\downarrow \\rho_X & \\ \\\\\nX & \\xrightarrow{\\hat{f}} & Y\n\\end{array}\n\\]\n\nThe first diagram is the universal property of the reflection, the last is that of \\( L \\dashv T \\); so the direction from right to left proves existence of an reflection of \\( \\hat{f} \\) and the direction from left to right proves its uniqueness.\n(⇒) Let $R \\vdash I$ and note that with the forgetful $U : Kl(T) \\to C$ from the Kleisli adjunction $I \\dashv U$, we have $T = UI$. Define $L := RI$; then $L \\dashv T$ by following natural isomorphisms between hom-sets:\n\n\\[\n\\begin{array}{ccc}\nRX & \\to & Y \\\\\n\\downarrow & & \\downarrow \\\\\nIX & \\to & IY \\\\\n\\downarrow & & \\downarrow \\\\\nX & \\to & UIY\n\\end{array}\n\\]\n\nNote that for $R \\dashv I$ and $L \\dashv T$, $IR : Kl(T) \\to Kl(T)$ is the extension of $L$, because $IL = IRI$.\n\n**Example 6.4.** In case of the reader monad $\\Phi$ on $C = \\text{Poset}$ or $C = \\text{Set}$ (resp. $\\Phi := J(L)$, and $\\sim J(L) \\cong T$ the lattice monad from Section 4), consider a Kleisli arrow $f : X \\to Y$. Then its reflection is the uncurried $\\tilde{f}$:\n\n\\[\n\\tilde{f} : LX \\times \\Phi \\to Y \\quad \\tilde{f}(x, \\varphi) = f(x)(\\varphi).\n\\]\n\nThe reflector $R : Kl(\\Phi) \\to C$ maps $f : X \\to Y$ to the pure map\n\n\\[\nRf : X \\times \\Phi \\to Y \\times \\Phi, \\quad Rf(x, \\varphi) = (f(x)(\\varphi), \\varphi)\n\\]\n\nwhich is the reflection of $\\rho Y \\circ f : X \\to Y \\times \\Phi$.\n\nFollowing [ABH+12], a reflective subcategory with an $(E, M)$-factorisation structure gives rise to a pseudo-factorisation structure in the base category, which in turn can be used to compute behavioural equivalence, provided the functor meets some conditions.\n\n**Definition 6.5.** Let $\\mathcal{E}$ and $\\mathcal{M}$ be any two classes of morphisms in a category $S$. Then the tuple $(\\mathcal{E}, \\mathcal{M})$ is called a factorisation structure for $S$ if\n\n- The classes $\\mathcal{E}$ and $\\mathcal{M}$ are closed under composition with isomorphisms;\n- Every arrow $f$ of $S$ has a factorisation $f = m \\cdot e$, where $m \\in \\mathcal{M}$ and $e \\in \\mathcal{E}$;\n- Unique diagonal property: For all arrows $f, g, e \\in \\mathcal{E}$, and $m \\in \\mathcal{M}$, if $g \\cdot e = m \\cdot f$, then there exists a unique arrow $d$ such that:\n\n\\[\n\\begin{array}{ccc}\ne & \\to & e \\\\\n\\downarrow & \\exists d & \\downarrow \\\\\nf & \\to & g \\\\\n\\downarrow & \\downarrow \\\\\nx & \\to & m\n\\end{array}\n\\]\n\n\\[(6.1)\\]\n\n**Remark 6.6.** In case of $\\mathcal{E}$ = regular epimorphisms and $\\mathcal{M}$ = monomorphisms the diagonalisation property (6.1) holds automatically. If $e$ is the coequaliser of $p_1, p_2$, then $e$ merges $p_1$ and $p_2$ and so does $g \\cdot e = m \\cdot f$. Since $m$ is monic, $f \\cdot p_1 = f \\cdot p_2$ and the coequaliser $e$ induces a unique diagonal with $d \\cdot e = f$ and thus also $m \\cdot d = g$.\n\n**Example 6.7.** Poset has a (RegEpi,Mono)-factorisation structure [AHS90, 14.23 Examples].\n\n- Regular epimorphisms in Poset are monotone functions $e : X \\to Y$ where $e$ is surjective and $\\le_Y$ is the smallest order on $Y$ making $e$ monotone. Regular epimorphisms are by definition coequalisers. In complete categories such as Poset, a regular epimorphism is the coequaliser of its kernel pair $\\ker e \\rightrightarrows X$.\n- Monos in Poset are monotone maps with an injective carrier map. In other words, $U : \\text{Poset} \\to \\text{Set}$ creates monos.\n\nOne transfers the factorisation structure from Poset to Kl($\\Phi$) using the reflection:\nNotation 6.8. From now on, the application of the inclusion functor $S \\hookrightarrow A$ is made implicit. For clarity, morphisms in $S$ are denoted by $\\rightarrow$, and morphisms in $A$ by $\\rightarrow\\rightarrow$. $S$-arrows in $M$ are indicated by $\\rightarrow$.\n\nDefinition 6.9. Consider a reflective subcategory $S \\hookrightarrow A$ with the $A$-reflection $\\rho$ and with an $(E, M)$-factorisation structure on $S$. For an $A$-morphism $f : X \\rightarrow Y$, take its reflection $f' : LX \\rightarrow Y$ and construct its $(E, M)$-factorisation $f' = m \\cdot e'$ with $e' \\in E$, $m \\in M$. Then $(m, e' \\circ \\rho_X)$ is called the $(E, M)$-pseudo factorisation of $f$.\n\nFor such pseudo-factorisations, we do not necessarily have a diagonal arrow for $m \\in M$, $e' \\in E$, and $e = e' \\circ \\rho_X$ in (6.1), but one can show that such an arrow exists whenever $g$ is in $S$. And the diagonal will also be an $S$-arrow.\n\nRemark 6.10. This applies to $\\text{Set} \\hookrightarrow \\text{Kl}(\\Phi)$. The pseudo-factorisation of $f : X \\rightarrow\\rightarrow Y$ in $\\text{Kl}(\\Phi)$ is as follows:\n\n- The inclusion $m : Y_0 \\hookrightarrow Y$, $Y_0 = \\{f(x)(\\varphi) \\mid x \\in X, \\varphi \\in \\Phi\\} \\subseteq Y$.\n- The function $e : X \\rightarrow Y_0$ defined as $e(x)(\\varphi) = f(x)(\\varphi)$.\n- The relation $\\leq_{Y_0}$ is the smallest order such that $e'$ is order preserving.\n\nWe now recall the algorithm from [ABH+12] in its entirety.\n\nAlgorithm 6.11. Let $A$ be a category with a final object $1$ and let $S$ be a complete and reflective subcategory of $A$ that has an $(E, M)$-factorisation structure where\n\n- all arrows in $E$ are epimorphism and\n- for all objects $X$ the class of $E$ morphisms with domain $X$ is a set.\n\nFurthermore, let $\\hat{H}$ be an endofunctor on $A$ preserving $S$ and $M$. Then, given an $\\hat{H}$-coalgebra $\\alpha : X \\rightarrow\\rightarrow \\hat{H}X$ we can compute the minimisation of $\\alpha$ in the following way:\n\n1. Let $d_0 : X \\rightarrow\\rightarrow 1$ be the final morphism.\n2. Given a $d_i : X \\rightarrow\\rightarrow Y$, pseudo-factorise $d_i = m_i \\circ e_i$, where $m_i \\in M$, $e_i = e'_i \\circ \\rho_X$, $e'_i \\in E$.\n3. Compute $d_{i+1} = \\hat{H}e_i \\circ \\alpha$.\n4. The algorithm terminates if the diagonal $u$ with $e_n = u \\circ e_{n+1}$ is an isomorphism in $S$ and yields $e_n$ as its output.\n\nThe dashed arrows in the diagram above are obtained by diagonalisation.\n\nTermination is guaranteed whenever the state set $X$ is finite. Whenever the algorithm terminates we obtain a coalgebra homomorphism $e_n$ from $\\alpha$ to $m_{n+1} \\cdot u^{-1} : Z_n \\rightarrow \\hat{H}Z_n$. \nThe Algorithm 6.11 is correct in the following sense:\n\n**Theorem 6.12** [ABH+12, Theorem 4.9, Theorem 3.8].\nLet \\( \\alpha' : LX \\to HLX \\) be the reflection of\n\\[ X \\xrightarrow{\\alpha} HX \\xrightarrow{Hq} HLX, \\]\nthen the uncurrying of \\( e_n, \\varepsilon_n : LX \\to Z_n, \\) is the greatest \\( \\mathcal{E} \\)-quotient of \\( \\alpha' \\).\n\n**Remark 6.13.** We call \\( e : (LX, \\alpha') \\to (Z, z) \\) the greatest \\( \\mathcal{E} \\)-quotient if \\( e \\in \\mathcal{E} \\) and for any \\( H \\)-coalgebra homomorphism \\( q : (LX, \\alpha') \\to (W, w) \\) with \\( q \\in \\mathcal{E} \\), there is a unique homomorphism \\( (W, w) \\to (Z, z) \\). In \\( \\text{Poset} \\) this means that any two elements \\( x_1, x_2 \\in LX \\) are merged by \\( e \\) if and only if they are merged by a coalgebra homomorphism in \\( \\mathcal{E} \\).\n\n**Remark 6.14.** If \\( H \\) preserves \\( \\mathcal{M} \\), then the \\( (\\mathcal{E}, \\mathcal{M}) \\)-factorisation system lifts to coalgebras, i.e. any coalgebra homomorphism \\( h \\) factorises into \\( h = m \\cdot q \\) where \\( m \\in \\mathcal{M} \\) and \\( q \\in \\mathcal{E} \\) are coalgebra homomorphisms. By the diagonalisation, the coalgebra structure on the image is defined uniquely. So in \\( \\text{Poset} \\) for monos \\( \\mathcal{M} \\), \\( x, y \\in V \\) are merged by some coalgebra homomorphism if and only if they are merged by some \\( \\mathcal{E} \\)-carried coalgebra homomorphism.\n\nThe algorithm’s output \\( e_n : X \\to Z_n \\) characterises conditional bisimilarity (in the general sense of Definition 5.18) in the following way: for two elements \\( x_1, x_2 \\in X \\) and \\( \\varphi \\in \\Phi \\) we have \\( x_1 \\sim_{\\varphi} x_2 \\) if and only if \\( (x, \\varphi) \\) and \\( (y, \\varphi) \\) are merged by the uncurried \\( \\varepsilon_n : LX \\to Z_n \\).\n\n**Theorem 6.15.** Using the terminology of Algorithm 6.11 it holds that for \\( x_1, x_2 \\in X \\)\n\\( x_1 \\sim_{\\varphi} x_2 \\) iff \\( \\varepsilon_n \\) merges \\( (x_1, \\varphi), (x_2, \\varphi) \\).\n\n**Proof.**\n\n\\( (\\Rightarrow) \\) By Theorem 5.22 we know that \\( x_1 \\sim_{\\varphi} x_2 \\) if there exists a coalgebra homomorphism \\( h : X \\to Y \\) with \\( h(x_1)(\\varphi) = h(x_2)(\\varphi) \\). Hence if \\( e_n \\) merges \\( (x_1, \\varphi), (x_2, \\varphi) \\), we can infer that \\( e_n(x_1)(\\varphi) = e_n(x_2)(\\varphi) \\) and since \\( e_n \\) is a coalgebra homomorphism we have \\( x_1 \\sim_{\\varphi} x_2 \\).\n\n\\( (\\Rightarrow) \\) By Theorem 5.22, \\( x_1 \\sim_{\\varphi} x_2 \\) implies the existence of some \\( h : (X, \\alpha) \\to (Y, \\beta) \\) with \\( h(x_1)(\\varphi) = h(x_2)(\\varphi) \\). Recall from [ABH+12, Prop. 4.4] that since \\( \\tilde{H} \\) is an extension and \\( \\text{Kl}(\\_^{\\Phi}) \\hookrightarrow \\text{Poset} \\) is a reflective subcategory, the category of \\( H \\)-coalgebras is a reflective subcategory of the \\( \\tilde{H} \\)-coalgebras. So applying the reflector \\( R : \\text{Kl}(\\_^{\\Phi}) \\to \\text{Poset} \\) to the square of the \\( \\tilde{H} \\)-coalgebra homomorphism \\( h \\) results in an \\( H \\)-coalgebra homomorphism:\n\n\\[\n\\begin{align*}\nLX \\xrightarrow{\\alpha'} & HLX \\\\\n\\downarrow \\text{R}_h & \\downarrow \\text{H}_R \\text{h} \\\\\nLY \\xrightarrow{\\beta'} & HLY\n\\end{align*}\n\\]\nR acts on objects as L and we have $Rh(x_i, \\varphi) = (h(x_i))(\\varphi), \\varphi$, for both $i \\in \\{1, 2\\}$ (cf. Example 6.4), and so $R(x_1, \\varphi) = R(x_2, \\varphi)$. By Remark 6.14 and 6.13, the greatest $\\mathcal{E}$-quotient $\\hat{e}_n : LX \\to Z_n$ merges $(x_1, \\varphi)$ and $(x_2, \\varphi)$.\n\nRecall from Theorem 2.10, that the functors $\\mathcal{DP}$ and $\\mathcal{P}_{(- \\times \\Phi)}$ (cf. Remark 5.3) preserve the subcategory Poset. Furthermore, they preserve $\\mathcal{M}$, i.e., the class of (pure) order preserving injections, because the underlying endofunctors $D, P$ and $\\mathcal{P}_{(- \\times \\Phi)}$ do.\n\nThus, the algorithm from [ABH+12] is applicable using the derived pseudo-factorisation structure. We now discuss a small example for the application of the minimisation algorithm from [ABH+12] using this pseudo-factorisation structure on $\\mathcal{Kl}(\\Phi)$ for $\\mathcal{P}_{(- \\times \\Phi)}$.\n\n**Example 6.16.** Let $X = \\{x, y, z, x', y', z'\\}$, $|A| = 1$ and $\\Phi = \\{\\varphi', \\varphi\\}$, with $\\varphi' \\leq \\varphi$. Let $\\alpha : X \\to \\hat{V}X$ (note that $\\hat{V} = \\mathcal{P}_{(- \\times \\Phi)}A^A$) be the coalgebra modelling the CTS depicted below.\n\nTo compute behavioural equivalence, we start by taking the unique morphism $d_0 : X \\to 1$ into the final object of $\\mathcal{Kl}(\\Phi)$ that is $1 = \\{\\bullet\\}$. At the $i$th iteration, we obtain $e_i$ via the pseudo-factorisation of $d_i = m_i \\circ e_i$ and then we build $d_{i+1} = \\hat{V}e_i \\circ \\alpha$. These iterations are shown in the following tables. Note that each table represents both, $d_i$ and $e_i$, because the pseudo-factorisation just yields simple injections as monomorphisms, so $d_i$ and $e_i$ in each step only differ by their codomain.\n\nIn the tables for $d_2/e_2$ and $d_3/e_3$ we have used colours to code the entries, because the full notation for the entries would be too large to fit in the tables.\nThe codomains $C_0, C_1, C_2,$ and $C_3$ of $e_0, e_1, e_2,$ and $e_3$ (resp.) are given below (note that the colours in $C_2$ and $C_3$ indicate the colours in the tables above):\n\n$C_0 = \\{\\bullet\\}$\n\n$C_1 = \\{\\emptyset, \\{\\bullet, \\varphi\\}, \\{\\bullet, \\varphi'\\}\\}$\n\n$C_2 = \\{\\{\\emptyset, \\varphi\\}, \\{\\emptyset, \\varphi'\\}, \\{\\bullet, \\varphi'\\}\\}$\n\n$C_3 = \\{\\{\\emptyset, \\varphi\\}, \\{\\{\\bullet, \\varphi'\\}\\}, \\{\\bullet, \\varphi'\\}\\}$\n\neach ordered by inclusion. By contrast, the codomain $C'_i$ of $d_i$ is defined as $C'_i = C_0, C'_i = \\mathcal{P}(C_i \\times \\Phi)$ for $i = 1, 2, 3$.\n\nBy comparing the columns for each state we can determine which states are bisimilar. The partitions are divided as follows (where $X_i$ denote the entries at the $i^{\\text{th}}$ iteration):\n\n$X_0 = \\{\\{x, y, z, x', y', z'\\}\\}$\n\n$X_1 = \\{\\{x, x'\\}, \\{y, y'\\}, \\{z, z'\\}\\}$\n\n$X_2 = X_3 = \\{\\{x\\}, \\{x'\\}, \\{y, y'\\}, \\{z, z'\\}\\}$\n\nTo obtain the greatest conditional bisimulation from $e_2$ (or $e_3$), we need to compare individual entries of each table. We can identify the greatest bisimulation as $\\{R_\\varphi, R_\\varphi'\\}$, where (written as equivalence classes)\n\n$R_\\varphi = \\{\\{z, z'\\}, \\{x\\}, \\{x'\\}, \\{y, y'\\}\\}$\n\n$R_\\varphi' = \\{\\{x, x'\\}, \\{y, y'\\}, \\{z, z'\\}\\}$\n\nAdditionally, it is possible to derive the minimal coalgebra that was identified using the minimisation algorithm, which is of the form $(E_2, m_3 \\circ \\iota)$ where $\\iota : E_2 \\to \\hat{\\mathcal{V}}(E_2)$ is the arrow witnessing termination of the algorithm. The minimisation has the following form:\nNote that, if there was no order on $\\Phi$, $x$ and $x'$ would be found equivalent under $\\varphi$, because without upgrading, $x$ and $x'$ behave the same for $\\varphi$: Both can do exactly one step, reaching either of $y, z$ or $z'$, respectively, but in none of these states and additional steps are possible in the product $\\varphi$.\n\nOne can observe that both $x$ and $x'$ get mapped under $\\varphi'$ to the red state (second from bottom of the diagram), but under $\\varphi$, the state $x$ gets mapped to the blue state (top state in the diagram), whereas $x'$ gets mapped to the black state (right-most state in the diagram).\n\n**Remark 6.17.** In [BKKS17] we have also given a matrix multiplication algorithm for minimising CTSs. This algorithm is similar to applying Algorithm 6.11, but working conceptually in $\\text{Kl}(T)$ rather than $\\text{Kl}(\\neg \\Phi)$.\n\nSince we have seen that both categories are isomorphic, we can also characterise (pseudo-)factorisation in $\\text{Kl}(T)$. We could factorise an arrow by converting it to a $\\text{Kl}(\\neg \\Phi)$-arrow and factorising that arrow, then translating it back to $\\text{Kl}(T)$. Since we have already seen that factorising in $\\text{Kl}(\\neg \\Phi)$ basically means to exclude all states from the codomain of the arrow that are not in the image of any pair of states and alphabet symbol, this boils down to finding out when a state in a $\\text{Kl}(T)$-arrow will be identified as redundant in $\\text{Kl}(\\neg \\Phi)$. So let $f : X \\to Y$ be a $\\text{Kl}(T)$-arrow, then $f(x) = b \\in (Y \\to L)^*$. An element $y \\in Y$ will occur in the image of $f(x)$ if there is an irreducible element $\\varphi \\in J(L) = \\Phi$ such that $y$ is the smallest element of $Y$ with $b(y) \\geq \\varphi$. This is the case if $\\bigcup \\{b(y') \\mid y' < y\\} \\neq b(y)$. So, by factorising an arrow in $\\text{Kl}(T)$ we eliminate all states $y$ such that $\\bigcup \\{f(x)(y') \\mid y' < y\\} = b(y)$ for all $x \\in X$. Hence, $f = e \\circ m$ where $e : X \\to Y'$ and $Y' \\subseteq Y$ is the subset of $Y$ that remains after the elimination.\n\nThis enables us to execute the algorithm. The relation to the matrix multiplication method is discussed in more detail in Appendix A.\n\n### 7. Conclusion, Related and Future Work\n\nIn retrospect, the Kleisli categories for the lattice monad and the reader monad are equivalent, providing an analogue to the Birkhoff duality between lattices and partially ordered sets. This duality also reflects the duality between a CTS and an LaTS. We investigated two different functors which can be used to model CTSs without upgrades and general CTSs, respectively, in such a way that behavioural equivalence is conditional bisimulation. Though CTSs without upgrades can be modelled using just $\\mathcal{P}(-)^A$, this functor can not be employed for non-discrete orders, i.e., in the case where upgrades are present. When considering upgrades, the individual products cannot be considered purely a side effect and must instead be observed, which leads to the requirement of making the products explicit in a way and to our choice of the functor $\\mathcal{P}(- \\times \\Phi)^A$.\n\nThe Kleisli category for the reader monad has a pseudo-factorisation structure that makes it possible to use a result from [ABH+12] to compute the greatest conditional bisimulation using a final chain-based algorithm for both functors.\n\nOur work obviously stands in the tradition of the work in [ABH+12] and [KK14]. In a broader sense, the modelling technique of using Kleisli categories to obtain the “right” notion of behavioural equivalence goes back to previous work in [HJS07, PT99], where non-deterministic branching of NFA was masked by the use of a Kleisli category (over $\\text{Set}$ in this case) to obtain language equivalence as behavioural equivalence rather than bisimulation.\nModelling new types of systems and behaviours coalgebraically is an ongoing field of research, as evident by recent work for instance by Bonchi et al. on decorated traces [BBC⁺16], Hermanns et al. on probabilistic bisimulation [HKK14] or Latella et al. on labelled state-to-function transition systems [LMdV15].\n\nSystem models that can handle various products derived from a common base are of particular interest in the field of software product lines. Featured transition systems (FTSs) are conceptually the closest to CTS and can in fact be simulated by CTSs in a rather straightforward way. A featured transition system is defined as a labelled transition system where each transition is guarded by a feature from a common set of features. A given FTS evolves at follows: first, a set of features (which corresponds to a condition in a CTS) is chosen and transitions are activated or deactivated accordingly, then, the FTS evolves just like a labelled transition system. By choosing for the set of conditions the powerset of all features, ordered discretely, one can simulate FTS via CTS. Due to the upgrading aspect of CTS, the same does not hold the other way around. Similar systems to CTSs have been studied for instance by Cordy et al. [CCP⁺12] and Kupferman [KL10]. FTS in particular have been an active field of study in the past years, with various similar, yet not identical definitions being conceived in various lines of work. Classen et al. [CHS⁺10], as well as Atlee et al. [AFL15] and Cordy et al. [CCH⁺13] have worked, among many others, on FTS and the accompanying feature diagrams.\n\nIn the future, we want to characterise conditional bisimulation via operational semantics and an appropriate logic. Furthermore, we are interested in analysing different properties of CTSs rather than bisimulation, in particular we are interested in a notion of weak bisimilarity. For this purpose, we will consider adapting a path-based approach similar to the one present in [BK17] to the Kleisli category of the reader monad.\n\nIn this paper, we have already taken steps to adapt the notion of conditional bisimilarity to a coalgebraic setting, making it independent of the concrete model and functor under investigation. We plan to investigate whether the notion of conditions (or products) can be introduced for various state-based system models, for instance for probabilistic systems. That is, we are interested in combining the (sub)distribution functor with our monads, in order to coalgebraically model and analyse families of probabilistic systems in a unified way. From the point of view of software product lines, this could be an entry point to a quantitative analysis of software product lines, rather than a purely qualitative one.\n\nReferences\n\n\nAppendix A. Comparison of the Final Chain Algorithm and the Matrix Multiplication Algorithm\n\nIn our previous work on conditional transition systems, where we did not consider CTS and LaTS from a coalgebraic perspective, we also presented a fixed point algorithm to compute the greatest lattice bisimulation for a LaTS. The procedure works as follows:\n\n**Algorithm A.1.** Let \\((X, A, L, f)\\) be a finite LaTS over the finite distributive lattice \\(\\mathbb{L} = \\mathcal{O}(\\Phi, \\leq_{\\Phi})\\), i.e., the sets \\(X\\), and \\(A\\) are finite. We define a series of lattice-valued relations \\(R_i : X \\times X \\to \\mathbb{L}\\).\n\nFix \\(R_0\\) as \\(R_0(x, y) = 1\\) for all \\(x, y \\in X\\). Then, compute \\(R_{i+1} = F_1(R_i) \\cap F_2(R_i)\\) for all \\(i \\in \\mathbb{N}_0\\) until \\(R_n \\subseteq R_{n+1}\\) for an \\(n \\in \\mathbb{N}_0\\). \\(F_1\\) and \\(F_2\\) are defined according to:\n\n\\[\nF_1(R)(x, y) = \\bigcap_{a \\in A, x' \\in X} \\left( f(x, a, x') \\to \\left( \\bigcup_{y' \\in X} (f(y, a, y') \\cap R(x', y')) \\right) \\right),\n\\]\n\n\\[\nF_2(R)(x, y) = \\bigcap_{a \\in A, y' \\in X} \\left( f(y, a, y') \\to \\left( \\bigcup_{x' \\in X} (f(x, a, x') \\cap R(x', y')) \\right) \\right).\n\\]\n\nLastly, return \\(R_n\\) as the greatest bisimulation.\n\nIt can be shown that for two states \\(x, y \\in X\\), \\(x \\sim_\\varphi y\\) if and only if \\(\\varphi \\in R_n(x, y)\\).\n\nAs explained before, CTS and LaTS are dual models and can be translated directly into one another. Using the functor \\(\\mathcal{V}\\) combined with the lattice monad, we have shown how to define LaTS coalgebraically. However, the final chain algorithm does not exactly replicate the fixed-point algorithm described above. Instead of \\(X \\times X\\) matrices over \\(\\mathbb{L}\\), the final chain algorithm yields – before factorisation – \\(X \\times \\mathcal{V}1\\) matrices over \\(\\mathbb{L}\\), when translated via \\(\\alpha^{-1}\\). Factorisation may shrink the second dimension, but it usually is not equal to \\(X\\). We will now show that there is still a strong correspondence between the final chain algorithm and the fixed point computation: Both algorithms separate pairs of states at the same point in the computation and both algorithms terminate at the same time.\n\n**Lemma A.2.** Let a CTS \\(\\alpha : X \\to \\mathcal{V}X\\) over a finite set of states \\(X\\) and a finite ordered set of conditions \\(\\Phi\\) be given. Moreover, consider the dual LaTS \\(f : X \\times X \\to \\mathcal{O}(\\Phi)\\). Then Algorithms A.1 and 6.11 terminate after the same number of iterations.\n\n**Proof.** Due to the special nature of the factorisation in Algorithm 6.11, we will always argue using \\(d_k\\) instead of \\(e_k\\). We will first show that Algorithm 6.11 separates two states in iteration \\(k\\) if and only if Algorithm A.1 does, as well. For that purpose we define the matrices\n\n\\[\nM_k(x, y) = \\{ \\varphi \\mid d_k(x)(\\varphi) = d_k(y)(\\varphi) \\}\n\\]\n\nNote that per definition of \\(\\mathcal{V}\\), this set is always downwards-closed for \\(k \\geq 1\\), and due to the \\(d_0\\) codomain being the final object, it is also downwards-closed for \\(k = 0\\). We can now prove that \\(R_k = M^k\\) for all \\(k\\), proving the first claim, that two states can only get separated in both algorithms at the same time. We prove this via induction.\n\n- Let \\(k = 0\\). Per definition, \\(R_0(x, y) = \\Phi\\) for all \\(x, y \\in X\\) and due to \\(d_0\\) being the unique arrow into the final object, is must also hold that \\(M_0(x, y) = \\Phi\\) for all \\(x, y \\in X\\).\n- Assume we have shown the claim for all \\(k' \\leq k\\).\n- We will now show that the claim also holds for \\(k + 1\\). For this we show mutual inclusion.\nLet \\( \\varphi \\in R_{k+1}(x, y) \\) for any \\( \\varphi \\in \\Phi, x, y \\in X \\). Then \\( R_{k}(x, y) \\supseteq \\varphi \\) and – by definition of \\( F_1 \\) – for all \\( a \\in A, \\varphi' \\leq \\varphi, x' \\in \\alpha(x)(\\varphi') \\) exists \\( y' \\in \\alpha(y)(\\varphi') \\) such that \\( R(x', y') \\supseteq \\varphi' \\) and – by definition of \\( F_2 \\) – vice versa. The induction allows us to find \\( M^k(x, y) \\supseteq \\varphi \\) and for all \\( a \\in A, \\varphi' \\leq \\varphi, x' \\in \\alpha(x)(\\varphi') \\) there exists a \\( y' \\in \\alpha(y)(\\varphi') \\) such that \\( d_k(x')(\\varphi') = d_k(y')(\\varphi') \\) (and vice versa). Therefore we can compute:\n\n\\[\nd_{k+1}(x)(\\varphi)(a) = \\hat{V}d_k \\circ \\alpha(x)(\\varphi)(a) = \\{(d_k(x')(\\varphi'), \\varphi') \\mid \\varphi' \\leq \\varphi, x' \\in \\alpha(x)(\\varphi')(a)\\}\n\\]\n\nTherefore for all \\( \\varphi' \\leq \\varphi, x' \\in \\alpha(x)(\\varphi')(a) \\), there must exist a \\( y' \\in \\alpha(y)(\\varphi')(a) \\) such that \\( d_k(x')(\\varphi') = d_k(y')(\\varphi') \\) and vice versa. Using the induction hypothesis we can therefore find, that \\( \\varphi' \\leq \\varphi, a \\in A, x' \\in \\alpha(x)(\\varphi')(a) \\), there must exist a \\( y' \\in \\alpha(y)(\\varphi')(a) \\) such that \\( \\varphi' \\in R_k(x', y') \\), proving \\( \\varphi \\in F_1(R_k(x, y)) \\) and vice versa, proving \\( \\varphi \\in F_2(R_k(x, y)) \\). Thus, \\( \\varphi \\in R_{k+1}(x, y) \\).\n\nSo we have seen that both algorithms separate pairs of states in the same iteration. However, it still has to be shown that when no pairs of states are separated anymore, Algorithm A.1 terminates. Per definition, Algorithm 6.11 terminates at that point, as well, so Algorithm 6.11 can mimic Algorithm A.1. So, let \\( d_n \\) be such that \\( M_{n-1} = M_n \\), and thus \\( R_{n-1} = R_n \\), i.e. Algorithm A.1 has terminated. Further, let \\( x, y \\) be given, such that \\( d_n(x)(\\varphi) \\leq d_n(y)(\\varphi) \\), i.e. for all \\( a \\in A, d_n(x)(\\varphi)(a) \\subseteq d_n(y)(\\varphi)(a) \\).\n\n\\[\nd_{n+1}(x)(\\varphi)(a) = \\hat{V}d_n \\circ \\alpha(x)(\\varphi)(a) = \\{(d_n(x')(\\varphi'), \\varphi') \\mid (x', \\varphi') \\in \\alpha(x)(\\varphi) \\wedge \\varphi' \\leq \\varphi\\}\n\\]\n\nand analogously\n\n\\[\nd_{n+1}(y)(\\varphi)(a) = \\{(d_n(y')(\\varphi'), \\varphi') \\mid (y', \\varphi') \\in \\alpha(y)(\\varphi) \\wedge \\varphi' \\leq \\varphi\\}\n\\]\n\nWe know that \\( d_n(x)(\\varphi)(a) \\subseteq d_n(y)(\\varphi)(a) \\), therefore, for \\( (x', \\varphi') \\in \\alpha(x)(\\varphi) \\) there must exist a \\( (y', \\varphi') \\in \\alpha(y)(\\varphi) \\) such that \\( d_{n-1}(x')(\\varphi') = d_{n-1}(y')(\\varphi') \\). Since \\( M_{n-1} = M_n \\), it must then also hold that \\( d_n(x')(\\varphi') = d_n(y')(\\varphi') \\). Thus we can conclude \\( d_{n+1}(y)(\\varphi)(a) \\supseteq d_{n+1}(x)(\\varphi)(a) \\).\n\nThus, Algorithm 6.11 terminates in step \\( n \\) as well. \\( \\square \\)"}}},{"rowIdx":196,"cells":{"id":{"kind":"string","value":"bf7d45fa4e479fd745e1de1b622b0b14ee31db1a"},"text":{"kind":"string","value":"Discover both the declarative (point-and-click) and the programmatic (code-based) features of Salesforce. Learn how you can optimize existing features such as Visualforce pages and quick actions for the Salesforce mobile experience, as we walk you through the process of making an existing organization mobile-ready.\n\nSalesforce App Developer Guide\n\n© Copyright 2000–2019 salesforce.com, inc. All rights reserved. Salesforce is a registered trademark of salesforce.com, inc., as are other names and marks. Other marks appearing herein may be trademarks of their respective owners.\n\nVarious trademarks held by their respective owners.\n\nNo part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the publisher.\n### CONTENTS\n\n**Chapter 1: Introduction**\n- Introducing the Salesforce Platform ............................................. 1\n- Salesforce Platform Features ..................................................... 2\n- Introducing the Salesforce App .................................................. 4\n- Getting Around in the Salesforce App ........................................ 4\n- What about the Other Mobile Apps? ......................................... 9\n\n**Chapter 2: About This Book** .................................................. 11\n- Who Is This Book For? ............................................................... 12\n- How Do I Begin? ........................................................................... 12\n- About the Sample Scenario ....................................................... 12\n- About Acme Wireless ................................................................. 12\n\n**Chapter 3: Setting Up Your Work Environment** ...................... 15\n- Install the Enhanced Warehouse Data Model .......................... 16\n- Download Salesforce ................................................................. 16\n\n### SALESFORCE APP ADMINISTRATION .................................... 17\n\n**Chapter 4: Configuring the Salesforce App** ............................ 17\n- Defining Which Users Can Use the Salesforce App .................. 18\n- About Notifications ..................................................................... 19\n- Try It Out: Enable Notifications .............................................. 19\n- About Offline Access in the Salesforce App .............................. 20\n\n**Chapter 5: Customizing the Salesforce App Navigation Menu** ... 23\n- About the Salesforce Navigation Menu ...................................... 24\n- Try It Out: Configuring the Salesforce App Navigation Menu .... 26\n- Test Out the Salesforce App Navigation Menu ......................... 27\n- How the Navigation Menu Works .............................................. 28\n\n**Chapter 6: Customizing How Your Data Shows Up in the Salesforce App** ......................................................... 31\n- How Page Layouts Work in the Salesforce App ............................ 32\n## Salesforce Platform Development Process\n\n- Development Prerequisites .................................................. 71\n - Change the System Administrator Page Layout Assignment ............ 72\n\n### Chapter 10: Designing Mobile-First User Interfaces\n\n- Design for Mobile ................................................................. 74\n- Keep Navigation Simple ......................................................... 74\n- Put Important Information at the Top ........................................ 74\n- Minimize the Number of Fields ............................................... 75\n- Use Field Defaults ................................................................ 76\n- Minimize User Interface Text .................................................. 76\n- Tap Target Size ..................................................................... 77\n\n### Chapter 11: Extending the Salesforce App with Visualforce Pages\n\n- Try It Out: Create a Visualforce Page ........................................ 80\n - Create a New Tab ................................................................. 83\n - Add the Tab to the Navigation Menu ....................................... 84\n - Test the Visualforce Page .................................................... 85\n- Tell Me More: Where Visualforce Pages Can Appear in the Salesforce App ........................................................................ 86\n- Tell Me More: About the Code .................................................. 88\n\n### Chapter 12: Adding Functionality with Visualforce Custom Actions\n\n- Custom Actions Scenario ........................................................ 94\n - Try It Out: Create a Visualforce Custom Action ......................... 94\n - Add the Visualforce Custom Action to the Page Layout ............. 95\n - Test Out the Visualforce Custom Action ............................... 96\n- Tell Me More: About the Code .................................................. 98\n\n### Chapter 13: Development Guidelines and Best Practices\n\n- When to Use the Navigation Menu or the Action Bar .................... 106\n- Guidelines and Best Practices .................................................. 108\n - Sharing Visualforce Pages Between Mobile and Desktop .......... 108\n - Excluding Visualforce Pages from Mobile or Desktop ............... 109\n - Choosing an Architecture for Visualforce Pages in the Salesforce App .......................... 109\n - Standard Visualforce Pages ................................................. 109\n - Mixed Visualforce and HTML .............................................. 111\n<table>\n<thead>\n<tr>\n<th>Content</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>JavaScript Remoting and Static HTML</td>\n<td>113</td>\n</tr>\n<tr>\n<td>Visualforce Components and Features to Avoid in the Salesforce App</td>\n<td>119</td>\n</tr>\n<tr>\n<td>Unsupported Visualforce Components</td>\n<td>120</td>\n</tr>\n<tr>\n<td>Choosing an Effective Page Layout</td>\n<td>120</td>\n</tr>\n<tr>\n<td>User Input and Interaction</td>\n<td>124</td>\n</tr>\n<tr>\n<td>Managing Navigation</td>\n<td>128</td>\n</tr>\n<tr>\n<td>Navigation and Messaging with the sforce.one Object</td>\n<td>130</td>\n</tr>\n<tr>\n<td>How sforce.one Handles API Versions</td>\n<td>134</td>\n</tr>\n<tr>\n<td>Using Visualforce Pages as Custom Actions</td>\n<td>138</td>\n</tr>\n<tr>\n<td>Creating Visualforce Pages That Work in Mobile and Desktop</td>\n<td>139</td>\n</tr>\n<tr>\n<td>Performance Tuning for Visualforce Pages</td>\n<td>140</td>\n</tr>\n<tr>\n<td>Canvas Guidelines and Best Practices</td>\n<td>141</td>\n</tr>\n<tr>\n<td>Canvas Apps in the Chatter Publisher and Salesforce App Action Bar</td>\n<td>141</td>\n</tr>\n<tr>\n<td>Canvas Apps in the Feed</td>\n<td>144</td>\n</tr>\n<tr>\n<td>Canvas Apps Context</td>\n<td>144</td>\n</tr>\n<tr>\n<td>Custom Icons for Canvas Apps</td>\n<td>145</td>\n</tr>\n<tr>\n<td><strong>Chapter 14: Learning More</strong></td>\n<td>147</td>\n</tr>\n<tr>\n<td><strong>INDEX</strong></td>\n<td>149</td>\n</tr>\n</tbody>\n</table>\nCHAPTER 1\n\nIntroduction\n\nMobile has become the new normal for staying connected in both our personal and professional lives. More and more, we’re living our lives connected to the Internet, but instead of sitting at a desk, we’re connecting on planes, in cabs, in between meetings, in hotels, or even in line for coffee. We follow friends, update status feeds, research local businesses, collaborate with colleagues, email suppliers, and much more—all tasks increasingly performed on the go.\n\nAnd at the same time, every company is working harder and faster to innovate and stay ahead of the competition. The successful businesses of the future must embrace this mobile-first world and the freedom this mobility provides to get things done, regardless of where you are and what you’re doing.\n\nSalesforce solves the problems of lagging innovation and a lack of mobile specialists with a revolutionary approach to app development for the social and mobile-first world. Salesforce delivers breakthrough productivity for all users because it puts the customer—employees, partners, consumers, and devices—at the center of everything.\n\nThe result is a fast, connected mobile solution with the potential to be as disruptive as Software as a Service. It’s time to build the future today!\nIntroducing the Salesforce Platform\n\nSalesforce is a mobile app development platform for everyone. It gives ISVs, developers, administrators, and every user the freedom to innovate.\n\nThis approach to unlocking mobile app development for organizations is built for today’s needs: mobile and social solutions delivered in days or weeks. Apps are driven by metadata and intelligently provide context to the user experience. These apps deliver information-based mobile device features: addresses can be plotted on maps, phone numbers can be dialed with a simple tap, feed-centric workflows can be created, and much more.\n\nBusiness users and administrators can develop apps with clicks, not code, complete with powerful workflow rules, approval processes, and dynamic user interfaces. Unlike other solutions where business users often create independent applications in which IT has little visibility into their security or reliability, Salesforce gives administrators the tools to centrally manage apps without limiting the business’s need to innovate.\n\nDesigned for scale with open APIs for extensibility and integration, and powerful developer tools, there’s no limit to what developers and ISVs can build on the platform. Salesforce’s flexible development models let every administrator or developer create custom apps that are supported by mobile back-end services and a unique, yet familiar, mobile user experience. ISVs developing on the Salesforce Platform can develop apps that take advantage of advanced packaging and version management controls, complete enterprise marketplace capabilities with the AppExchange, and feed-first discovery of their apps within the Salesforce Platform.\n\nSalesforce Platform Features\n\nThe Salesforce Platform brings together Lightning Platform, Heroku, and ExactTarget Fuel into one incredibly powerful family of social, mobile, and cloud services—all built API first.\n\nThe Salesforce Platform delivers:\n\nSocial Data\n\nThe ability to share, follow, collaborate, and take business actions directly on data within Salesforce is at the core of the platform. Users can follow records and data with a single tap. They can be notified of changes in real time, and collaborate directly within the record feed. This feed-based approach to working lets users focus on what’s most important to them.\n\nBy treating data as social and as an important participant in business, Salesforce allows data to share updates, trigger workflows, and be part of the collaboration process with workers, teams, partners, and\ncustomers. The result is an unparalleled opportunity to create new business apps and processes for business productivity.\n\n**Declarative and Programmatic Development**\n\nIT departments have struggled to keep pace with the level of change required for businesses to remain competitive. Too often, IT is resource-constrained because they must manage existing on-premises systems while at the same time recruit and retain professional developers—especially those with mobile application development experience.\n\nSalesforce solves this problem by providing intuitive drag-and-drop tools for storing and working with data, defining cloud-based logic with workflows, creating approval processes and formulas, and creating mobile-ready apps.\n\nProfessional developers can use the most popular open-source languages, tools, and standards to build completely custom apps and user interfaces. Unlike other platforms, Salesforce delivers a unique experience where developers and administrators create apps on the same platform, eliminating the effort required to build complicated integration solutions.\n\n**Action-Based App Model**\n\nSalesforce mobile puts the customer at the center of the development process. Rather than require complicated development cycles, apps can be declared through actions: create an order, set a delivery date, select a route, and so on. Administrators can define default values for actions to streamline apps down to the click of a mouse or a swipe of the finger.\n\nActions defined via the desktop are instantly available in context-sensitive menus on mobile devices. And, for developers building integrations with Salesforce, actions are automatically enabled with RESTful endpoints capable of accepting either XML or JSON data envelopes.\n\n**Connect to Everything with Open APIs**\n\nSalesforce provides the flexibility to create apps that connect to everything using efficient and scalable APIs that perform over 1.3 billion transactions a day. Every object or data entity is instantly REST-enabled. Our APIs include bulk APIs for data loading, social APIs for ubiquitous collaboration anywhere, cutting-edge streaming APIs to support push notification integrations, and metadata APIs that describe every aspect of your app and business such as permissions, data access policies, field types, and user experience.\nIntroducing the Salesforce App\n\nThe Salesforce apps are Salesforce on the go! These enterprise-class mobile apps give your users real-time access to the same information that they see in the office, but organized for getting work done in those precious free moments when they’re between customer meetings, waiting for a flight—even when they’re in line for coffee.\n\nYou can get Salesforce in different ways:\n\n- As an app for iOS from the App Store or an app for Android from Google Play.\n- As mobile web experience that runs in supported mobile browsers. This option doesn’t require anything to be installed.\n\nIn this book, we’ll be working exclusively with the downloadable apps.\n\nRequirements for Using Salesforce\n\nThe Salesforce app is available for most Salesforce editions and user license types. The app is supported on a variety of mobile platforms, with some minimum operating system and mobile browser requirements.\n\nFor current mobile platform requirements and the list of devices that Salesforce uses for testing, see Requirements for the Salesforce App in the Salesforce Help.\n\nOn most devices, Salesforce is supported in portrait orientation only. The one exception is when using the Salesforce for iOS on iPad tablets, where both portrait and landscape orientation are supported.\n\nGetting Around in the Salesforce App\n\nLet’s take a tour of Salesforce.\n\nWhen users log in to Salesforce, the first thing they see is a landing page. The first item in the navigation menu becomes a users’ landing page by default. If your organization has Chatter enabled, and you haven’t customized the navigation menu to change the first item in the menu to something else, the user’s Feed will be their landing page.\n\nThe Feed\n\nThe Chatter feed shows users their updates, updates to records and people they follow, and updates in groups they follow. Tapping a feed item displays all of the item’s details. Pulling down on the feed reveals the search bar (1), sort and filter options (2), the feeds drop-down menu (3), and feed items (4).\nFrom the feed, record pages, and from elsewhere in Salesforce, users access actions from the action bar.\n\nThe Action Bar and Menu\n\nDepending on which feed or record page users are viewing, they see different actions in the action bar and action menu. From the feed, for example, they see a set of global actions. From a record page, however, they see a mix of productivity actions, standard and custom buttons, standard Chatter actions such as Post and File, and global and object-specific actions that are assigned to the layout for that record type. Users can tap from the action bar to open the action menu, which contains the full set of actions that are available for the object.\nWe’ll go over creating and customizing actions in Using Actions in the Salesforce App on page 45.\n\nSalesforce App Navigation Menu\n\nAnywhere users see nier, they can tap it to access the navigation menu. If a user doesn’t see nier, they can swipe left to right on the header bar to open the navigation menu.\n\nWhat your users see in the menu is determined by how you, as the administrator, have configured it, what’s available in your organization, and what users have access to, based on their user permissions and profile.\nFrom the navigation menu, users can access the feed, objects, apps, tasks, notes, and any other item you’ve added to the menu. We’ll go over the components of the navigation menu in more detail in About the Salesforce Navigation Menu on page 24. But for now, let’s take a look at records.\n\nThe Record View\n\nThe record view is made up of the record feed, detail, and related information pages, which your users can swipe left and right to see. If your organization doesn’t have Chatter enabled, the record view only includes the detail and related information pages.\nAt the top of each record page is the record highlights area. The icon for standard objects is predefined in Salesforce, and you can select the icon for a custom object using the custom object’s tab style.\n\nYou can customize the fields displayed in the record highlights section by using compact layouts, which we’ll look at in About Compact Layouts on page 39.\n\n1. Back arrow—returns the user to the previous page\n2. Record highlights—displays the first four fields that are assigned to the compact layout for the object\nWhat else do I need to know?\n\nFrom the top of most pages, users can access their notifications by tapping notification icon.\n\nUsers can create a new record by tapping New at the top of recent object pages, search pages, and related list pages. They can also create and update records by using actions in the action bar.\n\nWhat about the Other Mobile Apps?\n\nWondering how the Salesforce app relates to the other Salesforce mobile products?\n\n- SalesforceA gives administrators mobile access to essential organization management tasks. Use it to edit, unlock, freeze, and deactivate user accounts, reset passwords, and assign permission sets.\n\nFor more detailed information about the full suite of Salesforce mobile apps, see “Salesforce Mobile Product Comparison” in the Salesforce Help.\nCHAPTER 2 About This Book\n\nIn this chapter ... \n- Who Is This Book For? \n- How Do I Begin? \n- About the Sample Scenario \n- About Acme Wireless\n\nThis book introduces you to both the declarative (point-and-click) and the programmatic (code-based) features of Salesforce.\n\nTo help you get familiar with the different pieces that make up the Salesforce Platform, and to show you how you can optimize existing features—such as Visualforce pages and actions—for the Salesforce mobile experience, this book walks you through the process of enhancing an existing organization to make it mobile-ready and mobile-friendly.\nWho Is This Book For?\n\nThis book is broken up into two major sections. The first, Salesforce App Administration, is aimed at administrators, and takes you through the declarative Salesforce tools in Setup, where you can point-and-click your way through getting your organization ready for the Salesforce mobile experience. This includes how to optimize your page layouts for mobile, customize the navigation menu, create actions, and set up mobile notifications.\n\nThe second section, Developing for the Salesforce App, is for advanced administrators and developers who are comfortable working with code. To fully understand its chapters, you should be familiar with Visualforce and XML. We’ll walk through optimizing your Visualforce pages for mobile and creating custom actions.\n\nTip: Point-and-click admins, don’t let this deter you! We include code samples in most places, so even if you’re not an experienced developer, you can still try the steps in each chapter and get a feeling for what can be done with Salesforce.\n\nHow Do I Begin?\n\nIt’s up to you! You could begin by pointing-and-clicking your way through Configuring the Salesforce App and working all the way through Using Actions in the Salesforce App. Then, put your developer hat on and create custom actions or add canvas apps to further enhance your users’ Salesforce experience.\n\nIf you’re a seasoned developer, you could jump into the deep end first with the Welcome to Salesforce Platform Development chapter.\n\nAbout the Sample Scenario\n\nThe sample scenario for this book builds on the sample Warehouse data and code created in the Force.com Workbook. We took that data set and added some extras. We’ll use what was built there as a launching point, then add more to bring our sample organization into the mobile world of Salesforce.\n\nTo do this, we’ll walk through the steps as if we were someone with administrator privileges at a make-believe company called Acme Wireless.\n\nAbout Acme Wireless\n\nLet’s find out a little bit about our fictional company.\nAcme Wireless is a large company that repairs devices such as mobile phones, tablets, and gaming consoles. The company has a number of brick-and-mortar locations where customers can drop off devices for repair. In addition, these storefronts sell device accessories like tablet covers, mobile phone covers, power cords, rechargers, and so on.\n\nAcme Wireless maintains a central warehouse where all the repair parts and accessories are stored. The storefront locations order parts from the warehouse so that they can keep some inventory on hand. When they need a special part that’s not in stock, storefronts can special order it from the warehouse.\n\nAcme Wireless is also expanding its repair services by doing on-site service. Mobile technicians will go to various customer locations to provide on-site service, including personal residences, hotels, small business offices, and conference centers.\n\nHow Acme Wireless Uses Salesforce\n\nAcme Wireless uses Salesforce to track customers. These are often individuals who visit the storefronts, but can also be small businesses that have contracted with Acme Wireless for device support. Acme Wireless also uses Salesforce to track merchandise items and inventory in the warehouse, as well as to manage its billing and invoicing. They use two custom Web applications: one to track orders and process merchandise for shipment and one to track delivery of shipments to storefront locations.\n\nEmployees at Acme Wireless’s storefronts and the main office use Chatter internally to communicate about inventory levels, customer accounts, and orders.\n\nHow Acme Wireless Wants to Use the Salesforce App\n\nAcme Wireless wants to use the app to leverage its existing Salesforce organization and enable mobile technicians to access customer and merchandise data. The technicians should be able to see all their repair tickets for the day, locate a customer, look up inventory for any parts needed, order parts, check the status of orders, and so on.\n\nAcme Wireless also wants to enable their truck drivers, delivering products from the warehouses to the storefronts, to track and update their deliveries for the day without having to use a separate app. They also want to give the warehouse workers the ability to track customer orders and process them for shipping.\n\nAcme Wireless also wants to enable integration with legacy Web applications for order management.\nCHAPTER 3 Setting Up Your Work Environment\n\nIn this chapter ...\n\n- Install the Enhanced Warehouse Data Model\n- Download Salesforce\n\nTo follow along with the exercises in this book, you’ll need a Salesforce account and a Developer Edition organization. If you don’t have a Developer Edition organization, go to http://sforce.co/1om1gHf and sign up for a free Developer Edition account. Developer Edition is a fully functional version of Salesforce that you can use to develop Salesforce apps. Since it’s free, there are limits on the amount of users, bandwidth, and storage you’re allowed, but it includes all the features in Salesforce.\n\nAfter that, you’ll need to install the enhanced Warehouse data model into your organization, and then download Salesforce, if you haven’t already.\nInstall the Enhanced Warehouse Data Model\n\nTo prepare your developer organization for the exercises in this book, you need to import the Warehouse data model. You might be familiar with the Warehouse app if you’ve gone through the tutorials in the Lightning Platform Workbook. We took the Warehouse data from that guide and added a few extra things to it to help show you what Salesforce can do.\n\n2. Open a new browser tab or window, and navigate to https://github.com/forcedotcom/Salesforce1-Dev-Guide-Setup-Package. Do this in the browser that you logged in to your developer organization with.\n3. Open the README file.\n4. Click the link in the README file. This is the installation link for the enhanced Warehouse data package. You should be taken directly into your development organization to the Package Installation Details page.\n5. Click Install.\n6. Wait for the installation to finish.\n7. From the Lightning Platform app menu, select Warehouse.\n8. Click the Data tab.\n9. Click Create Data.\n\nAll right! The last step is to download Salesforce, then we’ll be ready to roll.\n\nDownload Salesforce\n\nIf you’ve already downloaded Salesforce, you can skip this step.\n\n1. Go to www.salesforce.com/mobile/, and download Salesforce for your device. You may be prompted to create a security PIN.\n2. Open Salesforce.\n3. Log in using your developer organization credentials.\nThe Salesforce app is automatically enabled for all organizations, except those that have auto-enabling turned off.\n\nThe app doesn’t require much configuration at the beginning, but before your users get started, you should:\n\n1. Define which users can access the Salesforce app.\n2. Enable notifications.\n\nSince we’re in a developer organization, we don’t need to worry about enabling users. Review the information about that in the next section, then we’ll get started by enabling notifications.\nDefining Which Users Can Use the Salesforce App\n\nImportant: This information is for reference only. We won’t be enabling users in this book, but this step is important when configuring the Salesforce app in your production organization.\n\nDownloadable Apps\n\nSalesforce for Android and Salesforce for iOS are connected apps. As a result, you can control the users who have access to the apps, as well as other security policies. By default, all users in your organization can log in to Salesforce for Android and iOS.\n\nYou can control security and access policies for Salesforce for Android and Salesforce for iOS using settings components that are installed from the managed Salesforce connected apps package. These components need to be installed in Salesforce:\n\n- Salesforce for Android\n- Salesforce for iOS\n\nThese components are automatically installed when one of your users installs Salesforce from the App Store or Google Play on a mobile device and authenticates with your organization by logging in to the mobile app.\n\nAlternatively, you can manually install the Salesforce and Chatter Apps connected apps package so you can review and modify the default security and access settings before rolling out Salesforce for Android and Salesforce for iOS to your users.\n\nWhen the Salesforce connected apps components are installed, they’re added to the Connected Apps page. (From Setup, enter Connected Apps in the Quick Find box, then select the option for managing connected apps.) Here, you can view and edit the settings for each of the apps, including controlling user access with profiles, permissions, and IP range restrictions. An error message is displayed if a restricted user attempts to log in to Salesforce for Android or Salesforce for iOS.\n\nMobile Browser App\n\nYou can control whether users can access Salesforce mobile web when they log in to Salesforce from a supported mobile browser. By default, mobile web is turned on for your organization.\n\n1. From Setup, enter Settings in the Quick Find box, then select Salesforce Settings.\n2. Select Enable the Salesforce mobile web to allow all users in your organization to access the app. Deselect this option to turn off access to the app.\n3. Click Save.\nWhen this option is turned on, users who log in to Salesforce from a supported mobile browser are automatically directed to the Salesforce mobile web experience. Logging in from an unsupported mobile browser loads the Salesforce Classic full site, even when this option is selected.\n\n**Important:** Use of the Salesforce Classic full site in a mobile browser isn’t supported. While you can disable Salesforce mobile web for your organization, and individual users can turn off mobile web for themselves, regular use of the full site in a mobile browser isn’t recommended. Your users may experience problems that Salesforce Customer Support won’t investigate.\n\nIt’s not possible to access the Lightning Experience full site from any mobile browser.\n\n### About Notifications\n\nNotifications let your users know when certain events occur in Salesforce. For example, notifications let users know when they receive approval requests or when someone mentions them in Chatter.\n\nThese types of notifications can appear to Salesforce app users.\n\n**In-app notifications**\n\n*In-app notifications* keep users aware of relevant activity while they’re using the Salesforce app. By tapping the notification bell, a user can view the 20 most recent notifications received within the last 90 days.\n\nIf Salesforce Communities is enabled for your organization, users see notifications from all of the communities they’re members of. To help users easily identify which community a notification came from, the community name is listed after the time stamp.\n\n**Push notifications**\n\n*Push notifications* are alerts that appear on a mobile device when a user has installed the Salesforce for Android and Salesforce for iOS but isn’t using it. These alerts can consist of text, icons, and sounds, depending on the device type. If an administrator enables push notifications for your organization, users can choose individually whether to receive push notifications on their devices.\n\nAs the first task in our fresh new development organization, let’s set up notifications for all the Acme Wireless mobile users.\n\n### Try It Out: Enable Notifications\n\nWe want all the mobile users in the Acme Wireless organization to receive notifications about events happening in the full Salesforce site, such as approval requests, or when they’re mentioned.\n1. From Setup, enter Connected Apps in the Quick Find box, then select Manage Connected Apps.\n\n2. If they’re not already selected, select both Enable in-app notifications and Enable push notifications.\n\n3. If you’re authorized to do so for your company, select Display full content push notifications.\n\n4. Click Save.\n\nNote: Enabling in-app notifications is an all-or-nothing process. Either they’re on for everyone, or off for everyone. Mobile users can’t customize, enable, or disable in-app notifications for themselves.\n\nNow that we’ve addressed notifications, let’s look at offline access in the app.\n\nAbout Offline Access in the Salesforce App\n\nOffline access is available for Salesforce for iOS and Salesforce for Android users only. We won’t be working with the app’s offline mode in this book, but this information is important if you have any users who want to take advantage of it.\n\nYour mobile users’ productivity doesn’t have to stop when there’s no connectivity. When you enable caching and Offline Edit, users can keep working, unimpeded by a subway commute, FAA regulations, capricious cellular signals, or bunker-style buildings. Offline access is available for Salesforce for Android and Salesforce for iOS. The beta version of Offline Edit requires version 10.0 of Salesforce for Android or Salesforce for iOS.\n\nCaching in the Salesforce app is enabled the first time someone in your org installs Salesforce for Android and Salesforce for iOS.\n\n<table>\n<thead>\n<tr>\n<th>Salesforce Data / Salesforce App Element</th>\n<th>Available for Offline Viewing</th>\n<th>Available to Create, Edit, or Delete Offline (Beta)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Navigation Menu</td>\n<td>Yes</td>\n<td>n/a</td>\n</tr>\n<tr>\n<td>Action Bar</td>\n<td>Yes</td>\n<td>Edit action: Yes</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Delete action: Yes</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Other actions: No</td>\n</tr>\n<tr>\n<td>Global Search</td>\n<td>Previous search results from current session</td>\n<td>n/a</td>\n</tr>\n<tr>\n<td>List Views</td>\n<td>If viewed in current session</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Salesforce Data / Salesforce App Element</td>\n<td>Available for Offline Viewing</td>\n<td>Available to Create, Edit, or Delete Offline (Beta)</td>\n</tr>\n<tr>\n<td>-----------------------------------------</td>\n<td>-----------------------------</td>\n<td>-----------------------------------------------</td>\n</tr>\n<tr>\n<td>Records for Recent Objects</td>\n<td>Yes, recently accessed records for the first five objects (excluding Files) in the Recent section of the Salesforce app navigation menu</td>\n<td>Yes, recently accessed records for the first five objects (excluding Files) in the Recent section of the Salesforce app navigation menu</td>\n</tr>\n<tr>\n<td>Records for Other Objects</td>\n<td>If viewed in current session</td>\n<td>If viewed in current session</td>\n</tr>\n<tr>\n<td>Related Records</td>\n<td>If viewed in current session</td>\n<td>If viewed in current session</td>\n</tr>\n<tr>\n<td>Salesforce Today</td>\n<td>Main page and mobile event records, if viewed in current session</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Salesforce Events</td>\n<td>If viewed in current session</td>\n<td>Create: No Edit and Delete: If viewed in current session</td>\n</tr>\n<tr>\n<td>Tasks</td>\n<td>Most recently accessed tasks from the first page of My Tasks list only</td>\n<td>Most recently accessed tasks from the first page of My Tasks list only (The simplified New Task form must be disabled)</td>\n</tr>\n<tr>\n<td>Notes</td>\n<td>If viewed in current session</td>\n<td>Create: Yes Edit: If viewed in current session Delete: No</td>\n</tr>\n<tr>\n<td>Files</td>\n<td>If viewed in current session</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Dashboards (Enhanced Charts)</td>\n<td>Most recently accessed only</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Dashboards (Legacy Charts)</td>\n<td>No</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Feeds, Groups, and People</td>\n<td>If viewed in current session</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Notifications</td>\n<td>If viewed in current session</td>\n<td>n/a</td>\n</tr>\n<tr>\n<td>Approvals (submit, approve, or reject)</td>\n<td>No</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Visualforce pages</td>\n<td>No</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\nChapter 4 Configuring the Salesforce App\n\n<table>\n<thead>\n<tr>\n<th>Salesforce Data / Salesforce App Element</th>\n<th>Available for Offline Viewing</th>\n<th>Available to Create, Edit, or Delete Offline (Beta)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Canvas Apps</td>\n<td>No</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Lightning pages</td>\n<td>No</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Salesforce App Settings</td>\n<td>Yes</td>\n<td>n/a</td>\n</tr>\n</tbody>\n</table>\n\nA Salesforce app session is the time between logging in and logging out of the app. Switching away from Salesforce app doesn’t end the session as long as the user doesn’t log out.\n\nAll right! We’ve addressed notifications and offline access, now let’s look at the navigation menu.\nCHAPTER 5 Customizing the Salesforce App Navigation Menu\n\nIn this chapter ...\n\n• About the Salesforce Navigation Menu\n• How the Navigation Menu Works\n\nBefore you can send your users out on their mobile adventure, they need a map to point the way to their destination.\n\nThe Salesforce app navigation menu is that map. And it’s up to you to draw it for them.\n\nHelp your mobile users get work done faster and more easily by configuring which items appear in the navigation menu and in which order.\nAbout the Salesforce Navigation Menu\n\nAnywhere your users see the icon, they can tap it to access the menu. As an administrator, you can customize what the menu contains.\n\nWhat You Can Include\n\nDepending on how your organization is configured and what they have access to, your users could see multiple items in their navigation menu.\n\n<table>\n<thead>\n<tr>\n<th>Menu Item</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Approval Requests</td>\n<td>Displays a list of the user’s pending approvals. Users can tap an approval item and approve or reject it from within Salesforce. Available in Salesforce for iOS and mobile web.</td>\n</tr>\n<tr>\n<td>Canvas apps</td>\n<td>Appears for organizations that have enabled a canvas app to appear in the navigation menu.</td>\n</tr>\n<tr>\n<td>Chatter</td>\n<td>The user’s main feed. Appears for organizations that have Chatter enabled.</td>\n</tr>\n<tr>\n<td>Dashboards</td>\n<td>Availability depends on edition and user permissions. If you don’t add this item to the navigation menu, dashboards are automatically included in the set of Smart Search Items instead and the Dashboards item is available from the Recent section.</td>\n</tr>\n<tr>\n<td>Events</td>\n<td>Lists events owned by the user, that the user created for him- or herself, and that the user or a user’s groups are invited to. If you don’t add this item to the navigation menu, events are automatically included in the set of Smart Search Items instead and the Events item is available from the Recent section.</td>\n</tr>\n<tr>\n<td>Forecasts</td>\n<td>Displays the Forecasts app, a helpful tool for every member of a sales team to keep track of forecast data and monitor progress towards quota. Available in Salesforce for iOS only.</td>\n</tr>\n</tbody>\n</table>\n\nNote: Your org must have Collaborative Forecasts enabled. If your org uses Customizable Forecasts, the Forecasts item isn’t available to add to the navigation menu.\n\n<p>| Groups | Appears for organizations that have Chatter enabled. If you don’t add this item to the navigation menu, groups are automatically included in the set of |</p>\n<table>\n<thead>\n<tr>\n<th><strong>Menu Item</strong></th>\n<th><strong>Description</strong></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Smart Search Items</td>\n<td>Smart Search Items instead and the Groups item is available from the Recent section.</td>\n</tr>\n<tr>\n<td>Lightning component</td>\n<td>Only custom Lightning components that have a Lightning component tab associated with them can appear in the navigation menu.</td>\n</tr>\n<tr>\n<td>Lightning component</td>\n<td>Custom app pages.</td>\n</tr>\n<tr>\n<td>Lightning pages</td>\n<td>Custom app pages.</td>\n</tr>\n<tr>\n<td>News</td>\n<td>Displays the News app, a one-stop place for news and other insights about the user’s accounts, contacts, leads, and opportunities.</td>\n</tr>\n<tr>\n<td>Notes</td>\n<td>Displays the Notes app. If you don’t add this item to the navigation menu, notes are automatically included in the set of Smart Search Items instead and the Notes item is available from the Recent section.</td>\n</tr>\n<tr>\n<td>Paused Flow Interviews</td>\n<td>Displays a list of flow interviews that the user paused. An interview is a running instance of a flow. Users can tap an interview and resume or delete it. Available in Salesforce mobile web only.</td>\n</tr>\n<tr>\n<td>People</td>\n<td>Appears for organizations that have Chatter enabled. If you don’t add this item to the navigation menu, profiles are automatically included in the set of Smart Search Items instead and the People item is available from the Recent section.</td>\n</tr>\n<tr>\n<td>Reports</td>\n<td>Availability depends on edition and user permissions. If you don’t add this item to the navigation menu, reports are automatically included in the set of Smart Search Items instead and the Reports item is available from the Recent section.</td>\n</tr>\n<tr>\n<td>Smart Search Items</td>\n<td>Adds standard and custom Salesforce objects to the Recent section in the menu. This item also adds a set of the user’s recently accessed objects to the Recent section and adds the More item so users can access all the objects they have permission to use and that are supported. If you don’t include this item in the navigation menu, users can’t access any objects on the navigation menu.</td>\n</tr>\n</tbody>\n</table>\n\n**Note:** Smart Search Items is required for users to get search results in Salesforce for Android. Users of Salesforce for iOS and the Salesforce mobile web are able to search for records if this option is omitted from the navigation menu.\nMenu Item | Description\n--- | ---\n | If your iOS downloadable app users don’t yet have a history of recent objects, they initially see a set of default objects in the Recent section. For Salesforce for Android and Salesforce mobile web, the default set of objects match the Lightning Experience Navigation Bar that the admin has configured in the Lightning App. If the user doesn’t have access or permissions to the Lightning App, they also see a default set of objects until the user’s most frequently used objects are determined. It can take up to 15 days for the objects that users work with regularly in both the Salesforce app and the full Salesforce site to appear in the Recent section. To make objects appear under Recent sooner, users can pin them from the search results screen in the full site.\nTasks | Lists of a user’s open and closed tasks and tasks that have been delegated. If you don’t add this item to the navigation menu, tasks are automatically included in the set of Smart Search Items instead and the Tasks item is available from the Recent section.\nToday | An app that helps users plan for and manage their day by integrating mobile calendar events with associated Salesforce tasks, accounts, and contacts. The app also allows users to instantly join conference calls, quickly log notes about events, and more. Available in Salesforce for Android and iOS only.\nVisualforce page tabs | Only Visualforce pages with the Available for Lightning Experience, the Salesforce app, and Lightning Communities checkbox selected will display in the Salesforce app.\n\nWe won’t get into Visualforce pages in these exercises, but to learn more about them and how they work in Salesforce, see Extending the Salesforce App with Visualforce Pages on page 79.\n\nTry It Out: Configuring the Salesforce App Navigation Menu\n\n1. From Setup, enter Navigation in the Quick Find box, then select Salesforce Navigation. Some items are automatically added to the menu.\n\n The order in which you put the items in the Selected list is the order that they display in the navigation menu. Also, the first item you put in the list becomes your users’ Salesforce app landing page. The Acme Wireless mobile technicians will probably be using the Today and Tasks menu items the most, so we want to put those at the top.\n2. Using the Up or Down arrows, arrange the top items in the Selected list like so:\n • Chatter\n • Today\n • Tasks\n • Smart Search Items\n • Dashboards\n\n Now whenever a mobile technician logs in to Salesforce, the Today page will be the first thing they see.\n\n3. Click Save.\n\nLet’s go look at our changes.\n\nTest Out the Salesforce App Navigation Menu\n\n1. Open Salesforce on your mobile device.\n2. Tap ☰ to access the navigation menu.\n3. Pull down and release the navigation menu to refresh it.\n You should see the Chatter, Today, Tasks items at the top, and then the Recent section, which is created from the Smart Search Items element.\n4. Scroll down to the Apps section.\n This section contains any menu item that was put below the Smart Search Items element, whether it’s really an “app” or not.\nNow that we’ve addressed the navigation menu, let’s look at configuring our data for mobile.\n\nHow the Navigation Menu Works\n\n- The first item in the Selected list becomes your users’ Salesforce app landing page.\n- You can’t set different menu configurations for different types of users.\n- When organizing the menu items, put the items that users will use most at the top. The Smart Search Items element can expand into a set of eight or more menu items and it might end up pushing other\nelements below the scroll point if you put it near the top of the menu. Anything you put below the Smart Search Items element appears in the Apps section of the navigation menu.\n\n- Before you can include Visualforce pages, Lightning pages, or Lightning components in the Salesforce app navigation menu, create tabs for them. From Setup, enter Tabs in the Quick Find box, then select Tabs.\n\n- Anything represented by a tab in Salesforce—such as standard and custom objects, Visualforce pages, the Chatter feed, People, or Groups—is visible for a user in the Salesforce app menu, based on the user’s profile settings. For example, if a user is assigned to a profile that has the Groups tab set to Tab Hidden, the user won’t see the Groups menu item in the Salesforce app, even though an administrator has included it in the menu.\n\nSome objects are excluded from the Recent section in the navigation menu, even if you accessed them recently.\n\n- People, groups, notes, dashboards, reports, tasks, and events, if these items were added directly to the navigation menu\n- List views, which are shown only on object home pages, not in the navigation menu\n- Objects that aren’t available in the Salesforce app, including any objects that don’t have a tab in the full Salesforce site\n\n### About the Dashboards, Reports, Notes, Tasks, Events, Groups, and People Menu Items\n\nIf you opt to add the Dashboards, Reports, Notes, Tasks, Events, Groups, or People items to the Selected list for the navigation menu, these items appear in the order you specify, just like Today and other individual menu items.\n\nIf you don’t add these items to the navigation menu, however, they’re automatically included in the Smart Search Items set of objects and show up in the Recent section of the navigation menu.\n\n### Pin an Object into the Recent Section\n\nUsers can customize the objects that appear in the Recent section of the navigation menu. If they search for an object in the full site, they can hover their mouse over the object name and click to pin it to the top of the search results. The order of pinned objects in the full site determines the order of the objects that stick to the top of the Recent section of the navigation menu. However, pinning objects in this way causes the unpinned objects remaining in the Recent section to drop into the More element.\nCHAPTER 6\n\nCustomizing How Your Data Shows Up in the Salesforce App\n\nIn this chapter ... \n\n• How Page Layouts Work in the Salesforce App \n• About Compact Layouts\n\nWe’ve done the basic configuration for the Salesforce app; now it’s time to consider how we can optimize things in the full Salesforce site to give our users the best possible mobile experience. First, we’ll customize how our Salesforce data shows up when presented in a mobile context.\n\nTwo factors affect how information is displayed in the Salesforce app. One has been around for a while: page layouts. The other is newer: compact layouts. You’ll learn about both in this chapter.\nHow Page Layouts Work in the Salesforce App\n\nUse the enhanced page layout editor to customize the layout of an object’s record detail pages, configure actions, and adjust which fields and related lists appear in the Salesforce mobile app.\n\nIn the Salesforce mobile app, page layouts drive these areas of the mobile experience.\n\nRecord Related Information and Detail Pages\n\nWhen you view a record in the mobile app, you see the fields, Visualforce pages, and related lists that are based on the record type and the user’s profile. Related lists show up as single-line cards containing the name of the page or related list. Tapping the related list card displays its details.\n\nMobile Cards\n\nYou can add expanded lookups, components, canvas apps, and Visualforce pages to the Mobile Cards section of your page layout to have them show up as mobile cards in the mobile app. The elements you place in this section don’t show up on a record’s detail page in the full Salesforce site. They appear only on the record’s related information page in the mobile app.\n\nNote: In organizations that are created after Spring ’14, the Twitter component is added by default to the Mobile Cards section of page layouts for objects that support it.\n\nActions\n\nActions in the Salesforce Mobile and Lightning Experience Actions section of a page layout appear in the action bar and action menu on the object’s record pages.\n\nHere are the record detail page, related information page, and action menu for a sample account, Edge Communications:\nWe’ll cover actions in a later chapter. For now, let’s focus on record pages and mobile cards.\n\nRethinking Your Page Layouts for Mobile\n\nPage layouts containing dozens of fields and lots of related lists might be manageable when viewing records on a computer screen, but on a small mobile device, viewing that same record can be overwhelming. People accessing information using a mobile device are looking for a quick way to get what they need, and making your users sift through hundreds of fields and related lists just doesn’t make sense.\n\nFor example, in our Warehouse data model, our custom page layout has 32 standard and custom fields. That may not seem like many, but in a mobile context, fields add up quickly. In the full Salesforce site, an account record detail page using the Warehouse Schema Account Layout looks like this:\nIn the Salesforce app, the same account detail page looks like this:\n\nWe only show three here, but there were five pages of scrolling, and that’s from a page layout with only 32 fields! If you were a mobile user trying to find specific fields in a record detail with dozens of fields on\nyour phone, you’d have to scroll... and scroll... and scroll. It’s not the best user experience and it’s definitely not good for your users’ productivity.\n\nYou have two options for handling page layouts for your mobile users: re-engineer your existing page layouts, or create new page layouts that are mobile-friendly from the outset.\n\nWe’ll look at both options. First, we’ll walk through creating a fresh mobile-friendly page layout, then we’ll discuss tips and tricks for optimizing existing long layouts for a mobile audience.\n\n**Try It Out: Create a Custom Page Layout for the Mobile Technicians Profile**\n\nUsers like the mobile technicians at Acme Wireless will spend the majority of their time accessing Salesforce from a mobile device. We can create a streamlined, mobile-optimized page layout assigned to the Mobile Technician profile, with only the items they need when on-site, and, voilà! Instant productivity boost.\n\nIn addition, using the specialized Mobile Cards section of the page layout, we can enhance the record’s related information page by adding Visualforce pages and lookup cards.\n\n1. From the object management settings for accounts, go to Page Layouts.\n2. Click **New**.\n3. Leave the Existing Page Layout drop-down list set to –None–.\n - We want to start with a clean slate for this page layout, so we’re choosing not to clone an existing page layout.\n4. Enter **Account Mobile Technician Layout** in the Page Layout Name field.\n5. Click **Save**.\n - Required fields and “Always on Layout” fields are pre-populated onto the page layout. We just need to add a few more that are pertinent to the mobile technicians.\n6. Drag these fields from the palette into the Account Detail portion of the page, below the existing fields.\n - Shipping Address\n - Business Hours\n - Phone\n7. Click the Visualforce Pages category in the palette and drag Account Location into the Mobile Cards section.\nAccount Location is a preconfigured Visualforce page that shows the user the location of the selected account on a Google map. In Salesforce, this will show up as a mobile card on the account record related information page.\n\nNote: Only Visualforce pages with the Available for Lightning Experience, the Salesforce app, and Lightning Communities checkbox selected will display in the Salesforce app. Mobile-enabled Visualforce pages show up as slightly differently colored elements in the palette than their non-mobile-enabled counterparts. Hovering your mouse over a Visualforce page element in the palette shows whether the Visualforce page is mobile-enabled.\n\nFor more detailed information about using Visualforce in the Salesforce app, see Extending the Salesforce App with Visualforce Pages on page 79.\n\n8. Click the Expanded Lookups category and drag Parent Account into the Mobile Cards section, above the Account Location mobile card.\n\nParent Account is a lookup field, and putting it into the Mobile Cards section makes it display as a related lookup card on the account’s related information page.\n\n9. Click the Related Lists category and drag the Cases and Contacts related lists to the Related Lists section.\n\nRelated lists show up on the record related information page in the Salesforce mobile app. When the mobile technicians navigate to an account’s related information page, they’ll see preview cards for the related lists that they can tap to get more information about the cases and contacts for that location.\n\n10. Click Save.\n\n11. Click No when asked if you want to override users’ customized related lists.\n\n12. Click Page Layout Assignment.\n\n13. Click Edit Assignment.\n\nIn this step, you would normally assign the new mobile-optimized page layout to a user profile for the mobile technicians. However, since you’re logged in as a system administrator, we’re going to have you assign it to the System Administrator profile instead.\n\n14. Click the System Administrator line item to select it.\n\n15. Select Account Mobile Technician Layout from the Page Layout to Use drop-down list.\n\nThe System Administrator profile should now be assigned to the Account Mobile Technician Layout.\n\n16. Click Save.\n\nNow let’s check out what we did.\nTest the Page Layout\n\n1. Open Salesforce on your mobile device and log in.\n2. Tap \\( \\equiv \\) to access the navigation menu.\n3. In the Recent section, tap Accounts. You may have to tap More... to find it.\n4. Tap the search bar.\n5. Enter Barbary.\n6. Tap Search.\n7. Tap Barbary Coast Wireless.\n You’re on the Barbary Coast Wireless record detail page, which is the default view when accessing a record. Scroll down a bit, and you should see the same fields we added to the page layout, in the same order.\n\n8. Tap Related to get to the related information page.\n You should see the Parent Account lookup card and the preview card for the Visualforce page first.\nScroll down and you should also see the related lists that we added to the page layout. Tap a related list to see its details.\n\nNow that we’ve created this specialized page layout and added the fields our mobile technicians will need, their jobs will be much easier when they go on site. When they visit an account record’s related information page, they won’t have to shuffle through a long list of unnecessary fields to find the ones they really want. And, since we added the Visualforce page as a mobile card, they’ll be able to see the location of an account on a Google map.\n\nIn the Actions chapter, we’ll enhance this page layout with special actions we’ve created just for our mobile technicians. But for now, let’s go over some recommendations for paring down existing page layouts to make them more mobile friendly.\n\n**Tips for Optimizing Page Layouts for Mobile**\n\nIn many cases, creating a new mobile-only page layout may not make sense. Here are some tips and tricks to making your existing page layouts more mobile friendly.\n\nWhen optimizing a page layout, consider:\n\n- What are the important things to see at a glance?\nWhat are the important moments for your users when they’re working in the Salesforce mobile app?\nWhat actions or processes can you automate so that your users don’t have to manually do them?\n\nThe Key: Organize and Minimize Fields\n\n- Use sections to organize information logically, putting the most important things at the top of the page so they show up first. Your users don’t want to search for fields individually. Organizing similar fields in sections will help your users find what they need. They can then easily scroll down the page to the section they care about.\n- For accounts, contacts, and leads, you don’t need to put phone or email fields near the top. They’re already quickly accessible via the phone and email icons on each record page’s action bar.\n- You don’t need to keep fields in one column, as the page will render dynamically based on the device that’s viewing it. A phone will reorder the fields into a single column, and a tablet or desktop will show two columns.\n- Put the most important fields into the compact layout—which drives record highlights and record preview cards in the mobile app—so they’re available right up front, and so your mobile users don’t have to drill into the record detail. We’ll get into compact layouts in more detail soon.\n- Keep the number of required fields to a minimum. Setting a field to required means it must appear on the detail page of all page layouts, so consider whether each field is truly required. You might have to convince stakeholders that a field isn’t actually necessary for a record to be saved.\n- If available in your organization, think about using record types so that fields that aren’t common to all records don’t have to appear on all records.\n- To reduce the number of fields on a screen, consider using default values for new records instead of having the user enter the data.\n\nWe’ve gone over page layouts. Now let’s get into another kind of layout, created especially for mobile: the compact layout.\n\nAbout Compact Layouts\n\nIn the last section, we learned how page layouts affect the look and content of records in the Salesforce app. But page layouts aren’t the only thing used to help customize how your Salesforce data appears in a mobile environment.\n\nA compact layout displays a record’s key fields at a glance in both the Salesforce mobile app and Lightning Experience.\n\nIn the full Salesforce site, a compact layout determines which fields appear in the Chatter feed item that appears after a user creates a record with a quick action.\nChapter 6 Customizing How Your Data Shows Up in the Salesforce App\n\nIn the Salesforce mobile app, the first four fields that you assign to a compact layout appear in:\n\n- An object record’s highlights area\n- Expanded lookup cards on a record’s related information page\n\nIf a user doesn’t have access to one of the fields that you assign to a compact layout, the next field on the layout is used.\n\nThe first four fields you assign to your compact layout populate the record highlights section at the top of each record view in the Salesforce app, so we’ll put the fields we think our mobile technicians most want to see into the list.\n\nCreating and customizing compact layouts for objects isn’t required for the Salesforce app, because system defaults are provided out of the box. However, we recommend using compact layouts to put important fields into object record headers—and elsewhere—to help your mobile users get the information they need quickly. Let’s give it a try.\n\nTry It Out: Create a Compact Layout\n\nAs with page layouts, there are separate compact layouts for each object. By default, each object derives its record highlight fields, preview cards, and action-related feed items from the predefined set of fields in the object’s read-only, system default compact layout. You can create custom compact layouts on an object-by-object basis. After you create one or more custom compact layouts, you set one as the primary compact layout for the object. The primary compact layout is then used as the new default for that object.\n\nWe’ll create a custom compact layout, and then set it as the primary compact layout for the Merchandise object. Our new compact layout is used to render important merchandise record fields first in Salesforce for the Acme Wireless mobile technicians.\n\nBefore we can see compact layouts in action, though, we need a Merchandise record in our organization. Let’s quickly create one.\n\n1. From the app menu, select Warehouse.\n2. Click the Merchandise tab.\n3. Click New.\n4. For Merchandise Name, enter iPhone 6.\n5. For Price, enter 599.\n6. For Quantity, enter 10.\n7. Click the Warehouse lookup, then select Oaklandia.\n8. Set the Condition to Refurbished.\n9. Click Save.\nCurrently, the Merchandise object uses its system default compact layout, which only has the Merchandise Name field assigned. Here’s what our iPhone 6 record looks like:\n\nLet’s add more fields alongside that “iPhone6” so our mobile users can see more pertinent information right at the top of the Merchandise record pages.\n\n1. Navigate to the Merchandise custom object in Setup. From the Compact Layouts related list, click New.\n2. In the Label field, enter Customized Compact Layout.\n3. Select these fields for the compact layout, and then click Add.\n When on site, these are the most important fields for our mobile technicians to see. You can select and add them individually or select them as a group using CTRL-click.\n - Condition\n - Merchandise Name\n - Price\n - Quantity\n4. Using the **Up** or **Down** buttons, adjust the list so that the fields are in this order: Merchandise Name, Quantity, Condition, Price.\n\n5. Click **Save**.\n Now we need to set our compact layout as the primary.\n\n6. Click **Compact Layout Assignment**.\n You can see that the primary compact layout is set to the System Default here. We need to change that.\n\n7. Click **Edit Assignment**.\n\n8. Select the compact layout you just created to use as the primary compact layout.\n\n9. Click **Save**.\n\nWe’ve customized a compact layout for the Merchandise object. Now let’s see what its related information page looks like.\n\n**Test the Compact Layout**\n\nWhen you customize a compact layout and assign it as the default, as we just did, the changes are reflected in Salesforce immediately.\n\n1. Open Salesforce on your mobile device.\n\n2. Tap 📡 to access the navigation menu.\n\n3. In the Recent section, tap **Merchandise**. You may have to tap **More...** to find it.\n\n4. Tap the **iPhone 6** item.\nAs you can see, the record highlights area has the fields from our newly-created custom compact layout. Instead of seeing just the merchandise name, as on the system default layout, the Acme Wireless mobile technicians can now see much more: that there are ten refurbished iPhone 6s in stock at the warehouse, and they cost $599.00 each.\n\n**Tell Me More: Compact Layouts**\n\nWe’ve gone over a lot about compact layouts, but here are a few more tidbits about how they work. Compact layouts support all field types except:\n\n- text area\n- long text area\n- rich text area\n- multi-select picklist\n\nIf a user doesn’t have access to one of the fields that you assign to a compact layout, the next field on the layout is used.\nRemoving a field from a page layout doesn’t remove it from the object’s compact layout. The two layout types are independent.\n\nFields that aren’t available in the SOAP API don’t show up on compact layouts in the Salesforce app.\n\n**Compact Layouts and Record Types**\n\nIf you have record types associated with an object, you can override the object’s primary compact layout and assign different compact layouts to some or all of the record types. Each record type can have only one compact layout assigned to it. If you don’t set any record type overrides, all record types use the object’s primary compact layout by default.\n\nTo find out more about compact layouts and record types, see “Assign Compact Layouts to Record Types” in the Salesforce Help.\nAs an administrator, you can enable valuable micro-moments for all of your users by creating unique actions. When thinking about what actions you might want to create specifically for the Salesforce app, ask your users what they wish they could do in the mobile context.\n\nFor example, an administrator at a food service company could create an \"Emergency Order\" action that allows their delivery drivers to immediately order extra or missing food items using their mobile phone while still at a customer site. Creating actions for the Salesforce app can drive adoption in your organization and make you a hero to your users!\n\nIn this chapter, we’ll learn about types and categories of actions, how to create and customize them in Salesforce using point-and-click tools, and how they can help mobile users get essential work done while away from the office.\nQuick Actions\n\nCreate quick actions, and add them to your Salesforce Classic home page, to the Chatter tab, to Chatter groups, and to record detail pages. Choose from standard quick actions, such as create and update actions, or create custom actions based on your company’s needs. In addition, actions have their own action layouts, which let you specify which fields are included in the action, and in which order.\n\nWhere Do Actions Appear?\n\nIn the Salesforce app, actions appear in the action bar and its action menu.\n\nActions also appear in an action bar on list items such as task lists and related record lists. This gives your mobile users the ability to work with records directly from lists and update records without having to open them. To access list item actions, navigate to the task list or open a related list from an object’s related information page. Then swipe left on the desired record.\n\nObject-Specific Quick Actions\n\nObject-specific actions let users quickly create or update records, log calls, send emails, and more, in the context of a particular object. For example, you add an object-specific action on the Account object that creates contacts. If a user creates a contact with that action on the detail page for the Acme account, that\nnew contact is associated with Acme. You can only add an object-specific action to page layouts for that object.\n\n**Global Quick Actions**\n\nYou can add global quick actions to almost any page that supports actions. Use global actions to let users log call details, create or update records, or send email, all without leaving the page they’re on. Global create actions enable users to create object records, but the new record has no direct relationship with other records.\n\n>Note: Actions to create records for an object that is the detail object in a master-detail relationship must be object-specific, not global.\n\n**Quick Action Types**\n\nThere are several types of object-specific and global quick actions.\n\n- *Create actions* let users create records—like New Contact, New Opportunity, and New Lead. Global create actions enable users to create object records, but the new record has no direct relationship with other records. Object-specific create actions create records that are automatically associated with related records. They’re different from the Quick Create and Create New features on the Salesforce Classic home page, because create actions respect validation rules and field requiredness, and you can choose each action’s fields.\n\n- *Update actions* let users make changes to a record.\n\n- *Log a Call actions* let users record the details of phone calls or other customer interactions. These call logs are saved as completed tasks. Object-specific Log a Call actions let users enter notes about calls, meetings, or other interactions that are related to a specific record.\n\n- *Custom actions* invoke Lightning components, flows, Visualforce pages, or canvas apps with functionality that you define. Use a Visualforce page, Lightning component, or a canvas app to create global custom actions for tasks that don’t require users to use records that have a relationship to a specific object. Object-specific custom actions invoke Lightning components, flows, Visualforce pages, or canvas apps that let users interact with or create records that have a relationship to an object record.\n\n- Object-specific Send Email actions, available only on cases, give users access to a simplified version of the Case Feed Email action in the Salesforce mobile app. You can use the case-specific Send Email action in Salesforce Classic, Lightning Experience, and the Salesforce mobile app.\n\n- Global *Send Email actions* are supported only in Lightning Experience. You can’t add them to the Cases layout or use them with cases.\n\n- *Question actions* enable users to ask and search for questions about the records that they’re working with.\nFor create, log-a-call, and custom actions—which we'll go over at the end of this chapter—you can create either object-specific quick actions or global quick actions. Update actions must be object-specific.\n\nFor a list of supported objects for object-specific and global actions, see \"Object-Specific Actions\" and \"Global Quick Actions\" in Salesforce Help.\n\n**Action Categories**\n\nActions fall into several different categories. What you see depends on the age and configuration of your org.\n\n**Standard Chatter actions**\n\nStandard Chatter actions are actions that are included automatically when Chatter is enabled: Post, File, Link, Poll, and, in orgs that use work.com, Thanks. Standard actions can also include any actions that you created for your org using point-and-click methods, such as create or Log A Call actions.\n\n**Default actions**\n\nDefault actions are sets of predefined actions to get you and your users started using actions in your org. Add default actions to publisher layouts to make them available to your users in the full Salesforce site and the action bar in the Salesforce mobile app. Default actions are sets of predefined actions to get you and your users started using actions in your org.\n\nBecause our Development org is new, it contains a set of default actions. You can check out the default global actions: From Setup, enter Global Actions in the Quick Find box, then select Global Actions.\n\nFor a list of which default actions appear on which object, see “Default Actions” in the Salesforce Help.\n\n**Mobile smart actions**\n\nMobile smart actions are a set of preconfigured actions and are supported on the same list of objects as default actions. However, they appear in orgs created before Winter ’14 and are displayed only in the Salesforce app.\n\nMobile smart actions appear as a single action element in the page layout editor. In the Salesforce mobile app, the Mobile Smart Actions element expands to distinct create actions that enable users to create records directly from the action bar.\nMobile smart actions are populated with all your org’s required fields on the relevant object, regardless of how many fields there are. For example, the New Case action in the mobile smart action bundle includes all required case fields. You can’t edit the fields on mobile smart actions. The fields that appear change only if you change which fields on an object are required.\n\nMobile smart actions don’t appear in the full Salesforce site, regardless of which page layouts you add them to. They appear only to users in the Salesforce mobile app.\n\nFor a list of what the mobile smart action element on each supported object expands to include, see “Mobile Smart Actions” in the Salesforce Help.\n\nCustom quick actions\n\nCustom quick actions are actions that you create and customize, such as Create a Record, Send Email, or Log a Call actions. Quick actions can also invoke Lightning components, flows, Visualforce pages, or canvas apps with functionality that you define. For example, you can create an action so that users can write comments that are longer than 5,000 characters. Or, you can create an action that integrates a video-conferencing application so that support agents can communicate visually with customers.\n\nWe’ll touch briefly on custom actions later in About Custom Actions, but you can find out much more about them in the Adding Functionality with Visualforce Custom Actions chapter.\n\nProductivity Actions\n\nProductivity actions are predefined and attached to a limited set of objects. Productivity actions include Send Email, Call, Map, View Website, and Read News. Except for the Call action, you can’t edit or delete productivity actions.\n\nPoint and Click Your Way to Actions\n\nIn the next set of tasks, we’ll create an object-specific action. But that’s only the first step. There are a few things we need to do after that to make sure the action shows up where it’s supposed to in both the Salesforce app and the full Salesforce site, and that it’s optimized for a mobile experience.\n\nThese are the steps you need to follow when setting up actions. We’ll go through all of them.\n\n1. Create a global or object-specific action.\n2. Customize the action’s layout, choosing the fields users see when they use it.\n3. If you created an object-specific action, add it to one or more of that object’s page layouts. If you created a global action, add it to a global publisher layout.\n4. Set predefined field values for required fields, where possible.\n\nLet’s get started!\nTry It Out: Create an Object-Specific Action\n\nLet’s give the mobile technicians at Acme Wireless a way to quickly log a case while they’re still on site with a customer. If we put a record create action on the Account object with Case as the target object, the technicians can browse to a customer account record on their mobile device. They can also log cases directly from there.\n\n1. In the object management settings for accounts, go to Buttons, Links, and Actions.\n2. Click New Action.\n3. For Action Type, select Create a Record.\n4. For Target Object, select Case.\n5. For Label, enter Create a Case.\n6. Click Save.\n\nAfter saving, we’re dropped directly into the action layout editor, where we can customize the fields assigned to the action. We’ll get to action layouts shortly. But before we do, there’s one more thing we need to do: assign the action to an account page layout.\n\nTry It Out: Assign the Action to the Account Page Layout\n\nBefore the object-specific quick action can appear in the Salesforce mobile app, you need to add it to a page layout.\n\n1. We’re already in the Buttons, Links, and Actions area for accounts. Now navigate to Page Layouts.\n2. Click Edit next to Account Mobile Technician Layout.\n\n This layout is the one you created in the Page Layouts chapter. The Salesforce Mobile and Lightning Experience Actions section is empty, and a message says that Salesforce has predefined the actions on this layout. Because this page layout is for Acme Wireless mobile technicians, we want to customize the actions to match the work the technicians need to do when they’re in the field.\n\n3. In the Salesforce Mobile and Lightning Experience Actions section, click override the predefined actions.\n\n Tip: If you haven’t customized the Salesforce Mobile and Lightning Experience Actions section of a page layout, the actions for that object default to a set of predefined actions. If you have customized actions in the Quick Actions in the Salesforce Classic Publisher section, and have saved the layout, the Salesforce Mobile and Lightning Experience Actions section inherits the actions from the Quick Actions in the Salesforce Classic Publisher section, plus any standard or custom buttons present on the layout, when you click to override.\n4. Click the Mobile & Lightning Actions category in the palette and then adjust the actions in the Salesforce Mobile and Lightning Experience Actions section to match this list.\n\n- Create a Case\n- Log a Call\n- New Contact\n- New Opportunity\n- New Task\n- Post\n- File\n\nBecause the Create a Case action is important to the mobile technicians, we put it first in the list so that they can access it directly from the action bar.\n\nNotice there's also a New Case item in the palette. The New Case item is a global default action associated with the Account object. We're going to customize our object-oriented Create a Case action, so we don’t need the redundant global action.\n\nTip: On object page layouts, the Mobile & Lightning Actions category contains all available types of actions for the object, including quick actions, productivity actions, Lightning component actions, and standard and custom buttons.\n\n5. Click Save.\n\nOur new Create a Case action appears in the action bar on account records in the Salesforce mobile app for all the mobile technicians.\n\nNow that’s all done, let’s go over global actions. Then we’ll revisit action layouts and customize our Create a Case action.\n\nAbout Global Quick Actions\n\nGlobal create actions enable users to create object records, but the new record has no direct relationship with other records. Actions tied to specific objects are only accessible from those objects’ record pages; however, global actions can be added to any supported objects’ page layouts as well as to global layouts, so they’re very useful for quickly creating records.\nCreating Global Quick Actions\n\nYou create global actions in a different place in Setup than you create object-specific actions. To create a global action, from Setup, enter *Actions* in the *Quick Find* box, then select *Global Actions*. They’re called *global actions* because they can be put anywhere actions are supported.\n\nThe Global Publisher Layout\n\nGlobal publisher layouts determine the global actions that appear in the various Salesforce interfaces. In Salesforce Classic and Lightning Experience, these layouts customize the actions on global pages (like the Home page) and on the Chatter page. Lightning Experience also uses these layouts to populate the Global Actions menu. And in the Salesforce app, these layouts drive the actions that appear in the action bar on the Feed and People pages. Global publisher layouts can include global actions only. You can assign different global publisher layouts to different user profiles to customize which actions users see by default on global pages.\n\nIn the Salesforce app, global actions appear in the action bar and action menu on pages to which the global publisher layout applies. Before our global action will show up either in the full Salesforce site or in the app, we need to add it to the global publisher layout.\n\nTell Me More: Actions\n\n- If you add an action to a page layout, but a user assigned to the profile that uses that page layout can’t see the action either in the full Salesforce site or in the Salesforce app, it might be because:\n - If it’s a create action, the profile might not have access to create the record type of the action.\n - The user doesn’t have both Read and Edit permission on the action’s relationship field. The relationship field is the field that’s automatically populated on the target object when a user creates a record using an action. For example, for an action on a case that lets users create child cases, the default relationship field is *Parent Case*. To be sure that users can see the Create Child Case action, check that they have both Read and Edit permissions on the *Parent Case* field.\n\n- You can remove a required field from the action layout, but make sure that the field has a predefined value. Otherwise, users can’t create records.\n\nFor more tips, see *Action Guidelines and Best Practices* on page 64.\n\nAbout Action Layouts\n\nJust as object record pages have page layouts that can be customized, actions have action layouts that can be customized. We do this in the action layout editor.\nWhen you create an action, Salesforce populates its layout with a default set of fields. You can add, remove, or reorder fields on the action layout to present only the essential items your users need when they’re taking the action.\n\nThe upper part of the action layout editor is the palette, and below the palette is the action layout. The palette contains fields from the action’s target object that you can add to the action layout, except for the following unsupported field types:\n\n- Record type fields\n- Read-only field types such as roll-up summary, formula, and auto-number fields\n- Read-only system fields such as Created By or Last Modified By\n\n**Inactive Fields**\n\nFields that are already on the action layout still appear on the palette but are inactive. When you select an inactive field on the palette, Salesforce highlights the field on the action layout.\n\n**Field Type Conversion**\n\nIf you convert a field’s type from one that is supported for actions to a type that isn’t supported, Salesforce removes the field from the action layout. If you convert the field back to a supported type\nwithout changing the action layout, Salesforce automatically adds the field back to the layout. If you edit the layout, and then convert the field back to a supported type, add the field back to the layout manually.\n\n**Layouts Used for Log a Call Actions**\n\nA Log a Call action takes the active task page layout except under the following conditions:\n\n- Suppose that your organization has a custom Log a Call action for an object. The custom action takes the custom action layout defined for it.\n- Now suppose that your organization has a custom Log a Call global action. That action takes the custom layout defined for it, unless you also have a custom Log a Call action for an object. (A custom action on an object overrides a custom global action.)\n\nTo display the simpler New Task form to Salesforce mobile app users, enable the form in Activity Settings and ensure that the layout used includes a subject field.\n\n**Layout Auditing**\n\nSalesforce tracks action layout customization in the setup audit trail history.\n\n**Try It Out: Customize an Object-Specific Action Layout**\n\nThe first time you view the layout for an action you’ve created, certain fields are prepopulated: target object default fields, standard required fields, and any custom universally required fields. We’re going to add more fields to the Create a Case action so the mobile technicians can put more information into the case for the Acme Wireless support reps.\n\n1. In the object management settings for accounts, go to Buttons, Links, and Actions.\n2. Click **Layout** next to our Create a Case action.\n \n The action has four fields already set by default: **Contact Name**, **Status**, **Subject**, and **Description**. The red asterisk next to the **Status** field shows that it’s a required field. Let’s add a few more fields.\n3. Click and drag **Priority** into position right after **Status**.\n4. Click and drag **Product** into position right after **Priority**.\n \n This field lets the technicians indicate what product the customer is having trouble with.\n5. Click **Save**.\n\nNow when the Acme Wireless mobile technicians view an account in the Salesforce app, they can create a case from any account record page. Let’s give it a try.\n\n**Test Out the Object-Specific Quick Action**\n\nWhen you create an action, assign it to a page layout, and customize its action layout, as we did, the changes are reflected in Salesforce immediately.\n\n1. Open Salesforce on your mobile device.\n\n2. Tap ☰️ to access the navigation menu.\n\n3. In the Recent section, tap **Accounts**.\n\n4. Tap **Barbary Coast Wireless**.\n\n5. In the action bar, tap 📡 to access the action menu. Create a Case, and the other actions we added, are now in the action menu.\n6. Tap the Create a Case action.\n7. Tap the Contact Name field.\n8. Tap Lloyd Benjamin to assign him to the case.\n9. Leave its status as New.\n10. Assign the case a low priority.\n11. Tap Product, and select the first one on the list.\n12. Enter a subject and description.\n13. Tap Save.\n\nOK, we’re back on the account record detail page. Tap Feed, and you should see a new feed item for the case you just created.\nNice work!\n\n## About Predefined Values in Actions\n\nSetting up *predefined values* for certain fields on actions can increase your mobile users’ productivity and optimize the action for the mobile environment at the same time.\n\nWhen you configure action layouts, it’s better to use fewer fields. Most users, especially mobile users, don’t like to fill in a lot of required fields. They want to get things done and move on to their next task. A good way to use fewer fields in action layouts is to set predefined values for as many fields as possible. The more fields you can set predefined values for, the more you can remove from the layout and make the action easier and quicker to use. Balance ease of use with the need for required information. However, don’t remove required fields from an action layout without setting a predefined value for those fields, or when a user applies that action, the record won’t save properly.\n\nIf you set predefined values for fields on object records created through an action, you don’t need to add those fields to the action layout. For example, when you configure an action that lets users create opportunities, set Prospecting as the predefined value for the Stage field. All new opportunities users\ncreate through that action are automatically assigned to the prospecting stage. You can remove the Stage field from the action’s layout, because the field is going to be assigned a value automatically.\n\nYou can set predefined values for any field available in the action layout editor, with these exceptions.\n\n- Multi-select picklists\n- Read-only field types like auto-number, formula, and roll-up summary fields\n\nPredefined values for fields on actions are different from default values that you can set for fields on records. If a field is included in an action, it can have both a predefined value set for the action and a default value set. If a field on an action has both a predefined value and a default value set, the action uses the predefined value, not the default value.\n\nLet’s set a predefined value for one of the fields on our Create a Case action.\n\n### Try It Out: Set a Predefined Field Value on an Action\n\nWhen we customized our Create a Case action, the Status field was already present, because it’s a required field for cases. Whenever Acme Wireless’ mobile technicians are out in the field and have to open a case, the case status is always going to be “New” for them. Rather than require them to fill in the Status field every time they open a case, let’s set up a predefined field value for it as “New”. Then we can remove it from the action layout, and whenever the Create a Case action is used to create a case, the status will automatically be set to “New”.\n\n1. In the object management settings for accounts, go to Buttons, Links, and Actions.\n2. Click **Create a Case**.\n3. In the Predefined Values related list, click **New**.\n4. From the Field Name drop-down list, select Status.\n5. Set its value to New.\n6. Click **Save**.\n \n Now we need to remove the Status field from the action layout.\n\n7. On the action detail page, click **Edit Layout**.\n8. Click the Status field on the layout and drag it up to the palette.\n\n Tip: You can remove a required field from the action layout, but make sure that the field has a predefined value. Otherwise, users can’t create records.\n\n9. Click **Save**.\n\nOK, now let’s see it in action.\nTest the Predefined Value\n\n1. Open Salesforce on your mobile device.\n2. Tap ☰️ to access the navigation menu.\n3. In the Recent section, tap Accounts. You may have to tap More... to find it.\n4. Tap Barbary Coast Wireless.\n5. In the action bar, tap ☰️ to access the action menu.\n6. Tap the Create a Case action.\n Notice the Status field is now gone.\n7. Assign the case a High priority.\n8. Tap Product, and select any of the products on the list.\n9. Enter a subject and description.\n10. Tap Save.\n11. Tap Feed, and you should see a new feed item for the case you just created.\n12. Tap the case number in the feed item, then tap Details.\n In the record highlights area of the case record page, you'll see the subject, priority (High), status (New), and the case number. The Status field was populated for us, thanks to our predefined value.\nAll right! We’re almost done with actions. There’s one more type, custom actions, that we’ll go over briefly for now.\n\n**About Custom Actions**\n\nObject-specific custom actions invoke Lightning components, flows, Visualforce pages, or canvas apps that let users interact with or create records that have a relationship to an object record. The Visualforce page for an object-specific custom action must include the standard controller for the relevant object. For example, use the standard contact controller to create a custom action that lets users import a contact’s Twitter profile and add that information to a contact record.\n\nUse a Visualforce page, Lightning component, or a canvas app to create global custom actions for tasks that don’t require users to use records that have a relationship to a specific object. Canvas apps that you want to use as custom actions require Publisher as a location. To call Lightning components from custom actions, you must have My Domain deployed in your org. Visualforce pages that you want to use as global custom actions can’t use standard controllers. For example, you want a custom action that lets users enter a street address and see a map, the local time, and the local weather. For this action, create a Visualforce page that doesn’t use any of the standard controllers, and add it as a custom global action.\nWe can’t create custom actions with point-and-click, so we won’t be working with them in our administrator exercises. If you want to find out more about custom actions, see *Adding Functionality with Visualforce Custom Actions* on page 93.\nCHAPTER 8 Guidelines and Best Practices for Administrators\n\nIn this chapter ...\n\n- **Action Guidelines and Best Practices**\n- **Custom Icon Guidelines and Best Practices**\n\nWe’ve covered the primary places you can use point-and-click tools to optimize your organization for your mobile users. We enabled notifications, created page layouts and compact layouts, set up quick actions, and customized the navigation menu.\n\nIn this chapter, we’ll cover some suggestions and best practices for actions and custom icons that can make your mobile users’ experience that much better. And in case you missed it, don’t forget to review the page layout guidelines in *Tips for Optimizing Page Layouts for Mobile* on page 38.\nAction Guidelines and Best Practices\n\nActions are a great way to let your users get work done quickly. As an administrator, you're in a prime position to give them the exact actions that they need.\n\nWhen considering what kinds of actions to create, or even when creating the actions themselves, keep these suggestions in mind.\n\n- When customizing action layouts, consider what your users will do with them. Minimalism is key. Include only the fields that are necessary for them and for whomever handles the cases, calls, or records that result from those actions.\n- Don't use actions for simple navigation shortcuts. They're designed to perform a function.\n- Give your actions task-oriented names that tell your users what they do. Use terms such as New, Create, Share, Update, or Import. Keep names short and descriptive.\n- Create a global action if you're contemplating something that your users need to do that isn't tied to a specific object and that you want to be accessible from anywhere.\n- Use the Description field to create notes for yourself about each action. Notes are especially useful if you're creating several similar actions for different record types, for example. The description appears in the list of buttons, links, and actions for object-specific actions, or in the list of global actions, as well as on the detail page for the action. Your notes aren't visible to users.\n- There is no hard limit to the number of fields you can add to an action layout. However, for optimum usability, we recommend a maximum of 8 fields. Adding more than 20 fields can severely impact user efficiency. To reduce the number of fields in your layout, you can create predefined values for the required fields, and then remove those fields from your layout. You can set predefined field values from the action detail page.\n\nCustom Icon Guidelines and Best Practices\n\nYou can add custom icons to your actions or custom tabs if your organization has access to the Documents tab.\n\nIf you decide to create your own action or tab icon, upload it to a Documents folder and make sure Externally Available Image is selected.\n\nWhen creating a custom icon, follow these image guidelines. The icon should:\n\n- Be less than 10k in size\n- Be 120 x 120 pixels\n- Be a PNG with a transparent background\n• Have a resolution of 72 dpi\n• Not include a color background\n• Not include outer shadows on the inner icon graphic\n\nIn addition, follow these visual guidelines.\n• Center inner icon graphics within a 80 x 80 pixel area, leaving 20 pixels of spacing surrounding it in a 120 x 120 px final format.\n• The icon graphic should be white, or lighter than the background color.\n• Avoid heavy inner or outer shadows.\n• Use simple and flat styling resembling the Salesforce icon family. See the Salesforce App Style Guide for examples.\n\nYou assign custom icons using the Change Icon link when you create the action or tab.\n\nYou can also customize the icon that is used in the navigation menu for canvas apps. See Custom Icons for Canvas Apps on page 145.\nWelcome to Salesforce Platform Development\n\nIn this chapter ...\n\n- Our Scenario\n- Who This Part is For\n- When to Use Declarative vs. Programmatic Tools to Create Salesforce Apps\n- When to Use the Salesforce Platform vs. Creating Custom Apps\n- Salesforce Platform Development Process\n- Development Prerequisites\n\nWelcome to development for the Salesforce Platform. In Part I, Salesforce app Administration, you learned how to set up and configure your organization for the Salesforce app. You also learned how to customize Salesforce for mobile users by using declarative programming features. In this part, you’ll learn how you can use the Salesforce Platform features to extend the Salesforce and add new functionality for your users with code.\n\nDeveloping for mobile users in Salesforce means you can leverage your existing skills to extend and customize the app for your users. You can use the Salesforce Platform to extend your organization and then make those changes available to both mobile users and users of the full Salesforce site.\nOur Scenario\n\nWe’ll continue the business scenario of Acme Wireless and build functionality to meet the needs of their mobile technicians and warehouse workers.\n\nYou’ll learn how to:\n\n- Optimize the mobile experience for users by employing mobile-first user interface design.\n- Implement Visualforce pages so that mobile users can access them from the navigation menu or action bar, from a record, or from the publisher in the full Salesforce site.\n- Create a Visualforce custom action to make a Visualforce page available from the action bar or from the publisher in the full Salesforce site.\n- Implement development best practices when extending the Salesforce app.\n\nWho This Part is For\n\nPart II of this book is geared towards all developers who need to customize the Salesforce app with code, from beginner to seasoned pro.\n\nIf you’re familiar with programming in the Lightning platform or have done development using the Mobile SDK, then you should be able to easily make the jump to developing in the Salesforce Platform.\n\nIf you’re new to the platform or have done mostly declarative programming, then don’t worry. Each chapter takes you step-by-step through the process of implementing each feature for our fictitious business, Acme Wireless. This way, you can learn by doing. These sections are titled “Try It Out.”\n\nIn each chapter you’ll also find information about what the feature is, how it works, and when to use it. These sections are titled “Tell Me More.” Go there to delve into the details of the feature.\n\nWhen to Use Declarative vs. Programmatic Tools to Create Salesforce Apps\n\nWhen developing functionality for your Salesforce mobile users, you can use declarative features (clicks) or programmatic tools (code). Here are some points to consider before you start coding.\n\nSalesforce features built with declarative tools:\n\n- Are usually faster and cheaper to build.\n- Generally require less maintenance.\n- Receive automatic upgrades when the tools are improved.\nCommon declarative tools you can use in your Salesforce apps include:\n\n- Quick Actions\n- Page layout customization\n- Formula fields and roll-up summary fields\n- Validation rules\n- Workflows and approval processes\n- Custom fields and objects\n\nWe know it’s tempting to jump straight into coding. But just because you can doesn’t always mean you should. Before you commit to developing a new feature using programmatic tools such as Visualforce, consider whether you can implement your feature with declarative tools instead.\n\nOf course, some apps can’t be built with declarative tools. Programmatic tools are often required for features that:\n\n- Support specialized or complex business processes.\n- Provide highly customized user interfaces or customized click-through paths.\n- Connect to or integrate with third-party systems.\n\nSo which tool do you choose? There’s no hard-and-fast rule for when to choose clicks over code. When choosing, consider the problems you’re trying to solve and resources available to solve them.\n\n**When to Use the Salesforce Platform vs. Creating Custom Apps**\n\nWhen it comes to developing functionality for your Salesforce mobile users, you have options. Here are some differences between extending the Salesforce app and creating custom apps using the Mobile SDK or other tools.\n\n**Salesforce Platform**\n\n- Defined user interface.\n- Full access to Salesforce data.\n- Possible integrated experience in the Salesforce app.\n- Inclusion of your own apps and functionality with quick actions.\n- Customized with point-and-click or programmatic tools.\nChapter 9 Welcome to Salesforce Platform Development\n\n- Programmatic functionality through Visualforce pages, Canvas apps, and the Lightning Component framework.\n- Defined navigation points, since customizations or apps adhere to the navigation menu. For example, a Visualforce page can be called from the navigation menu or from a custom action in the action bar.\n- Enables you to leverage existing Salesforce development experience, both point-and-click and programmatic.\n- Included in all Salesforce editions and supported by Salesforce.\n\nCustom Apps\n\nCustom apps can be either free-standing apps you create with Salesforce Mobile SDK or browser apps using plain HTML5, CSS, and your choice of mobile-friendly JavaScript frameworks. With custom apps, you can have:\n\n- A custom user experience.\n- Access to Salesforce data using REST APIs in native and hybrid local apps, or with Visualforce in hybrid apps using JavaScript Remoting. In HTML5 apps, do the same using standard JavaScript APIs.\n- A branded user interface, including a custom app icon, for increased exposure in customer-facing apps.\n- Standalone mobile app, either with native APIs using Java for Android or Objective-C for iOS, or through a hybrid container using JavaScript and HTML5 (Mobile SDK only).\n- App distribution through mobile industry channels, such as the Apple App Store or Google Play (Mobile SDK only).\n- Control of complex offline behavior (Mobile SDK only).\n- Push notifications (available for Mobile SDK native apps only).\n- A custom security container using your own OAuth module (Mobile SDK only).\n\nOther important Mobile SDK considerations:\n\n- Access to open-source SDK, downloadable for free through npm installers and GitHub. No licensing required.\n- Requires you to develop and compile your apps in an external development environment (Xcode for iOS, Eclipse or similar for Android).\n\nThere’s no right or wrong answer when choosing between the Salesforce platform and the Mobile SDK. Base your choice on which features are most important for your app.\nSalesforce Platform Development Process\n\nThe Salesforce app is designed to run on a mobile device, like a phone or tablet, but that doesn’t mean you have to develop on one. Especially when you’re working with Visualforce pages that will appear in both the app and the full Salesforce site, it’s convenient to develop on your desktop. By accessing the Salesforce app in a device emulator, you can develop iteratively on your desktop, without having to pick up your device to test each change.\n\n**Important:** Running the Salesforce app in an emulator isn’t supported for normal use, and it’s not a substitute for full testing of your custom apps and pages on your organization’s supported mobile devices. During development you should regularly test your app on every device and platform on which you intend to deploy.\n\nTo view your custom mobile pages and apps on a device emulator, download and install the appropriate SDK for your supported devices.\n\n- Apple iOS Simulator for iPhone and iPad\n \n\n- Android Virtual Device Emulator for Phone and Tablet\n \n developer.android.com/tools/devices/emulator.html\n\nYou can’t use the standard https://<Salesforce_instance>/apex/yourPageName URL to test Visualforce in the Salesforce app. You can only do that by accessing the page within the app.\n\nDevelopment Prerequisites\n\nYou’ll need to have these before you can start these exercises.\n\n- Access to a Developer Edition organization.\n \n If you aren’t already a member of the Lightning Platform developer community, go to [http://sforce.co/1om1gHf](http://sforce.co/1om1gHf) and follow the instructions for signing up for a Developer Edition organization. Even if you already have Enterprise Edition, Unlimited Edition, or Performance Edition, use Developer Edition for developing, staging, and testing your solutions against sample data to protect your organization’s live data.\n\n- The “API Enabled” permission must be enabled for your Developer Edition organization. This permission is enabled by default, but might have been changed by an administrator.\nThe Warehouse data model must be installed in your Developer Edition organization and the Salesforce app installed on a mobile device. If you haven’t already set up these items, see Setting Up Your Work Environment on page 15.\n\n**Chapter 9 Welcome to Salesforce Platform Development**\n\n- Change the System Administrator Page Layout Assignment\n\nWe’ve created a custom page layout to help us illustrate some of the concepts in this book. Before we begin, let’s switch the page layout assignment for our System Administrator profile to this new layout.\n\n1. In Setup, enter Profiles in the Quick Find box, then select Profiles.\n2. Select the System Administrator profile.\n3. In the Page Layouts section, find Account, and click View Assignment.\n4. Click Edit Assignment.\n5. Click the System Administrator line item.\n6. Select Warehouse Schema Account Layout from the Page Layout to Use drop-down list.\n7. Click Save.\n\nAll right! Now we’re ready to roll.\nCHAPTER 10 Designing Mobile-First User Interfaces\n\nIn this chapter, we’ll learn about user interface design considerations to keep in mind when developing functionality for Salesforce mobile users.\n\nDesigning your user interface with mobile in mind is critical to the success of your app. If users find your functionality easy to use and in alignment with the experience they have with other mobile apps, they’ll be much happier with the app. The user interface guidelines in this chapter address key differences in the mobile platform and the way users work in it:\n\n• Mobile devices have smaller screens.\n• Navigation is done with gestures like tapping and swiping.\n• Users typically perform focused tasks from mobile devices like adding a new record.\n\nThroughout the examples in this book, we demonstrate these best practices. As you develop and create your own customizations and apps using the Salesforce Platform, keep these guidelines in mind.\n\nIn this chapter ...\n\n• Design for Mobile\n• Keep Navigation Simple\n• Put Important Information at the Top\n• Minimize the Number of Fields\n• Use Field Defaults\n• Minimize User Interface Text\n• Tap Target Size\nDesign for Mobile\n\nWhen designing a user interface for Salesforce mobile users, keep the smaller form factor and the way users work in mind from the start.\n\nIn the mobile paradigm, users work in quick bursts, spending not more than a minute or two on a task. So be sure to design your app for the way users work.\n\nAvoid taking forms and workflow designed for the desktop environment and simply making them available. For example, it may be an acceptable user experience in a desktop Web browser to have a form with many fields and related lists on it. However, that same form probably won’t provide a good user experience when used from a mobile device.\n\nUsers will have a much better experience with forms that follow these user interface guidelines and are designed specifically for the mobile environment.\n\nKeep Navigation Simple\n\nDesign your customizations so that users can get to the screen quickly and know where they are within the app.\n\nWhen creating forms, be sure that they have a simple, logical flow. This helps users to know where they are and keeps them from having to remember where they came from. For example, avoid creating a feed item that links to another form that then links to another form.\n\nPut Important Information at the Top\n\nPut the most essential information at the top of the screen so that it’s immediately visible to the user and easy to access.\n\nFor example, on a screen that the mobile technician uses to see all their repair appointments, put the most important customer data such as name, address, and phone number at the top. For each screen, identify what the user’s task is and what data they need to accomplish that task. Another example is if you’re generating feed items, the text should be as concise as possible and the most important information should be at the beginning of the post, as shown in the following example.\nMinimize the Number of Fields\n\nWhen it comes to presenting fields on a screen, less is more. Give users only the fields they need to complete the task at hand.\n\nFor example, if you’re creating a screen for adding a new warehouse, you might only want to surface the warehouse name field. This way the user can quickly add a new warehouse. If the user has collected more information, they can edit the new record and add it in the detail view.\n\nThis guideline is particularly important when displaying information that’s for viewing only. For example, if you’re creating a form that the mobile technician uses to look up a customer, the technician probably needs to see only the customer name, address, and a phone number. In our page to search for merchandise, only two fields are needed: the merchandise name and delivery distance.\nTo reduce the number of fields on a screen, consider using default values for new records instead of having the user enter the data.\n\nUse Field Defaults\n\nWhen you have fields on a screen that user must enter, create defaults for as many of them as you can. For example, if you create a form with a multi-select picklist, consider defaulting the field to a particular value. This way the user can change it if necessary, but otherwise can simply accept the default for quicker workflow.\n\nMinimize User Interface Text\n\nBe mindful of device form factor and size, and keep labels and user interface text short and concise. Keep field and menu labels as short as you can while still conveying enough meaning for users to understand what the field is for. Use intuitive icons or symbols whenever possible so users can quickly understand\nyour user interface. The goal with user interface text is to provide enough information so that users can understand what they need to do while at the same time keeping the user interface clean and simple.\n\nA common best practice is to place labels above fields and to show only one column of fields instead of displaying fields side by side.\n\nAny blocks of text should also be concise and to the point. For example, if you’re automatically creating a feed item to be viewed, keep the text short and include only the necessary information.\n\nIn our warehouse scenario, when an order is fulfilled in the warehouse, a feed item appears in the customer account feed that shows the key information such as invoice number and order number, along with a short message and a link to the invoice.\n\nTap Target Size\n\nMobile users interact with the Salesforce user interface with their fingers, so be sure to design user interface elements to be the optimal size.\nScreen controls should be large enough for users to tap easily and take into account that every user’s hands are sized differently. Controls that are too small means users will need to tap multiple times, a frustrating experience. But you don’t want controls so large that users can accidentally tap one when they meant to tap another.\n\nWe recommend a minimum tap target size of 44 pixels wide by 44 pixels high. For more information about custom icons, see Custom Icon Guidelines and Best Practices on page 64.\nCHAPTER 11 Extending the Salesforce App with Visualforce Pages\n\nIn this chapter ... \n\n- Try It Out: Create a Visualforce Page \n- Tell Me More: Where Visualforce Pages Can Appear in the Salesforce App \n- Tell Me More: About the Code \n\nYou can use Visualforce to extend the Salesforce app and give your mobile users the functionality they need.\n\nIn this chapter, we’ll extend the Acme Wireless organization and give mobile technicians a way to find nearby warehouses. For example, if the technician is out on a call and needs a part, they can use this page to look for warehouses within a 20–mile radius.\n\nWhile you could take an existing Visualforce page and surface it in the Salesforce app, you should consider how that page will look and function on a mobile device. Most likely, you’ll want to create a new page designed especially for a mobile experience.\n\nFor more information about where Visualforce pages can appear in the user interface, see Tell Me More: Where Visualforce Pages Can Appear in the Salesforce App on page 86.\n\nNow, let’s get started!\nTry It Out: Create a Visualforce Page\n\nNow we’ll create a Visualforce page and make it available from the navigation menu.\n\nThis Visualforce page references these items.\n\n- A static resource named googleMapsAPI\n- An Apex class named FindNearby\n\nThese have been provided for you in the package that you downloaded and installed for this guide.\n\nAlso included in the package is the Visualforce page FindNearbyWarehousesPage. You can move on to the next step, Create a New Tab on page 83, if you want to use the page included in the package.\n\nThe code for this page uses the location of the current user and integrates with Google Maps to display a map with warehouses located within 20 miles. For each nearby warehouse, the map displays a pin along with the warehouse name, address, and phone number.\n\n1. In the Salesforce application, from Setup, enter Visualforce Pages in the Quick Find box, then select Visualforce Pages.\n\n2. Click New.\n\n3. In the Label field, enter FindNearbyWarehousesPage.\n\n The FindNearbyWarehousesPage page is included in the package you installed, so if you’re copying this code to create a new page, you’ll want to name your page something different.\n\n4. Select the Available for Lightning Experience, Lightning Communities, and the mobile app checkbox.\n\n Selecting this checkbox designates that the page is mobile-ready.\n\n5. Copy and paste this code into the Visualforce Markup tab.\n\n```\n<apex:page sidebar=\"false\" showheader=\"false\"\n standardController=\"Warehouse__c\"\n recordSetVar=\"warehouses\" extensions=\"FindNearby\">\n\n <apex:includeScript value=\"{!$Resource.googleMapsAPI}\" />\n <!-- This API key needs to be set up for there to be no JS errors -->\n <!--http://salesforcesolutions.blogspot.com/2013/01/integration-of-salesforcecom-and-google.html-->\n <script type=\"text/javascript\"\n src=\"https://maps.googleapis.com/maps/api/js?key=\n AIzaSyAVrfZm7_NhbLjHrFPdl242BYV1PBmDPqs\n &sensor=false\">\n```\nfunction initialize() {\n var lat, lon;\n\n // Check to see if the device has geolocation detection capabilities with JS\n if (navigator.geolocation) {\n navigator.geolocation.getCurrentPosition(\n function(position){\n lat = position.coords.latitude;\n lon = position.coords.longitude;\n\n //Use VF Remoting to send values to be queried in the associated Apex Class\n Visualforce.remoting.Manager.invokeAction(\n '{!$RemoteAction.FindNearby.getNearby}',\n lat, lon,\n function(result, event){\n if (event.status) {\n console.log(result);\n createMap(lat, lon, result);\n } else if (event.type === 'exception') {\n //exception case code\n } else {\n }\n },\n {escape: true}\n );\n }\n );\n } else { //Set default values for map if the device\n }\n// doesn't have geolocation capabilities\n/** San Francisco **/\nlat = 37.77493;\nlon = -122.419416;\n\nvar result = [];\ncreatemap(lat, lon, result);\n}\n\nfunction createmap(lat, lng, warehouses){\n // Grab the map div and center the map at\n // the proper latitude/longitude\n var mapDiv = document.getElementById('map-canvas');\n var map = new google.maps.Map(mapDiv, {\n center: new google.maps.LatLng(lat, lng),\n zoom: 12,\n mapTypeId: google.maps.MapTypeId.ROADMAP\n });\n\n // Set up the markers for the map using the\n // variable we queried for in our controller\n var warehouse;\n for(var i=0; i<warehouses.length;i++){\n warehouse = warehouses[i];\n console.log(warehouses[i]);\n setupMarker();\n }\n}\n\nfunction setupMarker(){\n var content='<a href src=\"/\"'+ warehouse.Id +'\">'+'\n warehouse.Name + '</a><br/>\n warehouse.Street_Address__c +\n '<br/>' + warehouse.City__c +\n '<br/>' + warehouse.Phone__c;\n\n // Create the callout that will pop up\n // on the marker\n var infowindow = new google.maps.\n InfoWindow({\n content: content\n });\n6. Click Save.\n\nNow that we’ve created the Visualforce page for finding warehouses, the next step is to create a tab for it. We’ll then add the page to the navigation menu.\n\n**Create a New Tab**\n\nNow we’ll create a new tab and add the Visualforce page you just created.\n\n1. From Setup, enter *Tabs* in the *Quick Find* box, then select *Tabs*.\n2. In the Visualforce Tabs section, click *New*.\n3. In the Visualforce Page drop-down list, select *FindNearbyWarehousesPage*, or the page you created in the previous step.\n4. In the Tab Label field, enter Find Warehouses. This label appears on the navigation menu.\n\n5. Click into the Tab Style field, and select the Globe style. The icon for this style appears as the icon for the page in the navigation menu.\n\n6. Click Next.\n\n7. Click Next to accept the visibility defaults.\n\n8. Deselect the Include Tab checkbox so that the tab isn’t included in any of the apps in the organization. We only want this tab to appear when users are viewing it on their mobile device.\n\n9. Click Save.\n\nNow that you’ve created the Visualforce page and the tab, you’re ready to add the new tab to the navigation menu.\n\nAdd the Tab to the Navigation Menu\n\nIn this step, we’ll add the tab as a navigation menu item. It will instantly become available to Salesforce app users that have access to it.\n\n1. From Setup, enter Navigation in the Quick Find box, then select Salesforce Navigation.\n\n2. Select Find Warehouses and click Add to move it over to the Selected list.\n3. Move the Find Warehouses item to just below the Smart Search Items menu item.\n\nNote: Menu items that you put below Smart Search Items appear in the Apps section of the Salesforce navigation menu.\n\n4. Click Save.\n\nWhen your users log in, they’ll see the Find Warehouses menu item in the navigation menu. Now let’s test it out.\n\nTest the Visualforce Page\n\nNow you’ll play the part of an Acme Wireless mobile technician and search for nearby warehouses on your device.\n\n1. Open Salesforce on your mobile device.\n\n2. Tap to access the navigation menu.\n \n You should see Find Warehouses under the Apps section.\n\n3. Tap Find Warehouses.\n\n4. Click OK when you see a prompt that asks to use your current location. A map that contains all the nearby warehouse locations within 20 miles appears.\nThe warehouses in our package sample data are all located in the San Francisco area. If you’re testing this from another location, be sure to add a warehouse located within 20 miles. To add a new warehouse, choose Warehouse from the Lightning Platform app menu, click the Warehouses tab, and then click New in the Recent Warehouses section.\n\nThat’s it! You can see how easy it is to make standard pages and tabs available to your mobile users. For more information about development guidelines for Visualforce pages, see Guidelines and Best Practices on page 108.\n\nTell Me More: Where Visualforce Pages Can Appear in the Salesforce App\n\nWhen you create a Visualforce page, you can make it available from a number of places in the user interface.\n\n• Navigation menu—available when you tap 📊 from the mobile app\n- Action bar and action menu—available from the bottom of any page that supports actions\nRecord related information page (as a mobile card)—available when you navigate to a record\n\nYou can also reference, and link to, another Visualforce page in your Visualforce markup using the supported navigation calls listed at Navigation with the sforce.one Object. Be sure to select Available for Lightning Experience, Lightning Communities, and the mobile app for all pages in a multi-page process.\n\nIf a referenced page doesn't have Available for Lightning Experience, Lightning Communities, and the mobile app selected, it doesn't prevent the referencing, or parent, page from appearing. However, when a user tries to access the nonmobile enabled page, they receive an \"Unsupported Page\" error message.\n\nTell Me More: About the Code\n\nLet's take a look at some of the code behind our Visualforce page that finds warehouses.\nFindNearby Apex Class Query\n\nThis snippet is a dynamic SOQL query that uses variables passed in from the Visualforce page to find warehouses within 20 miles of the device accessing the page. This page works on any mobile device and HTML5–enabled desktop browser.\n\nIf the page is unable to obtain the location, the search is centered on San Francisco. If you test this from a browser, you might have to approve that the page can access your location depending on your device security settings.\n\n```java\nString queryString = \n 'SELECT Id, Name, Location__Longitude__s, \n Location__Latitude__s, ' + \n Street_Address__c, Phone__c, City__c ' + \n FROM Warehouse__c ' + \n 'WHERE DISTANCE(Location__c, ' + \n GEOLOCATION('+lat+', '+lon+'), \\\"mi\\\") < 20 ' + \n 'ORDER BY DISTANCE(Location__c, ' + \n GEOLOCATION('+lat+', '+lon+'), \\\"mi\\\") ' + \n 'LIMIT 10';\n```\n\nVisualforce Page `initialize` Function\n\nThe `initialize` function in the Visualforce page uses the HTML5 geolocation API to get the coordinates of the user. The browser gets the position without using any plug-ins or external libraries, and then uses JavaScript remoting to invoke the `getNearby` function in the Apex controller and passes in the coordinates.\n\n```java\nfunction initialize() {\n var lat, lon;\n\n // Check to see if the device has geolocation\n // detection capabilities with JavaScript\n if (navigator.geolocation) {\n navigator.geolocation.getCurrentPosition(\n function(position){\n lat = position.coords.latitude;\n lon = position.coords.longitude;\n\n //Use VF Remoting to send values to be\n //queried in the associated Apex Class\n Visualforce.remoting.Manager.invokeAction(\n '{$RemoteAction.FindNearby.getNearby}', lat, lon,\n );\n }\n );\n }\n}\n```\nfunction(result, event){\n if (event.status) {\n console.log(result);\n createMap(lat, lon, result);\n } else if (event.type === 'exception') {\n //exception case code\n } else {\n }\n},\n{escape: true}\n});\n\n} else {\n //Set default values for map if the device doesn't have geolocation capabilities\n /** San Francisco **/\n lat = 37.77493;\n lon = -122.419416;\n\n var result = [];\n createMap(lat, lon, result);\n}\n\nVisualforce Page Redirect Code\n\nThe page FindNearbyWarehousesPage uses the Google Maps JavaScript API v3 to plot the nearby warehouses on a map. We resize the map based on the records returned by the SOQL query and plot each record as marker on the map.\n\nThe most important piece of the code is where we determine whether or not the page is being viewed in the Salesforce app. If it is, the redirect link to the warehouse record must be coded slightly differently. If the page runs in the Salesforce app, we must use the navigateToSobjectRecord method to go to the record detail page but still stay in the app. We can check this with a simple try/catch construct, and then set the redirect link accordingly.\n\ntry{\n if(sforce.one){\n warehouseNavUrl = 'javascript:sforce.one.navigateToSObject(\n '\\' + warehouse.Id + '\\');\n }\n} catch(err) {\n}\nconsole.log(err);\nwarehouseNavUrl = '\\' + warehouse.Id;\n}\nvar warehouseDetails =\n'<a href=' + warehouseNavUrl + ' ' +\nwarehouse.Name + '</a><br/>\nwarehouse.Street_Address__c + '<br/>' +\nwarehouse.City__c + '<br/>' +\nwarehouse.Phone__c;\nCHAPTER 12 Adding Functionality with Visualforce Custom Actions\n\nIn this chapter …\n\n• Custom Actions Scenario\n• Try It Out: Create a Visualforce Custom Action\n• Tell Me More: About the Code\n\nActions appear in the action bar and action menu in the Salesforce mobile app, and are a quick way for mobile users to access commonly used tasks or functionality.\n\nWe learned about standard actions that can be configured with point-and-click tools in Using Actions in the Salesforce App on page 45. In this chapter we’ll look at custom actions, which are actions that you define. There are two types of custom actions:\n\n• Visualforce—specifies a Visualforce page that’s called from the Chatter publisher or the Salesforce app action bar.\n\n• Canvas—specifies a canvas app that’s called from the Chatter publisher or the Salesforce app action bar.\n\nCustom actions aren’t specific to mobile users, and appear in both the Salesforce app and in the full Salesforce site. In the Salesforce mobile app, custom actions appear in the action bar. In the full Salesforce site, custom actions appear in the Chatter publisher.\nCustom Actions Scenario\n\nIn this chapter, we’ll further extend the Acme Wireless organization and give mobile technicians a way to quickly create an order. We’ll create a Visualforce page and make it available as a custom action from the action bar. That way, if the technicians are out at a customer site and they want to order a part, they can quickly navigate to the page.\n\nThe custom action enables the technician to enter the part name and a radius, and the Visualforce page searches all warehouses within the given radius for that part. Once a warehouse is located, the technician simply enters the quantity and taps a button to create the order. This is all done within the context of the customer account.\n\nTry It Out: Create a Visualforce Custom Action\n\nFirst, we’ll create a Visualforce custom action that references a Visualforce page.\n\nThe custom action we’re creating uses these elements from the package that you downloaded and installed for this guide.\n\n- **QuickOrderPage** Visualforce page\n- **QuickOrderController** Apex class\n- **Mobile_Design_Templates** static resource used for styling the page\n\nWe’ll take an in-depth look at the code later in this chapter. But first, we’re going to create the action and try it out.\n\nThe Visualforce code for this page uses the location of the current customer account to find warehouses located within the specified distance (in miles) that also have a particular part in stock.\n\n1. From the object management settings for accounts, go to Buttons, Links, and Actions.\n2. Click **New Action**.\n3. In the Action Type drop-down list, select Custom Visualforce.\n4. In the Visualforce Page drop-down list, select QuickOrderPage.\n5. In the **Label** field, enter *Create Quick Order*.\n\n This is the action name that appears to the user in the action menu in the Salesforce app or in the publisher in the full Salesforce site.\nChapter 12 Adding Functionality with Visualforce Custom Actions\n\n6. Click **Save**.\n\nNow that we’ve created the custom action, we’ll add the action to the Account page layout. This ensures that the custom action appears in the publisher when you go to the page for a customer account.\n\nAdd the Visualforce Custom Action to the Page Layout\n\nNow we’ll add the custom action to the Account page layout.\n\n1. From the object management settings for Accounts, go to Page Layouts.\n2. Click **Edit** next to the Warehouse Schema Account Layout.\n3. Click the Mobile & Lightning Actions category in the palette.\n4. In the Salesforce Mobile and Lightning Experience Actions section, click **override the predefined actions**.\n5. Drag the Create Quick Order element into the Salesforce Mobile and Lightning Experience Actions section so that it appears as the first element on the left.\n \n Our mobile technicians are going to use this custom action a lot, so we’re putting it at the start of the list so it is one of the first actions they see in the action bar.\n\n6. If it’s present, drag the Mobile Smart Actions element out of the section and back to the palette.\n\n7. Click **Save**.\n\nNow that we’ve created the custom action and added it to the page layout, we’re ready to see it in action.\nTest Out the Visualforce Custom Action\n\nNow you’ll play the part of an Acme Wireless mobile technician on a customer call, and we’ll test out the custom action in the Salesforce app.\n\n1. Open the Salesforce app on your mobile device.\n2. Tap \\( \\equiv \\) to access the navigation menu.\n3. From the navigation menu, tap **Accounts** and navigate to an account.\n4. In the action bar, tap \\( \\equiv \\) to access the action menu.\n5. Tap the **Create Quick Order** action.\n\n6. In the **Merchandise Name** field, enter the name of an item, such as *iPhone 5*.\n7. In the **Max Delivery Distance (miles)** field, enter **10**.\n8. Tap **Submit**.\n\n---\n\n**Chapter 12** Adding Functionality with Visualforce Custom Actions\n9. In the Search Results section at the bottom, you’ll see a list of merchandise that matches what you searched for. The list shows parts contained in warehouses within 10 miles of the current account. Tap iPhone 5S Gold.\n\n10. In the Quantity field, enter 1.\n\nAfter identifying nearby warehouses that contain the part you’re looking for, this screen lets you enter a quantity and creates an order for the part. The order is associated with the current account.\n\nTip: If you want to return to the search screen, be sure to use the Back button. If you tap Cancel, an invoice with no line items is created.\n\n11. Tap Save.\n\nThe order has been created. Swipe to the Related screen, and you’ll see the Invoices related list. Tap it, and you’ll see the new invoice. You can tap the invoice, go to the Related screen, and then tap Line Items to see the line item that was created for the iPhone 5S Gold part.\n\nSuccess! You’ve gone through the entire process of enabling a mobile technician to quickly search for a part in a warehouse and create an order.\nTell Me More: About the Code\n\nThere are two code objects behind our Visualforce custom action: the Apex class `QuickOrderController` and the Visualforce page `QuickOrderPage`.\n\nThe Apex class is the controller for the Visualforce page, and uses the `@RemoteAction` annotation on the methods. When you use this annotation, the Visualforce page wraps the logic in a JavaScript-friendly way. This is known as *Visualforce remoting*.\n\nVisualforce remoting allows for quick and tight integration between Apex and JavaScript. This communication model works asynchronously as opposed to the synchronous model in the traditional Visualforce/Apex MVC paradigm. So after passing parameters into your controller, you can get the result from a response handler function, and write any additional client-side logic before doing any DOM manipulation or building your page with mobile templates or frameworks.\n\nVisualforce remoting is ideal for mobile developers on the Salesforce Platform because it simplifies the direct server-side access to Salesforce objects and allows you to use Apex tools such as SOQL, Apex methods, and so on for rapid platform development. And, you don’t have to deal with view state, which makes pages perform better.\n\n**Apex Class `QuickOrderController`**\n\nThis class uses Visualforce remoting and contains the logic called by the Visualforce page to find warehouses and create orders and line items.\n\n```apex\nglobal class QuickOrderController{\n public static List<Merchandise__c> merchandise;\n public static Line_Item__c quickOrder;\n\n public QuickOrderController(ApexPages.StandardController controller){\n }\n\n @RemoteAction\n global static List<Merchandise__c> findWarehouses(String accId,\n String merchName, String warehouseDist){\n merchandise = new List<Merchandise__c>();\n String queryString = '';\n```\nString queryName = '%' + merchName + '%';\n\nAccount acc = [Select Location__Longitude__s, Location__Latitude__s, Name, Id from Account where Id =: accId];\n\n//Finds warehouses nearby if you have location\n//specified on the Account\nif(acc.Location__Latitude__s != null &&\n acc.Location__Longitude__s != null){\n queryString = 'SELECT Id, (SELECT Id, Name, Quantity__c, Warehouse__r.Name, Warehouse__r.Id, Warehouse__r.Street_Address__c, Warehouse__r.City__c ' +\n 'FROM Merchandise__r WHERE Name like :queryName) ' +\n 'FROM Warehouse__c WHERE ' +\n '+DISTANCE(Location__c, GEOLOCATION(' +\n +acc.Location__Latitude__s+', ' +\n +acc.Location__Longitude__s+'), \"mi\")';\n if(warehouseDist != null){\n queryString += ' <' + warehouseDist;\n }\n}\n\n//If no location defined on the Account, this will run\n//query against the merchandise name only\nelse {\n queryString = 'SELECT Id, Name, Location__Longitude__s, Location__Latitude__s, ' +\n '(SELECT Id, Name, Warehouse__r.Name, Quantity__c FROM Merchandise__r WHERE Name like :queryName) ' +\n 'FROM Warehouse__c limit 25';\n}\n\n//This creates a list of merchandise\n//to display in the search results\nWarehouse__c[] warehouses = Database.Query(queryString);\nfor(Warehouse__c warehouse : warehouses){\n```apex\nMerchandise__c merch = \n warehouse.getSObjects('Merchandise__r');\nif (merch != null) {\n for (Merchandise__c m : merch){\n merchandise.add(m);\n }\n}\nreturn merchandise;\n\n//This remote action creates the invoice for the quick order\n@RemoteAction\nglobal static Line_Item__c createQuickOrder(\n String accId, String merchandiseId){\n Invoice__c newInvoice = new Invoice__c();\n newInvoice.Account__c = accId;\n insert newInvoice;\n quickOrder = new Line_Item__c();\n Merchandise__c m = [Select Id, Name from Merchandise__c\n where Id=: merchandiseId limit 1];\n quickOrder.Merchandise__c = m.Id;\n quickOrder.Invoice__c = newInvoice.Id;\n return quickOrder;\n}\n\n//This remote action creates the line item related to the\n//invoice for the quick order\n@RemoteAction\nglobal static Boolean insertQuickOrder(String o, String q){\n try {\n Integer quantity = integer.valueof(q);\n Line_Item__c order = new Line_Item__c();\n /* The order variable being passed in as a param is being\n passed in the form of a JSON object. You need to use\n the JSON deserialize method in Apex to convert it\n into a SObject */\n order = (Line_Item__c)JSON.deserialize(\n o, Line_Item__c.class);\n```\norder.Quantity__c = quantity;\ninsert order;\n\n// Need to requery for the name for the post to chatter\n// since it wasn't explicitly specified\nLine_Item__c li = [Select Name, Merchandise__r.Name, Id,\n Quantity__c, Invoice__c from Line_Item__c\nwhere Id =: order.Id];\n\nFeedItem post = new FeedItem();\npost.ParentId = aId;\npost.Body = UserInfo.getName() + ' just created a quick order';\n\npost.type = 'LinkPost';\npost.LinkUrl = '/' + li.Invoice__c;\npost.Title = li.Merchandise__r.Name + ': ' + li.quantity__c;\ninsert post;\n} catch(System.Exception ex) {\n system.debug(ex.getMessage());\n}\nreturn true;\n\n// This remote action handles deleting the invoice if\n// the user doesn't want to insert the line item\n@RemoteAction\nglobal static Boolean goBack(String invoiceId){\n // Delete created invoice and return to original\n // search screen\n Invoice__c cancelledInvoice = [select Id from Invoice__c\nwhere Id=: invoiceId];\n delete cancelledInvoice;\n\n return true;\n}\n\nNote: Use static queries and binding variables to prevent a SOQL injection attack. For example, use :queryName instead of \"'%'+merchName+'%'\". For more information, see “Security Guidelines for Apex and Visualforce Development” in the Salesforce Help.\nThe Apex controller also has an `insertQuickOrder` method that creates a feed item about the new order in the account feed as shown in this code snippet. The feed item is a link post that links to the invoice.\n\n```java\nFeedItem post = new FeedItem();\npost.ParentId = aId;\npost.Body = UserInfo.getName() + ' just created a quick order';\npost.type = 'LinkPost';\npost.LinkUrl = '/' + li.Invoice__c;\npost.Title = li.Merchandise__r.Name + ':' + li.quantity__c;\ninsert post;\n```\n\n**Visualforce Page QuickOrderPage**\n\nThis page calls the controller with the user input and then displays the merchandise and warehouse information to the user. If the user wants to create an order, this page also calls the controller to create the order associated with the customer account and add a line item. At the beginning of the page, the code also does some styling of the page using the Salesforce mobile design templates.\n\n```html\n<apex:page standardController=\"Account\"\nextensions=\"QuickOrderController\" docType=\"html-5.0\"\nstandardStylesheets=\"false\" showheader=\"false\" sidebar=\"false\">\n<!--Include stylesheets for the mobile look and feel -->\n<apex:stylesheet value=\"{!URLFOR($Resource.Mobile_Design_Templates, 'Mobile-Design-Templates-master/common/css/app.min.css')}\"/>\n<apex:includeScript value=\"{!URLFOR($Resource.Mobile_Design_Templates, 'Mobile-Design-Templates-master/common/js/jquery2.0.2.min.js')}\"/>\n<apex:includeScript value=\"{!URLFOR($Resource.Mobile_Design_Templates, 'Mobile-Design-Templates-master/common/js/jquery.touchwipe.min.js')}\"/>\n<apex:includeScript value=\"{!URLFOR($Resource.Mobile_Design_Templates, 'Mobile-Design-Templates-master/common/js/main.min.js')}\"/>\n\n<style>\n/* Default S1 color styles */\n```\nThe QuickOrderPage also calls the Canvas SDK to enable the publisher Submit button and close the publisher window.\n\nFirst, it includes a reference to the SDK:\n\n```html\n<!-- This needs to be included so the publisher can be used to submit the action -->\n<script type='text/javascript'\nsrc='/canvas/sdk/js/publisher.js'></script>\n```\n\nThen it calls the setValidForSubmit method to enable the publisher Submit button:\n\n```javascript\n//This method will activate the publish button\n//so the form can be submitted\nSfdc.canvas.publisher.publish({\n name: \"publisher.setValidForSubmit\",\n payload:\"true\"});\n```\n\nAfter the setValidForSubmit is called and the user clicks Submit, this subscribe method fires. This method invokes the final JavaScript function which uses JavaScript remoting to insert the line item (thus completing the quick order) and then post a feed item to the account:\n\n```javascript\nSfdc.canvas.publisher.subscribe({name: \"publisher.post\",\nonData:function(e) {\n //This subscribe fires when the user hits\n //Submit in the publisher\n insertQuickOrder();\n}});\n```\n\nFinally, after the callback from the remoting method returns successfully, this method closes the publisher window:\n\n```javascript\n// Success - close the publisher and refresh the feed\nSfdc.canvas.publisher.publish({name: \"publisher.close\",\n payload:{ refresh:\"true\"}});\n```\nYou've had a chance to learn the major concepts of developing for the Salesforce app, and to see how you can easily add customized functionality for your mobile users. This chapter focuses on some conceptual guidelines and specific best practices for developing advanced custom actions and pages using the programmatic tools available to all Salesforce Platform developers.\n\nWhether you’re creating Visualforce pages to add as custom actions or mobile cards, or creating or integrating canvas apps into the Salesforce app, these principles and practices will help you provide the best experience for your mobile users.\nWhen to Use the Navigation Menu or the Action Bar\n\nAs we’ve seen throughout the examples in this book, you can extend and customize the Salesforce app and make your new functionality accessible to users from either the navigation menu or from the action bar. Here we’ll look at when you should use one method over another.\n\n**Navigation menu**\n\nThe navigation menu appears when you tap 📚. This menu is available in the global context. For example, if users log in and are viewing items in the feed, they can tap and open the navigation menu, and it displays menu items. Typically, these menu items lead to more complex business processes that don’t take place in the context of any particular object.\n\nMenu items in the navigation menu should bring users to a fully functional page or app. So if you have a page or app that contains many fields through which the user would need to scroll and perform a more complex process, you’ll want to make your page or app available from the navigation menu.\n\nAn example from this book is the Find Warehouses Visualforce page that we made available from the navigation menu in *Extending the Salesforce App with Visualforce Pages* on page 79. When the mobile technician taps the menu item, a page appears that contains a Google map and displays any nearby warehouses. The functionality of this page is global—not in the context of any particular object in our schema.\nAction Bar\n\nThe action bar and its action menu appear on all pages that support actions. The action bar is for accessing custom functionality that displays small amounts of data and allows users to perform short, quick actions. If you have functionality that occurs in the context of an object, you’ll want to add it as an action in the action bar.\n\nAn example from this book is the Create Quick Order action, available from the action bar within a customer account. While the mobile technicians are servicing a customer account, they can tap the action and then enter in just the merchandise name and distance to find warehouses with a part in stock. Then the technicians enter the quantity and a customer order is created. The functionality of this Visualforce page occurs within the context of a customer account. The user interaction with the page is quick, and it’s a simple process to search and create an order because the action contains only a few fields.\nGuidelines and Best Practices\n\nVisualforce pages aren’t automatically mobile friendly in the Salesforce app. The standard Salesforce header and sidebar are disabled in favor of the mobile controls, and a JavaScript API is available to make it possible for Visualforce pages to connect with mobile navigation management. In other respects the pages remain as they are and, although usable within the app, desktop focused Visualforce pages will feel desktop focused.\n\nFortunately, making your apps look great in the Salesforce app is straightforward. You can either revise your code so that your pages work in both the full Salesforce site and the app, or you can create mobile-specific pages.\n\nIn this chapter, you’ll learn best practices for how to:\n\n• Share Visualforce pages between mobile and desktop.\n• Exclude Visualforce from mobile or desktop.\n• Choose the best architecture for your Visualforce pages.\n• Choose an effective page layout for your pages.\n• Manage user input and navigation.\n• Use Visualforce pages as custom actions.\n• Tune your pages for the best performance.\n\nSharing Visualforce Pages Between Mobile and Desktop\n\nRevise Visualforce pages that appear in both the Salesforce app and in the full Salesforce site to support both environments. This includes Visualforce pages used as custom actions, and Visualforce pages added to standard page layouts, except those added to the Mobile Cards section of a page layout.\n\nVisualforce pages that need to work in both environments include:\n\n• Pages used as custom actions. Custom actions appear in the action bar in the Salesforce app, and in the publisher menu in the full Salesforce site.\n• Pages added to normal page layouts, when Available for Lightning Experience, Lightning Communities, and the mobile app is enabled for the page.\n• Custom Visualforce buttons or links added to normal page layouts.\n• Standard button overrides with Visualforce pages for the New, Edit, View, Delete, and Clone actions. Overriding standard list and tab controls isn’t supported in the app. Button overrides won’t appear in the app unless Available for Lightning Experience, Lightning Communities, and the mobile app is enabled for the page.\nNote: Standard buttons that are overridden with a Visualforce page disappear from record detail pages and record lists in the app if Available for Lightning Experience, Lightning Communities, and the mobile app isn’t selected for the Visualforce page that overrides the corresponding button.\n\nExcluding Visualforce Pages from Mobile or Desktop\n\nTo display your Visualforce pages only in the Salesforce app, add them to the Mobile Cards section of your page layout. To add Visualforce pages to either the app or the full Salesforce site, use tab and navigation settings.\n\nVisualforce pages that can be configured to be desktop-only or mobile-only include:\n\n- Pages added as mobile cards on page layouts. These only appear in the Salesforce app.\n- Pages added to normal page layouts, when Available for Lightning Experience, Lightning Communities, and the mobile app is disabled for the page. These only appear in the full Salesforce site.\n- Pages used in Visualforce tabs. You add tabs to mobile navigation separately from adding them to the full Salesforce site navigation.\n\nChoosing an Architecture for Visualforce Pages in the Salesforce App\n\nThere are several ways to design and structure Visualforce pages, each with different trade-offs with respect to development time, developer skill required, and how thoroughly you want your custom functionality to match the Salesforce app.\n\nUse one of the following approaches for the structure of your pages:\n\n- Standard Visualforce Pages on page 109\n- Mixed Visualforce and HTML on page 111\n- JavaScript Remoting and Static HTML on page 113\n\nStandard Visualforce Pages\n\nNormal Visualforce pages render well on mobile browsers, and can be used as-is, with a modest reduction of the user experience compared to mobile-optimized Web pages. Pages display as they would on the full Salesforce site, and won’t visually match other Salesforce app features.\nLimitations\n\nLimitations to the user experience include:\n\n- Tap targets—buttons, links, form fields, and so on—are optimized for mouse cursors, and can be difficult to hit accurately with a fingertip.\n- The visual design is unchanged, and may not fit with the mobile-optimized, modern visual design of the Salesforce app.\n\nIf your development timeline is aggressive, you might find these limitations acceptable.\n\n**Example: Example of a Standard Visualforce Page**\n\nThe following code provides a sample for a standard Visualforce page that allows a user to edit a warehouse record. The edit feature is provided by the standard controller for the object.\n\n```xml\n<apex:page standardController=\"Warehouse__c\">\n <apex:form>\n <apex:pageBlock title=\"{! warehouse__c.Name }\">\n <apex:pageBlockSection title=\"Warehouse Details\" columns=\"1\">\n <apex:inputField value=\"{! warehouse__c.Street_Address__c }\"/>\n <apex:inputField value=\"{! warehouse__c.City__c }\"/>\n <apex:inputField value=\"{! warehouse__c.Phone__c }\"/>\n </apex:pageBlockSection>\n <apex:pageBlockButtons location=\"bottom\">\n <apex:commandButton action=\"{! quickSave }\" value=\"Save\"/>\n </apex:pageBlockButtons>\n </apex:pageBlock>\n </apex:form>\n</apex:page>\n```\n\nThis page can be used in both the Salesforce app and the full Salesforce site. It displays as a standard desktop Visualforce page in both contexts.\nMixed Visualforce and HTML\n\nCombine Visualforce tags for form elements and output text with static HTML for page structure to create mobile-friendly pages that more closely match the visual design of the Salesforce app. For mobile-only pages, you can quickly convert an existing Visualforce page, but this doesn’t work as well for pages that are used in both the Salesforce app and the full Salesforce site.\n\nVisualforce pages designed this way are still \"standard\" Visualforce, in that they use the standard request-response cycle, standard controller functionality, `<apex:inputField>` for form fields, POSTBACK and view state, and so on. The main difference from authoring pages for the full Salesforce site is the reduced or eliminated use of Visualforce tags to add structure to the page, in favor of static HTML. That is, replacing `<apex:pageBlock>`, `<apex:pageBlockSection>`, and so on, with `<div>`, `<p>`, `<span>`, and so on.\n\nThis approach also requires creating CSS stylesheets to manage the look-and-feel of the page elements, instead of using the built-in, automatically applied styles provided when you use the Visualforce components. While this can take some time, it allows you to much more closely match the visual design of the Salesforce app. This also means that pages designed this way won’t match the full Salesforce site visually.\n\nApplying this Approach to Your Visualforce Pages\n\nTo use this approach for creating pages to use in the Salesforce app, follow a few general rules.\n\n- Don’t use the following Visualforce tags:\n - `<apex:pageBlock>`\n - `<apex:pageBlockButtons>`\n - `<apex:pageBlockSection>`\n - `<apex:pageBlockSectionItem>`\n - `<apex:pageBlockTable>`\n\n- Use `<apex:form>`, `<apex:inputField>` or `<apex:input>`, and `<apex:outputLabel>` for forms.\n- Use `<apex:outputText>` or Visualforce for non-editable text.\n- Use your preferred HTML to construct the structure for the page: `<div>`, `<span>`, `<h1>`, `<p>`, and so on.\n- Use CSS styling to apply your preferred visual design.\nAdvantages and Limitations\n\nThe advantages of this approach include:\n\n- Reasonably fast development time, and you use the normal Visualforce development tools and processes.\n- It’s reasonably easy to repurpose existing pages.\n- You can more closely match the Salesforce app’s look and feel.\n\nSome limitations to keep in mind:\n\n- This approach makes the usual Visualforce request round trips, with larger data payloads, compared to a fully mobile-optimized approach using JavaScript remoting.\n- It’s extra work to add CSS styles that replace the styles automatically added by `<apex:pageBlock>` and related components.\n\nExample: Example of a Mixed Visualforce and HTML Page\n\nThe following code sample shows a mixed HTML and Visualforce page that allows a user to edit a warehouse record. The edit feature is provided by the standard controller for the object.\n\n```xml\n<apex:page standardController=\"Warehouse__c\">\n <style>\n html, body, p { font-family: sans-serif; }\n </style>\n <apex:form >\n <h1>{!Warehouse__c.Name}</h1>\n <h2>Warehouse Details</h2>\n <div id=\"theForm\">\n <apex:outputLabel for=\"address\" value=\"Street Address\"/>\n <apex:inputField id=\"address\"\n value=\"{\"! warehouse__c.Street_Address__c}\"/>\n </div>\n <div>\n <apex:outputLabel for=\"city\" value=\"City\"/>\n <apex:inputField id=\"city\"\n value=\"{\"! warehouse__c.City__c}\"/>\n </div>\n </apex:form>\n</apex:page>\n```\nThis page can be used in both the Salesforce app and the full Salesforce site. It displays as a standard page on the full Salesforce site, but without the full Salesforce styling for the form. In the Salesforce app, it displays roughly matching the Salesforce app’s visual style. With additional styles, the page can approximate the visual style for both versions.\n\n### JavaScript Remoting and Static HTML\n\nCombine JavaScript remoting and static HTML to offer the best user experience, with the best performance and user interface match to the Salesforce app. This architecture avoids most Visualforce tags in favor of rendering page elements in JavaScript. This option requires the most developer expertise, and can take a little longer to set up than standard Visualforce or mixed Visualforce and HTML. Use the Salesforce Mobile Packs for a fast start and to work with the very latest in mobile Web application technology.\n\nVisualforce pages designed this way eschew many of the automatic, simplified features of standard Visualforce, in favor of taking more control over the request-response cycle, and performing page updates using JavaScript instead of page reloads. This can substantially improve the performance of the page, especially over the lower bandwidth, higher latency wireless network connections that make mobile devices so, well, mobile. The downside is that there is more code to write, and you need expertise in JavaScript, JavaScript remoting, HTML5, your mobile toolkit, and CSS, in addition to Apex and Visualforce. The upside of the downside is that you’re working with the latest, most advanced tools for mobile development, and the pages you can build are the best, most complete way to “snap in” custom functionality that fully integrates with the app.\n\nYou can build desktop Visualforce pages using this approach as well as pages for the Salesforce app. It’s even possible to share such pages between the two environments by customizing the styling, though it’s a challenge to closely match the full Salesforce site look and feel. Most importantly, the pages you design can be fully responsive, adapting and working across a range of devices and form factors.\nApplying this Approach to Your Visualforce Pages\n\nTo use this approach for creating pages for the Salesforce app, follow this general process:\n\n1. Install your preferred Salesforce Mobile Pack (available on Salesforce) into your organization as a static resource.\n\n2. Set your page’s docType to `html-5.0`. Strongly consider disabling the standard stylesheets and header. For example:\n\n ```xml\n <apex:page standardController=\"Warehouse__c\"\n extensions=\"WarehouseEditor\"\n showHeader=\"false\" standardStylesheets=\"false\"\n docType=\"html-5.0\">\n ```\n\n3. Add scripts and styles from your chosen mobile toolkit to the page using Visualforce resource tags. For example:\n\n ```xml\n <apex:includeScript\n value=\"{!URLFOR($Resource.Mobile_Design_Templates,\n 'Mobile-Design-Templates-master/common/js/\n jQuery2.0.2.min.js')}\">\n ```\n\n4. Use HTML5 and your mobile toolkit’s tags and attributes to create a page skeleton.\n\n5. Add JavaScript functions to the page as handlers to respond to user interaction. Use JavaScript remoting to call Apex `@RemoteAction` methods that retrieve records, perform DML, and so on.\n\n6. Add additional JavaScript functions to handle user actions and page updates. Perform page updates by constructing HTML elements in JavaScript, and then adding or appending them to the page skeleton.\n\n**Example: Example of a JavaScript Remoting and Static HTML Page**\n\nThe following code sample shows a remoting + HTML Visualforce page that allows a user to edit a warehouse record. The edit feature is provided by a controller extension with `@RemoteAction` methods that respond to JavaScript remoting requests.\n\n```xml\n<apex:page standardController=\"Warehouse__c\"\n extensions=\"WarehouseEditor\"\n showHeader=\"false\" standardStylesheets=\"false\"\n docType=\"html-5.0\" applyHtmlTag=\"false\" applyBodyTag=\"false\">\n```\nChapter 13 Development Guidelines and Best Practices\n\n<!-- Include Mobile Toolkit styles and JavaScript -->\n<apex:stylesheet\n value=\"{!URLFOR($Resource.Mobile_Design_Templates,\n 'Mobile-Design-Templates-master/common/css/app.min.css')}\"/>\n\n<apex:includeScript\n value=\"{!URLFOR($Resource.Mobile_Design_Templates,\n 'Mobile-Design-Templates-master/common/js/jQuery2.0.2.min.js')}\"/>\n\n<apex:includeScript\n value=\"{!URLFOR($Resource.Mobile_Design_Templates,\n 'Mobile-Design-Templates-master/common/js/jquery.touchwipe.min.js')}\"/>\n\n<apex:includeScript\n value=\"{!URLFOR($Resource.Mobile_Design_Templates,\n 'Mobile-Design-Templates-master/common/js/main.min.js')}\"/>\n\n<head>\n <style>\n html, body, p { font-family: sans-serif; }\n input { display: block; }\n </style>\n</head>\n\n<script>\n $(document).ready(function(){\n // Load the record\n loadWarehouse();\n });\n\n // Utility; parse out parameter by name from URL query string\n $.urlParam = function(name){\n var results = new RegExp('[\\?&]' + name + '=(([^&#]*))').exec(window.location.href);\n return results[1] || 0;\n }\n\n function loadWarehouse() {\n // Get the record Id from the GET query string\n warehouseId = $.urlParam('id');\n// Call the remote action to retrieve the record data\nVisualforce.remoting.Manager.invokeAction(\n '{$RemoteAction.WarehouseEditor.getWarehouse}',\n warehouseId,\n function(result, event){\n if(event.status){\n console.log(warehouseId);\n $('#warehouse_name').text(result.Name);\n $('#warehouse_address').val(result.Street_Address__c);\n $('#warehouse_city').val(result.City__c);\n $('#warehouse_phone').val(result.Phone__c);\n } else if (event.type === 'exception'){\n console.log(result);\n } else {\n // unexpected problem...\n }\n });\n\nfunction updateWarehouse() {\n // Get the record Id from the GET query string\n warehouseId = $.urlParam('id');\n\n // Call the remote action to save the record data\n Visualforce.remoting.Manager.invokeAction(\n '{$RemoteAction.WarehouseEditor.setWarehouse}',\n warehouseId, $('#warehouse_address').val(),\n $('#warehouse_city').val(),\n $('#warehouse_phone').val(),\n function(result, event){\n if(event.status){\n console.log(warehouseId);\n $('#action_status').text('Record updated.');\n } else if (event.type === 'exception'){\n console.log(result);\n $('#action_status').text('Problem saving record.');\n } else {\n // unexpected problem...\n }\n });\n}\nThe static HTML provides the shell of the page, including empty form fields. JavaScript functions load the record, fill in the form fields, and send updated form data back to Salesforce.\n\nAlthough this page can be used in the full Salesforce site, it’s designed as a Salesforce app page and looks very different than a normal Visualforce page.\n\n**Example: Example of a JavaScript Remoting and Static HTML Controller**\n\nUnlike the other two approaches to creating mobile pages, the remoting + HTML approach doesn’t use standard controller functionality to retrieve data from and save data to Salesforce. Instead, you create a controller extension, or custom controller, to add any `@RemoteAction` methods your page requires. Here’s a simplified controller extension that supports the above page.\n\n```java\nglobal with sharing class WarehouseEditor {\n\n // Stub controller\n // We're only using RemoteActions, so this never runs\n public WarehouseEditor(ApexPages.StandardController ctl) { }\n\n @RemoteAction\n global static Warehouse__c getWarehouse(String warehouseId) {\n\n // Clean up the Id parameter, in case there are spaces\n warehouseId = warehouseId.trim();\n\n // Simple SOQL query to get the warehouse data we need\n Warehouse__c wh = [\n SELECT Id, Name, Street_Address__c, City__c, Phone__c\n FROM Warehouse__c\n WHERE Id = :warehouseId]\n\n return(wh);\n }\n\n @RemoteAction\n global static Boolean setWarehouse(\n String whId, String street, String city, String phone) {\n\n // Get the warehouse record for the Id\n }```\n\nChapter 13 Development Guidelines and Best Practices\nVisualforce Components and Features to Avoid in the Salesforce App\n\nMost core Visualforce components (those components in the apex namespace) function normally within the Salesforce app. Unfortunately, that doesn’t mean they’re optimized for mobile, or that every feature works with the app. You can improve the mobile user experience of your Visualforce pages by following some straightforward rules.\n\nIn general, avoid structural components, like `<apex:pageBlock>` and child components, and other components that mimic the Salesforce look and feel, such as `<apex:pageBlockTable>`. If you must use these components, set them to one column, using `<apex:pageBlockSection columns=\"1\">`, instead of the default of two columns.\n\nAvoid wide, non-wrapping components, especially `<apex:detail>`, `<apex:enhancedList>`, `<apex:listViews>`, and `<apex:relatedList>`, which are all unsupported. Keep device width in mind when creating tables with `<apex:dataTable>`.\n\nAvoid using `<apex:inlineEditSupport>`. Inline editing is a user interface pattern that works well for mouse-based desktop apps, but it’s difficult to use on a touch-based device, especially on phones where the screen is small.\n\nUsing `<apex:inputField>` is fine for fields that display as a basic input field, like text, email, and phone numbers, but avoid using it for field types that use an input widget, such as date and lookup fields.\n\nDon’t use `<apex:scontrol>`. sControls aren’t supported anywhere in the Salesforce app.\nPDF rendering, by setting `renderAs=\"PDF\"` on `<apex:page>`, isn’t supported for pages in the Salesforce app.\n\nUnsupported Visualforce Components\n\nHere’s a list of Visualforce components that aren’t supported in the Salesforce app, and shouldn’t be used in Visualforce pages that will be used with the Salesforce app.\n\n- `<analytics:reportChart>`\n- `<apex:detail>`\n- `<apex:emailPublisher>`\n- `<apex:enhancedList>`\n- `<apex:flash>`\n- `<apex:inputField>` for field types that use a widget for input, instead of a basic form field\n- `<apex:listViews>`\n- `<apex:logCallPublisher>`\n- `<apex:relatedList>`\n- `<apex:scontrol>`\n- `<apex:sectionHeader>`\n- `<apex:selectList>` for picklist fields\n- `<apex:tabPanel>` (and, as a consequence, `<apex:tab>`) \n- `<apex:vote>`\n\n**Warning:** Embedded Visualforce pages—that is, those added to a page layout—that contain an `<apex:enhancedList>` component may cause the Salesforce app to crash on iOS.\n\nStandard components outside the `apex` namespace, for example, `<liveagent:*>, `<chatter:*>`, and so on, aren’t supported in the app.\n\nCustom components can be used in Visualforce in the app, as long as they themselves don’t use unsupported components.\n\nChoosing an Effective Page Layout\n\nDesign Visualforce pages that look good and work well within the Salesforce app by using a page layout appropriate for the context that the page is used in. Pages added as main navigation tabs or as custom actions in the action bar can use nearly the full screen of the device, and can scroll vertically, while Visualforce added to an object’s page layout has to fit within a specific, limited space.\nIn general, Visualforce added to page layouts works best if it’s read-only, at-a-glance information. Put features that require user interaction, like multi-field forms, on full screen pages by adding them as tabs in the main navigation, or as custom actions from the action bar.\n\n**Mobile Card Layout**\n\nMobile cards have the most limited layout, both in size and placement. Visualforce pages added as mobile cards on an object’s page layout appear on the related lists page for the object in the Salesforce app, as the first items on the page, below the header.\n\n1. The record header displays when an record is loaded, but can be scrolled up and off the screen by the user. When on screen, it’s 158 pixels high on all devices, and takes the full width of the screen. You can’t control the display of the record header.\n\n2. Mobile cards display above all of the related items on the record.\n\n3. Set the width to 100%; the element sizes automatically, minus some padding on either side. The content of mobile cards can’t be scrolled, so make sure it fits in the space you provide to it.\n\n4. Control the height of the mobile card by setting the height in pixels in the page layout editor. The mobile card area uses exactly that height, even if the mobile card’s content is shorter. In that case, the extra area is blank. If the card’s content is taller, the content is clipped. As a best practice, don’t create mobile cards taller than the smallest device screen you intend to support. Be sure to set the height of screen elements relevant to your environment.\n\n5. The record’s related items are displayed after all mobile cards.\nWhile you can add multiple mobile cards, it quickly becomes a user experience challenge to scroll past them to the related lists. It’s a best practice to add only one or two. If you need a full screen to display your page, consider moving it to a custom action on the object instead.\n\nThe normal Salesforce header and sidebar are automatically removed from Visualforce pages added as mobile cards. You may find it useful to explicitly turn them and the full Salesforce site stylesheets off while you’re developing the page. Additionally, if your page uses the Google Maps API, Google recommends using an HTML5 doctype. Here’s an `<apex:page>` tag that does all of these things:\n\n```\n<apex:page standardController=\"Warehouse__c\"\n docType=\"html-5.0\" showHeader=\"false\" standardStylesheets=\"false\">\n```\n\n**Visualforce on a Page Layout**\n\nVisualforce pages added to an object’s page layout display on the record details page. Unlike mobile cards, you can control the Visualforce element’s placement on the mobile record details screen, putting fields and other record details above and below it, by changing its placement on the object’s page layout. Visualforce pages added this way follow the same rules for ordering that fields and other elements do.\n\n1. The record header displays when an record is loaded, but can be scrolled up and off the screen by the user. When on screen, it’s 158 pixels high on all devices, and takes the full width of the screen. You can’t control the display of the record header.\n\n2. Record controls and details, automatically generated by the Salesforce app.\n3. A Visualforce page added to the object’s page layout.\n\n4. Set the width to 100%; the element sizes automatically, minus some padding on either side.\n\n5. Control the height of the Visualforce page’s area by setting the height of the item in pixels in the page layout editor. The Visualforce element uses exactly that height, even if the content is shorter. In that case, the extra area is blank. If the page’s content is taller, the content is clipped. As a best practice, don’t set inline Visualforce pages to be taller than the smallest device screen you intend to support.\n\nAs is the case with multiple cards, although you can add multiple inline Visualforce pages to a page layout, it quickly becomes a user experience challenge to scroll past them to see the rest of the page. It’s a best practice to never add more than two Visualforce page elements in a row; separate Visualforce elements with a regular page element, such as a field. If you need a full screen to display your page, consider moving it to a custom action on the object instead.\n\nVisualforce pages added to page layouts automatically have the normal Salesforce header and sidebar removed. You may find it useful to explicitly turn them and the full Salesforce site stylesheets off while you’re developing the page. Additionally, if your page uses the Google Maps API, Google recommends using an HTML5 doctype. Here’s an `<apex:page>` tag that does all of these things:\n\n```xml\n<apex:page standardController=\"Warehouse__c\" docType=\"html-5.0\" showHeader=\"false\" standardStylesheets=\"false\">```\n\nFull Screen Layout\n\nVisualforce pages added to the Salesforce app navigation menu, or as custom actions to the action bar, can use almost the entire screen, allowing more information, and more complex user interfaces.\n1. The Salesforce header, which provides access to the main navigation menu, is 42 pixels high. The contents of the header can’t be changed.\n\n2. The rest of the device screen is dedicated to your Visualforce page.\n\nWhen displayed in the Salesforce app, the standard Salesforce header and sidebar are automatically removed, like Visualforce pages used as mobile cards or added to page layouts. However, Visualforce pages used as custom actions in the action bar are shared with the full Salesforce site, and pages added to the navigation may or may not be shared. Pages shared with the full Salesforce site shouldn’t have the standard Salesforce header and sidebar explicitly removed unless removing the header and sidebar is the standard practice for all Visualforce on your site.\n\nUser Input and Interaction\n\nUse `<apex:input>`, the `type` attribute, and pass-through HTML attributes to create mobile-friendly forms and user interfaces that are efficient and take advantage of native mobile browser features.\n\nWithout a keyboard and mouse, standard HTML forms can be difficult for users to fill out and interact with on mobile devices, especially phones. For Visualforce pages that don’t use JavaScript remoting to make requests, choose Visualforce components for form input with an eye towards mobile users. No other change you can make to your Visualforce pages will have a larger usability impact than taking advantage of new HTML5 and mobile browser features to improve your forms and user interface controls.\nChoose Efficient Input Elements\n\nUse `<apex:input>` to get user input whenever possible. `<apex:input>` is an HTML5-ready, mobile-friendly, general-purpose input component that adapts to the data expected by a form field. It’s even more flexible than `<apex:inputField>` because it uses the `type` attribute to allow client browsers to display type-appropriate user input widgets, such as a date picker, or use a type-specific keyboard that makes entering input on a mobile device much easier.\n\nYou can also use `<apex:inputField>` to create an HTML input element for a value that corresponds to a field on a Salesforce object. `<apex:inputField>` adapts the HTML generated to correspond with the data type of the underlying sObject field. Usually this is what you want, but if it isn’t, use the `type` attribute to override the automatic data type detection. However, be aware that `<apex:inputField>` generates a lot of HTML, and requires additional resources to load, which means it’s not the most efficient component to use over a mobile wireless connection.\n\nUse the `type` Attribute to Create Mobile-Friendly Input Elements\n\nSet the `type` attribute on `<apex:input>` components—and `<apex:inputField>` if you’re using it—to display data-type-specific keyboards and other input user interface widgets that are easier to use on touchscreens. The value is passed through to the generated HTML `<input>` element, for display in the Salesforce app.\n\nAs users step through form elements, the input method for that form element adapts for the type of data expected. Text fields show the standard keyboard, email fields show an email-specific keyboard with characters like the “@” sign and “.com” assigned to keys, date fields show a date picker, and so on.\n\nHere’s an example of a form that illustrates how this works:\n\n```xml\n<apex:form >\n\n <apex:outputLabel value=\"Phone\" for=\"phone\"/>\n <apex:input id=\"phone\" value=\"{!fPhone}\" type=\"tel\"/><br/>\n\n <apex:outputLabel value=\"Email\" for=\"email\"/>\n <apex:input id=\"email\" value=\"{!fText}\" type=\"email\"/><br/>\n\n <apex:outputLabel value=\"That Number\" for=\"num\"/>\n <apex:input id=\"num\" value=\"{!fNumber}\" type=\"number\"/><br/>\n\n <apex:outputLabel value=\"The Big Day\" for=\"date\"/>\n <apex:input id=\"date\" value=\"{!fDate}\" type=\"date\"/><br/>\n\n</apex:form>\n```\nAs the user moves through the form fields, either by tapping into them or tapping the Next button, the keyboard changes to match the expected data for the field.\n\nThese type-specific keyboards make filling in forms much easier for people using their mobile devices. <apex:input> allows the following explicit type values to be set:\n\n- date\n- datetime\n- datetime-local\n- month\n- week\n- time\n- email\n- number\n- range\n- search\n- tel\n- text\n- url\n\nYou can also set type to auto, and the data type of the associated controller property or method is used. The HTML type attribute, including new HTML5 features, is a standard part of HTML. For additional details about the type attribute, what you can use it for, and how it relates to mobile development, see Chapter 13 Development Guidelines and Best Practices.\nWHATWG’s list of `input` attribute values and descriptions. Not all values are supported on Visualforce input components. If you want to use a value not supported by Visualforce, use static HTML instead of a Visualforce tag.\n\n**Use HTML5 Pass-Through Attributes for Client-Side Validation**\n\nSet pass-through attributes on your `<apex:input>` and other Visualforce components to enable other HTML5 features, such as client-side validation. By performing basic validation on the client side, you can avoid sending a request to the server and waiting for a response, when there are easily-corrected errors on a form.\n\nAttributes prefixed with `html-` are passed through to the generated HTML, with the prefix removed. To enable client-side validation, set an `html-pattern` attribute on the `<apex:input>` tag to match expected form values. This will add a `pattern` attribute to the generated `<input>` tag, enabling client-side validation for that field.\n\n**Note:** Client-side validation requires that the Visualforce page be set to API version 29.0 or later, and the page `docType` be set to `html-5.0`.\n\nValidation patterns are regular expressions. Form input is checked against the expression, and if it matches, the field input is considered valid. If it doesn’t match, the input is considered invalid; an error message is displayed, and the form won’t be submitted to the server. Here’s an example of a field that requires an email address from a specific domain:\n\n```html\n<apex:input id=\"email\" value=\"{!fText}\" type=\"email\"\n html-placeholder=\"you@example.com\"\n html-pattern=\"^[a-zA-Z0-9._-]+@example.com$\"\n title=\"Please enter an example.com email address\"/>\n```\n\nOther useful HTML5 attributes that can be set as pass-through attributes include:\n\n- `placeholder` (set using the `html-placeholder` attribute)—adds ghost text to the field to show sample input to the user.\n- `title` (set using the `title` attribute on `<apex:input>`, and the `html-title` attribute on components without a title attribute)—adds an error message to use if the field fails client-side validation.\n\nFor inspiration for how you can use attributes to enhance the usability of HTML `<input>` elements, *HTML5 Forms Introduction and New Attributes* is a good survey of the new features in HTML5. For further details, especially for mobile users, and details of client-side forms validation, see [Client-side form validation](#) and [Improving the user experience on mobile devices](#) in WHATWG’s *HTML: The Living Standard.*\nManaging Navigation\n\nThe Salesforce app manages navigation using events. The navigation event framework is made available as a JavaScript object that provides a number of utility functions that make creating programmatic navigation that “just works” a breeze. The advantage is a navigation experience that’s more natural for a mobile context. It also makes creating post-completion navigation, such as redirecting to an order page after the order is successfully submitted, easier for Salesforce developers.\n\nIn the Salesforce app, programmatic navigation for Visualforce pages generally works something like this:\n\n1. A user invokes a Visualforce page, usually from the navigation menu, or from an action in the action bar.\n2. The Visualforce page loads and runs, including any custom controller or extension code called by the page.\n3. The user interacts with the page in some way: for example, to fill in some form values.\n4. The user submits the form, or performs some other action on the page that commits a change.\n5. Controller or extension code runs, saving the changes to Salesforce, and returning the results of the action.\n6. The Visualforce page, using JavaScript response handlers, receives the results of the action, and when successful, responds by redirecting the user to a new page that shows the results of their action.\n\nThis scenario is easily handled by the app’s navigation framework.\n\nAnother common use case is simply adding links or other user interface controls to a page, which move from that Visualforce page to another page in the app. This navigation is also easily managed by the app’s navigation framework.\n\nIn these cases, navigation is handled by a special utility JavaScript object, sforce.one. The sforce.one object is automatically added to all Visualforce pages when they run inside the Salesforce app. This object provides a number of functions that trigger navigation events when they run. To use these functions, you can call them directly from your page’s JavaScript code, or you can attach calls as click handlers to elements on the page.\n\nHere’s a JavaScript function that creates markers to add to a Google map.\n\n```javascript\nfunction setupMarker()\n{\n // Use JavaScript nav function to determine if we are\n // in the Salesforce app and set navigation link appropriately\n var warehouseNavUrl =\n 'sforce.one.navigateToSObject('/', + warehouse.Id + '}}');\n```\nThe very first line builds a string, `warehouseNavUrl`, that, when used as a JavaScript URL, navigates to the detail page for the warehouse. The link is created around the warehouse name, and appears in the information panel (put together in the `warehouseDetails` string) that appears when you click a marker. Clicking the warehouse name takes you to the detail page for that warehouse (the omitted part of the function code deals with the Google Maps API calls to create a marker and add it to the map).\n\nIf you have JavaScript code or HTML markup that runs inside of the Salesforce app, keep these considerations in mind:\n\n- Don’t directly manipulate the browser URL using `window.location.href`. This doesn’t work well with the app’s navigation management system.\n- Don’t use `target=\"_blank\"` in navigation URLs; you can’t open new windows inside the app.\n\n### Navigation Methods within the Canvas Framework\n\nIf you’re using Canvas, there’s a simpler way to control navigation around canvas apps and canvas personal apps in the Salesforce app.\n\nYou can use Lightning Platform methods to control navigation in the app. These methods within the Canvas framework are events that reside in the JavaScript library. When you call one of the navigation methods from your canvas code, you send an event into Salesforce that reads the payload and directs the user to the specified destination.\n\nReference the navigation method as an event variable, with name and payload. For example:\n\n```javascript\nvar event = {name: \"s1.createRecord\", payload: {entityName: \"Account\", recordTypeId: \"00h300000001234\"}};\n```\nFor more information about using the new methods, see Salesforce App Navigation Methods for Use with Canvas Apps in the Canvas Developer Guide.\n\n## Navigation and Messaging with the `sforce.one` Object\n\nThe Salesforce Platform includes an event mechanism for navigation and messaging. This is exposed in Visualforce as a JavaScript object called `sforce.one`. It’s available in any page that appears in the Salesforce app.\n\nThe `sforce.one` object provides the following functions. Reference the function using dotted notation from the `sforce.one` object. For example: `sforce.one.navigateToSObject(recordId, view).\n\nFurther details of the underlying events fired by these functions can be found in the Lightning Aura Components Developer Guide.\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><code>back([refresh])</code></td>\n<td>Navigates to the previous state that’s saved in the <code>sforce.one</code> history. It’s equivalent to clicking a browser’s Back button. <code>refresh</code> is optional. By default, the page doesn’t refresh. Pass <code>true</code> to refresh the page if possible.</td>\n</tr>\n</tbody>\n</table>\n| `navigateToSObject(recordId[, view])` | Navigates to an sObject record, specified by `recordId`. This record “home” has several views, which in the Salesforce app are available as slides that the user can swipe between. `view` is optional and defaults to `detail`. `view` specifies the slide within record home to display initially. **Note:** Record IDs corresponding to ContentNote SObjects aren’t supported. The possible values are as follows. \n - `detail`: the record detail slide \n - `chatter`: the Chatter slide \n - `related`: the view of related slide |\n<p>| <code>navigateToURL(url[, isredirect])</code> | Navigates to the specified URL. Relative and absolute URLs are supported. Relative URLs are relative to the Lightning domain, and retain navigation history. External URLs—that |</p>\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>is, URLs that are outside the Lightning domain—open in a separate browser window.</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Note:</strong> Depending on the user’s device platform, device settings, version of Salesforce, and authentication requirements for the external URL being opened, the separate browser window might require authentication or re-authentication.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nUse relative URLs to navigate to different screens within your app. Use external URLs to allow the user to access a different site or app, where they can take actions that don’t need to be preserved in your app. To return to your app, the separate window that’s opened by an external URL must be closed when the user is finished with the other app. The new window has a separate history from your app, and this history is discarded when the window is closed. This also means that the user can’t click a Back button to go back to your app; the user must close the new window.\n\n`mailto:`, `tel:`, `geo:`, and other URL schemes are supported for launching external apps and attempt to “do the right thing.” However, support varies by mobile platform and device. `mailto:` and `tel:` are reliable, but we recommend that you test any other URLs on a range of expected devices.\n\n`isredirect` is optional and defaults to `false`. Set it to `true` to indicate that the new URL should replace the current one in the navigation history.\n\n**Note:** Be careful when using `navigateToURL` within the `onClick` handler of an `<apex:commandButton>` or any `<button type=\"submit\">` or `<input type=\"submit\">`. Even if `isredirect=true`, the default click action of the command button is a form post. In this scenario, the command button performs a form post and a `navigateToURL` action, requiring the user to click the back button twice to navigate to the previous page. To prevent the default click action, configure the `onClick` handler to either call `event.preventDefault()` or return `false`.\n\n**Note:** URLs corresponding to ContentNote SObjects aren’t supported.\nnavigateToFeed(subjectId, type)\n\nNavigates to the feed of the specified type, scoped to the subjectId. For some feed types, the subjectId is required but ignored. For those feed types, pass the current user’s ID as the subjectId.\n\ntype is the feed type. The possible values are as follows.\n\n- **BOOKMARKS**: Contains all feed items saved as bookmarks by the context user. Pass the current user’s ID as the subjectId.\n- **COMPANY**: Contains all feed items except feed items of type TrackedChange. To see the feed item, the user must have sharing access to its parent. Pass the current user’s ID as the subjectId.\n- **FILES**: Contains all feed items that contain files posted by people or groups that the context user follows. Pass the current user’s ID as the subjectId.\n- **GROUPS**: Contains all feed items from all groups the context user either owns or is a member of. Pass the current user’s ID as the subjectId.\n- **NEWS**: Contains all updates for people the context user follows, groups the user is a member of, and files and records the user is following. Contains all updates for records whose parent is the context user. Contains every feed item and comment that mentions the context user or that mentions a group the context user is a member of. Pass the current user’s ID as the subjectId.\n- **PEOPLE**: Contains all feed items posted by all people the context user follows. Pass the current user’s ID as the subjectId.\n- **RECORD**: Contains all feed items whose parent is a specified record, which could be a group, user, object, file, or any other standard or custom object. When the record is a group, the feed also contains feed items that mention the group. When the record is a user, the feed contains only feed items on that user. You can get another user’s record feed. Pass the record’s ID as the subjectId.\n- **TO**: Contains all feed items with mentions of the context user. Contains feed items the context user commented on and feed items created by the context user that are commented on. Pass the current user’s ID as the subjectId.\n### Function | Description\n---|---\n- TOPICS: Contains all feed items that include the specified topic. Pass the topic's ID as the `subjectId`. This value is supported in Salesforce for mobile web only. Topics aren't available in Salesforce for iOS or Salesforce for Android.\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><code>navigateToFeedItemDetail(feedItemId)</code></td>\n<td>Navigates to the specific feed item, <code>feedItemId</code>, and any associated comments.</td>\n</tr>\n<tr>\n<td><code>navigateToRelatedList(relatedListId, parentRecordId)</code></td>\n<td>Navigates to a related list for the <code>parentRecordId</code>. For example, to display a related list for a Warehouse object, the <code>parentRecordId</code> is <code>Warehouse__c.Id</code>. <code>relatedListId</code> is the API name or ID of the related list to display.</td>\n</tr>\n<tr>\n<td><code>navigateToList(listViewId, listViewName, scope)</code></td>\n<td>Navigates to the list view that's specified by the <code>listViewId</code>, which is the ID of the list view to be displayed. <code>listViewName</code> sets the title for the list view. It doesn't need to match the actual name that's saved for the list view. To use the saved name, set <code>listViewName</code> to null. Set <code>scope</code> to the name of the sObject in the view, for example, "Account" or "MyObject__c".</td>\n</tr>\n<tr>\n<td><code>createRecord(entityName[, recordTypeId][, defaultFieldValues])</code></td>\n<td>Opens the page to create a record for the specified <code>entityName</code>, for example, "Account" or "MyObject__c". <code>recordTypeId</code> is optional and specifies the record type for the created object. Calling <code>createRecord</code> without providing a <code>recordTypeId</code> may result in an error. <code>defaultFieldValues</code> is optional and, if provided, prepopulates fields on a record create panel, including fields not displayed on the panel. Users must have create access to fields with prepopulated values. Errors during saving that are caused by field access limitations don’t display error messages.</td>\n</tr>\n<tr>\n<td><code>editRecord(recordId)</code></td>\n<td>Opens the page to edit the record specified by <code>recordId</code>.</td>\n</tr>\n<tr>\n<td><code>showToast({toastParams})</code></td>\n<td>Shows a toast. A toast displays a message below the header at the top of a view. The <code>toastParams</code> object sets the attributes for the toast.</td>\n</tr>\n</tbody>\n</table>\nFunction | Description\n---|---\nUse any attribute available for the `force:showToast` Aura event. For example:\n```javascript\nsforce.one.showToast({\n \"title\": \"Success!\",\n \"message\": \"The record was updated successfully.\"\n});\n```\n\nKeep the following in mind when using the `sforce.one` object:\n\n- Calls to `sforce.one.navigateToURL` may result in an \"Unsupported Page\" error if the URL references standard pages for objects or Chatter pages. To avoid this error, ensure that the URL begins with a forward slash (`/_ui` instead of `_ui`).\n- The `sforce.one.createRecord` method doesn't respect Visualforce overrides on the standard action.\n- While developers can use the `PageReference` class to control navigation for the full site, it isn't supported for the Salesforce mobile app and may not work as expected. Some pages load using `PageReference`, but that may change with any update.\n\n**How `sforce.one` Handles API Versions**\n\nThe `sforce.one` object is frequently improved in new releases. To maintain backward compatibility, `sforce.one` provides version-specific behavior, and you can use a specific version of `sforce.one` in your apps.\n\nBy default, `sforce.one` uses the same version as the API version of the requested Visualforce page. For example, if a Visualforce page has an API version of 30.0, JavaScript on that page that uses `sforce.one` by default uses the API version 30.0 of `sforce.one`.\n\nThis means that when a Visualforce page is updated to a new API version, the page automatically uses the updated version of `sforce.one`. In the preceding example, if that Visualforce page is updated to API version 31.0, app functionality that uses `sforce.one` uses the API version 31.0 of `sforce.one`. If updated behavior in a new API version of `sforce.one` causes compatibility problems with the page's features, you have three options for correcting the problem:\n\n- Revert the Visualforce page's API version to the prior version. This action requires no code changes.\n• Update the code for the page’s features to fix the problem. This solution is best, but it might require some debugging, and it will definitely require code changes.\n\n• Use a specific version of sforce.one. This solution often requires minimal code changes.\n\n Note: sforce.one was added in Winter ’14 (API version 29.0) and wasn’t versioned until Summer ’14 (API version 31.0). All versions of sforce.one earlier than version 31.0 are identical to version 31.0. You can specify a version of sforce.one for any version that’s valid for Visualforce, that is, from version 15.0 to the current API version.\n\nUsing a Specific Version of sforce.one\n\nTo use a specific version of sforce.one, use the sforce.one.getVersion() function and provide it with the API version and a callback function that needs to use a specific version of sforce.one. The appropriate versions of sforce.one are automatically loaded by this call.\n\nThe signature for sforce.one.getVersion() is:\n\n```javascript\nsforce.one.getVersion(versionString, callbackFunction);\n```\n\nversionString is the API version that your application requires. It’s always two digits, a period, and one digit, such as “30.0”. Calls with invalid version strings fail silently.\n\ncallbackFunction is a JavaScript function that uses a specific version of sforce.one. sforce.one.getVersion() operates asynchronously, and your callback function is called when it finishes loading the requested version of sforce.one. Your callback function receives a single parameter, an sforce.one object for the specified API version. Use the object passed in instead of the global sforce.one to make calls to sforce.one that conform to the API version that your app requires.\n\nExamples of Using a Specific Version of sforce.one\n\nThe next examples all add a Create Account function to the following input button:\n\n```html\n<input type=\"button\" value=\"Create Account\" onclick=\"btnCreateAccount()\" id=\"btnCreateAcct\"/>\n```\n\nDefaulting to the Visualforce Page’s API Version\n\nApp code that should use the default version of sforce.one—the version that corresponds to the Visualforce Page’s API version—doesn’t need to ask for a version. Using that version happens automatically, and the code is straightforward.\n\n```javascript\nfunction MyApp() {\n // App code here\n\n // Example of creating a new account\n var account = sforce.one.newAccount();\n account.FirstName = \"John\";\n account.LastName = \"Doe\";\n account.Email = \"johndoe@example.com\";\n account.save();\n```\nApp functionality is created in a MyApp object, and then an event handling function calls the app function when that event, a button click, occurs. Separating application functionality from application event handling is a best practice, and it sets you up for using version-specific versions of sforce.one.\n\n**Using a Specific sforce.one API Version (Simple)**\n\nTo use a specific version of sforce.one, get and save a reference to a versioned instance of the object. Then use this object to make sforce.one calls. The simplest way is to save it in the MyApp object. In the next sample, references to the versioned instance of sforce.one are in bold.\nIn the preceding example, the event-handling function is expanded from the first example to include the creation of a version-specific instance of `sforce.one`. If your app needs to mix multiple versions, you can create multiple `MyApp` instances with appropriate versions and names. More than one or two, though, are cumbersome to manage. We recommend the next approach instead.\n\n**Using a Specific sforce.one API Version (Best)**\n\nA better way to organize your app code is to create version-specific instances of `sforce.one` in an app initialization block of code so you can keep the event handling separate.\n\n```jsx\n<script>\nfunction MyApp(sfone) {\n this.createAccount = function() {\n sfone.navigateToURL(\"/001/e\");\n };\n}\n\nvar app30 = null;\n\n// Initialize app: get versioned API, wire up clicks\nsforce.one.getVersion(\"30.0\", function(sfoneV30) {\n // Create app object with versioned sforce.one\n app30 = new MyApp(sfoneV30);\n\n // Wire up button event\n var btn = document.getElementById(\"btnCreateAcct\");\n btn.onclick = btnCreateAccount;\n});\n\n// Events handling functions\n// Can't be fired until app is defined\nfunction btnCreateAccount() {\n app30.createAccount();\n}\n</script>\n```\n\nIn this sample the app initialization is separated only by white space and comments, but you can separate it into functions for better encapsulation.\n\n**Using a Specific sforce.one API Version (Synchronous)**\nYou can trigger a synchronous mode for sforce.one by manually including the specific version of sforce.one's JavaScript on your page. The format for the URL to the library is: /sforce/one/sforceOneVersion/api.js. Here's an example:\n\n```html\n<script src=\"/sforce/one/30.0/api.js\"></script>\n\nfunction MyApp(sfone) {\n this.createAccount = function() {\n sfone.navigateToURL(\"/001/e\");\n }\n}\n\nvar app = null;\n\nsforce.one.getVersion(\"30.0\", function(sfoneV30) {\n app = new MyApp(sfoneV30);\n});\n\n// Events handling function\n// Can't be fired until app is defined\nfunction btnCreateAccount() {\n app.createAccount();\n}\n</script>\n```\n\nAlthough some situations require synchronous mode, the asynchronous version is preferred. If you forget to manually include the correct versions of the sforce.one library, your code will contain bugs that are difficult to diagnose.\n\n### Using Visualforce Pages as Custom Actions\n\nIf your Visualforce page is used as a custom action, design it so that it either acts upon a single record provided by a standard controller, or finds and acts upon a record, or records your custom controller code retrieves.\n\n### Custom Actions on an Object\n\nA Visualforce page added as a custom action on an object is invoked in the context of a record of that object type. The custom action is passed a specific record ID—the record the user was looking at when the user clicked the custom action. Design the page to act on that specific record type.\nVisualforce pages used as custom actions on an object must use the standard controller for that object. Use controller extensions to add custom code, including @RemoteAction methods you can call using JavaScript remoting.\n\nYour custom code could do more than make updates to the originating record. For example, the Create Quick Order custom action searches for matching merchandise. It then creates an invoice and line item, all as part of creating an order for a part. That logic occurs in the context of the originating account record—the invoice is associated to the account record where the quick order action was invoked.\n\nWhen you redirect to a URL internal to your org, the action dialog closes upon completion or programmatically navigating away. If you set up the redirect to point to an external URL, the behavior can vary because an external URL opens in a new browser tab.\n\n**Custom Global Actions**\n\nVisualforce pages used as global actions can be invoked in many different places and don’t have a specific record associated with them. They have complete “freedom of action,” which means it’s up to you to write the code.\n\nMore specifically, Visualforce pages used as global actions can’t use any standard controller. You must write a custom controller to handle the page. Your code might create one or many records, modify found records, and so on.\n\nWhen a global action completes, the user should be either redirected to a parent record created as part of the action or returned to where they started.\n\n**Creating Visualforce Pages That Work in Mobile and Desktop**\n\nCreate Visualforce pages that work well in both the Salesforce app and the full Salesforce site by writing code that adapts to the context it’s running in.\n\nThe Salesforce app provides a framework for handling various navigation controls and events. That framework isn’t available to Visualforce pages when they run on the full Salesforce site, because the sforce object is injected onto pages only inside the app. This means that, for pages shared between the Salesforce app and the full Salesforce site, you’ll want to write code that uses the sforce object when it’s available, and standard Visualforce navigation when it’s not.\n\nFor example, here is a bit of JavaScript that runs after a JavaScript remoting request successfully returns from the @RemoteAction method that creates a quick order. This code is from a Visualforce page that’s used as a custom action, which adds it to the action bar in the Salesforce app and the publisher\nmenu in the full Salesforce site. It needs to work in both places. The intent of the code is to navigate to the detail page for the account for whom the order was placed:\n\n```javascript\n// Go back to the Account detail page\nif( (typeof sforce != 'undefined') && sforce && (!!sforce.one) ) {\n // Salesforce app navigation\n sforce.one.navigateToSObject(aId);\n}\nelse {\n // Set the window's URL using a Visualforce expression\n window.location.href = '{!URLFOR($Action.Account.View, account.Id)}';\n}\n```\n\nThe `if` statement checks to see if the `sforce` object is available and usable. This is only true if the page is running inside the app. If `sforce` is available, the mobile navigation management system is used to go to the account’s detail page.\n\nIf the `sforce` object isn’t available, trying to use it to navigate anywhere results in a JavaScript error, and no navigation. So, instead, the code sets the window’s URL using a Visualforce expression that returns the URL for the account’s detail page. You don’t want to do this in the app because the navigation event will be lost by the framework, but it’s required in normal Visualforce.\n\n**Note:** It’s a best practice to factor out common tests like this one into their own helper function. You could add something like the following to a JavaScript static resource, and then just call `ForceUI.isSalesforce1()` in your if conditions. Then, if the detection logic changes, you only have to update it in one place.\n\n```javascript\n(function(myContext){\n myContext.ForceUI = myContext.ForceUI || {};\n myContext.ForceUI.isSalesforce1 = function() {\n return ((typeof sforce != 'undefined') && sforce && (!!sforce.one));\n }\n})(this);\n```\n\n**Performance Tuning for Visualforce Pages**\n\nPerformance is an important aspect of mobile Visualforce pages. Visualforce has a caching mechanism to help you tune the performance of your pages.\nTo enable caching for a page, use this statement:\n\n```xml\n<apex:page cache=\"true\" expires=\"600\"/>\n```\n\nThe parameters for page caching are:\n\n<table>\n<thead>\n<tr>\n<th>Attribute</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>cache</td>\n<td>Boolean value that specifies whether the browser should cache the page. If not specified, defaults to false.</td>\n</tr>\n<tr>\n<td>expires</td>\n<td>Integer value that specifies the period of cache in seconds.</td>\n</tr>\n</tbody>\n</table>\n\nFor more information, see Force.com Sites Best Practices on Developerforce\n\n**More Resources**\n\nHere are some more resources to help you tune the performance of your Salesforce apps:\n\n- Inside the Force.com Query Optimizer (webinar)\n- Maximizing the Performance of Force.com SOQL, Reports, and List Views (blog post)\n- Force.com SOQL Best Practices: Nulls and Formula Fields (blog post)\n\n**Canvas Guidelines and Best Practices**\n\nThere are some additional best practices and guidelines to keep in mind when exposing your applications as canvas apps and making them available to mobile users.\n\nCanvas makes it easy for you to integrate Web applications with the Salesforce app at the user interface level. However, the user experience in the app is different than in the full Salesforce site. You'll want to make sure you design your canvas apps for mobile users and be sure to test them in the mobile environment.\n\n**Canvas Apps in the Chatter Publisher and Salesforce App Action Bar**\n\nKeep these best practices and guidelines in mind when making your canvas apps available in the publisher and action bar.\nWhen you access a canvas app from the publisher in the full Salesforce site, the user interface is different than when you access a canvas app from the action bar or action menu in the Salesforce app. For example, in the feed in the full Salesforce site, the Share button is at the bottom of the feed item.\n\nIn the Salesforce app, the Share button is at the top of the screen.\nWhen creating a canvas custom action, the height available for that action in the full Salesforce site is much greater than the height for that action in the app. Use the Dimensions object in the Canvas SDK to render your canvas app in the correct size.\n\nKeep the labels for canvas custom actions concise. Longer labels may not fully display in the publisher.\n\nWhen you access a canvas app from the publisher, the **What are you working on?** pane appears above the canvas app. This pane remains fixed, even if your canvas app scrolls.\n\nWhen the request comes into your Web application that’s exposed as a canvas app, you can determine the type of device that’s making the request. Use this information to render your app based on the requesting device for a better user experience. For example, you can add logic so that if the request comes from a mobile phone, only four lines of text are displayed; if the request comes from a tablet, ten lines of text are displayed.\n\nIn most cases, you’ll want to specify 100% for the canvas app height and width in your CSS. This ensures that the canvas app takes up the maximum available screen space.\n\nCanvas apps appear in an iFrame, so you can format the app appearance as you would any standard iFrame.\nCanvas Apps in the Feed\n\nKeep these best practices and guidelines in mind when making your canvas apps available in the feed.\n\n- On a mobile device, the link text and description for a feed item display fewer characters than in the full Salesforce site. Keep this in mind when programmatically creating feed items.\n- When a canvas app is contained in a feed item, the feed item appears with a link to the canvas app. On a mobile device, the canvas app doesn’t appear in the feed; instead, a new page opens and displays the canvas app.\n- In Salesforce for mobile web, the screen changes if the device is rotated. Your canvas app should support rotation, if possible, to maintain a seamless user experience. Note that Salesforce for iOS and Salesforce for Android doesn’t rotate.\n- If your canvas app appears as a feed item, keep in mind that it will display in the feed on a mobile device so you’ll want to render a mobile-friendly user interface.\n\nCanvas Apps Context\n\nWhen you display a canvas app inside the Salesforce app, keep these considerations in mind.\n\nWhen you display a canvas app inside of the feed or publisher, the canvas context you receive (either from the signed request or from the `getContext` call) contains information specific to the Salesforce app publisher.\n\n- You can verify you’re on either the feed or publisher by looking at the `displayLocation` value in the environment section. For publisher, `displayLocation` is set to `Publisher`. For the feed, `displayLocation` is set to `ChatterFeed`.\n- When creating a canvas feed item, you can specify a JSON string as the parameter’s value. When the context is sent, any value in the parameter’s field on the feed item is sent in the parameters of the environment section of the context.\n- As with any canvas app, the context contains information about the app dimensions. Since the Salesforce app is designed for mobile, the sizes we provide are different than for the full Salesforce site.\n- For a single-finger touch scrolling experience:\n - Ensure that the outermost `div` elements contain the following properties:\n - `min-height: 250px;`\n - `overflow: scroll;`\n - `width: 100%;`\n - `-webkit-overflow-scrolling: touch;`\n - `-webkit-transform: translated(0%,0px,0px);`\nSet the `height` attribute to the `clientHeight` value delivered in the signed request. For example:\n\n```javascript\n// Where `sr` is a parsed signed request object\nvar h = parseInt(sr.context.environment.dimensions.clientHeight, 10);\nSfdc.canvas.byId('divElementId').style.height = h;\n```\n\nThe `clientHeight` value can be very small, particularly in a phone’s landscape mode, and users may not be able to see any content. Use `min-height` set to the desired height in pixels to ensure a good user experience.\n\n## Custom Icons for Canvas Apps\n\nKeep these best practices and guidelines in mind when you add custom icons to your canvas apps.\n\nYou can customize the icon that is used in the Salesforce navigation menu. You set this icon in the Icon URL entry in the Basic Information section of the connected app settings for your canvas app. From Setup, enter `Apps` in the Quick Find box, then select `Apps` and click `Edit` for your connected app. The icon URL must be a secure HTTPS URL that points to an icon image file. The image file must be in the GIF, JPG, or PNG file format. For the Salesforce navigation menu, the icon cannot be larger than 60 pixels high by 60 pixels wide.\n\nThe custom icon that is used in the Salesforce navigation menu is also used in the Chatter tab and the Canvas App Previewer. If your canvas app will be shown in the navigation menu, we recommend that you use a 60x60 pixel size icon and let Salesforce automatically resize the icon to the smaller size that is needed for the Chatter tab and the Canvas App Previewer.\n\nYou can also customize the icon that is used in the action bar for a canvas app. The action bar uses the custom icon set for the action that accesses the canvas app, not the custom icon that is associated with the connected app. See Custom Icon Guidelines and Best Practices on page 64 for more guidelines on custom action icons.\nCHAPTER 14 Learning More\n\nIn addition to this guide, there are many resources available to help you in your Salesforce Platform development journey.\n\nAdmin Resources\n\nSalesforce Help & Training Portal\nA site devoted to the help documentation for Salesforce. Get help for what you’re working on, find answers to your questions, and download tip sheets and other guides.\n\nSalesforce Trailblazer Community\nHome to a set of extremely useful tools to help you get your Salesforce work done. Connect with Salesforce customers, partners, product specialists and employees to learn, get answers to your questions, and share new ideas.\n\nSalesforce Developers Website\nOur premier developer site is a one-stop shop for all things related to Salesforce Platform development. On Salesforce Developers you’ll find documentation, code samples, tools, articles, discussion boards, and other resources to help you get started with mobile development.\n\nDeveloper Documentation\n\nYou’ll find all these guides and more on our developer site at http://developer.salesforce.com/docs.\n\nQuick Actions Implementation Guide\nLearn about the default actions, how to create object-specific actions, and how to configure publisher layouts. Find out how you can extend the Chatter publisher and the Salesforce mobile action bar with Visualforce custom actions and Canvas custom actions.\nChapter 14 Learning More\n\n**Mobile App Developer Guide**\nLearn about native iOS and Android, HTML5, and hybrid mobile development. This guide also includes information about more advanced topics such as authentication, geolocation, and distributing your mobile apps.\n\n**Lightning Platform REST API Developer’s Guide**\nLearn to use the REST-based API to retrieve, create, update, and delete data in Salesforce. You’ll learn how to get up to speed quickly with quick starts, about the available REST API resources, and how to make calls and work with data.\n\n**Visualforce Developer’s Guide**\nLearn how to use Visualforce to customize and extend the Salesforce user interface.\n\n**SOQL and SOSL Reference**\nLearn how to use SOQL and SOSL to build powerful queries and text searches.\nINDEX\n\nA\nAbout Acme Wireless 12\nAbout the sample scenario 12\nAbout this book\n audience 12\n how do I begin? 12\nActions\n about action layouts 52\n about custom actions 60\n about predefined values 57\n assigning to a global page layout 51\n assigning to a page layout 50\n create actions 46\n creating 49\n creating a global action 51\n creating an object-specific action 50\n custom actions 48\n customizing an action layout 54\n default actions 48\n global actions 46\n guidelines and best practices 64\n log a call actions 46\n mobile smart actions 48\n object-specific actions 46, 50, 55\n overview for mobile 45\n predefined values for actions 59\n setting a predefined field value 58\n standard actions 48\n tell me more 52\n testing in Salesforce app 55, 59\n update actions 46\n what they are 46\nAdd the Visualforce tab to the navigation menu 84\nAudience for Part II, developer guide 68\n\nB\nbusiness scenario, Acme Wireless 68\n\nC\nCanvas\n best practices 141, 144–145\nCompact layouts\n creating 40\n find out more 43\n overview 39\n overview for mobile 31\n test it out 42\n try it out 40\nConfiguring and enabling offline access 20\nConfiguring Salesforce app 17–18\nCreate a Visualforce page 80\nCreate a Visualforce tab 83\nCustom actions\n add the Visualforce custom action to the page layout 95\n business scenario 94\n create a Visualforce custom action 94\n introduction 93\n test the Visualforce custom action in the Salesforce app 96\n custom actions introduction 93\n\nD\ndevelopment process for the Salesforce app 71\n\nG\nGuidelines and best practices\n actions 64\n custom icons 64\n for administrators 63\nGuidelines and best practices (continued)\n for developers 105\n\nI\nIntroduction 1\n\nL\nLearning more\ndevision resources 147\n\nM\nMobile 19\n\nN\nNavigation menu\n when to use 106\nNotifications\n about 19\n enabling 19\n\nP\nPage layouts\n creating a mobile-optimized layout 35\n how they work in Salesforce app 32\n optimizing for mobile 38\n overview for mobile 31\n rethinking for mobile 33\n test it out 37\nPrerequisites for Salesforce app development 71\nPublisher\n when to use 106\n\nS\nSalesforce app\n about 4\n comparison to other mobile apps 9\n configuring 17–18\n configuring offline access 20\n defining users 18\nSalesforce app (continued)\n enabling offline access 20\n notifications, about 19\n notifications, enabling 19\n overview 9\n what it looks like 4\nSalesforce app development\n about the Visualforce page code 88\n business scenario 68\n introduction 67\n prerequisites 71\n Visualforce pages 79–80, 83–84\n who this part is for 68\nSalesforce app navigation menu\n about 24\n configuring 26\n overview 23\n tell me more 28\n test it out 27\n try it out 26\nSalesforce mobile development\n about the Visualforce custom action code 98\n best practices 105–106, 141, 144–145\n Canvas 105, 141\n Canvas apps in the feed 144\n Canvas apps in the publisher 141\n Canvas context 144\n Canvas custom icons 145\n custom actions 93–96\n custom actions scenario 94\n development process 71\n Visualforce 105\nSalesforce Platform\n features 2\n overview 2\nSalesforce Platform development\n clicks vs. code 68\n learning more 147\n Salesforce Platform vs. custom apps 69\n<table>\n<thead>\n<tr>\n<th>Setting up your work environment</th>\n<th>Visualforce custom actions (continued)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>downloading and configuring Salesforce app</td>\n<td>add the Visualforce custom action to the page layout</td>\n</tr>\n<tr>\n<td>importing warehouse data model 16</td>\n<td>create a Visualforce custom action 94</td>\n</tr>\n<tr>\n<td>setting your default page layout 72</td>\n<td>test the Visualforce custom action in the app 96</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>U</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>User interface guidelines</td>\n<td>Visualforce pages in the navigation menu</td>\n</tr>\n<tr>\n<td>design for mobile 74</td>\n<td>about the controller and page code 88</td>\n</tr>\n<tr>\n<td>introduction 73</td>\n<td>add the tab to the navigation menu 84</td>\n</tr>\n<tr>\n<td>keep navigation simple 74</td>\n<td>create a page 80</td>\n</tr>\n<tr>\n<td>minimize the number of fields 75</td>\n<td>create a tab 83</td>\n</tr>\n<tr>\n<td>minimize user interface text 76</td>\n<td>introduction 79</td>\n</tr>\n<tr>\n<td>put important information at the top 74</td>\n<td>Visualforce pages introduction 79</td>\n</tr>\n<tr>\n<td>tap target size 77</td>\n<td></td>\n</tr>\n<tr>\n<td>use field defaults 76</td>\n<td>W</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>V</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Visualforce custom actions</td>\n<td>When to use the Mobile SDK 69</td>\n</tr>\n<tr>\n<td>about the custom action code 98</td>\n<td>When to use the Salesforce Platform 68–69</td>\n</tr>\n<tr>\n<td></td>\n<td>When to use Visualforce 68</td>\n</tr>\n</tbody>\n</table>"}}},{"rowIdx":197,"cells":{"id":{"kind":"string","value":"b03aaf44553d74341d344dec41e99f95205ed833"},"text":{"kind":"string","value":"PrivaLog: a privacy-aware logic programming language\n\nJoosep Jääger\\(^1,2\\) and Alisa Pankova\\(^1\\)\n\nCybernetica, Estonia\n{joosep.jaager,alisa.pankova}@cyber.ee\n\nAbstract. Logic Programming (LP) is a subcategory of declarative programming that is considered to be relatively simple for non-programmers. LP developers focus on describing facts and rules of a logical derivation, and do not need to think about the algorithms actually implementing the derivation. Secure multiparty computation (MPC) is a cryptographic technology that allows to perform computation on private data without actually seeing the data. In this paper, we bring together the notions of MPC and LP, allowing users to write privacy-preserving applications in logic programming language.\n\n1 Introduction\n\nLogic Programming is a simple, yet powerful formalism suitable for programming and knowledge representation [2]. It is a declarative language. A typical logic program is represented as a set of facts and rules that derive new facts from the existing ones. Logic programming engine will use the rules to perform logical reasoning, using internal mechanisms that the programmer does not need to describe. Program output can be either a single boolean value denoting whether a certain predicate (called a goal) can be satisfied, or a set of variable valuations satisfying the goal.\n\nSecure multiparty computation (MPC) is a cryptographic technology that allows to perform computation on data without actually seeing the data. A standard use case of MPC is when several distinct parties (e.g. companies) want to compute a functionality that includes their data, but they do not want to disclose that data to each other. Secure MPC allows to perform the computation in such a way that the parties do not learn anything besides the final output, e.g. some aggregated statistics.\n\nMPC applications are typically written in imperative languages [4,6,11,19,21,27,28] or functional languages [18,20,24]. A privacy-preserving programming language based on Datalog has been proposed in [22]. That short paper describes a general framework for transforming a Datalog program (with certain constraints) to a privacy-preserving application. In particular, it outputs a program that can be run on Sharemind [8] framework.\n\nSharemind is one of numerous frameworks that support deployments of MPC using special API call interfaces [3]. The main protocol set [9] of Sharemind is based on secret-sharing among three parties. The client who makes a query to secret-shared database and receives the output can be a separate entity. Sharemind has numerous subprotocols available for use, e.g. oblivious shuffle [17]. In this work, we do not invent yet another MPC platform, but provide a LP programming interface for Sharemind. In [22], the source logic program is translated to SecreC language [6]. SecreC is an imperative language that has already implemented type derivations and security measures which allows to significantly simplify security proofs.\n\nContribution of this paper. In this work, we extend and deepen the framework proposed in [22]. In particular, we do the following.\n\n- Extend the supported syntax with aggregation functions, and relax some limitations on the input program.\n- Provide a formal description of the full transformation, accompanied with correctness and security proofs.\n- Implement the translator and evaluate its performance.\n\nThe translator is available for public use in a GitHub repository, and it is compatible with both the licensed Sharemind, as well as freely available Sharemind Emulator that does not require a license.\nTable 1. Basic elements of Prolog\n\n<table>\n<thead>\n<tr>\n<th>element</th>\n<th>details</th>\n<th>example</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>variable</td>\n<td>name that starts from an upper case letter</td>\n<td>X</td>\n</tr>\n<tr>\n<td>unnamed variable</td>\n<td>underscore</td>\n<td>-</td>\n</tr>\n<tr>\n<td>constant</td>\n<td>name that starts from a lower case letter or a number</td>\n<td>ship, 12</td>\n</tr>\n<tr>\n<td>logical operator</td>\n<td>AND</td>\n<td>p, q</td>\n</tr>\n<tr>\n<td></td>\n<td>OR</td>\n<td>p ; q</td>\n</tr>\n<tr>\n<td></td>\n<td>NOT</td>\n<td>+p</td>\n</tr>\n<tr>\n<td>comparison</td>\n<td>unification (it should be arithmetic) and perform ( X = Y )</td>\n<td>( X = Y )</td>\n</tr>\n<tr>\n<td></td>\n<td>arithmetic equality</td>\n<td>( X =::= Y )</td>\n</tr>\n<tr>\n<td></td>\n<td>arithmetic inequality</td>\n<td>( X = /= Y )</td>\n</tr>\n<tr>\n<td>fact</td>\n<td>a predicate declaration</td>\n<td>( p(x_1,\\ldots,x_n) ).</td>\n</tr>\n<tr>\n<td>rule</td>\n<td>( p ) is true if ( q ) is true</td>\n<td>( p ;\\neg q ).</td>\n</tr>\n</tbody>\n</table>\n\n2 Preliminaries\n\n2.1 Notation\n\nThroughout this paper, variable names will start from an upper case letter (e.g. Ship), and constants will start from lower case letters (e.g. ship). We will use underscore _ to denote a hole, i.e. an unnamed variable that pattern matches to everything. Since syntax of logic programs may be different for different languages, throughout this paper, we will use SWI-Prolog syntax. The corresponding notation is briefly described in Table 1. The notation for arithmetic operations and inequalities is standard and is not given in the table.\n\n2.2 Running example\n\nA logic program is a list of facts, and rules describing how new facts can be derived from the existing ones. The facts can be viewed as logical predicates, or as database relations. Let us start from a small example, which will be used as a running example throughout this paper. Datalog distinguishes between extensional predicate symbols (defined by facts) and intensional predicate symbols (defined by rules). The corresponding database relations are denoted EDB and IDB respectively. Our example program has two EDB relations:\n\n- ship(name, latitude, longitude, speed, cargo_type, cargo_amount) tells that there is a ship with a certain name, located at geographic point (latitude,longitude), which can move with certain speed and carries a certain cargo_amount of certain cargo_type.\n- port(name, latitude, longitude, offload_capacity) tells that there is a port with a certain name located at (latitude,longitude), which can accommodate as much cargo as fits into its offload_capacity.\n\nThe logic program starts with facts corresponding to these two relations. Each fact ends with a period.\n\n```prolog\nship('alfa', 270, 290, 40, 'carrot', 10).\nship('beta', 180, 280, 30, 'garlic', 5).\n...\nport('alma', 0, 0, 10).\nport('cow', 10, 10, 10).\n...\n```\n\nWe now need to list the rules. The rules describe how IDB relations are derived from EDB relations, as well as the other EDB relation. The IDB relation reachability_time(Ship,Port,Time) is true if the Ship can reach the Port in certain Time.\nreachability_time(Ship, Port, Time) :-\n ship(Ship, X1, Y1, Speed, _),\n port(Port, X2, Y2, _),\n Time is sqrt((X1 - X2)^2 + (Y1 - Y2)^2) / Speed.\n\nThe IDB relation suitable_port(Ship, Port) is true if the Port can accommodate cargo of the Ship.\n\nsuitable_port(Ship, Port) :-\n port(Port, _, _, Capacity),\n ship(Ship, _, _, _, CargoAmount),\n Capacity >= CargoAmount.\n\nThe IDB relation arrival(Ship, Port, CargoType, Time) depends on the previous two relations, and it is true if the Ship carrying CargoType can reach the Port within certain Time.\n\narrival(Ship, Port, CargoType, Time) :-\n ship(Ship, _, _, CargoType, _),\n feasible_port(Ship, Port),\n reachability_time(Ship, Port, Time).\n\nFinally, there is a goal querying the relation arrival with certain portname and cargotype.\n\n?-arrival(Ship, portname, cargotype, Time).\n\nThe program will output all pairs (Ship, Time) where a Ship carries cargotype and can reach the port within some Time. Alternatively, we can output just a single value, e.g. the minimum time that it takes for cargo of given cargotype to reach given port.\n\n?-min(arrival(Ship, portname, cargotype, Time), Time, MinTime).\n\nIn the latter case, the program will output the value of MinTime.\n\n2.3 Relational algebra\n\nIn this paper, we will formalize logic programs treating logic predicates as relations. We follow the description of relational algebra from [10], where it is defined in logic programming context. In the relational model, data are organized using relations, which are defined as follows.\n\nDefinition 1 (relation). Let \\( D_1, \\ldots, D_n \\) be sets, called domains (not necessarily distinct). Let \\( D = D_1 \\times \\cdots \\times D_n \\) be the Cartesian product. A relation defined on \\( D \\) is any subset of \\( D \\).\n\nWe suppose domains to be finite sets of data. Unless stated otherwise, we will therefore assume finite relations.\n\nDefinition 2 (tuple of a relation over domain). A tuple of a relation \\( \\mathcal{R} \\) over \\( D = D_1 \\times \\cdots \\times D_n \\) is a tuple \\( (d_1, \\ldots, d_n) \\), with \\( d_1 \\in D_1, \\ldots, d_n \\in D_n \\).\n\nThe number of tuples in \\( \\mathcal{R} \\) is called the cardinality of \\( \\mathcal{R} \\). The empty set is a particular relation, the null (or empty) relation. Note that a relation is a set, therefore tuples in a relation are distinct, and the order of tuples is irrelevant. However, the order of elements in each tuple is relevant, and each position has a special name called an attribute of relation. Let \\( \\mathsf{VName} \\) be the set of variable names.\n\nDefinition 3 (schema). A schema of a relation \\( \\mathcal{R} \\) is an ordered set of all its attributes \\( \\{a_1, \\ldots, a_n\\} \\subseteq \\mathsf{VName}^n \\).\nWe may refer to attributes of relations either by their name (denoted \\( R[x] \\), where \\( x \\in \\text{VName} \\)) or by the position (denoted \\( R[i] \\), where \\( i \\in \\mathbb{N} \\)). Let \\( \\mathcal{U}_r \\) denote the a universal relation (i.e. a relation that contains all possible tuples) with schema \\( \\Gamma \\). Let \\( \\text{Rel}_r \\) be the set of all possible relations over schema \\( \\Gamma \\), i.e. the set of all subsets of \\( \\mathcal{U}_r \\). Let \\( \\emptyset_r \\) denote an empty relation over schema \\( \\Gamma \\).\n\nRelational Algebra is defined through several operators that apply to relations, and produce other relations. A relational algebra operator can be a selection (filter), projection, a cartesian product, union, intersection, difference, and renaming of columns. The semantics of these operators w.r.t. relation sets is given in Figure 2. A filter is using a boolean expression \\( q : R \\rightarrow \\{ \\text{true}, \\text{false} \\} \\), which formally maps each row \\( r \\in R \\) of a relation \\( R \\) to a boolean value. Its semantics are given in Figure 1, where function \\( \\phi \\) defines semantics of predicates not covered by propositional logic, e.g. inequalities.\n\n\\[\n\\begin{align*}\n[false](r) &= false \\\\\n[true](r) &= true \\\\\n[f(s_1, \\ldots, s_k)](r) &= \\phi(f)([s_1, r, \\ldots, s_k]) \\\\\n[q_1 \\land q_2](r) &= [q_1](r) \\land [q_2](r) \\\\\n[q_1 \\lor q_2](r) &= [q_1](r) \\lor [q_2](r) \\\\\n[-q](r) &= \\neg[q](r)\n\\end{align*}\n\\]\n\n\\text{Fig. 1.} Semantics of boolean expressions\n\n\\[\n\\begin{align*}\n\\pi_{\\Gamma'} R &= \\bigcup_{\\forall \\Gamma' : \\mathcal{U}_r} R' \\\\\n&\\text{undefined, if } \\Gamma \\not\\subseteq \\text{schema}(R) \\\\\n\\sigma_q R &= \\{ r \\in R \\mid [q] r = \\text{true} \\} \\\\\n&\\text{undefined, if } \\text{vars}(q) \\not\\subseteq \\text{schema}(R) \\\\\nR_1 \\times R_2 &= \\{ r_1 \\parallel r_2 \\mid r_1 \\in R_1, r_2 \\in R_2 \\} \\\\\n&\\text{undefined, if } \\text{schema}(R_1) \\cap \\text{schema}(R_2) \\neq \\emptyset \\\\\nR_1 \\cap R_2 &= \\{ r_1 \\cap r_2 \\mid \\text{schema}(R_1) = \\text{schema}(R_2) \\} \\\\\n&\\text{undefined, if } \\text{schema}(R_1) \\neq \\text{schema}(R_2) \\\\\nR_1 \\cup R_2 &= \\{ r_1 \\cup r_2 \\mid \\text{schema}(R_1) = \\text{schema}(R_2) \\} \\\\\n&\\text{undefined, if } \\text{schema}(R_1) \\neq \\text{schema}(R_2) \\\\\nR_1 \\setminus R_2 &= \\{ r_1 \\setminus r_2 \\mid \\text{schema}(R_1) = \\text{schema}(R_2) \\} \\\\\n&\\text{undefined, if } \\text{schema}(R_1) \\neq \\text{schema}(R_2) \\\\\n\\rho_{\\Gamma' / \\Gamma}(R) &= R \\\\\n&\\text{undefined, if } \\text{schema}(R) \\neq \\Gamma\n\\end{align*}\n\\]\n\n\\text{Fig. 2.} Semantics of relational operators w.r.t. relation sets\n\nWhen applying operators, we treat relations as set, and it may be unclear how the resulting schema looks like. We define schemas of relational expressions in 3.\n\nIn this work, we will use the following properties of relational algebra (without proofs):\n\n**Proposition 1 (properties of relational algebra).** Let \\( R \\) be a relation. The following holds:\n\n- \\( \\sigma_{\\neg q}(R) = R \\setminus \\sigma_q(R) \\);\n- \\( \\sigma_{q_1 \\land q_2}(R) = \\sigma_{q_1}(R) \\cap \\sigma_{q_2}(R) \\);\n- \\( \\sigma_{q_1 \\lor q_2}(R) = \\sigma_{q_1}(R) \\cup \\sigma_{q_2}(R) \\);\n- \\( \\sigma_q(R) = \\sigma_q(\\mathcal{U}_r) \\cap R \\) for schema(\\( R \\)) \\( \\subseteq \\Gamma \\).\n\\( \\text{schema}(\\pi_I(R)) = \\Gamma \\)\n\n\\( \\text{schema}(\\sigma_I(R)) = \\text{schema}(R) \\)\n\n\\( \\text{schema}(R_1 \\times R_2) = \\text{schema}(R_1) || \\text{schema}(R_2) \\)\n\n\\( \\text{schema}(R_1 \\cup R_2) = \\text{schema}(R_1) \\)\n\n\\( \\text{schema}(R_1 \\cap R_2) = \\text{schema}(R_1) \\)\n\n\\( \\text{schema}(R_1 \\setminus R_2) = \\text{schema}(R_1) \\)\n\n\\( \\text{schema}(\\rho_{\\Gamma/\\Gamma}(R)) = \\Gamma' \\)\n\n\\( \\text{undefined, if } \\Gamma \\not\\subseteq \\text{schema}(R) \\)\n\n\\( \\text{undefined, if } \\text{vars}(q) \\not\\subseteq \\text{schema}(R) \\)\n\n\\( \\text{undefined, if } \\text{schema}(R_1) \\cap \\text{schema}(R_2) \\neq \\emptyset \\)\n\n\\( \\text{undefined, if } \\text{schema}(R_1) \\neq \\text{schema}(R_2) \\)\n\n\\( \\text{undefined, if } \\text{schema}(R_1) \\neq \\text{schema}(R_2) \\)\n\n\\( \\text{undefined, if } \\text{schema}(R_1) \\neq \\Gamma' \\)\n\n---\n\n2.4 Deployment model and the SecreC Language\n\nIn this paper, we consider the following deployment model of Sharemind system. First of all, there are input parties who provide the data. This data is stored in Sharemind platform in an encrypted (secret-shared) manner and is not visible to anyone. There are three designated computing parties (usually different from the input parties) who will perform the computation on this data, without actually seeing the data. Finally, there is a client (who can be one of the input parties, as well as a separate entity) who will receive the final output. More information about deployment models of Sharemind can be found in [13, Table 2.2].\n\nThe computation that the computing parties are going to perform is described in SecreC language. SecreC is a C-like programming language designed for writing privacy-preserving applications for the Sharemind platform [5,14,23]. SecreC distinguishes between public data (visible to all computing parties) and private data (not visible to any computing party) on type system level. It guarantees that values of private variables will never be written to the memory of public variables. The only way to convert private data to public (which may be needed for some applications) is to use an explicit declassify command, which works as decryption. If the SecreC program does not involve any declassifications, we can be sure that the private data will be kept private throughout the computation. The only thing that we need to care about is that the initial input data have been assigned correct privacy types.\n\nSimilarly to [22], we translate LP programs to SecreC language. SecreC compiler can then be used to perform the typecheck (and thus ensure that private data is not leaked during the computation), and transform a SecreC program to a sequence of Sharemind API calls.\n\nWhen writing a program in SecreC, one should take into account that SecreC does not allow control flow to depend on private data. Let us bring a simple example, taken from [22]. Suppose that there is a condition \\( S < 2500 \\) where \\( S \\) has private type, SecreC does not allow to check directly whether the inequality is true, as it would leak some information about the secret \\( S \\). Instead, SecreC allows to compute a private bit \\( b \\in \\{0,1\\} \\), denoting whether the inequality is true. The programmer needs to restructure the subsequent computation, which in general requires simulation of computation in both branches (the cases \\( S < 2500 \\) and \\( S \\geq 2500 \\)), and using the bit \\( b \\) to choose the final output for each variable affected by computation in these branches. For example, if a variable \\( y \\) gets a value \\( y_0 \\) in the case \\( b = 0 \\), and a value \\( y_1 \\) in the case \\( b = 1 \\), we need to compute both \\( y_0 \\) and \\( y_1 \\), and eventually take \\( y = (1 - b) \\cdot y_0 + b \\cdot y_1 \\). Since \\( b \\) has private type, the variable \\( y \\) is also assigned private type, so the computing parties will not know whether \\( y = y_0 \\) or \\( y = y_1 \\). In context of LP, this means that we cannot immediately backtrack when reaching a false statement that depends on private data. Instead, for each potential solution, we get a private satisfiability bit \\( b \\), and in the end the client will receive only those solutions for which \\( b = 1 \\).\n\nSince even computation of simple operations like multiplication or comparison on private data requires network communication between computing parties, SecreC programs are much more efficient if the data are processed in larger batches using SIMD (Single Instruction Multiple Data) operations. For example, in [5,15], an iterative SecreC program that constructs frequently occurring itemsets of certain size, and the same privacy-preserving operations are applied at once in all search branches for the entire depth level of all constructed itemsets of size \\( k \\). Hence, the programmer should use as many vectorized computations as possible.\npossible. For that reason, in this work, we will process different possible non-deterministic computational branches simultaneously in parallel.\n\n**Existing SecreC functions.** In this work, we will not invent new secure MPC protocols, but instead build our solution on top of numerous existing Sharemind protocols already available. In particular, SecreC already has the functionalities:\n\n- **Arithmetic Blackbox Functions:** SecreC has numerous built-in functions for privacy-preserving arithmetic and boolean operations.\n- **Existing Protocols:** SecreC has some protocols for frequently used tasks (like shuffle and sorting) already implemented.\n- **Database operations:** SecreC allows to store data in a private database and access it during the computation.\n\nWe list some existing SecreC functions that are relevant for this paper in Table 2. We use notation $\\langle \\langle x \\rangle \\rangle$ to denote a private (secret-shared) value $x$.\n\n**Syntax of SecreC.** The syntax of SecreC core language, taken from [23], is given in Figure 4. Compared to original core syntax, we remove conditional statements and while-loops, since we will not be using these constructions in our SecreC programs. We also leave out declarations of protection domain, which is not relevant for this work. The protection domain defines used secret-sharing scheme (assumed attacker strength, number of parties etc), and we are always assuming that this scheme has been fixed in advance and remains implicit. We also assume that return statement is always the last line of function body. These simplifications turn SecreC into quite simple imperative language.\n\n<table>\n<thead>\n<tr>\n<th>Operation Call</th>\n<th>Effect</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>getTable(t)</code></td>\n<td>return columns of a table $t$ from private database</td>\n</tr>\n<tr>\n<td><code>join(⟨⟨X_1⟩⟩, ..., ⟨⟨X_n⟩⟩)</code></td>\n<td>return a cross product $\\langle ⟨X_1 \\times \\cdots \\times X_n⟩ \\rangle$</td>\n</tr>\n<tr>\n<td><code>declassify(⟨⟨x⟩⟩)</code></td>\n<td>return $x$</td>\n</tr>\n<tr>\n<td><code>argument(⟨⟨x⟩⟩)</code></td>\n<td>receive input $x$ from the client</td>\n</tr>\n<tr>\n<td><code>publish(⟨⟨x⟩⟩)</code></td>\n<td>send output $x$ to the client</td>\n</tr>\n<tr>\n<td><code>unique(⟨⟨x⟩⟩)</code></td>\n<td>return a boolean vector $\\langle ⟨b⟩ \\rangle$, where $b_i$ denotes whether $x_i$ is a duplicate</td>\n</tr>\n<tr>\n<td><code>shuffle(⟨⟨x⟩⟩)</code></td>\n<td>return $\\langle ⟨x_1 \\times \\cdots \\times x_n⟩ \\rangle$</td>\n</tr>\n<tr>\n<td><code>concat(⟨⟨x_1⟩⟩, ..., ⟨⟨x_n⟩⟩)</code></td>\n<td>return $\\langle ⟨x_1⟩ \\parallel \\cdots \\parallel ⟨⟨x_n⟩⟩ \\rangle$</td>\n</tr>\n<tr>\n<td><code>filter(⟨⟨x⟩⟩, b)</code></td>\n<td>return $\\langle ⟨{x_i \\in x \\mid b_i = true}⟩ \\rangle$</td>\n</tr>\n</tbody>\n</table>\n\nTable 2. Basic blackbox operations used in this work\n\n---\n\n\\[\nP ::= F^* \\quad s\n\\]\n\n\\[\nF ::= f(x_1 : d_1 \\ t_1, \\ldots, x_n : d_n \\ t_n) : d \\ t \\ (s; \\text{return} \\ e)\n\\]\n\n\\[\nt ::= \\text{unit} \\mid \\text{int} \\mid \\text{bool} \\mid \\text{int[]} \\mid \\text{bool[]}\n\\]\n\n\\[\ns ::= \\text{skip}\n\\]\n\n\\[\ne ::= x\n\\]\n\n\\[\nx = e\n\\]\n\n\\[\n\\{x : d \\ t ; s\\}\n\\]\n\n\\[\ne_1 \\oplus e_2 \\quad \\text{for } \\oplus \\in \\{+, -, \\cdot, /, \\&\\}\n\\]\n\n\\[\ne_1 \\odot e_2 \\quad \\text{for } \\odot \\in \\{<, \\leq, =, !=, >, \\geq\\}\n\\]\n\n\\[\nf(e_1, e_2, \\ldots, e_n)\n\\]\n\nFig. 4. Abstract syntax of the SecreC core language\n\n6\nSemantics of SecreC. We give simplified semantics of a SecreC program in Figure 5. In this work, we will not need type derivation proofs, so we only describe how program changes a state in terms of denotational semantics. Our SecreC programs will work on vectors, so a state is a map\n\n\\[ s : \\text{VName} \\rightarrow \\text{Vec}[m], \\]\n\nwhere \\text{Vec}[m] is a set of vectors of fixed length \\( m \\). While data is uploaded to Sharemind system in secret-shared manner in advance, it is fine to treat the database as part of the input state, as we treat data as immutable.\n\nProgram-defined functions will only be called from the main function, so semantics of such functions do not depend on each other. The program will receive a special function \\( T : \\text{VName} \\rightarrow \\text{Rel} \\) that extracts relations of private database by table name. To give semantics to ABB (Arithmetic Black Box) operators, we will need an interpretation function \\( \\psi \\) that assigns values to constant symbols, as well as the operators. We assume that the function \\( \\psi \\) is defined globally. In addition, we will need a function \\( \\xi : \\text{VName} \\rightarrow (\\text{Vec}[m] \\rightarrow \\text{Vec}[m]) \\) to store functions defined internally in a SecreC program.\n\n\\[\n\\begin{align*}\n[x] \\xi s &= s[x] \\\\\n[c] \\xi s &= \\psi(c) \\\\\n[e] \\xi s &= \\neg[e] s \\\\\n[e_1 \\oplus e_2] \\xi s &= [e_1] \\xi s \\oplus [e_2] \\xi s \\quad \\text{for } \\oplus \\in \\{+, -, \\ast, /, \\cdot, \\} \\\\\n[e_1 \\odot e_2] \\xi s &= [e_1] \\xi s \\odot [e_2] \\xi s \\quad \\text{for } \\odot \\in \\{\\lt, \\leq, =, \\neq, \\geq, \\gt\\} \\\\\n[f(e_1, \\ldots, e_n)] \\xi s &= [f] \\xi ([e_1] \\xi s, \\ldots, [e_n] \\xi s) \\\\\n\\text{getTable} \\xi t &= (\\xi db).t \\\\\n\\text{join} \\xi (t_1, \\ldots, t_n) &= t_1 \\times \\cdots \\times t_n \\\\\n\\text{declassify} \\xi x &= x \\\\\n\\text{argument} \\xi x &= x \\\\\n\\text{publish} \\xi x &= x \\\\\n\\text{unique} \\xi x &= \\text{deduplication of } x \\\\\n\\text{shuffle} \\xi x &= \\text{random shuffle of } x \\\\\n\\text{concat} \\xi (x_1, \\ldots, x_n) &= x_1 \\parallel \\cdots \\parallel x_n \\\\\n\\text{filter} \\xi (x, b) &= [x_i \\mid b_i = \\text{true}] \\\\\n\\text{skip} \\xi s &= s \\\\\n[s_1 : s_2] \\xi s &= ([s_1] \\xi \\circ [s_2] \\xi) s \\\\\n[x = e] \\xi s &= s[x \\mapsto [c] \\xi s] \\\\\n[x : d t ; s'] \\xi s &= [s'] \\xi s \\\\\n[f(x_1 : d_1 t_1, \\ldots, x_n : d_n t_n) \\; (s ; \\text{return } y_1 : d'_1 t'_1, \\ldots, y_m : d'_m t'_m)] \\xi [v_1, \\ldots, v_n] &= ([s] \\xi \\{x_i \\mapsto v_i\\}) \\{y_1, \\ldots, y_m\\} \\\\\n[f_1 \\ldots f_m] x \\; \\mathcal{T} &= \\text{let } \\xi = \\{db \\mapsto \\mathcal{T}\\} \\text{ in} \\\\\n&= [s] x (\\xi \\cup \\{\\text{name}(f_i) \\mapsto [f_i] \\xi\\})\n\\end{align*}\n\\]\n\nFig. 5. Denotational semantics of the SecreC core language\n3 The PrivaLog language\n\nIn this work, we are dealing with logic programs like the one described in Sec. 2.2. For privacy-preserving computation, we need to enhance the data with privacy labels (public and private). The requirement is that no information is leaked about private data. Putting aside privacy labels (which are a new component), our input language is a subset of Datalog. Due to new constructions and differences in syntax, we treat it as a different language, which we call PrivaLog.\n\nIn common Datalog, it would be natural to list the database relations as facts inside the logic program itself. However, if the data are private we cannot just include it into the program. Instead, we can only list the structure of database predicates and the types of their arguments. The data will be uploaded to MPC platform by input parties separately, using special secure data upload mechanisms. Facts that contain only public data can still be defined inside Datalog script. Without loss of generality, we can view them as rules of the form fact :- true.\n\n3.1 Syntax\n\nThe syntax of PrivaLog is given in Figure 6, and it closely follows the syntax defined in [22]. The schema of extensional database is defined in the beginning of a program. The attributes of EDB relations are typed. First of all, we need to specify whether an attribute is public or private. The data type is important as well, since it determines how exactly private data will be handled technically inside Sharemind. W.l.o.g, we assume that the goal consists of a single atomic predicate, as we can fold a more complex goal into a separate rule if needed.\n\n\nLimitations Similarly to Datalog, there are certain additional constraints set on an input program.\n\n1. The program is stratified, i.e. IDB relations can be ordered in such a way that the body of the rules corresponding to the i-th relation may only contain j-th relations for j ≤ i. This is a quite standard constraint on Datalog programs [25].\n2. Negations are not allowed in front of formulae containing IDB predicates. This is a more strict constraint that the standard Datalog assumption which requires that the body of the rules corresponding to the i-th relation may only contain negations of j-th relations for j < i. In particular, we only allow j = 0, i.e. a negated relation can only be an EDB relation.\n\n3.2 Semantics\n\nIntuitively, semantics of a logic program defines the set of sentences that are true/false w.r.t. the program. Since we will be transforming a declarative logic program to an imperative program, we need to be able to compare them semantically. As the basis, we take Datalog relational semantics, described e.g. in [1]. This seems well suitable for comparing a Datalog and a SecreC program, since in our case a SecreC program will also output a certain relation.\n\nIn Prolog/Datalog, a fact is considered false if it does not follow from the given set of fact and rules. This approach is called negation by failure. In the world of databases, a relation is considered false if it does not belong to the set of true relations.\n\nDefinition 4 (negation [1]). For any schema \\( \\Gamma \\), there exists a universal relation \\( U_\\Gamma \\). Negation of a relation \\( R \\) can then be defined as \\( \\neg R := U_\\Gamma \\setminus R \\).\n\nLet \\( \\text{Rel}_\\Gamma \\) be the set of all subsets of \\( U_\\Gamma \\). A Datalog formula can be treated as a query operating on \\( \\text{Rel}_\\Gamma \\).\n\nDefinition 5 (formula semantics [1]). A formula \\( q \\) whose free term variables are contained in \\( \\Gamma \\) denotes a function from \\( \\text{Rel}_\\Gamma^n \\) to \\( \\text{Rel}_\\Gamma \\).\n\n\\[\n[e]_\\Gamma : \\text{formula} \\rightarrow \\text{Rel}_\\Gamma^n \\rightarrow \\text{Rel}_\\Gamma\n\\]\n\nIf \\( \\mathcal{R} = (\\mathcal{R}_1, \\ldots, \\mathcal{R}_n) \\) is a choice of a relation \\( \\mathcal{R}_i \\) for each of the literals \\( A_i \\), \\( [q]_\\Gamma (\\mathcal{R}) \\) is inductively defined according to the rules in Figure 7.\n\n\\[\n\\begin{align*}\n[\\top]_\\Gamma (\\mathcal{R}) & := U_\\Gamma \\\\\n[\\bot]_\\Gamma (\\mathcal{R}) & := \\emptyset_\\Gamma \\\\\n[A_j]_\\Gamma (\\mathcal{R}) & := \\mathcal{R}_j \\\\\n[q_1 \\land q_2]_\\Gamma (\\mathcal{R}) & := [q_1]_\\Gamma (\\mathcal{R}) \\cap [q_2]_\\Gamma (\\mathcal{R}) \\\\\n[q_1 \\lor q_2]_\\Gamma (\\mathcal{R}) & := [q_1]_\\Gamma (\\mathcal{R}) \\cup [q_2]_\\Gamma (\\mathcal{R}) \\\\\n[\\neg q]_\\Gamma (\\mathcal{R}) & := U_\\Gamma \\setminus [q]_\\Gamma (\\mathcal{R}) \\\\\n[\\exists x.q]_\\Gamma (\\mathcal{R}) & := \\pi_{\\{x\\}} ([q]_\\Gamma (\\mathcal{R}))\n\\end{align*}\n\\]\n\nFig. 7. Semantics of a formula\n\nDefinition 5 is very abstract, and it does not say how \\( \\mathcal{R} = (\\mathcal{R}_1, \\ldots, \\mathcal{R}_n) \\) are related to IDB, EDB, or internal system predicates like (in)equalities. It assumes in advance that relations \\( \\mathcal{R}_j \\) cover all variables of \\( \\Gamma \\).\n\nA Datalog rule can be viewed as a formula that generates new relations from already existing relations. A common way (albeit not the only one) to execute a Datalog program is to start from the initial set of facts, and applying the rules to the facts generated so far to obtain more facts until the goal is achieved (bottom-up approach). So-called immediate consequence operator computes one such step.\nDefinition 6 (immediate consequence operator \\([\\mathcal{I}]\\)). Given a program \\(\\mathbb{P} = (P_1, \\ldots, P_n)\\), where \\(P_i\\) is a predicate with schema \\(\\Gamma_i \\), the immediate consequence operator \\(\\mathcal{I} : \\text{Rel}^n \\rightarrow \\text{Rel}^n\\) is defined as\n\\[\n\\mathcal{I}(\\mathcal{R}_1, \\ldots, \\mathcal{R}_n) = ([P_1]_{r_i} (\\mathcal{R}_1, \\ldots, \\mathcal{R}_n), \\ldots, [P_n]_{r_i} (\\mathcal{R}_1, \\ldots, \\mathcal{R}_n)) .\n\\]\nApplying the operator repeatedly until no more new facts are generated, we get the program semantics.\n\nDefinition 7 (program semantics). The semantics of a program \\(\\mathbb{P}\\) is defined to be\n\\[\n[\\mathbb{P}] := \\text{lfp}_{\\text{Rel}^n}(\\mathcal{I})\n\\]\nand may be calculated by iterative application of \\(\\mathcal{I}\\) to \\(\\perp\\) until fixpoint is reached.\n\nDefinition 7 covers all relations that would be true w.r.t. a program \\(\\mathbb{P}\\). However, if we have fixed a particular goal, then it is sufficient to consider only the solutions that we observe for this goal.\n\nDefinition 8 (program semantics w.r.t. goal). Let \\(\\Gamma\\) be the schema of the goal \\(g\\). The semantics of a program \\(\\mathbb{P}\\) w.r.t. \\(g\\) is defined to be\n\\[\n[\\mathbb{P}] := \\pi_{\\Gamma}(\\text{lfp}_{\\text{Rel}^n}(\\mathcal{I})) .\n\\]\nExistence of the fixpoint is typically ensured by constraining the program such that \\(\\mathcal{I}\\) is monotone. In a privacy-preserving application, the step on which the fixpoint is reached may depend on private data, so ideally it should not be leaked whether a fixpoint has been reached. For that reason, we compute \\([\\mathbb{P}](m) := \\mathcal{I}^m(\\perp)\\) for some fixed \\(m \\geq 0\\). If we underestimate \\(m\\), we can only guarantee \\([\\mathbb{P}](m) \\subseteq [\\mathbb{P}]\\), so it is possible that we do not find all the answers to our goal query. Since Datalog (and PrivaLog) does not support complex terms, an upper bound on the fixpoint can actually be derived from the sizes of table in the database. The latter functionality remains out of scope of this paper.\n\nIn Figure 8 we show how the definitions above are instantiated to a PrivaLog program defined according to the syntax of Figure 6. Let us list the key points of our definition:\n\n- The relations \\(R_j\\) are only of the form \\(p(x_1, \\ldots, x_n)\\) for IDB/EDB predicates \\(p\\). To avoid conflicts with variable naming, we use notation \\(R_j[i]\\) for the name of the \\(i\\)-th argument of relation \\(R_j\\).\n- Semantics of (in)equality predicates are defined as filters over relations, which in turn depend on semantics of arithmetic expressions. For this, we will need an interpretation function \\(\\phi\\) that assigns values to constant symbols, as well as arithmetic operations. The function \\(\\phi\\) is defined globally once, and it is assumed to be fixed when we compare different PrivaLog programs.\n- We assume that a PrivaLog program is executed on particular inputs \\(v_1, \\ldots, v_k\\) that valuate certain arguments of the goal.\n- Since the syntax of Figure 6 only defines the schemas of the tables, and does not describe the actual data, we need a special input \\(T : \\text{VName} \\rightarrow \\text{Rel}\\), such that \\(T(\\text{tableName})\\) returns all tuples of the relation \\(\\text{tableName}\\).\n\nHandling exceptions. So far, we have defined semantics only for well-defined programs. Execution of real programs may result in an error if we try to valuate a non-ground expression (e.g. \\(X < 5\\) or \\(Y \\text{ is } X\\) for a free variable \\(X\\)), try to combine non-matching types (\\(X = 2 + a\\)), or if some arithmetic function is undefined for given input (\\(X = Y / 0\\)). While the first two kinds of error depend on program structure and can be detected in the preprocessing phase, it is more difficult with arithmetic errors which depend on private data. We cannot output immediate errors in such case since it would require observing private values. Instead, we just let the resulting SecreC program produce a garbage result, without announcing that it is actually garbage. In general, we require correctness of translation only w.r.t. valid PrivaLog programs executed on valid inputs.\n\\[ [\\text{true}]_f (\\mathcal{R}) := \\mathcal{U}_f \\]\n\\[ [\\text{false}]_f (\\mathcal{R}) := \\emptyset_f \\]\n\\[ [\\land q]_f (\\mathcal{R}) := [q_1]_f (\\mathcal{R}) \\cap [q_2]_f (\\mathcal{R}) \\]\n\\[ [\\lor q]_f (\\mathcal{R}) := [q_1]_f (\\mathcal{R}) \\cup [q_2]_f (\\mathcal{R}) \\]\n\\[ [\\forall \\varphi]_f (\\mathcal{R}) := \\mathcal{U}_f \\setminus [q]_f (\\mathcal{R}) \\]\n\n\\[ [p_j(x_1, \\ldots, x_n)]_f (\\mathcal{R}) := \\rho_{_{x_1/\\mathcal{R}_j[1], \\ldots, x_n/\\mathcal{R}_j[n]} \\mathcal{R}_j} \\times \\mathcal{U}_f \\setminus \\{x_1, \\ldots, x_n\\} \\]\n\\[ [\\exists x.q]_f (\\mathcal{R}) := \\pi_f ([q]_{f \\cup \\{x\\}} (\\mathcal{R})) \\]\n\n\\[ [t_1 \\circ t_2]_f (\\mathcal{R}) := \\sigma_{[t_1]_f \\circ [t_2]_f} \\mathcal{U}_f \\; \\text{for} \\; \\circ \\in \\{\\leq, =, \\neq, \\subseteq, \\supseteq\\} \\]\n\\[ [t_1 =: t_2]_f (\\mathcal{R}) := \\sigma_{[t_1]_f = [t_2]_f} \\mathcal{U}_f \\; \\text{for} \\; \\circ \\in \\{=:, \\neq\\} \\]\n\\[ [c] r := \\phi(c) \\; \\text{for} \\; \\text{a constant} \\; c \\]\n\\[ [x] r := r[x] \\; \\text{for} \\; \\text{a variable} \\; x \\]\n\\[ [\\land t] r := \\neg[t] r \\]\n\\[ [t_1 \\land t_2] r := [t_1] r \\land [t_2] r \\]\n\\[ [t_1 \\lor t_2] r := [t_1] r \\lor [t_2] r \\]\n\\[ [t_1 \\oplus t_2] r := \\phi(t_1 \\oplus t_2) r \\; \\text{for} \\; \\oplus \\in \\{\\ast, \\div, \\cdot\\} \\]\n\\[ [t_1 \\circ t_2] r := \\phi(t_1 \\circ t_2) r \\; \\text{for} \\; \\circ \\in \\{\\ast, \\div, \\cdot\\} \\]\n\n\\begin{align*}\n\\text{vars}(q) & := \\text{all variables occurring in} \\; q \\\\\n\\text{schema}(p(x_1, \\ldots, x_k)) := q. & := \\{x_1, \\ldots, x_k\\} \\\\\n\\text{formula}(p(x_1, \\ldots, x_k)) := q. & := \\exists y_1, \\ldots, y_{\\ell} \\; q \\; \\text{where} \\; \\forall i \\in [\\ell] : y_i \\in \\text{vars}(q), y_i \\notin \\{x_1, \\ldots, x_k\\} \\\\\n\\text{decl(-type} (p(x_1, \\ldots, x_k)) := T & := p(x_1, \\ldots, x_k) := q_1; \\ldots; q_{\\ell}, \\text{ where} \\; ((t_{11}, \\ldots, t_{1k}), \\ldots, (t_{\\ell1}, \\ldots, t_{\\ell k})) = T(p), \\; q_i = (x_1 = t_{i1}, \\ldots, (x_k = t_{ik}) \\; \\text{for} \\; i \\in [\\ell]) \\\\\n\\end{align*}\n\n\\[ [D_1 \\ldots D_m \\; C_1 \\ldots C_n \\; G] \\; v_1, \\ldots, v_k] \\; T := \\sigma_{t_0} (\\text{if}_{\\text{Prelm}+m+n+1}(\\mathcal{I})) \\]\n\\[ \\text{where} \\]\n\\[ G' := G \\{x_i \\mapsto v_i\\} \\]\n\\[ (I_{n+1}, P_{n+1}) := (\\text{schema}(C_i), \\text{formula}(C_i)) \\; \\text{for} \\; i \\in [n] \\]\n\\[ (I_0, P_0) := (\\text{schema}(G'), \\text{formula}(G')) \\]\n\\[ [(\\Gamma_{n+1}, P_{n+1}), \\ldots, (\\Gamma_{n+m}, P_{n+m})] := \\{(\\text{schema}(C), \\text{formula}(C)) \\mid i \\in [m], C = \\text{decl}(D_i) \\; T\\} \\]\n\\[ \\mathcal{I}(\\mathcal{R}) = ([P_0]_{I_0}(\\mathcal{R}), \\ldots, [P_{n+m}]_{I_{n+m}}(\\mathcal{R})) \\] .\n\nFig. 8. Relational semantics of a PrivaLog program\n\n11\n\n\n4 Preprocessing of a PrivaLog program\n\nThe goal of preprocessing is to rewrite the program in such a way that it would be easily convertible to a SecreC program. There are the certain properties that the program should satisfy after preprocessing. These properties are summarized in Definition 9 which is given for a formula.\n\nDefinition 9. A PrivaLog formula defined according to the syntax of Fig. 6 is called inlined if it satisfies the following properties.\n\n1. In every disjunction $X ; Y$ occurring in the rule, both $X$ and $Y$ are ground terms, i.e. do not contain free variables.\n2. In every comparison $X = Y$ occurring in the rule, the term $X$ is a free variable.\n3. The rule does not contain any IDB predicates.\n\nThese properties can be directly generalized to a rule by requiring Definition 9 for a rule body, and to a program by requiring it for each rule of the program. These conditions are achieved by applying several distinct transformations, which we will now describe one by one. During these transformations, we meanwhile drop some rules that are known unsatisfiable even without knowing the actual EDB data.\n\n4.1 Adornment of rules\n\nDuring the transformation, we will need to know which variables are free and which are bounded. Assigning bounded ($b$) and free ($f$) labels to variables and predicate arguments is called adornment. We use a slightly modified version of the Basic Sideways Capture Rule (BSCR) to add boundness annotations to the variables in rules as follows. Let $P$ be a PrivaLog program, $P'$ an initially empty program, and $r \\in P$ a rule which has the terms $A_1, \\ldots, A_k$ in its body. We start from the rule that corresponds to the goal predicate (there may be several such rules). Establish a set $B_1$, which contains the argument variables of $r$ that are bound in the rule head. For $1 < i \\leq k$, let $B_i$ be a set of variables that are either in $B_{i-1}$ or variables in the expression tree of $A_i$. If $A_i$ is a predicate, we rename that predicate so that the name reflects, which arguments of the predicate are bound. This is done by appending an underscore and then a single letter for each argument of the predicate. That is, if the argument at the $i$-th position appears in the set $B_{i-1}$ then we append the letter $b$ for 'bound', otherwise we append the letter $f$ for 'free'. For example, if we have the predicate $p(X,Y)$, where the argument $X$ is bound and $Y$ is free, then the predicate becomes $p_{bf}(X,Y)$. Finally, we rename the rule head by the same scheme and add that to our new adorned program $P'$.\n\nNext, we need to ensure that all the renamed predicates have a corresponding rule. For this, we look at every predicate in the body of the rule we have just adorned and then see, whether we already have an adorned rule in $P'$ with the same name. If there is no such rule, then we find the unadorned rules from $P$ and apply the previously described algorithm to that. This ensures that we only adorn the rules that are required for evaluating the goal. It is possible that we get different adornments for the same IDB predicate, e.g. $P'$ may contain rules for $p_{bf}(X,Y)$, $p_{fb}(X,Y)$, $p_{bb}(X,Y)$ simultaneously.\n\n4.2 Elimination of non-deterministic choices\n\nIn logic programs, if a disjunction $X ; Y$ contains a fresh variable $Z$ that has not used anywhere before, then we are having a choice, where the value of $Z$ is being assigned non-deterministically. We want to avoid such constructions in SecreC. A simple way to resolve this problem is to bring the RHS $q$ of each rule $p \\leftarrow q$ to disjunctive normal form (DNF), i.e. $\\bigvee_i \\bigwedge_j A_{ij}$ where $A_{ij}$ are literals of $q$. Putting $q_i = \\bigwedge_j A_{ij}$, we split the rule $p \\leftarrow q$ to several rules $p \\leftarrow q_1, \\ldots, p \\leftarrow q_n$, where each new rule does not contain any disjunctions. We need to be careful that the literals of $q_i$ keep the same order which they have had in $q$, so that each $q_i$ corresponds to a single search path.\n\nDisjunctions $X ; Y$ are allowed if both $X$ and $Y$ are ground terms, since such conditions can be easily evaluated in SecreC, and it is much more efficient to keep such disjunctions instead of generating several\nrules that essentially are performing the same computation. We may treat such disjunctions as single literals. \n\nTo keep the initial order of literals, we bring a formula to DNF using basic laws of logic. First, we bring the formula to negation normal form using De Morgan’s laws to push negation inwards, and eliminating double negations. After that, distributivity laws can be used to push conjunctions inward, and we only apply distributivity law to a formula that contains at least one free variable. All applied rewrite rules do not change the initial order of literals in the formula.\n\n4.3 Elimination of IDB calls\n\nWhile internal function calls and recursion are not a technical limitation of SecreC language, it performs much better if SIMD operations are used, as discussed in Sec. 5. For that reason, we unfold the IDB predicates as much as possible to achieve parallel evaluation of rules on all possible non-deterministic choices of EDB inputs. Eliminating IDB calls will also simplify the subsequent transformation steps. The unfolding transformation is close to the one described in [23].\n\nThe transformation is very similar to symbolic bottom-up execution of a Datalog program in a naive way, i.e. use the rules to provide the knowledge base with more and more facts until a fixpoint (or the bound on the number of iterations) is reached. Since we treat constants as symbolic variables, we cannot evaluate all literals, and will still get rules instead of facts by postponing the evaluation. As the result, we get a set of rules without IDB predicates.\n\nThe transformation is given in Figure 9. We use notation $RB \\in Set(clause)$ for the rule base, i.e. the set of ground rules (without IDB predicates) that have already been generated. Formally, we define transformation functions $T^F : program \\to program$, $T^C : clause \\to Set(clause)$, and $T^F : formula \\to Set(formula)$.\n\n\\[\n\\begin{align*}\nT^F(\\text{true})(RB) & := \\{\\text{true}\\} \\\\\nT^F(\\text{false})(RB) & := \\emptyset \\\\\nT^F(p_j(x_1, \\ldots, x_n))(RB) & := \\{q\\theta \\mid (x_1 = y_1\\theta), \\ldots, (x_n = y_n\\theta) \\mid p_j(y_1, \\ldots, y_n) :- q. \\in RB_j\\} \\\\\n& \\quad \\text{where } \\theta \\text{ is a substitution that gives fresh names to all variables} \\\\\nT^F(t_1 \\odot t_2)(RB) & := \\{t_1 \\odot t_2\\} \\text{ for } \\odot \\in \\{\\lt, \\lt=, \\lt?, \\leq, \\geq, \\leq?, \\geq?, \\is\\} \\\\\nT^F(q_1, q_2)(RB) & := \\{q_1', q_2' \\mid q_1 \\in T^F(q_1)(RB), q_2 \\in T^F(q_2)(RB)\\} \\\\\nT^F(q_1 \\setminus q_2)(RB) & := \\{q_1 \\setminus q_2\\} \\\\\nT^F(\\\\setminus+q)(RB) & := \\{\\\\setminus+q\\}\n\\end{align*}\n\\]\n\n\\[\nT^C(p_j(x_1, \\ldots, x_n) :- q.)(RB) := \\{p_j(x_1, \\ldots, x_n) :- q'. \\mid q' \\in T^F(q)(RB)\\}\n\\]\n\n\\[\nT^F(D_1 \\ldots D_m C_1 \\ldots C_n G) := D_1 \\ldots D_m \\text{ ifp}_{Set(clause)}^{m+n}(\\hat{I}) G\n\\]\n\nwhere \n\n\\[\n\\begin{align*}\ndecl(\\cdot\\text{-type } (p(x_1, \\ldots, x_k)).) & = p(x_1, \\ldots, x_k):\\text{-true}. \\\\\nP_i & := C_i \\text{ for } i \\in \\{1, \\ldots, n\\} \\\\\nP_i & := \\text{decl}(D_i) \\text{ for } i \\in \\{n + 1, \\ldots, m + n\\} \\\\\n\\hat{I}(RB) & = (T^C(P_1)(RB), \\ldots, T^C(P_{m+n})(RB)).\n\\end{align*}\n\\]\n\n**Fig. 9.** Unfolding a PrivaLog program\n\nSince predicates can correspond to more than one rule, we have to be careful how inlining is done. If we inline all the predicates in every rule body with every possible rule corresponding to those predicates,\nthen just one iteration of our algorithm might cause the intermediate program to rapidly explode in size. For example, let us look at the rule \\((r_1: p_1, \\ldots, p_k),\\) where \\(p_1, \\ldots, p_k\\) are predicates and \\(p_i\\) appears in the head of \\(j_i \\in \\mathbb{N}\\) different rules. In that case if we were to create a new rule for each possible combination of predicate inlinings, we would end up with \\(\\prod_{i=0}^k j_i\\) new rules. It is easy to see how the size of the program grows exponentially (or even worse) as the number of iterations goes up, especially in programs that contain recursion (e.g. the Fibonacci sequence).\n\nIn order to allow for better fine-tuning of the size of the intermediate program, we only apply inlining to the first predicate that appears in the body of the rule. This makes it so that after one iteration of inlining, we would only have \\(j_1\\) new rules. However, this algorithm uses the depth-first approach, so if the first predicate is recursive, the algorithm will never converge on a fixpoint. Even though this method has drawbacks, we still use in the current version of the PrivaLog translator as it is sufficient for most use cases. In the future we might look into algorithms, which use a breadth-first approach and where one iteration takes a predictable amount of time.\n\nThe nature of transformation of Figure 9 is very similar to the semantics described in Figure 3. The main difference is that \\(T^P\\) does not utilize the actual table data, but postpones valuation of table relations. Intuitively, on each step of the iteration of \\(\\mathcal{I}\\) and \\(\\mathcal{I}_1\\), the sets \\(\\mathcal{R}\\) and \\(\\mathcal{RB}\\) are tightly related to each other, so that we would always be able to get \\(\\mathcal{R}\\) out of \\(\\mathcal{RB}\\) as soon as we get the data.\n\n**Definition 10 (relations derived w.r.t. data).** Let \\(\\mathcal{R}\\) be a set of relations over a predicate \\(p\\), and let \\(\\mathcal{RB}\\) be a set of rules for \\(p\\). Let \\(\\mathcal{T}\\) be a set of extensional database relations. We say that \\(\\mathcal{R}\\) is derived from \\(\\mathcal{RB}\\) w.r.t. \\(\\mathcal{T}\\), denoting \\(\\mathcal{R} \\not\\overset{\\mathcal{T}}{\\sim} \\mathcal{RB}\\), if\n\n\\[\n\\mathcal{R} = \\left\\{ (a_{i1}, \\ldots, a_{in}) \\mid p(x_{i1}, \\ldots, x_{in}) :- q_i \\in \\mathcal{RB}, (a_{i1}, \\ldots, a_{in}) \\in [q_i(x_{i1}, \\ldots, x_{in})]_{\\mathcal{T}} \\right\\} .\n\\]\n\nWe want to show that the property of Definition 10 is maintained after applying the transformation. First, we show that it holds on formula level.\n\n**Lemma 1.** Let \\(\\mathcal{R} \\overset{\\mathcal{T}}{\\not\\sim} \\mathcal{RB}\\), \\(\\mathcal{T} \\subseteq \\mathcal{R}\\). Let \\(\\Gamma = \\text{vars}(q)\\). Then,\n\n\\[\n[q]_{\\mathcal{R}} = \\bigcup_{q' \\in T^F(q)(\\mathcal{RB})} [q']_{\\mathcal{T}} .\n\\]\n\n**Proof.** We prove the statement by induction on size of \\(q\\). We will refer to the left hand side of the proved equality as \\(LHS\\), and the right hand side as \\(RHS\\), so we need to show that \\(LHS = RHS\\).\n\n- Let \\(q \\in \\{true, false, \\forall q', q_1 \\mid q_2, t_1 \\odot t_2\\}\\) for \\(\\odot \\in \\{\\&, \\#, \\#, \\#\\#\\}\\). In these cases, the transformation does not change \\(q\\), and we have \\([q]_{\\mathcal{R}} = [q]_{\\mathcal{T}}\\), and \\(T^F(q)(\\mathcal{RB}) = \\{q\\}\\). Hence,\n\n\\[\nRHS = \\bigcup_{q' \\in T^F(q)(\\mathcal{RB})} [q']_{\\mathcal{R}} .\n\\]\n\n- Let \\(q = p_j(x_1, \\ldots, x_n)\\). We have \\(\\Gamma = \\text{Var}(q) = (x_1, \\ldots, x_n)\\) By definition,\n\n\\[\nT^F(p_j(x_1, \\ldots, x_n))(\\mathcal{RB}) = \\{q_i\\theta, (x_1 = y_{i1}\\theta), \\ldots, (x_n = y_{in}\\theta) \\mid p_j(y_{i1}, \\ldots, y_{in}) :- q_i \\in \\mathcal{RB}\\} ,\n\\]\n\nwhere \\(\\theta\\) issues fresh names to all variables. We need to show\n\n\\[\n[q]_{x_1, \\ldots, x_n}(\\mathcal{R}) = \\bigcup_{p_j(y_{i1}, \\ldots, y_{in}) \\mid q_i \\in \\mathcal{RB}} [q_i\\theta, (x_1 = y_{i1}\\theta), \\ldots, (x_n = y_{in}\\theta)]_{x_1, \\ldots, x_n}(\\mathcal{T}) .\n\\]\n\nBy assumption of the lemma, \\(\\mathcal{R} \\overset{\\mathcal{T}}{\\not\\sim} \\mathcal{RB}\\), so we have\n\n\\[\n\\mathcal{R}_j = \\left\\{ (a_{i1}, \\ldots, a_{in}) \\mid p_j(y_{i1}, \\ldots, y_{in}) :- q_i \\in \\mathcal{RB}, (a_{i1}, \\ldots, a_{in}) \\in [q_i(y_{i1}, \\ldots, y_{in})]_{\\mathcal{T}} \\right\\} .\n\\]\nWe have\n\\[\nLHS = [q]_{x_1,\\ldots,x_n}(R) = [p_j(x_1,\\ldots,x_n)]_{x_1,\\ldots,x_n}(T) = R_j\n= \\{(a_{i_1},\\ldots,a_{i_m}) \\mid p_j(y_{i_1},\\ldots,y_{i_m}) \\Leftarrow q_i \\in RB, (a_{i_1},\\ldots,a_{i_m}) \\in [q_i]_{y_{i_1},\\ldots,y_{i_m}}(T)\\}\n= \\bigcup_{p_j(y_{i_1},\\ldots,y_{i_m}) \\Leftarrow q_i \\in RB} [q_i]_{y_{i_1},\\ldots,y_{i_m}}(T);\n\\]\n\\[\nRHS = \\bigcup_{p_j(y_{i_1},\\ldots,y_{i_m}) \\Leftarrow q_i \\in RB} [q_i\\theta, (x_1 = y_{i_1}\\theta), \\ldots, (x_n = y_{i_n}\\theta)]_{x_1,\\ldots,x_n}(T)\n= \\bigcup_{p_j(y_{i_1},\\ldots,y_{i_m}) \\Leftarrow q_i \\in RB} [q_i\\theta, (x_1 = y_{i_1}\\theta), \\ldots, (x_n = y_{i_n}\\theta)]_{y_{i_1}\\theta,\\ldots,y_{i_n}\\theta}(T)\n= \\bigcup_{p_j(y_{i_1},\\ldots,y_{i_m}) \\Leftarrow q_i \\in RB} [q_\\theta]_{y_{i_1}\\theta,\\ldots,y_{i_n}\\theta}(T).\n\\]\n\nIn the last equality, since \\(x_i\\) are not present in \\(q_i\\), the conditions \\(x_j = y_{ij}\\) are always true and do not affect the set of relations generated by \\(q_i\\), so they only affect \\(T\\). Since \\(\\theta\\) only renames variables, without changing the semantics, we have \\(LHS = RHS\\).\n\n- Let \\(q = q_1 \\cup q_2\\). By induction hypothesis,\n - \\([q_1]_T(R) = \\bigcup_{q' \\in T^p(q_1)(RB)} [q']_T(\\Gamma)\\);\n - \\([q_2]_T(R) = \\bigcup_{q' \\in T^p(q_2)(RB)} [q']_T(\\Gamma)\\).\n\nHence,\n\\[\nLHS = [q_1, q_2]_T(R) = [q_1]_T(R) \\cap [q_2]_T(R);\nRHS = \\bigcup_{q' \\in T^p(q_1,q_2)(RB)} [q']_T(\\Gamma)\n= \\bigcup_{q_1 \\in T^p(q_1)(RB), q_2 \\in T^p(q_2)(RB)} [q_1]_T(\\Gamma) \\cap [q_2]_T(\\Gamma)\n= \\bigcup_{q_1 \\in T^p(q_1)(RB)} [q_1]_T(\\Gamma) \\cap \\bigcup_{q_2 \\in T^p(q_2)(RB)} [q_2]_T(\\Gamma)\n= [q_1]_T(\\Gamma) \\cap [q_2]_T(\\Gamma).\n\\]\n\nWe now show that Definition \\(\\Gamma\\) is maintained after applying the transformation on clause level.\n\n**Lemma 2.** Let \\(R \\not\\subseteq RB\\), \\(T \\subseteq R\\). Then, \\([q]_{x_1,\\ldots,x_n}(R) \\not\\subseteq T^C(p(x_1,\\ldots,x_n) \\Leftarrow q)(RB)\\).\n\n**Proof.** We need to show that\n\\[\nLHS := [q]_{x_1,\\ldots,x_n}(R) = \\bigcup_{p(x_1,\\ldots,x_n) \\Leftarrow q \\in T^C(p(x_1,\\ldots,x_n) \\Leftarrow q)(RB)} [q]_{x_1,\\ldots,x_n}(T) =: RHS.\n\\]\n\n- By Lemma \\(\\Gamma\\) since \\(R \\not\\subseteq RB\\), we have \\(LHS = [q]_{x_1,\\ldots,x_n}(R) = \\bigcup_{q_i \\in T^p(q)(RB)} [q_i]_{x_1,\\ldots,x_n}(T)\\).\n- By definition of clause transformation,\n \\[\n T^C(p_j(x_1,\\ldots,x_n) \\Leftarrow q)(RB) := \\{p_j(x_1,\\ldots,x_n) \\Leftarrow q \\mid q_i \\in T^p(q)(RB)\\}.\n \\]\n\nHence,\n\\[\nRHS = \\bigcup_{q_i \\in T^p(q)(RB)} [q_i]_{x_1,\\ldots,x_n}(T).\n\\]\n\nSince \\(x_j\\) and \\(x_{ij}\\) for all \\(i,j\\) correspond to the same relation attribute, we get \\(LHS = RHS\\). □\nWe now show that the unfolding transformation preserves program semantics. The idea is that, since the property \\( \\mathcal{R} \\subseteq \\mathcal{RB} \\) is maintained for each clause on each transformation step, we can show that \\( \\mathcal{R} \\subseteq \\mathcal{RB} \\) still holds after the \\( n \\)-th steps, which means that the set of relations generated by the initial and the transformed PrivaLog programs are the same. We note that we do not explicitly the assumption that a program is stratified, since according to our semantics we would not obtain new relations from looping constructions for the initial program as well.\n\n**Theorem 1.** Let \\( \\mathbb{P} \\) be a program defined according to the syntax of Figure 6. We have \\([\\mathbb{P}] = [T^P(\\mathbb{P})] \\).\n\n**Proof.** Let \\( \\mathbb{P} = (D_1 \\ldots D_m C_1 \\ldots C_n G) \\). The idea is to show that \\( \\mathcal{R} \\subseteq \\mathcal{RB} \\) is preserved on each step of the \\( \\text{ifp} \\) computation.\n\n- On the first step, the fixpoint operator is applied to \\( \\bot \\). We trivially have \\( \\bot \\subseteq \\mathcal{I} \\).\n- Let \\( \\mathcal{R} \\subseteq \\mathcal{RB} \\). Let \\( \\Pi_i = p_i(x_1,\\ldots,x_{i_k}) \\vdash q_i \\) be the \\( i \\)-th rule. We have:\n\n\\[\n\\mathcal{I}(\\mathcal{R}) = ([q_1]_{\\{x_1,\\ldots,x_{i_k}\\}}(\\mathcal{R}), \\ldots, [q_n]_{\\{x_{n_1},\\ldots,x_{n_k}\\}}(\\mathcal{R})); \\\\\n\\hat{\\mathcal{I}}(\\mathcal{RB}) = (T^C(p_1(x_{1i},\\ldots,x_{1k}), \\vdash q_i)(\\mathcal{RB}), \\ldots, T^C(p_n(x_{n1},\\ldots,x_{nk}), \\vdash q_n)(\\mathcal{RB})).\n\\]\n\nSince \\( \\mathcal{R} \\subseteq \\mathcal{RB} \\), by Lemma 2 we have \\([q_i]_{\\{x_{i1},\\ldots,x_{ik}\\}}(\\mathcal{R}) \\subseteq T^C(p_i(x_{1i},\\ldots,x_{in}), \\vdash q_i .)(\\mathcal{RB}) \\) for all \\( i \\).\n\nIt remains to show that the property \\( \\mathcal{R} \\subseteq \\mathcal{RB} \\) gives us what is needed. Let \\( n \\) be any iteration step. Consider the set of rules \\( \\mathcal{RB}^n \\) obtained for \\( T^P(\\mathbb{P}) \\) after the \\( n \\)-th step of transformation. We have shown above that \\( \\mathcal{R}^n \\subseteq \\mathcal{RB}^n \\). By definition of \\( \\mathcal{I} \\), we have\n\n\\[\n\\mathcal{R}^n = \\{(a_{i1},\\ldots,a_{in}) \\mid p(x_{1i},\\ldots,x_{in}) \\vdash q_i \\in \\mathcal{RB}^n, (a_{i1},\\ldots,a_{in}) \\in [q_i]_{\\{x_{i1},\\ldots,x_{in}\\}}(\\mathcal{T}) \\}.\n\\]\n\n- Let us prove that \\([\\mathbb{P}] \\subseteq [T^P(\\mathbb{P})] \\). Let \\( r \\in \\mathcal{R}^n = \\mathcal{I}(\\bot) \\) be any relation considered to be true after the \\( n \\)-th step in the initial program \\( \\mathbb{P} \\). We show that \\( r \\in \\mathcal{I}_{T^P(\\mathbb{P})}(\\mathcal{T}) \\). Since \\( \\mathcal{R}^n \\subseteq \\mathcal{RB}^n \\), there exists a rule \\( p(x_{1i},\\ldots,x_{in}) \\vdash q_i \\in \\mathcal{RB}^n \\), such that \\( r = (a_{i1},\\ldots,a_{in}) \\in [q_i]_{\\{x_{i1},\\ldots,x_{in}\\}}(\\mathcal{T}) \\). Hence, the relation \\( r \\) can be obtained from rules \\( \\mathcal{RB}^n \\) that have been generated on the \\( n \\)-th transformation step.\n\n- Let us prove that \\([T^P(\\mathbb{P})] \\subseteq [\\mathbb{P}] \\). Let \\( r \\) be any relation considered to be true in the transformed program \\( T^P(\\mathbb{P}) \\). Assume that \\( r \\) has been obtained using any rule from the set \\( \\mathcal{RB}^n \\) for some \\( n \\). By construction, the rules of \\( \\mathcal{RB}^n \\) do not contain any recursive calls, so their truthness depends only on the extensional database \\( \\mathcal{T} \\). Therefore, \\( r = (a_{i1},\\ldots,a_{in}) \\) where \\( p(x_{1i},\\ldots,x_{in}) \\vdash q_i \\in \\mathcal{RB}^n \\), and \\( (a_{i1},\\ldots,a_{in}) \\in [q_i]_{\\{x_{i1},\\ldots,x_{in}\\}}(\\mathcal{T}) \\). Since \\( \\mathcal{R}^n \\subseteq \\mathcal{RB}^n \\), by definition of \\( \\mathcal{I} \\), we have \\( r \\in \\mathcal{R}^n \\).\n\n\\( \\square \\)\n\n### 4.4 Distinguishing Comparisons from Assignments\n\nIn PrivaLog, we have the operator \\( = \\) which represent unification. We also have the operator \\( \\approx \\) which is the same as \\( = \\) with the restriction that the left argument should be a simple term, and the right argument a ground term. If both arguments are ground, then these operators can be interpreted as comparisons. If at least one argument of \\( = \\) is a free variable, or the left argument of \\( \\approx \\) is a free variable, then we have an assignment. Moreover, if both arguments of \\( = \\) are free variables, then these variables should be treated as the same variable in the entire computation, even if they have not been valued at the point of reaching \\( X \\approx Y \\). Using adornment functionality described in Section 4.1, we can discover all such cases and interpret them properly. We rewrite the comparison operators, so that the operator \\( = \\) would always mean assignment, and the operator \\( =:\\approx \\) equality. This makes subsequent translation to SecreC simpler.\n5 Generating SecreC code\n\nIn this section, we describe how a Datalog program is being transformed to SecreC code. Instead of using SecreC formal syntax directly, we describe the resulting program in terms of SecreC core language, so that the result of this section would be relevant if SecreC syntax undergoes some changes.\n\n5.1 Transformation to SecreC\n\nThe transformation of a Datalog program to SecreC code in terms of SecreC core language is given in Figure 10. Similarly to transformation of Sec. 4, we define transformation functions $S^P : \\text{program} \\rightarrow \\text{program}$, $S^C : \\text{clause} \\rightarrow \\text{Set}(\\text{clause})$, and $S^F : \\text{formula} \\rightarrow \\text{Set}(\\text{formula})$. Note that there are cases where a formula is treated as an expression. This happens when a program contains a disjunction or a negation, which by assumption may only contain ground variables, so SecreC can evaluate these expressions directly and does not need to introduce implicit variable assignments.\n\nFirst of all, we import a set of existing SecreC functions that will be needed. This is done by introducing a fixed header that lists imported modules and declares the private domain kind that will be used in the application.\n\nFor each Datalog relation, some arguments will provide inputs, and some arguments will be treated as outputs. This partitioning depends on the goal. Since different output variables may have different types, we are going to use a struct data structure that allows to return several different datatypes.\n\nIn Sec 6, we have agreed that the goal for simplicity only contains a single predicate. Hence, from the set of obtained unfolded rules, it suffices to take only those rules whose head matches the goal. Each such rule is converted to a SecreC function. In Section 4.1, we described preprocessing that labels each argument of the rule head as bounded or free. The bounded arguments will be rule inputs $x_i$, and free arguments will be rule outputs $y_i$. The values for inputs $x_i$ are passed as arguments of the SecreC function. The function then collects all extensional predicates called inside the rule body, and takes the cross product of corresponding EDB tables. It then evaluates rule body on the obtained cross product by simulating semantics of Datalog, to obtain valuations of outputs $y_i$. Since satisfiability may depend on private comparisons, each potential solution is accompanied with a private bit $b$, denoting whether that solution has satisfied the rule or not. The function finally returns some data $y$ of type struct that we have defined before. Since the only operation on strings that we are using so far is comparison, we compute (in a privacy-preserving way) an integer 32-bit hash of each string, and operate on integers. We note that, while CRC32 hash is quite good at avoiding collisions, it still does not get rid of them completely. In critical applications, we may still need to compare strings elementwise, which decreases efficiency.\n\nThe bags of possible valuations of $y_i$ obtained by different rules are eventually put together into one bag. To convert a bag to a set, the solutions are first de-duplicated. The bit $b$ should be taken into account in the uniqueness, since we do not want to occasionally remove a solution with $b = 1$ and leave the solution with $b = 0$. Due to privacy reasons, the duplicate solutions cannot be eliminated immediately, but instead we set $b = 0$ for the solutions that should be eliminated. Finally, only those solutions for which $b = 1$ should be published to the client. For this, all solutions are first shuffled (together with their satisfiability bits), and then the shuffled satisfiability bits are declassified, i.e. become visible to the computing parties. Shuffling is needed to conceal the initial positions of satisfiable solutions. Only those solutions for which $b = 1$ are published to the client.\n\nThe semantics of resulting SecreC program is defined as the set of valuations of $(y_1, \\ldots, y_m)$ that are output to the client, i.e. for which $b = 1$. We assume that the derivation order does not matter for the semantics. The latter is fine for Datalog, but we note that the order in which solutions are derived may be important for Prolog. We prove that the set of returned solution is the same for the initial PrivaLog program and the resulting SecreC program.\n\n5.2 Correctness\n\nIn Figure 8 we have defined semantics of an arithmetic expression only for a single relation tuple (since the definitions have been borrowed from relational algebra). We will need to generalize the definition to relations.\n\\[\nS^E(\\land \\mathbf{c}) := S^E(\\mathbf{c}) \\\\\nS^E(\\mathbf{e}_1 \\oplus \\mathbf{e}_2) := S^E(\\mathbf{e}_1) S^{\\text{OP}}(\\oplus) S^E(\\mathbf{e}_2) \\quad \\text{for } \\oplus \\in \\{+, \\cdot, , , /, \\ldots , \\} \\\\\nS^E(\\mathbf{e}_1 \\odot \\mathbf{e}_2) := S^E(\\mathbf{e}_1) S^{\\text{OP}}(\\odot) S^E(\\mathbf{e}_2) \\quad \\text{for } \\odot \\in \\{\\lt, \\lt, =, =, =\\} \\\\\nS^E(\\mathbf{c}) := \\mathbf{c} \\text{ for a constant } \\mathbf{c} \\\\\nS^E(\\mathbf{x}) := \\mathbf{x} \\text{ for a variable } \\mathbf{x}\n\\]\n\n\\(S^{\\text{OP}}(\\cdot)\\) translates PrivaLog operators to corresponding SecreC operators\n\n\\[\nS^F(\\mathbf{k}, \\mathbf{q}) := \\mathbf{b}_k : \\text{d bool}; \\mathbf{bk} = S^E(\\mathbf{q}); \\\\\n\\quad \\text{for } \\mathbf{q} \\text{ that does not contain any IDB/EDB predicates or fresh variables.}\n\\]\n\n\\[\nS^F(\\mathbf{k}, \\mathbf{z} = \\mathbf{e}) := \\mathbf{z} : \\text{d } \\mathbf{t}; \\mathbf{z} = S^E(\\mathbf{e}); \\mathbf{bk} : \\text{public bool}; \\mathbf{bk} = \\text{true}; \\\\\n\\quad \\text{where } \\mathbf{z} \\text{ is a fresh variable.}\n\\]\n\n\\[\nS^F(\\mathbf{k}, \\mathbf{p}(\\mathbf{z}_1, \\ldots, \\mathbf{z}_n)) := S^F(\\mathbf{k}, \\mathbf{z}_1 = \\mathbf{R}_k[1])_{\\mathbf{i} \\in [n]} \\\\\n\\quad \\mathbf{bk} : \\text{d bool}; \\mathbf{bk} = \\mathbf{bk}_1 \\& \\cdots \\& \\mathbf{bk}_n;\n\\]\n\n\\[\nS^F(\\mathbf{k}, -\\mathbf{p}(\\mathbf{z}_1, \\ldots, \\mathbf{z}_n)) := S^F(\\mathbf{k}, \\mathbf{z}_1 = \\mathbf{R}_k[1])_{\\mathbf{i} \\in [n]} \\\\\n\\quad \\mathbf{bk} : \\text{d bool}; \\mathbf{bk} = ! (\\mathbf{bk}_1 \\& \\cdots \\& ! \\mathbf{bk}_n);\n\\]\n\n\\[\nS^C(\\mathbf{j}', \\mathbf{p}(\\mathbf{z}_1, \\ldots, \\mathbf{z}_n) :- \\mathbf{q}_1, \\ldots, \\mathbf{q}_m) := p_j(\\mathbf{x}_i : \\text{d, } \\mathbf{t}_i)_{\\mathbf{i} \\in \\mathbf{X}} : \\text{d bool, } (\\mathbf{d}, \\mathbf{t}_i)_{\\mathbf{i} \\in \\mathbf{V}} \\{ \\mathbf{s} ; \\text{return } \\mathbf{w} \\}\n\\]\n\nwhere\n\n\\[\n\\mathbf{s} = (\\mathbf{R}_k)_{\\mathbf{k} \\in \\mathbf{K}} = \\text{join}(\\text{getTable}(\\mathbf{p}_j))_{\\mathbf{j} \\in \\mathbf{K}}; \\\\\n\\mathbf{(S^F(\\mathbf{k}, \\mathbf{q}_k))_{\\mathbf{k} \\in [n]}} \\\\\n\\mathbf{b} : \\text{d bool}; \\mathbf{b} = \\mathbf{b}_1 \\& \\cdots \\& \\mathbf{b}_m; \\\\\n\\mathbf{w} := (\\mathbf{b}, (\\mathbf{y}_j)_{\\mathbf{j} \\in \\mathbf{V}}) \\\\\n\\mathbf{K} := \\{ (\\mathbf{k}, \\mathbf{j}) | \\mathbf{k} \\in [n], \\mathbf{q}_k = \\mathbf{p}_j(\\ldots) \\} \\\\\n\\mathbf{X} := \\{ \\mathbf{i} | \\mathbf{z}_i \\text{ is an input of goal predicate} \\} \\\\\n\\mathbf{Y} := \\{ \\mathbf{i} | \\mathbf{z}_i \\text{ is an output of goal predicate} \\} \\\\\n\\mathbf{d}_i := \\text{domain type of } \\mathbf{z}_i \\text{ that depends on the schema of } \\mathbf{p}. \\\\\n\\mathbf{t}_i := \\text{data type of } \\mathbf{z}_i \\text{ that depends on the schema of } \\mathbf{p}. \\\\\n\\mathbf{d} := \\text{domain of } \\mathbf{b} \\text{ that is private iff at least one } \\mathbf{bk} \\text{ is private.}\n\\]\n\n\\[\nS^G(\\text{goal}(\\mathbf{x}_1, \\ldots, \\mathbf{x}_k, \\mathbf{y}_1, \\ldots, \\mathbf{y}_l) :- \\mathbf{p}(\\mathbf{z}_1, \\ldots, \\mathbf{z}_n), \\mathbf{J}) := \\\\\n(\\mathbf{x}_i : \\mathbf{d}_i, \\mathbf{t}_i = \\text{argument}(\\mathbf{x}_i))_{\\mathbf{i} \\in [n]} \\\\\n(\\mathbf{b} : \\text{private bool, } (\\mathbf{y}_i : \\mathbf{d}_i, \\mathbf{t}_i)_{\\mathbf{i} \\in [\\ell]} = \\text{unique}(\\text{shuffle}(\\text{concat}(\\mathbf{p}_j(\\mathbf{x}_1, \\ldots, \\mathbf{x}_k)_{\\mathbf{j} \\in \\mathbf{J}})))) \\\\\n\\text{pb : public bool} = \\text{declassify}(\\mathbf{b}); \\\\\n(\\text{publish(filter(pb, y_j)))}_{\\mathbf{j} \\in [\\ell]}; \\\\\nS^P(\\mathbf{C}_1 \\ldots \\mathbf{C}_m \\mathbf{G}) := (S^C(\\mathbf{j}, \\mathbf{C}_j))_{\\mathbf{j} \\in \\mathbf{J}} \\quad S^G(\\mathbf{G}, \\mathbf{J}) \\\\\n\\text{where } \\mathbf{J} = \\{ \\mathbf{j} | \\text{pred}(\\mathbf{C}_j) = \\text{pred}(\\mathbf{G}) \\}\n\\]\n\nFig. 10. Transformation of a semi-positive Datalog program to SecreC (\\(S^P\\))\nThat is, for an expression \\( e \\) and a set of relation tuples \\( \\mathcal{R} \\), we define expression semantics as\n\n\\[\n[e] \\mathcal{R} = \\{ [e] r \\mid r \\in \\mathcal{R} \\}.\n\\]\n\nWe provide a shorthand notation for a function that selects from a vector only those elements for which the satisfiability bit is 1.\n\n**Definition 11 (choice function for a vector).** Let \\( v \\in \\text{Vec}[m] \\). Let \\( b \\) a boolean vector of length \\( m \\). We define choice function as\n\n\\[\n\\text{choose}(v,b) = \\{ v_i \\mid i \\in [m], \\ b_i = \\text{true} \\}.\n\\]\n\nGeneralization of Definition 11 from \\( v \\in \\text{Vec}[m] \\) to \\( [v_1,\\ldots,v_n] \\in \\text{Vec}[m]^n \\) is straightforward. It can also be generalized to a program state as follows.\n\n**Definition 12 (choice function for a state).** Let \\( s \\) be a state over \\( \\text{Vec}[m] \\). Let \\( b \\) a boolean vector of length \\( m \\). Let \\( \\{x_1,\\ldots,x_n\\} = \\text{Dom}(s) \\). We define choice function as\n\n\\[\n\\text{choose}(s,b) = \\{ s[x_1],\\ldots,s[x_n] \\mid i \\in [m], \\ b_i = \\text{true} \\}.\n\\]\n\nIn order to prove that SecreC and PrivaLog programs perform the same computation, we need to define an equivalence relation between SecreC program states and PrivaLog relations. First of all, if we consider a single variable, the only difference is that the elements in a vector are ordered, but in a relation they comprise an unordered set.\n\n**Definition 13 (relation and vector equivalence w.r.t. attribute).** A relation \\( R \\) and a vector \\( v \\in \\text{Vec}[m] \\) are called equivalent w.r.t. attribute \\( x \\) (denoted \\( v \\sim_x R \\)) if\n\n\\[\n\\{ v_i \\mid i \\in [m] \\} = R[x].\n\\]\n\nGeneralization of Definition 13 from \\( v \\in \\text{Vec}[m] \\) to \\( [v_1,\\ldots,v_n] \\in \\text{Vec}[m]^n \\) is straightforward. It can also be generalized to a program state as follows.\n\n**Definition 14 (relation and program state equivalence w.r.t. schema).** A relation \\( R \\) and a program state \\( s \\) over \\( \\text{Vec}[m] \\) are called equivalent w.r.t. schema \\( \\Gamma = \\{ x_1,\\ldots,x_n \\} \\) (denoted \\( s \\sim_{\\Gamma} R \\)) if\n\n\\[\n\\{ s[x_1],\\ldots,s[x_n] \\mid i \\in [m] \\} = \\{ r[x_1],\\ldots,r[x_n] \\mid r \\in R \\}.\n\\]\n\nNote that \\( s \\sim_{\\Gamma} R \\) implies \\( s[x] \\sim_x R \\) for all \\( x \\in \\Gamma \\). However, it does not hold the other way around, as the relations between variables are important for \\( s \\sim_{\\Gamma} R \\).\n\nWe show that choice function preserves the equivalence relation.\n\n**Proposition 2.** Let \\( s \\in \\text{Vec}[m] \\) be a state and \\( \\mathcal{R}, \\mathcal{R}' \\) relations s.t. \\( \\text{choose}(s,b) \\sim_{\\Gamma} \\mathcal{R} \\) and \\( \\text{choose}(s,b') \\sim_{\\Gamma} \\mathcal{R}' \\) for some schema \\( \\Gamma \\) and boolean vectors \\( b \\) and \\( b' \\) of length \\( m \\). We have\n\n\\[\n\\text{choose}(s,b \\land b') \\sim_{\\Gamma} \\mathcal{R} \\cap \\mathcal{R}'\\;.\n\\]\n\n**Proof.** Let \\( \\Gamma = \\{ x_1,\\ldots,x_n \\} \\).\n\n\\[\n\\text{choose}(s,b \\land b') \\sim_{\\Gamma} \\mathcal{R} \\cap \\mathcal{R}' \\iff \\{ s[x_1],\\ldots,s[x_n] \\mid i \\in [m], \\ b_i = \\text{true}, b'_i = \\text{true} \\}\n\\]\n\\[\n= \\{ r[x_1],\\ldots,r[x_n] \\mid r \\in \\mathcal{R} \\cap \\mathcal{R}' \\}\n\\]\n\\[\n\\iff \\{ s[x_1],\\ldots,s[x_n] \\mid i \\in [m], \\ b_i = \\text{true} \\}\n\\]\n\\[\n\\cap\\{ s[x_1],\\ldots,s[x_n] \\mid i \\in [m], \\ b'_i = \\text{true} \\}\n\\]\n\\[\n= \\{ r[x_1],\\ldots,r[x_n] \\mid r \\in \\mathcal{R} \\cap \\{ r[x_1],\\ldots,r[x_n] \\mid r \\in \\mathcal{R}' \\}\n\\]\n\\[\n\\iff \\text{choose}(s,b) \\sim_{\\Gamma} \\mathcal{R} \\land \\text{choose}(s,b') \\sim_{\\Gamma} \\mathcal{R}'\\;,\n\\]\nwhere the latter statement holds by assumption.\nProposition 3. Let \\( s \\in \\text{Vec}[m] \\) be a state s.t. \\( \\text{choose}(s, b') \\sim_\\Gamma \\mathcal{R} \\) for some schema \\( \\Gamma \\) and boolean vector \\( b' \\) of length \\( m \\). Let \\( b \\) a boolean expression defined over variables of \\( \\Gamma \\), and let \\( b = [b] s \\). We have\n\n\\[\n\\text{choose}(s, b \\land b') \\sim_\\Gamma \\sigma_b \\mathcal{R} b'.\n\\]\n\nProof. Let \\( \\Gamma = \\{x_1, \\ldots, x_n\\} \\). Since \\([b]\\) is only defined over \\( \\Gamma \\), we have \\([b] s = [b] (s[x_1], \\ldots, s[x_n])\\).\n\n\\[\n\\text{choose}(s, b \\land b') \\sim_\\Gamma \\sigma_b \\mathcal{R} \\iff \\{s[x_1], \\ldots, s[x_n] | i \\in [m], b_i = \\text{true}, b'_i = \\text{true}\\}\n= \\{r[x_1], \\ldots, r[x_n] | r \\in \\sigma_b(\\mathcal{R})\\}\n\\]\n\nPutting \\( b' = \\text{true} \\), we get the following corollary.\n\nCorollary 1. Let \\( s \\) be a state s.t. \\( \\sim_\\Gamma \\mathcal{R} \\) for some schema \\( \\Gamma \\). Let \\( b \\) a boolean expression defined over variables of \\( \\Gamma \\), and let \\( b = [b] s \\). We have\n\n\\[\n\\text{choose}(s, b) \\sim_\\Gamma \\sigma_b \\mathcal{R}.\n\\]\n\nSo far, a function \\( \\phi \\) defined semantics for Datalog functional symbols, and \\( \\psi \\) defined semantics for SecreC functional symbols. We need that the interpretation function \\( \\phi \\) of Datalog and \\( \\psi \\) of SecreC would be isomorphic w.r.t function \\( S^{OP} \\) that defines correspondence between functional symbols of these two languages.\n\nDefinition 15 (interpretation isomorphism). The interpretation function \\( \\phi \\) of Datalog and \\( \\psi \\) of SecreC are called isomorphic (denoted \\( \\psi \\sim \\phi \\)) if, for all \\( v, v_1, v_2 \\in \\text{Val} \\):\n\n1. \\( \\psi(c) = \\phi(c) \\) for any constant symbol \\( c \\);\n2. \\( \\psi(!) v = \\phi(\\neg \\ast) v \\);\n3. \\( \\psi(S^{OP}(\\ast)) (v_1, v_2) = \\phi(\\ast) (v_1, v_2) \\) for \\( \\ast \\in \\{\\ast, \\neg, \\ast, /, \\ast, ;\\} \\);\n4. \\( \\psi(S^{OP}(\\circ)) (v_1, v_2) = \\phi(\\circ) (v_1, v_2) \\) for \\( \\circ \\in \\{<, =, =, =, =, /, =, >, =\\} \\).\n\nIn the following, to avoid ambiguity, we denote semantics of Datalog as \\( [\\_]^{DL} \\), and semantics of SecreC as \\( [\\_]^{SC} \\). We will heavily use the properties of relational algebra listed in Proposition 3.\n\nLemma 3. Let \\( q \\) be a ground PrivLog formula that does not contain IDB or EDB predicates. Let \\( \\Gamma \\) be a schema satisfying \\( \\Gamma \\supseteq \\text{vars}(q) \\) Then for any relation set \\( \\mathcal{R} \\), we have \\([q]_\\Gamma^{DL}(\\mathcal{R}) = \\sigma_{[q]^{DL}}(\\mathcal{U}_\\Gamma) \\).\n\nProof. We prove the statement by induction on size of \\( q \\) and case distinction.\n\n- Let \\( q = \\text{true} \\).\n\n\\[\n[q]^{DL}_\\Gamma(\\mathcal{R}) = \\mathcal{U}_\\Gamma\n= \\sigma_{\\text{true}}(\\mathcal{U}_\\Gamma)\n= \\sigma_{[\\text{true}]}^{DL}(\\mathcal{U}_\\Gamma)\n\\]\n- Let $q = \\text{false}$.\n\n$$[\\text{false}]^{DL}_{\\Gamma}(R) = \\emptyset$$\n\n$$= \\sigma_{\\text{false}}(U_{\\Gamma})$$\n\n$$= \\sigma_{[\\text{false}]^{DL}}(U_{\\Gamma})$$\n\n- Let $q = \\neg q'$.\n\n$$[\\neg q']^{DL}_{\\Gamma}(R) = U_{\\Gamma} \\setminus [q']^{DL}_{\\Gamma}(R)$$\n\n$$= U_{\\Gamma} \\setminus \\sigma_{q'}^{DL}(U_{\\Gamma})$$\n\n$$= \\sigma_{\\neg q'}^{DL}(U_{\\Gamma})$$\n\n$$= \\sigma_{[\\neg q']^{DL}}(U_{\\Gamma})$$\n\n- Let $q = q_1 \\land q_2$.\n\n$$[q_1 \\land q_2]^{DL}_{\\Gamma}(R) = [q_1]^{DL}_{\\Gamma}(R) \\cap [q_2]^{DL}_{\\Gamma}(R)$$\n\n$$= \\sigma_{q_1}^{DL}(U_{\\Gamma}) \\cap \\sigma_{q_2}^{DL}(U_{\\Gamma})$$\n\n$$= \\sigma_{[q_1 \\land q_2]^{DL}}(U_{\\Gamma})$$\n\n$$= \\sigma_{[q_1 \\land q_2]^{DL}}(U_{\\Gamma})$$\n\n- Let $q = q_1 \\lor q_2$.\n\n$$[q_1 \\lor q_2]^{DL}_{\\Gamma}(R) = [q_1]^{DL}_{\\Gamma}(R) \\cup [q_2]^{DL}_{\\Gamma}(R)$$\n\n$$= \\sigma_{q_1}^{DL}(U_{\\Gamma}) \\cup \\sigma_{q_2}^{DL}(U_{\\Gamma})$$\n\n$$= \\sigma_{[q_1 \\lor q_2]^{DL}}(U_{\\Gamma})$$\n\n$$= \\sigma_{[q_1 \\lor q_2]^{DL}}(U_{\\Gamma})$$\n\n- $q = (e_1 \\oplus e_2)$ for $\\oplus \\in \\{<,\\leq,=,\\neq,\\geq,>\\}$\n\n$$[e_1 \\oplus e_2]^{DL}_{\\Gamma}(R) = \\sigma_{[e_1 \\oplus e_2]^{DL}}(U_{\\Gamma})$$\n\nSince $q$ is ground, by assumption, it cannot be of the form $q_1 = q_2$. Hence, we have looked through all possible cases.\n\nWe will prove equivalence of SecreC and PrivaLog programs on different granularity levels (expression, formula, clause, program). We start from expressions, showing how to increase the schema $\\Gamma$ w.r.t. a state and a relation.\n\n**Lemma 4 (equivalence of expression semantics).** Let $e$ be an expression defined according to the syntax of Figure 6. Let $s \\sim_{\\Gamma} R$, $\\psi \\sim \\phi$, $z \\notin \\Gamma$, and $\\text{vars}(e) \\subseteq \\Gamma$. We have\n\n$$s[z \\mapsto [S^E(e)]^{SC}_{\\Gamma}] \\sim_{\\Gamma \\cup \\{z\\}} \\sigma_{z:=e}^{DL}(R \\times U_z)$$\n\nfor $z \\notin \\text{schema}(R)$.\n\n**Proof.** Let $s \\in \\text{Vec}[m]$. Let $s' := s[z \\mapsto [S^E(e)]^{SC}_{\\Gamma}]$, and let $R' := \\sigma_{z:=e}^{DL}(R \\times U_z)$. Let $\\Gamma = \\{x_1, \\ldots, x_n\\}$. Suppose that\n\n$$\\forall (v_1, \\ldots, v_n) \\in \\text{Val}^n : [S^E(e)]^{SC}_{\\Gamma}(v_1, \\ldots, v_n) = [e]^{DL}_{\\Gamma}(v_1, \\ldots, v_n).$$\n\n(1)\nWe have\n\n\\[ \\{ s'[x_1], \\ldots, s'[x_n], s'[z] \\mid i \\in [m] \\} = \\{ s[x_1], \\ldots, s[x_n], ([S^E(e)]^{SC})_i \\mid i \\in [m] \\} \\]\n\n\\[ \\{ r[x_1], \\ldots, r[x_n], r[z] \\mid r \\in R' \\} = \\{ r[x_1], \\ldots, r[x_n], r[z] \\mid [z := e]^{DL} r = true, r \\in R \\times U \\} \\]\n\nfor all \\( e \\). This follows almost directly from \\( \\psi \\sim \\phi \\). We prove the statement by induction on size of expression \\( e \\). Let \\( v = (v_1, \\ldots, v_n) \\in Val^n \\).\n\n\\[ [S^E(\\land e)]^{SC} v = [S^E(e)]^{SC} v = [S^E(e)]^{SC} v \\]\n\n\\[ [S^E(e_1 \\lor e_2)]^{SC} v = [S^E(e_1) \\lor [S^E(e_2)]^{SC} v \\]\n\n\\[ = \\psi([S^O(\\lor)](S^E(e_1))^{SC} v, [S^E(e_2)]^{SC} v) \\]\n\n\\[ = \\phi(\\lor, ([e_1]^{DL} v, [e_2]^{DL} v) \\]\n\n\\[ = [e_1 \\lor e_2]^{DL} v \\]\n\nfor \\( \\lor \\in \\{\\land, \\lor, \\land \\} \\).\n\n\\[ [S^E(c)]^{SC} v = \\psi(c) = [c]^{DL} v \\]\n\nfor a constant \\( c \\).\n\n\\[ [S^E(x_i)]^{SC} (v_1, \\ldots, v_n) = v_i = [x_i]^{DL} v \\]\n\nfor a variable \\( x_i \\).\n\n\\[ \\square \\]\n\nFor a formula, we want that the set of satisfiable relations computed by PrivaLog program is the same as the set of relations computed by SecreC program. An important detail here is that the relations computed by SecreC are accompanied by a secret-shared bit whose value we do not know in advance before publishing. Hence, we prove that the sets of relations will be the same for those solutions \\( y_i \\) where \\( b_i = 1 \\), and we do not care of the other solutions.\n\n**Lemma 5 (equivalence of formula semantics w.r.t. input).** Let \\( q = q_1, \\ldots, q_m \\) be a formula defined according to the syntax of Figure 6 and satisfying Definition 4. Let \\( \\Gamma = \\text{vars}(q) \\) be the variables of \\( q \\).\n\nLet \\( X = \\text{fvars}(q) \\) be the free variables of \\( q \\).\n\nLet \\( R_X \\) be a relation such that \\( \\text{schema}(R_X) = X \\).\n\nLet \\( R \\) be a set of relations \\( R_k \\) such that \\( \\text{schema}(R_k) = (R_k[1], \\ldots, R_k[n_k]) \\) for all \\( k \\in K \\).\n\nLet \\( s_0 \\) be a state such that\n\n- \\( \\text{Dom}(s_0) = X \\cup \\{ (R_k[1], \\ldots, R_k[n_k])_{k \\in K} \\} \\);\n- \\( s_0 \\sim_{X} R_X \\);\n- \\( s_0 \\sim_{(a_k[1], \\ldots, a_k[n_k])_{k \\in K}} \\prod_{k \\in K} R_k \\).\n\nLet \\( R^0 = R_X \\times U_{\\Gamma \\setminus X} \\).\n\nLet \\( R^k = [q_k]^{DL}(R) \\), and let \\( s = [S^F(1, q_1)]^{SC} \\circ \\cdots \\circ [S^F(m, q_m)]^{SC} s_0 \\).\n\nWe have:\n\n\\[ \\text{choose}(s, s[b1] \\land \\cdots \\land s[bm]) \\sim_{\\Gamma} (R^0 \\cap R^1 \\cap \\cdots \\cap R^m) \\]\nProof. By induction on \\( k \\), we prove a stronger statement. Let \\( s_k = \\lfloor q_1, \\ldots, q_k, s \\rceil^{SC} \\) \\( s_0 \\). Let \\( \\Gamma_0 = X \\), and let \\( \\Gamma_k := X \\cup \\text{vars}(q_1, \\ldots, q_k) \\). For all \\( k \\leq m \\):\n\n\\[\n\\text{choose}(s_k, s_k[b_1] \\land \\cdots \\land s_k[b_k]) \\sim_{\\Gamma_k} (R^0 \\cap R^1 \\cap \\cdots \\cap R^k).\n\\]\n\nIn the following, we will use notation \\( C_k := \\text{choose}(s_k, s_k[b_1] \\land \\cdots \\land s_k[b_k]) \\).\n\n**Base:** We have \\( k = 0 \\), and \\( s = s_0 \\). By assumption, \\( s_0 \\sim_{\\Gamma_0} R_0 \\). By Corollary 1\n\n\\[\nC_0 = \\text{choose}(s, true) = \\text{choose}(s_0, true) \\sim_{\\Gamma_0} \\sigma_{true}(R^0) = R^0.\n\\]\n\n**Step:** Let \\( k > 0 \\). We know that \\( s_k[b_i] = s_{k-1}[b_i] \\) for \\( i < k \\), since each variable \\( b_i \\) is only defined once. Hence,\n\n\\[\nC_k = \\text{choose}(s_k, s_{k-1}[b_1] \\land \\cdots \\land s_{k-1}[b(k-1)] \\land s_k[b_k]) .\n\\]\n\nFurther simplification depends on the form of \\( q_k \\). We need to apply case distinction.\n\n- Let \\( q_k \\) be ground formula without IDB/EDB predicates.\n\n\\[\n\\begin{align*}\nR^k \\; &= \\; \\lfloor q_k \\rfloor^{DL}_{\\mathcal{R}} \\\\\n\\Gamma_1 \\; &= \\; \\Gamma_k-1 \\\\\ns_k \\; &= \\; \\lfloor S^F(k, q_k) \\rfloor^{SC} \\; s_{k-1} \\\\\n&= \\; \\lfloor bk : d \\; \\text{bool}; \\; bk = S^E(q_k) \\rfloor^{SC} \\; s_{k-1}\n\\end{align*}\n\\]\n\nNo new variables are introduced by \\( \\lfloor q_k \\rfloor^{SC} \\) except \\( bk \\), which are not a part of \\( \\Gamma_k \\). Therefore:\n\n- \\( \\Gamma_k = \\Gamma_k-1 \\):\n- \\( s_k[x] = s_{k-1}[x] \\) for all \\( x \\in \\Gamma_k \\);\n- \\( \\lfloor q_k \\rfloor^{DL}_{\\mathcal{R}} = \\sigma_{q_k}^{DL}(U_T) \\) by Lemma 3.\n\nApplying induction hypothesis and Proposition 3\n\n\\[\nC_k = \\text{choose}(s_k, s_{k-1}[b_1] \\land \\cdots \\land s_{k-1}[b(k-1)] \\land s_k[b_k])\n\\]\n\n\\[\n\\sim_{\\Gamma_k} \\sigma_{[q_k]}^{DL}(R^0 \\cap \\cdots \\cap R^{k-1})\n\\]\n\n\\[\n= \\sigma_{[q_k]}^{DL}(U_T) \\cap (R^0 \\cap \\cdots \\cap R^{k-1})\n\\]\n\n\\[\n= R^k \\cap (R^0 \\cap \\cdots \\cap R^{k-1})\n\\]\n\n- Let \\( q_k = (z = e) \\).\n\n\\[\n\\begin{align*}\nR^k \\; &= \\; \\lfloor z = e \\rfloor^{DL}_{\\mathcal{R}} \\\\\n&= \\sigma_{[z=:e]}^{DL}(U_T) \\\\\ns_k \\; &= \\; \\lfloor S^F(k, z = e) \\rfloor^{SC} \\; s_{k-1} \\\\\n&= \\; \\lfloor x:d \\; ; \\; z=S^E(e); \\; bk:public \\; \\text{bool}; \\; bk=true \\rfloor^{SC} \\; s_{k-1}\n\\end{align*}\n\\]\n\nBy assumption, the RHS of an assignment should be a ground term. Hence, each variable \\( x \\in \\text{vars}(e) \\) has occurred before in \\( q_1, \\ldots, q_{k-1} \\), and \\( \\text{vars}(e) \\subseteq \\text{vars}(q_1, \\ldots, q_{k-1}) \\subseteq \\Gamma_k-1 \\). By induction hypothesis,\n\n\\[\n\\text{choose}(s_{k-1}, s_{k-1}[b_1] \\land \\cdots \\land s_{k-1}[b(k-1)]) \\sim_{\\Gamma_k} (R^0 \\cap \\cdots \\cap R^{k-1}),\n\\]\n\nso we can apply Lemma 4\n\n\\[\nC_k = \\text{choose}(s_k, s_{k-1}[b_1] \\land \\cdots \\land s_{k-1}[b(k-1)] \\land s_k[b_k])\n\\]\n\n\\[\n\\sim_{\\Gamma_k} \\sigma_{[z=:e]}^{DL}(R^0 \\cap \\cdots \\cap R^{k-1})\n\\]\n\n\\[\n= \\sigma_{[z=:e]}^{DL}(U_T) \\cap (R^0 \\cap \\cdots \\cap R^{k-1})\n\\]\n\n\\[\n= R^k \\cap (R^0 \\cap \\cdots \\cap R^{k-1}) = R^0 \\cap \\cdots \\cap R^k\n\\]\n– Let \\( q_k = p_j(z_1, \\ldots, z_n) \\).\n\n\\[\nR^k = [p_j(z_1, \\ldots, z_n)]^{DL}(R) = \\rho_{z_i/R_j[1], \\ldots, z_n/R_j[n]} R_j \\times U \\setminus \\{z_1, \\ldots, z_n\\}\n\\]\n\n\\[\ns_k = \\left[ S^F(k, p_j(z_1, \\ldots, z_n)) \\right]^{SC} s_{k-1}\n\\]\n\n\\[\n= \\left[ S^F(k, z_i = R_j[i])_{i \\in [n]} bk : d \\text{ bool} ; bk = b_{k1} & \\cdots & b_{kn}\\right]^{SC} s_{k-1}\n\\]\n\n\\[\n= [bk : d \\text{ bool} ; bk = b_{k1} & \\cdots & b_{kn}]^{SC} \\circ \\left[ S^F(k, z_i = R_j[i])_{i \\in [n]} \\right]^{SC} s_{k-1}\n\\]\n\nLet us first analyze \\( \\left[ S^F(k, z_i = R_j[i])_{i \\in [n]} \\right]^{SC} s_{k-1} \\). Let \\( q_k := (z_i = R_j[i]) \\) for \\( i \\in [n] \\). Consider the formula \\( q' := q_1, \\ldots, q_{k-1}, q_{k1}, \\ldots, q_{kn} \\). The variables \\( X' := \\{R_j[i] \\mid i \\in [n]\\} \\) are not a part of \\( \\Gamma \\). We have \\( \\text{vars}(q') = \\Gamma \\cup X' \\), and \\( \\text{fvars}(q') = X \\cup X' \\).\n\nLet \\( s' = \\left[ S^F(q') \\right]^{SC} s_0 \\). By assumption, \\( s_0 \\sim_X R_X \\), and \\( s_0 \\sim_{(b_{k1}[1], \\ldots, b_{kn}[n])}_{k \\in K} \\prod_{k \\in K} R_k \\), so we have \\( s_0 \\sim_{X \\cup X'} R_X \\times R_j \\), and can apply induction hypothesis to \\( q' \\) with \\( R_{X \\cup X'} := R_X \\times R_j \\). While the formula \\( q' \\) is longer than \\( q \\), we can still apply induction since the newly introduced expressions have a simpler structure for which we already have the proof. We get\n\n\\[\nC'_k := \\text{choose}(s', s_k-1[b1] \\land \\cdots \\land s_k-1[bk - 1] \\land s'[bk1] \\land \\cdots \\land s'[bkn])\n\\]\n\n\\[\n\\sim_{r_k} \\sigma_{[z_i = R_j[1] \\land \\cdots \\land z_n = b_{kn}[n]]}^{DL}((R_X \\times R_j \\times U \\setminus X) \\cap (R^1 \\times U \\setminus X') \\cap \\cdots \\cap (R^{k-1} \\times U \\setminus X'))\n\\]\n\n\\[\n= \\sigma_{[z_i = R_j[1] \\land \\cdots \\land z_n = b_{kn}[n]]}^{DL}((R^0 \\times R_j) \\cap (R^1 \\times U \\setminus X) \\cap \\cdots \\cap (R^{k-1} \\times U \\setminus X'))\n\\]\n\n\\[\n= \\sigma_{[z_i = R_j[1] \\land \\cdots \\land z_n = b_{kn}[n]]}^{DL}((R^0 \\cap R^1 \\cap \\cdots \\cap R^{k-1}) \\times R_j) .\n\\]\n\nOn the other hand,\n\n\\[\nR^k = \\rho_{z_i/R_j[1], \\ldots, z_n/R_j[n]} R_j \\times U \\setminus \\{z_1, \\ldots, z_n\\}\n\\]\n\n\\[\n= \\pi^r(\\sigma_{[z_i = R_j[1], \\ldots, z_n = b_{kn}[n]]}^{DL}((U \\setminus X) \\times R_j))\n\\]\n\n\\[\n= \\pi^r(\\sigma_{[z_i = R_j[1] \\land \\cdots \\land z_n = b_{kn}[n]]}^{DL}(U \\setminus X) \\times R_j)) ,\n\\]\n\nhence\n\n\\[\nC'_k \\sim_{r_k} \\sigma_{[z_i = R_j[1] \\land \\cdots \\land z_n = b_{kn}[n]]}^{DL}((R^0 \\cap R^1 \\cap \\cdots \\cap R^{k-1}) \\times R_j)\n\\]\n\n\\[\n= \\pi^r(\\sigma_{[z_i = R_j[1] \\land \\cdots \\land z_n = b_{kn}[n]]}^{DL}(R^0 \\cap R^1 \\cap \\cdots \\cap R^{k-1}) \\times R_j))\n\\]\n\n\\[\n= \\pi^r(\\sigma_{[z_i = R_j[1] \\land \\cdots \\land z_n = b_{kn}[n]]}^{DL}(U \\setminus X) \\times R_j)) \\cap (R^0 \\cap R^1 \\cap \\cdots \\cap R^{k-1})\n\\]\n\n\\[\n= \\pi^r((R^0 \\cap R^1 \\cap \\cdots \\cap R^{k-1}) \\times R_j)\n\\]\n\nThe only difference between states \\( s' \\) and \\( s \\) is that \\( bk \\) is not defined in \\( s' \\). Other than this, we have \\( s'[x] = s_k[x] \\) for all \\( x \\in I_k \\). We have\n\n\\[\nC_k = \\text{choose}(s_k, s_{k-1}[b1] \\land \\cdots \\land s_k-1[bk - 1] \\land s_k[bk])\n\\]\n\n\\[\n= \\text{choose}(s_k, s_{k-1}[b1] \\land \\cdots \\land s_k-1[bk - 1] \\land s_k[bk1] \\land \\cdots \\land s_k[bkn])\n\\]\n\n\\[\n= \\text{choose}(s', s_{k-1}[b1] \\land \\cdots \\land s_k-1[bk - 1] \\land s'[bk1] \\land \\cdots \\land s'[bkn])\n\\]\n\n\\[\n= C'_k = R^0 \\cap \\cdots \\cap R^{k-1} .\n\\]\n\n– Let \\( q_k = \\chi \\land p_j(z_1, \\ldots, z_n) \\).\n\n\\[\nR^k = [p_j(z_1, \\ldots, z_n)]^{DL}(R) = U \\setminus \\rho_{z_i/R_j[1], \\ldots, z_n/R_j[n]} R_j\n\\]\n\n\\[\ns_k = \\left[ S^F(k, \\chi \\land p(z_1, \\ldots, z_n)) \\right]^{SC} s_{k-1}\n\\]\n\n\\[\n= \\left[ S^F(k, z_i = R_k[i])_{i \\in [n]} bk : d \\text{ bool} ; bk = ! (bk1 & \\cdots & bkn)\\right]^{SC} s_{k-1}\n\\]\n\n\\[\n= [bk : d \\text{ bool} ; bk = ! (bk1 & \\cdots & bkn)]^{SC} \\circ \\left[ S^F(k, z_i = R_j[i])_{i \\in [n]} \\right]^{SC} s_{k-1}\n\\]\n\nThis case is very similar from the previous one. The difference is that we do not look for the cases where equalities we successful, but look for the case where they were not all successful. Consider the formula\n\n\\[\n24\n\\]\nLet $q' := q_1, \\ldots, q_{k-1}, q_{k+1}, \\ldots, q_{kn}$. Let $s' = [S^F(q')]^{SC} s_0$. Taking $\\mathcal{R}_{X \\cup X'} := \\mathcal{R}_X \\times \\mathcal{R}_j$, by induction hypothesis,\n\n\\[ C'_k := \\text{choose}(s', s_{k-1}[b_1] \\land \\cdots \\land s_{k-1}[b_{k-1}] \\land \\neg(s'[b_{k-1}] \\land \\cdots \\land s'[b_{kn}])) \\sim_{I_k} \\sigma_{[\\vee(z_1 = b_1[1] \\land \\cdots \\land z_n = b_n[n])]}^D L((\\mathcal{R}_X \\times \\mathcal{R}_j \\times \\mathcal{U}_{F \\setminus \\{x\\}}) \\cap (\\mathcal{R}^1 \\times \\mathcal{U}_{X'}) \\cap \\cdots \\cap (\\mathcal{R}^{k-1} \\times \\mathcal{U}_{X'})) . \\]\n\nOn the other hand,\n\n\\[ \\mathcal{R}^k = \\mathcal{U}_F \\setminus \\rho_{z_1 / \\mathcal{R}_j[1], \\ldots, z_n / \\mathcal{R}_j[n]} \\mathcal{R}_j \\times \\mathcal{U}_{F \\setminus \\{z_1, \\ldots, z_n\\}} \\]\n\n\\[ = \\mathcal{U}_F \\setminus \\pi_{\\mathcal{R}}(\\sigma_{[z_1 = b_1[1] \\land \\cdots \\land z_n = b_n[n]]}^D L(\\mathcal{U}_F \\times \\mathcal{R}_j)) , \\]\n\nhence\n\n\\[ C'_k \\sim_{I_k} \\sigma_{[\\vee(z_1 = b_1[1] \\land \\cdots \\land z_n = b_n[n])]}^D L((\\mathcal{R}^0 \\cap \\mathcal{R}^1 \\cap \\cdots \\cap \\mathcal{R}^{k-1}) \\times \\mathcal{R}_j) \\]\n\n\\[ = \\pi_{\\mathcal{R}}(\\sigma_{[z_1 = b_1[1] \\land \\cdots \\land z_n = b_n[n]]}^D L((\\mathcal{R}^0 \\cap \\mathcal{R}^1 \\cap \\cdots \\cap \\mathcal{R}^{k-1}) \\times \\mathcal{R}_j)) \\]\n\n\\[ = \\pi_{\\mathcal{R}}(\\sigma_{[z_1 = b_1[1] \\land \\cdots \\land z_n = b_n[n]]}^D L(\\mathcal{U}_F \\times \\mathcal{R}_j)) \\cap (\\mathcal{R}^0 \\cap \\mathcal{R}^1 \\cap \\cdots \\cap \\mathcal{R}^{k-1}) \\]\n\n\\[ = \\mathcal{U}_F \\setminus \\pi_{\\mathcal{R}}(\\sigma_{[z_1 = b_1[1] \\land \\cdots \\land z_n = b_n[n]]}^D L(\\mathcal{U}_F \\times \\mathcal{R}_j)) \\cap (\\mathcal{R}^0 \\cap \\mathcal{R}^1 \\cap \\cdots \\cap \\mathcal{R}^{k-1}) \\]\n\n\\[ = \\mathcal{R}^k \\cap (\\mathcal{R}^0 \\cap \\mathcal{R}^1 \\cap \\cdots \\cap \\mathcal{R}^{k-1}) . \\]\n\nSimilarly to the previous case, $C_k = C'_k$. □\n\nLemma 6 (equivalence of clause semantics). Let $C_j := p_j(z_1, \\ldots, z_n) := q_1, \\ldots, q_m$ be a clause. Let $\\{x_1, \\ldots, x_k\\} \\subseteq \\{z_1, \\ldots, z_n\\}$ be marked as inputs, and $\\{y_1, \\ldots, y_e\\} \\subseteq \\{z_1, \\ldots, z_n\\}$ as outputs. Let $\\Gamma = \\text{vars}(q_1, \\ldots, q_m)$.\n\nLet $\\mathcal{R} \\subseteq \\{\\text{relations} \\ \\mathcal{R}_k\\}$, where schema$(\\mathcal{R}_k) = (R_k[1], \\ldots, R_k[n_k])$.\n\nLet $\\mathcal{T} : \\text{VName} \\rightarrow \\text{Rel}$ be a function such that $\\mathcal{T}(p_k) = \\mathcal{R}_k$.\n\nLet $(b, (w_i)_{i \\in Y}) = [S(j, C)]^{SC} [v_1, \\ldots, v_k]$. We have\n\n\\[ \\text{choose}((w_i)_{i \\in Y}, b) \\sim_Y (\\sigma_{z_1 = v_1, \\ldots, x_k = v_k} \\mathcal{U}_F \\cap [q_1]^D L(\\mathcal{R}^0) \\cap \\cdots \\cap [q_m]^D L(\\mathcal{R}^m)) . \\]\n\nProof. Let $v_1, \\ldots, v_k$ be the valuations of $x_1, \\ldots, x_k$. Semantics of a SecreC function is defined as\n\n\\[ [S(j, C)]^{SC} [v_1, \\ldots, v_k] := ([s] \\{ x_i \\mapsto v_i \\}) [b, v_1, \\ldots, y_e] \\]\n\nwhere\n\n\\[ s = [S^C(j', p(z_1, \\ldots, z_n) := q_1, \\ldots, q_m)]]^{SC} [v_1, \\ldots, v_k] \\]\n\n\\[ = [b : d \\ \\text{bool} ; b = b_1 \\ \\& \\ \\cdots \\ \\& \\ b_m]^{SC} \\]\n\n\\[ \\circ [S^F(k, q_k)]_{k \\in [m]}^{SC} \\]\n\n\\[ \\circ [(R_k)_{k \\in K}] = \\text{join}((\\text{getTable}(p_j))_{(\\lambda_j) \\in K}) ; [S^C(v_1, \\ldots, v_k)]^{SC} \\]\n\nwhere $K = \\{(k, j) \\mid k \\in [m], q_k = p_j(\\cdot)\\}$.\n\nLet $X = \\{x_1, \\ldots, x_n\\}$, and $s' = \\{x_i \\mapsto v_1, \\ldots, x_k \\mapsto v_k\\}$. That is, $s' \\sim_X \\sigma_{x_1 = v_1, \\ldots, x_k = v_k} \\mathcal{U}_F$. The first line of the SecreC program creates a new state $s_0$ satisfying $s_0 \\sim_{[R_1[1], \\ldots, R_m[n_k]]} \\prod_{k \\in K} \\mathcal{R}_k$ by definition of blackbox functions join and getTable that extract from $\\mathcal{T}$ relations $\\mathcal{R}_j$ and construct their cross product. Technically, the inputs $s_0[x_i]$ are scaled to the length of cross product table, so that operations on vectors would be correct, and we still have $s_0 \\sim_X \\sigma_{x_1 = v_1, \\ldots, x_k = v_k} \\mathcal{U}_F$. Let $\\mathcal{R}_X := \\pi_X(\\sigma_{x_1 = v_1, \\ldots, x_k = v_k} \\mathcal{U}_F)$. We can apply Lemma 5 on $q_k$, $X$, $\\mathcal{R}$, $\\mathcal{R}_X$ and $s_0$, getting\n\n\\[ \\text{choose}(s, s[b_1] \\land \\cdots \\land s[b_m]) \\sim_{I_k} (\\mathcal{R}^0 \\cap \\cdots \\cap \\mathcal{R}^m) , \\]\n\nwhere $\\mathcal{R}^k = [q_k]^D L(\\mathcal{R})$ for $k > 0$, and $\\mathcal{R}^0 = \\sigma_{x_1 = v_1, \\ldots, x_k = v_k} \\mathcal{U}_F$. Since $\\{y_i \\mid i \\in Y\\} \\subseteq \\Gamma$, the relation $\\sim_Y$ holds as well.\n\n25\nThe last line of the SecreC program defines \\( s[b] = s[b_1] \\land \\cdots \\land s[b_m] \\). We get \\( \\text{choose}((w_i)_{i \\in Y}, b) = \\text{choose}(s, s[b]) = \\text{choose}(s, s[b_1] \\land \\cdots \\land s[b_m]) = \\text{choose}(s, s[b_1] \\land \\cdots \\land s[b_m])_{[y_1, \\ldots, y_\\ell]} \\), which implies\n\n\\[\n\\text{choose}((w_i)_{i \\in Y}, b) \\sim_Y (\\sigma_{z_1 = v_1, \\ldots, x_k = v_k} U_T \\cap \\{q_1\\}_{1}^{DL}(\\mathcal{R}) \\cap \\cdots \\cap \\{q_m\\}_{1}^{DL}(\\mathcal{R})) .\n\\]\n\n\\[\\square\\]\n\n**Theorem 2.** Let \\( P \\) be a PrivaLog program with input variables \\( X = \\{x_1, \\ldots, x_k\\} \\), and output variables \\( Y = \\{y_1, \\ldots, y_\\ell\\} \\). We have\n\n\\[\n[S^P(\\mathcal{P})]^{SC} \\sim_Y [P]^{DL} .\n\\]\n\n**Proof.** Let \\( v_1, \\ldots, v_k \\) be some valuations of inputs for \\( P \\) and \\( S^P(\\mathcal{P}) \\).\n\nLet \\( P = D_1 \\ldots D_n C_1 \\ldots C_m G \\). Let \\( J = \\{ j \\mid \\text{pred}(C_j) = \\text{pred}(G) \\} \\). Let \\( G' = G_{x_i \\mapsto v_i} \\). In \\( P \\), we have by assumption unfolded the rules in such a way that all answers may be obtained in one iteration of \\( \\mathcal{I} \\) operator, assuming that only relations \\( \\mathcal{R} = (\\mathcal{R}_1, \\ldots, \\mathcal{R}_n) \\) corresponding to \\( (D_1, \\ldots, D_n) \\) are given. We have \\( \\text{if}_{\\text{Rel}}(\\mathcal{I}) = \\mathcal{I}(\\mathcal{R}) \\), and hence\n\n\\[\n[P]^{DL} = \\sigma_{\\text{schema}(G')}(\\text{if}_{\\text{Rel}}(\\mathcal{I}))\n= \\sigma_{\\text{schema}(G')}(\\mathcal{I}(\\mathcal{R}))\n= \\left[\\text{formula}(G')\\right]_\\text{schema}(G')(\\mathcal{R})\n= \\bigcup_{j \\in J} \\left[\\text{formula}(C_j)\\right]_\\text{schema}(G'\\{x_i \\mapsto v_i\\})(\\mathcal{R}) .\n\\]\n\nLet \\( \\mathcal{R} = (\\mathcal{R}_1, \\ldots, \\mathcal{R}_n) \\), where \\( \\text{schema}(\\mathcal{R}_k) = (R_k[1], \\ldots, R_k[n_k]) \\). A transformed program is defined as\n\n\\[\nS^P(C_1 \\ldots C_m G) := (S^C(j, C_j))_{j \\in J} S^G(G, J)\nwhere \\quad J = \\{ j \\mid \\text{pred}(C_j) = \\text{pred}(G) \\} .\n\\]\n\nSemantics of the main function of SecreC program is\n\n\\[\n[S^G(G, J)]^{SC} = [S^G(\\text{goal}(x_1, \\ldots, x_k, y_1, \\ldots, y_\\ell)) = p(z_1, \\ldots, z_\\ell), J)]^{SC}\n= \\left[\\text{publish}(\\text{filter}(p_b, y_i))\\right]_{\\{i \\mid \\exists j \\}}^{SC}\n\\circ \\left[\\text{public bool} = \\text{declassify}(b)\\right]^{SC}\n\\circ \\left[\\left(b: \\text{private bool}, (y_i:d_i t_i)_{i \\in \\{i \\}} = \\text{unique}(\\text{shuffle}(\\text{concat}(p_j(x_1, \\ldots, x_k)_{j \\in J})))\\right)\\right]^{SC}\n\\circ \\left[(x_i : d_i t_i = \\text{argument}(\\text{\"x_i\"}))\\right]_{\\{i \\}}^{SC}\n\\]\n\nExecution of the main function starts from empty program state \\( s_0 = \\emptyset \\).\n\nOn the first line(s), the function \\text{argument} reads values \\( v_i \\) provided by the client for inputs \\( x_i \\). These correspond to the inputs \\( [x_1, \\ldots, x_k] \\) of the goal predicate. This results in program state \\( s_1 = \\{x_i \\mapsto v_i\\} \\).\n\nOn the next line, SecreC functions \\( p_j := [C_j]^{SC} \\) are executed for \\( j \\in J \\). Each function is called on the inputs \\( s_1[x_1] = v_1, \\ldots, s_1[x_k] = v_k \\), and returns outputs \\( (b_j, (w_{ji})_{i \\in Y}) \\). Applying Lemma 6 for each SecreC function constructed from a clause \\( p_j(z_1, \\ldots, z_\\ell) \\rightarrow q_{j1}, \\ldots, q_{jm} \\), with \\( \\text{vars}(q_{j1}, \\ldots, q_{jm}) = \\Gamma \\), we get\n\n\\[\n\\text{choose}((w_{ji})_{i \\in Y}, b_j) \\sim_Y (\\sigma_{z_1 = v_1, \\ldots, x_k = v_k} U_T \\cap \\{q_{j1}\\}_{1}^{DL}(\\mathcal{R}) \\cap \\cdots \\cap \\{q_{jm}\\}_{1}^{DL}(\\mathcal{R})) .\n\\]\n\nFor each \\( i \\in Y \\), the function \\text{concat} constructs a state \\( s_2 \\) such that \\( s_2[y_i] \\) is concatenation of the vectors \\( w_{ji} \\) for \\( j \\in J \\), and \\( s_2[b] \\) is concatenation of \\( b_j \\) for \\( j \\in J \\). The function \\text{shuffle} changes the order in which the solutions come, but does not change the set of solutions, and keeps relations between \\( w_{ji} \\) and \\( b_j \\). The function \\text{unique} removes duplicate solutions. This results in a state \\( s_2 \\) satisfying\n\n\\[\n\\text{choose}(s_2, s_2[b]) \\sim_Y \\bigcup_{j \\in J} (\\sigma_{z_1 = v_1, \\ldots, x_k = v_k} U_T \\cap \\{q_{j1}\\}_{1}^{DL}(\\mathcal{R}) \\cap \\cdots \\cap \\{q_{jm}\\}_{1}^{DL}(\\mathcal{R})) .\n\\]\nThe last two lines declassify values $s_2[b]$ (which keeps $s_3[b] = s_2[b]$ and $s_3[y_i] = s_2[y_i]$ for all $i \\in Y$) and send to the client solutions $s_3[y_i]$ for which the declassified bit is 1. That is, for each rule $j \\in J$, the client receives vectors that correspond to relation \\( \\choose(s_3, s_3[b]) \\sim_Y \\bigcup_{j \\in J} (\\sigma_{x_1 = v_1, \\ldots, x_k = v_k} U_P \\cap [q_j]_P^{DL}(R) \\cap \\cdots \\cap [q_jm]_P^{DL}(R)) \\)\n\n\\[\n= \\bigcup_{j \\in J} \\sigma_{x_1 = v_1, \\ldots, x_k = v_k} [\\text{formula}(C_j)]_P^{DL}(R) \\\\\n= \\bigcup_{j \\in J} [\\text{formula}(C_j)[x_i \\mapsto v_i]]_\\text{schema}(G(x_i \\mapsto v_i))(R).\n\\]\n\nThe set of published answers is thus the same as for the initial PrivaLog program.\n\n5.3 Security\n\nLet us now consider security of the resulting SecreC program. We need to estimate how much is leaked to the client who makes the query, as well as to Sharemind computing parties. Thanks to properties of SecreC, we know that the computing parties do not learn anything except what is deliberately declassified (which is the set of satisfying solutions). Informally, we are going to prove the following:\n\n1. Computing parties learn only the size of the database, and the number of satisfying solutions for $P$.\n2. The client learns only the satisfying solutions for $P$.\n\nSecurity of the resulting SecreC program is stated in Theorem 3. We base the security definition on the non-interference properties of two programs sharing common pre-agreed side-information [12]. Let $x \\sim x'$ denote that the variables $x$ and $x'$ have the same probability distribution.\n\nLemma 7. Let $P$ be a PrivaLog program with input variables $[x_1, \\ldots, x_k]$ and output variables $[y_1, \\ldots, y_l]$. Let $s$ be the final state of the execution $[S_P(P)] [v_1, \\ldots, v_k] T$, and $s'$ be the final state of the execution $[S_P(P)] [v'_1, \\ldots, v'_k] T'$, where $T$ and $T'$ have the same size. We have:\n\n1. $s[pb] \\sim s'[pb]$ for $[P] [v_1, \\ldots, v_k] T = [P] [v'_1, \\ldots, v'_k] T'$.\n2. $s[y_1] \\cdot s[pb] \\cdot \\ldots \\cdot s[y_l] \\cdot s[pb] \\sim s'[y_1] \\cdot s'[pb] \\cdot \\ldots \\cdot s'[y_l] \\cdot s'[pb]$ for $[P] [v_1, \\ldots, v_k] T = [P] [v'_1, \\ldots, v'_k] T'$.\n\nProof. We prove the statements one by one.\n\n1. Let $[P] [v_1, \\ldots, v_k] T = [P] [v'_1, \\ldots, v'_k] T'$. By Theorem 2 we also have $[S_P(P)] [v_1, \\ldots, v_k] T = [S_P(P)] [v'_1, \\ldots, v'_k] T'$. The final output is obtained after leaving only such solutions $s[y_i]_k$ that $s[b]_k = 1$. The number of such solutions is the same $m$ for $s$ and $s'$.\n\nOn the other hand, consider the value $s[pb]$. This vector is obtained after shuffling $s[b]$. The function shuffle of SecreC performs a uniform shuffle, so we have $s[pb] \\sim \\text{shuffle}([1, \\ldots, 1, 0, \\ldots, 0])$. The total number of elements in $s[pb]$ depends only on the database size, as in $S_P(P)$ we have not performed any branching based on private data. The database size is the same for $s$ and $s'$, hence, we have $s[pb] \\sim \\text{shuffle}([1, \\ldots, 1, 0, \\ldots, 0]) \\sim s'[pb]$.\n\n2. Let $[P] [v_1, \\ldots, v_k] T = [P] [v'_1, \\ldots, v'_k] T'$. By Theorem 2 we also have $[S_P(P)] [v_1, \\ldots, v_k] T = [S_P(P)] [v'_1, \\ldots, v'_k] T'$. The final output is obtained after leaving only such solutions $s[y_i]_k$ that $s[b]_k = 1$. The set of such solutions is the same $(y_{ik}, \\ldots, y_{(m-1)k})_{k \\in [m]}$ for $s$ and $s'$.\n\nOn the other hand, consider the value $s[y_1] \\cdot s[pb] \\cdot \\ldots \\cdot s[y_l] \\cdot s[pb]$. Similarly to the previous point, since function shuffle of SecreC performs a uniform shuffle, we have $s[y_i] \\cdot s[pb] \\sim \\text{shuffle}([y_{ik} \\cdot s[pb] \\cdot \\ldots \\cdot s[y_l] \\cdot s[pb]]$ for all $i \\in [l]$. \\qed\nIt suffices to show that non-interference on $pb$ is sufficient for privacy against computing parties, and non-interference on $y_1 \\cdot pb_1, \\ldots, y_n \\cdot pb_n$ is sufficient for privacy against computing parties. Let $s \\downarrow P$ denote the set of values of all variables that are visible to the party $P$.\n\n**Theorem 3 (Security).** Let $\\mathcal{P}$ be a PrivaLog program with input variables $[x_1, \\ldots, x_k]$ and output variables $[y_1, \\ldots, y_l]$. Let $s$ be the final state of the execution $[S^p(\\mathcal{P})] [v_1, \\ldots, v_k] T$, and $s'$ the final state of the execution $[S^p(\\mathcal{P})] [v_1', \\ldots, v_k'] T'$. After executing $S^p(\\mathcal{P})$ on Sharemind with computing parties $S_1, S_2, S_3$ and a client party $C$:\n\n1. $s \\downarrow S_i \\sim s' \\downarrow S_i$ for all $i \\in \\{1, 2, 3\\}$, if\n - $[[\\mathcal{P}]] [v_1, \\ldots, v_n] T = [[\\mathcal{P}]] [v_1', \\ldots, v_n] T'$;\n - the values of public variables are the same in $v_i$ and $v_i'$, $T$ and $T'$.\n2. $s \\downarrow C \\sim s' \\downarrow C$ for $[[\\mathcal{P}]] [v_1, \\ldots, v_n] T = [[\\mathcal{P}]] [v_1', \\ldots, v_n] T'$.\n\n**Proof.** We prove the statements one by one.\n\n1. The type system of SecreC ensures that only the variables that are labeled public are visible to $S_i$. In $S^p(\\mathcal{P})$, there are many more public variables than just $pb$. Let us list all of them, and show that the values of the other variables do not depend on private inputs.\n - Public constants are a part of the program, and they are always the same for $s$ and $s'$.\n - There are more public variables that get their values from an assignments. Type system of SecreC ensures that only public data can be written into public variables. In $S^p(\\mathcal{P})$, the public inputs have by assumption exactly the same values in $s$ and $s'$, and the private inputs are assigned private data type. The only way to convert a private variable to public is to use a special function declassify, and the only public variable of $S^p(\\mathcal{P})$ that gets its value in this way is $pb$. For $pb$, the claim follows directly from Lemma 4.\n - While there are no other declassify functions in $S^p(\\mathcal{P})$, the libraries of SecreC actually do contain some instances of declassify. For the SecreC functions that have been used in this paper (deduplication and count sort), it has been proven that the distribution of the public values does not depend on private inputs to which these functions are applied, and we have $s[z] \\sim s'[z]$ for all such variables $z$.\n2. In SecreC, the only function that delivers data to the client party $C$ is the function publish. In $S^p(\\mathcal{P})$, this function is not used in any of the imported libraries, and the only place where it occurs is the line $\\text{publish}(\\text{filter}(pb, y_k))_{i \\in [k]}$, which opens to the client exactly the values $s[y_i] k$ for which $s[b] k = 1$, and there are no more values opened. These values comprise a subset of $s[y_1] \\cdot s[pb], \\ldots, s[y_k] \\cdot s[pb]$. We have $s \\downarrow C \\subseteq s[y_1] \\cdot s[pb], \\ldots, s[y_k] \\cdot s[pb]$, and the claim then follows directly from Lemma 4.\n\n### 6 Implementation and Evaluation\n\nWe have implemented full PrivaLog→SecreC transformation in Haskell language. The implementation is available in GitHub repository [https://github.com/fs191/secure-logic-programming](https://github.com/fs191/secure-logic-programming). Since the Haskell tool only produces a SecreC program, an instance of Sharemind platform is needed to actually run these programs. The platform is available at [https://sharemind.cyber.ee/sharemind-mpc/](https://sharemind.cyber.ee/sharemind-mpc/). The Haskell tool is compatible with the emulator, as well as the licensed version.\n\n#### 6.1 Extensions and Optimizations\n\nIn this section, we describe some extensions and optimizations that are not covered by the basic transformation, but allow to support greater variety of input PrivaLog programs.\n\n**Expressions in predicate arguments** In PrivaLog syntax, we are assuming that the arguments in rule head are always variables. Allowing constants or expressions in place of variables does not give any additional functionality, but serves as syntactic sugar. In particular, a rule head $p(B, F) :- q$, where $B$ is a bounded argument and $F$ is a free argument, can be substituted with $p(X, Y) :- B = X, q, Y = F$, where $X$ and $Y$ are variables.\n**Aggregations** So far, we have not mentioned aggregations in the syntax and semantics of PrivaLog, and we assumed that there are no high order predicates. Adding aggregation is easy if we assume that a single aggregation is applied in the end to the bag of answers that satisfy the goal, since it requires just a single additional step in the resulting SecreC program. This functionality is supported by the implementation. If some intermediate aggregations are required, then we could treat each intermediate aggregation as a distinct program, and use the results of aggregation as an EDB table in another program. For this, instead of publishing the result to the client, the intermediate output should be stored inside Sharemind. The implementation currently does not support intermediate aggregations.\n\n**Making use of primary keys** If an IDB predicate occurs in the same rule several times, then we need to include the corresponding table several times as well, since each predicate may take a different tuple from the relation. In some cases, this leads to unnecessary overhead, both in memory and in computation. For example, if we know that the ship name is unique, then a conjunction of two predicates ship(ShipName,X1,Y1,_,_) , ship(ShipName,_,_,CargoType,CargoAmount) can be substituted with a single predicate ship(ShipName,X1,X2,CargoType,CargoAmount). To discover such places, we allow to mark one column of an EDB predicate as primary key. Whenever two EDB predicates p(PK,X1,...,Xn) and p(PK,Y1,...,Yn) with the same primary key PK are discovered in a rule body, only the first occurrence is left behind, and the second occurrence is substituted with (Y1=X1) ,...,(Yn=Xn).\n\n**Discovering Inconsistencies** In Section 4.3, a lot of new rules is being generated. These rules in general cannot be immediately evaluated, since they depend on private data that is not known in advance. However, in some cases, we may still discover inconsistencies even without having all the data. For example, if X is a private input, we do not know its exact value, but if the rule body contains conditions X > 2 and X < 1, then we can immediately understand that it never evaluates to true, and we can discard such rules during the unfolding process upon generation. In our current solution, we collect all arithmetic expressions of a rule body and transform these to an input for Z3 solver. Some expressions are not supported by the solver, and EDB calls have no meaning for Z3 as well, but as far as inconsistency is found in a subset of rule premises, the entire rule can be treated as false.\n\n**6.2 Evaluation**\n\nOur solution is based on 3-party protocol set of Sharemind, which means that we need to set up 3 servers that would run MPC protocols by exchanging messages in the network. We benchmarked our implementation on three Intel(R) Xeon(R) CPU E5-2673 v4 @ 2.30GHz servers in Azure cloud, with 1.9GB RAM running on a 100Mbps LAN. In Table 3, we present results for simpler programs to give an impression of how large datasets our solution is capable to process so far. The compilation time is the running time of the Haskell preprocessor that generates a SecreC program for Sharemind. The computation time is the time of executing that program on Sharemind using particular data.\n\n*Ship arrival time (ship_mintime.pl)* This is the running example of Section 2.2. The size of table port is fixed to 5, and the “input size” denotes the size of the ship table. The compilation time does not depend on the private data, so it is the same for any number of inputs. The times of finding the solution set and deduplication grows linearly in the number of rows in a single table. Computing the minimum takes more time since its the communication complexity is $O(n \\log(n))$ for the privacy-preserving algorithm used for finding minimum.\n\n*Ship delivered cargo (ship_sumcargo.pl)* The previous example turned out to be very slow because of the minimum aggregations. Let us show how a similar example would work with a sum aggregation, which is much simpler in terms of secure MPC, as it does not require any network communication. Let us state the query as “how much cargo of certain type arrives at a certain port within certain time?”. We need to slightly modify the rule for arrival and the goal.\narrival(Ship, Port, CargoType, CargoAmount, TimeLimit) :-\n ship(Ship, _, _, _, CargoType, CargoAmount),\n suitable_port(Ship, Port),\n reachability_time(Ship, Port, Time),\n Time < TimeLimit.\n?-sum(arrival(_, @portname, @cargotype, CargoAmount, @time), CargoAmount, SumCargo).\n\nThe time of computing the aggregation is now negligible. The bottleneck is now related to reading data from the table. The main reason is that the current solution reads string data from the table one by one, and computes CRC32 of each string in a separate round, so for 1000 rows there will be 1000 rounds of network communication. There are no theoretical issues, and the only problem is that there is no Sharemind interface for computing CRC32 as SIMD operation. A possible solution is to compute CRC32 once string data gets uploaded to Sharemind, so it will not have to be computed each time when the table is used in some computation. We defer this optimization to future work.\n\nShip delivered cargo with numeric data (ship_sumcargo_num.pl) In this example, we assume that the ship names and cargo types are numeric values, e.g., the CRC32 hashes have been computed in advance. We can now get rid of the huge overhead of preprocessing string data and get much faster execution times.\n\nFibonacci numbers (fib.pl) To demonstrate the tool from another point of view, we will try to compile a simple computation of Fibonacci numbers.\n\nfib(0, 1).\nfib(1, 1).\nfib(N, F) :-\n N > 1,\n N1 is N-1,\n N2 is N-2,\n fib(N1, F1),\n fib(N2, F2),\n F is F1+F2.\n?-fib(X,Y).\n\nThis example does not use any EDB predicates at all. Instead, it evaluates Fibonacci number on a private index. The problem here is that we need to know an upper bound on the index in order to know how many Fibonacci numbers to compute. The “input size” parameter in this experiment denotes this upper bound. In this example, we are extensively using the optimizations related to discovery of inconsistencies (described in Section 6.1). While this successfully removes redundant branches, the time nevertheless grows exponentially in the input size. There are also excessive computations of quadratic complexity in the resulting SecreC program. The problem is that the rules themselves get larger. For example, the rule that is equivalent to fib(2,2) looks like\n\nfib_bf(X_0, X_1) :-\n X_0 > 1,\n X_0 - 1 =:= 1,\n X_0 - 2 =:= 0,\n X_1 = 2.\n\nThe only satisfiable solution is \\( X_0 = 2 \\), but this is not obvious for the tool. In this particular case, we could extract the set of possible solutions from the SMT solver and rewrite the rule accordingly, but we cannot use it in a generic transformation, since in some cases it can make the result worse, e.g., if there are many satisfiable solutions. Another observation is that, due to full unfolding of the rules, we are getting repeating...\n### Table 3. Running times of different examples of logic programs\n\n<table>\n<thead>\n<tr>\n<th>program</th>\n<th>input size</th>\n<th>compilation time (s)</th>\n<th>computation time (s)</th>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td>readDB</td>\n<td>solution set</td>\n<td>deduplication</td>\n<td>aggregation</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ship_mintime.pl</td>\n<td>10</td>\n<td>< 1</td>\n<td>0.82</td>\n<td>1.6</td>\n<td>2.9</td>\n<td>15.9</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_mintime.pl</td>\n<td>100</td>\n<td>< 1</td>\n<td>2.9</td>\n<td>1.9</td>\n<td>3.1</td>\n<td>167.3</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_mintime.pl</td>\n<td>1000</td>\n<td>< 1</td>\n<td>45.3</td>\n<td>8.9</td>\n<td>10.1</td>\n<td>1672.4</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_sumcargo.pl</td>\n<td>10</td>\n<td>< 1</td>\n<td>0.8</td>\n<td>1.4</td>\n<td>1.2</td>\n<td>0.05</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_sumcargo.pl</td>\n<td>100</td>\n<td>< 1</td>\n<td>3.3</td>\n<td>2.4</td>\n<td>2.2</td>\n<td>0.03</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_sumcargo.pl</td>\n<td>1000</td>\n<td>< 1</td>\n<td>45.4</td>\n<td>8.0</td>\n<td>7.9</td>\n<td>0.04</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_sumcargo_num.pl</td>\n<td>10</td>\n<td>< 1</td>\n<td>0.58</td>\n<td>1.8</td>\n<td>1.3</td>\n<td>0.05</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_sumcargo_num.pl</td>\n<td>100</td>\n<td>< 1</td>\n<td>0.59</td>\n<td>2.0</td>\n<td>2.4</td>\n<td>0.07</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_sumcargo_num.pl</td>\n<td>1000</td>\n<td>< 1</td>\n<td>0.85</td>\n<td>7.8</td>\n<td>7.0</td>\n<td>0.04</td>\n<td></td>\n</tr>\n<tr>\n<td>ship_sumcargo_num.pl</td>\n<td>10000</td>\n<td>< 1</td>\n<td>2.5</td>\n<td>33.5</td>\n<td>24.1</td>\n<td>0.07</td>\n<td></td>\n</tr>\n<tr>\n<td>fib.pl</td>\n<td>1</td>\n<td>0.07</td>\n<td>–</td>\n<td>0.58</td>\n<td>–</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>fib.pl</td>\n<td>2</td>\n<td>0.19</td>\n<td>–</td>\n<td>0.79</td>\n<td>–</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>fib.pl</td>\n<td>3</td>\n<td>0.58</td>\n<td>–</td>\n<td>0.93</td>\n<td>–</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>fib.pl</td>\n<td>4</td>\n<td>1.3</td>\n<td>–</td>\n<td>1.5</td>\n<td>–</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>fib.pl</td>\n<td>6</td>\n<td>6.1</td>\n<td>–</td>\n<td>2.6</td>\n<td>–</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>fib.pl</td>\n<td>7</td>\n<td>11.5</td>\n<td>–</td>\n<td>4.0</td>\n<td>–</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>fib.pl</td>\n<td>8</td>\n<td>18.3</td>\n<td>–</td>\n<td>7.1</td>\n<td>–</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>fib.pl</td>\n<td>10</td>\n<td>75</td>\n<td>–</td>\n<td>18.0</td>\n<td>–</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\ncomputations in different rules, so one possible generic optimization that we could apply is merging separate rules into one by introducing disjunctions. This should be done carefully, since disjunctions may introduce non-determinism. Such optimizations are deferred to future work.\n\n### 7 Conclusion\n\nIn this paper, we have presented PrivaLog, which is a logic programming language with data privacy types. The language is accompanied with a translator to SecreC language, which allows to execute the program on Sharemind system using secure multi-party-computation. We have proven that the transformation preserves program semantics, and that the data labeled as “private” will remain confidential during the computation.\n\nWe have provided a transformation tool that makes use of several optimizations, and evaluated it on some examples. For some example programs, we can already see that there are potentially more optimizations that could be applied.\n\n### References\n\n\n"}}},{"rowIdx":198,"cells":{"id":{"kind":"string","value":"1b924b35340dd33f5c5b3bf3855104cd3f3c4bf1"},"text":{"kind":"string","value":"The KatePart Handbook\n\nThad McGinnis\nAnne-Marie Mahfouf\nAnders Lund\nT.C. Hollingsworth\nChristoph Cullmann\nLauri Watts\n# Contents\n\n1 Introduction .............................................................. 8\n\n2 Some Fundamentals .................................................. 9\n 2.1 Drag and Drop .................................................. 9\n 2.2 Shortcuts ...................................................... 9\n\n3 Working with the KatePart editor .................................... 12\n 3.1 Overview .................................................... 12\n 3.2 Navigating in the Text ...................................... 13\n 3.3 Working with the Selection ................................ 13\n 3.3.1 Using Block Selection ............................... 14\n 3.3.2 Using Overwrite Selection ....................... 14\n 3.3.3 Using Persistent Selection ....................... 14\n 3.4 Copying and Pasting Text ................................. 14\n 3.5 Finding and Replacing Text .............................. 15\n 3.5.1 The Search and Replace Bars .................. 15\n 3.5.2 Finding Text ....................................... 16\n 3.5.3 Replacing Text ................................... 16\n 3.6 Using Bookmarks ........................................... 17\n 3.7 Automatically Wrapping text ............................ 17\n 3.8 Using automatic indenting ............................ 18\n 3.9 Line Modification Indicators .......................... 18\n 3.10 The Scrollbar Minimap ................................. 19\n\n4 The Menu Entries .................................................. 20\n 4.1 The File Menu ............................................ 20\n 4.2 The Edit Menu ............................................ 21\n 4.3 The View Menu .......................................... 23\n 4.4 The Bookmarks Menu .................................. 25\n 4.5 The Tools Menu .......................................... 25\n 4.6 The Settings and Help Menu .......................... 29\n5 Advanced Editing Tools\n 5.1 Comment/Uncomment .................................................. 30\n 5.2 The Editor Component Command Line .................................. 30\n 5.2.1 Standard Command Line Commands .................................. 31\n 5.2.1.1 Commands for Configuring the Editor .............................. 31\n 5.2.1.2 Commands for editing ................................................. 32\n 5.2.1.3 Commands for navigation ............................................ 37\n 5.2.1.4 Commands for Basic Editor Functions (These depend on the applica-\n tion the editor component is used in) ................................... 37\n 5.3 Using Code Folding ..................................................... 38\n\n6 Extending KatePart\n 6.1 Introduction .............................................................. 39\n 6.2 Working with Syntax Highlighting ...................................... 39\n 6.2.1 Overview .............................................................. 39\n 6.2.2 The KatePart Syntax Highlight System ............................. 40\n 6.2.2.1 How it Works ..................................................... 40\n 6.2.2.2 Rules ............................................................ 41\n 6.2.2.3 Context Styles and Keywords .................................. 41\n 6.2.2.4 Default Styles .................................................. 41\n 6.2.3 The Highlight Definition XML Format ................................ 42\n 6.2.3.1 Overview .......................................................... 42\n 6.2.3.2 The Sections in Detail .......................................... 44\n 6.2.3.3 Available Default Styles ........................................ 46\n 6.2.4 Highlight Detection Rules .......................................... 47\n 6.2.4.1 The Rules in Detail .............................................. 49\n 6.2.4.2 Tips & Tricks ..................................................... 52\n 6.3 Scripting with JavaScript ............................................... 53\n 6.3.1 Indentation Scripts .................................................. 53\n 6.3.1.1 The Indentation Script Header .................................. 53\n 6.3.1.2 The Indenter Source Code ....................................... 54\n 6.3.2 Command Line Scripts ............................................... 55\n 6.3.2.1 The Command Line Script Header ................................ 55\n 6.3.2.2 The Script Source Code ......................................... 56\n 6.3.2.2.1 Binding Shortcuts ......................................... 57\n 6.3.3 Scripting API ........................................................ 57\n 6.3.3.1 Cursors and Ranges .............................................. 58\n 6.3.3.1.1 The Cursor Prototype .................................... 58\n 6.3.3.1.2 The Range Prototype .................................... 59\n 6.3.3.2 Global Functions ................................................ 60\n 6.3.3.2.1 Reading & Including Files ................................ 60\n 6.3.3.2.2 Debugging .................................................. 60\n 6.3.3.2.3 Translation ................................................. 61\n 6.3.3.3 The View API ..................................................... 61\n 6.3.3.4 The Document API ............................................... 62\n 6.3.3.5 The Editor API .................................................. 67\n7 Configure KatePart\n\n7.1 The Editor Component Configuration\n\n7.1.1 Appearance\n\n7.1.1.1 General\n\n7.1.1.2 Borders\n\n7.1.2 Fonts & Colors\n\n7.1.2.1 Colors\n\n7.1.2.2 Font\n\n7.1.2.3 Default Text Styles\n\n7.1.2.4 Highlighting Text Styles\n\n7.1.3 Editing\n\n7.1.3.1 General\n\n7.1.3.2 Text Navigation\n\n7.1.3.3 Indentation\n\n7.1.3.4 Auto Completion\n\n7.1.3.5 Spellcheck\n\n7.1.3.6 Vi Input Mode\n\n7.1.4 Open/Save\n\n7.1.4.1 General\n\n7.1.4.2 Advanced\n\n7.1.4.3 Modes & Filetypes\n\n7.2 Configuring With Document Variables\n\n7.2.1 How KatePart uses Variables\n\n7.2.2 Available Variables\n\n7.2.3 Extended Options in .kateconfig files\n\n8 Credits and License\n\n9 The VI Input Mode\n\n9.1 VI Input Mode\n\n9.1.1 Incompatibilities with Vim\n\n9.1.2 Switching Modes\n\n9.1.3 Integration with Kate features\n\n9.1.4 Supported normal/visual mode commands\n\n9.1.5 Supported motions\n\n9.1.6 Supported text objects\n\n9.1.7 Supported insert mode commands\n\n9.1.8 The Comma Text Object\n\n9.1.9 Missing Features\nAbstract\n\nKatePart is a fully featured editor component by KDE.\nChapter 1\n\nIntroduction\n\nKatePart is a fully featured text editor component used by many Qt™ and KDE applications. KatePart is more than a text editor; it is meant to be a programmer’s editor, and could be considered as at least a partial alternative to more powerful editors. One of KatePart’s main features is the colorized syntax, customized for many different programming languages such as: C/C++, Java™, Python, Perl, Bash, Modula 2, HTML, and Ada.\n\nKWrite is a simple text editor application based on KatePart. It has a single document interface (SDI) allowing you to edit one file at the time per window. Since KWrite is a very simple implementation of KatePart, it does not require its own documentation. If you know how to use KWrite, you can use KatePart anywhere!\nChapter 2\n\nSome Fundamentals\n\nKWrite and many other KatePart users are very simple to use. Anyone that has used a text editor should have no problems.\n\n2.1 Drag and Drop\n\nKatePart uses the KDE Drag and Drop protocol. Files may be dragged and dropped onto KatePart from the Desktop, the filemanager Dolphin, or some remote FTP site opened in one of Dolphin’s windows.\n\n2.2 Shortcuts\n\nMany of the shortcuts are configurable by way of the Settings menu. By default KatePart honors the following shortcuts:\n\n<table>\n<thead>\n<tr>\n<th>Key</th>\n<th>Action</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Ins</td>\n<td>Toggle between Insert and Overwrite mode. When in insert mode the editor will add any typed characters to the text while pushing along any data to the right of the text cursor. Overwrite mode causes the entry of each character to eliminate the character immediately to the right of the text cursor.</td>\n</tr>\n<tr>\n<td>Left</td>\n<td>Move the cursor one character to the left</td>\n</tr>\n<tr>\n<td>Right</td>\n<td>Move the cursor one character to the right</td>\n</tr>\n<tr>\n<td>Up</td>\n<td>Move the cursor up one line</td>\n</tr>\n<tr>\n<td>Down</td>\n<td>Move the cursor down one line</td>\n</tr>\n<tr>\n<td>Ctrl+E</td>\n<td>Go to previous editing line</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+E</td>\n<td>Go to next editing line</td>\n</tr>\n<tr>\n<td>Alt+Shift+Up</td>\n<td>Move cursor to previous matching indent</td>\n</tr>\n<tr>\n<td>Alt+Shift+Down</td>\n<td>Move cursor to previous matching indent</td>\n</tr>\n<tr>\n<td>Ctrl+6</td>\n<td>Move to Matching Bracket</td>\n</tr>\n<tr>\n<td>PgUp</td>\n<td>Move the cursor up one page</td>\n</tr>\n<tr>\n<td>PgDn</td>\n<td>Move the cursor down one page</td>\n</tr>\n<tr>\n<td>Home</td>\n<td>Move the cursor to the beginning of the line</td>\n</tr>\n<tr>\n<td>End</td>\n<td>Move the cursor to the end of the line</td>\n</tr>\n<tr>\n<td>-----------------</td>\n<td>----------------------------------------</td>\n</tr>\n<tr>\n<td>Ctrl+Home</td>\n<td>Move to Beginning of Document</td>\n</tr>\n<tr>\n<td>Ctrl+End</td>\n<td>Move to End of Document</td>\n</tr>\n<tr>\n<td>Ctrl+Up</td>\n<td>Scroll Line Up</td>\n</tr>\n<tr>\n<td>Ctrl+Down</td>\n<td>Scroll Line Down</td>\n</tr>\n<tr>\n<td>Ctrl+Right</td>\n<td>Move Word Right</td>\n</tr>\n<tr>\n<td>Ctrl+Left</td>\n<td>Move Word Left</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+Up</td>\n<td>Move Lines Up</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+Down</td>\n<td>Move Lines Down</td>\n</tr>\n<tr>\n<td>Ctrl+Alt+Up</td>\n<td>Duplicate Selected Lines Up</td>\n</tr>\n<tr>\n<td>Ctrl+Alt+Down</td>\n<td>Duplicate Selected Lines Down</td>\n</tr>\n<tr>\n<td>Ctrl+B</td>\n<td>Set a Bookmark</td>\n</tr>\n<tr>\n<td>Alt+PgUp</td>\n<td>Previous Bookmark</td>\n</tr>\n<tr>\n<td>Alt+PgDn</td>\n<td>Next Bookmark</td>\n</tr>\n<tr>\n<td>Del</td>\n<td>Delete the character to the right of the cursor (or any selected text)</td>\n</tr>\n<tr>\n<td>Backspace</td>\n<td>Delete the character to the left of the cursor</td>\n</tr>\n<tr>\n<td>Ctrl+Del</td>\n<td>Delete Right Word</td>\n</tr>\n<tr>\n<td>Ctrl+Backspace</td>\n<td>Delete Left Word</td>\n</tr>\n<tr>\n<td>Ctrl+K</td>\n<td>Delete Line</td>\n</tr>\n<tr>\n<td>Shift+Enter</td>\n<td>Insert newline including leading characters of the current line which are not letters or numbers. It is useful e.g. to write comments in the code: At the end of the line ‘// some text’ press this shortcut and the next line starts already with ‘//’. So you do not have to enter the comment characters at the beginning of each new line with comments.</td>\n</tr>\n<tr>\n<td>Shift+Left</td>\n<td>Mark text one character to the left</td>\n</tr>\n<tr>\n<td>Shift+Right</td>\n<td>Mark text one character to the right</td>\n</tr>\n<tr>\n<td>Ctrl+F</td>\n<td>Find</td>\n</tr>\n<tr>\n<td>F3</td>\n<td>Find Next</td>\n</tr>\n<tr>\n<td>Shift+F3</td>\n<td>Find Previous</td>\n</tr>\n<tr>\n<td>Ctrl+H</td>\n<td>Find Selected</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+H</td>\n<td>Find Selected Backwards</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+Right</td>\n<td>Select Word Right</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+Left</td>\n<td>Select Word Left</td>\n</tr>\n<tr>\n<td>Shift+Home</td>\n<td>Select to Beginning of Line</td>\n</tr>\n<tr>\n<td>Shift+End</td>\n<td>Select to End of Line</td>\n</tr>\n<tr>\n<td>Shift+Up</td>\n<td>Select to Previous Line</td>\n</tr>\n<tr>\n<td>Shift+Down</td>\n<td>Select to Next Line</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+6</td>\n<td>Select to Matching Bracket</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+PgUp</td>\n<td>Select to Top of View</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+PgDn</td>\n<td>Select to Bottom of View</td>\n</tr>\n<tr>\n<td>Shift+PgUp</td>\n<td>Select Page Up</td>\n</tr>\n<tr>\n<td>Shift+PgDn</td>\n<td>Select Page Down</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+Home</td>\n<td>Select to Beginning of Document</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+End</td>\n<td>Select to End of Document</td>\n</tr>\n<tr>\n<td>Ctrl+Home</td>\n<td>Select All</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+A</td>\n<td>Deselect</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+B</td>\n<td>Block Selection Mode</td>\n</tr>\n<tr>\n<td>Ctrl+C / Ctrl+Ins</td>\n<td>Copy the marked text to the clipboard.</td>\n</tr>\n<tr>\n<td>Ctrl+D</td>\n<td>Comment</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+D</td>\n<td>Uncomment</td>\n</tr>\n<tr>\n<td>-------------------------------</td>\n<td>----------------------------------</td>\n</tr>\n<tr>\n<td>Ctrl+G</td>\n<td>Go to line...</td>\n</tr>\n<tr>\n<td>Ctrl+I</td>\n<td>Indent selection</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+I</td>\n<td>Unindent selection</td>\n</tr>\n<tr>\n<td>Ctrl+J</td>\n<td>Join Lines</td>\n</tr>\n<tr>\n<td>Ctrl+P</td>\n<td>Print</td>\n</tr>\n<tr>\n<td>Ctrl+R</td>\n<td>Replace</td>\n</tr>\n<tr>\n<td>Ctrl+S</td>\n<td>Invokes the Save command.</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+S</td>\n<td>Save As</td>\n</tr>\n<tr>\n<td>Ctrl+U</td>\n<td>Uppercase</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+U</td>\n<td>Lowercase</td>\n</tr>\n<tr>\n<td>Ctrl+Alt+U</td>\n<td>Capitalize</td>\n</tr>\n<tr>\n<td>Ctrl+V / Shift+Ins</td>\n<td>Paste the clipboard text into line edit.</td>\n</tr>\n<tr>\n<td>Ctrl+X / Shift+Ins</td>\n<td>Delete the marked text and copy it to the clipboard.</td>\n</tr>\n<tr>\n<td>Ctrl+Z</td>\n<td>Undo</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+Z</td>\n<td>Redo</td>\n</tr>\n<tr>\n<td>Ctrl++</td>\n<td>Shrink Font</td>\n</tr>\n<tr>\n<td>Ctrl++Ctrl+=</td>\n<td>Enlarge Font</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+-</td>\n<td>Fold Toplevel Nodes</td>\n</tr>\n<tr>\n<td>Ctrl+Shift++</td>\n<td>Unfold Toplevel Nodes</td>\n</tr>\n<tr>\n<td>Ctrl+Space</td>\n<td>Invoke Code Completion</td>\n</tr>\n<tr>\n<td>F5</td>\n<td>Reload</td>\n</tr>\n<tr>\n<td>F6</td>\n<td>Show/Hide Icon Border</td>\n</tr>\n<tr>\n<td>F7</td>\n<td>Switch to Command Line</td>\n</tr>\n<tr>\n<td>F9</td>\n<td>Show/Hide Folding Markers</td>\n</tr>\n<tr>\n<td>F10</td>\n<td>Dynamic Word Wrap</td>\n</tr>\n<tr>\n<td>F11</td>\n<td>Show/Hide Line Numbers</td>\n</tr>\n<tr>\n<td>Ctrl+T</td>\n<td>Transpose Characters</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+O</td>\n<td>Automatic Spell Checking</td>\n</tr>\n<tr>\n<td>Ctrl+Shift+V</td>\n<td>Switch to Next Input Mode</td>\n</tr>\n<tr>\n<td>Ctrl+8</td>\n<td>Reuse Word Above</td>\n</tr>\n<tr>\n<td>Ctrl+9</td>\n<td>Reuse Word Below</td>\n</tr>\n<tr>\n<td>Ctrl+Alt+#</td>\n<td>Expand Abbreviation</td>\n</tr>\n</tbody>\n</table>\nChapter 3\n\nWorking with the KatePart editor\n\nAnders Lund\nDominik Haumann\n\n3.1 Overview\n\nThe KatePart editor is the editing area of the KatePart window. This editor is shared between Kate and KWrite, and it can also be used in Konqueror for displaying text files from your local computer, or from the network.\n\nThe editor is composed of the following components:\n\nThe editing area\nThis is where the text of your document is located.\n\nThe Scrollbars\nThe scrollbars indicate the position of the visible part of the document text, and can be used to move around the document. Dragging the scrollbars will not cause the insertion cursor to be moved.\nThe scrollbars are displayed and hidden as required.\n\nThe Icon Border\nThe icon border is a small pane on the left side of the editor, displaying a small icon next to marked lines.\nYou can set or remove a bookmark in a visible line by clicking the left mouse button in the icon border next to that line.\nThe display of the icon border can be toggled using the View → Show Icon Border menu item.\n\nThe Line Numbers Pane\nThe Line numbers pane shows the line numbers of all visible lines in the document.\nThe display of the Line Numbers Pane can be toggled using the View → Show Line Numbers menu item.\n\nThe Folding Pane\nThe folding pane allows you to collapse or expand foldable blocks of lines. The calculation of the foldable regions is done according to rules in the syntax highlight definition for the document.\n3.2 Navigating in the Text\n\nMoving around in the text in KatePart is similar to most graphical text editors. You move the cursor using the arrow keys and the Page Up, Page Down, Home and End keys in combination with the Ctrl and Shift modifiers. The Shift key is always used to generate a selection, while the Ctrl key has different effects on different keys:\n\n- For the Up and Down keys it means scroll rather than move the cursor.\n- For the Left and Right keys it means skip words rather than characters.\n- For the Page Up and Page Down keys it means move to the visible edge of the view rather than browse.\n- For the Home and End keys it means move to the beginning or end of the document rather than the beginning or end of the line.\n\nKatePart also provides you with a way to quickly jump to a matching brace or parenthesis: place the cursor on the inside of a parenthesis or brace character, and press Ctrl+6 to jump to the matching parenthesis or brace.\n\nIn addition you can use bookmarks to quickly jump to positions that you define on your own.\n\n3.3 Working with the Selection\n\nThere are two basic ways of selecting text in KatePart: using the mouse, and using the keyboard.\n\nTo select using the mouse, hold down the left mouse button while dragging the mouse cursor from where the selection should start, to the desired end point. The text gets selected as you drag.\n\nDouble-clicking a word will select that word.\n\nTriple-clicking in a line will select the entire line.\n\nIf Shift is held down while clicking, text will be selected:\n\n- If nothing is already selected, from the text cursor position to the mouse cursor position.\n- If there is a selection, from and including that selection to the mouse cursor position.\nNOTE\nWhen selecting text by dragging the mouse, the selected text is copied to the clipboard, and can be\npasted by clicking the middle mouse button in the editor, or in any other application to which you want\nto paste the text.\n\nTo select using the keyboard, hold down the **Shift** key while using the navigation keys (Arrow\nkeys, **Page Up**, **Page Down**, **Home** and **End**, possibly in combination with **Ctrl** to extend the\nmove of the text cursor).\n\nSee also the section *Navigating in the Text* in this chapter.\n\nTo Copy the current selection, use the **Edit → Copy** menu item or the keyboard shortcut (defaults\nto **Ctrl+C**).\n\nTo Deselect the current selection, use the **Edit → Deselect** menu item, or the keyboard shortcut\ndefault is **Ctrl+Shift+A**), or click with the left mouse button in the editor.\n\n### 3.3.1 Using Block Selection\n\nWhen Block Selection is enabled, you can make ‘vertical selections’ in the text, meaning selecting\nlimited columns from multiple lines. This is handy for working with tab separated lines for\nexample.\n\nBlock Selection can be toggled using the **Edit → Block Selection Mode** menu item. The default\nkeyboard shortcut is **Ctrl+Shift+B**.\n\n### 3.3.2 Using Overwrite Selection\n\nIf Overwrite Selection is enabled, typing or pasting text into the selection will cause the selected\ntext to be replaced. If not enabled, new text will be added at the position of the text cursor.\n\nOverwrite Selection is enabled by default.\n\nTo change the setting for this option, use the **Cursor & Selection** page of the **Configuration Dialog**.\n\n### 3.3.3 Using Persistent Selection\n\nWhen Persistent Selection is enabled, typing characters or moving the cursor will not cause the\nSelection to become deselected. This means that you can move the cursor away from the selection\nand type text.\n\nPersistent Selection is disabled by default.\n\nPersistent Selection can be enabled in the **Cursor & Selection** page of the **Configuration Dialog**.\n\n**WARNING**\nIf Persistent Selection and Overwrite Selection are both enabled, typing or pasting text when the text\ncursor is inside the selection will cause it to be replaced and deselected.\n\n### 3.4 Copying and Pasting Text\n\nTo copy text, select it and use the **Edit → Copy** menu item. Additionally, selecting text with the\nmouse will cause selected text to be copied to the X selection.\n\nTo paste the text currently in the clipboard, use the **Edit → Paste** menu item.\n\nAdditionally, text selected with the mouse may be pasted by clicking the middle mouse button\nat the desired position.\nThe KatePart Handbook\n\n**Tip**\nIf you are using the KDE desktop, you can retrieve earlier copied text from any application using the Klipper icon in the system tray.\n\n### 3.5 Finding and Replacing Text\n\n#### 3.5.1 The Search and Replace Bars\n\nKatePart has an incremental search bar and a power search and replace bar, which offers the means of entering a replacement string along with a few extra options.\n\nThe bars offer the following common options:\n\n- **Find**\n - This is where to enter the search string. The interpretation of the string depends on some of the options described below.\n\n- **Match case**\n - If enabled, the search will be limited to entries that match the case (upper or lower) of each of the characters in the search pattern.\n\nThe power search and replace bar offers some additional options:\n\n- **Plain Text**\n - Literally match any occurrence of the search string.\n\n- **Whole Words**\n - If selected, the search will only match if there is a word boundary at both ends of the string matching, meaning not an alphanumeric character - either some other visible character or a line end.\n\n- **Escape Sequences**\n - If selected, the Add menuitem at the bottom of the context menu of the text boxes will be enabled and allows you to add escape sequences to the search pattern from a predefined list.\n\n- **Regular Expression**\n - If selected, the search string is interpreted as a regular expression. The Add menuitem at the bottom of the context menu of the text boxes will be enabled and allows you to add regular expression items to the search pattern from a predefined list.\n \n See [Regular Expressions](#) for more on these.\n\n- **Search in the selection only**\n - If checked, the search and replace will be performed within the selected text only.\n\n- **Find all**\n - Clicking this button highlights all matches in the document and shows the number of found matches in a small popup.\n3.5.2 Finding Text\n\nTo find text, launch the incremental search bar with Ctrl+F or from the Edit → Find... menu item. This opens the incremental search bar at the bottom of the editor window. On the left side of the bar is a button with an icon to close the bar, followed by a small text box for entering the search pattern.\n\nWhen you start entering the characters of your search pattern, the search starts immediately. If there is a match in the text this is highlighted and the background color of the entry field changes to light green. If the search pattern does not match any string in the text, this is indicated by a light red background color of the entry field.\n\nUse the or button to jump to the next or previous match in the document.\n\nMatches in the document are highlighted even when you close the search bar. To clear this highlighting, press the Esc key.\n\nYou can choose whether the search should be case sensitive. Selecting will limit finds to entries that match the case (upper or lower) of each of the characters in the search pattern.\n\nClick on the button at the right side of the incremental search bar to switch to the power search and replace bar.\n\nTo repeat the last find operation, if any, without calling the incremental search bar, use Edit → Find Next (F3) or Edit → Find Previous (Shift+F3).\n\n3.5.3 Replacing Text\n\nTo replace text, launch the power search and replace bar using the Edit → Replace command, or the Ctrl+R shortcut.\n\nOn the upper left side of the bar is a button with an icon to close the bar, followed by a small text box for entering the search pattern.\n\nYou can control the search mode by selecting the options Plain Text, Whole Words, Escape Sequences or Regular Expression from the drop down box.\n\nIf Escape sequences or Regular expression are selected, the Add... menu item at the bottom of the context menu of the text boxes will be enabled and allows you to add escape sequences or regular expression items to the search or replace pattern from predefined lists.\n\nUse the or button to jump to the next or previous match in the document.\n\nEnter the text to replace with in the text box labeled Replace and click the Replace button to replace only the highlighted text or the Replace All button to replace the search text in the whole document.\n\nYou can modify the search and replace behavior by selecting different options at the bottom of the bar. Selecting will limit finds to entries that match the case (upper or lower) of each of the characters in the search pattern. will search and replace within the current selection only. The Find All button highlights all matches in the document and shows the number of found matches in a small popup.\n\nClick on the button at the right side of the power search and replace bar to switch to the incremental search bar.\n3.6 Using Bookmarks\n\nThe bookmarks feature allows you to mark certain lines, to be able to easily find them again. You can set or remove a bookmark in a line in two ways:\n\n- Move the insertion cursor to the line and activate the Bookmarks → Set Bookmark (Ctrl+B) command.\n- Click in the Icon Border next to the line.\n\nBookmarks are available in the Bookmarks menu. The individual bookmarks are available as menu items, labeled with the line number of the line with the bookmark, and the first few characters of the text in the line. To move the insertion cursor to the beginning of a bookmarked line, open the menu and select the bookmark.\n\nTo quickly move between bookmarks or to the next/previous bookmark, use the Bookmarks → Next (Alt+PgDown) or Bookmarks → Previous (Alt+PgUp) commands.\n\n3.7 Automatically Wrapping text\n\nThis feature allows you to have the text formatted in a very simple way: the text will be wrapped, so that no lines exceed a maximum number of characters per line, unless there is a longer string of non-whitespace characters.\n\nTo enable/disable it, check/uncheck the Static Word Wrap checkbox in the edit page of the configuration dialog.\n\nTo set the maximum line width (maximum characters per line), use the Wrap Words At option in the Editing page of the configuration dialog.\n\nIf enabled, it has the following effects:\n\n- While typing, the editor will automatically insert a hard line break after the last whitespace character at a position before the maximum line width is reached.\n- While loading a document, the editor will wrap the text in a similar way, so that no lines are longer than the maximum line width, if they contain any whitespace allowing that.\n\n**Notice**\n\nThere is currently no way to set word wrap for document types, or even to enable or disable the feature on a per document level. This will be fixed in a future version of KatePart.\n3.8 Using automatic indenting\n\nKatePart's editor component supports a variety of autoindenting modes, designed for different text formats. You can pick from the available modes using the Tools → Indentation menu. The autoindent modules also provide a function Tools → Align which will recalculate the indentation of the selected or current line. Thus, you may reindent your entire document by selecting all the text and activating that action.\n\nAll the indent modes use the indentation related settings in the active document.\n\n<table>\n<thead>\n<tr>\n<th>Available Autoindent Modes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>None</td>\n</tr>\n<tr>\n<td>Selecting this mode turns automatic indenting off entirely.</td>\n</tr>\n<tr>\n<td>Normal</td>\n</tr>\n<tr>\n<td>This indenter simply keeps the indentation similar to the previous line with any content other than whitespace. You can combine this with using the indent and unindent actions for indenting to your own taste.</td>\n</tr>\n<tr>\n<td>C Style</td>\n</tr>\n<tr>\n<td>An indenter for C and similar languages, such as C++, C#, java, javascript and so on. This indenter will not work with scripting languages such as Perl or PHP.</td>\n</tr>\n<tr>\n<td>Haskell</td>\n</tr>\n<tr>\n<td>An indenter for the functional programming language Haskell.</td>\n</tr>\n<tr>\n<td>Lilypond</td>\n</tr>\n<tr>\n<td>An indenter for the Lilypond notation language for music.</td>\n</tr>\n<tr>\n<td>Lisp</td>\n</tr>\n<tr>\n<td>An indenter specifically for the Lisp scripting language and Lisp dialects.</td>\n</tr>\n<tr>\n<td>Python</td>\n</tr>\n<tr>\n<td>An indenter specifically for the python scripting language.</td>\n</tr>\n<tr>\n<td>XML Style</td>\n</tr>\n<tr>\n<td>An indenter specifically for XML like languages.</td>\n</tr>\n</tbody>\n</table>\n\n3.9 Line Modification Indicators\n\nKatePart’s line modification indicators let you easily see what you have recently changed in a file. By default, saved changes are indicated by a green bar to the left of a document, while unsaved changes are indicated by an orange bar.\nThe KatePart Handbook\n\n```c++\n// new block for empty buffer I write new stuff HERE\nandNewStuffHere = 1;\nif (newLineChangedAgain)\n lala();\nmore = 1;\naftersaveEdited();\n\nTextBlock *newBlock = new TextBlock (this, 0);\nnewBlock->appendLine (TextLine (new TextLineData()));\n```\n\n**Line Modification Indicators in action.**\n\nYou can change the colors used in the **Fonts & Colors** configuration panel, or you can disable this feature completely in the **Borders** tab of the **Appearance** configuration panel.\n\n### 3.10 The Scrollbar Minimap\n\nKatePart’s Scrollbar Minimap displays a preview of documents in place of the scrollbar. The currently visible portion of the document is highlighted.\n\n*The Scrollbar Minimap shows a preview of the Kate source code.*\n\nYou can temporarily enable or disable the minimap by selecting **View → View Scrollbar Minimap** or permanently in the Appearance section of KatePart’s configuration.\nChapter 4\n\nThe Menu Entries\n\n4.1 The File Menu\n\nFile → New (Ctrl+N)\nThis starts a new document in a new and independent editor window.\n\nFile → Open... (Ctrl+O)\nDisplays a standard KDE Open File dialog. Use the file view to select the file you want to open, and click on Open to open it.\n\nFile → Open Recent\nThis is a shortcut to open recently saved documents. Clicking on this item opens a list to the side of the menu with several of the most recently saved files. Clicking on a specific file will open it in KatePart - if the file still resides at the same location.\n\nFile → Save (Ctrl+S)\nThis saves the current document. If there has already been a save of the document then this will overwrite the previously saved file without asking for the user’s consent. If it is the first save of a new document the save as dialog (described below) will be invoked.\n\nFile → Save As... (Ctrl+Shift+S)\nThis allows a document to be saved with a new file name. This is done by means of the file dialog box described above in the Open section of this help file.\n\nFile → Save As with Encoding\nSave a document with a new file name in a different encoding.\n\nFile → Save Copy As\nSave a copy of the document with a new file name and continue editing the original document.\n\nFile → Reload (F5)\nReloads the active file from disk. This command is useful if another program or process has changed the file while you have it open in KatePart.\n\nFile → Print... (Ctrl+P)\nOpens a simple print dialog allowing the user to specify what, where, and how to print.\nFile → Export as HTML\nSave the currently open document as an HTML file, which will be formatted using the current syntax highlighting and color scheme settings.\n\nFile → Close (Ctrl+W)\nClose the active file with this command. If you have made unsaved changes, you will be prompted to save the file before KatePart closes it.\n\nFile → Quit (Ctrl+Q)\nThis will close the editor window, if you have more than one instance of KatePart running, through the New or New Window menu items, those instances will not be closed.\n\n4.2 The Edit Menu\n\nEdit → Undo (Ctrl+Z)\nUndo the last editing command (typing, copying, cutting etc.)\n\nNOTE\nThis may undo several editing commands of the same type, like typing in characters.\n\nEdit → Redo (Ctrl+Shift+Z)\nThis will reverse the most recent change (if any) made using Undo\n\nEdit → Cut (Ctrl+X)\nThis command deletes the current selection and places it on the clipboard. The clipboard works invisibly and provides a way to transfer data between applications.\n\nEdit → Copy (Ctrl+C)\nThis copies the currently selected text to the clipboard so that it may be pasted elsewhere. The clipboard works invisibly and provides a way to transfer data between applications.\n\nEdit → Paste (Ctrl+V)\nThis will insert the first item in the clipboard at the cursor position. The clipboard works invisibly and provides a way to transfer data between applications.\n\nNOTE\nIf Overwrite Selection is enabled, the pasted text will overwrite the selection, if any.\n\nEdit → Clipboard History\nThis submenu will display the beginning of portions of text recently copied to the clipboard. Select an item from this menu to paste it in the currently open file.\n\nEdit → Copy as HTML\nCopy the selection as HTML, formatted using the current syntax highlighting and color scheme settings.\n\nEdit → Select All (Ctrl+A)\nThis will select the entire document. This could be very useful for copying the entire file to another application.\n\nEdit → Deselect (Ctrl+Shift+A)\nDeselects the selected text in the editor if any.\nThe KatePart Handbook\n\n**Edit → Block Selection Mode (Ctrl+Shift+B)**\n\nToggles Selection Mode. When the Selection Mode is **BLOCK**, the status bar contains the string `[BLOCK]` and you can make vertical selections, e.g. select column 5 to 10 in lines 9 to 15.\n\n**Edit → Input Modes**\n\nSwitch between a normal and a vi-like, modal editing mode. The vi input mode supports the most used commands and motions from vim's normal and visual mode and has an optional vi mode statusbar. This status bar shows commands while they are being entered, output from commands and the current mode. The behavior of this mode can be configured in the **Vi Input Mode** tab of the **Editing** page in KatePart’s settings dialog.\n\n**Edit → Overwrite Mode (Ins)**\n\nToggles the Insert/Overwrite modes. When the mode is **INS**, you insert characters where the cursor is. When the mode is **OVR**, writing characters will replace the current characters if your cursor is positioned before any character. The status bar shows the current state of the Overwrite Mode, either **INS** or **OVR**.\n\n**Edit → Find... (Ctrl+F)**\n\nThis opens the incremental search bar at the bottom of the editor window. On the left side of the bar is a button with an icon to close the bar, followed by a small text box for entering the search pattern.\n\nWhen you start entering characters of your search pattern, the search starts immediately. If there is a match in the text this is highlighted and the background color of the entry field changes to light green. If the search pattern does not match any string in the text, this is indicated by a light red background color of the entry field.\n\nUse the `←` or `→` button to jump to the next or previous match in the document.\n\nMatches in the document are highlighted even when you close the search bar. To clear this highlighting, press the `Esc` key.\n\nYou can choose whether the search should be case sensitive. Selecting `A` will limit finds to entries that match the case (upper or lower) of each of the characters in the search pattern.\n\nClick on the `←` button at the right side of the incremental search bar to switch to the power search and replace bar.\n\n**Edit → Find Variants → Find Next (F3)**\n\nThis repeats the last find operation, if any, without calling the incremental search bar, and searching forwards through the document starting from the cursor position.\n\n**Edit → Find Variants → Find Previous (Shift+F3)**\n\nThis repeats the last find operation, if any, without calling the incremental search bar, and searching backwards instead of forwards through the document.\n\n**Edit → Find Variants → Find Selected (Ctrl+H)**\n\nFinds next occurrence of selected text.\n\n**Edit → Find Variants → Find Selected Backwards (Ctrl+Shift+H)**\n\nFinds previous occurrence of selected text.\n\n**Edit → Replace... (Ctrl+R)**\n\nThis command opens the power search and replace bar. On the upper left side of the bar is a button with an icon to close the bar, followed by a small text box for entering the search pattern.\n\nYou can control the search mode by selecting **Plain text**, **Whole words**, **Escape sequences** or **Regular expression** from the drop down box.\nThe KatePart Handbook\n\nIf Escape sequences or Regular expression are selected, the Add... menuitem at the bottom of the context menu of the text boxes will be enabled and allows you to add escape sequences or regular expression items to the search or replace pattern from predefined lists.\n\nUse the or button to jump to the next or previous match in the document. Enter the text to replace with in the text box labeled Replace and click the Replace button to replace only the highlighted text or the Replace All button to replace the search text in the whole document.\n\nYou can modify the search and replace behavior by selecting different options at the bottom of the bar. Selecting will limit finds to entries that match the case (upper or lower) of each of the characters in the search pattern. will search and replace within the current selection only. The Find All button highlights all matches in the document and shows the number of found matches in a small popup.\n\nClick on the button at the right side of the power search and replace bar to switch to the incremental search bar.\n\n**Edit → Go To → Move to Matching Bracket (Ctrl+6)**\nMove the cursor to the associated opening or closing bracket.\n\n**Edit → Go To → Select to Matching Bracket (Ctrl+Shift+6)**\nSelects the text between associated opening and closing brackets.\n\n**Edit → Go To → Move to Previous Modified Line**\nLines that were changed since opening the file are called modified lines. This action jumps the previous modified line.\n\n**Edit → Go To → Move to Next Modified Line**\nLines that were changed since opening the file are called modified lines. This action jumps the next modified line.\n\n**Edit → Go To → Go to Line... (Ctrl+G)**\nThis opens the goto line bar at the bottom of the window which is used to have the cursor jump to a particular line (specified by number) in the document. The line number may be entered directly into the text box or graphically by clicking on the up or down arrow spin controls at the side of the text box. The little up arrow will increase the line number and the down arrow decrease it. Close the bar with a click on the button with an icon on the left side of the bar.\n\n### 4.3 The View Menu\n\n**View → New Window**\nCreate another window containing the current document. All changes to the document in one window are reflected in the other window and vice versa.\n\n**View → Switch to Command Line (F7)**\nDisplays the KatePart command line at the bottom of the window. In the command line, type help to get help and help list to get a list of commands. For more information on the command line, see The Editor Component Command Line.\n\n**View → Enlarge Font (Ctrl++)**\nThis increases the display font size.\nView → Shrink Font (Ctrl+-)\n This decreases the display font size.\n\nView → Schema\n This menu lists the available color schemes. You can change the schema for the current\n view here, to change the default schema you need to use the Fonts & Colors page of the\n config dialog.\n\nView → Word Wrap → Dynamic Word Wrap (F10)\n Toggles dynamic word wrap in the current view. Dynamic word wrap makes all the text\n in a view visible without the need for horizontal scrolling by rendering one actual line on\n more visual lines as needed.\n\nView → Word Wrap → Dynamic Word Wrap Indicators\n Choose when and how the dynamic word wrap indicators should be displayed. This is\n only available if the Dynamic Word Wrap option is checked.\n\nView → Word Wrap → Show Static Word Wrap Marker\n If this option is checked, a vertical line will be drawn at the word wrap column as defined\n in the Settings → Configure Editor... in the Editing tab. Please note that the word wrap\n marker is only drawn if you use a fixed pitch font.\n\nView → Borders → Show Icon Border (F6)\n This is a toggle item. Setting it on checked will make the Icon Border visible in the left side\n of the active editor, and vice versa. The Icon Border indicates the positions of the marked\n lines in the editor.\n\nView → Borders → Show Line Numbers (F11)\n This is a toggle Item. Setting it on checked will make a pane displaying the line numbers of\n the document visible in the left border of the active editor, and vice versa.\n\nView → Borders → Show Scrollbar Marks\n If this option is checked, the view will show marks on the vertical scrollbar. The marks are\n equivalent to the marks on the Icon Border.\n\nView → Borders → Show Scrollbar Mini-Map\n This will replace the scrollbar with a visualization of the current document. For more infor-\n mation on the scrollbar minimap, see Section 3.10\n\nView → Code Folding\n These options pertain to code folding:\n\n Show Folding Markers (F9)\n Toggles the display of the folding marker pane in the left side of the view.\n\n Fold Current Node\n Collapse the region that contains the cursor.\n\n Unfold Current Node\n Expand the region that contains the cursor.\n\n Fold Toplevel Nodes (Ctrl+Shift+-)\n Collapse all toplevel regions in the document. Click on the right pointing triangle to\n expand all toplevel regions.\n\n Unfold Toplevel Nodes (Ctrl+Shift++)\n Expand all toplevel regions in the document.\n\nShow Non-Printable Spaces\n Show/hide bounding box around non-printable spaces.\n4.4 The Bookmarks Menu\n\nBelow the entries described here, one entry for each bookmark in the active document will be available. The text will be the first few words of the marked line. Choose an item to move the cursor to the start of that line. The editor will scroll as necessary to make that line visible.\n\n**Bookmarks → Set Bookmark (Ctrl+B)**\nSets or removes a bookmark in the current line of the active document. (If it’s there, it is removed, otherwise one is set.)\n\n**Bookmarks → Clear All Bookmarks**\nThis command will remove all the markers from the document as well as the list of markers which is appended at the bottom of this menu item.\n\n**Bookmarks → Previous (Alt+PgUp)**\nThis will move the cursor to beginning of the first above line with a bookmark. The menu item text will include the line number and the first piece of text on the line. This item is only available when there is a bookmark in a line above the cursor.\n\n**Bookmarks → Next (Alt+PgDown)**\nThis will move the cursor to beginning of the next line with a bookmark. The menu item text will include the line number and the first piece of text on the line. This item is only available when there is a bookmark in a line below the cursor.\n\n4.5 The Tools Menu\n\n**Tools → Read Only Mode**\nSet the current document to Read Only mode. This prevents any text addition and any changes in the document formatting.\n\n**Tools → Mode**\nChoose the filetype scheme you prefer for the active document. This overwrites the global filetype mode set in Settings → Configure Editor... in the Filetypes tab for your current document only.\n\n**Tools → Highlighting**\nChoose the Highlighting scheme you prefer for the active document. This overwrites the global highlighting mode set in Settings → Configure Editor... for your current document only.\n\n**Tools → Indentation**\nChoose the style of indentation you want for your active document. This overwrites the global indentation mode set in Settings → Configure Editor... for your current document only.\n\n**Tools → Encoding**\nYou can overwrite the default encoding set in Settings → Configure Editor... in the Open/Save page to set a different encoding for your current document. The encoding you set here will be only valid for your current document.\n\n**Tools → End of Line**\nChoose your preferred end of line mode for your active document. This overwrites the global end of line mode set in Settings → Configure Editor... for your current document only.\nTools → Add Byte Mark Order (BOM)\nChecking this action you can explicitly add a byte order mark for unicode encoded documents. The byte order mark (BOM) is a Unicode character used to signal the endianness (byte order) of a text file or stream, for more information see Byte Order Mark.\n\nTools → Scripts\nThis submenu contains a list of all scripted actions. The list can easily be modified by writing your own scripts. This way, KatePart can be extended with user-defined tools.\n\nTools → Scripts → Navigation\n- Tools → Scripts → Navigation → Move cursor to previous matching indent (Alt+Shift+Up)\n Moves the cursor to the first line above the current line that is indented at the same level as the current line.\n- Tools → Scripts → Navigation → Move cursor to next matching indent (Alt+Shift+Down)\n Moves the cursor to the first line below the current line that is indented at the same level as the current line.\n\nTools → Scripts → Editing\n- Tools → Scripts → Editing → Sort Selected Text\n Sorts the selected text or whole document in ascending order.\n- Tools → Scripts → Editing → Move Lines Down (Ctrl+Shift+Down)\n Move selected lines down.\n- Tools → Scripts → Editing → Move Lines Up (Ctrl+Shift+Up)\n Move selected lines up.\n- Tools → Scripts → Editing → Duplicate Selected Lines Down (Ctrl+Alt+Down)\n Duplicates the selected lines down.\n- Tools → Scripts → Editing → Duplicate Selected Lines Up (Ctrl+Alt+Up)\n Duplicates the selected lines up.\n- Tools → Scripts → Editing → URI-encode selected text\n Encodes the selected text so that it can be used as part of a query string in a URL, replacing the selection with the encoded text.\n- Tools → Scripts → Editing → URI-decode selected text\n If part of the query string of a URL is selected, this will decode it and replace the selection with the original raw text.\n\nTools → Scripts → Emmet\n- Tools → Scripts → Emmet → Expand abbreviation\n Converts the selected text to a pair of opening and closing HTML or XML tags. For example, if \\texttt{div} is selected, this item will replace that with \\texttt{<div></div>.\n- Tools → Scripts → Emmet → Wrap with tag\n Wraps the selected text with the tag provided on the command line.\n- Tools → Scripts → Emmet → Move cursor to matching tag\n If the cursor is inside an opening HTML/XML tag, this item will move it to the closing tag. If the cursor is inside the closing tag, it will instead move it to the opening tag.\n- Tools → Scripts → Emmet → Select HTML/XML tag contents inwards\n When the cursor is inside a pair of HTML/XML tags, this option will change the selection to include the contents of those HTML/XML tags, without selecting the tags themselves.\n- Tools → Scripts → Emmet → Select HTML/XML tag contents outwards\n When the cursor is inside a pair of HTML/XML tags, this item will change the selection to include the contents of those HTML/XML tags, including the tags themselves.\n- Tools → Scripts → Emmet → Toggle Comment\n If the selected portion is not a comment, this item will enclose that portion in HTML/XML comments (e.g. \\texttt{<!-- selected text -->}). If the selected portion is a comment, the comment tags will be removed instead.\nTools → Scripts → Emmet → Delete tag under cursor\nIf the cursor is presently inside a HTML/XML tag, this item will delete the entire tag.\n\nTools → Scripts → Emmet → Decrement number by 1\nThis item will subtract one from the currently selected text, if it is a number. For example, if 5 is selected, it will become 4.\n\nTools → Scripts → Emmet → Decrement number by 10\nThis item will subtract 10 from the currently selected text, if it is a number. For example, if 15 is selected, it will become 5.\n\nTools → Scripts → Emmet → Decrement number by 0.1\nThis item will subtract 0.1 from the currently selected text, if it is a number. For example, if 4.5 is selected, it will become 4.4.\n\nTools → Scripts → Emmet → Increment number by 1\nThis item will add one to the currently selected text, if it is a number. For example, if 5 is selected, it will become 6.\n\nTools → Scripts → Emmet → Increment number by 10\nThis item will add 10 to the currently selected text, if it is a number. For example, if 5 is selected, it will become 15.\n\nTools → Scripts → Emmet → Increment number by 0.1\nThis item will add 0.1 to the currently selected text, if it is a number. For example, if 4.5 is selected, it will become 4.6.\n\nTools → Invoke Code Completion (Ctrl+Space)\nManually invoke command completion, usually by using a shortcut bound to this action.\n\nTools → Word Completion\nReuse Word Below (Ctrl+9) and Reuse Word Above (Ctrl+8) complete the currently typed text by searching for similar words backward or forward from the current cursor position. Shell Completion pops up a completion box with matching entries.\n\nTools → Spelling → Automatic Spell Checking (Ctrl+Shift+O)\nWhen Automatic Spell Checking is enabled, wrongly spelled text is underlined in the document on-the-fly.\n\nTools → Spelling → Spelling...\nThis initiates the spellchecking program - a program designed to help the user catch and correct any spelling errors. Clicking on this entry will start the checker and bring up the speller dialog box through which the user can control the process. There are four settings lined up vertically in the center of the dialog with their corresponding labels just to the left. Starting at the top they are:\n\nUnknown word:\nHere, the spellchecker indicates the word currently under consideration. This happens when the checker encounters a word not in its dictionary - a file containing a list of correctly spelled words against which it compares each word in the editor.\n\nReplace with:\nIf the checker has any similar words in its dictionary the first one will be listed here. The user can accept the suggestion, type in his or her own correction, or choose a different suggestion from the next box.\n\nLanguage:\nIf you have installed multiple dictionaries, here you can select which dictionary/language should be used.\n\nOn the right side of the dialog box are 6 buttons that allow the user to control the spellcheck process. They are:\nAdd to Dictionary\nPressing this button adds the **Unknown word** to the checker’s dictionary. This means that in the future the checker will always consider this word to be correctly spelled.\n\nSuggest\nThe checker may list here a number of possible replacements for the word under consideration. Clicking on any one of the suggestions will cause that word to be entered in the **Replace with** box, above.\n\nReplace\nThis button has the checker replace the word under consideration in the document with the word in the **Replace with** box.\n\nReplace All\nThis button causes the checker to replace not only the current **Unknown word**: but to automatically make the same substitution for any other occurrences of this **Unknown word** in the document.\n\nIgnore\nActivating this button will have the checker move on without making any changes.\n\nIgnore All\nThis button tells the checker to do nothing with the current **Unknown word**: and to pass over any other instances of the same word.\n\nThree more buttons are located horizontally along the bottom of the spellcheck dialog. They are:\n\nHelp\nThis invokes the KDE help system with the help page for this dialog.\n\nFinished\nThis button ends the spellcheck process, and returns to the document.\n\nCancel\nThis button cancels the spellcheck process, all modifications are reverted, and you will return to your document.\n\nTools → Spelling → Spelling (from cursor)...\nThis initiates the spellchecking program but it starts where your cursor is instead of at the beginning of the document.\n\nTools → Spelling → Spellcheck Selection...\nSpellchecks the current selection.\n\nTools → Spelling → Change Dictionary\nDisplays a drop down box with all available dictionaries for spellchecking at the bottom of the editor window. This allows easy switching of the spellcheck dictionary e.g. for automatic spellcheck of text in different languages.\n\nTools → Clean Indentation\nThis cleans the indentation for the current selection or for the line the cursor is currently in. Cleaning the indentation ensures that all your selected text follows the indentation mode you choose.\n\nTools → Align\nCauses a realign of the current line or selected lines using the indentation mode and indentation settings in the document.\nTools → Comment (Ctrl+D)\nThis adds one space to the beginning of the line where the text cursor is located or to the beginning of any selected lines.\n\nTools → Uncomment (Ctrl+Shift+D)\nThis removes one space (if any exist) from the beginning of the line where the text cursor is located or from the beginning of any selected lines.\n\nTools → Uppercase (Ctrl+U)\nPut the selected text or the letter after the cursor in uppercase.\n\nTools → Lowercase (Ctrl+Shift+U)\nPut the selected text or the letter after the cursor in lowercase.\n\nTools → Capitalize (Ctrl+Alt+U)\nCapitalize the selected text or the current word.\n\nTools → Join Lines (Ctrl+J)\nJoins the selected lines, or the current line and the line below with one white space character as a separator. Leading/trailing white space on joined lines is removed in the affected ends.\n\nTools → Apply Word Wrap\nApply static word wrapping on all the document. That means that a new line of text will automatically start when the current line exceeds the length specified by the Wrap words at option in the Editing tab in Settings → Configure Editor...\n\n4.6 The Settings and Help Menu\n\nKatePart has the common KDE Settings and Help menu items, for more information read the sections about the Settings Menu and Help Menu of the KDE Fundamentals.\nChapter 5\n\nAdvanced Editing Tools\n\nAnders Lund\nDominik Haumann\n\n5.1 Comment/Uncomment\n\nThe Comment and Uncomment commands, available from the Tools menu allow you to add or remove comment markers to the selection, or the current line if no text is selected, if comments are supported by the format of the text you are editing.\n\nThe rules for how commenting is done are defined in the syntax definitions, so if syntax highlighting is not used, commenting/uncommenting is not possible.\n\nSome formats define single line comment markers, some multiline markers and some both. If multiline markers are not available, commenting out a selection that does not fully include its last line is not possible.\n\nIf a single line marker is available, commenting single lines is preferred where applicable, as this helps to avoid problems with nested comments.\n\nWhen removing comment markers, no uncommented text should be selected. When removing multiline comment markers from a selection, any whitespace outside the comment markers is ignored.\n\nTo place comment markers, use the Tools → Comment menu item or the related keyboard shortcut sequence, the default is Ctrl+D.\n\nTo remove comment markers, use the Tools → Uncomment menu item or the related keyboard shortcut, the default is Ctrl+Shift+D.\n\n5.2 The Editor Component Command Line\n\nKatePart’s editor component has an internal command line, allowing you to perform various actions from a minimal GUI. The command line is a text entry at the bottom of the editor area; to show it select View → Switch to Command Line or use the shortcut (default is F7). The editor provides a set of commands as documented below, and additional commands can be provided by plugins.\n\nTo execute a command, type the command then press the return key. The command line will indicate whether it succeeded and possibly display a message. If you entered the command line\nby pressing F7 it will automatically hide after a few seconds. To clear the message and enter a new command, press F7 again.\n\nThe command line has a built-in help system; issue the command help to get started. To see a list of all available commands issue help list; to view help for a specific command, do help command.\n\nThe command line has a built in history, so you can reuse commands already typed. To navigate the history, use the Up and Down keys. When showing historical commands, the argument part of the command will be selected, allowing you to easily overwrite the arguments.\n\n# 5.2.1 Standard Command Line Commands\n\n## Argument Types\n\n**BOOLEAN**\n\nThis is used with commands that turns things on or off. Legal values are on, off, true, false, 1 or 0.\n\n**INTEGER**\n\nAn integer number.\n\n**STRING**\n\nA string, surrounded by single quotes (‘) or double quotes (¨) when it contains spaces.\n\n## 5.2.1.1 Commands for Configuring the Editor\n\nThese commands are provided by the editor component, and allow you to configure the active document and view only. This is handy if you want to use a setting different from the default settings, for example for indentation.\n\n```\nset-tab-width INTEGER width\n Sets the tab width to the number width.\n\nset-indent-width INTEGER width\n Sets the indentation width to the number width. Used only if you are indenting with spaces.\n\nset-word-wrap-column INTEGER width\n Sets the line width for hard wrapping to width. This is used if you are having your text wrapped automatically.\n\nset-icon-border BOOLEAN enable\n Sets the visibility of the icon border.\n\nset-folding-markers BOOLEAN enable\n Sets the visibility of the folding markers pane.\n\nset-line-numbers BOOLEAN enable\n Sets the visibility of the line numbers pane.\n\nset-replace-tabs BOOLEAN enable\n If enabled, tabs are replaced with spaces as you type.\n\nset-remove-trailing-space BOOLEAN enable\n If enabled, trailing whitespace is removed whenever the cursor leaves a line.\n```\nset-show-tabs BOOLEAN enable\nIf enabled, TAB characters and trailing whitespace will be visualized by a small dot.\n\nset-show-indent BOOLEAN enable\nIf enabled, indentation will be visualized by a vertical dotted line.\n\nset-indent-spaces BOOLEAN enable\nIf enabled, the editor will indent with indent-width spaces for each indentation level, rather than with one TAB character.\n\nset-mixed-indent BOOLEAN enable\nIf enabled, KatePart will use a mix of TAB and spaces for indentation. Each indentation level will be indent-width wide, and more indentation levels will be optimized to use as many TAB characters as possible.\n\nWhen executed, this command will additionally set space indentation enabled, and if the indent width is unspecified it will be set to half of the tab-width for the document at the time of execution.\n\nset-word-wrap BOOLEAN enable\nEnables dynamic word wrap according to enable.\n\nset-replace-tabs-save BOOLEAN enable\nWhen enabled, tabs will be replaced with whitespace whenever the document is saved.\n\nset-remove-trailing-space-save BOOLEAN enable\nWhen enabled, trailing space will be removed from each line whenever the document is saved.\n\nset-indent-mode STRING name\nSets the autoindentation mode to name. If name is not known, the mode is set to ‘none’. Valid modes are ‘none’, ‘normal’, ‘cstyle’, ‘haskell’, ‘lilypond’, ‘lisp’, ‘python’, ‘ruby’ and ‘xml’.\n\nset-auto-ident BOOLEAN script\nEnable or disable autoindentation.\n\nset-highlight STRING highlight\nSets the syntax highlighting system for the document. The argument must be a valid highlight name, as seen in the Tools → Highlighting menu. This command provides an autocompletion list for its argument.\n\nreload-scripts\nReload all JavaScript scripts used by Kate, including indenters and command line scripts.\n\nset-mode STRING mode\nChoose the filetype scheme for the current document.\n\nnoremap STRING original STRING mapped\nMap the key sequence original to mapped.\n\n5.2.1.2 Commands for editing\nThese commands modify the current document.\n\nindent\nIndents the selected lines or the current line.\nThe KatePart Handbook\n\nunindent\nUnindents the selected lines or current line.\n\ncleanindent\nCleans up the indentation of the selected lines or current line according to the indentation settings in the document.\n\ncomment\nInserts comment markers to make the selection or selected lines or current line a comment according to the text format as defined by the syntax highlight definition for the document.\n\nuncomment\nRemoves comment markers from the selection or selected lines or current line according to the text format as defined by the syntax highlight definition for the document.\n\nkill-line\nDeletes the current line.\n\nreplace STRING pattern STRING replacement\nReplaces text matching pattern with replacement. If you want to include whitespace in the pattern, you must quote both the pattern and replacement with single or double quotes. If the arguments are unquoted, the first word is used as pattern and the rest for replacement. If replacement is empty, each occurrence of pattern is removed.\nYou can set flags to configure the search by adding a colon, followed by one or more letters each representing a configuration, giving the form replace:options pattern replacement. Available options are:\n\n- b: Search backwards.\n- c: Search from cursor position.\n- e: Search in the selection only.\n- r: Do regular expression search. If set, you may use \\N where N is a number to represent captures in the replacement string.\n- s: Do case sensitive search.\n- p: Prompt for permission to replace the next occurrence.\n- w: Match whole words only.\n\ndate STRING format\nInserts a date/time string as defined by the specified format, or the format ‘yyyy-MM-dd hh:mm:ss’ if none is specified. The following translations are done when interpreting format:\n\n<table>\n<thead>\n<tr>\n<th>d</th>\n<th>The day as number without a leading zero (1-31).</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dd</td>\n<td>The day as number with a leading zero (01-31).</td>\n</tr>\n<tr>\n<td>ddd</td>\n<td>The abbreviated localized day name (e.g. 'Mon'..'Sun').</td>\n</tr>\n<tr>\n<td>dddd</td>\n<td>The long localized day name (e.g. 'Monday'..'Sunday').</td>\n</tr>\n<tr>\n<td>M</td>\n<td>The month as number without a leading zero (1-12).</td>\n</tr>\n<tr>\n<td>Code</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>------</td>\n<td>-------------</td>\n</tr>\n<tr>\n<td>MM</td>\n<td>The month as number with a leading zero (01-12).</td>\n</tr>\n<tr>\n<td>MMMM</td>\n<td>The long localized month name (e.g. 'January'..'December').</td>\n</tr>\n<tr>\n<td>MMM</td>\n<td>The abbreviated localized month name (e.g. 'Jan'..'Dec').</td>\n</tr>\n<tr>\n<td>yy</td>\n<td>The year as two digit number (00-99).</td>\n</tr>\n<tr>\n<td>yyyy</td>\n<td>The year as four digit number (1752-8000).</td>\n</tr>\n<tr>\n<td>h</td>\n<td>The hour without a leading zero (0..23 or 1..12 if AM/PM display).</td>\n</tr>\n<tr>\n<td>hh</td>\n<td>The hour with a leading zero (00..23 or 01..12 if AM/PM display).</td>\n</tr>\n<tr>\n<td>m</td>\n<td>The minute without a leading zero (0..59).</td>\n</tr>\n<tr>\n<td>mm</td>\n<td>The minute with a leading zero (00..59).</td>\n</tr>\n<tr>\n<td>s</td>\n<td>The second without a leading zero (0..59).</td>\n</tr>\n<tr>\n<td>ss</td>\n<td>The second with a leading zero (00..59).</td>\n</tr>\n<tr>\n<td>z</td>\n<td>The milliseconds without leading zeroes (0..999).</td>\n</tr>\n<tr>\n<td>zzzz</td>\n<td>The milliseconds with leading zeroes (000..999).</td>\n</tr>\n<tr>\n<td>AP</td>\n<td>Use AM/PM display. AP will be replaced by either “AM” or “PM”.</td>\n</tr>\n<tr>\n<td>ap</td>\n<td>Use am/pm display. ap will be replaced by either “am” or “pm”.</td>\n</tr>\n</tbody>\n</table>\n\n**char STRING identifier**\n\nThis command allows you to insert literal characters by their numerical identifier, in decimal, octal or hexadecimal form. To use it launch the Editing Command dialog and type **char: [number]** in the entry box, then hit **OK**.\n\n**Example 5.1 char examples**\n\n**Input:** char:234 \n**Output:** ê \n**Input:** char:0x1234 \n**Output:** jué\n\n**s///[lig] %s///[lig]**\n\nThis command does a sed-like search/replace operation on the current line, or on the whole file (%s///).\n\nIn short, the text is searched for text matching the search pattern, the regular expression between the first and the second slash, and when a match is found, the matching part of the text is replaced with the expression between the second and last slash. Parentheses in the search pattern create back references, that is the command remembers which part of the string matched in the parentheses; these strings can be reused in the replace pattern, referred to as \\1 for the first set of parentheses, \\2 for the second and so on.\n\nTo search for a literal ( or ), you need to escape it using a backslash character: \\\\\n\nIf you put an i at the end of the expression, the matching will be case insensitive. If you put a g at the end, all occurrences of the pattern will be replaced, otherwise only the first occurrence is replaced.\nExample 5.2 Replacing text in the current line\n\nYour friendly compiler just stopped, telling you that the class myClass mentioned in line 3902 in your source file is not defined. \n\n“Buckle!” you think, it is of course MyClass. You go to line 3902, and instead of trying to find the word in the text, you launch the Editing Command Dialog, enter \\s/myclass/MyClass/i, hit the OK button, save the file and compile – successfully without the error.\n\nExample 5.3 Replacing text in the whole file\n\nImagine that you have a file, in which you mention a ‘Miss Jensen’ several times, when someone comes in and tells you that she just got married to ‘Mr Jones’. You want, of course, to replace each and every occurrence of ‘Miss Jensen’ with ‘Ms Jones’. \n\nEnter the command line and issue the command %s/Miss Jensen/Ms Jones/ and hit return, you are done.\n\nExample 5.4 A More Advanced Example\n\nThis example makes use of back references as well as a character class (if you do not know what that is, please refer to the related documentation mentioned below).\n\nSuppose you have the following line:\n\n```cpp\nvoid MyClass :: DoStringOps ( String &foo , String &bar , String *p , int & a , int &b )\n```\n\nNow you realize that this is not nice code, and decide that you want to use the const keyword for all ‘address of’ arguments, those characterized by the & operator in front of the argument name. You would also like to simplify the white space, so that there is only 1 whitespace character between each word.\n\nLaunch the Editing Command Dialog, and enter: \\s/\\s+\\(\\w+\\)\\s+(&)/ const \\1 \\2/g and hit the OK button. The g at the end of the expression makes the regular expression recompile for each match to save the backreferences.\n\nOutput: `void MyClass::DoStringOps( const String &foo, const String &bar, String *p, const int &a, const int &b )`\n\nMission completed! Now, what happened? Well, we looked for some white space followed by one or more alphabetic characters followed by some more whitespace followed by an ampersand, and in the process saved the alphabetic chunk and the ampersand for reuse in the replace operation. Then we replaced the matching part of our line with one whitespace followed by ‘const’ followed by one whitespace followed by our saved alphabetic chunk followed by one whitespace followed by our saved ampersand.\n\nNow in some cases the alphabetical chunk was ‘String’, in some ‘int’, so using the character class \\w and the + quantifier proved a valuable asset.\n\n**sort**\n\nSorts the selected text or entire document.\n\n**natsort**\n\nSort the selected lines or entire document naturally.\n\nExample 5.5 sort vs. natsort\n\n```\nsort(a10, a1, a2)\nresults in a1, a10, a2\n```\n\n```\nnatsort(a10, a1, a2)\nresults in a1, a2, a10\n```\n\n**moveLinesDown**\n\nMove selected lines down.\nmoveLinesUp\nMove selected lines up.\n\nuniq\nRemove duplicated lines from the selected text or the whole document.\n\nrtrim\nRemove trailing space from the selected text or the whole document.\n\nltrim\nRemove leading space from the selected text or the whole document.\n\njoin [STRING separator]\nJoin selected lines or whole document. Optionally takes a parameter defining a separator, for example: join ' ', '\n\nrmblank\nRemove all blank spaces from the selected text or the whole document.\n\nunwrap\nUnwrap the selected text or the whole document.\n\neach STRING script\nGiven a JavaScript function as an argument, call that for the list of selected lines and replace them with the return value of that callback.\n\nExample 5.6 Join selected lines\neach 'function(lines){return lines.join('', '')}'\nOr, more briefly:\neach 'lines.join('', '')'\n\nfilter STRING script\nGiven a JavaScript function as an argument, call that for the list of selected lines and remove those where the callback returns false.\n\nExample 5.7 Remove blank lines\nfilter 'function(l){return l.length > 0;}'\nOr, more briefly:\nfilter 'line.length > 0'\n\nmap STRING script\nGiven a JavaScript function as an argument, call that for the list of selected lines and replace the line with the value of the callback.\n\nExample 5.8 Remove blank lines\nmap 'function(line){return line.replace(/\\s+/, '');}'\nOr, more briefly:\nmap 'line.replace(/\\s+/, '')'\n\nduplicateLinesUp\nDuplicate the selected lines above the current selection.\n\nduplicateLinesDown\nDuplicate the selected lines below the current selection.\n5.2.1.3 Commands for navigation\n\n**goto INT line**\nThis command navigates to the specified line.\n\n**grep STRING pattern**\nSearch the document for the regular expression **pattern**. For more information, see appendix A\n\n**find STRING pattern**\nThis command navigates to the first occurrence of **pattern** according to the configuration. Following occurrences can be found using **Edit → Find Next** (the default shortcut is **F3**). The find command can be configured by appending a colon followed by one or more options, the form is **find:options pattern**. The following options are supported:\n\n- **b**\n Search backwards.\n- **c**\n Search from cursor position.\n- **e**\n Search in the selection only.\n- **r**\n Do regular expression search. If set, you may use \\N where N is a number to represent captures in the replacement string.\n- **s**\n Do case sensitive search.\n- **w**\n Match whole words only.\n\n**ifind STRING pattern**\nThis command provides ‘as-you-type’ searching. You can configure the behavior of the search by appending a colon followed by one or more options, like this: **ifind:options pattern**. Allowed options are\n\n- **b**\n Search backwards.\n- **r**\n Do regular expression search.\n- **s**\n Do case sensitive search.\n- **c**\n Search from cursor position.\n\n5.2.1.4 Commands for Basic Editor Functions (These depend on the application the editor component is used in)\n\n- **w**\n Save the current document.\n- **wa**\n Save all currently open documents.\n- **q**\n Close the current document.\n5.3 Using Code Folding\n\nCode folding allows you to hide parts of a document in the editor, making it easier to overview large documents. In KatePart the foldable regions are calculated using rules defined in the syntax highlight definitions, and therefore it is only available in some formats - typically program source code, XML markup and similar. Most highlight definitions supporting code folding also lets you manually define foldable regions, typically using the `BEGIN` and `END` keywords.\n\nTo use the code folding feature, activate the folding markers using View → Show Folding Markers menu item if they are not already visible. The Folding Markers Pane on the left side of the screen displays a graphical view of the foldable regions, with triangle symbols to indicate the possible operation on a given region: a top down triangle means that the region is expanded, clicking it will collapse the region and a right pointing triangle will be displayed instead.\n\nThree commands are provided to manipulate the state of folding regions, see the menu documentation.\n\nThe folded lines are remembered when a file is closed, so when you reopen the file the folded nodes will still be folded. This applies to reload operations as well.\n\nIf you do not want to use the code folding feature, you can disable the Show folding markers (if available) option in the Appearance page of the editor configuration.\nChapter 6\n\nExtending KatePart\n\nT.C. Hollingsworth\n\n6.1 Introduction\n\nLike any advanced text editor component, KatePart offers a variety of ways to extend its functionality. You can write simple scripts to add functionality with JavaScript. Finally, once you have extended KatePart, you are welcome to join us and share your enhancements with the world!\n\n6.2 Working with Syntax Highlighting\n\n6.2.1 Overview\n\nSyntax Highlighting is what makes the editor automatically display text in different styles/colors, depending on the function of the string in relation to the purpose of the file. In program source code for example, control statements may be rendered bold, while data types and comments get different colors from the rest of the text. This greatly enhances the readability of the text, and thus helps the author to be more efficient and productive.\n\n```\nTheme Repository::defaultTheme(Repository::DefaultTheme t)\n{\n if (t == DarkTheme)\n return theme(QLatin1String(\"Breeze Dark\"));\n return theme(QLatin1String(\"Default\"));\n}\n```\n\n*A C++ function, rendered with syntax highlighting.*\nThe KatePart Handbook\n\nThe same C++ function, without highlighting.\n\nOf the two examples, which is easiest to read?\n\nKatePart comes with a flexible, configurable and capable system for doing syntax highlighting, and the standard distribution provides definitions for a wide range of programming, scripting and markup languages and other text file formats. In addition you can provide your own definitions in simple XML files.\n\nKatePart will automatically detect the right syntax rules when you open a file, based on the MIME Type of the file, determined by its extension, or, if it has none, the contents. Should you experience a bad choice, you can manually set the syntax to use from the Tools → Highlighting menu.\n\nThe styles and colors used by each syntax highlight definition can be configured using the Highlighting Text Styles tab of the Config Dialog, while the MIME Types and file extensions it should be used for are handled by the Modes & Filetypes tab.\n\nNOTE\nSyntax highlighting is there to enhance the readability of correct text, but you cannot trust it to validate your text. Marking text for syntax is difficult depending on the format you are using, and in some cases the authors of the syntax rules will be proud if 98% of text gets correctly rendered, though most often you need a rare style to see the incorrect 2%.\n\n6.2.2 The KatePart Syntax Highlight System\n\nThis section will discuss the KatePart syntax highlighting mechanism in more detail. It is for you if you want to know about it, or if you want to change or create syntax definitions.\n\n6.2.2.1 How it Works\n\nWhenever you open a file, one of the first things the KatePart editor does is detect which syntax definition to use for the file. While reading the text of the file, and while you type away in it, the syntax highlighting system will analyze the text using the rules defined by the syntax definition and mark in it where different contexts and styles begin and end.\n\nWhen you type in the document, the new text is analyzed and marked on the fly, so that if you delete a character that is marked as the beginning or end of a context, the style of surrounding text changes accordingly.\n\nThe syntax definitions used by the KatePart Syntax Highlighting System are XML files, containing\n\n• Rules for detecting the role of text, organized into context blocks\n• Keyword lists\n• Style Item definitions\nWhen analyzing the text, the detection rules are evaluated in the order in which they are defined, and if the beginning of the current string matches a rule, the related context is used. The start point in the text is moved to the final point at which that rule matched and a new loop of the rules begins, starting in the context set by the matched rule.\n\n### 6.2.2.2 Rules\n\nThe detection rules are the heart of the highlighting detection system. A rule is a string, character or regular expression against which to match the text being analyzed. It contains information about which style to use for the matching part of the text. It may switch the working context of the system either to an explicitly mentioned context or to the previous context used by the text.\n\nRules are organized in context groups. A context group is used for main text concepts within the format, for example quoted text strings or comment blocks in program source code. This ensures that the highlighting system does not need to loop through all rules when it is not necessary, and that some character sequences in the text can be treated differently depending on the current context.\n\nContexts may be generated dynamically to allow the usage of instance specific data in rules.\n\n### 6.2.2.3 Context Styles and Keywords\n\nIn some programming languages, integer numbers are treated differently from floating point ones by the compiler (the program that converts the source code to a binary executable), and there may be characters having a special meaning within a quoted string. In such cases, it makes sense to render them differently from the surroundings so that they are easy to identify while reading the text. So even if they do not represent special contexts, they may be seen as such by the syntax highlighting system, so that they can be marked for different rendering.\n\nA syntax definition may contain as many styles as required to cover the concepts of the format it is used for.\n\nIn many formats, there are lists of words that represent a specific concept. For example, in programming languages, control statements are one concept, data type names another, and built-in functions of the language a third. The KatePart Syntax Highlighting System can use such lists to detect and mark words in the text to emphasize concepts of the text formats.\n\n### 6.2.2.4 Default Styles\n\nIf you open a C++ source file, a Java™ source file and an HTML document in KatePart, you will see that even though the formats are different, and thus different words are chosen for special treatment, the colors used are the same. This is because KatePart has a predefined list of Default Styles which are employed by the individual syntax definitions.\n\nThis makes it easy to recognize similar concepts in different text formats. For example, comments are present in almost any programming, scripting or markup language, and when they are rendered using the same style in all languages, you do not have to stop and think to identify them within the text.\n\n---\n\n**Tip**\n\nAll styles in a syntax definition use one of the default styles. A few syntax definitions use more styles than there are defaults, so if you use a format often, it may be worth launching the configuration dialog to see if some concepts use the same style. For example, there is only one default style for strings, but as the Perl programming language operates with two types of strings, you can enhance the highlighting by configuring those to be slightly different. All available default styles will be explained later.\n6.2.3 The Highlight Definition XML Format\n\n6.2.3.1 Overview\n\nKatePart uses the Syntax-Highlighting framework from KDE Frameworks. The default highlighting xml files shipped with KatePart are compiled into the Syntax-Highlighting library by default.\n\nThis section is an overview of the Highlight Definition XML format. Based on a small example it will describe the main components and their meaning and usage. The next section will go into detail with the highlight detection rules.\n\nThe formal definition, also known as the XSD you find in Syntax Highlighting repository in the file `language.xsd`. Custom .xml highlight definition files are located in `org.kde.syntax-highlighting/syntax/` in your user folder found with `qtpaths--paths GenericDataLocation` which usually is `$HOME /.local/share/`.\n\nOn Windows® these files are located `%USERPROFILE%/AppData/Local/org.kde.syntax-highlighting/syntax/`. %USERPROFILE% usually expands to `C:\\Users\\user`.\n\nFor Kate’s Flatpak package, these files are located `$/HOME /.var/app/org.kde.kate/data/org.kde.syntax-highlighting/syntax/` and for Kate’s Snap package, it is `$/HOME /snap/kate/current/.local/share/org.kde.syntax-highlighting/syntax/`.\n\nIf multiple files exist for the same language, the file with the highest `version` attribute in the `language` element will be loaded.\n\nMain sections of KatePart Highlight Definition files\n\nA highlighting file contains a header that sets the XML version:\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n```\n\nThe root of the definition file is the element `language`. Available attributes are:\n\n- **Required attributes:**\n - `name` sets the name of the language. It appears in the menus and dialogs afterwards.\n - `section` specifies the category.\n - `extensions` defines file extensions, such as `*.cpp;*.h`.\n - `version` specifies the current revision of the definition file in terms of an integer number. Whenever you change a highlighting definition file, make sure to increase this number.\n - `kateversion` specifies the latest supported KatePart version.\n\n- **Optional attributes:**\n - `mimetype` associates files MIME type.\n - `casesensitive` defines, whether the keywords are case sensitive or not.\n - `priority` is necessary if another highlight definition file uses the same extensions. The higher priority will win.\n - `author` contains the name of the author and his email-address.\n - `license` contains the license, usually the MIT license for new syntax-highlighting files.\n - `style` contains the provided language and is used by the indenters for the attribute required-syntax-style.\n - `indenter` defines which indenter will be used by default. Available indenters are: `ada`, `normal`, `cstyle`, `cmake`, `haskell`, `latex`, `lilypond`, `lisp`, `lua`, `pascal`, `python`, `replicode`, `ruby` and `xml`.\n - `hidden` defines whether the name should appear in KatePart’s menus.\n\nSo the next line may look like this:\nNext comes the highlighting element, which contains the optional element list and the required elements contexts and itemDatas.\n\nlist elements contain a list of keywords. In this case the keywords are class and const. You can add as many lists as you need.\n\nSince KDE Frameworks 5.53, a list can include keywords from another list or language/file, using the include element. ## is used to separate the list name and the language definition name, in the same way as in the IncludeRules rule. This is useful to avoid duplicating keyword lists, if you need to include the keywords of another language/file. For example, the othername list contains the str keyword and all the keywords of the types list, which belongs to the ISO C++ language.\n\nThe contexts element contains all contexts. The first context is by default the start of the highlighting. There are two rules in the context Normal Text, which match the list of keywords with the name somename and a rule that detects a quote and switches the context to string. To learn more about rules read the next chapter.\n\nThe third part is the itemDatas element. It contains all color and font styles needed by the contexts and rules. In this example, the itemData Normal Text, String and Keyword are used.\n\nThe last part of a highlight definition is the optional general section. It may contain information about keywords, code folding, comments, indentation, empty lines and spell checking.\nThe KatePart Handbook\n\nThe `comment` section defines with what string a single line comment is introduced. You also can define a multiline comment using `multiLine` with the additional attribute `end`. This is used if the user presses the corresponding shortcut for `comment/uncomment`.\n\nThe `keywords` section defines whether keyword lists are case sensitive or not. Other attributes will be explained later.\n\nThe other sections, folding, emptyLines and spellchecking, are usually not necessary and are explained later.\n\n```xml\n<general>\n <comments>\n <comment name=\"singleLine\" start=\"#\"/>\n </comments>\n <keywords casesensitive=\"1\"/>\n <folding indentationSensitive=\"0\"/>\n <emptyLines>\n <emptyLine regexpr=\"\\s+\"/>\n <emptyLine regexpr=\"\\s*#.*\"/>\n </emptyLines>\n <spellchecking>\n <encoding char=\"á\" string=\"\\'a\"/>\n <encoding char=\"à\" string=\"\\'a\"/>\n </spellchecking>\n</general>\n</language>\n```\n\n6.2.3.2 The Sections in Detail\n\nThis part will describe all available attributes for contexts, itemDatas, keywords, comments, code folding and indentation.\n\nThe element context belongs in the group contexts. A context itself defines context specific rules such as what should happen if the highlight system reaches the end of a line. Available attributes are:\n\n- **name** states the context name. Rules will use this name to specify the context to switch to if the rule matches.\n- **lineEndContext** defines the context the highlight system switches to if it reaches the end of a line. This may either be a name of another context, `#stay` to not switch the context (e.g., do nothing) or `#pop` which will cause it to leave this context. It is possible to use for example `#pop#pop#pop` to pop three times, or even `#pop#pop!OtherContext` to pop two times and switch to the context named `OtherContext`.\n- **lineEmptyContext** defines the context if an empty line is encountered. Default: `#stay`.\n- **fallthrough** defines if the highlight system switches to the context specified in fallthroughContext if no rule matches. Default: `false`.\n- **fallthroughContext** specifies the next context if no rule matches.\n- **noIndentationBasedFolding** disables indentation-based folding in the context. If indentation-based folding is not activated, this attribute is useless. This is defined in the element folding of the group general. Default: `false`.\n\nThe element itemData is in the group itemDatas. It defines the font style and colors. So it is possible to define your own styles and colors. However, we recommend you stick to the default styles if possible so that the user will always see the same colors used in different languages. Though, sometimes there is no other way and it is necessary to change color and font attributes. The attributes name and defStyleNum are required, the others are optional. Available attributes are:\nname sets the name of the itemData. Contexts and rules will use this name in their attribute\nattribute to reference an itemData.\ndefStyleNum defines which default style to use. Available default styles are explained in\ndetail later.\ncolor defines a color. Valid formats are ‘#rrggbb’ or ‘#rgb’.\nselColor defines the selection color.\nitalic if true, the text will be italic.\nbold if true, the text will be bold.\nunderline if true, the text will be underlined.\nstrikeout if true, the text will be struck out.\nspellChecking if true, the text will be spellchecked.\n\nThe element keywords in the group general defines keyword properties. Available attributes are:\ncasesensitive may be true or false. If true, all keywords are matched case sensitively.\nweakDeliminator is a list of characters that do not act as word delimiters. For example,\nthe dot ‘.’ is a word delimiter. Assume a keyword in a list contains a dot, it will only\nmatch if you specify the dot as a weak delimiter.\nadditionalDeliminator defines additional delimiters.\nwordWrapDeliminator defines characters after which a line wrap may occur.\nDefault delimiters and word wrap delimiters are the characters . () : ! + , <= % & * ; ? [ ] ^\n{ } \\ ~ \\ system \\ ‘ ’ and tabulator (‘\\t’).\n\nThe element comment in the group comments defines comment properties which are used for\nTools → Comment and Tools → Uncomment. Available attributes are:\nname is either singleLine or multiLine. If you choose multiLine the attributes end and region\nare required.\nstart defines the string used to start a comment. In C++ this would be “ /* ”.\nend defines the string used to close a comment. In C++ this would be “*/”.\nregion should be the name of the foldable multiline comment. Assume you have\nbeginRegion=“Comment” ... endRegion=“Comment” in your rules, you should use re-\ngion=“Comment”. This way uncomment works even if you do not select all the text of the\nmultiline comment. The cursor only must be in the multiline comment.\n\nThe element folding in the group general defines code folding properties. Available attributes are:\nindentationsensitive if true, the code folding markers will be added indentation\nbased, as in the scripting language Python. Usually you do not need to set it, as it defaults to false.\n\nThe element emptyLine in the group emptyLines defines which lines should be treated as\nempty lines. This allows modifying the behavior of the lineEmptyContext attribute in the\nelements context. Available attributes are:\nregexp defines a regular expression that will be treated as an empty line. By default,\nempty lines do not contain any characters, therefore, this adds additional empty lines, for\nexample, if you want lines with spaces to also be considered empty lines. However, in most\nsyntax definitions you do not need to set this attribute.\n\nThe element encoding in the group spellchecking defines a character encoding for spell\nchecking. Available attributes:\ncchar is a encoded character.\nstring is a sequence of characters that will be encoded as the character char in the spell\nchecking. For example, in the language LaTeX, the string \\'\\{A\\} represents the character Ą.\n6.2.3.3 Available Default Styles\n\nDefault Styles were already explained, as a short summary: Default styles are predefined font and color styles.\n\nGeneral default styles:\n- **dsNormal**, when no special highlighting is required.\n- **dsKeyword**, built-in language keywords.\n- **dsFunction**, function calls and definitions.\n- **dsVariable**, if applicable: variable names (e.g. $someVar in PHP/Perl).\n- **dsControlFlow**, control flow keywords like if, else, switch, break, return, yield, ...\n- **dsOperator**, operators like + - * / ::\n- **dsBuiltIn**, built-in functions, classes, and objects.\n- **dsExtension**, common extensions, such as Qt classes and functions/macros in C++ and Python.\n- **dsPreprocessor**, preprocessor statements or macro definitions.\n- **dsAttribute**, annotations such as @override and __declspec(...).\n\nString-related default styles:\n- **dsChar**, single characters, such as ‘x’.\n- **dsSpecialChar**, chars with special meaning in strings such as escapes, substitutions, or regex operators.\n- **dsString**, strings like \"hello world\".\n- **dsVerbatimString**, verbatim or raw strings like 'raw \\backslash' in Perl, CoffeeScript, and shells, as well as r\\'raw' in Python.\n- **dsSpecialString**, SQL, regexes, HERE docs, LaTeX math mode, ...\n- **dsImport**, import, include, require of modules.\n\nNumber-related default styles:\n- **dsDataType**, built-in data types like int, void, u64.\n- **dsDecVal**, decimal values.\n- **dsBaseN**, values with a base other than 10.\n- **dsFloat**, floating point values.\n- **dsConstant**, built-in and user defined constants like PI.\n\nComment and documentation-related default styles:\n- **dsComment**, comments.\n- **dsDocumentation**, /* Documentation comments */ or \"\"\"docstrings\"\"\"\".\n- **dsAnnotation**, documentation commands like @param, @brief.\n- **dsCommentVar**, the variable names used in above commands, like “foobar” in @param foobar.\n- **dsRegionMarker**, region markers like //BEGIN, //END in comments.\n\nOther default styles:\n- **dsInformation**, notes and tips like @note in doxygen.\n- **dsWarning**, warnings like @warning in doxygen.\n- **dsAlert**, special words like TODO, FIXME, XXX.\n- **dsError**, error highlighting and wrong syntax.\n- **dsOthers**, when nothing else fits.\n6.2.4 Highlight Detection Rules\n\nThis section describes the syntax detection rules.\n\nEach rule can match zero or more characters at the beginning of the string they are tested against. If the rule matches, the matching characters are assigned the style or attribute defined by the rule, and a rule may ask that the current context is switched.\n\nA rule looks like this:\n\n```\n<RuleName attribute=\"{identifier}\" context=\"{identifier}\" [rule specific ←\nattributes] />\n```\n\nThe attribute identifies the style to use for matched characters by name, and the context identifies the context to use from here.\n\nThe context can be identified by:\n\n- An identifier, which is the name of the other context.\n- An order telling the engine to stay in the current context (\\#stay), or to pop back to a previous context used in the string (\\#pop).\n \n To go back more steps, the \\#pop keyword can be repeated: \\#pop\\#pop\\#pop\n- An order followed by an exclamation mark (!) and an identifier, which will make the engine first follow the order and then switch to the other context, e.g. \\#pop\\#pop!OtherContext.\n\nRule specific attributes varies and are described in the following sections.\n\n**COMMON ATTRIBUTES**\n\n- attribute: An attribute maps to a defined itemData.\n- context: Specify the context to which the highlighting system switches if the rule matches.\n- endRegion: Close a code folding block. Default: unset.\n- lookAhead: If true, the highlighting system will not process the matches length. Default: false.\n- firstNonSpace: Match only, if the string is the first non-whitespace in the line. Default: false.\n- column: Match only, if the column matches. Default: unset.\n\n**DYNAMIC RULES**\n\n- dynamic: may be (true|false).\n\nHow does it work:\n\nIn the regular expressions of the RegExpr rules, all text within simple curved brackets (\\(\\text{PAT tern}\\)) is captured and remembered. These captures can be used in the context to which it is switched, in the rules with the attribute dynamic true, by \\$N (in String) or \\$ (in char).\n\nIt is important to mention that a text captured in a RegExpr rule is only stored for the switched context, specified in its context attribute.\nIf the captures will not be used, both by dynamic rules and in the same regular expression, **non-capturing groups** should be used: `(?PATTERN)`\n\nThe **lookahead** or **lookbehind** groups such as `(?=PATTERN)` or `(?<=PATTERN)` are not captured. See **Regular Expressions** for more information.\n\n- The capture groups can be used within the same regular expression, using \\N instead of %N respectively. For more information, see **Capturing matching text (back references)** in **Regular Expressions**.\n\n**Example 1:**\n\nIn this simple example, the text matched by the regular expression `=*` is captured and inserted into %1 in the dynamic rule. This allows the comment to end with the same amount of = as at the beginning. This matches text like: `[[ comment ]], [[ comment ]]` or `[===== [ comment ]=====]`.\n\nIn addition, the captures are available only in the switched context **Multi-line Comment**.\n\n**Example 2:**\n\nIn the dynamic rule, %1 corresponds to the capture that matches #+, and %2 to `quot;+`. This matches text as: `#label´´´´´´´´inside the context´´´´´´´´#`\n\nThese captures will not be available in other contexts, such as **OtherContext**, **FindEscapes** or **SomeContext**.\n\n**Example 3:**\n\nThis matches text like: **Class::function<T>( ... )**.\n6.2.4.1 The Rules in Detail\n\n**DetectChar**\nDetect a single specific character. Commonly used for example to find the ends of quoted strings.\n\n```xml\n<DetectChar char=\"(character)\" (common attributes) (dynamic) />\n```\n\nThe `char` attribute defines the character to match.\n\n**Detect2Chars**\nDetect two specific characters in a defined order.\n\n```xml\n<Detect2Chars char=\"(character)\" char1=\"(character)\" (common attributes) />\n```\n\nThe `char` attribute defines the first character to match, `char1` the second.\n\n**AnyChar**\nDetect one character of a set of specified characters.\n\n```xml\n<AnyChar String=\"(string)\" (common attributes) />\n```\n\nThe `String` attribute defines the set of characters.\n\n**StringDetect**\nDetect an exact string.\n\n```xml\n<StringDetect String=\"(string)\" [insensitive=\"true|false\"] (common attributes) (dynamic) />\n```\n\nThe `String` attribute defines the string to match. The `insensitive` attribute defaults to `false` and is passed to the string comparison function. If the value is `true` insensitive comparing is used.\n\n**WordDetect**\nDetect an exact string but additionally require word boundaries such as a dot '.' or a whitespace on the beginning and the end of the word. Think of `\\b<string>\\b` in terms of a regular expression, but it is faster than the rule `RegExpr`.\n\n```xml\n<WordDetect String=\"(string)\" [insensitive=\"true|false\"] (common attributes) />\n```\n\nThe `String` attribute defines the string to match. The `insensitive` attribute defaults to `false` and is passed to the string comparison function. If the value is `true` insensitive comparing is used.\n\nSince: Kate 3.5 (KDE 4.5)\n\n**RegExpr**\nMatches against a regular expression.\nThe String attribute defines the regular expression.\n insensitive defaults to false and is passed to the regular expression engine.\n minimal defaults to false and is passed to the regular expression engine.\n\nBecause the rules are always matched against the beginning of the current string, a regular\nexpression starting with a caret (^) indicates that the rule should only be matched against\nthe start of a line.\nSee Regular Expressions for more information on those.\n\n**keyword**\nDetect a keyword from a specified list.\n\nThe String attribute identifies the keyword list by name. A list with that name must exist.\nThe highlighting system processes keyword rules in a very optimized way. This makes\nit an absolute necessity that any keywords to be matched need to be surrounded by de-\nfinite delimiters, either implied (the default delimiters), or explicitly specified within the\nadditionalDeliminator property of the keywords tag.\n\nIf a keyword to be matched shall contain a delimiter character, this respective character\nmust be added to the weakDeliminator property of the keywords tag. This character will then\nloose its delimiter property in all keyword rules.\n\n**Int**\nDetect an integer number (as the regular expression: \\b[0-9]+).\n\nThis rule has no specific attributes.\n\n**Float**\nDetect a floating point number (as the regular expression: (\\b[0-9]+\\.[0-9]*\\.?[0-9]+)?).\n\nThis rule has no specific attributes.\n\n**HICOct**\nDetect an octal point number representation (as the regular expression: \\b0[0-7]+).\n\nThis rule has no specific attributes.\n\n**HICHex**\nDetect a hexadecimal number representation (as a regular expression: \\b0[xX] [0-9a-fA-\nF]+).\n\nThis rule has no specific attributes.\n\n**HICStringChar**\nDetect an escaped character.\nThis rule has no specific attributes.\nIt matches literal representations of characters commonly used in program code, for example \\n (newline) or \\t (TAB).\nThe following characters will match if they follow a backslash (\\): abefnrtv´¨?\\. Additionally, escaped hexadecimal numbers such as for example \\xff and escaped octal numbers, for example \\033 will match.\n\n**HlCChar**\nDetect an C character.\n\n```xml\n<HlCChar (common attributes) />\n```\n\nThis rule has no specific attributes.\nIt matches C characters enclosed in a tick (Example: ‘c’). The ticks may be a simple character or an escaped character. See HlCStringChar for matched escaped character sequences.\n\n**RangeDetect**\nDetect a string with defined start and end characters.\n\n```xml\n<RangeDetect char=\"(character)\" char1=\"(character)\" (common attributes ←) />\n```\n\n*char* defines the character starting the range, *char1* the character ending the range.\nUseful to detect for example small quoted strings and the like, but note that since the highlighting engine works on one line at a time, this will not find strings spanning over a line break.\n\n**LineContinue**\nMatches a specified char at the end of a line.\n\n```xml\n<LineContinue (common attributes) [char=\"\\\"] />\n```\n\n*char* optional character to match, default is backslash (‘\\’). New since KDE 4.13.\nThis rule is useful for switching context at end of line. This is needed for example in C/C++ to continue macros or strings.\n\n**IncludeRules**\nInclude rules from another context or language/file.\n\n```xml\n<IncludeRules context=\"contextlink\" [includeAttrib=\"true|false\"] />\n```\n\nThe *context* attribute defines which context to include.\nIf it is a simple string it includes all defined rules into the current context, example:\n\n```xml\n<IncludeRules context=\"anotherContext\" />\n```\n\nIf the string contains a ## the highlight system will look for a context from another language definition with the given name, for example\n\n```xml\n<IncludeRules context=\"String##C++\" />\n```\n\nwould include the context *String* from the C++ highlighting definition.\nIf *includeAttrib* attribute is *true*, change the destination attribute to the one of the source. This is required to make, for example, commenting work, if text matched by the included context is a different highlight from the host context.\nThe KatePart Handbook\n\n**DetectSpaces**\nDetect whitespaces.\n\n```xml\n<DetectSpaces (common attributes) />\n```\n\nThis rule has no specific attributes.\nUse this rule if you know that there can be several whitespaces ahead, for example in the beginning of indented lines. This rule will skip all whitespace at once, instead of testing multiple rules and skipping one at a time due to no match.\n\n**DetectIdentifier**\nDetect identifier strings (as the regular expression: `[a-zA-Z_][a-zA-Z0-9_]`).\n\n```xml\n<DetectIdentifier (common attributes) />\n```\n\nThis rule has no specific attributes.\nUse this rule to skip a string of word characters at once, rather than testing with multiple rules and skipping one at a time due to no match.\n\n### 6.2.4.2 Tips & Tricks\n\n- If you only match two characters use `Detect2Chars` instead of `StringDetect`. The same applies to `DetectChar`.\n\n- Regular expressions are easy to use but often there is another much faster way to achieve the same result. Consider you only want to match the character `'#'` if it is the first character in the line. A regular expression based solution would look like this:\n\n```xml\n<RegExpr attribute=\"Macro\" context=\"macro\" String=\"^\\s*#\" />\n```\n\nYou can achieve the same much faster in using:\n\n```xml\n<DetectChar attribute=\"Macro\" context=\"macro\" char=\"#\" firstNonSpace=\"true\" />\n```\n\nIf you want to match the regular expression `'^#'` you can still use `DetectChar` with the attribute `column='0'`. The attribute `column` counts characters, so a tabulator is only one character.\n\n- In `RegExpr` rules, use the attribute `column='0'` if the pattern `^PATTERN` will be used to match text at the beginning of a line. This improves performance, as it will avoid looking for matches in the rest of the columns.\n\n- In regular expressions, use non-capturing groups `(?:PATTERN)` instead of capturing groups `(PATTERN)`, if the captures will not be used in the same regular expression or in dynamic rules. This avoids storing captures unnecessarily.\n\n- You can switch contexts without processing characters. Assume that you want to switch context when you meet the string `*/`, but need to process that string in the next context. The below rule will match, and the `lookAhead` attribute will cause the highlighter to keep the matched string for the next context.\n\n```xml\n<Detect2Chars attribute=\"Comment\" context=\"# pop\" char=\"*\" char1=\"/\" lookAhead=\"true\" />\n```\n\n- Use `DetectSpaces` if you know that many whitespaces occur.\n- Use `DetectIdentifier` instead of the regular expression `'[a-zA-Z_]\\w*'`. \n\n52\nThe KatePart Handbook\n\n- Use default styles whenever you can. This way the user will find a familiar environment.\n- Look into other XML-files to see how other people implement tricky rules.\n- You can validate every XML file by using the command `validatehl.sh language.xsd mySyntax.xml`. The files `validatehl.sh` and `language.xsd` are available in the Syntax Highlighting repository.\n- If you repeat complex regular expression very often you can use `ENTITIES`. Example:\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE language SYSTEM \"language.dtd\">\n[\n <!ENTITY myref \"[A-Za-z_[:\\w.:_\\-]*\"/>\n]\n```\n\nNow you can use `&myref;` instead of the regular expression.\n\n6.3 Scripting with JavaScript\n\nThe KatePart editor component is easily extensible by writing scripts. The scripting language is ECMAScript (widely known as JavaScript). KatePart supports two kinds of scripts: indentation and command line scripts.\n\n6.3.1 Indentation Scripts\n\nIndentation scripts - also referred as indenters - automatically indent the source code while typing text. As an example, after hitting the return key the indentation level often increases.\n\nThe following sections describe step by step how to create the skeleton for a simple indenter. As a first step, create a new `.js` file called e.g. `javascript.js` in the local home folder `$XDG_DATA_HOME/katepart5/script/indentation`. Therein, the environment variable `XDG_DATA_HOME` typically expands to either `~/.local` or `~/.local/share`.\n\nOn Windows® these files are located in `%USERPROFILE%\\AppData\\Local\\katepart5\\indentation`. `%USERPROFILE%` usually expands to `C:\\Users\\user`.\n\n6.3.1.1 The Indentation Script Header\n\nThe header of the file `javascript.js` is embedded as JSON at the beginning of the document as follows:\n\n```javascript\nvar katescript = {\n \"name\": \"JavaScript\",\n \"author\": \"Example Name <example.name@some.address.org>\",\n \"license\": \"BSD License\",\n \"revision\": 1,\n \"kate-version\": \"5.1\",\n \"required-syntax-style\": \"javascript\",\n \"indent-languages\": [\"javascript\"],\n \"priority\": 0,\n}; // kate-script-header, must be at the start of the file without comments\n```\n\nEach entry is explained in detail now:\n• name [required]: This is the indenter name that appears in the menu Tools → Indentation and in the configuration dialog.\n\n• author [optional]: The author’s name and contact information.\n\n• license [optional]: Short form of the license, such as BSD License or LGPLv3.\n\n• revision [required]: The revision of the script. This number should be increased whenever the script is modified.\n\n• kate-version [required]: Minimum required KatePart version.\n\n• required-syntax-style [optional]: The required syntax style, which matches the specified style in syntax highlighting files. This is important for indenters that rely on specific highlight information in the document. If a required syntax style is specified, the indenter is available only when the appropriate highlighter is active. This prevents ‘undefined behavior’ caused by using the indenter without the expected highlighting schema. For instance, the Ruby indenter makes use of this in the files ruby.js and ruby.xml.\n\n• indent-languages [optional]: JSON array of syntax styles the indenter can indent correctly, e.g.: [\"c++\", \"java\"].\n\n• priority [optional]: If several indenters are suited for a certain highlighted file, the priority decides which indenter is chosen as default indenter.\n\n### 6.3.1.2 The Indenter Source Code\n\nHaving specified the header this section explains how the indentation scripting itself works. The basic skeleton of the body looks like this:\n\n```javascript\n// required katepart js libraries, e.g. range.js if you use Range\nrequire (\"range.js\");\n\ntriggerCharacters = \"{};/;\";\nfunction indent(line, indentWidth, ch) {\n // called for each newline (ch == '\\n') and all characters specified in\n // the global variable triggerCharacters. When calling ToolsAlign\n // the variable ch is empty, i.e. ch == \".\"\n //\n // see also: Scripting API\n return -2;\n}\n```\n\nThe function `indent()` has three parameters:\n\n• line: the line that has to be indented\n\n• indentWidth: the indentation width in number of spaces\n\n• ch: either a newline character (ch == '\\n'), the trigger character specified in `triggerCharacters` or empty if the user invoked the action Tools → Align.\n\nThe return value of the `indent()` function specifies how the line will be indented. If the return value is a simple integer number, it is interpreted as follows:\n\n• return value -2: do nothing\n\n• return value -1: keep indentation (searches for previous non-blank line)\n\n• return value 0: numbers >= 0 specify the indentation depth in spaces\nAlternatively, an array of two elements can be returned:\n\n- return [ indent, align ];\n\nIn this case, the first element is the indentation depth as above with the same meaning of the special values. However, the second element is an absolute value representing a column for 'alignment'. If this value is higher than the indent value, the difference represents a number of spaces to be added after the indentation of the first parameter. Otherwise, the second number is ignored. Using tabs and spaces for indentation is often referred to as 'mixed mode'.\n\nConsider the following example: Assume using tabs to indent, and tab width is set to 4. Here, <tab> represents a tab and '. ' a space:\n\n```\n1: <tab><tab>foobar(\"hello\",\n2: <tab><tab>.......\"world\");\n```\n\nWhen indenting line 2, the indent() function returns [8, 15]. As result, two tabs are inserted to indent to column 8, and 7 spaces are added to align the second parameter under the first, so that it stays aligned if the file is viewed with a different tab width.\n\nA default KDE installation ships KatePart with several indenters. The corresponding JavaScript source code can be found in $XDG_DATA_DIRS/katepart5/script/indentation.\n\nOn Windows® these files are located in %USERPROFILE%\\AppData\\Local\\katepart5\\indentation.\n\nDeveloping an indenter requires reloading the scripts to see whether the changes behave appropriately. Instead of restarting the application, simply switch to the command line and invoke the command reload-scripts.\n\nIf you develop useful scripts please consider contributing to the KatePart Project by contacting the mailing list.\n\n### 6.3.2 Command Line Scripts\n\nAs it is hard to satisfy everyone’s needs, KatePart supports little helper tools for quick text manipulation through the built-in command line. For instance, the command sort is implemented as a script. This section explains how to create *.js files to extend KatePart with arbitrary helper scripts.\n\nCommand line scripts are located in the same folder as indentation scripts. So as a first step, create a new *.js file called myutils.js in the local home folder $XDG_DATA_HOME/katepart5/script/commands. Therein, the environment variable XDG_DATA_HOME typically expands to either ~/.local or ~/.local/share.\n\nOn Windows® these files are located in %USERPROFILE%\\AppData\\Local\\katepart5\\commands. %USERPROFILE% usually expands to C:\\Users\\user.\n\n#### 6.3.2.1 The Command Line Script Header\n\nThe header of each command line script is embedded in JSON at the beginning of the script as follows:\n\n```javascript\nvar katescript = {\n \"author\": \"Example Name <example.name@some.address.org>\",\n \"license\": \"LGPLv2+\",\n \"revision\": 1,\n \"kate-version\": \"5.1\",\n \"functions\": [\"sort\", \"moveLinesDown\"],\n \"actions\": [ \n```\nEach entry is explained in detail now:\n\n- **author** [optional]: The author’s name and contact information.\n- **license** [optional]: Short form of the license, such as BSD License or LGPLv2.\n- **revision** [required]: The revision of the script. This number should be increased whenever the script is modified.\n- **kate-version** [required]: Minimum required KatePart version.\n- **functions** [required]: JSON array of commands in the script.\n- **actions** [optional]: JSON Array of JSON objects that defines the actions that appear in the application menu. Detailed information is provided in the section Binding Shortcuts.\n\nSince the value of `functions` is a JSON array, a single script is able to contain an arbitrary number of command line commands. Each function is available through KatePart’s built-in command line.\n\n### 6.3.2.2 The Script Source Code\n\nAll functions specified in the header have to be implemented in the script. For instance, the script file from the example above needs to implement the two functions `sort` and `moveLinesDown`.\n\nAll functions have the following syntax:\n\n```javascript\n// required katepart js libraries, e.g. range.js if you use Range\nrequire(\"range.js\");\n\nfunction <name>(arg1, arg2, ...)\n{\n // ... implementation, see also: Scripting API\n}\n```\n\nArguments in the command line are passed to the function as `arg1, arg2, etc`. In order to provide documentation for each command, simply implement the ‘`help`’ function as follows:\n\n```javascript\nfunction help(cmd)\n{\n if (cmd == \"sort\") {\n return i18n(\"Sort the selected text.\");\n } else if (cmd == \"...\") {\n // ...\n }\n}\n```\nExecuting `help sort` in the command line then calls this help function with the argument `cmd` set to the given command, i.e. `cmd == \"sort\"`. KatePart then presents the returned text as documentation to the user. Make sure to translate the strings.\n\nDeveloping a command line script requires reloading the scripts to see whether the changes behave appropriately. Instead of restarting the application, simply switch to the command line and invoke the command `reload-scripts`.\n\n6.3.2.2.1 Binding Shortcuts\n\nIn order to make the scripts accessible in the application menu and assign shortcuts, the script needs to provide an appropriate script header. In the above example, both functions `sort` and `moveLinesDown` appear in the menu due to the following part in the script header:\n\n```javascript\nvar katescript = {\n ...\n \"actions\": [\n {\n \"function\": \"sort\",\n \"name\": \"Sort Selected Text\",\n \"icon\": \"\",\n \"category\": \"Editing\",\n \"interactive\": \"false\"\n },\n {\n \"function\": \"moveLinesDown\",\n \"name\": \"Move Lines Down\",\n \"icon\": \"\",\n \"category\": \"Editing\",\n \"shortcut\": \"Ctrl+Shift+Down\",\n \"interactive\": \"false\"\n }\n ]\n};\n```\n\nThe fields for one action are as follows:\n\n- **function** [required]: The function that should appear in the menu Tools → Scripts.\n- **name** [required]: The text appears in the script menu.\n- **icon** [optional]: The icon appears next to the text in the menu. All KDE icon names can be used here.\n- **category** [optional]: If a category is specified, the script appears in a submenu.\n- **shortcut** [optional]: The shortcut given here is the default shortcut. Example: `Ctrl+Alt+t`. See the Qt documentation for further details.\n- **interactive** [optional]: If the script needs user input in the command line, set this to `true`.\n\nIf you develop useful scripts please consider contributing to the KatePart Project by contacting the mailing list.\n\n6.3.3 Scripting API\n\nThe scripting API presented here is available to all scripts, i.e. indentation scripts and command line commands. The `Cursor` and `Range` classes are provided by library files in `$XDG_DATA_DIRS/katepart5/libraries`. If you want to use them in your script, which needs to use some of the `Document` or `View` functions, please include the necessary library by using:\nTo extend the standard scripting API with your own functions and prototypes simply create a new file in KDE's local configuration folder \\$XDG_DATA_HOME/katepart5/libraries and include it into your script using:\n\n```\nrequire (\"myscriptnamehere.js\");\n```\n\nOn Windows® these files are located in \\%USERPROFILE%\\AppData\\Local\\katepart5\\libraries. \\%USERPROFILE% usually expands to C:\\Users\\user.\n\nTo extend existing prototypes like Cursor or Range, the recommended way is to not modify the global *.js files. Instead, change the Cursor prototype in JavaScript after the cursor.js is included into your script via require.\n\n### 6.3.3.1 Cursors and Ranges\n\nAs KatePart is a text editor, all the scripting API is based on cursors and ranges whenever possible. A Cursor is a simple (line, column) tuple representing a text position in the document. A Range spans text from a starting cursor position to an ending cursor position. The API is explained in detail in the next sections.\n\n#### 6.3.3.1.1 The Cursor Prototype\n\n- **Cursor();**\n Constructor. Returns a Cursor at position (0, 0).\n Example: var cursor = new Cursor();\n\n- **Cursor(int line, int column);**\n Constructor. Returns a Cursor at position (line, column).\n Example: var cursor = new Cursor(3, 42);\n\n- **Cursor(Cursor other);**\n Copy constructor. Returns a copy of the cursor other.\n Example: var copy = new Cursor(other);\n\n- **Cursor.Cursor.clone();**\n Returns a clone of the cursor.\n Example: var clone = cursor.clone();\n\n- **Cursor.setPosition(int line, int column);**\n Sets the cursor position to line and column.\n Since: KDE 4.11\n\n- **bool Cursor.isValid();**\n Check whether the cursor is valid. The cursor is invalid, if line and/or column are set to -1.\n Example: var valid = cursor.isValid();\n\n- **Cursor.Cursor.invalid();**\n Returns a new invalid cursor located at (-1, -1).\n Example: var invalidCursor = cursor.invalid();\n\n---\n\n// required katepart js libraries, e.g. range.js if you use Range\nrequire (\"range.js\");\nint Cursor.compareTo(Cursor other);\n Compares this cursor to the cursor other. Returns\n • -1, if this cursor is located before the cursor other,\n • 0, if both cursors equal and\n • +1, if this cursor is located after the cursor other.\n\nbool Cursor.equals(Cursor other);\n Returns true, if this cursor and the cursor other are equal, otherwise false.\n\nString Cursor.toString();\n Returns the cursor as a string of the form ‘Cursor(line, column)’.\n\n6.3.3.1.2 The Range Prototype\n\nRange();\n Constructor. Calling new Range() returns a Range at (0, 0) - (0, 0).\n\nRange(Cursor start, Cursor end);\n Constructor. Calling new Range(start, end) returns the Range (start, end).\n\nRange(int startLine, int startColumn, int endLine, int endColumn);\n Constructor. Calling new Range(startLine, startColumn, endLine, endColumn) returns\n the Range from (startLine, startColumn) to (endLine, endColumn).\n\nRange(Range other);\n Copy constructor. Returns a copy of Range other.\n\nRange Range.clone();\n Returns a clone of the range.\n Example: var clone = range.clone();\n\nbool Range.isEmpty();\n Returns true, if the start and end cursors are equal.\n Example: var empty = range.isEmpty();\n Since: KDE 4.11\n\nbool Range.isValid();\n Returns true, if both start and end cursor are valid, otherwise false.\n Example: var valid = range.isValid();\n\nRange Range.invalid();\n Returns the Range from (-1, -1) to (-1, -1).\n\nbool Range.contains(Cursor cursor);\n Returns true, if this range contains the cursor position, otherwise false.\n\nbool Range.contains(Range other);\n Returns true, if this range contains the Range other, otherwise false.\n\nbool Range.containsColumn(int column);\n Returns true, if column is in the half open interval [start.column, end.column), otherwise\n false.\n\nbool Range.containsLine(int line);\n Returns true, if line is in the half open interval [start.line, end.line), otherwise false.\nbool Range.overlaps(Range other);\n Returns true, if this range and the range other share a common region, otherwise false.\n\nbool Range.overlapsLine(int line);\n Returns true, if line is in the interval [start.line, end.line], otherwise false.\n\nbool Range.overlapsColumn(int column);\n Returns true, if column is in the interval [start.column, end.column], otherwise false.\n\nbool Range.onSingleLine();\n Returns true, if the range starts and ends at the same line, i.e. if Range.start.line == Range.end.line.\n Since: KDE 4.9\n\nbool Range.equals(Range other);\n Returns true, if this range and the Range other are equal, otherwise false.\n\nString Range.toString();\n Returns the range as a string of the form ‘Range(Cursor(line, column), Cursor(line, column))’.\n\n6.3.3.2 Global Functions\n\nThis section lists all global functions.\n\n6.3.3.2.1 Reading & Including Files\n\nString read(String file);\n Will search the given file relative to the katepart/script/files directory and return its content as a string.\n\nvoid require(String file);\n Will search the given file relative to the katepart/script/libraries directory and evaluate it. require is internally guarded against multiple inclusions of the same file.\n Since: KDE 4.10\n\n6.3.3.2.2 Debugging\n\nvoid debug(String text);\n Prints text to stdout in the console launching the application.\n### 6.3.3.3 Translation\n\nIn order to support full localization, there are several functions to translate strings in scripts, namely i18n, i18nc, i18np and i18ncp. These functions behave exactly like KDE’s translation functions.\n\nThe translation functions translate the wrapped strings through KDE’s translation system to the language used in the application. Strings in scripts being developed in the official KatePart sources are automatically extracted and translatable. In other words, as a KatePart developer you do not have to bother with message extraction and translation. It should be noted though, that the translation only works inside the KDE infrastructure, i.e., new strings in 3rd-party scripts developed outside of KDE are not translated. Therefore, please consider contributing your scripts to Kate such that proper translation is possible.\n\n```cpp\nvoid i18n(String text, arg1, ...);\n```\n\nTranslates `text` into the language used by the application. The arguments `arg1, ...`, are optional and used to replace the placeholders `%1, %2, etc.\n\n```cpp\nvoid i18nc(String context, String text, arg1, ...);\n```\n\nTranslates `text` into the language used by the application. Additionally, the string `context` is visible to translators so they can provide a better translation. The arguments `arg1, ...`, are optional and used to replace the placeholders `%1, %2, etc.\n\n```cpp\nvoid i18np(String singular, String plural, int number, arg1, ...);\n```\n\nTranslates either `singular` or `plural` into the language used by the application, depending on the given `number`. The arguments `arg1, ...`, are optional and used to replace the placeholders `%1, %2, etc.\n\n```cpp\nvoid i18ncp(String context, String singular, String plural, int number, arg1, ...);\n```\n\nTranslates either `singular` or `plural` into the language used by the application, depending on the given `number`. Additionally, the string `context` is visible to translators so they can provide a better translation. The arguments `arg1, ...`, are optional and used to replace the placeholders `%1, %2, etc.\n\n### 6.3.3.3 The View API\n\nWhenever a script is being executed, there is a global variable ‘view’ representing the current active editor view. The following is a list of all available View functions.\n\n```cpp\nCursor view.cursorPosition();\n```\n\nReturns the current cursor position in the view.\n\n```cpp\nvoid view.setCursorPosition(int line, int column); void view.setCursorPosition(Cursor cursor);\n```\n\nSet the current cursor position to either (line, column) or to the given cursor.\n\n```cpp\nCursor view.virtualCursorPosition();\n```\n\nReturns the virtual cursor position with each tab counting the corresponding amount of spaces depending on the current tab width.\n\n```cpp\nvoid view.setVirtualCursorPosition(int line, int column); void view.setVirtualCursorPosition(Cursor cursor);\n```\n\nSet the current virtual cursor position to (line, column) or to the given cursor.\n\n```cpp\nString view.selectedText();\n```\n\nReturns the selected text. If no text is selected, the returned string is empty.\nbool view.hasSelection();\n Returns true, if the view has selected text, otherwise false.\n\nRange view.selection();\n Returns the selected text range. The returned range is invalid if there is no selected text.\n\nvoid view.setSelection(Range range);\n Set the selected text to the given range.\n\nvoid view.removeSelectedText();\n Remove the selected text. If the view does not have any selected text, this does nothing.\n\nvoid view.selectAll();\n Selects the entire text in the document.\n\nvoid view.clearSelection();\n Clears the text selection without removing the text.\n\nobject view.executeCommand(String command, String args, Range range);\n Executes the command line command command with the optional arguments args and the optional range. The returned object has a boolean property object.ok that indicates whether execution of the command was successful. In case of an error, the string object.status contains an error message.\n Since: KDE Frameworks 5.50\n\n6.3.3.4 The Document API\n\nWhenever a script is being executed, there is a global variable ‘document’ representing the current active document. The following is a list of all available Document functions.\n\nString document.fileName();\n Returns the document’s filename or an empty string for unsaved text buffers.\n\nString document.url();\n Returns the document’s full url or an empty string for unsaved text buffers.\n\nString document.mimeType();\n Returns the document’s mime type or the mime type application/octet-stream if no appropriate mime type could be found.\n\nString document.encoding();\n Returns the currently used encoding to save the file.\n\nString document.highlightingMode();\n Returns the global highlighting mode used for the whole document.\n\nString document.highlightingModeAt(Cursor pos);\n Returns the highlighting mode used at the given position in the document.\n\nArray document.embeddedHighlightingModes();\n Returns an array of highlighting modes embedded in this document.\n\nbool document.isModified();\n Returns true, if the document has unsaved changes (modified), otherwise false.\n\nString document.text();\n Returns the entire content of the document in a single text string. Newlines are marked with the newline character ‘\\n’.\nThe KatePart Handbook\n\nString document.text(int fromLine, int fromColumn, int toLine, int toColumn); String document.text(Cursor from, Cursor to); String document.text(Range range);\n\nReturns the text in the given range. It is recommended to use the cursor and range based version for better readability of the source code.\n\nString document.line(int line);\n\nReturns the given text line as string. The string is empty if the requested line is out of range.\n\nString document.wordAt(int line, int column); String document.wordAt(Cursor cursor);\n\nReturns the word at the given cursor position.\n\nRange document.wordRangeAt(int line, int column); Range document.wordRangeAt(Cursor cursor);\n\nReturn the range of the word at the given cursor position. The returned range is invalid (see Range.isValid()), if the text position is after the end of a line. If there is no word at the given cursor, an empty range is returned.\n\nSince: KDE 4.9\n\nString document.charAt(int line, int column); String document.charAt(Cursor cursor);\n\nReturns the character at the given cursor position.\n\nString document.firstChar(int line);\n\nReturns the first character in the given line that is not a whitespace. The first character is at column 0. If the line is empty or only contains whitespace characters, the returned string is empty.\n\nString document.lastChar(int line);\n\nReturns the last character in the given line that is not a whitespace. If the line is empty or only contains whitespace characters, the returned string is empty.\n\nbool document.isSpace(int line, int column); bool document.isSpace(Cursor cursor);\n\nReturns true, if the character at the given cursor position is a whitespace, otherwise false.\n\nbool document.matchesAt(int line, int column, String text); bool document.matchesAt(Cursor cursor, String text);\n\nReturns true, if the given text matches at the corresponding cursor position, otherwise false.\n\nbool document.startsWith(int line, String text, bool skipWhiteSpaces);\n\nReturns true, if the line starts with text, otherwise false. The argument skipWhiteSpaces controls whether leading whitespaces are ignored.\n\nbool document.endsWith(int line, String text, bool skipWhiteSpaces);\n\nReturns true, if the line ends with text, otherwise false. The argument skipWhiteSpaces controls whether trailing whitespaces are ignored.\n\nbool document.setText(String text);\nSets the entire document text.\n\nbool document.clear();\nRemoves the entire text in the document.\n\nbool document.truncate(int line, int column); bool document.truncate(Cursor cursor);\n\nTruncate the given line at the given column or cursor position. Returns true on success, or false if the given line is not part of the document range.\nbool document.insertText(int line, int column, String text); bool\ndocument.insertText(Cursor cursor, String text);\n Inserts the text at the given cursor position. Returns true on success, or false, if the\ndocument is in read-only mode.\n\nbool document.removeText(int fromLine, int fromColumn, int toLine, int toColumn); bool document.removeText(Cursor from, Cursor to); bool\ndocument.removeText(Range range);\n Removes the text in the given range. Returns true on success, or false, if the document is\nin read-only mode.\n\nbool document.insertLine(int line, String text);\n Inserts text in the given line. Returns true on success, or false, if the document is in read-\nonly mode or the line is not in the document range.\n\nbool document.removeLine(int line);\n Removes the given text line. Returns true on success, or false, if the document is in read-\nonly mode or the line is not in the document range.\n\nbool document.wrapLine(int line, int column); bool document.wrapLine(C-\nursor cursor);\n Wraps the line at the given cursor position. Returns true on success, otherwise false, e.g.\nif line < 0.\n Since: KDE 4.9\n\nvoid document.joinLines(int startLine, int endLine);\n Joins the lines from startLine to endLine. Two succeeding text lines are always separated\nwith a single space.\n\nint document.lines();\n Returns the number of lines in the document.\n\nbool document.isLineModified(int line);\n Returns true, if line currently contains unsaved data.\n Since: KDE 5.0\n\nbool document.isLineSaved(int line);\n Returns true, if line was changed, but the document was saved. Hence, the line currently\ndoes not contain any unsaved data.\n Since: KDE 5.0\n\nbool document.isLineTouched(int line);\n Returns true, if line currently contains unsaved data or was changed before.\n Since: KDE 5.0\n\nbool document.findTouchedLine(int startLine, bool down);\n Search for the next touched line starting at line. The search is performed either upwards\nor downwards depending on the search direction specified in down.\n Since: KDE 5.0\n\nint document.length();\n Returns the number of characters in the document.\n\nint document.lineLength(int line);\n Returns the line’s length.\n\nvoid document.editBegin();\n Starts an edit group for undo/redo grouping. Make sure to always call editEnd() as often\nas you call editBegin(). Calling editBegin() internally uses a reference counter, i.e., this\ncall can be nested.\nvoid document.editEnd();\n Ends an edit group. The last call of editEnd() (i.e. the one for the first call of editBegin())\n finishes the edit step.\n\nint document.firstColumn(int line);\n Returns the first non-whitespace column in the given line. If there are only whitespaces in\n the line, the return value is -1.\n\nint document.lastColumn(int line);\n Returns the last non-whitespace column in the given line. If there are only whitespaces in\n the line, the return value is -1.\n\nint document.prevNonSpaceColumn(int line, int column); int\n document.prevNonSpaceColumn(Cursor cursor);\n Returns the column with a non-whitespace character starting at the given cursor position\n and searching backwards.\n\nint document.nextNonSpaceColumn(int line, int column); int\n document.nextNonSpaceColumn(Cursor cursor);\n Returns the column with a non-whitespace character starting at the given cursor position\n and searching forwards.\n\nint document.prevNonEmptyLine(int line);\n Returns the next non-empty line containing non-whitespace characters searching backwards.\n\nint document.nextNonEmptyLine(int line);\n Returns the next non-empty line containing non-whitespace characters searching forwards.\n\nbool document.isInWord(String character, int attribute);\n Returns true, if the given character with the given attribute can be part of a word, otherwise false.\n\nbool document.canBreakAt(String character, int attribute);\n Returns true, if the given character with the given attribute is suited to wrap a line, otherwise false.\n\nbool document.canComment(int startAttribute, int endAttribute);\n Returns true, if a range starting and ending with the given attributes is suited to be commented out, otherwise false.\n\nString document.commentMarker(int attribute);\n Returns the comment marker for single line comments for a given attribute.\n\nString document.commentStart(int attribute);\n Returns the comment marker for the start of multi-line comments for a given attribute.\n\nString document.commentEnd(int attribute);\n Returns the comment marker for the end of multi-line comments for a given attribute.\n\nRange document.documentRange();\n Returns a range that encompasses the whole document.\n\nCursor documentEnd();\n Returns a cursor positioned at the last column of the last line in the document.\nbool isValidTextPosition(int line, int column);\nbool isValidTextPosition(Cursor cursor);\n\nReturns true, if the given cursor position is positioned at a valid text position. A text position is valid only if it locate at the start, in the middle, or the end of a valid line. Further, a text position is invalid if it is located in a Unicode surrogate.\n\nSince: KDE 5.0\n\nint document.attribute(int line, int column);\nint document.attribute(Cursor cursor);\n\nReturns the attribute at the given cursor position.\n\nbool document.isAttribute(int line, int column, int attribute);\nbool document.isAttribute(Cursor cursor, int attribute);\n\nReturns true, if the attribute at the given cursor position equals attribute, otherwise false.\n\nString document.attributeName(int line, int column);\nString document.attributeName(Cursor cursor);\n\nReturns the attribute name as human readable text. This is equal to the itemData name in the syntax highlighting files.\n\nbool document.isAttributeName(int line, int column, String name);\nbool document.isAttributeName(Cursor cursor, String name);\n\nReturns true, if the attribute name at a certain cursor position matches the given name, otherwise false.\n\nString document.variable(String key);\n\nReturns the value of the requested document variable key. If the document variable does not exist, the return value is an empty string.\n\nvoid document.setVariable(String key, String value);\n\nSet the value of the requested document variable key.\n\nSee also: Kate document variables\nSince: KDE 4.8\n\nint document.firstVirtualColumn(int line);\n\nReturns the virtual column of the first non-whitespace character in the given line or -1, if the line is empty or contains only whitespace characters.\n\nint document.lastVirtualColumn(int line);\n\nReturns the virtual column of the last non-whitespace character in the given line or -1, if the line is empty or contains only whitespace characters.\n\nint document.toVirtualColumn(int line, int column);\nint document.toVirtualColumn(Cursor cursor); Cursor\ndocument.toVirtualCursor(Cursor cursor);\n\nConverts the given ‘real’ cursor position to a virtual cursor position, either returning an int or a Cursor object.\n\nint document.fromVirtualColumn(int line, int virtualColumn);\nint document.fromVirtualColumn(Cursor virtualCursor); Cursor\ndocument.fromVirtualCursor(Cursor virtualCursor);\n\nConverts the given virtual cursor position to a ‘real’ cursor position, either returning an int or a Cursor object.\n\nCursor document.anchor(int line, int column, Char character);\nCursor\ndocument.anchor(Cursor cursor, Char character);\n\nSearches backward for the given character starting from the given cursor. As an example, if ‘(’ is passed as character, this function will return the position of the opening ‘('. This reference counting, i.e. other ‘(...)’ are ignored.\nCursor document.rfind(int line, int column, String text, int attribute = -1); Cursor document.rfind(Cursor cursor, String text, int attribute = -1);\n\nFind searching backwards the given text with the appropriate attribute. The argument attribute is ignored if it is set to -1. The returned cursor is invalid, if the text could not be found.\n\nint document.defStyleNum(int line, int column); int\ndocument.defStyleNum(Cursor cursor);\n\nReturns the default style used at the given cursor position.\n\nbool document.isCode(int line, int column); bool document.isCode(Cursor cursor);\n\nReturns true, if the attribute at the given cursor position is not equal to all of the following styles: dsComment, dsString, dsRegionMarker, dsChar, dsOthers.\n\nbool document.isComment(int line, int column); bool\ndocument.isComment(Cursor cursor);\n\nReturns true, if the attribute of the character at the cursor position is dsComment, otherwise false.\n\nbool document.isString(int line, int column); bool document.isString(Cursor cursor);\n\nReturns true, if the attribute of the character at the cursor position is dsString, otherwise false.\n\nbool document.isRegionMarker(int line, int column); bool\ndocument.isRegionMarker(Cursor cursor);\n\nReturns true, if the attribute of the character at the cursor position is dsRegionMarker, otherwise false.\n\nbool document.isChar(int line, int column); bool document.isChar(Cursor cursor);\n\nReturns true, if the attribute of the character at the cursor position is dsChar, otherwise false.\n\nbool document.isOthers(int line, int column); bool document.isOthers(Cursor cursor);\n\nReturns true, if the attribute of the character at the cursor position is dsOthers, otherwise false.\n\n6.3.3.5 The Editor API\n\nIn addition to the document and view API, there is a general editor API that provides functions for general editor scripting functionality.\n\nString editor.clipboardText();\nReturns the text that currently is in the global clipboard.\nSince: KDE Frameworks 5.50\n\nString editor.clipboardHistory();\nThe editor holds a clipboard history that contains up to 10 clipboard entries. This function returns all entries that currently are in the clipboard history.\nSince: KDE Frameworks 5.50\n\nvoid editor.setClipboardText(String text);\nSet the contents of the clipboard to text. The text will be added to the clipboard history.\nSince: KDE Frameworks 5.50\nChapter 7\n\nConfigure KatePart\n\nSelecting Settings → Configure Application... from the menu brings up the Configure dialog box. This dialog can be used to alter a number of different settings. The settings available for change vary according to which category the user chooses from a vertical list on the left side of the dialog. By means of three buttons along the bottom of the box the user can control the process.\n\nYou may invoke the Help system, accept the current settings and close the dialog by means of the OK button, or Cancel the process. The categories Appearance, Fonts & Colors, Editing, Open/Save and Extensions are detailed below.\n\n7.1 The Editor Component Configuration\n\nThis group contains all pages related to the editor component of KatePart. Most of the settings here are defaults, they can be overridden by defining a filetype, by Document Variables or by changing them per document during an editing session.\n\n7.1.1 Appearance\n\n7.1.1.1 General\n\nDynamic Word Wrap\n\nIf this option is checked, the text lines will be wrapped at the view border on the screen.\n\nDynamic word wrap indicators (if applicable)\nChoose when the Dynamic word wrap indicators should be displayed, either Off, Follow Line Numbers or Always on.\n\nAlign dynamically wrapped lines to indentation depth:\nEnables the start of dynamically wrapped lines to be aligned vertically to the indentation level of the first line. This can help to make code and markup more readable. Additionally, this allows you to set a maximum width of the screen, as a percentage, after which dynamically wrapped lines will no longer be vertically aligned. For example, at 50%, lines whose indentation levels are deeper than 50% of the width of the screen will not have vertical alignment applied to subsequent wrapped lines.\n\nWhitespace Highlighting\nHighlight tabulators\nThe editor will display a » symbol to indicate the presence of a tab in the text.\n\nHighlight trailing spaces\nThe editor will display dots to indicate the presence of extra whitespace at the end of lines.\n\nHighlight marker size\nUse the slider to change the size of the visible highlight marker.\n\nAdvanced\n\nShow indentation lines\nIf this is checked, the editor will display vertical lines to help identifying indent lines.\n\nHighlight range between selected brackets\nIf this is enabled, the range between the selected matching brackets will be highlighted.\n\nAnimate bracket matching\nIf enabled, moving on the brackets (,{, ],,( or )) will quickly animate the matching bracket.\n\nFold first line\nIf enabled, the first line is folded, if possible. This is useful, if the file starts with a comment, such as a copyright\n\nShow Word Count\nDisplays the number of words and characters in the document and in the current selection in the status bar. This option is also available in the status bar context menu.\n\nShow line count\nDisplays the number of total lines in the document in the status bar. This option is also available in the status bar context menu.\n\n7.1.1.2 Borders\n\nBorders\n\nShow folding markers\nIf this option is checked, the current view will display marks for code folding, if code folding is available.\n\nShow preview of folded code\nIf checked, hovering over a folded region shows a preview of the folded text in a popup.\n\nShow icon border\nIf this is checked, you will see an icon border on the left hand side. The icon border shows bookmark signs for instance.\n\nShow line numbers\nIf this is checked, you will see line numbers on the left hand side.\n\nShow line modification markers\nIf this is checked, line modification markers will be visible. For more information, see Section 3.9.\n\nShow scrollbar marks\nIf this option is checked the current view will show marks on the vertical scrollbar. These marks will for instance show bookmarks.\nShow text preview on scrollbar\nIf this option is checked, and you hover the scrollbar with the mouse cursor a small\ntext preview with several lines of the current document around the cursor position\nwill be displayed. This allows you to quickly switch to another part of the document.\n\nShow scrollbar mini-map\nIf this option is checked, every new view will show a mini map of the document on\nthe vertical scrollbar.\nFor more information on the scrollbar minimap, see Section 3.10\n\nMinimap Width\nAdjusts the width of the scrollbar mini-map, defined in pixels.\n\nScrollbars visibility\nSwitch the scrollbar on, off or show the scrollbar only when needed. Click with the\nleft mouse button on the blue rectangle to display the line number range of the doc-\nument displayed on the screen. Keep the left mouse button pressed outside the blue\nrectangle to automatically scroll through the document.\n\nSort Bookmarks Menu\n\nBy creation\nEach new bookmark will be added to the bottom, independently from where it is\nplaced in the document.\n\nBy position\nThe bookmarks will be ordered by the line numbers they are placed at.\n\n7.1.2 Fonts & Colors\nThis section of the dialog lets you configure all fonts and colors in any color scheme you have, as\nwell creating new schemes or deleting existing ones. Each scheme has settings for colors, fonts\nand normal and highlight text styles.\nKatePart will preselect the currently active scheme for you, if you want to work on a different\nscheme start by selecting that from the Schema combobox. With the New and Delete button you\ncan create a new scheme or delete existing ones.\nAt the bottom of the page you can select the Default schema for KatePart.\nBy default, KatePart will base its color scheme on the current KDE color scheme. You can reset\nan individual color back to default by clicking the reset arrow to the right of the entry in the color\neditor, or you can reset all colors back to default by clicking the Use KDE Color Scheme at the\nbottom of the panel.\n\n<table>\n<thead>\n<tr>\n<th>TIP</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>You can adjust the KDE color scheme in the Colors module in System Settings.</td>\n</tr>\n</tbody>\n</table>\n\n7.1.2.1 Colors\n\nEditor Background Colors\n\nText Area\nThis is the default background for the editor area, it will be the dominant color on the\neditor area.\n\nSelected Text\nThis is the background for selected text. The default is the global selection color, as\nset in your KDE color preferences.\nCurrent Line\nSet the color for the current line. Setting this a bit different from the Normal text background helps to keep focus on the current line.\n\nSearch Highlight\nSet the color for the text that matches your last search.\n\nReplace Highlight\nSet the color for the text that matches your last replace operation.\n\nIcon Border\n\nBackground Area\nThis color is used for the marks, line numbers and folding marker borders in the left side of the editor view when they are displayed.\n\nLine Numbers\nThis color is used to draw the line numbers on the left side of the view when displayed.\n\nWord Wrap Marker\nThis color is used to draw a pattern to the left of dynamically wrapped lines when those are aligned vertically, as well as for the static word wrap marker.\n\nCode Folding\nThis color is used to highlight the section of code that would be folded when you click on the code folding arrow to the left of a document. For more information, see the code folding documentation.\n\nModified Lines\nThis color is used to highlight to the left of a document lines that have been modified but not yet saved. For more information, see Section 3.9\n\nSaved Lines\nThis color is used to highlight to the left of a document lines that have been modified this session and saved. For more information, see Section 3.9\n\nText Decorations\n\nSpelling Mistake Line\nThis color is used to indicate spelling mistakes.\n\nTab and Space Markers\nThis color is used to draw white space indicators, when they are enabled.\n\nIndentation Line\nThis color is used to draw a line to the left of indented blocks, if that feature is enabled.\n\nBracket Highlight\nThis color is used to draw the background of matching brackets.\n\nMarker Colors\n\nBookmark\nThis color is used to indicate bookmarks. For more information, see Section 3.6.\n\nActive Breakpoint\nThis color is used by the GDB plugin to indicate an active breakpoint. For more information, see the GDB Plugin documentation.\n\nReached Breakpoint\nThis color is used by the GDB plugin to indicate a breakpoint you have reached while debugging. For more information, see the GDB Plugin documentation.\n\nDisabled Breakpoint\nThis color is used by the GDB plugin to indicate an inactive breakpoint. For more information, see the GDB Plugin documentation.\nExecution\nThis color is used by the GDB plugin the line presently being executed. For more information, see the GDB Plugin documentation.\n\nWarning\nThis color is used by the build plugin to indicate a line that has caused a compiler warning. For more information, see the Build Plugin documentation.\n\nError\nThis color is used by the build plugin to indicate a line that has caused a compiler error. For more information, see the Build Plugin documentation.\n\nText Templates & Snippets\n\nBackground\nThis color is used by the Kate Snippets plugin to mark the background of a snippet.\n\nEditable Placeholder\nThis color is used by the Kate Snippets plugin to mark a placeholder that you can click in to edit manually.\n\nFocused Editable Placeholder\nThis color is used by the Kate Snippets plugin to mark the placeholder that you are presently editing.\n\nNot Editable Placeholder\nThis color is used by the Kate Snippets plugin to mark a placeholder that cannot be edited manually, such as one that is automatically populated. For more information, see the Kate Snippets documentation.\n\nUse KDE Color Scheme\nClicking this button will set all the above defined colors to match the current color scheme defined in KDE's System Settings. For more information, see the documentation for the Colors KDE Control Module.\nIf you do not use the KDE Plasma Workspaces, this button will have no effect, and may not be present.\n\n7.1.2.2 Font\nHere you can choose the font for the schema. You can choose from any font available on your system, and set a default size. A sample text displays at the bottom of the dialog, so you can see the effect of your choices.\nFor more information about selecting a font, see the Choosing Fonts section of the KDE Fundamentals documentation.\n\n7.1.2.3 Default Text Styles\nThe default text styles are inherited by the highlight text styles, allowing the editor to present text in a very consistent way, for example comment text is using the same style in almost all of the text formats that KatePart can highlight.\nThe name in the list of styles is using the style configured for the item, providing you with an immediate preview when configuring a style.\nEach style lets you select common attributes as well as foreground and background colors. To unset a background color, right-click to use the context menu.\n7.1.2.4 Highlighting Text Styles\n\nHere you can edit the text styles used by a specific highlight definition. The editor preselects the highlight used by your current document. To work on a different highlight, select one in the Highlight combobox above the style list.\n\nThe name in the list of styles is using the style configured for the item, providing you with an immediate preview when configuring a style.\n\nEach style lets you select common attributes as well as foreground and background colors. To unset a background color, right-click to use the context menu. In addition you can see if a style is equal to the default style used for the item, and set it to that if not.\n\nYou will notice that many highlights contain other highlights represented by groups in the style list. For example most highlights import the Alert highlight, and many source code formats imports the Doxygen highlight. Editing colors in those groups only affects the styles when used in the edited highlight format.\n\n7.1.3 Editing\n\n7.1.3.1 General\n\nStatic Word Wrap\n\nWord wrap is a feature that causes the editor to automatically start a new line of text and move (wrap) the cursor to the beginning of that new line. KatePart will automatically start a new line of text when the current line reaches the length specified by the Wrap Words At: option.\n\nEnable static word wrap\n\nTurns static word wrap on or off.\n\nShow static word wrap marker (if applicable)\n\nIf this option is checked, a vertical line will be drawn at the word wrap column as defined in the Settings → Configure Editor... in the Editing tab. Please note that the word wrap marker is only drawn if you use a fixed pitch font.\n\nWrap words at:\n\nIf the Enable static word wrap option is selected this entry determines the length (in characters) at which the editor will automatically start a new line.\n\nInput Mode\n\nThe selected input mode will be enabled when opening a new view. You can still toggle the vi input mode on/off for a particular view in the Edit menu.\n\nAuto brackets\n\nWhen the user types a left bracket ([, (, or {) KatePart automatically enters the right bracket (], ), or }) to the right of the cursor.\n\nWhen text is selected, typing one of the characters wraps the selected text.\n\nCopy and Paste\n\nCopy/Cut the current line if no selection\n\nIf this option is enabled and the text selection is empty, copy and cut action are performed for the line of text at the actual cursor position.\n7.1.3.2 Text Navigation\n\nText Cursor Movement\n\n- **Smart home and smart end**\n - When selected, pressing the home key will cause the cursor to skip white space and go to the start of a line’s text.\n\n- **PageUp/PageDown moves cursor**\n - This option changes the behavior of the cursor when the user presses the `Page Up` or `Page Down` key. If unselected the text cursor will maintain its relative position within the visible text in KatePart as new text becomes visible as a result of the operation. So if the cursor is in the middle of the visible text when the operation occurs it will remain there (except when one reaches the beginning or end.) With this option selected, the first key press will cause the cursor to move to either the top or bottom of the visible text as a new page of text is displayed.\n\n- **Autocenter cursor:**\n - Sets the number of lines to maintain visible above and below the cursor when possible.\n\nText Selection Mode\n\n- **Normal**\n - Selections will be overwritten by typed text and will be lost on cursor movement.\n\n- **Persistent**\n - Selections will stay even after cursor movement and typing.\n\n- **Allow scrolling past the end of the document**\n - This option lets you scroll past the end of the document. This can be used to vertically centre the bottom of the document, or put it on top of the current view.\n\n- **Backspace key removes character’s base with its diacritics**\n - When selected, composed characters are removed with their diacritics instead of only removing the base character. This is useful for Indic locales.\n\n7.1.3.3 Indentation\n\nDefault indentation mode:\n\n- Select the automatic indentation mode you want to use as default. It is strongly recommended to use `None` or `Normal` here, and use filetype configurations to set other indentation modes for text formats like C/C++ code or XML.\n\nIndent using\n\n- **Tabulators**\n - When this is enabled the editor will insert tabulator characters when you press the `Tab` key or use automatic indentation.\n\n- **Spaces**\n - When this is enabled the editor will insert a calculated number of spaces according to the position in the text and the `tab-width` setting when you press the `Tab` key or use automatic indentation.\n\n- **Tabulators and Spaces**\n - When this is enabled, the editor will insert spaces as describe above when indenting or pressing `Tab` at the beginning of a line, but insert tabulators when the `Tab` key is pressed in the middle or end of a line.\nTab width:\nThis configures the number of spaces that are displayed in place of a tabulator character.\n\nIndentation width:\nThe indentation width is the number of spaces which is used to indent a line. If configured to indent using tabulators, a tabulator character is inserted if the indentation is divisible by the tab width.\n\nIndentation Properties\n\nKeep extra spaces\nIf this option is disabled, changing the indentation level aligns a line to a multiple of the width specified in Indentation width.\n\nAdjust indentation of text pasted from the clipboard\nIf this option is selected, text pasted from the clipboard is indented. Triggering the Undo action removes the indentation.\n\nIndentation Actions\n\nBackspace key in leading blank space unindent\nIf this option is selected, the Backspace key decreases the indentation level if the cursor is located in the leading blank space of a line.\n\nTab key action (if no selection exists)\nIf you want Tab to align the current line in the current code block like in emacs, make Tab a shortcut to the action Align.\n\nAlways advance to the next tab position\nIf this option is selected, the Tab key always inserts white space so that the next tab position is reached. If the option Insert spaces instead of tabulators on the General tab in the Editing page is enabled, spaces are inserted; otherwise, a single tabulator is inserted.\n\nAlways increase indentation level\nIf this option is selected, the Tab key always indents the current line by the number of character positions specified in Indentation width.\n\nIncrease indentation level if in leading blank space\nIf this option is selected, the Tab key either indents the current line or advances to the next tab position. If the insertion point is at or before the first non-space character in the line, or if there is a selection, the current line is indented by the number of character positions specified in Indentation width. If the insertion point is located after the first non-space character in the line and there is no selection, white space is inserted so that the next tab position is reached: if the option Insert spaces instead of tabulators on the General tab in the Editing page is enabled, spaces are inserted; otherwise, a single tabulator is inserted.\n\n7.1.3.4 Auto Completion\n\nGeneral\n\nEnable auto completion\nIf enabled, a word completion box automatically pops up during typing showing a list of text entries to complete the current text under the cursor.\n\nMinimal word length to complete\nWhile typing text, the word completion searches for words in the document starting with the already typed text. This option configures the minimal amount of characters that are needed to make the word completion active and pop up a completion box.\nRemove tail on complete\nRemove the tail of a previous word when the completion item is chosen from a list.\n\nKeyword completion\nIf enabled, the built-in autocompletion uses the keywords defined by the syntax highlighting.\n\n7.1.3.5 Spellcheck\nThese configuration options are described in the documentation for the System Settings module Spell Checker.\n\n7.1.3.6 Vi Input Mode\n\nGeneral\n\nLet Vi commands override Kate shortcuts\nWhen selected, Vi commands will override KatePart’s built-in commands. For example: Ctrl+R will redo, and override the standard action (showing the search and replace dialog).\n\nDisplay relative line numbers\nif this is enabled, the current line always refers to line 0. Lines above and below increase the line number relatively.\n\nKey Mapping\nKey mapping is used to change the meaning of typed keys. This allows you to move commands to other keys or make special keypresses for doing a series of commands.\n\nExample:\nF2 -> I--- Esc\nThis will prepend I--- to a line when pressing F2.\n\n7.1.4 Open/Save\n\n7.1.4.1 General\n\nFile Format\n\nEncoding\nThis defines the standard encoding to use to open/save files, if not changed in the open/save dialog or by using a command line option.\n\nEncoding Detection\nSelect an item from the drop down box, either to disable autodetection or use Universal to enable autodetection for all encodings. But as this may probably only detect utf-8/utf-16, selecting a region will use custom heuristics for better results. If neither the encoding chosen as standard above, nor the encoding specified in the open/save dialog, nor the encoding specified on command line match the content of the file, this detection will be run.\nFallback Encoding\n\nThis defines the fallback encoding to try for opening files if neither the encoding chosen as standard above, nor the encoding specified in the open/save dialog, nor the encoding specified on command line match the content of the file. Before this is used, an attempt will be made to determine the encoding to use by looking for a byte order mark at start of file: if one is found, the right unicode encoding will be chosen; otherwise encoding detection will run, if both fail fallback encoding will be tried.\n\nEnd of line\n\nChoose your preferred end of line mode for your active document. You have the choice between UNIX®, DOS/Windows® or Macintosh.\n\nAutomatic end of line detection\n\nCheck this if you want the editor to autodetect the end of line type. The first found end of line type will be used for the whole file.\n\nEnable byte order mark (BOM)\n\nThe byte order mark is a special sequence at the beginning of unicode encoded documents. It helps editors to open text documents with the correct unicode encoding. For more information see Byte Order Mark.\n\nLine Length Limit\n\nUnfortunately, due to deficiencies in Qt™, KatePart experiences poor performance when working with extremely long lines. For that reason, KatePart will automatically wrap lines when they are longer than the number of characters specified here. To disable this, set this to 0.\n\nAutomatic Cleanups on Save\n\nRemove trailing spaces\n\nThe editor will automatically eliminate extra spaces at the ends of lines of text while saving the file. You can select Never to disable this functionality, On Modified Lines to do so only on lines that you have modified since you last saved the document, or In Entire Document to remove them unconditionally from the entire document.\n\nAppend newline at end of file on save\n\nThe editor will automatically append a newline to the end of the file if one is not already present upon saving the file.\n\n7.1.4.2 Advanced\n\nBackup on Save\n\nBacking up on save will cause KatePart to copy the disk file to <prefix><filename><suffix> before saving changes. The suffix defaults to ~ and prefix is empty by default.\n\nLocal files\n\nCheck this if you want backups of local files when saving.\n\nRemote files\n\nCheck this if you want backups of remote files when saving.\n\nPrefix\n\nEnter the prefix to prepend to the backup file names.\n\nSuffix\n\nEnter the suffix to add to the backup file names.\nSwap file options\nKatePart is able to recover (most of) what was written after last save in case of a crash or power failure. A swap file (.swp.<filename>) is created after the first editing action on a document. If the user doesn’t save the changes and KatePart crashes, the swap file remains on the disk. When opening a file, KatePart checks if there is a swap file for the document and if it is, it asks the user whether he wants to recover the lost data or not. The user has the possibility to view the differences between the original file and the recovered one, too. The swap file is deleted after every save and on normal exit.\nKatePart syncs the swap files on the disk every 15 seconds, but only if they have changed since the last sync. The user can disable the swap files syncing if he wants, by selecting Disable, but this can lead to more data loss.\nWhen enabled, the swap files are saved in the same folder as the file. When Alternative Directory is chosen, swap files are created in the specified folder. This is useful for network file systems to avoid unnecessary network traffic.\n\n7.1.4.3 Modes & Filetypes\nThis page allows you to override the default configuration for documents of specified mimetypes. When the editor loads a document, it will try if it matches the file masks or mimetypes for one of the defined filetypes, and if so apply the variables defined. If more filetypes match, the one with the highest priority will be used.\n\nFiletype:\nThe filetype with the highest priority is the one displayed in the first drop down box. If more filetypes were found, they are also listed.\n\nNew\nThis is used to create a new filetype. After you click on this button, the fields below get empty and you can fill the properties you want for the new filetype.\n\nDelete\nTo remove an existing filetype, select it from the drop down box and press the Delete button.\n\nProperties of current filetype\nThe filetype with the highest priority is the one displayed in the first drop down box. If more filetypes were found, they are also listed.\n\nName:\nThe name of the filetype will be the text of the corresponding menu item. This name is displayed in the Tools → Filetypes menu.\n\nSection:\nThe section name is used to organize the file types in menus. This is also used in the Tools → Filetypes menu.\n\nVariables:\nThis string allows you to configure KatePart’s settings for the files selected by this mimetype using KatePart variables. You can set almost any configuration option, such as highlight, indent-mode, etc.\nPress Edit to see a list of all available variables and their descriptions. Select the checkbox on the left to enable a particular variable and then set the value of the variable on the right. Some variables provide a drop-down box to select possible values from while others require you to enter a valid value manually.\nFor complete information on these variables, see Configuring with Document Variables.\nHighlighting:\nIf you create a new file type, this drop down box allows you to select a file type for\nhighlighting.\n\nIndentation Mode:\nThe drop down box specifies the indentation mode for new documents.\n\nFile extensions:\nThe wildcards mask allows you to select files by filename. A typical mask uses an\nasterisk and the file extension, for example *.txt; *.text. The string is a semicolon-\nseparated list of masks.\n\nMIME types:\nDisplays a wizard that helps you easily select mimetypes.\n\nPriority:\nSets a priority for this file type. If more than one file type selects the same file, the one\nwith the highest priority will be used.\n\n7.2 Configuring With Document Variables\n\nKatePart variables is KatePart’s implementation of document variables, similar to Emacs and vi\nmodelines. In katepart, the lines have the following format: kate: VARIABLENAME VALUE;\n[ VARIABLENAME VALUE; ... ] The lines can of course be in a comment, if the file is in a\nformat with comments. Variable names are single words (no whitespace), and anything up to the\nnext semicolon is the value. The semicolon is required.\n\nHere is an example variable line, forcing indentation settings for a C++, java or javascript file:\n\n```\n// kate: replace-tabs on; indent-width 4; indent-mode cstyle;\n```\n\n**NOTE**\nOnly the first and last 10 lines are searched for variable lines.\n\nAdditionally, document variables can be placed in a file called .kateconfig in any directory,\nand the configured settings will be applied as if the modelines were entered on every file in the\ndirectory and its subdirectories. Document variables in .kateconfig use the same syntax as in\nmodelines, but with extended options.\n\nThere are variables to support almost all configurations in KatePart, and additionally plugins can\nuse variables, in which case it should be documented in the plugin’s documentation.\n\nKatePart has support for reading configurations from .editorconfig files, when the editorconfig\nlibrary is installed. KatePart automatically searches for a .editorconfig whenever you open a\nfile. It gives priority to .kateconfig files, though.\n\n7.2.1 How KatePart uses Variables\n\nWhen reading configuration, katepart looks in the following places (in that order):\n\n- The global configuration.\n- Optional session data.\n- The “Filetype” configuration.\n- Document variables in .kateconfig.\n• Document variables in the document itself.\n• Settings made during editing from menu or command line.\n\nAs you can see, document variables are only overridden by changes made at runtime. Whenever a document is saved, the document variables are reread, and will overwrite changes made using menu items or the command line.\n\nAny variable not listed below is stored in the document and can be queried by other objects such as plugins, which can use them for their own purpose. For example, the variable indent mode uses document variables for its configuration.\n\nThe variables listed here documents KatePart version 5.38. More variables may be added in the future. There are 3 possible types of values for variables, with the following valid expressions:\n\n• BOOL - on | off | true | false | 1 | 0\n• INTEGER - any integer number\n• STRING - anything else\n\n7.2.2 Available Variables\n\n**auto-brackets [BOOL]**\nEnable automatic insertion of brackets.\n\n**auto-center-lines [INT]**\nSet the number of autocenter lines.\n\n**background-color [STRING]**\nSet the document background color. The value must be something that can be evaluated to a valid color, for example #ff0000.\n\n**backspace-indents [BOOL]**\nEnable or disable unindenting when Backspace is pressed.\n\n**block-selection [BOOL]**\nTurn block selection on or off.\n\n**bom | byte-order-mark | byte-order-marker [BOOL]**\nEnable/disable the byte order mark (BOM) when saving files in Unicode format (utf8, utf16, utf32).\nSince: Kate 3.4 (KDE 4.4)\n\n**bracket-highlight-color [STRING]**\nSet the color for the bracket highlight. The value must be something that can be evaluated to a valid color, for example #ff0000.\n\n**current-line-color [STRING]**\nSet the color for the current line. The value must be something that can be evaluated to a valid color, for example #ff0000.\n\n**default-dictionary [STRING]**\nSets the default dictionary used for spellchecking.\nSince: Kate 3.4 (KDE 4.4)\n\n**dynamic-word-wrap [BOOL]**\nTurns dynamic word wrap on or off.\nThe KatePart Handbook\n\neol | end-of-line [STRING]\n Set the end of line mode. Valid settings are unix, mac and dos.\n\nfolding-markers [BOOL]\n Set the display of folding markers on or off.\n\nfolding-preview [BOOL]\n Enable folding preview in the editor border.\n\nfont-size [INT]\n Set the point size of the document font.\n\nfont [STRING]\n Set the font of the document. The value should be a valid font name, for example courier.\n\nhl | syntax [STRING]\n Set the syntax highlighting. Valid strings are all the names available in the menus. For instance, for C++ simply write C++.\n\nicon-bar-color [STRING]\n Set the icon bar color. The value must be something that can be evaluated to a valid color, for example #ff0000.\n\nicon-border [BOOL]\n Set the display of the icon border on or off.\n\nindent-mode [STRING]\n Set the auto-indentation mode. The options none, normal, cstyle, haskell, lilypond, lisp, python, ruby and xml are recognized. See the section Section 3.8 for details.\n\nindent-pasted-text [BOOL]\n Enable/disable adjusting indentation of text pasted from the clipboard.\n Since: Kate 3.11 (KDE 4.11)\n\nindent-width [INT]\n Set the indentation width.\n\nkeep-extra-spaces [BOOL]\n Set whether to keep extra spaces when calculating indentation width.\n\nline-numbers [BOOL]\n Set the display of line numbers on or off.\n\nnewline-at-eof [BOOL]\n Add an empty line at the end of the file (EOF) when saving the document.\n Since: Kate 3.9 (KDE 4.9)\n\noverwrite-mode [BOOL]\n Set overwrite mode on or off.\n\npersistent-selection [BOOL]\n Set persistent selection on or off.\n\nreplace-tabs-save [BOOL]\n Set tab to space conversion on save on or off.\n\nreplace-tabs [BOOL]\n Set dynamic tab to space conversion on or off.\n**remove-trailing-spaces [STRING]**\nRemoves trailing spaces when saving the document. Valid options are:\n\n- **none**, − or 0: never remove trailing spaces.\n- **modified**, **mod**, + or 1: remove trailing spaces only in modified lines. The modified lines are marked by the line modification system.\n- **all**, * or 2: remove trailing spaces in the entire document.\n\nSince: KDE 4.10.\n\n**scrollbar-minimap [BOOL]**\nShow scrollbar minimap.\n\n**scrollbar-preview [BOOL]**\nShow scrollbar preview.\n\n**scheme [STRING]**\nSet the color scheme. The string must be the name of a color scheme that exists in your configuration to have any effect.\n\n**selection-color [STRING]**\nSet the selection color. The value must be something that can be evaluated to a valid color, for example **#ff0000**.\n\n**show-tabs [BOOL]**\nSet the visual tab character on or off.\n\n**smart-home [BOOL]**\nSet smart home navigation on or off.\n\n**tab-indent [BOOL]**\nSet Tab key indentation on or off.\n\n**tab-width [INT]**\nSet the tab character display width.\n\n**undo-steps [INT]**\nSet the number of undo steps to remember.\nNote: Deprecated since Kate 3 in KDE4. This variable is ignored. The maximal count of undo steps is unlimited.\n\n**word-wrap-column [INT]**\nSet the static word wrap width.\n\n**word-wrap-marker-color [STRING]**\nSet the word wrap marker color. The value must be something that can be evaluated to a valid color, for example **#ff0000**.\n\n**word-wrap [BOOL]**\nSet static word wrapping on or off.\n7.2.3 Extended Options in `.kateconfig` files\n\nKatePart always search for a `.kateconfig` file for local files (not remote files). In addition, it is possible to set options based on wildcards (file extensions) as follows:\n\n```bash\nkate: tab-width 4; indent-width 4; replace-tabs on;\nkate-wildcard (*.xml): indent-width 2;\nkate-wildcard (Makefile): replace-tabs off;\n```\n\nIn this example, all files use a tab-width of 4 spaces, an indent-width of 4 spaces, and tabs are replaced expanded to spaces. However, for all `*.xml` files, the indent width is set to 2 spaces. And Makefiles use tabs, i.e. tabs are not replaced with spaces.\n\nWildcards are semicolon separated, i.e. you can also specify multiple file extensions as follows:\n\n```bash\nkate-wildcard (*.json; *.xml): indent-width 2;\n```\n\nFurther, you can also use the mimetype to match certain files, e.g. to indent all C++ source files with 4 spaces, you can write:\n\n```bash\nkate-mimetype (text/x-c++ src): indent-width 4;\n```\n\n**NOTE**\n\nNext to the support in `.kateconfig` files, wildcard and mimetype dependent document variables are also supported in the files itself as comments.\nChapter 8\n\nCredits and License\n\nKatePart and KWrite Copyright 2001-2014 by the Kate team.\nBased on the original KWrite, which was Copyright 2000 by Jochen Wilhelmy digisnap@cs.tu-berlin.de\nContributions:\n\n• Christoph Cullmann cullmann@kde.org\n• Michael Bartl michael.bartl1@chello.at\n• Philip phlip_cpp@my-deja.com\n• Anders Lund anders@alweb.dk\n• Matt Newell newellm@proaxis.com\n• Joseph Wenninger kde@jowenn.at\n• Jochen Wilhelmy digisnap@cs.tu-berlin.de\n• Michael Koch koch@kde.org\n• Christian Gebauer gebauer@kde.org\n• Simon Hausmann hausmann@kde.org\n• Glen Parker glenebob@nwlink.com\n• Scott Manson sdmanson@altnet.net\n• John Firebaugh jfirebaugh@kde.org\n\nThe KatePart documentation is based on the original KWrite documentation, modified to be relevant to all KatePart consumers.\nThe original KWrite documentation was written by Thad McGinnis ctmcginnis@compuserve.com, with lots of modifications from Christian Tibirna tibirna@kde.org. Converted to docbook/proofreading by Lauri Watts lauri@kde.org and updated by Anne-Marie Mahfouf annma@kde.org and Anders Lund anders@alweb.dk\n\nThe current KatePart documentation is maintained by T.C. Hollingsworth tchollingsworth@gmail.com. Please send comments or suggestions to the KatePart development mailing list at kwrite-devel@kde.org or file a bug in the KDE Bugtracking System.\n\nThis documentation is licensed under the terms of the GNU Free Documentation License.\nThis program is licensed under the terms of the GNU General Public License.\nChapter 9\n\nThe VI Input Mode\n\nErlend Hamberg\n\n9.1 VI Input Mode\n\nThe goal of the VI mode is not to be a complete replacement for Vim and support all Vim’s features. Its aim is to make the ‘Vim way’ of text editing - and the Vim habits learned - available for programs using the KatePart text editor as their internal editor.\n\nThe VI mode aims to integrate nicely with the program and deviate from Vim’s behavior where it makes sense. For example, :w will open a save dialog in KatePart’s VI mode.\n\nTo enable the VI Input Mode for all new views, go to Settings → Configure KatePart... → Editing → VI Input Mode. On this tab you can set options for the VI Input Mode and define and edit the key mapping in this mode. VI Input Mode can also be toggled with the VI Input Mode setting in the Edit menu. (The default shortcut key is Meta+Ctrl+V - where Meta usually is the Windows key).\n\nNOTE\nMany Vi Mode keyboard commands are case-sensitive, unlike most KDE keyboard shortcuts. That means that y and Y are different commands. To enter the y (yank) command, make sure Caps Lock is disabled and press Y. To enter the Y (yank to end of line) command, Shift+Y.\n\nThis does not apply to commands that use the Ctrl key, which may be entered regardless of Caps Lock mode and without pressing Shift. However, some commands require the use of a Ctrl-key combination followed by another key which is case sensitive. For instance, to input ‘Ctrl+W, h’ (switch to split view right) make sure Caps Lock is disabled, press Ctrl+W, release, and then press H.\n\n9.1.1 Incompatibilities with Vim\n\nThere are only a few features of KatePart’s VI mode which are incompatible with Vim (not counting things missing). They are listed below together with the respective reasons.\n\n• KatePart: U and Ctrl+R is redo.\n Vim: Ctrl+R is normal redo, U is used to undo all latest changes on one line.\n\nThe reason for having U act as redo in KatePart’s VI mode is that the shortcut Ctrl+R by default is taken by KatePart’s replace function (search and replace). By default, the VI mode won’t override KatePart’s shortcuts (this can be configured in Settings → Configure\nThe KatePart Handbook\n\nKatePart...+Editing → Vi Input Mode), therefore a redo-action needs to be available as a ‘regular’ key press, too. Besides, the behavior of the U command in Vim does not map well to KatePart’s internal undo system, so it would be non-trivial to support anyway.\n\n• KatePart: print shows the Print dialog.\n Vim: print prints the lines of the given range like its grandfather ed.\n Commands like :print are available not only in the VI mode but for users using ‘regular’ KatePart, too - therefore the :print command opens the print dialog - following the principle of least surprise instead of mimicking Vim’s behavior.\n\n• KatePart: Y yanks to end of line.\n Vim: Y yanks whole line, just like yy.\n VI’s behavior for the Y command is in practice a bug. For both change and delete commands, cc/dd will do its action on the current line and C/D will work from the cursor column to the end of the line. However, both yy and Y yanks the current line. In KatePart’s VI Mode Y will yank to the end of the line. This is described as ‘more logical’ in the Vim documentation.\n\n• KatePart: O and o opens [count] new lines and puts you in insert mode.\n Vim: O and o opens a new line and inserts text [count] times when leaving insert mode.\n This is mostly done as a consequence of witnessing many people being confused by this behavior on a vim irc channel (#vim on freenode).\n\n9.1.2 Switching Modes\n\n• Normal Mode permits you to enter commands to navigate or edit a document, and is the default mode. You can return to it from any other mode by pressing Esc.\n\n• Visual Mode permits you to highlight text in a document. Most Normal Mode commands are also valid in this mode. You can enter it by pressing v to select characters or V to select lines.\n\n• Insert Mode permits you to edit the document directly. You can enter it by pressing i or one of several other commands listed below.\n\n• Command Mode invokes KatePart’s command line, permitting you to run many commands available in Vi implementations as well as some specific to KatePart. For more information on these commands, see Section 5.2. To use it, press ;, enter the command, and press Enter.\n\n9.1.3 Integration with Kate features\n\n• Visual Mode is entered automatically when text is selected with the mouse. It is also entered when using functions of Kate that select text, such as Select All (either from the menu or via Ctrl+A.)\n\n• Vi marks and Kate bookmarks are integrated. When a mark is created in Vi Mode, a corresponding Kate bookmark is created and appears in the Bookmarks menu. Conversely, when a Kate bookmark is created, a corresponding Vi mark at the 0 column is also created.\n\n9.1.4 Supported normal/visual mode commands\n<table>\n<thead>\n<tr>\n<th>Key</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>a</td>\n<td>Enter Insert Mode; append after cursor</td>\n</tr>\n<tr>\n<td>A</td>\n<td>Enter Insert Mode; append after line</td>\n</tr>\n<tr>\n<td>i</td>\n<td>Enter Insert Mode; insert before cursor</td>\n</tr>\n<tr>\n<td>Insert</td>\n<td>Enter Insert Mode; insert before cursor</td>\n</tr>\n<tr>\n<td>I</td>\n<td>Enter Insert Mode; insert before first non-blank char on line</td>\n</tr>\n<tr>\n<td>gi</td>\n<td>Enter Insert Mode; insert before place, where leaving the last insert mode</td>\n</tr>\n<tr>\n<td>v</td>\n<td>Enter Visual Mode; select characters</td>\n</tr>\n<tr>\n<td>V</td>\n<td>Enter Visual Mode; select lines</td>\n</tr>\n<tr>\n<td>Ctrl+v</td>\n<td>Enter Visual Mode; select blocks</td>\n</tr>\n<tr>\n<td>gb</td>\n<td>Enter Visual Mode; reselect the last selection</td>\n</tr>\n<tr>\n<td>o</td>\n<td>Open a new line below current line</td>\n</tr>\n<tr>\n<td>O</td>\n<td>Open a new line above current line</td>\n</tr>\n<tr>\n<td>J</td>\n<td>Join lines</td>\n</tr>\n<tr>\n<td>c</td>\n<td>Change: follow by a motion to delete and enter Insert mode</td>\n</tr>\n<tr>\n<td>C</td>\n<td>Change to end of line: Delete to end of line and enter Insert Mode</td>\n</tr>\n<tr>\n<td>cc</td>\n<td>Change line: Delete line and enter Insert Mode</td>\n</tr>\n<tr>\n<td>s</td>\n<td>Substitute character</td>\n</tr>\n<tr>\n<td>S</td>\n<td>Substitute line</td>\n</tr>\n<tr>\n<td>dd</td>\n<td>Delete line</td>\n</tr>\n<tr>\n<td>d</td>\n<td>Follow by a motion to delete</td>\n</tr>\n<tr>\n<td>D</td>\n<td>Delete to end of line</td>\n</tr>\n<tr>\n<td>x</td>\n<td>Delete character to right of cursor</td>\n</tr>\n<tr>\n<td>Delete</td>\n<td>Delete character to right of cursor</td>\n</tr>\n<tr>\n<td>X</td>\n<td>Delete character to left of cursor</td>\n</tr>\n<tr>\n<td>gu</td>\n<td>Follow with a motion to make lowercase</td>\n</tr>\n<tr>\n<td>guu</td>\n<td>Make the current line lowercase</td>\n</tr>\n<tr>\n<td>gUU</td>\n<td>Make the current line uppercase</td>\n</tr>\n<tr>\n<td>y</td>\n<td>Follow by a motion to ‘yank’ (copy)</td>\n</tr>\n<tr>\n<td>yy</td>\n<td>Yank (copy) line</td>\n</tr>\n<tr>\n<td>Y</td>\n<td>Yank (copy) line</td>\n</tr>\n<tr>\n<td>p</td>\n<td>Paste after cursor</td>\n</tr>\n<tr>\n<td>P</td>\n<td>Paste before cursor</td>\n</tr>\n<tr>\n<td>]p</td>\n<td>Paste after cursor indented</td>\n</tr>\n<tr>\n<td>[p</td>\n<td>Paste before cursor indented</td>\n</tr>\n<tr>\n<td>r</td>\n<td>Follow with a character to replace the character after the cursor</td>\n</tr>\n<tr>\n<td>R</td>\n<td>Enter Replace Mode</td>\n</tr>\n<tr>\n<td>:</td>\n<td>Enter Command Mode</td>\n</tr>\n<tr>\n<td>/</td>\n<td>Search</td>\n</tr>\n<tr>\n<td>u</td>\n<td>Undo</td>\n</tr>\n<tr>\n<td>Ctrl+R</td>\n<td>Redo</td>\n</tr>\n<tr>\n<td>U</td>\n<td>Redo</td>\n</tr>\n<tr>\n<td>m</td>\n<td>Set mark (can be used by motions later)</td>\n</tr>\n<tr>\n<td>n</td>\n<td>Find next</td>\n</tr>\n<tr>\n<td>N</td>\n<td>Find previous</td>\n</tr>\n<tr>\n<td>Command</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>---------</td>\n<td>-------------</td>\n</tr>\n<tr>\n<td>>></td>\n<td>Indent line</td>\n</tr>\n<tr>\n<td><<</td>\n<td>Unindent line</td>\n</tr>\n<tr>\n<td>></td>\n<td>Indent lines</td>\n</tr>\n<tr>\n<td><</td>\n<td>Unindent lines</td>\n</tr>\n<tr>\n<td>Ctrl+F</td>\n<td>Page down</td>\n</tr>\n<tr>\n<td>Ctrl+B</td>\n<td>Page up</td>\n</tr>\n<tr>\n<td>ga</td>\n<td>Print the ASCII value of the character</td>\n</tr>\n<tr>\n<td>.</td>\n<td>Repeat last change</td>\n</tr>\n<tr>\n<td>==</td>\n<td>commandAlignLine</td>\n</tr>\n<tr>\n<td>=</td>\n<td>commandAlignLines</td>\n</tr>\n<tr>\n<td>~</td>\n<td>Change case of current character</td>\n</tr>\n<tr>\n<td>Ctrl+S</td>\n<td>Split view horizontally</td>\n</tr>\n<tr>\n<td>Ctrl+V</td>\n<td>Split view vertically</td>\n</tr>\n<tr>\n<td>Ctrl+W, w</td>\n<td>Cycle to next split window</td>\n</tr>\n<tr>\n<td>Ctrl+W, h</td>\n<td>Go to left split window</td>\n</tr>\n<tr>\n<td>Ctrl+W Left</td>\n<td>Go to left split window</td>\n</tr>\n<tr>\n<td>Ctrl+W, l</td>\n<td>Go to right split window</td>\n</tr>\n<tr>\n<td>Ctrl+W Right</td>\n<td>Go to right split window</td>\n</tr>\n<tr>\n<td>Ctrl+W, k</td>\n<td>Go to above split window</td>\n</tr>\n<tr>\n<td>Ctrl+W Up</td>\n<td>Go to above split window</td>\n</tr>\n<tr>\n<td>Ctrl+W Down</td>\n<td>Go to below split window</td>\n</tr>\n</tbody>\n</table>\n\n### 9.1.5 Supported motions\n\nThese may be used to move around a document in Normal or Visual mode, or in conjunction with one of the above commands. They may be preceded by a count, which indicates how many of the appropriate movements to make.\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>h</td>\n<td>Left</td>\n</tr>\n<tr>\n<td>Left</td>\n<td>Left</td>\n</tr>\n<tr>\n<td>Backspace</td>\n<td>Left</td>\n</tr>\n<tr>\n<td>j</td>\n<td>Down</td>\n</tr>\n<tr>\n<td>Down</td>\n<td>Down</td>\n</tr>\n<tr>\n<td>k</td>\n<td>Up</td>\n</tr>\n<tr>\n<td>Up</td>\n<td>Up</td>\n</tr>\n<tr>\n<td>l</td>\n<td>Right</td>\n</tr>\n<tr>\n<td>Right</td>\n<td>Right</td>\n</tr>\n<tr>\n<td>Space</td>\n<td>Right</td>\n</tr>\n<tr>\n<td>$</td>\n<td>End of line</td>\n</tr>\n<tr>\n<td>End</td>\n<td>End of line</td>\n</tr>\n<tr>\n<td>0</td>\n<td>First character of line (Column 0)</td>\n</tr>\n<tr>\n<td>Home</td>\n<td>First character of line</td>\n</tr>\n<tr>\n<td>^</td>\n<td>First non-blank character of line</td>\n</tr>\n<tr>\n<td>f</td>\n<td>Follow by character to move to right of cursor</td>\n</tr>\n<tr>\n<td>F</td>\n<td>Follow by character to move to left of cursor</td>\n</tr>\n<tr>\n<td>t</td>\n<td>Follow by character to move to right of cursor, placing the cursor on character before it</td>\n</tr>\n</tbody>\n</table>\n### 9.1.6 Supported text objects\n\nThese may be used to select certain portions of a document.\n\n<table>\n<thead>\n<tr>\n<th>iw</th>\n<th>Inner word: word including whitespace</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>aw</td>\n<td>A word: word excluding whitespace</td>\n</tr>\n<tr>\n<td>i"</td>\n<td>Previous double-quote (""") to next double-quote, including quotation marks</td>\n</tr>\n<tr>\n<td>a"</td>\n<td>Previous double-quote (""") to next double-quote, excluding quotation marks</td>\n</tr>\n<tr>\n<td>i'</td>\n<td>Previous single-quote (') to next single-quote, including quotation marks</td>\n</tr>\n<tr>\n<td>a'</td>\n<td>Previous single-quote (') to next single-quote, excluding quotation marks</td>\n</tr>\n</tbody>\n</table>\n## 9.1.7 Supported insert mode commands\n\n<table>\n<thead>\n<tr>\n<th>Key Combination</th>\n<th>Command Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Ctrl+D</td>\n<td>Unindent</td>\n</tr>\n<tr>\n<td>Ctrl+T</td>\n<td>Indent</td>\n</tr>\n<tr>\n<td>Ctrl+E</td>\n<td>Insert from below</td>\n</tr>\n<tr>\n<td>Ctrl+Y</td>\n<td>Delete word</td>\n</tr>\n<tr>\n<td>Ctrl+W</td>\n<td>Delete word</td>\n</tr>\n<tr>\n<td>Ctrl+U</td>\n<td>Delete line</td>\n</tr>\n<tr>\n<td>Ctrl+J</td>\n<td>New line</td>\n</tr>\n<tr>\n<td>Ctrl+H</td>\n<td>Delete char backward</td>\n</tr>\n<tr>\n<td>Ctrl+Home</td>\n<td>Move to first character in the document</td>\n</tr>\n<tr>\n<td>Ctrl+R n, command</td>\n<td>Insert the contents of register n</td>\n</tr>\n<tr>\n<td>Ctrl+O, command</td>\n<td>Enter normal mode for one command only</td>\n</tr>\n<tr>\n<td>Ctrl+A</td>\n<td>Increment currently selected number</td>\n</tr>\n<tr>\n<td>Ctrl+X</td>\n<td>Decrement currently selected number</td>\n</tr>\n</tbody>\n</table>\n9.1.8 The Comma Text Object\n\nThis object is missing in Vim. The comma text object makes it easy to modify parameter lists in C-like languages and other comma separated lists. It is basically the area between two commas or between a comma and a bracket. In the line shown in the illustration, the three ranges this text object can span are highlighted.\n\nComma text object ranges. If the cursor is over e.g. `arg2`, pressing `ci`, ('change inner comma') would delete `double arg2` and place the cursor between the two commas in insert mode. A very convenient way to change a function’s parameters.\n\n9.1.9 Missing Features\n\nAs stated earlier, the goal of KatePart’s VI Mode is not to support 100% of Vim’s features.\nAppendix A\n\nRegular Expressions\n\nThis Appendix contains a brief but hopefully sufficient and covering introduction to the world of regular expressions. It documents regular expressions in the form available within KatePart, which is not compatible with the regular expressions of perl, nor with those of for example grep.\n\nA.1 Introduction\n\nRegular Expressions provides us with a way to describe some possible contents of a text string in a way understood by a small piece of software, so that it can investigate if a text matches, and also in the case of advanced applications with the means of saving pieces or the matching text.\n\nAn example: Say you want to search a text for paragraphs that starts with either of the names ‘Henrik’ or ‘Pernille’ followed by some form of the verb ‘say’.\n\nWith a normal search, you would start out searching for the first name, ‘Henrik’ maybe followed by ‘sa’ like this: Henrik sa, and while looking for matches, you would have to discard those not being the beginning of a paragraph, as well as those in which the word starting with the letters ‘sa’ was not either ‘says’, ‘said’ or so. And then of course repeat all of that with the next name...\n\nWith Regular Expressions, that task could be accomplished with a single search, and with a larger degree of preciseness.\n\nTo achieve this, Regular Expressions defines rules for expressing in details a generalization of a string to match. Our example, which we might literally express like this: ‘A line starting with either ‘Henrik’ or ‘Pernille’ (possibly following up to 4 blanks or tab characters) followed by a whitespace followed by ‘sa’ and then either ‘ys’ or ‘id’” could be expressed with the following regular expression:\n\n^[ \t]{0,4}(Henrik|Pernille) sa(ys|id)\n\nThe above example demonstrates all four major concepts of modern Regular Expressions, namely:\n\n- Patterns\n- Assertions\n- Quantifiers\n- Back references\nThe KatePart Handbook\n\nThe caret (\\^) starting the expression is an assertion, being true only if the following matching string is at the start of a line.\n\nThe strings [\\t] and (Henrik|Pernille) sa(ys|id) are patterns. The first one is a character class that matches either a blank or a (horizontal) tab character; the other pattern contains first a subpattern matching either Henrik or Pernille, then a piece matching the exact string sa and finally a subpattern matching either ys or id.\n\nThe string \\{0,4\\} is a quantifier saying ‘anywhere from 0 up to 4 of the previous’.\n\nBecause regular expression software supporting the concept of back references saves the entire matching part of the string as well as sub-patterns enclosed in parentheses, given some means of access to those references, we could get our hands on either the whole match (when searching a text document in an editor with a regular expression, that is often marked as selected) or either the name found, or the last part of the verb.\n\nAll together, the expression will match where we wanted it to, and only there.\n\nThe following sections will describe in details how to construct and use patterns, character classes, assertions, quantifiers and back references, and the final section will give a few useful examples.\n\nA.2 Patterns\n\nPatterns consists of literal strings and character classes. Patterns may contain sub-patterns, which are patterns enclosed in parentheses.\n\nA.2.1 Escaping characters\n\nIn patterns as well as in character classes, some characters have a special meaning. To literally match any of those characters, they must be marked or escaped to let the regular expression software know that it should interpret such characters in their literal meaning.\n\nThis is done by prepending the character with a backslash (\\). The regular expression software will silently ignore escaping a character that does not have any special meaning in the context, so escaping for example a ‘j’ (\\j) is safe. If you are in doubt whether a character could have a special meaning, you can therefore escape it safely.\n\nEscaping of course includes the backslash character itself, to literally match a such, you would write \\.\".\n\nA.2.2 Character Classes and abbreviations\n\nA character class is an expression that matches one of a defined set of characters. In Regular Expressions, character classes are defined by putting the legal characters for the class in square brackets, [ ], or by using one of the abbreviated classes described below.\n\nSimple character classes just contains one or more literal characters, for example [abc] (matching either of the letters ‘a’, ‘b’ or ‘c’) or [0123456789] (matching any digit).\n\nBecause letters and digits have a logical order, you can abbreviate those by specifying ranges of them: [a-c] is equal to [abc] and [0-9] is equal to [0123456789]. Combining these constructs, for example [a-fynot1-38] is completely legal (the last one would match, of course, either of ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘y’, ‘n’, ‘o’, ‘t’, ‘1’, ‘2’, ‘3’ or ‘8’).\n\nAs capital letters are different characters from their non-capital equivalents, to create a caseless character class matching ‘a’ or ‘b’, in any case, you need to write it [aAbB].\nIt is of course possible to create a ‘negative’ class matching as ‘anything but’ To do so put a caret (\\^) at the beginning of the class:\n[\\^abc] will match any character but ‘a’, ‘b’ or ‘c’.\n\nIn addition to literal characters, some abbreviations are defined, making life still a bit easier:\n\n\\a\nThis matches the ASCII bell character (BEL, 0x07).\n\n\\f\nThis matches the ASCII form feed character (FF, 0x0C).\n\n\\n\nThis matches the ASCII line feed character (LF, 0x0A, Unix newline).\n\n\\r\nThis matches the ASCII carriage return character (CR, 0x0D).\n\n\\t\nThis matches the ASCII horizontal tab character (HT, 0x09).\n\n\\v\nThis matches the ASCII vertical tab character (VT, 0x0B).\n\n\\xhhhh\nThis matches the Unicode character corresponding to the hexadecimal number hhhh (between 0x0000 and 0xFFFF). \\0ooo (i.e., \\zero ooo) matches the ASCII/Latin-1 character corresponding to the octal number ooo (between 0 and 0377).\n\n. (dot)\nThis matches any character (including newline).\n\n\\d\nThis matches a digit. Equal to [0-9]\n\n\\D\nThis matches a non-digit. Equal to [ˆ0-9] or [ˆ\\d]\n\n\\s\nThis matches a whitespace character. Practically equal to [ \\t\\n\\r]\n\n\\S\nThis matches a non-whitespace. Practically equal to [ˆ \\t\\r\\n], and equal to [ˆ\\s]\n\n\\w\nMatches any ‘word character’ - in this case any letter, digit or underscore. Equal to [a-zA-Z0-9_] \n\n\\W\nMatches any non-word character - anything but letters, numbers or underscore. Equal to [ˆa-zA-Z0-9_] or [ˆ\\w]\n\nThe POSIX notation of classes, [:<class name>:] are also supported. For example, [:digit:] is equivalent to \\d, and [:space:] to \\s. See the full list of POSIX character classes here.\n\nThe abbreviated classes can be put inside a custom class, for example to match a word character, a blank or a dot, you could write [\\w \\. ]\nA.2.2.1 Characters with special meanings inside character classes\n\nThe following characters has a special meaning inside the ‘[ ]’ character class construct, and must be escaped to be literally included in a class:\n\n- \\] - Ends the character class. Must be escaped unless it is the very first character in the class (may follow an unescaped caret)\n- ^ (caret) - Denotes a negative class, if it is the first character. Must be escaped to match literally if it is the first character in the class.\n- – (dash) - Denotes a logical range. Must always be escaped within a character class.\n- \\ (backslash) - The escape character. Must always be escaped.\n\nA.2.3 Alternatives: matching ‘one of’\n\nIf you want to match one of a set of alternative patterns, you can separate those with | (vertical bar character).\n\nFor example to find either ‘John’ or ‘Harry’ you would use an expression John|Harry.\n\nA.2.4 Sub Patterns\n\nSub patterns are patterns enclosed in parentheses, and they have several uses in the world of regular expressions.\n\nA.2.4.1 Specifying alternatives\n\nYou may use a sub pattern to group a set of alternatives within a larger pattern. The alternatives are separated by the character ‘|’ (vertical bar).\n\nFor example to match either of the words ‘int’, ‘float’ or ‘double’, you could use the pattern int|float|double. If you only want to find one if it is followed by some whitespace and then some letters, put the alternatives inside a subpattern: (int|float|double)\\s+\\w+.\n\nA.2.4.2 Capturing matching text (back references)\n\nIf you want to use a back reference, use a sub pattern (\\textbf{PATTERN}) to have the desired part of the pattern remembered. To prevent the sub pattern from being remembered, use a non-capturing group (\\textbf{?:PATTERN})\n\nFor example, if you want to find two occurrences of the same word separated by a comma and possibly some whitespace, you could write (\\textbf{\\w+}, \\textbf{\\s+}\\textbf{\\1}). The sub pattern \\textbf{\\w+} would find a chunk of word characters, and the entire expression would match if those were followed by a comma, 0 or more whitespace and then an equal chunk of word characters. (The string \\textbf{\\1} references the first sub pattern enclosed in parentheses)\nNOTE\nTo avoid ambiguities with usage of \\1 with some digits behind it (e.g. \\12 can be 12th subpattern or just the first subpattern with 2) we use \\(12\\) as syntax for multi-digit subpatterns.\nExamples:\n\n• \\(12\\)1 is ‘use subpattern 12’\n• \\123 is ‘use capture 1 then 23 as the normal text’\n\nA.2.4.3 Lookahead Assertions\n\nA lookahead assertion is a sub pattern, starting with either ?= or ?!.\n\nFor example to match the literal string ‘Bill’ but only if not followed by ‘ Gates’, you could use this expression: Bill(?! Gates). (This would find ‘Bill Clinton’ as well as ‘Billy the kid’, but silently ignore the other matches.)\n\nSub patterns used for assertions are not captured.\nSee also Assertions\n\nA.2.4.4 Lookbehind Assertions\n\nA lookbehind assertion is a sub pattern, starting with either ?<= or ?<!.\n\nLookbehind has the same effect as the lookahead, but works backwards. For example to match the literal string ‘fruit’ but only if not preceded by ‘grape’, you could use this expression: (?!g rape)fruit.\n\nSub patterns used for assertions are not captured.\nSee also Assertions\n\nA.2.5 Characters with a special meaning inside patterns\n\nThe following characters have meaning inside a pattern, and must be escaped if you want to literally match them:\n\n\\ (backslash)\n The escape character.\n\n^ (caret)\n Asserts the beginning of the string.\n\n$ \n Asserts the end of string.\n\n() (left and right parentheses)\n Denotes sub patterns.\n\n{} (left and right curly braces)\n Denotes numeric quantifiers.\n\n[] (left and right square brackets)\n Denotes character classes.\nThe KatePart Handbook\n\n| (vertical bar)\n| logical OR. Separates alternatives.\n\n+ (plus sign)\nQuantifier, 1 or more.\n\n* (asterisk)\nQuantifier, 0 or more.\n\n? (question mark)\nAn optional character. Can be interpreted as a quantifier, 0 or 1.\n\nA.3 Quantifiers\n\nQuantifiers allow a regular expression to match a specified number or range of numbers of either a character, character class or sub pattern.\n\nQuantifiers are enclosed in curly brackets ( { and } ) and have the general form { [minimum-occurrences], [maximum-occurrences] }\n\nThe usage is best explained by example:\n\n{1}\nExactly 1 occurrence\n\n{0, 1}\nZero or 1 occurrences\n\n{0, 1}\nThe same, with less work;\n\n{5, 10}\nAt least 5 but maximum 10 occurrences.\n\n{5,}\nAt least 5 occurrences, no maximum.\n\nAdditionally, there are some abbreviations:\n\n* (asterisk)\nsimilar to {0,}, find any number of occurrences.\n\n+ (plus sign)\nsimilar to {1,}, at least 1 occurrence.\n\n? (question mark)\nsimilar to {0,1}, zero or 1 occurrence.\n\nA.3.1 Greed\n\nWhen using quantifiers with no maximum, regular expressions defaults to match as much of the searched string as possible, commonly known as greedy behavior.\n\nModern regular expression software provides the means of ‘turning off greediness’, though in a graphical environment it is up to the interface to provide you with access to this feature. For example a search dialog providing a regular expression search could have a check box labeled ‘Minimal matching’ as well as it ought to indicate if greediness is the default behavior.\nA.3.2 In context examples\n\nHere are a few examples of using quantifiers\n\n\\d{4,5}\\s\nMatches the digits in ‘1234 go’ and ‘12345 now’, but neither in ‘567 eleven’ nor in ‘223459 somewhere’\n\\s+\nMatches one or more whitespace characters\n(bla){1,}\nMatches all of ‘blablabla’ and the ‘bla’ in ‘blackbird’ or ‘tabla’\n/?>\nMatches ‘/>’ in ‘<closeditem/>’ as well as ‘>’ in ‘<openitem>’.\n\nA.4 Assertions\n\nAssertions allows a regular expression to match only under certain controlled conditions.\n\nAn assertion does not need a character to match, it rather investigates the surroundings of a possible match before acknowledging it. For example the word boundary assertion does not try to find a non word character opposite a word one at its position, instead it makes sure that there is not a word character. This means that the assertion can match where there is no character, i.e. at the ends of a searched string.\n\nSome assertions actually do have a pattern to match, but the part of the string matching that will not be a part of the result of the match of the full expression.\n\nRegular Expressions as documented here supports the following assertions:\n\n^ (caret: beginning of string)\nMatches the beginning of the searched string.\nThe expression ^Peter will match at ‘Peter’ in the string ‘Peter, hey!’ but not in ‘Hey, Peter!’\n\n$ (end of string)\nMatches the end of the searched string.\nThe expression you\\?\\$ will match at the last you in the string ‘You didn’t do that, did you?’ but nowhere in ‘You didn’t do that, right?’\n\n\\b (word boundary)\nMatches if there is a word character at one side and not a word character at the other.\nThis is useful to find word ends, for example both ends to find a whole word. The expression \\bin\\b will match at the separate ‘in’ in the string ‘He came in through the window’, but not at the ‘in’ in ‘window’.\n\n\\B (non word boundary)\nMatches wherever ‘\\b’ does not.\nThat means that it will match for example within words: The expression \\Bin\\B will match at in ‘window’ but not in ‘integer’ or ‘I’m in love’.\n(?=PATTERN) (Positive lookahead)\nA lookahead assertion looks at the part of the string following a possible match. The positive lookahead will prevent the string from matching if the text following the possible match does not match the PATTERN of the assertion, but the text matched by that will not be included in the result.\n\nThe expression `handy (?=\\w)` will match at 'handy' in 'handyman' but not in 'That came in handy!'\n\n(?!PATTERN) (Negative lookahead)\nThe negative lookahead prevents a possible match to be acknowledged if the following part of the searched string does match its PATTERN.\n\nThe expression `const \\w+\\b(?!\\s&)` will match at 'const char' in the string 'const char* foo' while it can not match 'const QString' in 'const QString& bar' because the '&' matches the negative lookahead assertion pattern.\n\n(?<=PATTERN) (Positive lookbehind)\nLookbehind has the same effect as the lookahead, but works backwards. A lookbehind looks at the part of the string previous a possible match. The positive lookbehind will match a string only if it is preceded by the PATTERN of the assertion, but the text matched by that will not be included in the result.\n\nThe expression `(?<=cup)cake` will match at 'cake' if it is succeeded by 'cup' (in 'cupcake' but not in 'cheesecake' or in 'cake' alone).\n\n(?<!PATTERN) (Negative lookbehind)\nThe negative lookbehind prevents a possible match to be acknowledged if the previous part of the searched string does match its PATTERN.\n\nThe expression `(?<![^\\w.\\-])[0-9]+` will match at '123' in the strings '123' and '-123' while it can not match '123' in '.123' or 'word123'.\n\n(PATTERN) (Capturing group)\nThe sub pattern within the parentheses is captured and remembered, so that it can be used in back references. For example, the expression `("+) [\""]*` matches '```text```' and '```text```'.\n\nSee the section Capturing matching text (back references) for more information.\n\n(?!PATTERN) (Non-capturing group)\nThe sub pattern within the parentheses is not captured and is not remembered. It is preferable to always use non-capturing groups if the captures will not be used.\nAppendix B\n\nIndex\n\nC\ncomment, 30\n\nR\nreplace, sed style\n search, sed style, 34\n\nU\nuncomment, 30"}}},{"rowIdx":199,"cells":{"id":{"kind":"string","value":"87b103b20335cc6d17d6ef537a5a4249df221ad9"},"text":{"kind":"string","value":"THE UNIVERSITY OF CHICAGO\n\nPERFORMANCE-FRIENDLY CONCURRENCY BUG FAILURE RECOVERY AND FIXING\n\nA DISSERTATION SUBMITTED TO\nTHE FACULTY OF THE DIVISION OF THE PHYSICAL SCIENCES\nIN CANDIDACY FOR THE DEGREE OF\nDOCTOR OF PHILOSOPHY\n\nDEPARTMENT OF COMPUTER SCIENCE\n\nBY\nYUXI CHEN\n\nCHICAGO, ILLINOIS\nMARCH, 2020\nDedicated to my parents, for their continuous support and endless love.\nProgram testing can be used to show the presence of bugs, but never to show their absence!\n\n– Edsger W. Dijkstra\n# TABLE OF CONTENTS\n\nLIST OF FIGURES ....................................................... vii\nLIST OF TABLES ........................................................ ix\nACKNOWLEDGMENTS ..................................................... x\nABSTRACT ................................................................. xii\n\n1 INTRODUCTION .......................................................... 1\n 1.1 Motivation ............................................................ 5\n 1.1.1 Concurrency bugs failure recovery ....................... 5\n 1.1.2 Automatic concurrency bug fixing ....................... 7\n 1.2 Contributions ..................................................... 11\n 1.3 Dissertation Organization ..................................... 16\n\n2 BACKGROUND AND RELATED WORK ................................ 17\n 2.1 Concurrency bug .................................................. 17\n 2.2 Empirical study of concurrency bugs ......................... 18\n 2.3 Concurrency bug detection ..................................... 19\n 2.4 Concurrency-bug failure prevention ......................... 19\n 2.5 Failure recovery ................................................ 20\n 2.6 Concurrency bug fixing ........................................ 21\n 2.7 Condition synthesis in program repair ..................... 21\n\n3 APPLYING TRANSACTIONAL MEMORY FOR CONCURRENCY-BUG FAILURE RECOVERY IN PRODUCTION RUNS ..................... 23\n 3.1 Challenges for applying transactional memory for concurrency bug failure recovery ........................................ 23\n 3.2 Transactional Memory (TM) ...................................... 24\n 3.3 ConAir ............................................................. 25\n 3.4 BugTM_H ........................................................... 27\n 3.4.1 High-Level Design ........................................ 27\n 3.4.2 Design about AbortTx .................................... 29\n 3.4.3 Design about StartTx and CommitTx ................... 30\n 3.4.4 Design for fallback and retry .......................... 32\n 3.4.5 Inter-procedural Designs and Others .................. 33\n 3.5 Roadmap for Further Exploration ............................. 34\n 3.6 BugTM_S .......................................................... 35\n 3.6.1 Deferred Writes for Failure-Unrelated \\( w_{\\text{kill}} \\) .......... 36\n 3.6.2 Undo Log for Failure-Related Killing Writes .......... 38\n 3.7 BugTM_HS ........................................................ 40\n 3.8 Failure Diagnosis ............................................... 42\n3.9 Methodology ................................................. 45\n3.10 Experimental results ....................................... 46\n 3.10.1 Failure recovery capability .......................... 46\n 3.10.2 Performance ........................................ 51\n 3.10.3 Diagnosis .......................................... 53\n 3.10.4 Alternative designs of BugTM ....................... 55\n3.11 Discussion ................................................ 56\n3.12 Conclusion ............................................... 58\n\n4 AUTOMATICALLY FIX CONCURRENCY BUGS VIA BYPASSING COMPUTATION SEMANTICS .......................................................... 59\n 4.1 Challenges for automatically generating correct bypassing patches for concurrency bugs ............................................ 59\n 4.2 Existing auto-fixing tools .................................. 61\n 4.3 Bug-fixing framework ...................................... 62\n 4.4 Three bypassing patterns .................................. 64\n 4.4.1 Overwritten ....................................... 64\n 4.4.2 Conditional ....................................... 67\n 4.4.3 Exclusive ......................................... 70\n 4.5 BFix .................................................... 73\n 4.5.1 Workflow of BFix .................................. 73\n 4.5.2 Feasibility checking ................................ 74\n 4.5.3 Patch generation .................................. 81\n 4.5.4 Patch merging .................................... 86\n 4.6 Methodology .............................................. 87\n 4.7 Experimental results ..................................... 88\n 4.7.1 Correctness ....................................... 89\n 4.7.2 Performance ....................................... 90\n 4.7.3 Simplicity ......................................... 92\n 4.8 Discussion ............................................... 94\n 4.9 Conclusion .............................................. 95\n\n5 CONCLUSION AND FUTURE WORK ............................. 96\n# LIST OF FIGURES\n\n1.1 Main phases of software life cycle and their corresponding tasks .............................................. 2 \n1.2 Single-threaded recovery for concurrency bugs ............................................................................ 6 \n1.3 A real-world concurrency bug from Mozilla ............................................................................. 7 \n1.4 A simplified real-world concurrency bug from Mozilla DNS module. ‘+/−’ indicates the manual patch .............................................................................................................. 9 \n1.5 Design space of concurrency-bug failure recovery (Heart: non-existing optimal design; Rx [60] changes OS) ............................................................................................................. 10 \n1.6 Execution timeline for the patched version in bug-triggering timing and the original program in a bug-free timing of Figure 1.4. All timeline figures in this dissertation use the same symbols: gray font means FALSE Boolean expression; rectangle represents skipped regions. .................................................................................. 14 \n\n2.1 A real-world OV bug (simplified from Transmission) ............................................................... 18 \n2.2 A real-world DD bug (simplified from HawkNL) ..................................................................... 18 \n\n3.1 A real-world concurrency bug from MySQL ............................................................................ 26 \n3.2 BugTMAbortTx wrapper function (my_xabort) ..................................................................... 29 \n3.3 A toy example adapted from Figure 1.3 (left-side) and its BugTMH transformation (right-side) ................................................................................................................................. 31 \n3.4 BugTMHCommitTx wrapper function (my_xend) .................................................................... 32 \n3.5 BugTMHStartTx wrapper function (my_xbegin) .................................................................... 32 \n3.6 BugTMS deferred write transformation, denoted by ‘+/−’, makes a ConAir-unrecoverable bug recoverable ............................................................................................................................... 36 \n3.7 Moving a killing write (ttag is initialized as FALSE) ............................................................... 38 \n3.8 Memory-checkpoint example .................................................................................................... 38 \n3.9 BugTMHS rollback wrapper function .......................................................................................... 42 \n3.10 Recovery-guided root-cause diagnosis for BugTMH and BugTMS ........................................... 43 \n\n4.1 Why bypassing works for AV bugs: (i) bug context for write-after-write AV bug; (ii) skipping failure-triggering operations; (iii) skipping buggy operations ............................................. 61 \n4.2 MySQL example from CFix. Interleaving ‘A’ and ‘B’ are two bug-free interleavings, ‘+’ indicates the generated patch by CFix ............................................................................................................................. 62 \n4.3 Notation for the buggy code snippet. Arrows indicate the bug-triggering timing .......... 63 \n4.4 Types of AV bugs. ‘x’ is a shared memory location ................................................................. 64 \n4.5 A simplified bug in Jscript module of Mozilla, ‘+’ indicates the manual patch ................. 65 \n4.6 Execution timeline for the patched version in bug-triggering timing and a bug-free run in Figure 4.5 ............................................................................................................................................ 66 \n4.7 Simplified overwritten pattern for read-after-write AV bugs and their patch pattern .......... 66 \n4.8 Simplified overwritten pattern for write-after-read AV bugs and their patch pattern .......... 67 \n4.9 Simplified overwritten pattern for OV bugs and their patch pattern .................................. 67 \n4.10 A simplified bug from Apache Xerces. ‘+/−’ indicates the manual patch ......................... 68 \n4.11 Execution timeline for the patched version in bug-triggering timing and a bug-free run in Figure 4.10 .............................................................................................................................................. 69 \n\nvii\n4.12 Simplified conditional pattern for bypassing $R$ and the patch pattern .... 70\n4.13 Simplified conditional pattern for bypassing $C$ and the patch pattern .... 70\n4.14 Simplified conditional pattern for bypassing $A$ and the patch pattern .... 71\n4.15 All conditional patterns that BFIX handles. $global\\_field$ is a shared memory location, it can be a variable or expression. For each case, the inferred correct timing and bypass-able operation are also shown ......................... 71\n4.16 A modified version of a concurrency bug in Apache, ‘+’ indicates the manual patch 72\n4.17 Workflow of BFIX .................................................. 74\n4.18 Bypass-patched program may change the execution order of original program; dotted arrows means execution order is changed; same notation is used as Figure 4.3 ................................................................. 78\n4.19 Patch pattern for bypassing $R$ ($pid$ is thread ID) .................... 83\n4.20 Patch pattern for bypassing $C$ ($pid$ is thread ID) .................... 83\n4.21 Patch pattern for bypassing $A$ ($pid$ is thread ID) .................... 84\n4.22 A naive bypassing patch with a new bug .......................... 85\n4.23 Simple patch for AV bugs ........................................ 85\n4.24 A patch pattern used by developers ............................ 91\n4.25 A simplified Mozilla bug BFIX can not help; ‘+’ indicates patch .... 94\n## LIST OF TABLES\n\n1.1 Design comparisons ......................................................... 12\n\n3.1 Common types of concurrency bugs and how BugTM\\(_H\\) and ConAir attempt to recover from them ......................................................... 28\n\n3.2 Recovery capability comparison ............................................... 47\n\n3.3 Static failure sites hardened by BugTM\\(_{HS}\\) ........................................ 49\n\n3.4 Overhead during regular execution and detailed performance comparison ...... 50\n\n3.5 Failure recovery details by BugTM\\(_{HS}\\) ........................................ 52\n\n3.6 Diagnosis capability comparison ............................................. 54\n\n3.7 BugTM\\(_H\\) vs. alternative designs ............................................... 55\n\n4.1 Failure Rates comparison ..................................................... 89\n\n4.2 Performance comparison ..................................................... 90\n\n4.3 Simplicity comparison (#Sync: number of new synchronization operations added by the patch; #line: line of code modification; L: lock; U: unlock; S: signal; W: wait; +: add; -: remove; ↑: move) ..................................................... 92\nACKNOWLEDGMENTS\n\nThe past five years had been the most beautiful memories in my life. I still remember the day I got the offer from the University of Chicago, as if it were yesterday. Looking back over the last five years, it is not an easy journey for me. I would like to express my most sincere gratitude to people who have helped me.\n\nFirst and foremost, I would like to thank my advisor, Prof. Shan Lu, for the endless effort that she spent on me. She is a great mentor not only in the research but also in the daily life. From her, I knew how to be a passionate researcher with critical thinking. She always pushed me to think and express my idea bravely, which is the most important lesson that I have learnt from the graduate school. From her, I knew how to be an optimistic person in my own life. I had a really tough time in my third year and kept doubting myself. Her patience and invaluable suggestions pull me back on track. It is my honor to be her PhD student. Without her help, I do not think I can reach the destination.\n\nI would like to thank Prof. Haryadi S. Gunawi, Prof. Ravi Chugh for being on my doctoral dissertation committee, and Prof. Andrew A. Chien for being on my master’s committee. Their constructive suggestions help improve my research and make my dissertation stand on a solid foundation. I am really honored to have them on my committee.\n\nAt UChicago, I was fortunate enough to work with many excellent colleagues. I would like to thank every member in Shan’s and Haryadi’s groups: Wei Zhang, Guoliang Jin, Linhai Song, Haopeng Liu, Guangpu Li, Shu Wang, Junwen Yang, Chi Li, Lefan Zhang, Chengcheng Wan, Xu Wang, Xianglan Chen, Jiaxin Li, Wei Yuan, Yu Gao, Jeffrey Lukman, Tanakorn Leesatapornwongsa, Riza Suminto, Huan Ke, Shiqin Yan and Huaicheng Li for the opportunity of collaborations and technical discussions. I especially thank Haopeng Liu and Shiqin Yan. In the past five years, we wen to campus and went home together; we went to Chinatown every weekends together; we travelled together. You are not only friends for me, but also brothers. I also want to thank the technical support from Bob Bartlett,\nadministrational help from Margaret P. Jaffey.\n\nI am very happy to make lots of fantastic friends here: Steven Basart, Min Xu, Yuwanwei Fang, Zhixuan Zhou, Liwen Zhang, Dixin Tang, Aiman Fang, Qingqin Zheng, Yun Li, Yan Liu, Huazhe Zhang, Cong Zhang, Jialin Li, Yan Yang and many more I can not list all of them here. I like hanging out, travelling, studying with you guys.\n\nI would also thank my roommates: Yanzhe Wu, Hao Tong, Hing Yin Tsang, Cheng Wu. Even we have different lifestyles, it is still a great experience for me to live with you in the past five years.\n\nThis dissertation means nothing for me if it did not make my family proud. Thank you, Dad, Mom and my younger brother, for your unconditional and greatest love. And I am very lucky to find my true love Yalin Sun during this journey, thanks for your company.\nABSTRACT\n\nConcurrency bugs widely exist and severely threaten system availability and reliability. Their unique non-deterministic nature has made them difficult to avoid, diagnose, and fix by developers. In the past, much research has been done to fight with concurrency bugs during the early phases of software life cycle. For example, people designed new languages (e.g. Go) and new static analysis tools to help avoid some concurrency bugs during the code design and the implementation. And many testing techniques and dynamic tools are proposed to expose concurrency bugs during in-house testing. However, none of these techniques are perfect. Many concurrency bugs still inevitably slip into deployment, cause production failures and incur huge cost for code maintenance, such as 60 million ether theft in the Bitcoin system. Consequently, besides the early phases of software life cycle, automated tools that help fight with concurrency bugs in the late phases of software life cycle are well desired.\n\nTo help fight with concurrency bugs in the late phases of software life cycle, this dissertation tries to solve two problems: (1) During the production deployment, how to help software survive from failures caused by concurrency bugs with low overhead? (2) During the software maintenance, how to automatically fix concurrency bugs so that the patches are correct and simple without unnecessary performance degradation? In other words, this dissertation aims to improve the availability and reliability of multi-threaded programs through efficient concurrency bug failure recovery and fixing.\n\nAlong the direction of failure recovery, we present BugTM, an approach that applies transactional memory techniques for failure recovery in production runs. Requiring no knowledge about where are concurrency bugs, BugTM uses static analysis and code transformation to enable BugTM-transformed software to recover from a concurrency-bug failure by rolling back and re-executing the recent history of a failure thread. BugTM greatly improves the recovery capability of state-of-the-art techniques with low run-time overhead and no changes to OS or hardware, while guarantees not to introduce new bugs.\nAlong the direction of efficient concurrency bug fixing, we present BFix, a tool that automatically generates computation-bypassing patches for some concurrency bugs. Given a bug report, BFix first uses static analysis to check whether the bypassing strategy is suitable for the reported bug and, if so, constructs a patch. It further tries to combine its patches for better performance and code readability. We have compared BFix patches with bypassing patches manually developed by programmers, as well as the patches generated by state-of-the-art auto-fixing tools. The experimental results showed that BFix patches have the similar quality to the manual patches, outperforming auto-generated patches from previous tools in terms of patch performance, and patch simplicity.\n\nThese two approaches can greatly improve software availability and reliability by tackling detected or undetected concurrency bugs in the late phases of software life cycle. BugTM leverages transactional memory techniques for concurrency bug failure recovery without intensively using checkpointing. BFix tries to skip certain part of the original computation in the bug-triggering context without using time-consuming synchronization primitives (e.g., locks). Both of them achieve good efficiency, which makes them serve as good choices to help fight with concurrency bugs in the late phases of software life cycle for developers.\nCHAPTER 1\nINTRODUCTION\n\nConcurrency bugs are synchronization mistakes in multi-threaded software. Their unique non-deterministic nature has made them difficult to avoid, detect, diagnose, and fix. Even with lots of in-house testing, many concurrency bugs continue to slip into production runs, causing disasters [4, 36, 56, 66]. To make things worse, previous studies have shown that it often takes several months for developers to diagnose and correctly fix concurrency bugs [46]—concurrency bugs are the most difficult to fix correctly among common bug types [78], with many incorrect patches releases. Consequently, techniques or tools that can help fight with concurrency bugs are highly desired.\n\nFor different phases of software life cycle, since each of them has distinct task and requirement, the desired techniques or tools that can help fight with concurrency bugs are different. Software life cycle is a process for planning, creating, testing, and deploying a software system [3]. This cycle usually has five main phases, as shown in Figure 1.1: (1) design: describe the desired features and operations into complete, detailed software design documents; (2) implementation: convert the software specifications into an executable software, the real code is written during this phase; (3) testing: bring all components into a special testing environment, then check errors, bugs and interoperability; (4) deployment: put software into production and run actual business; (5) maintenance: assess and evaluate the software to ensure it does not become obsolete, and make changes into initial software for better user experience. As mentioned, different techniques or tools are needed in different phases. During the design phase, developers mainly want to avoid some concurrency bugs at very beginning by specifying details of design documents and tools. For example, developers prefer to adopt a multi-threaded-programming-friendly language so that some compiler-related concurrency bugs, like double-checked locking [65] can be avoided early on. During the implementation phase, efficient tools that can help find the violation [37] be-\nFigure 1.1: Main phases of software life cycle and their corresponding tasks\n\ntween specifications and real implementations for multi-threaded programs are very helpful. During the testing phase, static and dynamic bug detection tools, which have high coverage and high accuracy, are expected to expose the concurrency bugs. During the deployment phase, software availability requires effective and efficient recovery mechanisms to help software survive from the failures caused by concurrency bugs. During the maintenance phase, automatically patching concurrency bugs so that the patches are correct and simple without unnecessary performance degradation is anticipated.\n\nPeople have made huge progress in dealing with concurrency bugs in different phases of software life cycle. For example, much research effort has been made on bug finding [33, 45, 48, 64, 80, 85] during in-house testing. However, none of them has helped expose all concurrency bugs. People even design a specific language Go for multi-threaded programming to avoid concurrency bug during even earlier phase of software life cycle (code design and implementation phases). Unfortunately, Tu et al. [69] finds it is even easier to introduce concurrency bugs if developers do not have strong background about the inner mechanism of Go. As you can see, people always focus on the early phases of software life cycle to fight with concurrency bugs. However, since none of these techniques or tools are prefect, many\nConcurrency bugs still slip into the late phases of software life cycle, such as the deployment and maintenance phases, causing disasters and incurring huge cost for software maintenance. This is catastrophic and irreversible, since concurrency bugs would directly affect the end users. As a result, tools or techniques that help fight with concurrency bugs during the late phases of software life cycle are even more highly desired.\n\nLate in the software life cycle, software has already been deployed in production, hence solutions to help fight with concurrency bugs during these phases should meet higher standards than any early phase. First of all, they should guarantee the correctness. Early in the software life cycle, the newly-introduced problems caused by imperfect tools or techniques can be still addressed before deployment. However, all problems during the late phases will lead to direct and irreversible financial loss and user loss. According to statistics, downtime can cost companies $5,600 per minute and up to $300,000 per hour [2]. Second, performance really matters, but it may not be a major problem during the early phases. For example, the concurrency bug detection tools used during testing phase can incur 10X to 100X slowdown [13]. However, during the late phases, high overhead and long latency means huge user loss. For example, the BBC found they lost an additional 10% of users for every additional second their site took to load [5].\n\nPeople have already paid more attentions to proposing new solutions to help fight with concurrency bugs during the late phases of software life cycle. However, none of them can completely satisfy both requirements described above. Performance is usually scarified for correctness and generality. For example, rollback-and-reexecution is used to recover failures caused by concurrency bugs during the deployment phase, but aggressive intrusiveness and high overhead prevent it from being widely deployed in production run. Although great progress has been made in automated concurrency fixing during the code maintenance, patches generated by existing tools are mostly different from patches designed by developers and most of them are not performance-friendly since time-consuming synchronization\nprimitives are introduced. More details are covered in chapter 1.1.\n\nIn this dissertation, we focus on not only correctness but also performance. We aim to present new solutions to help software survive from concurrency bug failures with low overhead and automatically fix concurrency bugs with high quality patches. In other words, we try to improve the availability and reliability of multi-threaded programs through efficient concurrency bug failure recovery and fixing, which take effect during the late phases of software life cycle. For concurrency bug failure recovery, our solution actually does not eliminate the concurrency bugs and it does not know where they are; it just helps software survive from the failures caused by concurrency bugs to improve the availability of multi-threaded programs. As for the concurrency bug fixing, our solution tries to automatically patch the buggy programs and eliminate the reported concurrency bugs so that the software reliability is improved.\n\nWe design low-overhead production-run concurrency bug failure recovery tool BugTM [10, 11] to help software survive from failure caused by concurrency bugs that fail to be detected during in-housing testing. And for those which can be detected during in-housing testing, we propose BFix, which is the first automatic fixing tool using bypassing strategy to fix concurrency bugs.\n\nThese two solutions share several similarities: (1) They are both high-quality solutions. Whether for concurrency bug failure recovery or concurrency bug fixing, our solutions guarantee correctness, without introducing new problems, and great performance, with negligible overhead in production environment. These are different from the traditional ones. (2) Both solutions greatly explore the current design space. Unlike existing solutions, which touch corners of the design space, BugTM achieves good combination between recovery capability and overhead, while BFix achieves good balance among fixing capability, overhead and simplicity. (3) From the perspective of used techniques, somehow, both would change sequential semantics in the bug-triggering context. BugTM would skip the failure-triggering operations\nand then trigger execution when bug is about to happen. BFix would skip failure-inducing and related computation to fix concurrency bugs in the bug-triggering timing. (4) Both need a few to no human effort. BugTM does not need any knowledge about where the concurrency bugs are in the software. As for BFix, its input is directly obtained from existing concurrency bug detectors. Hence, both of them greatly alleviate the burden of developers. (5) Both BugTM and BFix tremendously complements existing solutions. They can greatly improve the availability and reliability of software during the late phases of software life cycle. Before the final patch is released, BugTM solution can serve as tentative patch for availability purpose. The diagnosis part of BugTM can complement bug detection tools, offering input for BFix and helping generate correct patch. Moreover, together with existing solutions, they can provide multi-phase, effective and efficient protections for multi-threaded programs.\n\nThese two solutions clearly have their own distinct goals and features given the fact that they are applied in different phases of software life cycle. Chapter 1.1 and 1.2 cover these parts. Chapter 1.1 introduces the specific goals for our concurrency bugs failure recovery and bug fixing solutions, while chapter 1.2 covers the novelty of our tools.\n\n1.1 Motivation\n\n1.1.1 Concurrency bugs failure recovery\n\nDuring the late phases of software life cycle, like the deployment phase, rollback-and-reexecution is a classic approach to recover failures caused by concurrency bugs. When a failure happens during a production run, the program rolls back and re-executes from an earlier checkpoint. Due to the unique non-deterministic nature of concurrency bugs, the re-execution could get around the failure.\n\nThis approach is appealing for several reasons. It is generic, requiring no prior knowledge\nabout bugs; it improves availability, masking the manifestation of concurrency bugs from end users; it avoids causing system inconsistency or wasting computation resources, which often come together with naive failure restarts; even if not successful, the recovery attempts only delays the failure by a negligible amount of time.\n\nThis approach also faces challenges in performance, recovery capability, and correctness (i.e., not introducing new bugs), as we elaborate below.\n\nTraditional rollback recovery conducts full-blown multi-threaded re-execution and whole-memory checkpointing. It can help recover almost all concurrency-bug failures, but incurs too large overhead to be deployed in production runs [60, 63]. Even with support from operating systems changes, periodic full-blown checkpointing still often incurs more than 10% overhead [60].\n\nA recently proposed recovery technique, ConAir, conducts single-threaded re-execution and register-only checkpointing [82]. As shown in Figure 1.2, when a failure happens at a thread, ConAir rolls back the register content of this thread through an automatically inserted `longjmp` and re-executes from the return of an automatically inserted `setjmp`, which took register checkpoints. This design offers great performance (<1% overhead), but also imposes severe limitations to failure-recovery capability. Particularly, with no memory checkpoints and re-executing only one thread, ConAir does not allow its re-execution regions to contain writes to shared variables (referred to as `wkill`) for correctness concerns, severely hurting its chance to recover many failures.\n\nThis limitation can be demonstrated by the real-world example in Figure 1.3. In this example, the `NULL` assignment from Thread-2 could execute between the write ($A_1$) and the\nread \\((A_2)\\) on \\(s\\rightarrow\\text{table}\\) from Thread-1, and cause failures. At the first glance, the failure could be recovered if we could rollback Thread-1 and re-execute both \\(A_1\\) and \\(A_2\\). However, such rollback and re-execution cannot be allowed by ConAir, as correctness can no longer be guaranteed if a write to a shared variable is re-executed (\\(A_1\\) in Figure 1.3): another thread \\(t\\) could have read the old value of \\(s\\rightarrow\\text{table}\\), saved it to a local pointer, the re-execution then gave \\(s\\rightarrow\\text{table}\\) a new value, causing inconsistency between \\(t\\) and Thread-1 and deviation from the original program semantics.\n\nA better approach for concurrency bug failure recovery, which is as powerful as traditional rollback recovery and as lightweight as ConAir, is highly desired.\n\n### 1.1.2 Automatic concurrency bug fixing\n\nAlthough failure recovery techniques can help improve the availability of software, they do not fundamentally eliminate the concurrency bugs. They only help software survive from the failures caused by concurrency bugs when buggy timing occurs. The concurrency bugs still exist. Patching is the fundamental way to eliminate concurrency bugs.\n\nRecently, many automated fixing techniques for concurrency bugs have been proposed \\([9, 25, 27, 28, 39, 40, 41, 42, 74]\\). These tools can handle all common types of concurrency bugs, such as order violations (OV), atomicity violations (AV). They leverage a unique property of concurrency bugs – since concurrency bugs manifest non-deterministically, the correct computation semantics already exist in software. Consequently, these tools work not by changing computation semantics, which is required for most non-concurrency-bug fixing, but by adding constraints to software timing. They mostly achieve this by adding\nsynchronization operations, including locks [27, 40, 42, 74] and condition variable signal/wait [28] into software. These synchronization changes help eliminate bug-triggering timing from the program space and hence fix concurrency bugs.\n\nAlthough helpful, these automatically generated synchronization fixes are sometimes much more complicated and performance degrading than patches that are manually designed by developers. According to a previous patch study [39], more than 30% of the studied real-world concurrency bugs were not fixed by eliminating buggy timings; nearly 20% of the bugs were actually fixed by simply bypassing certain computation in the original program under those buggy timings, which we refer to as bypassing patches. These manual patches are simple and light weight, involving no synchronization changes, but they deviate from the fundamental approach taken by existing concurrency-bug fixing tools, which is about eliminating buggy timings.\n\nTo understand bypassing patches designed by developers, we can look at a real-world concurrency bug from Mozilla. In Mozilla, several threads can invoke the ProcessLookup function, as illustrated in Figure 1.4, in parallel to fetch and process requests from the pending-request queue mQ. Although the request fetching (Line 12 of ProcessLookup) is conducted with lock protection, the request processing (through FireStop on Line 16) is conducted without lock protection. Concurrently, another thread might execute FindLookup, illustrated on the right side of Figure 1.4. Without lock protection, a DNS request processing thread’s (Thread-1) two consecutive accesses to mStatus in Line 8 & 28 of ProcessRequest could be interleaved by Thread-2’s remote write to mStatus (Line 9 on the right side of Figure 1.4), which can lead to a browser crash by assertion failure (Line 28).\n\nThe best patch that can be automatically generated by previous techniques [28, 39] would move the invocation of FireStop and hence its enclosing read access to mStatus into the critical section protected by lock DNS::Lock. However, such a patch would create an extremely long lock critical section—every invocation of FireStop involves network operations and hence\nvoid ProcessLookup(...){\n DNS::Lock();\n lookup->mStatus = COMPLETE;\n ط\n while(!lookup->mQ.empty()){\n request = lookup->mQ.front();\n lookup->mQ.pop();\n DNS::Unlock();\n request->FireStop(...);\n DNS::Lock();\n lookup->mprocess--;\n DNS::Unlock();\n }\n DNS::Unlock();\n}\n\nvoid FireStop(...){\n assert checking for mStatus\n NS_ASSERT(lookup->mStatus == COMPLETE);\n ...\n}\n\nFigure 1.4: A simplified real-world concurrency bug from Mozilla DNS module. ‘+/-’ indicates the manual patch\n\ntakes a long time—and would essentially serialize the concurrent invocations of ProcessLookup from all threads, which is clearly unacceptable in terms of performance.\n\nIn practice, instead of relying on lock synchronizations, developers simply add a field mProcess to record the number of threads that are currently processing requests, and add an extra checking in Thread-2 so that the reset procedure is bypassed when there is any thread processing DNS requests.\n\nUnlike the earlier patch, this manual patch does not eliminate the original buggy timing—the FireStop function can still be invoked concurrently with the FindLookup function. It does however ensure that the original bug never happens, as the new counter mProcess is guaranteed to be non-zero and hence cause any concurrent reset to be bypassed whenever a FireStop is invoked.\nIn addition to fixing the original bug, this manual patch also has a great *performance* advantage over the earlier patch that relies on lock synchronizations, as it does not impose any slowdowns on the processing of DNS requests. The patch also involves only a few lines of code changes and no synchronization changes.\n\nGiven the advantage of bypassing patches outlined above, it would be great if they could be generated automatically. To do so, we would need to automatically (1) decide which computation to bypass; (2) decide what is the condition to bypass specific computation; and (3) prove that the patched software can not only fix the original bug but also guarantee not to introduce new bugs into the software.\n\nAutomating these three tasks is challenging. Particularly, proving that the patched software does not introduce new bugs (i.e., the third task above) is difficult—bypassing a group of operations that have side effects at run time would clearly change the semantics of that run, and proving that the changed semantics is still correct is difficult. Indeed, a previous study has shown that \\[68\\] naive computation bypassing can easily introduce new bugs: more than 50\\% of condition-synthesis patches generated by automatic program-repair tools, like GenProg [35], actually introduce new bugs even though they can eliminate the original failure symptoms. Furthermore, even bypassing patches designed by skilled developers can sometimes introduce new bugs \\[59\\], which further motivates systematic and automated bypassing-patch generation techniques.\n\n\n\n*Figure 1.5: Design space of concurrency-bug failure recovery (Heart: non-existing optimal design; Rx [60] changes OS)*\n1.2 Contributions\n\nThis dissertation works on two components to address concurrency bug failure recovery and fixing problems: (1) Leveraging the transactional memory techniques to help software survive from failures caused by concurrency bugs with low overhead during production deployment; (2) Using bypassing strategy to fix concurrency bugs with high-quality patches during code maintenance.\n\n(1) Applying transactional memory for concurrency-bug failure recovery in production runs\n\nExisting recovery techniques only touch two corners of the design space — good performance but limited recovery capability or good recovery capability but limited performance — as shown in Figure 1.5.\n\nAlong the direction of efficient concurrency bug failure recovery, we present BugTM, a set of transactional-memory (TM) inspired designs that thoroughly explore the design space of concurrency-bug failure recovery, also shown in Figure 1.5. It greatly improves the combination of recovery-capability and performance over existing techniques, while still guarantees correctness.\n\nBugTM explores 3 designs, all implemented as compiler passes that automatically instrument software at the byte-code level. The instrumented software conducts checkpoint, rollback, and re-execution for failure recovery in different ways across these three designs, as shown in Table 1.1.\n\n**Hardware BugTM**, short for BugTM\\(_H\\), uses hardware transactional memory (HTM) techniques\\(^1\\) *exclusively* to help failure recovery. When a failure is going to happen, a hardware transaction abort causes the failing thread to roll back. The re-execution naturally starts from the beginning of the enclosing transaction, carefully inserted by BugTM\\(_H\\).\n\n**Software BugTM**, short for BugTM\\(_S\\), extends ConAir through software transactional\n\n---\n\n\\(^1\\) This dissertation’s implementation is based on Intel TSX. However, the principles apply to other vendors’ HTM implementations.\nmemory (STM) version-management techniques. When a failure is to happen, just like ConAir, a `longjmp` rolls back register content of the failing thread to the latest `setjmp`. Different from ConAir, selected memory checkpoints\\(^2\\) are conducted at some `setjmp` locations, offering the option to rollback some memory content before re-execution. Furthermore, BugTM\\(_S\\) conducts *deferred-write* code transformation that delays some shared-variable writes to further address ConAir’s failure-recovery limitations.\n\n**Hybrid BugTM**, short for BugTM\\(_{HS}\\), uses HTM and `setjmp/longjmp` together to help failure recovery. BugTM\\(_{HS}\\) inserts both `setjmp/longjmp` and HTM APIs into software, with the latter inserted only when beneficial (i.e., when able to extend re-execution regions). When a failure is going to happen, the rollback is carried out through transaction abort if under an active transaction or `longjmp` otherwise.\n\nThese three BugTM designs offer different performance and recovery-capability tradeoffs, as illustrated by Figure 1.5.\n\nBugTM\\(_H\\) and BugTM\\(_S\\) both support longer re-execution regions than ConAir by allowing shared-variable writes inside re-execution regions, and hence both achieve better recovery capability than ConAir. BugTM\\(_H\\) tends to have better recovery capability than BugTM\\(_S\\) benefiting from HTM, which we will explain in details in chapter 3.4 and chapter 3.6. On the other hand, BugTM\\(_H\\) and BugTM\\(_S\\) are both slower than ConAir. For BugTM\\(_H\\), this is\n\n\\(^2\\) That is, backing up selected variables using undo logs.\nbecause HTM costs more than setjmp/longjmp. For BugTM$_S$, this is because BugTM$_S$ takes extra lightweight memory checkpoints. Overall, their performance is still good, much better than full-blow memory checkpointing.\n\nBugTM$_{HS}$ provides performance almost as good as ConAir and recovery capability even better than BugTM$_H$ by carefully combining BugTM$_H$ and ConAir.\n\n(2) Automatically fix concurrency bugs via bypassing computation semantics\n\nAlong the direction of efficient concurrency bug fixing, we present a tool, BFix, that automates the whole process of fixing concurrency bugs via computation bypassing—skipping failure-inducing computation under bug-triggering contexts. BFix uses static analysis and code transformation to automatically decide which computation to bypass, to synthesize the computation-bypassing predicate, and to prove the correctness of the patch. Bypassing a group of operations clearly changes the sequential semantics of the running instance; how to make sure such execution behavior is acceptable and hence not lead software to invalid or unknown state is crucial to prove bypassing patch correctness. In this dissertation, a bypassing patch is considered to be correct only when it can help fix the reported concurrency bug as well as guarantee not to introduce new semantics, which means the bypassing semantics should already exist in the original software.\n\nBFix uses the following insight that is unique to concurrent programs to tackle the core challenge of proving the patch correctness. Instead of trying to prove that the behavior of the patched program $P'$ under a buggy timing $T$, denoted as $P'_T$, is equivalent with the behavior of the original program $P$ also under $T$, denoted as $P_T$ (which is impossible as $P_T$ is an execution failure), BFix aims to prove that $P'_T$ is equivalent with the behavior of $P$ under a different non-buggy timing $T'$, denoted as $P_{T'}$.\n\nTake the bypassing patch in Figure 1.4 as an example. It is difficult to prove the patch correctness by looking at one instance of FindLookup alone—skipping the reset of mStatus clearly would change the semantics of this individual function call. Fortunately, in the\noriginal program, Thread-2 periodically invokes FindLookup and sometimes also skips the reset of mStatus in FindLookup. For the ease of discussion, Figure 1.6(a) illustrates how the patched program $P'$ performs under a bug-triggering timing $T$: at the first invocation of FindLookup, which occurs at the original buggy timing, the reset of mStatus is skipped; then, at the second invocation of FindLookup, the reset of mStatus is successfully done. This execution behavior is actually equivalent with the original program $P$ under a slightly different timing $T'$, as shown in Figure 1.6(b): the first invocation of FindLookup occurs a little bit earlier, right before ProcessLookup is invoked, and hence the reset of mStatus is skipped as the completeness checking of lookup returns FALSE. Finally, at the second invocation of FindLookup, the reset of mStatus is successfully done.\n\n\\begin{itemize}\n \\item \\textbf{// Thread-1}\n \\item ProcessLookup:\n \\begin{itemize}\n \\item lookup->mStatus = COMPLETE;\n \\end{itemize}\n \\item NS_ASSERT(lookup->mStatus == COMPLETE);\n \\item FindLookup:\n \\begin{itemize}\n \\item if (lookup->mStatus == COMPLETE && (lookup->mProcess == 0))\n \\begin{itemize}\n \\item lookup->mStatus = NEW\n \\end{itemize}\n \\end{itemize}\n \\item \\textbf{// Thread-2}\n \\item FindLookup:\n \\begin{itemize}\n \\item if (lookup->mStatus == COMPLETE)\n \\begin{itemize}\n \\item lookup->mStatus = NEW\n \\end{itemize}\n \\end{itemize}\n\\end{itemize}\n\n\\begin{itemize}\n \\item \\textbf{// Thread-1}\n \\item ProcessLookup:\n \\begin{itemize}\n \\item lookup->mStatus = COMPLETE;\n \\end{itemize}\n \\item NS_ASSERT(lookup->mStatus == COMPLETE);\n \\item FindLookup:\n \\begin{itemize}\n \\item if (lookup->mStatus == COMPLETE && (lookup->mProcess == 0))\n \\begin{itemize}\n \\item lookup->mStatus = NEW\n \\end{itemize}\n \\end{itemize}\n \\item \\textbf{// Thread-2}\n \\item FindLookup:\n \\begin{itemize}\n \\item if (lookup->mStatus == COMPLETE)\n \\begin{itemize}\n \\item lookup->mStatus = NEW\n \\end{itemize}\n \\end{itemize}\n\\end{itemize}\n\n(a) Execution timeline for the patched version when bug happens \\hspace{1cm} (b) Execution timeline for original program when FindLookup is conducted early\n\nFigure 1.6: Execution timeline for the patched version in bug-triggering timing and the original program in a bug-free timing of Figure 1.4. All timeline figures in this dissertation use the same symbols: gray font means FALSE Boolean expression; rectangle represents skipped regions.\n\nFollowing this insight, BF\\textsc{ix} first identifies three common patterns where the behavior of skipping operations $O$ in the patched program $P'$ under timing $T$ is equivalent with the original program $P$ under timing $T'$: (1) overwritten pattern, where $O$'s side effect is overwritten by following writes and hence $P'_T$ is equivalent with skipping $O$ in $P_T$; (2) conditional pattern, where $O$ is skipped due to condition checking in both $P'_T$ and $P_T$ like that in Figure 1.6; and (3) exclusive pattern, where the repeated execution of $O$ could be\nskipped in both $P_T'$ and $P_T$ since the exclusive property guarantees only its first execution instance to succeed and repeated invocations are redundant, leading to software crash. The details are presented in chapter 4.4.\n\nGuided by these three patterns, BFix bug fixing goes through the following steps.\n\nFirst, given a bug report and the program source code, BFix first uses static analysis to decide whether any one of the three equivalence patterns might be suitable for the concurrency bug under fixing (see chapter 4.5.2 for details).\n\nSecond, if the answer is yes, BFix carefully identifies the program statements to be bypassed. Particularly, BFix makes sure that (1) enough operations are skipped so that the original bug’s failure symptom will disappear, and (2) operations that depend on to-be-skipped operations are also skipped so as not to introduce new bugs. BFix makes the above decisions by analyzing the bug report and the program source code, then following the particular equivalence pattern the bug matches with. The details are presented in chapter 4.5.2.\n\nThird, BFix synthesizes the condition predicate that decides when to bypass the above statements. Intuitively, failure-inducing operations only need to be bypassed under the bug-triggering timing, like when the FireStop is concurrently executed with the reset of mStatus in Figure 1.4. BFix carefully analyzes the program to decide whether new variables are needed or whether any existing expressions can be used to represent the bug-triggering timing. It then generates the condition checking and predicate-variable updates, if needed, accordingly. The details are presented in chapter 4.5.3.\n\nFourth, and finally, BFix merges related bug patches to further optimize performance and patch simplicity (chapter 4.5.4).\n\nAlthough computation-bypassing does not apply for all concurrency bugs, BFix helps to automatically generate high quality patches for a large family of concurrency bugs, greatly complementing existing auto-fixing tools. We have evaluated BFix on eight real-world con-\ncurrency bugs. The patches generated BFix eliminate 5 out of them and significantly decrease the failure probability in the other 3 cases. Comparing these patches with synchronization-adding patches generated by CFix [28] and synchronization-moving patches generated by HFix [39] generated by previous auto-fixing tools [28, 39], these bypassing patches generated by BFix offer much better performance and code simplicity. The experimental results show that the quality of BFix patches is similar to the manual bypassing patches in terms of patch correctness, patch performance and patch simplicity.\n\n### 1.3 Dissertation Organization\n\nThe remainder of this dissertation is organized as follows. Chapter 2 introduces previous work on empirical study of concurrency bugs, concurrency bug detection and fixing, concurrency bug prevention and failure recovery. Chapter 3 presents our efficient solution BugTM for concurrency bug failure recovery during production runs. Chapter 4 introduces our efficient fixing tool BFix for concurrency bugs during code maintenance. Chapter 5 concludes this dissertation and discusses future research work.\nCHAPTER 2\nBACKGROUND AND RELATED WORK\n\nThis chapter presents the background and the related work of this dissertation. Chapter 2.1 introduces concurrency bugs and the types we are working on. Chapter 2.2 discusses related empirical study of concurrency bugs. Chapter 2.3 discusses previous work on concurrency bug detection. Chapter 2.4 discusses how to prevent concurrency-bug failures, while chapter 2.5 discusses existing approaches on failure recovery. Chapter 2.6 introduces related work of concurrency bug fixing. Chapter 2.7 introduces condition synthesis in program repair.\n\n2.1 Concurrency bug\n\nConcurrency bugs are one notorious type of software bugs. These timing-related bugs manifest non-deterministically, and hence are extremely difficult to detect, diagnose, and fix. Concurrency bug problems are becoming more difficult and important with the prevalence of multi-core hardware [6].\n\nIn this dissertation, we mainly focus on fighting with three types of concurrency bugs, atomicity violation (AV), order violation (OV) and deadlock (DD).\n\nAn atomicity violation happens when the atomicity of a code region $C$ is unexpectedly violated, such as the bug shown in Figure 1.3. If Thread-2 assigns NULL to $s \\rightarrow \\text{table}$ between operations $A_1$ and $A_2$ in Thread-1, sanity checking in $A_2$ would fail, and fatal-error message would be thrown. However, no matter this assignment is executed before $A_1$ or after $A_2$, program can run as normal without bug manifestation.\n\nAn order violation happens when an operation $A$ unexpectedly executes after, instead of before, operation $B$, such as the bug in Figure 2.1. If $A$ in Thread-2 is executed before $B$ in Thread-1, the program can successfully execute. If the order is opposite ($B$ is executed before $A$), Thread-1 would throw assertion failure.\nDeadlock bugs occur when different threads each holds resources and circularly waits for each other. In Figure 2.2, Thread-1 and Thread-2 acquire nlock and slock in reversed orders and lead to deadlock.\n\n```c\n1 //Thread-1\n2 Close(){\n3 ... \n4 Lock(&nlock);\n5 \n6 drive->Close();\n7 \n8 Lock(&slock);\n9 ... \n10 }\n\n1 //Thread-2\n2 Shutdown(){\n3 ... \n4 Lock(&slock);\n5 \n6 if(nSockets[i]){ \n7 \n8 Lock(&nlock);\n9 } \n10 }\n```\n\nFigure 2.2: A real-world DD bug (simplified from HawkNL)\n\n### 2.2 Empirical study of concurrency bugs\n\nPast research studies looked at real-world concurrency bugs [18, 47] and synchronization-related code changes [20, 55, 62, 75]. They provide important guidance for concurrency bug detection.\n\nSeveral empirical studies have looked at concurrency-bug patches with different focuses. One focuses on the correctness of intermediate patches [78]; one studies patches to understand how file systems evolve [44]; one focuses on how transactional memory might help simplify concurrency bug patches [73], this is strongly related with our BugTM work. They manually apply transactional memory on concurrency bugs. However, as shown in chapter 3.1, our work is much more challenging.\n\nLu et al. [46] summarize concurrency-bug patches into five categories: condition check,\ncode switch, design change, add/change locks, and others. Their study gives a sense how the manual patches look like. Another study conducted by Cerney et al. [9] check the patches of concurrency bugs in Linux device drivers. Liu et al. [39] provide an in-depth understanding of concurrency bug patches, through a thorough study of manual patches for 77 real-world concurrency bugs. They find the patches generated by auto fixing tools are always different with the ones developed by human. Their findings motivates our fixing tool BFix.\n\n2.3 Concurrency bug detection\n\nMany automated detection tools have been proposed for a variety of concurrency bugs, including data races [8, 17, 24, 30, 53, 64, 71, 80], atomicity violations [48, 50], order violations [19, 67, 85], and deadlocks [74]. These tools aim to discover bugs during in-house testing and are not a good fit for production-run deployment — they often incur large overhead (e.g., 10X slowdowns) and cannot provide the desired bug/failure coverage. And, the software availability and reliability are not improved if only focusing on detection. Bug fixing is the fundamental way to eliminate the concurrency bug and improve the software availability and reliability.\n\n2.4 Concurrency-bug failure prevention\n\nThe prevention approach works by perturbing the execution timing, hoping that failure-triggering interleavings would not happen. It either relies on prior knowledge about a bug/failure [29, 49] to prevent the same bug from manifesting again, or relies on extensive off-line training [81, 79] to guide the production run towards likely failure-free timing. It is not suitable for avoiding production-run failures caused by previously unknown concurrency bugs. Particularly, the LiteTx work [79] proposes hardware extensions that are like lightweight HTM (i.e., without versioning or rollback) to constrain production-run thread interleavings,\nproactively prohibiting interleavings that have not been exercised during off-line testing.\n\n2.5 Failure recovery\n\nRollback and re-execution have long been a valuable recovery [60, 71] and debugging [14, 31, 57, 70] technique. Many rollback-reexecution techniques target full system/application replay, hence have huge run-time overhead.\n\nFeather-weight re-execution based on idempotency has been used before for recovering hardware faults [12, 16]. Using it to help recover from concurrency-bug failures was recently pioneered by ConAir [82]. Our BugTM greatly improved ConAir. BugTM_H and ConAir use not only different rollback/reexecution mechanisms, but also completely different static analysis and code transformation. The \\texttt{setjmp} and \\texttt{longjmp} used by ConAir have different performance and correctness implications from \\texttt{StartTx}, \\texttt{CommitTx}, and \\texttt{AbortTx}, which naturally led to completely different designs in BugTM_H and ConAir.\n\nRecent work leverages TM to help recover from transient hardware faults [32, 38, 77]. Due to the different types of faults/bugs these tools and BugTM are facing, their designs are different from BugTM. They wrap the whole program into transactions, which inevitably leads to large overhead (around 100% overhead [32, 77]) or lots of hardware changes to existing HTM [38], and different design about how/where to insert Tx APIs. They use different ways to detect and recover from the occurrence of faults, and hence have different Tx abort handling from BugTM. They either rely on non-existence of concurrency bugs to guarantee determinism [32] or only apply for single-threaded software [38, 77], which is completely different from BugTM.\n2.6 Concurrency bug fixing\n\nSeveral researches are proposed to help automatically generate patches for concurrency bugs [27, 28, 40, 74]. They work at off-line and rely on accurate bug-detection results. Tools like AFix [27] and CFix [28], automate the manual bug fixing process for programmers and strengthen it with the static analysis techniques such as the path analysis, the reduction of subsumed bugs, and then merging of overlapping bugs. Grail [40] introduces context-aware concepts. To fix AV bugs, locks in Grail only has effect when shared memory is really accessed during run time. Axis [42] applies Petri to convert concurrency bug fixing to constraints solving, which makes patches are provable.\n\nA recent work [25] proposes a data-privatization technique to automatically avoid some read-after-write and read-after-read atomicity violations. When a thread may access the same shared variable with no blocking operations in between, this technique would create a temporary variable to buffer the result of the earlier access and feed it to the later read access.\n\nThose tools share the same feature — they try to eliminate the buggy timing, which is fundamentally different from BFix. And as HFix [39] points out those patches are always far away from what developers propose. HFix tries to leverage existing synchronizations, moving lock to extend the critical region and moving pthread_join to enforce the operations’ execution order when those operations exist in child/parent threads separately. It complements the existing auto-fixing tools. However, it focuses on different fixing strategy from our BFix.\n\n2.7 Condition synthesis in program repair\n\nEven condition synthesis is firstly introduced to the automatic concurrency bug fixing tool, it is widely used in program repair, especially in search-and-validate program repair area. They\nusually firstly generate some possible patches, and verify the correctness by running the test cases. However they can not give any correctness guarantee. Tools like GenProg [35], which uses genetic algorithm to randomly generate condition checking, SPR [43] which proposes a heuristic strategy to search the repair space defined by its rich set of repair schemes, most patches they generate are wrong and can not be deployed. Even for the state-of-the-art approach, ACS [76] which uses topological dependency/data mining to choose condition variable, it can only achieve 73.9 % precision rate. That is not the whole story. Even for the plausible patches, Qi et al. [59] show that if condition can potentially lead to bugs if not well handled. Unlike the condition synthesis in software testing, BFix provides provably correct condition synthesis.\nCHAPTER 3\nAPPLYING TRANSACTIONAL MEMORY FOR CONCURRENcy-BUG FAILURE RECOVERY IN PRODUCTION RUNS\n\nAlong the direction of concurrency bug failure recovery, we present BugTM, a TM-inspired techniques to help automatically recover concurrency-bug failures during production runs. It is almost as powerful as the traditional rollback recovery and as lightweight as ConAir. In this chapter, we will introduce the details of BugTM. Chapter 3.1 discusses the challenges of applying transactional memory for concurrency bug failure recovery. Chapter 3.2 introduces the background of transactional memory. Chapter 3.3 introduces the state-of-the-art concurrency bug failure recovery technique – ConAir. Chapter 3.4 presents the first design BugTM_H, while chapter 3.6 and chapter 3.7 present our second and third designs BugTM_S and BugTM_HS. Chapter 3.5 introduces the reason why BugTM_S and BugTM_HS are proposed. Chapter 3.8 introduces the failure diagnosis BugTM provides. Chapter 3.9 introduces our methodology for experiments. Chapter 3.10 shows our experimental results. Chapter 3.11 discussions how to deploy BugTM into real systems. Chapter 3.12 concludes the first part of this dissertation.\n\n3.1 Challenges for applying transactional memory for concurrency bug failure recovery\n\nAt the first glance, the opportunity of HTM for concurrency bug failure recovery seems obvious, as HTM provides a powerful mechanism for concurrency control and rollback-reexecution.\n\nPrevious work [73] also showed that TM can be used to manually fix concurrency bugs after they are detected.\nHowever, automatically inserting HTMs to help tackle unknown concurrency bugs during production runs faces many challenges not encountered by manually fixing already detected concurrency bugs off-line:\n\n**Performance challenges:** High frequency of transaction uses would cause large overhead unacceptable for production runs. Unsuitable content of transactions, like trapping instructions\\(^1\\), high levels of transaction nesting, and long loops, would also cause performance degradation due to repeated and unnecessary transaction aborts.\n\n**Correctness challenges:** Unpaired transaction-start and transaction-commit could cause software to crash. Deterministic aborts, such as those caused by trapping instructions, could cause software to hang if not well handled. We need to guarantee these cases do not happen and ensure software semantics remains unmodified.\n\n**Failure recovery challenges:** In order for HTM to help recovery, we need to improve the chances that software executes in a transaction when a failure happens and we need to carefully design HTM-abort handlers to correctly process the corresponding transaction aborts.\n\nBugTM addresses these challenges by its carefully designed and carefully inserted, based on static program analysis, HTM start, commit, and abort routines. It instantiates three designs BugTM\\(_H\\), BugTM\\(_S\\), BugTM\\(_{HS}\\). In chapter 3.4, 3.6, 3.7, we will show details and how BugTM addresses those challenges from HTM perspective.\n\n### 3.2 Transactional Memory (TM)\n\nTM is a widely studied parallel programming construct [22, 23]. Developers can wrap a code region in a transaction (Tx), and the underlying TM system guarantees its atomicity, consistency, and isolation. Hardware transactional memory (HTM) provides much better\n\n\\(^1\\) Certain instructions such as system calls will deterministically cause HTM abort and are referred to as trapping instructions.\nperformance than its software counterpart (STM), and has been implemented in IBM [21], Sun [15], and Intel commercial processors [1].\n\nIn this dissertation, we focus on Intel Transactional Synchronization Extensions (TSX). TSX provides a set of new instructions: \\texttt{XBEGIN}, \\texttt{XEND}, \\texttt{XABORT}, and \\texttt{XTEST}. We will denote them as \\texttt{StartTx}, \\texttt{CommitTx}, \\texttt{AbortTx}, and \\texttt{TestTx}, respectively for generality. Here, \\texttt{CommitTx} may succeed or fail with the latter causing Tx abort. \\texttt{AbortTx} explicitly aborts the current Tx, which leads to Tx re-execution unless special fallback code is provided. \\texttt{TestTx} checks whether the current execution is under an active Tx.\n\nThere are multiple causes for Tx aborts in TSX. \\textit{Unknown abort} is mainly caused by trapping instructions, like exceptions and interrupts (abort code \\texttt{0x00}). \\textit{Data conflict abort} is caused by conflicting accesses from another thread that accesses (writes) the write (read) set of the current Tx (abort code \\texttt{0x06}). \\textit{Capacity abort} is due to out of cache capacity (abort code \\texttt{0x08}). \\textit{Nested transaction abort} happens when there are more than 7 levels Tx nesting (abort code \\texttt{0x20}). \\textit{Manual abort} is caused by \\texttt{AbortTx} operation, with programmers specifying abort code.\n\n### 3.3 ConAir\n\nConAir is a static code transformation tool built upon LLVM compiler infrastructure [34]. It is a state-of-the-art concurrency bug failure recovery technique as discussed in chapter 1. We describe some techniques and terminologies that will be used in later chapters below.\n\n\\textbf{Recovery capability limitations and killing writes} \\texttt{w}_{\\text{kill}} ConAir does not allow its re-execution regions to contain any writes to shared variables. Consequently, many of its re-execution points (i.e., \\texttt{setjmp} locations) are placed right after shared-variable writes, which we refer to as \\textit{killing writes} or \\texttt{w}_{\\text{kill}}. In many cases, ConAir could not recover from a failure because a successful recovery demands killing writes to be re-executed.\nConAir fundamentally cannot recover any RAW\\textsuperscript{2} violations (e.g., the bug in Figure 1.3) and WAR violations, as Table 3.1 shows. The reason is that the (RA)W and W(AR) have to be re-executed for successful recoveries, but they are killing writes for ConAir.\n\nEven for those root-cause types that ConAir can handle in Table 3.1, its recovery capability is limited, because a killing write may exist between the failure location and the ideal re-execution point. For example, the RAR atomicity violation in Figure 3.1 cannot be recovered by ConAir due to the write to *buf on Line 3. If Line 3 did not exist, ConAir could have rolled back Thread-1 to re-execute Line 2 and gotten around the failure. With Line 3, ConAir can only repeatedly re-execute the strcat on Line 4, with no chance of recovery.\n\n**Failure instruction** $f$ ConAir automatically identifies where failures may happen so that rollback APIs can be inserted right there. This identification is based on previous observations that $\\geq 90\\%$ of concurrency bugs lead to four types of failures [83]: assertion violations, segmentation faults, deadlocks, and wrong outputs. BugTM will reuse this technique to identify potential failure locations, denoted as failure instructions $f$ in the remainder of the dissertation. Specifically, ConAir identifies the invocations of \\_\\_assert\\_fail or other sanity-check macros as failure instructions for assertion failures. ConAir then automatically transforms software to turn segmentation faults and deadlocks into assertion failures: ConAir automatically inserts assertions to check whether a shared pointer variable $v$ is null right before $v$’s dereference and check whether a pointer parameter of a string-library function is null right before the library call; ConAir automatically turns lock functions into time-out...\nlock functions, with a long timeout indicating a likely deadlock failure, and inserts assertions accordingly. ConAir can help recover from wrong output failures as long as developers provide output specifications using assertions.\n\n3.4 BugTM_H\n\n3.4.1 High-Level Design\n\nWe discuss our high-level idea about where to put Txs, and compare with some strawman ideas based on performance and failure-recovery capability.\n\n**Strawman approaches** One approach is to chunk software to many segments and put every segment inside a hardware Tx [51]. This approach could avoid some atomicity violations, the most common type of concurrency bugs. However, it does not help recover from order violations, another major type of concurrency bugs. Furthermore, its excessive use of Txs will lead to unacceptable overhead for production-run deployment. Another approach is to replace all lock critical regions with Tx. However, this approach will not help eliminate many failures that are caused by missing lock.\n\n**Our approach** In BugTM_H, we selectively put hardware Txs around places where failures may happen, like the invocation of an `_assert_fail`, the dereference of a shared pointer, etc. This design has the potential to achieve good performance because it inserts Txs only at selected locations. It also has the potential to achieve good recovery capability because in theory it can recover from all common types of concurrency bugs, as shown in Table 3.1 and explained below.\n\nAn atomicity violation (AV) happens when the atomicity of a code region C is unexpectedly violated, such as the bug shown in Figure 1.3. It contributes to more than 70% of non-deadlock concurrency bugs based on empirical studies [46], and can be further categorized into 4 sub-types depending on the nature of C, as demonstrated in Table 3.1.\nTable 3.1\nCommon types of concurrency bugs and how BugTMH and ConAir attempt to recover from them\n\n<table>\n<thead>\n<tr>\n<th>Types</th>\n<th>Atomicity Violations</th>\n<th>Order Violations</th>\n<th>Deadlocks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>(a) RAR</td>\n<td>(b) RAW</td>\n<td>(c) WAR</td>\n</tr>\n<tr>\n<td>R/W: read/write to a shared variable; thick vertical line: the execution of one thread; dashed arrowed line: the re-execution region of BugTMH; thin arrowed line: the re-execution region of ConAir; explosion symbol: a failure; -: cannot recover; ✓: sometimes can recover if the recovery does not require re-executing shared-variable writes; ✓✓: mostly can recover. The recovery procedure under BugTMHS is a mix of BugTMH and ConAir and hence is not shown in table.</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nR/W: read/write to a shared variable; thick vertical line: the execution of one thread; dashed arrowed line: the re-execution region of BugTMH; thin arrowed line: the re-execution region of ConAir; explosion symbol: a failure; -: cannot recover; ✓: sometimes can recover if the recovery does not require re-executing shared-variable writes; ✓✓: mostly can recover. The recovery procedure under BugTMHS is a mix of BugTMH and ConAir and hence is not shown in table.\n\nConflicting accesses would usually trigger a rollback recovery before the failure occurs, shown by the dashed arrow lines in Table 3.1(a)(b)(c), benefiting from the strong atomicity guarantee of Intel TSX — a Tx will abort even if the conflicting access comes from non-Tx code. For the bug shown in Figure 1.3 (an RAW atomicity violation), if we put the code region in Thread-1 inside a Tx, the interleaving NULL assignment from Thread-2 would trigger a data conflict abort in Thread-1 before the if statement has a chance to read the NULL. The re-execution of Thread-1 Tx will then re-assign the valid value to s \\rightarrow table for the if statement to read from, successfully avoiding the failure.\n\nOV bugs are another main type of concurrency bugs. It happens when an instruction A unexpectedly executes after, instead of before, instruction B, such as the bug in Figure 2.1. Different from AVs, conflicting memory accesses related to OVs may not all happen inside a small window. In fact, A may not have executed when a failure occurs in the thread of B. Consequently, the Tx abort probably will be triggered by a software failure, instead of a conflicting access, depicted by the dashed arrow in Table 3.1(e). Fortunately, the rollback reexecution will still give the software a chance to correct the unexpected ordering and recover from the failure. Take the bug shown in Figure 2.1 as an example. If we put\na hardware Tx in Thread-1, when order violation leads to the assertion failure, the Tx will abort, rollback, and re-execute. Eventually, the pointer ptr will be initialized and the Tx will commit.\n\nDeadlock bugs occur when different threads each holds resources and circularly waits for each other. As shown in Table 3.1(f), it can be recovered by Tx rollback and re-execution too, as long as deadlocks are detected.\n\nOf course, BugTM_H cannot recover from all failures, because some error-propagation chains cannot fit into a HTM Tx, which we will discuss more in chapter 3.10.\n\nNext, we will discuss in details how BugTM_H surrounds failure sites with hardware Txs—how to automatically insert StartTx, CommitTx, AbortTx, and fallback/retry code into software, while targeting three goals: (1) good recovery capability; (2) good run-time performance; (3) not changing original program semantics.\n\n3.4.2 Design about AbortTx\n\nBugTM_H uses the same technique as ConAir to identify where failures would happen as discussed in chapter 3.3. BugTM_H puts an AbortTx wrapper function my_xabort right before every failure instruction f, so that a Tx abort and re-execution is triggered right before a failure manifests. my_xabort uses a unique abort code 0xFF for its AbortTx operation (as shown in Figure 3.2), so that BugTM_H can differentiate different causes of Tx aborts and handle them differently.\n3.4.3 Design about StartTx and CommitTx\n\n**Challenges** We elaborate on two key challenges in placing StartTx and CommitTx, and explain why we cannot simply insert well-structured atomic blocks (e.g., `__transaction_atomic` supported by GCC) into programs.\n\nFirst, poor placements could cause frequent Tx aborts. Trapping instructions (e.g., system calls) and heavy TM nesting (>7 level) deterministically cause aborts, while long Txs abort more likely than short ones due to timer-interrupts and memory-footprint threshold. These aborts hurt not only performance, but also recovery — deterministic aborts of a Tx will eventually force us to execute the Tx region\\(^3\\) in non-transaction mode, leaving no hope for failure recovery.\n\nSecond, poor placements could cause unpaired execution of StartTx and CommitTx, hurting both correctness and performance. When CommitTx executes without StartTx, the program will crash; when StartTx executes without a pairing CommitTx, its Tx will repeatedly abort.\n\nTaking Figure 3.3 as an example, we want to put \\(A_1\\) and \\(A_2\\), both accessing global variable \\(G\\), into a Tx together with `__assert_fail` on Line 6 for failure recovery. However, if we naively put StartTx on Line 2 and CommitTx on Line 12, forming a well structured atomic block, correct runs will incur repeated Tx aborts and huge slowdowns due to I/Os on Line 10. Simply moving CommitTx to right after Line 4 and keeping StartTx on Line 2 still will not work — when else is taken, the earlier StartTx has no pairing CommitTx and the Tx still aborts due to I/Os.\n\nWe address the first challenge by carefully placing StartTx and CommitTx. We address the second challenge mainly through our StartTx, CommitTx wrapper-functions.\n\n**Where to StartTx and CommitTx** The design principle is to minimize the chance of aborts that are unrelated to concurrency bugs, tackling the first challenge above. BugTM\\(_H\\) achieves\n\n---\n\n3. We will refer to the code region between our `my_xbegin` and `my_xend` as a Tx region, which may be executed in transactional mode.\nvoid func(...){\n G = g; //A1\n if(!G){ //A2\n __assert_fail; //f: failure instr.\n } else{\n IO(...); //computation & I/O\n }\n}\n\nvoid func(...){\n G = g;\n if(!G){\n __assert_fail;\n } else{\n IO(...);\n }\n}\n\nFigure 3.3: A toy example adapted from Figure 1.3 (left-side) and its BugTM transformation (right-side)\n\nthis by making sure that its Txs do not contain function calls, which avoids system calls and many trapping instructions, or loops, which avoids large memory footprints. The constraint of not containing function calls will be relaxed in chapter 3.4.5.\n\nSpecifically, for every failure instruction $f$ inside a function $F$, BugTM$_H$ puts a StartTx wrapper function right after the first function call instruction or loop-exit instruction or the entrance of $F$, whichever encountered first along every path tracing backward from $f$ to the entrance of $F$. BugTM$_H$ puts CommitTx wrapper functions right before the exit of $F$, every function call in $F$, and every loop header instruction in $F$, unless the corresponding loop contains a failure instruction, in which case we want to extend re-execution regions for possible failures inside the loop.\n\nAnalysis for different failure instructions may decide to put multiple StartTx (CommitTx) at the same program location. In these cases, we will only keep one copy.\n\nFor the toy example in Figure 3.3, the intra-procedural BugTM$_H$ identifies Line 2 to put a StartTx, and identifies Line 9 and 12 to put CommitTx, as shown in the figure.\n\nHow to StartTx and CommitTx The above algorithm does not guarantee one-to-one pairing of the execution of StartTx and CommitTx, the second challenge discussed above. BugTM$_H$ addresses this through TestTx checkings conducted in my_xbegin and my_xend, BugTM$_H$ wrapper functions for StartTx and CommitTx. That is, StartTx will execute only when there is no active\nif (_xtest())\n _xend(); //terminate an active transaction\n\nFigure 3.4: BugTM<sub>H</sub>CommitTx wrapper function (my_xend)\n\nif (_xtest() == 0){ //no active Tx\n Retrytimes = 0;\n prev_status = -1;\n retry: if((status = _xbegin()) == _XBEGIN_STARTED){ //Tx starts\n //Tx starts\n } else {\n //abort fallback handler, no active Tx at this point\n Retrytimes++;\n if(status==0x00||status==0x88){ //unknown or capacity abort\n if(!(prev_status==0x00 && status==0x00) &&\n !(prev_status==0x08 && status==0x88))\n { prev_status=status; goto retry; }\n else if(status==0x06 || status==0xFF){\n if(Retrytimes < RetryThreshold)\n {prev_status=status; goto retry; }\n } else {\n //continue execution in non-Tx mode\n }\n } else {\n //abort fallback handler, no active Tx at this point\n Retrytimes++;\n if(status==0x00||status==0x88){\n if(!(prev_status==0x80 && status==0x00) &&\n !(prev_status==0x08 && status==0x88))\n { prev_status=status; goto retry; }\n else if(status==0x06 || status==0xFF){\n if(Retrytimes < RetryThreshold)\n {prev_status=status; goto retry; }\n } else {\n //continue execution in non-Tx mode\n }\n }\n }\n\nFigure 3.5: BugTM<sub>H</sub>StartTx wrapper function (my_xbegin)\n\nTxs, as shown in Figure 3.5; CommitTx will execute only when there exists an active Tx, as shown in Figure 3.4.\n\nOverall, our design so far satisfies performance, correctness, and failure-recovery goals by guaranteeing a few properties. For performance, BugTM<sub>H</sub> guarantees that its Txs do not contain system/library calls or loops or nested Txs, and always terminate by the end of the function where the Tx starts. For correctness, BugTM<sub>H</sub> guarantees not to introduce crashes caused by unpairing CommitTx. For recovery capability, BugTM<sub>H</sub> makes the best effort in letting failures occur under active Txs.\n\n3.4.4 Design for fallback and retry\n\nChallenges It is not trivial to automatically and correctly generate fallback/retry code for all Txs inserted by BugTM<sub>H</sub>. Since many Tx aborts may be unrelated to concurrency\nbugs, inappropriate abort handling could lead to performance degradation, hangs, and lost failure-recovery opportunities.\n\n**Solutions** BugTM\\textsubscript{H} will check the abort code and react to different types of aborts differently. Specifically, BugTM\\textsubscript{H} implements the following fallback/retry strategy through its \\texttt{my\\_xbegin} wrapper (Figure 3.5).\n\nAborts caused by \\texttt{AbortTx} inserted by BugTM\\textsubscript{H} indicates software failures. We should re-execute the Tx under HTM, hoping that the failure will disappear in retry (Line 14–17). To avoid endless retry, BugTM\\textsubscript{H} keeps a retry-counter \\texttt{Retrytimes} (Figure 3.5). This counter is configurable in BugTM\\textsubscript{H}, with the default being 1000000.\n\nData conflict aborts (Line 14–17) are caused by conflicting accesses from another thread. They are handled in the same way as above, because they could be part of the manifestation of concurrency bugs.\n\nUnknown aborts and capacity aborts (Line 9–13) have nothing to do with concurrency bugs or software failures. In fact, the same abort code may appear repeatedly during retries, causing performance degradation without increasing the chance of failure recovery. Therefore, the fallback code will re-execute the Tx region in non-transaction mode once these two types of aborts are observed in two consecutive aborts. Nested Tx aborts would not be encountered by BugTM\\textsubscript{H}, because BugTM\\textsubscript{H} Txs are non-nested.\n\nThe above wrapper function not only implements fallback/retry strategy, but also allows easy integration into the target software, as demonstrated in Figure 3.3.\n\n3.4.5 **Inter-procedural Designs and Others**\n\nThe above algorithm allows no function calls or returns in Txs, keeping the whole recovery attempt within one function \\texttt{F}. This is too conservative as many functions contain no trapping instructions and could help recovery.\n\nTo extend the re-execution region into callees of \\texttt{F}, we put \\texttt{my\\_xend} before every system/li-\nbrary call instead of every function call. To extend the re-execution region into the callers of $F$, we slightly change the policy of putting $\\text{my\\_xbegin}$. When the basic algorithm puts $\\text{my\\_xbegin}$ at the entrance of $F$, the inter-procedural extension will find all possible callers of $F$, treat the callsite of $F$ in its caller as a failure instruction, and apply $\\text{my\\_xbegin}$ insertion and $\\text{my\\_xend}$ insertion in the caller.\n\nWe then adjust our strategy about when to finish a BugTM$_H$ Tx. The basic BugTM$_H$ may end a Tx too early: by placing $\\text{my\\_xend}$ before every function exit, the re-execution will end in a callee function of $F$ before returning to $F$ and reaching the potential failure site in $F$. Our adjustment changes the $\\text{my\\_xend}$ wrapper inserted at function exits, making it take effect only when the function is the one which starts the active Tx.\n\nFinally, as an optimization, we eliminate Txs that contain no shared-variable reads the failure instruction $f$ has control or data dependency on. In these cases, the execution and outcome of $f$ is deterministic during re-execution, and hence the failure cannot be recovered.\n\n### 3.5 Roadmap for Further Exploration\n\nHTM in BugTM$_H$ and setjmp/longjmp in previous state-of-the-art ConAir [82] are almost at the two ends of the design spectrum. While the former provides much better recovery capability, it has higher overhead than the latter. Furthermore, HTM disallows certain operations in a Tx (e.g. malloc, memcpy, pthread_cond_wait), which could be addressed by software techniques [61, 72].\n\nTo further explore the design space, the next two chapters will explore two designs to combine the strengths of BugTM$_H$ and ConAir.\n\nOne design, BugTM$_S$, is to implement some functionalities of HTM, tailored for concurrency-bug recovery, as software extensions for ConAir. Looking at the three TM principles of conflict detection, conflict resolution, and version management, we decide to try the latter two and give up conflict detection, as conflict detection is too expensive to implement in soft-\nware. The conflict-resolution technique for shared-variable reads can provide extra options for ConAir’s re-execution: reading the latest copy means delaying the current Tx (thread), whereas reading an earlier one using an undo log means delaying the conflicting one. The version-management technique for shared-variable writes, which completely does not exist in ConAir, can extend the types of regions that can be reexecuted for recovery in ConAir. This design will be discussed next in chapter 3.6.\n\nThe other design, BugTM$_{HS}$, directly combines ConAir and BugTM$_H$. This design is feasible as Intel TSX allows setjmp/longjmp to execute inside Txs. Therefore, we can actually apply BugTM$_H$ to a program already hardened by ConAir or any setjmp/longjmp recovery scheme and obtain the union of each component’s recovery capability, which we will discuss in more details in chapter 3.7.\n\nWe do not explore combining ConAir and BugTM$_S$, because BugTM$_S$ itself is already a direct extension of ConAir. We also do not explore combining BugTM$_H$ and BugTM$_S$, because this combination will be worse than combining BugTM$_H$ and ConAir (i.e., BugTM$_{HS}$) — in terms of performance, BugTM$_S$ is slower than ConAir; in terms of recovery capability, the advantage of BugTM$_S$ over ConAir is mostly overshadowed by BugTM$_H$.\n\n### 3.6 BugTM$_S$\n\nThis chapter will focus on extending the basic setjmp/longjmp recovery scheme ConAir with two TM techniques (1) deferred write version management; and (2) undo log rollback. Our implementation will not rely on HTM and is purely based on compiler techniques. The resulting tool BugTM$_S$ not only improves the failure recovery capability of ConAir with negligible performance impact, but also well complements BugTM$_H$ by offering better performance and more design flexibility at the cost of losing some recovery capability owned by BugTM$_H$. \n\n35\nFigure 3.6: BugTM₅ deferred write transformation, denoted by ‘+’ ‘-’, makes a ConAir-unrecoverable bug recoverable.\n\n3.6.1 Deferred Writes for Failure-Unrelated \\( w_{\\text{kill}} \\)\n\nFigure 3.6 shows an RAR atomicity violation, where the \\texttt{NULL} assignment from Thread-2 could cause Thread-1 to crash at Line 7. Theoretically, ConAir can recover RAR atomicity-violation failures. However, with a killing write, which is actually unrelated to the bug, at Line 4, ConAir cannot extend its re-execution region to include both reads of \\texttt{thd->proc} in Thread-1 and hence cannot recover from the failure.\n\nTo address this problem, BugTM₅ tries moving failure-unrelated \\( w_{\\text{kill}} \\) to after the failure instruction, emulating the deferred write version-management technique in TM, so that the re-execution region can go beyond these killing writes.\n\n**Feasibility checking** For each \\( w_{\\text{kill}} \\) and the corresponding failure site \\( f \\), BugTM₅ checks two things: (1) whether moving \\( w_{\\text{kill}} \\) would change program semantics; and (2) whether the moving will cut short other failure sites’ re-execution regions. If \\( w_{\\text{kill}} \\) fails either checking, it is not moved.\n\nThe second checking is straightforward. For the first condition, BugTM₅ collects all instructions along any path from \\( w_{\\text{kill}} \\) to \\( f \\), and checks whether there exists any write-after-write, read-after-write, or write-after-read dependency between any of such instruction with \\( w_{\\text{kill}} \\).\n\nIf there is no such dependency, moving \\( w_{\\text{kill}} \\) is guaranteed not to change program seman-\ntics\\textsuperscript{4}. If there exists such a dependency upon global/heap variables, we give up the moving. If the dependency is upon a stack variable, such as \\texttt{buf} in Figure 3.6, we try code transformation to eliminate the dependency. Note that, since \\texttt{wkill} writes to a shared variable, the stack variable dependency here must be a write-after-read dependency as the one between Line 4 and 5 in Figure 3.6.\n\nTo eliminate the write-after-read dependency between \\texttt{wkill} and \\texttt{i} on a stack variable \\texttt{v}s, BugTM\\textsubscript{S} will create temporary stack variable \\texttt{tmp} to keep a copy of \\texttt{v}s at the original code location of \\texttt{wkill}, move \\texttt{wkill}, and let the moved \\texttt{wkill} read from \\texttt{tmp} instead of \\texttt{v}s, as demonstrated by Figure 3.6.\n\n**Moving the \\texttt{wkill}** To make sure the moved \\texttt{wkill} will execute for the same number of times as in the original program, BugTM\\textsubscript{S} conducts the following analysis and transformation:\n\nFirst, check if \\texttt{wkill} and \\texttt{f} are inside one function \\texttt{F} with neither inside a loop in \\texttt{F}. If not, we give up the move.\n\nSecond, collect all the basic blocks \\texttt{B} in \\texttt{F} that are on path from \\texttt{wkill} to \\texttt{f}, and copy \\texttt{wkill} to every edge that connects a basic block inside \\texttt{B} to a basic block outside \\texttt{B}. This guarantees that the new location of \\texttt{wkill} will be touched exactly once in \\texttt{F}, either immediately after \\texttt{f} or immediately when there is no chance for \\texttt{f} to execute. This way, \\texttt{wkill} will get a chance to execute, even if \\texttt{f} is not executed.\n\nThird, a stack variable is introduced to make sure that the newly moved \\texttt{wkill} would not execute if its original location was not touched, as shown in Figure 3.7.\n\nNow BugTM\\textsubscript{S} can recover from some ConAir-unrecoverable failures, like the one shown in Figure 3.6. It has almost no performance impact to the original ConAir, and guarantees to preserve program semantics.\n\n\\textsuperscript{4} This guarantee holds based on the fact that almost all architectures, including Alpha, ARM, POWER, SPARC, x86, and many others, allow compilers to reorder stores to execute after independent loads.\nWhen killing writes are dependent upon the corresponding failure instruction, which are true for all RAW violations and WAR violations, deferred write does not apply. For these cases, BugTM\\textsubscript{S} enhances ConAir by offering an extra mode of rollback: ConAir only rolls back registers for re-execution; BugTM\\textsubscript{S} offers checkpointing and rolling back the content of selected shared-memory locations, emulating undo log in TM. This option can help recover from some Read-After-Write (RAW) atomicity violations, while preserving program semantics and introducing little overhead.\n\n**Basic Algorithm** Figure 3.8(a) shows a toy example of RAW atomicity violation: if another thread changes the value of \\( g_1 \\) from 1 to 0 between the write on Line 1 and the read on Line 6, an assertion failure could happen. ConAir cannot recover from this failure, because the re-execution will start after the \\( w_{\\text{kill}} \\) in Line 1 and can never change the failure-triggering\nvalue returned by Line 6 in Figure 3.8(b). However, if the value of \\( g_1 \\) could be checkpointed right at Line 1, as shown in Figure 3.8(c), the failure could be recovered.\n\nIn general, taking a memory checkpoint is straightforward: create a local variable \\( \\text{ckpt}_g_1 \\) and copy the right hand side of the \\( g_1 \\)-assignment to \\( \\text{ckpt}_g_1 \\) right before \\text{setjmp}.\n\nMaking re-execution use the checkpointed values can be achieved through code transformation. The return value of \\text{setjmp} is -1 only when it is jumped to from a \\text{longjmp}, indicating re-execution. As shown in Figure 3.8(c) Line 5–8, BugTM\\(_S\\) makes the read of \\( g_1 \\) conditional on this return value: the read uses the value in \\( \\text{ckpt}_g_1 \\) during re-execution and uses the up-to-date value in \\( g_1 \\) during regular execution.\n\nThe above BugTM\\(_S\\) transformation can successfully recover from the failure on Line 11 in Figure 3.8(c), because the checkpointed-reexecution essentially guarantees the RAW atomicity between Line 1 and Line 6. This transformation also guarantees to preserve the original program semantics during re-execution: its re-execution is equivalent with what the original program would behave if the re-executed region was executed instantaneously right after the \\text{setjmp}.\n\n**Final Algorithm** When encounters a \\( w_{\\text{kill}} \\) which the failure site \\( f \\) depends upon, BugTM\\(_S\\) checks whether there exists a read \\( r \\) that satisfies all of the following conditions: (1) \\( r \\) may read from the same memory location written by \\( w_{\\text{kill}} \\); (2) \\( f \\) depends on \\( r \\); (3) \\( r \\) and \\( w_{\\text{kill}} \\) are inside the same basic block. If such a read \\( r \\) is found, BugTM\\(_S\\) transforms the code region between \\( w_{\\text{kill}} \\) and \\( r \\) by (1) recording the \\text{setjmp} return value to a thread-local variable \\( \\text{sj\\_ret} \\); (2) taking checkpoints right before \\text{setjmp} for all the global/heap variables read between \\( w_{\\text{kill}} \\) and \\( r \\) including \\( r \\), no matter related to the failure or not, following their load order; (3) making these accesses conditionally read from either the checkpoint or the up-to-date memory location based on \\( \\text{sj\\_ret} \\).\n\nNote that, we need to checkpoint multiple global/heap variables in their original load order, because some architectures do not allow compilers to re-order loads for memory-\nconsistency concerns (e.g., x86). For a similar reason, we only handle \\( r \\) and \\( w_{\\text{kill}} \\) inside the same basic block, because otherwise there could be inconsistent load orders among different paths from \\( w_{\\text{kill}} \\) to \\( f \\).\n\nAs an optimization, when there are multiple memory reads that BugTM\\( S \\) needs to checkpoint, BugTM\\( S \\) simply creates a clone of the region from \\( w_{\\text{kill}} \\) to the end of its basic block, makes every cloned global/heap read gets its value from the checkpoint, and switches between the cloned and the original version based on \\( sj_{\\text{ret}} \\).\n\nWhen integrating with the original rollback scheme of ConAir, BugTM\\( S \\) configures the re-execution to use the checkpoints, if they exist, in the first re-execution attempt, and switch to not using checkpoints for following attempts. Since the re-execution using checkpoints is deterministic, there is no point for more attempts if the first attempt fails.\n\n**Limitations** This extension does not allow BugTM\\( S \\) to recover from write-after-read atomicity violations; and may not fundamentally recover from a read-after-write failure. Take the bug in Figure 1.3 as an example, by using the check-pointed value of \\( s->\\text{table} \\) at Line 4, BugTM\\( S \\) will recover from the original failure on Line 5. However, after the re-execution ends at Line 4, the execution will continue using the update-to-date value of \\( s->\\text{table} \\), which is \\texttt{NULL}. Software probably will still fail, just at a later point. To fundamentally recover from this failure, we will need BugTM\\( H \\).\n\n### 3.7 BugTM\\( HS \\)\n\nAs discussed in chapter 3.5, another interesting design point that can leverage both the performance strength of \\texttt{setjmp}/\\texttt{longjmp} and the recovery strength of HTM is to use them both. The high level idea is that we can apply ConAir to insert \\texttt{setjmp} and \\texttt{longjmp} recovery code into a program first; and then, only at places where the growth of re-execution regions are stopped by killing writes, we apply BugTM\\( H \\) to extend re-execution regions through HTM-based recovery.\nWhere to `setjmp` and `StartTx` ConAir and BugTM\\(_H\\) insert `setjmp` and `StartTx` using similar algorithms, easing the design of BugTM\\(_{HS}\\). That is, for every failure instruction \\(f\\) inside a function \\(F\\), ConAir (BugTM\\(_H\\)) traverses backward through every path \\(p\\) that connects \\(f\\) with the entrance of \\(F\\) on CFG, and puts a `setjmp` wrapper function (`StartTx` wrapper function) right after the first appearance of a *killing instruction*. We will refer to this location as \\(loc_{setjmp}\\) and \\(loc_{StartTx}\\), respectively. For ConAir, the killing instructions include the entrance of \\(F\\), writes to any global or heap variables, and a selected set of system/library calls; for BugTM\\(_H\\), the killing instructions include the entrance of \\(F\\), the loop-exit instruction, and all system/library calls \\(^5\\).\n\nBugTM\\(_{HS}\\) slightly modifies the above algorithm. Along every path \\(p\\), BugTM\\(_{HS}\\) inserts the `setjmp` wrapper function at every \\(loc_{setjmp}\\), where ConAir would insert it. In addition, BugTM\\(_{HS}\\) inserts the `StartTx` wrapper function at \\(loc_{StartTx}\\), when \\(loc_{StartTx}\\) is farther away from \\(f\\) than \\(loc_{setjmp}\\) (i.e., offering longer re-execution). Note that BugTM\\(_{HS}\\) inserts `setjmp` at every location \\(loc_{setjmp}\\) where ConAir would have inserted `setjmp` because every \\(loc_{setjmp}\\) might be executed without an active hardware transaction due to unexpected HTM aborts and others. When \\(loc_{setjmp}\\) is same as \\(loc_{StartTx}\\), BugTM\\(_{HS}\\) would only insert `setjmp` instead of inserting `StartTx` wrapper function.\n\nWhere to `CommitTx` BugTM\\(_{HS}\\) inserts `CommitTx` wrapper functions exactly where BugTM\\(_H\\) inserts them. Note that, BugTM\\(_{HS}\\) inserts fewer `StartTx` than BugTM\\(_H\\), and hence starts fewer Txs at run time. Fortunately, this does not affect the correctness of how BugTM\\(_{HS}\\) inserts `CommitTx`, because the wrapper function makes sure that `CommitTx` executes only under an active Tx.\n\nHow to retry ConAir and BugTM\\(_H\\) insert `longjmp` and `AbortTx` wrapper functions, which are responsible for triggering rollback-based failure recovery, using the same algorithm —\n\n---\n\n\\(^5\\) BugTM\\(_{HS}\\) also combines the inter-procedural recovery of ConAir and BugTM\\(_H\\) in a similar way. We skip details for space constraints.\nFigure 3.9: BugTM<sub>HS</sub> rollback wrapper function\n\nright before a failure is going to happen as described in chapter 3.3 and chapter 3.4.2.\n\nBugTM<sub>HS</sub> inserts its rollback function (Figure 3.9) at the same locations. We design BugTM<sub>HS</sub> rollback wrapper to first invoke HTM-rollback (i.e., <code>AbortTx</code>) if it is under an active transaction, which will allow a longer re-execution region and hence a higher recovery probability. The BugTM<sub>HS</sub> rollback wrapper invokes <code>longjmp</code> rollback if it is not under an active transaction. To make sure that the program would not keep attempting hopeless recoveries, BugTM<sub>HS</sub> continues to use the HTM-abort statistics in the <code>StartTx</code> wrapper function shown in Figure 3.5 and continues to keep the <code>longjmp</code> retry count threshold shown in Figure 3.9.\n\nFor examples shown in Figure 1.3, 3.1, and 3.3, BugTM<sub>HS</sub> would insert both <code>setjmp</code> and <code>StartTx</code> into the buggy code regions, because <code>StartTx</code> would provide longer re-execution regions in all three cases. However, if the <code>*buf++ = ' '</code> statement does not exist in Figure 3.1, BugTM<sub>HS</sub> would not insert <code>StartTx</code> there. Consequently, if failures happen, <code>longjmp</code> will be used for recovery.\n\nOverall, we expect BugTM<sub>HS</sub> to improve the performance of BugTM<sub>H</sub> and improve the recovery capability of both BugTM<sub>H</sub> and ConAir. This will be confirmed through experiments in chapter 3.10.\n\n### 3.8 Failure Diagnosis\n\nPrevious recovery techniques, like ConAir [82], leave failure diagnosis completely to the developers, which is often very time consuming. BugTM supports failure diagnosis through\nthe root-cause inference routine shown in Figure 3.10 and extra logging during recovery.\n\n((a)) diagnosis for BugTM\\textsubscript{H}\n\n1 Input: information from a successful recovery\n2 if (timeout failures)\n3 output: deadlock\n4 else if (other explicit failures)\n5 output: Order Violation or WAW atomicity violation\n6 else if (implicit failures) //HTM data conflict aborts\n7 output: maybe RAR, RAW, or RAW atomicity violations\n\n((b)) diagnosis for BugTM\\textsubscript{S}\n\n1 Input: information from a successful recovery\n2 if (timeout failures)\n3 output: deadlock\n4 else if (first re-execution succeeds)\n5 if (with checkpoint)\n6 output: RAW atomicity violation\n7 else\n8 output: RAR atomicity violation\n9 else if (re-execution succeeds after multiple attempts)\n10 output: Order Violation or WAW atomicity violation\n\nFigure 3.10: Recovery-guided root-cause diagnosis for BugTM\\textsubscript{H} and BugTM\\textsubscript{S}\n\nThe root-cause inference algorithms for BugTM\\textsubscript{H} and BugTM\\textsubscript{S} are shown in Figure 3.10a and Figure 3.10b, respectively. These two algorithms both use the time-out failure symptom to infer deadlock root cause as shown in Line 2 of both algorithms. However, the other parts of the algorithms differ from each other.\n\nFor BugTM\\textsubscript{H}, the manifestation of a concurrency bug could lead to a HTM abort due to either (1) an explicit failure inside a HTM transaction (e.g., an assertion gets violated) or (2) a data conflict abort caused by the buggy data race inside a HTM transaction. As illustrated in Table 3.1, order violations and WAW atomicity violations are much more likely to lead to explicit failure aborts (Line 4–5 in Figure 3.10a), while RAR, RAW, and WAR atomicity violations are much more likely to lead to data conflict aborts (Line 6–7 in Figure 3.10a).\n\nIt is difficult for BugTM\\textsubscript{H} to provide more detailed root-cause inference. Furthermore, in case of a data conflict abort, BugTM\\textsubscript{H} actually cannot conclude for sure whether the abort is caused by a benign data race or a failure-inducing data race. BugTM\\textsubscript{H} can only suggest that, if the abort was caused by a buggy race, the buggy race is much more likely to be RAR, RAW, or WAR atomicity violations than order violations or WAW atomicity violations (Line 6–7 in Figure 3.10a). As we will see, this is the major diagnosis-capability limitation of BugTM\\textsubscript{H}, particularly in comparison with BugTM\\textsubscript{S}. 43\nFor BugTM$_S$, we can make root-cause triage based on the number of re-executions that were needed for a successful recovery.\n\nWhen the recovery requires only one re-execution, the root cause is either RAW atomicity violation or RAR atomicity violation (Line 4–8 in Figure 3.10b). In both cases, unserializable interleaving is unlikely to occur again during the re-execution of the expected-to-be-atomic code region, and hence one re-execution should work. We can further differentiate these two types of root causes, as the recovery of RAW atomicity violation requires the use of undo-log, as discussed in chapter 3.6.2 (Line 5–6 in Figure 3.10b).\n\nWhen the recovery requires multiple re-execution attempts, the root cause is either an order violation or a WAW atomicity violation (Line 9–10 in Figure 3.10b). In case of an order violation, the failure thread, which executes unexpectedly fast, is waiting for the unexpectedly slow thread to catch up, which is likely to take more than one re-execution. In case of a WAW atomicity violation (e.g., code region $w_1 - w_2$ unserializably interleaved by a read $r$), the failure thread rolls back and re-executes $r$, hoping that the re-executed $r$ would occur after $w_2$, instead of in between $w_1$ and $w_2$. However, when the other thread would execute $w_2$ is unpredictable. Consequently, it might take multiple re-executions of $r$ for the recovery to succeed.\n\nNote that, BugTM$_S$ cannot recover from failures caused by WAR atomicity violations, and hence WAR atomicity violations are not part of the algorithm in Figure 3.10b.\n\nFor BugTM$_{HS}$, how much diagnostic information can be provided depends on whether a failure is recovered through HTM retries or setjmp/longjmp. When the recovery is through HTM retries, the root-cause inference routine in Figure 3.10a applies; on the other hand, the inference routine in Figure 3.10b applies.\n\nComparison and discussion As we can see, BugTM$_H$ offers less diagnostic information than BugTM$_S$, mainly because there are a wide variety of reasons behind its transaction aborts (Line 7 in Figure 3.10a).\nAll schemes of BugTM further support failure diagnosis by logging memory access type (read/write), addresses, values, and synchronization operations during re-execution, which helps failure diagnosis with no run-time overhead and only slight recovery delay.\n\nSome real-world concurrency bugs are complicated and may go beyond the categories we discussed above (e.g., multi-variable atomicity violations). However, complicated bugs can often be decomposed into simpler ones. Furthermore, some principles still hold. For example, if the re-execution succeeds with just one attempt, it is highly likely that an atomicity violation happened to a code region inside the re-execution region.\n\n3.9 Methodology\n\nBugTM is implemented using LLVM infrastructure (v3.6.1). We obtained the source code of ConAir, also built upon LLVM. All the experiments are conducted on 4-core Intel Core i7-5775C (Broadwell) machines with 6MB cache, 8GB memory running Linux version 2.6.32, and O3 optimization level.\n\nBenchmark suite We have evaluated BugTM on 29 bugs, including all the real-world bug benchmarks in a set of previous papers on concurrency-bug detection, fixing, and avoidance [27, 29, 67, 82, 83, 84]. They cover all common types of concurrency-bug root causes and failure symptoms. They are from server applications (e.g., MySQL database server, Apache HTTPD web server), client applications (e.g., Transmission BitTorrent client), network applications (e.g., HawkNL network library, HTTrack web crawler, Click router), and many desktop applications (e.g., PBZIP2 file compressor, Mozilla JavaScript Engine and XPCOM). The sizes of these applications range 50K — 1 million lines of code. Finally, our benchmark suite contains 3 extracted benchmarks: Moz52111, Moz209188, and Bank.\n\nThe goal of BugTM is to recover from production-run failures, not to detect bugs. Therefore, our evaluation uses previously known concurrency bugs that we know how to trigger failures. In all our experiments, the evaluated recovery tools do not rely on any knowledge\nabout specific bugs in their failure recovery attempts.\n\n**Setups and metrics** We will measure the recovery capability and overhead of three BugTM designs. We will also evaluate and compare with ConAir [82], the state of the art concurrency-bug recovery technique.\n\nTo measure recovery capability, we follow the methodology of previous work [28, 82], and insert *sleeps* into software, so that the corresponding bugs will manifest frequently. We then run each bug-triggering workload with each tool applied for 1000 times.\n\nTo measure the run-time overhead. We run the original software **without** any *sleeps* with each tool applied. We report the average overhead measured during 100 failure-free runs, reflecting the performance during **regular** execution. We also evaluate alternative designs of BugTM, such as not conducting inter-procedural recovery, not excluding system calls from Txs, not excluding loops, etc. Due to space constraints, we only show this set of evaluation results on Mozilla and MySQL benchmarks, two widely used client and server applications.\n\n### 3.10 Experimental results\n\nOverall, three BugTM schemes all have better recovery capability than ConAir, with BugTM$^\\text{HS}$ being the best and BugTM$^H$ a close second. The three schemes also all have good performance, with BugTM$^S$ being the best and BugTM$^\\text{HS}$ the second best. BugTM$^\\text{HS}$ provides the best combination of recovery capability and performance.\n\n#### 3.10.1 Failure recovery capability\n\nAmong all the 29 benchmarks, 9 cannot be recovered by any of the evaluated techniques, no matter ConAir or BugTM, and the remaining 20 can be recovered by at least one of the techniques (BugTM$^\\text{HS}$ can recover all of these 20).\nTable 3.2\nRecovery capability comparison\n\n<table>\n<thead>\n<tr>\n<th>RootCause</th>\n<th>ConAir</th>\n<th>BugTM_S</th>\n<th>BugTM_H</th>\n<th>BugTM_HS</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MySQL2011</td>\n<td>AV_RAR</td>\n<td>–</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>MySQL38883</td>\n<td>AV_RAR</td>\n<td>–</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Apache21287</td>\n<td>AV_RAW</td>\n<td>–</td>\n<td>✓*</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Moz-JS18025</td>\n<td>AV_RAW</td>\n<td>–</td>\n<td>✓*</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Moz-JS142651</td>\n<td>AV_RAW</td>\n<td>–</td>\n<td>–</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Bank</td>\n<td>AV_WAR</td>\n<td>–</td>\n<td>–</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Transmission</td>\n<td>OV</td>\n<td>✓</td>\n<td>✓</td>\n<td>–</td>\n</tr>\n</tbody>\n</table>\n\nTotal 1 3+ 6 7\n\n*: failures partly recovered; Moz-JS: Mozilla JavaScript Engine.\n\nTable 3.2 shows the result of 7 benchmarks where different tools show different recovery capability. For the other 13 benchmarks, ConAir and BugTM can all help recover from all of them.\n\nConAir fails to recover from 6 out of 7 failures in Table 3.2, mainly because it does not allow shared-variable writes in re-execution regions. As a result, it cannot recover from any RAW or WAR atomicity bugs, and some RAR bugs, including the one in Figure 3.1.\n\nBugTM_S has better recovery capability than ConAir. Its deferred write technique helps it to successfully recover from the two RAR violation failures in the table. The undo log technique of BugTM_S allows it to partly recover from two out of three RAW benchmarks. BugTM_S does not apply undo log to Moz-JS142651 because the bug involves complicated control flows. Moz-JS18025 is demonstrated in Figure 1.3. As discussed earlier, BugTM_S can help recover from the failure shown in the figure, but cannot prevent subsequent failures caused by the NULL value of s->table. Apache21287 can be recovered by BugTM_S with about 50% probability, depending on which bug-related thread fails first. Finally, BugTM_S fundamentally cannot handle WAR violations, as discussed at the end of chapter 3.6.\n\nBugTM_H can successfully recover from all the 6 failures that ConAir cannot in Table 3.2. BugTM_H cannot recover from the Transmission bug, because recovering this bug requires re-executing malloc, a trapping operation for Intel TSX but handled by ConAir. In fact,\nmalloc is allowed in some more sophisticated TM designs [61, 72].\n\nBugTM_{HS} combines the strengths of BugTM_H and ConAir, and hence can successfully recover from all 7 benchmarks in Table 3.2. It recovers the first 6 failures through HTM retries. It recovers from the Transmission failure through longjmp (it rolls back the malloc that cannot be handled by HTM-retry through free).\n\nUnrecoverable benchmarks There are 9 benchmarks that no tools can help recover for mainly three reasons. Some of these issues go beyond the scope of failure recovery, yet others are promising to address in the future. First, two order violation benchmarks cause failures when the failure thread is unexpectedly slow. Therefore, re-executing the failure thread would not help correct the timing. Fortunately, both failures can be prevented by delaying resource deallocation, a prevention approach proposed before for memory-bug failures [52, 60]. Second, three benchmarks, Cherokee326, Apache25520, and MySQL169, cause failures that are difficult to detect (i.e., silent data corruption). Tackling them goes beyond the scope of failure recovery. Third, the remaining four failures cannot be recovered due to un-reexecutable instructions, which are promising to address. For example, Intel TSX does not support putting memcpy, cond_wait, or I/O into its Txs. More sophisticated TMs with OS support [61, 72] could help recover these failures.\n\nHardened failure sites BugTM can help recover from failures caused by concurrency bugs because it statically identifies potential failure sites and inserts rollback-reexecution code surrounding them.\n\nTable 3.3 shows the number of failure sites that are hardened by BugTM_{HS} in each benchmark software. Naturally, BugTM_{HS} identifies and hardens the fewest failure sites in the smallest programs (Bank and HawkNL) and the most failure sites in the largest programs (MySQL and Apache). Benchmarks from the same software have slightly different numbers of failures sites in Table 3.3, because they come from different versions of the software. We do full instrumentation for each version.\n## Table 3.3\nStatic failure sites hardened by BugTM$_{HS}$\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Assertion Violation</th>\n<th>Wrong Output</th>\n<th>Seg. Fault</th>\n<th>Deadlock</th>\n<th>Total</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MySQL2011</td>\n<td>151</td>\n<td>3128</td>\n<td>15498</td>\n<td>21</td>\n<td>18798</td>\n</tr>\n<tr>\n<td>MySQL3596</td>\n<td>170</td>\n<td>3297</td>\n<td>15791</td>\n<td>19</td>\n<td>19277</td>\n</tr>\n<tr>\n<td>MySQL38883</td>\n<td>170</td>\n<td>3276</td>\n<td>15820</td>\n<td>19</td>\n<td>19285</td>\n</tr>\n<tr>\n<td>Apache21287</td>\n<td>5</td>\n<td>503</td>\n<td>16834</td>\n<td>89</td>\n<td>17431</td>\n</tr>\n<tr>\n<td>Moz-JS18025</td>\n<td>35</td>\n<td>34</td>\n<td>1802</td>\n<td>10</td>\n<td>1881</td>\n</tr>\n<tr>\n<td>Moz-JS142651</td>\n<td>1</td>\n<td>31</td>\n<td>1812</td>\n<td>13</td>\n<td>1857</td>\n</tr>\n<tr>\n<td>Bank</td>\n<td>1</td>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n<td>3</td>\n</tr>\n<tr>\n<td>Moz-ex52111</td>\n<td>1</td>\n<td>1</td>\n<td>23</td>\n<td>0</td>\n<td>25</td>\n</tr>\n<tr>\n<td>Moz-ex209188</td>\n<td>1</td>\n<td>2</td>\n<td>34</td>\n<td>0</td>\n<td>37</td>\n</tr>\n<tr>\n<td>MySQL791</td>\n<td>129</td>\n<td>2421</td>\n<td>17890</td>\n<td>43</td>\n<td>20483</td>\n</tr>\n<tr>\n<td>MySQL16582</td>\n<td>134</td>\n<td>2943</td>\n<td>14592</td>\n<td>20</td>\n<td>17689</td>\n</tr>\n<tr>\n<td>Click</td>\n<td>2134</td>\n<td>32</td>\n<td>2234</td>\n<td>0</td>\n<td>4400</td>\n</tr>\n<tr>\n<td>FFT</td>\n<td>5</td>\n<td>32</td>\n<td>14</td>\n<td>0</td>\n<td>51</td>\n</tr>\n<tr>\n<td>HTTrack</td>\n<td>657</td>\n<td>504</td>\n<td>3146</td>\n<td>0</td>\n<td>4307</td>\n</tr>\n<tr>\n<td>Moz-xpcom</td>\n<td>1</td>\n<td>117</td>\n<td>6791</td>\n<td>0</td>\n<td>6909</td>\n</tr>\n<tr>\n<td>Transmission</td>\n<td>430</td>\n<td>190</td>\n<td>2151</td>\n<td>0</td>\n<td>2771</td>\n</tr>\n<tr>\n<td>zsnes</td>\n<td>1</td>\n<td>50</td>\n<td>331</td>\n<td>0</td>\n<td>382</td>\n</tr>\n<tr>\n<td>HawkNL</td>\n<td>0</td>\n<td>0</td>\n<td>5</td>\n<td>2</td>\n<td>7</td>\n</tr>\n<tr>\n<td>Moz-JS79054</td>\n<td>0</td>\n<td>5</td>\n<td>134</td>\n<td>6</td>\n<td>145</td>\n</tr>\n<tr>\n<td>SQLite1672</td>\n<td>0</td>\n<td>25</td>\n<td>47</td>\n<td>1</td>\n<td>73</td>\n</tr>\n</tbody>\n</table>\n\nThere are four types of potential failure sites: every assertion checking is a potential site for assertion-violation failure; every output function call is a potential site for wrong-output failure; every dereference of a heap or global pointer is a potential site for segmentation-fault failures; every lock acquisition that is enclosed by another lock acquisition is considered as a potential deadlock site. Among these four, potential segmentation-fault sites are the most common, and potential deadlock sites are the least common.\n\nBugTM$_H$ and BugTM$_S$ have hardened similar, just slightly fewer, failure sites as BugTM$_{HS}$, as some failure sites hardened by BugTM$_{HS}$ are identified as un-recoverable for BugTM$_H$ and BugTM$_S$, and hence not hardened by them.\n### Table 3.4\nOverhead during regular execution and detailed performance comparison\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Run-time Overhead</th>\n<th>#setjmp</th>\n<th>#StartTx</th>\n<th>#StartTx per 10µs</th>\n<th>Abort%</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>C</td>\n<td>S</td>\n<td>H</td>\n<td>HS</td>\n<td>S</td>\n</tr>\n<tr>\n<td>MySQL2011</td>\n<td>0.05%</td>\n<td>0.04%</td>\n<td>0.13%</td>\n<td>0.08%</td>\n<td>642974</td>\n</tr>\n<tr>\n<td>MySQL3596</td>\n<td>0.40%</td>\n<td>0.43%</td>\n<td>3.10%</td>\n<td>1.12%</td>\n<td>144119</td>\n</tr>\n<tr>\n<td>MySQL38888</td>\n<td>0.40%</td>\n<td>0.41%</td>\n<td>3.08%</td>\n<td>1.11%</td>\n<td>144109</td>\n</tr>\n<tr>\n<td>Apache21287</td>\n<td>0.55%</td>\n<td>0.73%</td>\n<td>3.77%</td>\n<td>3.00%</td>\n<td>39918</td>\n</tr>\n<tr>\n<td>Moz-JS18025</td>\n<td>0.57%</td>\n<td>0.86%</td>\n<td>9.03%</td>\n<td>2.62%</td>\n<td>3987</td>\n</tr>\n<tr>\n<td>Moz-JS142651</td>\n<td>0.76%</td>\n<td>0.86%</td>\n<td>11.9%</td>\n<td>5.30%</td>\n<td>2269</td>\n</tr>\n<tr>\n<td>Bank</td>\n<td>0.15%</td>\n<td>0.23%</td>\n<td>2.18%</td>\n<td>2.95%</td>\n<td>6</td>\n</tr>\n<tr>\n<td>Moz-ex52111</td>\n<td>0.47%</td>\n<td>0.65%</td>\n<td>0.53%</td>\n<td>0.41%</td>\n<td>4</td>\n</tr>\n<tr>\n<td>Moz-ex209188</td>\n<td>0.12%</td>\n<td>0.12%</td>\n<td>0.58%</td>\n<td>0.77%</td>\n<td>2</td>\n</tr>\n<tr>\n<td>MySQL791</td>\n<td>0.35%</td>\n<td>0.84%</td>\n<td>1.98%</td>\n<td>0.24%</td>\n<td>48933</td>\n</tr>\n<tr>\n<td>MySQL16582</td>\n<td>0.15%</td>\n<td>0.33%</td>\n<td>3.03%</td>\n<td>0.99%</td>\n<td>269230</td>\n</tr>\n<tr>\n<td>Click</td>\n<td>0.57%</td>\n<td>0.80%</td>\n<td>8.11%</td>\n<td>3.60%</td>\n<td>4893</td>\n</tr>\n<tr>\n<td>FFT</td>\n<td>0.05%</td>\n<td>0.05%</td>\n<td>0.03%</td>\n<td>0.14%</td>\n<td>23</td>\n</tr>\n<tr>\n<td>HTTrack</td>\n<td>0.15%</td>\n<td>0.16%</td>\n<td>0.64%</td>\n<td>0.04%</td>\n<td>9004</td>\n</tr>\n<tr>\n<td>Moz-xpcom</td>\n<td>0.38%</td>\n<td>0.40%</td>\n<td>0.45%</td>\n<td>0.03%</td>\n<td>313</td>\n</tr>\n<tr>\n<td>Transmission</td>\n<td>0.11%</td>\n<td>0.20%</td>\n<td>0.22%</td>\n<td>0.07%</td>\n<td>1088</td>\n</tr>\n<tr>\n<td>zsses</td>\n<td>0.05%</td>\n<td>0.11%</td>\n<td>0.03%</td>\n<td>0.44%</td>\n<td>10684</td>\n</tr>\n<tr>\n<td>HawkNL</td>\n<td>0.09%</td>\n<td>0.08%</td>\n<td>0.00%</td>\n<td>0.15%</td>\n<td>10</td>\n</tr>\n<tr>\n<td>Moz-JS7954</td>\n<td>0.84%</td>\n<td>0.99%</td>\n<td>11.7%</td>\n<td>4.20%</td>\n<td>340</td>\n</tr>\n<tr>\n<td>SQLite1672</td>\n<td>0.05%</td>\n<td>0.01%</td>\n<td>0.98%</td>\n<td>0.50%</td>\n<td>6</td>\n</tr>\n<tr>\n<td>Avg.</td>\n<td>0.31%</td>\n<td>0.42%</td>\n<td>3.08%</td>\n<td>1.39%</td>\n<td>-</td>\n</tr>\n</tbody>\n</table>\n\nC: ConAir; S: BugTM_S; H: BugTM_H; HS: BugTM_HS; red font denotes >3% overhead; #: count of dynamic instances; Abort%: percentage of aborted dynamic Txs\n3.10.2 Performance\n\nTable 3.4 shows the regular-run overheads of applying BugTM schemes to 20 benchmarks, all the benchmarks that are recoverable by BugTM$_S$.\n\nOverall, BugTM$_S$ has the best performance, incurring less than 1% overhead for all benchmarks at run time, almost a free lunch for production failure recovery. Considering that each reexecution point only takes a few nanoseconds to execute (a `setjmp`), the low overhead of BugTM$_S$ is understandable.\n\nBugTM$_H$ incurs more overhead, about 3% on average, than ConAir does, about 0.3% on average, mainly because a Tx is much more expensive than a `setjmp`.\n\nFortunately, BugTM$_{HS}$ wins most of the lost performance back, incurring 1.4% overhead on average and less than 3% for all but 3 benchmarks. In the worst cases, it incurs 4.2% and 5.3% overhead for two benchmarks in Mozilla JavaScript Engine (JSE), a browser component with little I/O. If we apply BugTM$_{HS}$ to the whole browser, the overhead would be much smaller, as JSE never takes >20% of the whole page-loading time based on our profiling and previous work [54].\n\nComparing BugTM$_{HS}$ with BugTM$_H$, BugTM$_{HS}$ is faster mainly because it has greatly reduced the number of hardware transactions at run time. For example, for the four benchmarks that incur the largest overhead under BugTM$_H$ (Moz-JS18025, Moz-JS142651, Click, and Moz-JS79054), BugTM$_{HS}$ reduces the \\#startTx per 10$\\mu$s from 9.4 — 30.4 to 2.6 — 12.6, and hence dropping the overhead from 8.11—11.9% to 2.6—5.3%.\n\nTx abort rate is less than 1% for all benchmarks, with more than 95% of all aborts being unknown aborts (timer interrupts, etc.). As chapter 3.10.4 will show, abort rates and overhead are much worse in alternative designs.\n\nWe do not show the execution frequencies of failure sites. In our performance experiments behind Table 3.4, failures are never triggered. Of course, code regions surrounding failure sites have been executed during our experiments. Their execution frequencies are reflected\nTable 3.5\nFailure recovery details by BugTM$_{HS}$\n\n<table>\n<thead>\n<tr>\n<th>Root Cause</th>\n<th>Recovery ($\\mu$-seconds)</th>\n<th># Retries</th>\n<th>Restart ($\\mu$-seconds)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MySQL2011 AV$_{RAR}$</td>\n<td>10</td>\n<td>1</td>\n<td>5069944</td>\n</tr>\n<tr>\n<td>MySQL3596 AV$_{RAR}$</td>\n<td>21</td>\n<td>1</td>\n<td>5982713</td>\n</tr>\n<tr>\n<td>MySQL38883 AV$_{RAR}$</td>\n<td>21</td>\n<td>1</td>\n<td>5982720</td>\n</tr>\n<tr>\n<td>Apache21287 AV$_{RAW}$</td>\n<td>98</td>\n<td>1</td>\n<td>4824363</td>\n</tr>\n<tr>\n<td>Moz-JS18025 AV$_{RAW}$</td>\n<td>42</td>\n<td>1</td>\n<td>5508</td>\n</tr>\n<tr>\n<td>Moz-JS142651 AV$_{RAW}$</td>\n<td>74</td>\n<td>1</td>\n<td>1143</td>\n</tr>\n<tr>\n<td>Bank AV$_{WAR}$</td>\n<td>5</td>\n<td>1</td>\n<td>139</td>\n</tr>\n<tr>\n<td>Moz-ex52111 AV$_{RAW}$</td>\n<td>183</td>\n<td>1245</td>\n<td>149</td>\n</tr>\n<tr>\n<td>Moz-ex209188 AV$_{WAR}$</td>\n<td>92</td>\n<td>741</td>\n<td>107</td>\n</tr>\n<tr>\n<td>MySQL791 AV$_{WAW}$</td>\n<td>10732</td>\n<td>11234</td>\n<td>66724</td>\n</tr>\n<tr>\n<td>MySQL16582 AV$_{WAW}$</td>\n<td>24321</td>\n<td>23108</td>\n<td>7424224</td>\n</tr>\n<tr>\n<td>Click OV</td>\n<td>1211</td>\n<td>7662</td>\n<td>900452</td>\n</tr>\n<tr>\n<td>FFT OV</td>\n<td>11719</td>\n<td>9725</td>\n<td>131494</td>\n</tr>\n<tr>\n<td>HTTrack OV</td>\n<td>4625</td>\n<td>18244</td>\n<td>11776</td>\n</tr>\n<tr>\n<td>Moz-xpcom OV</td>\n<td>37388</td>\n<td>124732</td>\n<td>217041</td>\n</tr>\n<tr>\n<td>Transmission OV</td>\n<td>22445</td>\n<td>1234</td>\n<td>553298</td>\n</tr>\n<tr>\n<td>znes Deadlock</td>\n<td>109</td>\n<td>1</td>\n<td>354640</td>\n</tr>\n<tr>\n<td>HawkNL Deadlock</td>\n<td>78</td>\n<td>1</td>\n<td>14493</td>\n</tr>\n<tr>\n<td>Moz-JS79054 Deadlock</td>\n<td>35</td>\n<td>1</td>\n<td>472</td>\n</tr>\n<tr>\n<td>SQLite1672 Deadlock</td>\n<td>89</td>\n<td>1</td>\n<td>1570</td>\n</tr>\n</tbody>\n</table>\n\nThe experiments are conducted with small amount of noises inserted to help trigger the concurrency-bug failures by the numbers of setjmp and StartTx in Table 3.4.\n\n**Recovery time & Comparison with whole-program restart** As shown in Table 3.5, a successful BugTM failure recovery takes little time.\n\nThe recovery of atomicity violations, except for WAW atomicity violations, and deadlocks mostly takes less than 100 $\\mu$-seconds. For these bugs, one run of retry is sufficient to avoid unexpected interleaving, because the failing thread does not need to wait for any other threads.\n\nThe recovery of order violations and WAW atomicity violations takes slightly longer time, as it highly depends on how much sleep is inserted to trigger the failure, as discussed in chapter 3.8.\n\nThe reexecution regions are always small, ranging from 5-224 instructions at byte-code\nBugTM recovery is much faster than a system restart, which could take a few minutes or even more for complicated systems, as shown in the table. BugTM recovery also avoids wasting already conducted computation and crash inconsistencies. For example, without BugTM, MySQL791 would crash the database after a table is changed but before this change is logged, leaving inconsistent persistent states.\n\nTable 3.5 only shows the recovery details of BugTM_{HS}. The details of BugTM_{H} and BugTM_{S} are similar — they took negligible amount of time to recover from most atomicity violations and deadlocks, and slightly longer time to recover from order violations and WAW atomicity violations.\n\n**Understanding BugTM_{H} overhead** The overhead of BugTM_{H} differs among benchmarks, ranging from 0.00% to 11.9%. As TM researchers found before, performance in TM systems is often complicated [7, 58]. An indicating metrics for our benchmarks is the frequency of dynamic StartTx. As shown in the #StartTx per 10μs column of Table 3.4, BugTM_{H} executes more than 1 StartTx per 10 micro second on average for 10 benchmarks, and incurs more than 1% overhead for 9 of them.\n\n### 3.10.3 Diagnosis\n\nTable 3.6 shows the different diagnosis capability of BugTM.\n\nBugTM_{S} provides useful diagnosis information for all of the 18 benchmarks that it can help recover from. For 10 out of these benchmarks whose root causes are order violations or WAW atomicity violations, BugTM_{S} reports that the root cause could be either one of these two. For the other 8 benchmarks, BugTM_{S} accurately pin-points the exact root cause.\n\nThere are many benchmarks in Table 3.6 that can be recovered by BugTM_{H} and BugTM_{HS}, but cannot be diagnosed by them. The reason is that these bugs’ manifestation leads to HTM data conflict aborts, while BugTM_{H} and BugTM_{HS} cannot decide whether such aborts are\nTable 3.6\nDiagnosis capability comparison\n\n<table>\n<thead>\n<tr>\n<th>RootCause BugTM_S</th>\n<th>BugTM_H</th>\n<th>BugTM_HS</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MySQL2011 AVRAR</td>\n<td>✓</td>\n<td>-</td>\n</tr>\n<tr>\n<td>MySQL3596 AVRAR</td>\n<td>✓</td>\n<td>-</td>\n</tr>\n<tr>\n<td>MySQL38883 AVRAR</td>\n<td>✓</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Apache21287 AVRAW</td>\n<td>✓</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Moz-JS18025 AVRAW</td>\n<td>✓</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Moz-JS142651 AVRAW</td>\n<td>NA</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Bank AVWAR</td>\n<td>NA</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Moz-ex52111 AVWAW</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>Moz-ex209188 AVWAW</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>MySQL791 AVWAW</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>MySQL16582 AVWAW</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>Click OV</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>FFT OV</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>HTTrack OV</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>Moz-xpcom OV</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>Transmission OV</td>\n<td>✓*</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>zsnes OV</td>\n<td>✓*</td>\n<td>✓*</td>\n</tr>\n<tr>\n<td>HawkNL Deadlock</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>Moz-JS79054 Deadlock</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n<tr>\n<td>SQLite1672 Deadlock</td>\n<td>✓</td>\n<td>✓</td>\n</tr>\n<tr>\n<td><strong>Total</strong></td>\n<td>8(18)</td>\n<td>3(12)</td>\n</tr>\n</tbody>\n</table>\n\nNA: can’t help recover from them\n*: report two possible root causes, order violation and WAW violation.\n-: no affirmative diagnosis\nTable 3.7\nBugTM<sub>H</sub> vs. alternative designs\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>BugTM<sub>H</sub></th>\n<th>Intra-proc</th>\n<th>Trapping-Ins</th>\n<th>Loop</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Moz-xpcom</td>\n<td>0.45% ✓</td>\n<td>0.44% ×</td>\n<td>0.54% ✓</td>\n<td>0.20% ✓</td>\n</tr>\n<tr>\n<td>Moz-JS18052</td>\n<td>9.03% ✓</td>\n<td>7.01% ✓</td>\n<td>16.8% ✓</td>\n<td>11.3% ✓</td>\n</tr>\n<tr>\n<td>Moz-JS79054</td>\n<td>11.7% ✓</td>\n<td>11.4% ×</td>\n<td>14.0% ✓</td>\n<td>11.1% ✓</td>\n</tr>\n<tr>\n<td>Moz-JS142651</td>\n<td>11.9% ✓</td>\n<td>7.6% ×</td>\n<td>19.6% ✓</td>\n<td>12.2% ✓</td>\n</tr>\n<tr>\n<td>MySQL791</td>\n<td>1.98% ✓</td>\n<td>1.50% ✓</td>\n<td>11.4% ✓</td>\n<td>11.5% ✓</td>\n</tr>\n<tr>\n<td>MySQL2011</td>\n<td>0.13% ✓</td>\n<td>0.13% ×</td>\n<td>1.50% ✓</td>\n<td>0.06% ✓</td>\n</tr>\n<tr>\n<td>MySQL3596</td>\n<td>3.10% ✓</td>\n<td>3.05% ✓</td>\n<td>108% ×</td>\n<td>2.63% ✓</td>\n</tr>\n<tr>\n<td>MySQL16582</td>\n<td>3.03% ✓</td>\n<td>0.16% ✓</td>\n<td>93.1% ✓</td>\n<td>1.89% ✓</td>\n</tr>\n<tr>\n<td>MySQL38883</td>\n<td>3.08% ✓</td>\n<td>3.04% ✓</td>\n<td>106% ×</td>\n<td>2.52% ✓</td>\n</tr>\n</tbody>\n</table>\n\n%: the overhead over baseline execution w/o recovery scheme applied; ✓: failure recovered; ×: failure not recovered.\n\ncaused by software bugs or benign races.\n\nBugTM also conducts memory-access logging during failure recovery attempts. Evaluation shows that this extra logging incurs 1.01X – 2.5X slowdowns to failure recovery with no overhead to regular execution. The 2.5X slowdown happens during a fast half-microsecond recovery.\n\n3.10.4 Alternative designs of BugTM\n\nTable 3.7 shows the performance and recovery capability of three alternative designs of BugTM<sub>H</sub>. Due to space constraints, we only show results on benchmarks in MySQL database server and Mozilla browser suite (non-extracted). Since BugTM<sub>H</sub> is the foundation of BugTM<sub>HS</sub>, an alternative design that degrades the performance or recovery capability of BugTM<sub>H</sub> will also degrade BugTM<sub>HS</sub> accordingly as discussed below.\n\nInter-procedural vs. Intra-procedural BugTM<sub>H</sub> uses the inter-procedural algorithm discussed in chapter 3.4.5. This design adds 0.00 – 4.3 % overhead to its intra-procedural alternative, as shown in Table 3.7. In exchange, there are 4 benchmarks in Table 3.7 that require inter-procedural re-execution of BugTM<sub>H</sub> to recover from. Among them, two can be recovered by ConAir and hence can still be recovered by intra-procedural BugTM<sub>HS</sub>;\nthe other two require inter-procedural BugTM\\textsubscript{HS} to recover. Recovering MySQL2011, Moz-xpcom, Moz-JS79054 has to re-execute not only function \\( F \\) where failures occur, but also \\( F \\)'s caller. As for Moz-JS142651, we need to re-execute a callee of \\( F \\) where a memory access involved in the atomicity violation resides.\n\n**Including trapping instructions in Txs** Clearly, if BugTM\\textsubscript{H} did not intentionally exclude system calls from its Txs, more Txs will abort. This alternative design hurts performance a lot, incurring around 100% overhead for three MySQL benchmarks shown in Table 3.7. Such design also causes BugTM\\textsubscript{HS} to incur more than 20% overhead on these benchmarks. Furthermore, these aborts may hurt recovery capability, as they will cause corresponding Tx regions to execute in non-transaction mode to avoid endless aborts and hence lose the opportunity of failure recovery. This indeed happens for two benchmarks in Table 3.7. One of them will also fail to be recovered by BugTM\\textsubscript{HS} under this alternative design.\n\n**Including loops in Txs** could lead to more capacity aborts, which are indeed observed for all benchmarks in Table 3.7. The overhead actually does not change much for most benchmarks. Having said that, it raises the overhead of MySQL791 from 1.98% to 11.5%.\n\n**More Txs** We also tried randomly inserting more \\texttt{startTx}. The overhead increases significantly. For Moz-JS142651, when we double, treble, and quadruple the number of dynamic Txs through randomly inserted Txs, the overhead goes beyond 30%, 100%, and 800%. The impact to BugTM\\textsubscript{HS} would also be huge accordingly.\n\n### 3.11 Discussion\n\nBugTM has explored three designs that all have better failure-recovery capability than the state of the art technique ConAir, at the cost of slightly worse performance than ConAir. These three designs have different trade-off combinations between performance and failure-recovery capability. Among them, BugTM\\textsubscript{S} has the best performance, as well as the best\nfailure diagnosis capability, but has the worst recovery capability. BugTM\\textsubscript{H} has better recovery capability than BugTM\\textsubscript{S}, but the worst performance. BugTM\\textsubscript{HS} has the best recovery capability, and also good performance that is much better than BugTM\\textsubscript{H} but slightly worse than BugTM\\textsubscript{S}. On commodity machines that support HTM, BugTM\\textsubscript{HS} is likely the best BugTM design. For the multi-threaded software systems which are performance-sensitive or I/O intensive, like browser, BugTM\\textsubscript{S} and BugTM\\textsubscript{HS} are recommended instead of BugTM\\textsubscript{H} considering BugTM’s higher overhead and HTM constraints. For other multi-threaded software systems which emphasize availability, e.g. banking/business systems, they may prefer BugTM\\textsubscript{H} and BugTM\\textsubscript{HS} for better recovery capabilities, which means fewer failure occurrences during production runs. Overall, all hardened programs of these three designs can perform as the intermediate patches before the final patches generated, which improves software availability and could facilitate the debugging and patching process.\n\nAs the evaluation and our earlier discussion show, BugTM does not guarantee to recover from all concurrency bug failures, particularly if the bug has a long error propagation before causing a failure. However, we believe BugTM, particularly BugTM\\textsubscript{HS}, would provide a beneficial safety net to most multi-threaded software with little deployment cost or performance loss. Even if not successful, the recovery attempts only delays the failure manifestation by a negligible amount of time (less than 40 micro-seconds in our experiments).\n\nSeveral practices can help further improve the benefit of BugTM. First, as discussed in chapter 3.10.1, some improvements of HTM design would greatly help BugTM to recover from more concurrency-bug failures. Second, developers’ practices of inserting sanity checks into software would greatly help BugTM. With more sanity checks, fewer concurrency bugs would have long error propagation and hence more concurrency-bug failures would be recovered by BugTM. Third, different from locks, which protect the atomicity of a code region only when the region and all its conflicting code are all protected by the same lock, BugTM can help protect a code region regardless how other code regions are written. Consequently,\ndevelopers could choose to selectively apply BugTM to parts of software where he/she is least certain about synchronization correctness.\n\nFinally, BugTM can be applied to software that is already using HTMs. BugTM will choose not to make its HTM regions nesting with existing HTM regions.\n\n### 3.12 Conclusion\n\nConcurrency bugs severely affect system availability. We present three TM-inspired techniques to help automatically recover concurrency-bug failures during production runs. BugTM$_H$ automatically inserts HTM APIs into software. It is capable of recovering failures caused by all major types of concurrency bugs and incurs 3.08% overhead on average in our evaluation. BugTM$_S$ uses STM inspired techniques to enhance the recovery capability of state-of-the-art ConAir. Although it cannot recover as many failures as BugTM$_H$, it incurs less than 1% overhead and can provide useful diagnostic information. BugTM$_{HS}$ combines ConAir and BugTM$_H$, achieving a good combination of recovery capability and performance (1.39% overhead). Overall, BugTM improves the state of the art of failure recovery, and presents novel ways of using TM techniques.\nAlong the direction of efficient concurrency bug, we present BFix, an automatic tool to bypass parts of original computation under buggy context for concurrency bug fixing during code maintenance. The patches generated by BFix have better performance and code readability than most existing auto-fixing tools, since it skips some existing computations via simple conditional checking without using timing-consuming synchronization primitives (e.g. locks). In this chapter, we will introduce the details of BFix. Chapter 4.1 introduces the challenges BFix is facing. Chapter 4.2 discusses the background of auto-fixing tools, while chapter 4.3 shows concurrency bug fixing framework that BFix reuses. In chapter 4.5 talks the work flow of BFix in details, including feasibility checking, patch generation and patch merging. Chapter 4.6 introduces the methodology of our experiment. Chapter 4.7 shows the detailed experimental result. Chapter 4.8 discusses what bugs BFix fails to fix. Chapter 4.9 concludes this chapter.\n\n4.1 Challenges for automatically generating correct bypassing patches for concurrency bugs\n\nAs mentioned, bypassing patch generation tools should decide which computation to bypass, what the condition is and prove the patch correctness. The latter two challenges are highly related to the solution to which computation to bypass.\n\nIdeally, bypassing patches should try to skip the execution of some operations along the buggy interleaving for bug fixing. Because when they are skipped, the bug might disappear.\n\nSkipping failure-triggering operation is a straightforward option, since it is the explicit reflection of bug. Taking write-after-write AV bug as an example, as shown in (i) of Figure\n4.1, assuming it would throw assertion as failure to catch unexpected program state when Thread-2’s $R$ unexpectedly reads the intermediate result of Thread-1’s two consecutive writes $P$ and $C$. In the bug-triggering timing, if assertion invocation is skipped, as shown in (ii) of Figure 4.1, the failure symptom for this bug would disappear for sure. But this option has two main problems. Firstly, the bug is already propagated among the code region between $R$ and the failure location where the assertion is called. Secondly, since assertion here is used to catch unexpected program state, skipping it and continuing executing the subsequent code region would violate the original intention, which assumes the subsequent code only executes when program goes into the expected state.\n\nSkipping the earlier operations is another option, like buggy operation $R$ is skipped, as shown in (iii) of Figure 4.1. It has several advantages over skipping failure-triggering operation. Firstly, unexpected execution order of buggy operations directly means buggy timing, it is the sufficient condition of failure symptom and could be used as the indicator of bug occurrence. Secondly, skipping them might help eliminate the bug and avoid bug propagation problem introduced by skipping failure-triggering operation. Thirdly, their information can be easily got from bug detectors.\n\nHowever, only skipping buggy operation might lead to inconsistency problem given dependency among operations. Hence, the dependency relations among operations should be explored. We can get these by conducting heavy static analysis or asking the help from developers. But none of them can help propose a simple design.\n\nAs for the synthesized condition, how to choose the variables used in extra conditional expression is also not trivial. There are two options to choose variables. If leveraging existing variables, bypassing patch generation tools should pick the suitable variables among tons of used variables in the original program. Extra semantics information might be needed. These will make the design complex. If introducing new variables, how and where these variables are updated and checked is also not easy.\nFigure 4.1: Why bypassing works for AV bugs: (i) bug context for write-after-write AV bug; (ii) skipping failure-triggering operations; (iii) skipping buggy operations\n\nCorrectness proof is also very challenging. Even for the developers who have rich background about the bugs they are working on, it is not easy to reason the correctness patch (e.g., since bypassing patch usually change the sequential semantics, only focusing on the thread where to-be-skipped operations are on can not help reason the patch correctness, developers usually need check more threads and code regions). It is even harder for the automatic tools, because they lack of rich semantics information.\n\n### 4.2 Existing auto-fixing tools\n\nMost auto-fixing tools [27, 28, 40, 42, 74] prevent buggy timing occurrence via adding synchronizations operations into software. They do not get involved with any computation semantics. The correctness is obviously guaranteed, since the correct computation semantics already exist in software and they only add constraints to enforce occurrence of the correct computation semantics.\n\nFigure 4.2 is a simplified MySQL bug from CFix. If \\texttt{NULL} assignment of \\texttt{thd\\rightarrow proc} in\nFigure 4.2: MySQL example from CFix. Interleaving ‘A’ and ‘B’ are two bug-free interleavings, ‘+’ indicates the generated patch by CFix\n\nThread-2 happens between if checking and string concatenation in Thread-1, the concurrency bug would manifest. After adding locks by CFix, there are only two possible interleavings for these code snippets, marked as A and B in Figure 4.2. Actually, these two interleavings can originally happen due to different context switch even without adding lock/unlock synchronizations. That is the main correctness reasoning for synchronization-adding tools, like CFix.\n\nThere are other auto-fixing tools which do not belong to synchronization-adding category. Data privatization [25] creates a temporary variable to buffer the result of an earlier memory access in order to prevent the buggy shared memory access. HFix [39] tries to move around existing synchronizations to extend the critical regions or enforce order relations. But similarly, none of them get involved with computation semantics.\n\n### 4.3 Bug-fixing framework\n\nBFix reuses the general bug-fixing framework proposed by CFix. The inputs to the bug-fixing framework are bug reports, which can be automatically generated by bug detection tools. Given a bug report, some feasibility checks are conducted to determine whether the designed fixing strategy might be suitable for the bug or not. If yes, it goes through patch\ngeneration. Finally, patch merging is conducted for better performance and readability.\n\nBFix reuses an important philosophy of CFix – bug fixing works only when correct bug reports are provided. It reuses the bug report format requirement of CFix. An atomicity violation bug report needs to specify three operations $P$, $C$, and $R$, referred to as buggy operations. An AV bug manifests when one thread unexpectedly executes $R$ between another thread’s execution of $P$ and $C$. For AV bugs, based on the read/write access difference, they can be categorized into four types [48], as shown in Figure 4.4. An order violation bug report needs to specify two operations $A$ and $B$, referred to as buggy operations too. An OV bug happens when $A$ unexpectedly executes after, instead of before $B$. In the remaining parts of this dissertation, we will use the same symbols as shown in Figure 4.3 to mark the code regions for AV and OV bugs. Bug reports also provide (1) a call stack that executes the buggy operation in a thread, and (2) a chain of call stacks indicating how that thread has been created.\n\nFigure 4.3: Notation for the buggy code snippet. Arrows indicate the bug-triggering timing\n4.4 Three bypassing patterns\n\nAs discussed before, given a concurrency bug, it is easy to eliminate the original failure symptom by skipping one of the buggy operations (i.e., \\( P \\), \\( C \\), or \\( R \\) in an atomicity violation or \\( A \\) or \\( B \\) in an order violation), but it is challenging to prove that such skipping does not introduce new bugs.\n\nIn this chapter, we present three common patterns among buggy operations. As we will see, if a concurrency bug falls into one of these patterns, the correctness of a corresponding bypassing patch will be easy to prove.\n\n4.4.1 Overwritten\n\nThe overwritten pattern involves two buggy operations that come from different threads and write to the same memory location. This pattern utilizes data flow information from the original program. If two buggy operations are two consecutive writes (\\( W_1 \\) and \\( W_2 \\)) to the same memory location, the side effect of the \\( W_1 \\) would be overwritten by \\( W_2 \\) during \\( T' \\). In this pattern, skipping operations \\( O \\) in \\( P' \\) is \\( W_1 \\). Since both \\( P_{T'} \\) and \\( P'_{T'} \\) skip \\( W_1 \\), it is easy\nFigure 4.5: A simplified bug in Jscript module of Mozilla, `'+'` indicates the manual patch to prove they generate the same semantics.\n\nFigure 4.5 shows a real-world concurrency bug from Mozilla, which belongs to the overwritten pattern. Thread-1 tries to insert an entry into a table `table`, while Thread-2 conducts job cleaning, it firstly fills `table` with zero, then checks each entry in the `table`. If the insertion of Thread-1 happens in between, an assertion failure would show up and the system would crash. The manual patch would skip the insertion in `PROPERTY_CACHE_FILL` when Thread-2 conducts cleaning. Specifically the manual patch introduces a context-associating flag, which would be set as FALSE before Thread-2’s cleaning and reset as TRUE afterward. Depending on the value of this flag, Thread-1 will either skip the insertion when bug timing happens or conduct the insertion under the correct timing.\n\nPatch correctness reasoning utilizes the overwritten property without asking extra semantics from the developers. The patched program of Figure 4.5 in bug-triggering timing will skip write access to `table` in `PROPERTY_CACHE_FILL`. This execution behavior $P'_T$ is actually equivalent with the original program under a correct timing ($P_T$), where this write access is conducted before `memset` of `jsFlushPropertyCache`, as shown in Figure 4.6, since the side effect of this insertion will be overwritten by `memset`.\n\nThis pattern exist widely in AV and OV bugs. Look back four types of AV bugs in Figure 4.4. For `RAW`, considering a correct timing where $P$, $C$ and $R$ follow the order $RPC$, since Write$R$ and Write$P$ write to same memory location $x$, the side effect of Write$R$ is...\nPROPERTY_CACHE_FILL:\nif (js_context.enable)\n (table.s)[0] = obj;\n\njs_FlushPropertyCache:\nmemset(table, 0, sizeof table);\nassert(table.s[0] == 0);\n\n// Thread-1 // Thread-2\n\n(a) Execution timeline for the patched version when bug happens\n(b) Execution timeline when PROPERTY_CACHE_FILL is conducted early\n\nFigure 4.6: Execution timeline for the patched version in bug-triggering timing and a bug-free run in Figure 4.5\n\n1 //Thread-1\n2\n3 Write_P;\n4\n5 Read_C;\n\nFigure 4.7: Simplified overwritten pattern for read-after-write AV bugs and their patch pattern\n\nwould be overwritten by Write_P, other threads would only get the result written by Write_P. Hence, Write_R might could be skipped. For WAR, considering a correct timing where the order PCR is followed, similarly, Write_C would be overwritten by Write_R. As for WAW, in the same thread, Write_P can be overwritten by Write_C. However bypassing Write_P is not considered by BFix, since it is hard to generate a reasonable conditional checking (we will revisit this issue later). For OV, if A and B are both write operations (or if A is the write operation and along the call stack to B, there is an overwritten operation for the same address), A might could be bypassed.\n\nImplication to patch generation Figures 4.7, 4.8 and 4.9 show all simplified overwritten patterns for the AV and OV types that BFix handles and their patch patterns motivated by Figure 4.5. In terms of what operations to bypass, the overwritten buggy write operation (the former one of two consecutive writes in $T'$) should be skipped. In terms of what bypassing\npredicate the patch should use (e.g., \\texttt{bug\\_context} in Figures 4.7, 4.8 and 4.9), a variable whose status change can reflect the occurrence of the buggy timing should be selected. Motivated by Figure 4.5, this variable should be context or address sensitive, since multiple instances might be involved. The bypassing patch should take effect only when buggy operations touch the same memory location. Additionally if it is a newly-introduced variable as illustrated in Figure 4.5, we need to carefully update it around the buggy/overwritten operations. In terms of where to insert extra conditional checking, it should be directly inserted before the overwritten write access. In terms of correctness proof, we can try to find the equivalence between $P_T$ and $P'_T$, utilizing the data overwritten property.\n\n\\subsection*{4.4.2 Conditional}\n\nThe conditional pattern involves buggy operations that lie in the existing conditional branch. This pattern utilizes control flow information from the original program. This pattern has two features: (1) $C$, $R$ or $A$ originally lie in a conditional branch (referred to as \\texttt{cond}) of the original program; (2) the value of the conditional expression (referred to as \\texttt{global\\_flag}) is updated around other buggy operations in different threads. In this pattern, skipping operation $O$ in $P'$ includes all operations surrounded by \\texttt{cond}. Since the execution behavior\n```c\n1 // Thread-1\n2 Token* instance(){\n3 ...\n4 if(!fInst){\n5 XML_Lock();\n6 + if(fInst == NULL){\n7 fInst = new TokenMap();\n8 ...\n9 } + }\n10 XML_Unlock();\n11 } +\n12 }\n13 return fInst;\n14 }\n```\n\nFigure 4.10: A simplified bug from Apache Xerces. ‘+’ indicates the manual patch of skipping such operations could be found both in $P_T'$ and $P_T''$ due to the different paths taken, it is not difficult to prove they can generate the same semantics that skips $O$.\n\nFigure 1.4 belongs to the conditional pattern. The reset procedure is inside a conditional branch in the original program. When reasoning the correctness of the manual bypassing patch, lookup→mStatus == COMPLETE checking plays a critical role. As shown in Figure 1.6, in a correct timing where lookup→mStatus == COMPLETE checking happens before lookup→mStatus = COMPLETE, lookup→mStatus == COMPLETE should be FALSE, and as a result, the reset of mStatus is skipped. This skipping reset of mStatus execution behavior $P_T'$ is the same as the patched version in buggy timing $P_T''$.\n\nFigure 4.10 shows another conditional pattern example from Apache Xerces. When two threads concurrently execute the function instance, it is possible that fInst would be updated twice. If Thread-2 already reads and locally copies the returned fInst before the second update by Thread-1, it would lead to inconsistency issue. Similarly, the manual patch uses existing variable fInst for conditional checking to skip the second update in Thread-1.\n\nThe correctness of the bypassing patch of this example is also related to the existing condition branch in Line 4 of Thread-2. As shown in Figure 4.11, the patched program will skip the update to fInst in Thread-1 when the bug is about to happen. This execution behavior $P_T''$ is actually equivalent with the original program under a different timing ($P_T'$),\nwhere Thread-2 conducts instance earlier and the update to fInst in Thread-1 is skipped since fInst is not NULL after Thread-2’s update.\n\n(a) Execution timeline for the patched version when bug happens\n\n(b) Execution timeline when Thread-2 conducts instance later\n\nFigure 4.11: Execution timeline for the patched version in bug-triggering timing and a bug-free run in Figure 4.10\n\nFigures 4.12, 4.13, 4.14 show all conditional patterns that BFix handles and their patch patterns motivated by Figure 1.4 and Figure 4.10. They have several cases, since global_flag can be updated to different values in different locations. For example, for the case where R is in an existing conditional checking, global_flag can be updated before P, after C and between P and C. Additionally, the update has two types: (1) Upglobal_flag: global_flag is updated to the same value as conditional branch checks; (2) !Upglobal_flag: global_flag is updated to the opposite value as conditional branch checks.\n\n**Implication to patch generation** In terms of what operations to bypass, it is straightforward that all operations surrounded by the existing conditional branch cond should be skipped. In the conditional pattern, only skipping buggy operations is not enough, operations that depend on buggy operations should be skipped too. Such information is already encapsulated by the existing control flow structure cond. In terms of what bypassing predicate that patch should use, similar to the overwritten pattern, a variable bug_context whose status change can reflect the occurrence of buggy timing is introduced. Buggy variable itself can also serve as extra conditional checking, as shown in Figure 4.10, since the remote write\nfrom other threads can cause value difference at location $P$ and $C$. This finding provides a way of choosing existing variable for condition synthesis in bypassing patch generation. In terms of where to insert extra conditional checking, we need to use \\textbf{AND} to connect newly-introduced checking with existing conditional branch $cond$. In terms of correctness proof, we can try to find the equivalence between $P_T'$ and $P_T''$ utilizing existing control flow information.\n\n\\textbf{4.4.3 Exclusive}\n\nThe exclusive pattern involves two buggy operations that come from different threads and conduct the same exclusive function. This pattern utilizes implicit semantics of exclusive functions. Certain functions have exclusive property, that is – they can only successfully execute once for a specific memory location, further invocation on the same memory location is redundant and would fail. These functions always destroy resources, like \\texttt{free} for memory resource and \\texttt{shutdown} for socket resource. In this pattern, skipping operations $O$ in $P'$ should be the repeated invocation of the same exclusive function in $T$. Since the repeated execution of same exclusive function can always be skipped without violating the correctness, the\nFigure 4.14: Simplified conditional pattern for bypassing A and the patch pattern\n\n(a) Updating is opposite to the conditional check\n\n(b) Updating is same as the conditional checking\n\nFigure 4.15: All conditional patterns that BFix handles. global_flag is a shared memory location, it can be a variable or expression. For each case, the inferred correct timing and bypass-able operation are also shown\n\ncorrectness proof for this pattern is very simple and it is done by checking the existence of exclusive functions.\n\nFigure 4.16 shows a modified version of a bug in Apache belonging to the exclusive pattern. Thread-1 creates and inserts an entry obj_1 into a queue at the beginning and finally removes it from the queue and frees it by invoking cache_remove. Thread-2 tries to pop an entry obj_2 from the same queue and frees obj_2. When obj_1 and obj_2 point to the same memory location, and Thread-2’s cache_pop happens between Thread-1’s insertion and removal, the same object might be freed twice. The manual patch uses an existing function cache_find as conditional checking before Thread-1’s removal. When buggy timing happens, the entry would not be found in the queue, cache_find returns FALSE and as a\nFigure 4.16: A modified version of a concurrency bug in Apache, ‘+’ indicates the manual patch result, Thread-1 would skip removal for this object.\n\nThe correctness reasoning for this patch is different from the former two patterns. It utilizes the semantics provided by exclusive functions. Firstly, since `free` operation has exclusive property, the repeated invocation of `free` for the same memory location is always redundant and could be skipped. Secondly, `free` will deallocate the memory address, which means it is the ending of the life cycle for this entry object and no further valid operations should access the same entry object (the pointed space would be deallocated, and the pointer would point to an invalid location). Hence the repeated `free` could be skipped here without violating the correctness.\n\n**Implication to patch generation** In terms of what operations to bypass, the bypassing patch should skip the repeated invocation of same exclusive function in $T$. For Figure 4.16, the second invocation of `free` for the same memory location is skipped in bug-triggering timing 1. In terms of what bypassing predicate that patch should use, even developers directly leverage an existing function `cache_find` to check whether the object is removed or not, this function has the same property as previously introduced new variables – the return value of this function can reflect the occurrence of the bug timing. If automatic tools also\n\n---\n\n1. In bug-triggering timing, the removal procedure inside `cache_remove` is a silent behavior. It is read-only without changing any environment. Skipping `cache_remove` is actually semantically the same as skipping `free`. \n\n---\nwant to leverage this function, they need to explore the semantics of `cache_find` or ask the help from developers, which is different from Figure 4.10. And for this bug, the patch also cares about multi-instance or multi-thread problems. In terms of where to insert extra conditional checking, it should be inserted directly before the repeated invocation of the same exclusive function in $T$. In terms of correctness proof, we only need to check the existence of exclusive functions and whether their parameters touch the same memory location or not.\n\n4.5 BFix\n\nGuided by these three common bypassing patterns, BFix is designed to facilitate applying computation-bypassing strategy for concurrency bug fixing. In this chapter, we will firstly briefly introduce the workflow of BFix, and then introduce the design details about BFix, showing how BFix answers the questions about bypassed operations, synthesized conditions and correctness proof.\n\n4.5.1 Workflow of BFix\n\nThe framework of BFix is depicted in Figure 4.17. Given the bug report from bug detectors, BFix will conduct several checks to determine whether it is suitable to apply computation-bypassing fixing strategy during the feasibility checking stage. Specifically, three checks are conducted.\n\n**Pattern checking:** BFix checks whether the reported bug fit any one of three common bypassing patterns. Specifically, BFix checks (1) whether the buggy operations can be overwritten; (2) whether the buggy operations are conditional in the original program; (3) whether the buggy operations are used as arguments for exclusive functions. This step will identify which pattern the current program belongs to and the correct timing BFix infers.\n\n**Synchronization checking:** BFix checks whether the correct timing it infers in the pattern checking can really happen. Specifically, BFix would check whether there are existing\nsynchronizations around the buggy code region, which hinder the occurrence of the identified correct timing. BFix focuses on condition-wait operations, barriers, thread join operations.\n\n**Equivalence checking:** Pattern checking mainly focuses on the buggy operations or operations encapsulated with buggy operations. During equivalence checking, BFix considers all operations. BFix takes all operations’ execution order in the correct timing got from the pattern checking step and all operations’ execution order in the bug-triggering timing with certain code region skipped. Then BFix checks whether two series are semantically equivalent or not. This is mainly for the overwritten and conditional patterns.\n\nOnly when all checks are passed, BFix goes to patch generation, synthesizing conditional checking for the to-be-bypassed operations. Finally, BFix merges the patches for better performance and readability. The computation that will be bypassed depends on which pattern the original program belongs to, and this is answered in the pattern checking step. The patch generation step shows the details about what condition is synthesized. As for the correct proof, BFix relies on all checks conducted in the feasibility checking step.\n\n4.5.2 Feasibility checking\n\nFirstly, BFix will conduct **pattern checking**, where it focuses on three common bypassing patterns (Overwritten, Conditional and Exclusive patterns). BFix can only help generate\ncorrect bypassing patch for bugs that fit any one of these three patterns. Here we will introduce how to check original program matches them.\n\nChecking algorithm for Overwritten Pattern Given the bug report for a concurrency bug, BFix determines it is an AV or OV bug by checking the number of input buggy operations. For an AV bug, BFix checks the access types of $P$, $C$ and $R$. If it belongs to RAW or WAR cases, BFix marks it as an overwritten pattern, and records the bypassing candidate $R$ or $C$ (BFix does not need to check whether they write to the same memory location or not, since the bug detector has verified that in the buggy timing.). For an OV bug, similarly, BFix checks the access type of $A$ and $B$, if (1) $A$ and $B$ are both write operations, BFix marks this case as overwritten, or (2) $A$ is a write operation, and along the call stack of $B$, there is a overwritten operation to the same address, BFix marks this case as an overwritten pattern too.\n\nBFix covers complex overwritten cases, like the relation of writing to a filed of a struct and writing to the whole struct and some commonly-used overwritten library functions, like memset etc.\n\nChecking algorithm for Conditional Pattern BFix checks whether the reported bug belongs to the conditional pattern or not based on the control flow structure. As mentioned in chapter 4.4.2, because of different updating values and locations for $\\text{global\\_flag}$, there are 12 conditional cases that BFix can handles, as shown in Figure 4.15. The differences between updating value and location would affect what type of correct timing BFix will search. For example, for the case where $R$ is in an existing conditional checking, if $\\text{global\\_flag}$ is set to the opposite value of the conditional branch checks, BFix will mainly search PCR correct timing. Actually as long as the branch checking happens after $\\text{global\\_flag}$ updating, no matter PCR or RPC, they can generate the semantics where $R$ is skipped. However, it is more natural to search PCR since $RPC$ happens in a stricter timing. Which correct timing\nBFix infers does not affect the correctness of generated patch.\n\nThe checking algorithms for these 12 cases are similar. Due to the space limit, we only show details for (a)(1) and (b)(1), others can be easily inferred.\n\nThe checking algorithm is straightforward. Given the location of $P$, $C$, $R$ and their call stacks, firstly BFix backwardly searches the branches and their corresponding conditions from $R$ along the call stacks. Currently, BFix searches at most 5-level callers along the call stacks. This threshold is configurable. For the compound condition, the current version of BFix only considers \\textbf{AND} and \\textbf{NOT} binary operators for simplicity. For other cases, BFix simply ignores them.\n\nSecondly, for each recorded simple branch condition, BFix filters it out if it (1) has function calls (to avoid the expensive inter-procedural analysis); (2) only has local variable read; (3) has write operations. For each remaining condition $\\text{cond}$ after filtering, BFix records global/heap variable read ($\\text{global\\_flag}$), whose value can be affected by other threads. For the compound condition, BFix decomposes it and analyzes each part separately.\n\nThirdly, BFix backwardly searches $!U_{\\text{p\\_global\\_flag}}$ or $U_{\\text{p\\_global\\_flag}}$ (referred to as $\\text{cond\\_point}$) from $P$ ($P$ is included) for each $\\text{global\\_flag}$. Similarly, BFix searches at most 5-level callers along $P$’s call stack. And BFix constructs post-dominate tree to make sure this $!U_{\\text{p\\_global\\_flag}}$ or $U_{\\text{p\\_global\\_flag}}$ is executed with $P$ and $C$ every time. Also BFix checks there is no other updating to $\\text{global\\_flag}$ between $\\text{cond\\_point}$ and $P$. BFix uses LLVM built-in alias analysis. Only when it is reported as \\textbf{MUST} alias, BFix considers two variables touching the same memory location. For the case of updating to the same value as branch checking checks, as in (b)(1), BFix conducts safety checking, to make sure the value before the updating point in Thread-1 is actually FALSE along the call stack of $P$. Only when it is actually FALSE, BFix marks it as a conditional pattern. Similarly, BFix searches at most 5-level callees along $P$’s call stack.\n\nTaking Figure 1.4 as an example, BFix firstly finds reset of $\\text{m\\_Status}$ surrounded by a\nif checking in Line 5 of FindLookup. BFix then extracts the checking conditions from that if checking, where it checks heap variable mState equals COMPLETE or not. After that, BFix backwardly searches updating location for this heap variable from Line 27 in FireStop, which is the other buggy location reported by the bug detection. Along the call stack, BFix finds the statement in Line 8 of ProcessLookup (the caller of FireStop function). At this point, mState is updated to COMPLETE, and this would serve as the evidence that resetting procedure is bypassable.\n\n**Checking algorithm for Exclusive Pattern** Since the correctness reasoning of exclusive pattern heavily relies on the implicit semantics of exclusive functions, BFix carefully chooses exclusive functions.\n\nCurrently, BFix only considers free for memory operation and shutdown for socket operation. Given the bug report, BFix checks whether buggy operations served as arguments for such functions in the buggy code region. If yes, BFix considers it as an exclusive pattern. Developers can add more exclusive functions into the configure files of BFix, like adding vio_close for MySQL application.\n\nThe second checking in feasibility checking stage is synchronisation checking. For the correct timing from which BFix infers whether certain buggy operation is bypass-able, BFix also need to check whether it can really happen or not. Basically, BFix determines whether there are existing synchronisation operations (condition-wait operations, barriers, thread join operations, etc.) around the buggy code region.\n\nFor AV bugs, BFix checks whether there are mentioned synchronisation operations between P and C 2. If yes, the inferred correct timing PCR or RPC might not actually happen, and BFix conservatively stops.\n\nFor OV bugs, such check is not needed. Since BFix always infers from the correct timing AB, if this order can not happen, the bug could always manifest.\n\n2. It also includes the region between P/C and !Upglobal_flag/Upglobal_flag.\nThe third checking **equivalence checking** is directly with correctness proof. To prove the correctness of bypassing patch, basically, BFix checks the equivalence between the original program $P$ in a correct timing $T'$ and the patched program $P'$ in bug-triggering timing $T$. During the pattern checking, BFix mainly focuses on buggy operations or operations encapsulated with buggy operations, comparing their equivalent execution behavior in $T$ and $T'$. That is not enough. Since the execution order among other unchecked operations might be different in $T$ and $T'$, new semantics might be introduced. But if there are no dependencies among them, their execution could be reordered without violating correctness. As a result, equivalent execution behavior between them can be found. But if there are no dependency among them, their execution could be reordered without violating correctness. As a result, equivalent execution behavior between them can be found. In general, the independency relations among certain regions should be checked as well for correctness proof.\n\n\n\n(a) The execution of region $N$ is advanced in bypass-patched program for (a)(1) in Figure 4.15\n\n(b) The execution of region $M$ is postponed in bypass-patched program for (b)(1) in Figure 4.15\n\nFigure 4.18: Bypass-patched program may change the execution order of original program; dotted arrows means execution order is changed; same notation is used as Figure 4.3\n\nDepending on the operations that are to be bypassed and the correct timing BFix infers, different code regions should be checked. Taking (a)(1) and (b)(1) in Figure 4.15 as examples, different region relations should be verified for the full correctness proof, as shown in Figure 4.18. For (a)(1), in $T'$, all operations $I_N$ of region $N$ are conducted after $C$, while $I_N$ are conducted after $P$ in $T$, which means the execution of $I_N$ is advanced, if we can prove all\noperations $I_Y$ are independent with $I_N$ and $C$ is independent with $I_N$, then even we postpone the execution of $I_N$, it does not affect the correctness because of the accepted reordering by memory model \\(^3\\). As a result, the serialized interleaving of the patch program in $T$ is proven as a subset of the serialized interleaving of original program in $T'$, the correctness of bypassing patch is hence proven. Using the same analysis method, for (b)(1) we need to prove the independency between region $M$ and $P$ \\(^4\\), region $M$ and region $Y$.\n\nIn the remaining part of this dissertation, if two operation sequences $J$ and $K$ are data and control independent, this relation would be denoted as $J \\perp K$.\n\nThe basis philosophy of equivalence checking is: for two regions $J$ and $K$ from different threads, in $T'$, their execution orders are determined (e.g. all operations in $T'$ are executed after operations of $K$). While in $T$, the operations inside these two regions can interleave with each other, BFix tries to check whether the relation $J \\perp K$ is held or not.\n\n**What to check** Based on which correct run BFix infers, different code regions should be checked \\(^5\\).\n\n- **AV-bypassing $R$**: If the correct timing that BFix infers belongs to $PCR$, BFix checks whether $C' \\perp N$ and $Y \\perp N$ or not. If the correct timing that BFix infers belongs to $RPC$, BFix checks whether $M \\perp P'$ and $M \\perp Y$ or not.\n\n- **AV-bypassing $C$**: If the correct timing that BFix infers belongs to $PCR$, BFix checks $Y \\perp R'$ and $Y \\perp N$. If the correct timing that BFix infers belongs to $RPC$, BFix checks $M \\perp P'$, $M \\perp Y$, $R' \\perp Y$ and $R' \\perp P'$.\n\n---\n\n3. BFix uses PSO memory model for reordering transformation. For any read and write(read) in the same thread, if they don not touch the same memory location, their order can be flipped. It is also applied to the write and write operations.\n\n4. Actually it should be the region between $Up\\_global\\_flag$ and $P$.\n\n5. $P'$, $C'$, $R'$ and $B'$ refer to the operations between updating point $\\text{cond\\_point}$ and $P$, $C$, $R$ and $B$. \n\n79\n• OV-bypassing A: The correct timing BFix infers can only belong to AB, BFix checks $C' \\perp B'$ and $C'' \\perp F$.\n\nHow to check If at least one of region $J$ and $K$ is empty, then $J \\perp K$. If $J$ and $K$ are both the regions that contain at least one statement and are bounded 6, BFix checks $J$’s and $K$’s read and write sets along their call stack separately, then check whether they have read-and-write, write-and-read, or write-and-write dependency. All shared variable accesses in synchronization primitives are considered as read. In the current prototype, BFix uses the default MAY-pointer-alias in LLVM to decide whether two sets of operations read/write the same memory location. If at least one region is unbounded, BFix uses the following rules to conduct dependency checking (for conditional case, global_flag expression cond would be removed from the comparison, since its value is TRUE or FALSE, and BFix knows its value in bug-triggering timing and the correct timing BFix infers).\n\n1. If at least one of $J$ and $K$ only access the local variables, then $J \\perp K$.\n\n2. If for all heap/global variable accesses in $J$ (or $K$), before $K$ (or $J$), they are destroyed (currently BFix focuses on destroying functions free, gc, etc; developers can also provide such information through configure file), then $J \\perp K$.\n\n3. If there are no reported concurrency bugs in region $J$ and region $K$, then $J \\perp K$. (This means operations in $J$ and $K$ may touch the same memory location, but their order is enforced by existing synchronizations and can not interleave arbitrarily).\n\n4. Either current thread is terminated in $J$ or $K$ (e.g. kill and cancel of pthread library, these are configurable for BFix) or $J$ or $K$ is directly in the main function. In this\n\n---\n\n6. A region is bounded if its range can be determined statically. If the starting or the ending point of a region could be as far as the start or the end of the whole thread, then this region is unbounded. Except the region $P, Y, C, R$ for AV bugs and $A, B$ for OV bugs, all other regions are unbounded for BFix.\ncase, BFix can infer that the ending point of the region \\( J \\) or \\( K \\) is bounded, and uses the algorithm described above to check \\( J \\perp K \\).\n\n5. Current thread is created in \\( J \\) or \\( K \\) (e.g. \\texttt{pthread_create} in \\texttt{pthread} library). In this case, BFix can infer the the starting point of the region \\( J \\) or \\( K \\) is bounded, and uses the algorithm described above to check \\( J \\perp K \\).\n\nAfter passing the equivalence checking, the same semantics generated by the threads involved with bug manifestation are always found in the correct timing space. As for other threads, since we can always advance or delay them in the correct timing space to generate the same schedule as in the bug-triggering timing space, it follows that their equivalent semantics can be found in the correct timing space too. Then, BFix finds the equivalent execution behavior for all operations. The full correctness proof is completed.\n\n\\textit{4.5.3 Patch generation}\n\nThe patch generation for BFix is motivated by the hints obtained from the manual patches shown in chapter 4.4. Firstly, it is possible that one operation has multiple instances. The patch should only take effect for the instance, that leads to the bug-triggering timing. Secondly, if introducing new variables as conditional checking, such variables should update around the buggy region. Thirdly, buggy variable itself sometimes can be used as conditional checking. Fourthly, regardless of whether the bypassing patch is using existing variables or introducing variables, their status change should reflect the occurrence of the bug-triggering timing.\n\nIn this chapter, we will introduce how to generate the bypassing patch when all feasibility checks are passed. We will discuss where to insert the conditional checking, what the conditional expression is and what the bypassing patch looks like. BFix uses the same function clone technique as CFix in order to make sure the generated patch only affects the execution of the buggy call stack.\n**Which computation to bypass** Benefited by the three adopted common bypassing patterns, which computation to bypass in the bug-triggering timing is straightforward for BFix. For the overwritten pattern, BFix would bypass the former write access of two consecutive write accesses. For the conditional pattern, the related operations have been encapsulated by if-else body, BFix would bypass such operations. For the exclusive pattern, BFix would bypass the repeated invocation of exclusive function of buggy interleaving, which takes buggy variables as arguments.\n\n**What is the condition** There are two ways to synthesize variables or expressions for conditional checking. One is to directly use existing variable/expression/function, which may take advantage of existing well-structured logic. However, it would need more semantics knowledge, making the automated patching complex or requiring greater effort from the developers, like Figure 4.16. The other way is to introduce a new variable/expression and carefully maintain it so that its status change can reflect the occurrence of the buggy timing. This is a much simpler and more general approach that does not require extra semantics. Mainly, BFix prefers to introduce a new variable to reduce the semantics requirements. But for certain cases, BFix uses existing variable/expression to generate simple patch instead.\n\n**Introducing a new variable** BFix designs a general patch pattern for this case, which only uses the nature of concurrency bugs without requiring any extra concrete semantics information.\n\nFigure 4.19 and Figure 4.20 show what the patch patterns for bypassing $r$ and $c$. And Figure 4.21 shows what the patch pattern for bypassing $A$.\n\nBFix designs a general patch pattern for this case, which only uses the nature of concurrency bugs without any extra concrete semantics information.\n\nFigure 4.19 and Figure 4.20 show patch patterns for bypassing $R$ and $C$. Figure 4.21 shows the patch pattern for bypassing $A$. \n\n82\nFor each bug report, BFix records the run-time address and thread ID for each buggy operation via our `recorder` function. For AV bugs, BFix bypasses the bypassing-candidate operations only when: (1) \\( P \\), \\( C \\) and \\( R \\) touch the same memory location; (2) \\( P \\) and \\( C \\) are in the same thread, and \\( R \\) is in another thread; (3) they are about to construct the buggy order \\( PRC \\). Similarly, for OV bugs, only when (1) \\( A \\) and \\( B \\) touch the same memory location; (2) \\( A \\) and \\( B \\) are in different threads; (3) \\( B \\) is executed before \\( A \\), BFix bypasses the bypassing-candidate operations. Function `recorder` and `check_happen` maintain a protected map, which uses address information as key. `check_happen` function will return TRUE when the bug is about to happen, otherwise, it will return FALSE. It achieves this by analyzing the recorded sequences, checking whether a remote \\( R \\) exists between another thread’s \\( P \\) and \\( C \\) or whether a thread’s \\( B \\) is before another thread’s \\( A \\). For the conditional pattern, `check_happen` is inserted before the existing conditional expression using the AND operation to connect it with existing conditional expression.\n\nAs mentioned before, bypassing \\( P \\) for AV bugs is not a choice for BFix. Since when \\( P \\) is executed, \\( C \\) and \\( R \\) are not executed, it could be a bug when \\( R \\) is executed before \\( C \\), and could not be when \\( C \\) is executed before \\( R \\). Those are uncertain for BFix. Hence BFix would\nif(!check_happen(pid1,'A',&A)) {\n // check whether it can\n // really construct OV bug\n A\n +recorder(pid1,'A',&A);\n}\n\n+recorder(pid2,'B',&B);\n\nFigure 4.21: Patch pattern for bypassing A (pid is thread ID)\n\nnot try to bypass P for AV bugs.\n\nUsually there is no need to predict address of buggy operations before their execution. However for the conditional pattern, BFix needs to predict memory address in advance, especially when if checking cond_point and buggy operations are in different functions. If prediction is needed, BFix backwardly checks how the address is calculated along the call stack, and records such information until encountering cond_point. Only when the calculation (the way of calculating the base and the offset) is idempotent, BFix copies the calculation (replacing and using the correct variable names) around the existing conditional checking (cond_point). Otherwise, BFix can not guarantee to predict the correct address and fails to generate the bypassing patch.\n\nUsing an existing variable Even when trying to use existing variables, BFix does not want to explore much extra semantics information as that would complicate our design; instead, it only tries to explore the chance of using buggy variable as conditional checking. For AV bugs, we may have chance in read-after-read, read-after-write, and write-after-read cases, since the remote access for the same shared memory is a write operation. The buggy variable itself might also satisfy the property that status change can reflect the occurrence of bug timing. If the bypassing-candidate operation is C, in the correct timing, the value of the buggy variable should be the same in location C and location P; in the bug-triggering timing, this equality is not held because the remote write R happens in between and changes the value of this buggy variable.\n\nHowever, simply checking the equality in location P and location C might introduce new\nbugs. Figure 4.22 shows a make-up example. The patch simply checks whether a’s value is changed or not. If yes, then buggy timing would happen, and it bypasses Line 5 of Thread-1. However, this pattern would introduce extra access for a in Line 4, hence leading to another AV bug triplet.\n\nBFix only uses buggy variables as conditional checking, when (1) the bypassing-candidate operations include C; (2) C and R are protected by the same lock; (3) R is a write access; (4) P and C are in the same function (to avoid inter-procedural copy); (5) if P is a write access, its content should be idempotent (to avoid changing semantics during copy).\n\nFigure 4.23 shows the patch pattern of using an existing variable. BFix would do local copy for P around P, and then compare the local value and the global value of P. This simple patch pattern has higher adoption priority than our general patch pattern, since it is much simpler. BFix would check the chance of applying a simple patch before applying a general patch for a given bug.\n\nDiscussion Without the protection of locks, there would be a small buggy timing window even with the bypassing patch applied. Moreover, our introduced functions recorder and check_happen totally get rid of the lock primitives, hence they could be another bug triplet.\nFortunately, BFix can sometimes take advantage of existing locks to fundamentally fix the reported bug, as demonstrated in Figure 1.4. This happens especially for AV bugs. If $P$, $C$ and $R$ are already protected by the same lock, then our patch can fundamentally fix this bug. BFix checks whether $P$, $C$ and $R$ are protected by the same lock along the call stacks. If they are found to be protected by the same lock, then the generated patch can fundamentally fix the reported bug and BFix reports this information to users. If not, our bypassing patch is still appealing, since it has good readability and can significantly decrease the chance of bug occurrence, leading to good performance, since usually the $P - C$ region is very long and may be crossing several call stacks.\n\n4.5.4 Patch merging\n\nFor two given bug reports, BFix would generate the patch for them separately if applied. BFix would then conduct some simple merging if they are same type of bugs and have one of the following relationships:\n\n1. If two given bugs share same buggy operations, then BFix would only generate one bypassing patch.\n\n2. If two bypassing patches bypass two neighboring operations, and (1) these two to-be-skipped code regions have dominating and post-dominating relation; (2) no other operations exist in between (or those operations in between are not necessary, like log information for a non-log mode program running in MySQL, this is configurable by developers); (3) they share the same memory locations for other corresponding buggy operations, then BFix would generate one conditional checking for those operations instead of two conditional checking for each of them.\n\n3. If two bypassing patches bypass the same operation at the same program location.\n\n7. For simple patch case, only $C$ and $R$ are protected by the same lock is sufficient.\nor they have inclusion relation, and they share the same memory locations for other corresponding buggy operations, BFix would generate only one condition checking for the bigger region.\n\n4. If the bypassing operations of two patches lie in the same existing conditional checking (cond_point), and they share the same memory locations for other corresponding buggy operations, BFix would generate only one condition checking before cond_point.\n\n4.6 Methodology\n\n**Implementation** BFix is implemented using LLVM infrastructure (v3.6.1). All the experiments are conducted on 4-core Intel Core i7-5775C machines with 6MB cache, 8GB memory running 2.6.32, and O4 optimization level.\n\n**Benchmark suit** We have compared manual bypassing patches, the patches generated by BFix, CFix and HFix on 8 real-world bug benchmarks. They are the bugs, whose manual patches are marked as bypassing in HFix [39]. In HFix, there are 14 bugs with bypassing manual patches in total. However, we only conduct experiments on those 8 bugs, because they are well-documented so that we could reproduce them. The remaining bugs were reported around 20 years ago and could not be reproduced based on the descriptions. More importantly, none of those 6 bugs belong to our three common bypassing patterns. Our benchmark suits include server applications (e.g., MySQL database server, Apache HTTPD web server), network applications (e.g., Apache Xerces-C++ XML parser), and desktop application (e.g., Mozilla JavaScript Engine). The sizes of these applications range 50K – 1 million lines of code.\n\n**Setups and metrics** We evaluate the quality of BFix patches by comparing them with manual patches, and the patches generated by the state of the art concurrency-bug fixing techniques, including synchronization-adding tool CFix and synchronization-moving tool HFix. We compare them based on three criterion, correctness, performance and simplicity.\nTo measure the patch correctness, we follow the methodology of previous work [27, 28, 39, 82], and insert sleep into software, so that the corresponding bugs will manifest frequently. We then run each bug-triggering workload with the manual patches or each tool applied for 1000 times.\n\nTo measure the patch performance, we run the original software without any sleeps with the manual patches or each tool applied. We report the average overhead measured during 100 failure-free runs, reflecting the performance during regular execution.\n\nTo measure the patch simplicity, we mainly compare the number of synchronization operations introduced by the manual patches, BFix, CFix and HFix. We also count the lines of code modification at source code level for those patches (Even the patching happens at IR level, in order to compare with the manual patches, we try to convert them and count the lines of code modification at source code level.).\n\n### 4.7 Experimental results\n\nAlthough CFix patches can help eliminate all those 8 benchmarks, they usually have worst performance (around 20% for some of them). HFix patches has great performance, but can not be applied for 4 of them. BFix patches has the best performance and simplicity. As for correctness, BFix can help eliminate 5 of them, for the remaining 3 bugs, BFix can dramatically decrease the failure rates, similar to the manual patches. Unlike CFix patches, BFix patches do not introduce any new synchronizations. In general, BFix patches achieve the best balance among correctness, performance and code readability. Additionally, they have much performance and readability advantages over the patches generated by CFix and HFix.\nTable 4.1\nFailure Rates comparison\n\n<table>\n<thead>\n<tr>\n<th>Root Cause</th>\n<th>Origin Manual</th>\n<th>BF ix</th>\n<th>CF ix</th>\n<th>HF ix</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Mozilla85802</td>\n<td>AV 100% 0% 12% 0% 0%*</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Mozilla72599</td>\n<td>AV 97% 0% 0% 0% 0%*</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Apache21287</td>\n<td>AV 83% 0% 0% 0% 0%</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Apache38793</td>\n<td>AV 86% 12% 10% 0% NA</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Apache21285</td>\n<td>AV 98% 0% 0% 0% NA</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Apache17516</td>\n<td>AV 100% 0% 0% 0% 0%</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>MySQL19437</td>\n<td>AV 71% 0% 0% 0% NA</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Mozilla73761</td>\n<td>AV 91% 8% 9% 0% NA</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nNA: not applicable; *: original HF ix can not move lock/unlock across loops, since they do not want to change the number of times that lock executes. Here we change it to make it can move lock/unlock across loops.\n\n4.7.1 Correctness\n\nTable 4.1 shows the failure rates of the original software and the failure rates when applying manual patches, the patches generated by BF ix, CF ix and HF ix. The sleep s are inserted for bug manifestation.\n\nFor manual bypassing patches, they can help eliminate most of bugs except Apache38793 and Mozilla73761, since for these two bugs, manual patches can not leverage any existing synchronization operations (e.g., lock). Even inserting the conditional checking for bypassing, there is still a time window for bug manifestation, as discussed in chapter 4.5.3. It is similar to BF ix patches. For Mozilla85802, shown in Figure 1.4, the manual patch can even leverage the lock in $P - C$’s caller to prevent from bug occurrence. However, in current BF ix prototype, only when $P$, $C$ and $R$ (or $A$ and $B$) are protected by the same lock, BF ix patches can fundamentally fix the reported bugs. That is why BF ix fails to help eliminate the bug in Mozilla85802. BF ix correctly tells the cases that it can not fundamentally fix to users.\n\nCF ix can help eliminate all bugs, considering its generality design goal. However, as shown in chapter 4.7.2 later, this aggressively sacrifices the performance. CF ix patches have the highest run-time overhead, since the introduced critical regions may include many\nTable 4.2\nPerformance comparison\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Manual</th>\n<th>BFix</th>\n<th>CFix</th>\n<th>HFix</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Mozilla85802</td>\n<td>0.22%</td>\n<td>0.31%</td>\n<td>12.90%</td>\n<td>11.41%</td>\n</tr>\n<tr>\n<td>Mozilla72599</td>\n<td>0.81%</td>\n<td>0.75%</td>\n<td>3.21%</td>\n<td>3.62%</td>\n</tr>\n<tr>\n<td>Apache21287</td>\n<td>0.11%</td>\n<td>0.23%</td>\n<td>0.28%</td>\n<td>0.26%</td>\n</tr>\n<tr>\n<td>Apache38793</td>\n<td>0.88%</td>\n<td>0.94%</td>\n<td>18.95%</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>Apache21285</td>\n<td>0.39%</td>\n<td>0.42%</td>\n<td>14.47%</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>Apache17516</td>\n<td>0.21%</td>\n<td>0.32%</td>\n<td>0.55%</td>\n<td>0.43%</td>\n</tr>\n<tr>\n<td>MySQL19437</td>\n<td>0.91%</td>\n<td>0.90%</td>\n<td>2.81%</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>Mozilla73761</td>\n<td>0.71%</td>\n<td>0.82%</td>\n<td>17.6%</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>Average</td>\n<td>0.47%</td>\n<td>0.57%</td>\n<td>15.3%</td>\n<td>5.92%</td>\n</tr>\n</tbody>\n</table>\n\nNA: not applicable;\n\ntime-consuming structures or operations, like loops, IO, etc.\n\nOriginally HFix can not help 6 out of those 8 bugs, because the synchronization movement in HFix has lots of constraints. Firstly, it would fail to help if it can not find existing synchronizations (locks, thread_join, thread_create) to move around, this happens to Apache38793 and Mozilla73761. Secondly, to avoid complex inter-procedural analysis and keep the original code encapsulation, it can not help move synchronizations across different functions. Hence even having existing locks to move around, HFix can not help for MySQL19437 and Apache21285. Thirdly, HFix would not move synchronizations across loops. However this design only affects the performance without violating correctness, so here we make it possible to move synchronization across loops when there are no other synchronizations along the moving path. After this change, HFix can help fix Aapache38793 and Mozilla73761.\n\nEven not like CFix patches, which can fundamentally fix all those 8 bugs, BFix patches can eliminate most of them, similar to the manual patches and better than HFix. And as shown later, BFix has the best combination of correctness, performance and simplicity.\n\n4.7.2 Performance\n\nTable 4.2 shows the regular-run overheads of applying manual patches, the patches generated by BFix, CFix and HFix.\nFigure 4.24: A patch pattern used by developers\n\nOverall, the manual bypassing patches have the best performance, incurring less than 1% overhead for all benchmarks at run time. It is not surprising, since developers usually have rich semantics knowledge, they can make the best choice, like directly leveraging existing functions/expressions/variables for conditional checking.\n\nBFix patches have slightly worse performance than the manual ones. The overhead mainly comes from address/thread_id recording and determining the bug is about to happen or not in the newly-introduced conditional checking. The overhead for all benchmarks is less than 1% too, similar to the manual patches and much better than CFix and HFix.\n\nFor Mozilla72599 and MySQL19437, the manual patches use the same pattern as Figure 4.24 (For MySQL19437, R is already in a if body.). This patch pattern can help eliminate bug, but it also prevent the original correct interleaving PCR. For BFix, it wants to maximally maintain the original correct interleavings (since they might get benefit of parallelism). BFix only fixes the buggy interleaving without preventing from any original correct interleaving. Hence, BFix adopts the patch patterns as Figure 4.19 for them. And as shown in Table 4.2, for these two bugs, BFix patches have slightly better performance than the manual patches.\n\nAs mentioned before, the goal of CFix is to automatically correct patches for most types of concurrency bugs. It is not doubt that performance is also its concerns. However, the introduced critical regions may contain time-consuming operations. Worse, for AV bugs, if P and C are in different functions, CFix would try to search the call stack to find a common function to create a critical region inside it surrounding P and C, this can lead to much larger critical region when P is far from C. These are the main reasons why CFix has the worst\nTable 4.3\nSimplicity comparison (#Sync: number of new synchronization operations added by the patch; #line: line of code modification; L: lock; U: unlock; S: signal; W: wait; +: add; -: remove; ↑: move)\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Manual</th>\n<th>BFix</th>\n<th>CFix *</th>\n<th>HFix</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>#Sync</td>\n<td>#line</td>\n<td>#Sync</td>\n<td>#line</td>\n</tr>\n<tr>\n<td>Mozilla85802</td>\n<td>0</td>\n<td>+3</td>\n<td>0</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>Mozilla72599</td>\n<td>1L,1U</td>\n<td>+4</td>\n<td>0</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>Apache21287</td>\n<td>0</td>\n<td>+3</td>\n<td>0</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>Apache38793</td>\n<td>0</td>\n<td>+3</td>\n<td>0</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>Apache21285</td>\n<td>0</td>\n<td>+3</td>\n<td>0</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>Apache17516</td>\n<td>0</td>\n<td>+1</td>\n<td>0</td>\n<td>+2</td>\n</tr>\n<tr>\n<td>MySQL19437</td>\n<td>1L,1U</td>\n<td>+3</td>\n<td>0</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>Mozilla73761</td>\n<td>0</td>\n<td>+4</td>\n<td>0</td>\n<td>+3</td>\n</tr>\n</tbody>\n</table>\n\nNA: not applicable; *: For CFix patches, we do not count the line for global lock initialization when counting #line;\n\nperformance, with 15.3% overhead on average for our benchmarks. The patches generated for Mozilla85802 and Mozilla72599 would include loops. For Apache38793, the introduced critical region would contain the 6-step proxy connection. For Apache21285, CFix patch would include the whole life cycle of dynamic object caching and garbage collection would be contained for Mozilla73761.\n\nExcept the benchmarks HFix fails, HFix patches for Mozilla85802 and Mozilla72599 would include existing loops as well. And since HFix would not introduce new synchronizations, its patches usually have better performance than CFix. But as described before, it can not help most of benchmarks given its fixing constraints.\n\n4.7.3 Simplicity\n\nFor the manual patches or the patches generated by BFix, CFix and HFix, we count the newly-introduced synchronization operations and the lines of code modification at source code level 8. Table 4.3 shows the detailed result. Overall, BFix patches are as simple as the manual ones. And they are much more readable than CFix/HFix patches.\n\n8. For the newly-introduced functions, we only count it as 1-line code modification, since they can serve as library call and be dynamically linked.\nThe manual bypassing patches and the patches generated by BFix usually do not introduce new synchronizations. They either leverage the existing locks or simply give a patch which can not fundamentally fix the bugs but dramatically decrease the failure rates. The bypassing manual patches and the patches generated by BFix usually needs 3-4 lines of code modification, including 3-line conditional variables modification for AV bugs (2-line conditional variables modification for OV bugs), and 1-line conditional checking. Usually the bypassing manual patches are different from the patches generated by BFix, since manual patches can greatly utilize the domain knowledge that developers have and hence are a little bit simple, such as Mozilla72599 and MySQL19437. However, they essentially share the same philosophy. Taking Figure 1.4 as an example, both our recorder function in BFix patch and mProcess flag in its manual patch are used to depict the buggy timing, while our check_happen function in BFix patch and mProcess == 0 in its manual patch check the occurrence of buggy timing similarly. Sometimes, the patch generated by BFix is same as the one designed by developers. For Apache 17516, both manual patch and BFix patch adopts the simple patch pattern as Figure 4.23, hence it only needs 2-line code modification.\n\nCFix patches can help eliminate all 8 bugs because of its aggressive usage of synchronizations, as shown in the CFix column in Table 4.3. Usually for AV bug, it needs 1 lock/unlock pair to protect the region between P and C, and another lock/unlock pair to protect C. If there are complex control flows around the buggy snippet, then CFix needs more synchronizations to make sure synchronizations paired during run time, like Apache38793.\n\nFor the HFix patches, they usually need move the existing lock/unlock to extend the critical regions and when it is needed, they need also copy lock/unlock in the related path to guarantee the correctness (for Apache17516 case). For Mozilla85802 and Mozilla72599, since we change the original HFix design a little bit, we need also remove the extra 2-line lock/unlock to avoid the deadlock here.\n\nIn general, BFix patches are simple as the manual patches without introducing new\n4.8 Discussion\n\nAs shown in chapter 4.7, not like CFix, BFix can not fix all benchmarks. Our goal is not to design a new tool that can help fix most concurrency bugs. We try to provide a new fixing strategy to help developers generate high-quality patches, not introducing new bugs with low overhead and great readability. And our bypassing strategy is fundamentally different with other fixing strategies which have been automated, it gets involved with software semantics and does not eliminate the buggy timing. Our tool can complement the existing auto-fixing tools, offering diverse choice to facilitate the fixing process for developers.\n\nEven for the bugs whose patches are about bypassing, BFix can not help automatically fix all of them, due to the complex correctness reasoning, due to the complex correctness reasoning. BFix only instantiates three equivalent semantics patterns, which widely exist (they cover 8 out of 14 bugs, whose manual patches are about bypassing in HFix.) and can help easy correctness reasoning. For the bugs which do not belong to any of these three patterns, BFix fails. Figure 4.25 shows a simplified Mozilla bug which BFix can not help. When layouting text, the Mozilla browser uses mOffset and mLength together to mark the region of useful characters stored in mContent. Without synchronization protection, Thread-1 may read inconsistent value of mOffset and mLength. The patch would bypass the characters which would be displayed in the browser when bug manifests. Since the browser would keep\nflushing and finally the correct content would be displayed for the end users, visually, the effect of this bypassing patch is acceptable. However, it is really hard for the automated tool to reason the correctness for this patch without such domain knowledge. We admit there are also other situations that BFix fails to help. However, we still believe our work is worthwhile and can facilitate the fixing process for developers.\n\nFor big multi-threaded software, it is infeasible to prove the correctness of patched software. Following the methodology of previous work [27, 28, 39, 82], we made our best effort in correctness checking through manual examination and anecdotal patch testing. More importantly, our tool statically determine the bypass-patched program does not introduce new semantics, and the bypassing semantics already exist in the software. This is very crucial for the semantic-related patch proof. We are confident in the correctness of BFix patches because of both the soundness guarantee of BFix and the similarity between BFix patches and manual patches.\n\n4.9 Conclusion\n\nWe have described BFix, a framework for automatically fixing concurrency via bypassing strategy. It can help fix certain concurrency bugs without eliminating the buggy timing, fundamentally different with the existing auto-fixing tools. We have implemented the system and shown BFix can general high-quality patches for certain concurrency bugs, outperforming the state-of-the-art auto-fixing tools CFix and HFix. BFix conducts through static analysis to generate provably correct patches and reach a good balance among correctness, performance, and code readability. Overall, BFix complements the existing auto-fixing tools, offering more fixing choice to help developers fight with concurrency bugs during the late phases of software life cycle.\nCHAPTER 5\n\nCONCLUSION AND FUTURE WORK\n\nConcurrency bugs are difficult to avoid, detect, diagnose, and fix. Even with lots of in-house testing, some concurrency bugs can still slip into production run, threatening software availability and reliability. In this dissertation, we propose two approaches to help developers fight with concurrency bugs during the late phases of software life cycle.\n\nFor the concurrency bugs which fail to be detected during in-house testing, we present BugTM that leverages HTM available on commodity machines to help automatically recover concurrency-bug failures during production runs. BugTM can recover failures caused by all major types of concurrency bugs and incurs very low overhead. BugTM does not require any prior knowledge about concurrency bugs in a program and guarantees not to introduce any new bugs. We believe BugTM improves the state of the art of failure recovery, presents novel ways of using HTM techniques, and provides a practical and easily deployable solution to improve the availability of multi-threaded systems with little cost.\n\nBugTM can not recover from all concurrency bugs. In the future, firstly, we hope techniques such as xCall [72] can be applied into BugTM to further improve its recovery capability. Secondly, we hope to deploy BugTM into a commercial system to see its challenges and opportunities in a real commercial environment, since availability and reliability are very important for commercial systems, and they can directly affect thousands of end users. Thirdly, it would be very interesting to deploy BugTM into distributed systems. We know it would be much more challenging, but it is still worthwhile.\n\nFor the concurrency bugs which can are detected during in-house testing or those discovered by the diagnosis aspect of BugTM, we present BFix, which is the first automatic tool facilitating to apply bypassing strategy for concurrency bug fixing. Unlike most existing tools, it does not introduce new synchronizations. The BFix patches are performance-friendly and as simple as the patches generated by developers. BFix complements the existing tools,\nproviding more choice to help developers generate high quality patches.\n\nIn this direction, since our current three common bypassing patterns can still fail to cover lots of cases, in the future, we hope explore more patterns for bypassing and give a more general solution for correctness reasoning. Also, since in distributed systems, there are lots of code-bypassing scenario, such as when keeping trying to connect with master if slave encounters bad machine state, current retrial including the subsequent non-executed code region would be bypassed. And the system would just keep retrying without violating the correctness. If the buggy operations exist in such code region, it seems that they can be bypassed since some compensations would be done later. We would like to explore the chance of applying our bypassing idea for the concurrency bugs into distributed systems in the future. Similarly, for concurrency bugs in fast path and slow paths [26], if we bypass all operations in fast path/slow path and force program to execute the other path, it can guarantee the correctness and help fix the bug. This is also an interesting direction.\n\nIn conclusion, both of our solutions try to tackle detected or undetected concurrency bugs. They can greatly improve software availability and reliability during the late phases of software life cycle. Before final patch is released, BugTM solution can serve as tentative patch for availability purpose. The diagnosis aspect of BugTM can complement bug detection tools, offering input for BFix and helping generate correct patch. Together with existing solutions, they can provide effective and efficient multi-phase protections for multi-threaded programs. Moreover, their performance-friendliness and simplicity make them attractive to be adopted by developers.\nREFERENCES\n\n\n[16] Shuguang Feng, Shantanu Gupta, Amin Ansari, Scott Mahlke, and David August. Encore: Low-cost, fine-grained transient fault recovery. In *MICRO ’11*.\n\n\n100\n\n\n"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":1,"numItemsPerPage":100,"numTotalItems":22671,"offset":100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NDMzMjM1NywianRpIjoiYTI2MjA3NDMtMjZlZC00YTg5LWFhMWUtODgyNGJkMjE2ZDAxIiwic3ViIjoiL2RhdGFzZXRzL21saW5tZy9kb2xtYTNfbG9uZ21pbm9fbWl4LTEwMEItMTEyNS1zYWZlLXRvLWxvYWQiLCJleHAiOjE3ODQzMzU5NTcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.2sXoANpAgVwz4jYFc_xoojTMcCeII-CB1e5Na3O7v36lB5gm3DeIV4l0mmwy9JcKIq-Sd27zdZEpqTaTKqHCBA","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 |
|---|---|
42be513b93691eca09dbd58c4549f14c3b811188 | Microsoft
Dynamics NAV 2015 Financials Certification
Courseware
Version 1.0
Introduction to Microsoft Dynamics NAV 2015
User Interface
Source: Simplified UX - White Paper - Brian Nielsen (Principal Program Manager), Nikola Kukrika (Software Engineer), Jacob Winther (Senior UX Designer), July 2014, Microsoft
1. Manda... |
14acb7ab07889311b40dedad44a3c69308383879 | SAS® Intelligence and Investigation Management 1.1 on Linux: Deployment Guide
## Contents
### Chapter 1 / Introduction
- About This Guide ........................................... 1
- How Deployment Works .................................. 2
- Deployment Examples and Guidance .................. 2
- Contact SAS Techn... |
459eca8297ca38d7970030802a11e821a469d8dc | Microprocessor Debug Interface (MDI) Specification
Document Number: MD00412
Revision 02.41
September 22, 2009
MIPS Technologies, Inc.
955 East Arques Avenue
Sunnyvale, CA 94085-4521
Copyright © 2001-2009 MIPS Technologies Inc. All rights reserved.
Table of Contents
Chapter 1 Overview .................................. |
340a002a7288a011f7aedd96767f30dd2aaae052 | Table of Contents
Chapter 1 — Overview of the SAS Deployment Wizard, the SAS Deployment Manager, and the User’s Guide ............................................................. 1
What is the SAS Deployment Wizard? ............................................................. 1
What is the SAS Deployment Manager? .... |
9d14ec84ff7e22f5a1e350e292c2e97d4ecccc7e | Legal Notices
The software described in this document is furnished under license, and may be used or copied only in accordance with the terms of such license and with the inclusion of the copyright notice shown on this page. Neither the software, this document, nor any copies thereof may be provided to, or otherwise m... |
a99b8bf747b8a4c7beb0f274f06262f39edb2e2f | Liveness in Timed and Untimed Systems*
Roberto Segala† Rainer Gawlick‡ Jørgen Søgaard-Andersen§ Nancy Lynch¶
Abstract
When proving the correctness of algorithms in distributed systems, one generally considers safety conditions and liveness conditions. The Input/Output (I/O) automaton model and its timed version h... |
dd2e30eb0d44a64d6365c43967af8cb92bbc4a41 | A Formal Language for the Specification and Verification of Synchronous and Asynchronous Circuits
David M. Russinoff
COMPUTATIONAL LOGIC, INC.
Austin, Texas
Contract NAS1-18878
September 1993
A Formal Language
for the Specification and Verification
of Synchronous and Asynchronous Circuits
David M. Russinoff ... |
17ecce5ecf4e200657499c957a93e8e38aaf6235 | On CD-systems of stateless deterministic R-automata with window size one
Benedek Nagya, Friedrich Otto
Abstract
Here we study cooperating distributed systems (CD-systems) of restarting automata that are very restricted: they are deterministic, they cannot rewrite, but only delete symbols, they restart immediately af... |
8d1f16f550c1ad1ee93b5016ec1b7cce653088f3 | VSI Alliance™
Specification for VC/SoC Functional Verification
Version 1.0
(VER 2 1.0)
Functional Verification
Development Working Group
Released March 2004
**Dedication to Public Domain**
VSI Alliance hereby dedicates all copyright that VSI Alliance holds in this ______ (the "Work") to the public domain, free of ... |
ffcab7295061fbe20c52444dfdda7143d47eb7cb | Extending a real-time operating system with a mechanism for criticality-level changes
Citation for published version (APA):
Document status and date:
Published: 01/01/2015
Document Version:
Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)
Please check the document ver... |
6ab77625b4619c8d2f7f6a95dd6dcfd5e4c7b598 | <table>
<thead>
<tr>
<th>Chapter</th>
<th>Topic</th>
<th>Page</th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
<td>OAuth Authentication</td>
<td>35</td>
</tr>
<tr>
<td></td>
<td>SAML Single Sign-On for Canvas Apps</td>
<td>39</td>
</tr>
<tr>
<td></td>
<td>Getting Context in Your Canvas App</td>
<td>39</td>
</tr>
<tr>
<td></t... |
b762f2ec32c8e55c924754db8f1f54ee15b1890a | Lecture Notes on
Semantics of
Programming Languages
for Part IB of the Computer Science Tripos
Andrew M. Pitts
University of Cambridge
Computer Laboratory
© A. M. Pitts, 1997-2002
# Contents
Learning Guide .......................... ii
1 Introduction .......................... 1
1.1 Operational semantics ........ |
327c932110f8490760c2b03820f22e7a972c94b2 | Contents
Copyright ......................................................................................................................................................... 4
License ........................................................................................................................................... |
85a6025015365918711feda8740aaf318ead306e | NOTE
Progress is an ongoing commitment at Giddings & Lewis. We continually strive to offer the most advanced products in the industry; therefore, information in this document is subject to change without notice. The illustrations and specifications are not binding in detail. Giddings & Lewis shall not be liable for an... |
1d24665cc7b7931e4155bdf3dafbf88c18c33cdd | TOKENPASSER
A PETRI NET SPECIFICATION TOOL
NAGW-1333
by
Michael Mittmann
Rensselaer Polytechnic Institute
Electrical, Computer, and Systems Engineering
Troy, New York 12180-3590
January 1991
CIRSSE REPORT #81
CONTENTS
LIST OF FIGURES ................................ v
ACKNOWLEDGMENT ................................ |
698d534959a3911fda2d31da8f55e8f9a39ce470 | 1 Syntax_Tools User's Guide
Syntax_Tools contains modules for handling abstract Erlang syntax trees, in a way that is compatible with the "parse trees" of the STDLIB module erl_parse, together with utilities for reading source files in unusual ways and pretty-printing syntax trees. Also included is an amazing module m... |
a7194e4c4f0cfb6b80801fdc0aa32e08665e8454 | Join/Leave Protocol for Structured Peer-to-Peer Networks
Master Thesis
Group B1-215e - 10th semester
February 1st - June 10th, 2003
SYNOPSIS:
The aim of this project is to implement and test a Peer-to-Peer communication protocol, whose purpose is to assure a basic connectivity in the structured Peer-to-Peer network... |
378db5f1dc7ec90c133deff8a776bd3cbdd3a5b2 | Reasoning about Recursive Probabilistic Programs
Federico Olmedo Benjamin Lucien Kaminski Joost-Pieter Katoen Christoph Matheja
RWTH Aachen University, Germany
{federico.olmedo, benjamin.kaminski, katoen, matheja}@cs.rwth-aachen.de
Abstract
This paper presents a wp–style calculus for obtaining expectations on the ... |
0ad4653bab074e02e95a57ebd12f46469454322f | # Table of Contents
## Introduction
- In This Introduction ............................................. 3
- About This Manual ............................................. 3
- Types of Users ............................................. 3
- Software Dependencies .................................. 4
- Assumption... |
a5046ab0f7ac8b978795f5736067314619d771d9 | # Table of Contents
Preface ................................................................................................................. 1
Naming .............................................................................................................. 1
Hazeltcast IMDG ........................................ |
b06cc4bad1a3d925a6b3c2846aae9dd5fafe9c33 | # Table of Contents
1. About This Document ................................................................. 4
1.1. Intended Audience ............................................................... 4
1.2. New and Changed Information ................................................ 4
1.3. Notation Conve... |
3f18cd8533cedb4560fb9ae512da83d5026ef4d7 | MySQL Tutorial
Abstract
This is the MySQL Tutorial from the MySQL 5.1 Reference Manual.
For legal information, see the Legal Notices.
For help with using MySQL, please visit either the MySQL Forums or MySQL Mailing Lists, where you can discuss your issues with other MySQL users.
For additional documentation on MySQ... |
bacd2ce1b148db0366456c706fe55910228fe2da | ANALYSIS ON A RELEASE HISTORY DATABASE TO ASSIST MANAGEMENT OF THE SOFTWARE MAINTENANCE
Mohammad Saeed Bohlooli
A Thesis
in
The Department
of
Computer Science and Software Engineering
Presented in Partial Fulfillment of the Requirement
For the Degree of Applied Science in Software Engineering
Concordia University
Mo... |
4af951be984a1bb933932e848c23778f08a1b735 | Copyright
Copyright © 1991-1996 Exemplar Logic, Inc.
Trademarks
Exemplar Logic® is a registered trademark of Exemplar Logic, Inc.
Galileo™, Leonardo™, Exemplar VHDL Discovery Kit™ and MODGen™ are trademarks of Exemplar Logic, Inc.
V-System/VHDL™ and V-System/Verilog™ are trademarks of Model Technology.
Verilog® and ... |
b21f842787ce0435cbf33e8d1aa3d4d1ba79e5df | Short Contents
Introduction ................................................................. 1
1 Enabling OpenMP ......................................................... 3
2 OpenMP Runtime Library Routines ................................. 5
3 OpenMP Environment Variables .................................... 19
4 En... |
23138a1d66191048a0a0ed349127480a3e01122c | Parameterized safety verification of round-based shared-memory systems
Nathalie Bertrand, Nicolas Markey, Ocan Sankur, Nicolas Waldburger
To cite this version:
Nathalie Bertrand, Nicolas Markey, Ocan Sankur, Nicolas Waldburger. Parameterized safety verification of round-based shared-memory systems. ICALP 2022 - Intern... |
eecbe142a63e24e2a1001a26152864f26da68e04 | July 2015
This document describes how to design, configure, and manage WebLogic Server 10.3.6 environments. It is a resource for system administrators and operators responsible for implementing a WebLogic Server 10.3.6 installation.
Contents
Preface ........................................................................ |
6ff75d8008a434917753eeafd0c2d44954ef796d | Working With Oracle® Solaris 11.2
Directory and Naming Services: LDAP
This 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, y... |
72e45896a681aa9d78ed42e7d67fb22c2abb5ffc | FORTRAN ASSEMBLY PROGRAM (FAP) for the IBM 709/7090
The original FORTRAN Assembly Program was conceived by David E. Ferguson and coded by Mr. Ferguson and Donald P. Moore at the Western Data Processing Center, University of California at Los Angeles. Several features present in this version of FAP were added by Mr. Mo... |
0e6d4d73023e356e0b716acf8359255e889eca8d | RETRACTABILITY, GAMES AND ORCHESTRATORS FOR SESSION CONTRACTS
FRANCO BARBANERA AND UGO DE’ LIGUORO
Dipartimento di Matematica e Informatica, University of Catania
e-mail address: barba@dmi.unict.it
Dipartimento di Informatica, University of Torino
e-mail address: ugo.deliguoro@unito.it
Abstract. Session contracts i... |
cea40f56c6c407fdc7a8750c64b62e123b43d961 | Installation and Customization for CMS
Release 6
Installation and Customization for CMS
Release 6
Note!
Before using this information and the product it supports, be sure to read the general information under "Notices" on page iv.
Sixth Edition (November 1993)
This edition replaces and makes obsolete the previous ... |
9b4dba1dd4af67145e26bc278429eeda6fea016d | GT 5.2.3 GRAM5: Developer's Guide
Introduction
This guide is intended to help a developer interact with GRAM5. It includes sections on implementing clients in C and implementing a Local Resource Manager interface, as well as an overview of concepts and APIs used to interact with GRAM.
Table of Contents
I. Introducti... |
b0cc1049fb96df90ae95034b0045385cf77b9062 | COMPILING A SYNCHRONOUS PROGRAMMING LANGUAGE
INTO FIELD PROGRAMMABLE GATE ARRAYS
CENTRE FOR NEWFOUNDLAND STUDIES
TOTAL OF 10 PAGES ONLY
MAY BE XEROXED
(Without Author's Permission)
YING SHEN
To my parents and my sisters
Abstract
This thesis shows how to compile a program expressed by a novel hardware description l... |
700048a8275bdf5af4c6f7f9a18feedf132ab5f8 | # Table of Contents
1 **Introducing Fluid Effects** ................................................. 11
About
Fluids .............................................................................. 11
Introducing Fluid Effects .................................................. 11
Fluid Effects... |
3c6cdc7688589d0de540171ad8ac5b1889616d0c | Certain open source or other third-party software and data components are integrated and/or redistributed with various releases of the Qlik NPrinting family of software. Such third-party components include terms and conditions, such as attribution and liability disclaimers (collectively "Third Party Disclosures") for w... |
0893a746945d7e905c6528ae612b0f9b34a4387f | A Typed Slicing Compilation of the Polymorphic RPC Calculus
Citation for published version:
Digital Object Identifier (DOI):
10.1145/3479394.3479406
Link:
Link to publication record in Edinburgh Research Explorer
Document Version:
Peer reviewed version
Published In:
General rights
Copyright for the publications m... |
7ac257cb264bafbd0c95fe39f30b023169180939 | Intersection Type Assignment Systems
(Theoretical Computer Science, 151(2):385-435, 1995)
Steffen van Bakel
Afdeling Informatica, Universiteit Nijmegen, Toernooiveld 1, 6525 ED Nijmegen, Nederland
steffen@cs.kun.nl
Abstract
This paper gives an overview of intersection type assignment for the Lambda Calculus, as well ... |
6beed0d6b6e4466a3e1ae2059ce27c5c82eb511f | Quick Start Guide
Replication Server® Options
15.2
[ Linux, Microsoft Windows, and UNIX ]
# Contents
## About This Book ............................................................................................................................ v
### CHAPTER 1 Setting Up Replication for Microsoft SQL Server .......... |
f224e3994f93717dbd8ec6f50104ee79a9d146a2 |
Jamal Mustafa Al-Tuwaijari
Newcastle University
Newcastle upon Tyne, UK.
A thesis submitted for the degree of
Doctor of Philosophy
April, 2013
To My Loving Parents and Family
Abstract
Business processes are the backbone of organisations used to automate and increase the efficiency and effectiveness of their servic... |
a73ad8e47043468edd7e1053d847c2aa805259fc | GNU Offloading and Multi Processing Runtime Library
The GNU OpenMP and OpenACC Implementation
# Short Contents
<table>
<thead>
<tr>
<th>Section</th>
<th>Page</th>
</tr>
</thead>
<tbody>
<tr>
<td>Introduction</td>
<td>1</td>
</tr>
<tr>
<td>1. Enabling OpenMP</td>
<td>3</td>
</tr>
<tr>
<td>2. OpenMP Runtime Library Rou... |
b9a23d868cc2c950ec7bdf6a313d60c1e76a91e1 | Abstract
Two identical or similar code fragments form a clone pair. Previous studies have identified cloning as a risky practice. Therefore, a developer needs to be aware of any clone pairs so as to properly propagate any changes between clones. A clone pair experiences many changes during the creation and maintenance... |
90f948a37685ba662109a32d9c337d9c5c4ac763 | Published by the Free Software Foundation
51 Franklin Street, Fifth Floor
Boston, MA 02110-1301, USA
Copyright © 2006-2022 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version publish... |
1384fc189d91e962df367943a3b98098004e6a3e | # Contents
<table>
<thead>
<tr>
<th>Section</th>
<th>Page</th>
</tr>
</thead>
<tbody>
<tr>
<td>Copyright</td>
<td>4</td>
</tr>
<tr>
<td>License</td>
<td>5</td>
</tr>
<tr>
<td>About this guide</td>
<td>9</td>
</tr>
<tr>
<td>Purpose of this guide</td>
<td>9</td>
</tr>
<tr>
<td>Audience</td>
<td>9</td>
</tr>
<tr>
<td>How... |
e6d57befbe9b1268e65a4de06e39d65201e33e34 | SPF: SECURITY PERFORMANCE FLEXIBILITY FRAMEWORK FOR TRUSTED OPERATING SYSTEMS
BY
ALBERT LIMING CHU
B.S., University of Illinois at Urbana-Champaign, 2001
THESIS
Submitted in partial fulfillment of the requirements for the degree of Master of Science in Computer Science in the Graduate College of the University of ... |
2df4b77f844eff0dc652c18bc02e896b47588708 | The OpenGL Utility Toolkit (GLUT) Programming Interface
API Version 3
Mark J. Kilgard
Silicon Graphics, Inc.
February 23, 1996
CONTENTS
Contents
1 Introduction .......................... 1
1.1 Background ......................................... 1
1.2 Design Philosophy .......................... 2
1.3 API... |
ca066d45cb9f8507485fdad1d45f4ee37f88767d | OCaml modules: formalization, insights and improvements
Clément Blaudeau
To cite this version:
Clément Blaudeau. OCaml modules: formalization, insights and improvements: Bringing the existential types into a generative subset. Computer Science [cs]. 2021. hal-03526068
HAL Id: hal-03526068
https://inria.hal.science/ha... |
6fe29b89bcf167f108456c7db53158c097370aa5 | Package ‘rliger’
April 5, 2024
Version 2.0.1
Date 2024-04-04
Type Package
Title Linked Inference of Genomic Experimental Relationships
Description
Author Joshua Welch [aut],
Yichen Wang [aut, cre],
Chao Gao [aut],
Jialin Liu [aut],
Joshua Sodicoff [aut, ctb],
Velina Kozareva [aut, ctb],
Evan Macosko [aut, ctb],
Paul... |
36fc254bc2102bcdc47add7fe6217ba8b0aa599e | May 2015
This document explains how to configure, customize, and run the Oracle GoldenGate Adapters to produce flat files, capture JMS messages and deliver them as an Oracle GoldenGate trail, or read a trail and deliver transactions to a messaging system.
Contents
Preface ................................................. |
60ce57505b1da32a179f9151d321269900e71610 | Deploying and configuring single-node storage in Red Hat Enterprise Linux 8
Abstract
This documentation collection provides instructions on how to effectively manage storage devices in Red Hat Enterprise Linux 8.
# Table of Contents
PROVIDING FEEDBACK ON RED HAT DOCUMENTATION ............................................ |
c0fa6557ebdb3c0cf6e80406bd8414259a8e4a9e | THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR ANY PARTICULAR PURPOSE, OR ANY WARRANTY OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE. Except for a limited copyright license to copy this specification for inte... |
20cbc0bb92f0c607a0b327ba8cb50c7dd14c921e | Legal Disclaimer
Copyright 2018-2023 Intel Corporation.
This software and the related documents are Intel copyrighted materials, and your use of them is governed by the express license under which they were provided to you ("License"). Unless the License provides otherwise, you may not use, modify, copy, publish, dis... |
3d116692f4aed77ae81b053ade98d3161c3cf108 | Package ‘rmarkdown’
September 14, 2021
Type Package
Title Dynamic Documents for R
Version 2.11
Maintainer Yihui Xie <xie@yihui.name>
Description Convert R Markdown documents into a variety of formats.
Depends R (>= 3.0)
Imports tools, utils, knitr (>= 1.22), yaml (>= 2.1.19), htmltools (>= 0.3.5), evaluate (>= 0.13),... |
0092c5f3f5fd0164fcbb8bc929e8749e22c28250 | Experimental study of performance of minimum spanning tree algorithms
Alec Berenbaum
Follow this and additional works at: http://scholarworks.rit.edu/theses
Recommended Citation
Rochester Institute of Technology
Department of Computer Science
Experimental Study of
Performance of Minimum Spanning Tree Algorithms
by... |
b7bf42a2db1e5d059726f8298055e7a9e99421be | Towards Formalising Erlang Failure and Failure Detection
Audrianne Farrugia
Supervisor: Dr. Adrian Francalanza
Faculty of ICT
University of Malta
May 2011
Submitted in partial fulfillment of the requirements for the degree of B.Sc. I.C.T. (Hons.)
Faculty of ICT
Declaration
I, the undersigned, declare that the d... |
f75f4a27369f154a9321f2bd807da12c66ef168e | Apache Wink Developer Guide
Apache Wink 1.0
Apache Wink is a complete Java based solution for implementing and consuming REST based Web Services. The goal of the Apache Wink framework is to provide a reusable and extendable set of classes and interfaces that will serve as a foundation on which a developer can efficie... |
2009e8e2772dcdb40ff6a98aab9da8caefde7833 | Package ‘rtables’
May 25, 2023
Title Reporting Tables
Version 0.6.1
Date 2023-05-04
Description Reporting tables often have structure that goes beyond simple rectangular data. The ‘rtables’ package provides a framework for declaring complex multi-level tabulations and then applying them to data. This framework models... |
bee829a94f389cd972c3d26f8ddda8f5dcae357a | CONFLICT RESOLUTION AND OPERATOR PRIORITIES
IN EXTENDED BNF
RESEARCH THESIS
SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS
FOR THE DEGREE OF
MASTER OF SCIENCE IN COMPUTER SCIENCE
ANNA BEKKERMAN
SUBMITTED TO THE SENATE OF THE TECHNION - ISRAEL INSTITUTE OF TECHNOLOGY
TAMUZ, 5764 HAIFA JULY, 2004
ACKNOWLEDGMEN... |
d58079d12a10b5fff78745974efa8547bea87174 | Abstract
This document provides information on how to use Service Mesh in OpenShift Container Platform
Table of Contents
CHAPTER 1. SERVICE MESH RELEASE NOTES .................................................. 6
1.1. RED HAT OPENS SHIFT SERVICE MESH OVERVIEW .................. 6
1.2. GETTING SUPPORT .................... |
23fcbfdd119c8233160fd766f94bfbba85b7cf29 | Red Hat Fuse 7.8
Apache CXF Security Guide
Protecting your services and their consumers
Protecting your services and their consumers
Abstract
This guide describes how to use the Apache CXF security features.
# Table of Contents
## CHAPTER 1. SECURITY FOR HTTP-COMPATIBLE BINDINGS
- OVERVIEW ............................ |
2cae77d86c7a7b6fee3ad59050422b0420811ee2 | ## Contents
1 Introduction .................................................................................................................. 1-1
1.1 Objectives of the Runtime Architecture .............................................................. 1-1
1.2 About the Conventions ................................ |
51c6204e5fb648a42030e29ccbe018d33a575ddf | Package ‘iSEE’
May 8, 2024
Title Interactive SummarizedExperiment Explorer
Version 2.16.0
Date 2024-04-04
Description Create an interactive Shiny-based graphical user interface for exploring data stored in SummarizedExperiment objects, including row- and column-level metadata. The interface supports transmission ... |
ae732d96c3e411d4763105927728e4d47d0df155 | PM-1 3½" x 4" PHOTOGRAPHIC MICROCOPY TARGET
NBS 1010a ANSI/ISO #2 EQUIVALENT
1.0 1.25 2.5
1.1 1.4 2.2
1.25 1.6 2.0
PRECISION™ RESOLUTION TARGETS
POWERS PHOTOGRAPHIC TESTING SINCE 1912
MICROD
NOTICE
The quality of this microform is heavily dependent upon the quality of the original thesis submitted for microfi... |
d11b827aaed16cb3c66bd08843b0f14fdf0a96e8 | Oracle Berkeley DB Java Edition
Getting Started with Berkeley DB Java Edition
Release 3.2
Legal Notice
This documentation is distributed under an open source license. You may review the terms of this license at: http://www.oracle.com/technology/software/products/berkeley-db/htdocs/jeoslicense.html
Oracle, Berkeley ... |
d4e70d137aba07b642df3c3c3424bcbfa6f89edb | GXP2130/2135/2140/2160/2170 Firmware Release Notes
Table of Content
Table of Content .................................................................................................................. 1
FIRMWARE VERSION 1.0.11.16 ........................................................................................... |
a0399b2ddcda6e5562c1a6c62895fc9d999b9388 | University of Southern Queensland
Faculty of Engineering and Surveying
Centreline Tools Upgrade
A dissertation submitted by
Robert William Thompson
in fulfilment of the requirements for
Courses ENG4111 and 4112 Research Project
towards the degree of
Graduate Diploma of Geomatic Studies (Geographic Information Sy... |
6a0bae0cb878dd67526ab8950d57f6e228492ca0 | Legal Notice
THIS DOCUMENT AND THE SOFTWARE DESCRIBED IN THIS DOCUMENT ARE FURNISHED UNDER AND ARE SUBJECT TO THE TERMS OF A LICENSE AGREEMENT OR A NON-DISCLOSURE AGREEMENT, EXCEPT AS EXPRESSLY SET FORTH IN SUCH LICENSE AGREEMENT OR NON-DISCLOSURE AGREEMENT. NETIQ CORPORATION PROVIDES THIS DOCUMENT AND THE SOFTWARE DE... |
ab83e31e67d5c38044b8cef4cb450d9faf879d3a | Master’s Thesis
Gtext
A Language Workbench based on GLL and Term Rewriting
Ali Afroozeh
August 24, 2012
Supervisor:
Prof. dr. Mark van den Brand
I dedicate this work to my parents, for their encouragement and support at every step during my Master’s studies.
Abstract
One of the main difficulties in developing doma... |
74ccdcfccbc5681ee93de5d9f6b381dce82a8a3e | Joel is managing a project. The project is about three fourths done when the site engineer reports that due to inherent complexities in a certain task the deliverables would get delayed. This would involve additional analysis and then implementation. He requests that this new work that was not envisioned earlier be add... |
479a01a683fb3b8b03e8947d020fdc3746db407e | Abstract. We define a procedure for canonicalising SPARQL 1.1 queries. Specifically, given two input queries that return the same solutions modulo variable names over any RDF graph (which we call congruent queries), the canonicalisation procedure aims to rewrite both input queries to a syntactically canonical query tha... |
b49f7ca5dc055a4791e6deb741ec51e00cce4a7c | Predicting User Behavior over the Web
Amal Adnan Al Safadi
Master of Science in Information Technology
Faculty of Informatics
British University in Dubai
2010
Declaration
I declare that this thesis was composed by myself and that the work contained therein is my own, except where explicitly stated otherwise in the t... |
7156da5bade489480700d4951fe0b93b1e26039b | Algorithmic Analysis of Array-Accessing Programs\textsuperscript{1,2}
RAJEEV ALUR
University of Pennsylvania
PAVOL ČERNÝ
IST Austria
and
SCOTT WEINSTEIN
University of Pennsylvania
For programs whose data variables range over boolean or finite domains, program verification is decidable, and this forms the basis of ... |
9cf19bee4ec5b040610980acd236e120cea439a9 | Contents
1. DOCUMENT OVERVIEW
2. DIAGRAM ELEMENTS
2.1 Graphs and their Contents
2.2 Drawing paths
2.3 Invisible Hyperlinks And The Role Of Tools
2.4 Background information
2.5 String
2.6 Name
2.7 Label
2.8 Keywords
2.9 Expression
2.10 Note
2.11 Type-Instance Co... |
5c0c78f5d586c714c10563097ce84c24bc17a810 | Whole Team Thinking and Success Factors in Large Scale Agile Development
An Exploratory Case Study
Tina Christin Syversen
Master of Science in Computer Science
Submission date: May 2016
Supervisor: Torgeir Dingsøyr, IDI
Norwegian University of Science and Technology
Department of Computer and Information Science
Abs... |
e5717a5e3c7e216d2b4fcbe357a35ca13cfdc9d2 | # Introduction
1.1 Security Considerations ........................................... 8
1.2 Starting the xrootd Daemon .................................... 9
1.2.1 Multiple Instances and Automatic Fencing .................. 15
1.2.2 Passing Plug-In Command Line Arguments ................ 16
1.2.3 Log File Plug-In... |
ea49b90a449f5a8b30c3b0ae51670a355f09e92e | Master Thesis
Distributed Optimization for Non-Strongly Convex Regularizers
Author(s):
Forte, Simone
Publication Date:
2015
Permanent Link:
https://doi.org/10.3929/ethz-a-010585230
Rights / License:
In Copyright - Non-Commercial Use Permitted
Distributed Optimization for Non-Strongly Convex Regularizers
Master Th... |
a55428ff03236e15e0ef2037c961f080b3404cbb | Policy Merger System for P3P
In a
Cloud Aggregation Platform
Olumuyiwa Olurin
Thesis submitted to the
School of Electrical Engineering and Computer Science
In Partial Fulfillment of
The requirements for the degree of
Master of Applied Science,
Electrical and Computer Engineering
Under the auspices of the
Institute ... |
2b6da381fa9002112aa8fbe8b9885e288c8607e0 | Network of Excellence
Deliverable D2.4
Second Release of the Method and Tool Evaluation
<table>
<thead>
<tr>
<th>Deliverable Number</th>
<th>D2.4</th>
</tr>
</thead>
<tbody>
<tr>
<td>Title of Deliverable</td>
<td>Second Release of the Method and Tool Evaluation</td>
</tr>
<tr>
<td>Nature of Deliverable</td>
<td>R</td... |
b47e2ac3b2a9e58c0b47f785f237779fe4352431 | Autonomous Service Execution Driven by Service-Level Agreements
André Lage Freitas
To cite this version:
HAL Id: tel-00715375
https://tel.archives-ouvertes.fr/tel-00715375
Submitted on 11 Jul 2012
HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whet... |
055960846489e4b1970b91323bea9ba416f844f8 | How to Contact The MathWorks
www.mathworks.com Web
comp.soft-sys.matlab Newsgroup
www.mathworks.com/contact_TS.html Technical Support
@
suggest@mathworks.com Product enhancement suggestions
bugs@mathworks.com Bug reports
doc@mathworks.com Documentation error reports
service@mathworks.com Order status, license renewal... |
7482d31892ccfe529a15e3fc63a842d7dae44e6a | Visual GUI Testing in Practice: Challenges, Problems and Limitations
Emil Alégroth · Robert Feldt · Lisa Ryrholm
Received: date / Accepted: date
Abstract In today's software development industry, high-level tests such as Graphical User Interface (GUI) based system and acceptance tests are mostly performed with manua... |
cedb11fb0a61e58d97a58d86db424240c3278e8a | Integration of parametric and “ad hoc” second order polymorphism in a calculus with subtyping
Giuseppe Castagna
Keywords: type theory, typed foundation of object-oriented programming, second order λ-calculus, bounded polymorphism.
Abstract. In this paper we define an extension of $F_≤$ [CG92] to which we add functi... |
8452d648bc469dd8f213220d17a9109e362b77a3 | DESIGN FOR DEPENDABILITY: A SIMULATION-BASED APPROACH
Kumar K. Goswami
Coordinated Science Laboratory
College of Engineering
UNIVERSITY OF ILLINOIS AT URBANA-CHAMPAIGN
Approved for Public Release. Distribution Unlimited.
This research addresses issues in simulation-based system level dependability analysis of fault-... |
80823481a5ade3f47c783777575866921cfff187 | Building Efficient Distributed Systems: A Domain-Specific Language Based Approach
Laurent Réveillère
To cite this version:
HAL Id: tel-00814406
https://tel.archives-ouvertes.fr/tel-00814406
Submitted on 17 Apr 2013
HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific resear... |
834f15f63b2a6b3d138e975f50bc85cd96f615eb | Notice
Hewlett-Packard makes no warranty of any kind with regard to this material, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. Hewlett-Packard shall not be liable for errors contained herein or for incidental or consequential damages in connection with... |
defbf3102ac78e3625535805378c318f56d75d8b | A Framework For Security-Oriented Distributed Programming
submitted by
Manuel Reinert
on May, 9th, 2012
Supervisor
Dr. Matteo Maffei
Advisor
Kim Pecina
Reviewers
Dr. Matteo Maffei
Prof. Dr. Michael Backes
Eidesstattliche Erklärung
Ich erkläre hiermit an Eides statt, dass ich die vorliegende Arbeit selbstständig ... |
5c7334fc29fa063dd7986e883bd840cfcab8d4be | Notice to Customers
All documentation becomes dated and this manual is no exception. Microchip tools and documentation are constantly evolving to meet customer needs, so some actual dialogs and/or tool descriptions can differ from those in this document. Please refer to our web site (https://www.microchip.com) to obta... |
36c524c66732d9fd450c6cee54859395a60c77e3 | Putting Logic-Based Distributed Systems on Stable Grounds
Tom J. Ameloot*, Jan Van den Bussche
Hasselt University & transnational University of Limburg
William R. Marczak
University of California, Berkeley
Peter Alvaro
University of California, Santa Cruz
Joseph M. Hellerstein
University of California, Berkeley
su... |
b87304d4789b0fd97de2fb8d608d53117ddbf816 | Permission is hereby given to modify or use, but not for profit, any or all of this program provided that this copyright notice is included:
Copyright 19105
Ford Motor Company
The American Road
Dearborn, Michigan 48121
This work was supported by the Long Range Research Program of the Ford Motor Company, and was carr... |
17f033da749a76592014d20d1e644fd35100c688 | Optimal Parsing for dictionary text compression
Alessio Langiu
To cite this version:
HAL Id: tel-00804215
https://tel.archives-ouvertes.fr/tel-00804215
Submitted on 25 Mar 2013
HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are publish... |
e35a635bbf8abed4c404dca1f819bbbbdec74a86 | NOTICE
This document is disseminated under the sponsorship of the U.S. Department of Transportation in the interest of information exchange. The United States Government assumes no liability for the contents or use thereof. The United States Government does not endorse products or manufacturers. Trade or manufacturer’... |
2e7a34336069c6acf39d83296543cb096a08f6ea | Signing and security of Hue software
Citation for published version (APA):
Document status and date:
Published: 28/09/2017
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 manuscri... |
3a672e356c7e0c2d90fe60c0e1ebda2a83fe01b7 | A True Positives Theorem for a Static Race Detector
NIKOS GOROGIANNIS, Facebook, UK and Middlesex University London, UK
PETER W. O’HEARN, Facebook, UK and University College London, UK
ILYA SERGEY∗, Yale-NUS College, Singapore and University College London, UK
RacerD is a static race detector that has been proven to ... |
1f4b7458cd40bf3901714ee14765f04ed1978de6 | StarSQL™ for UNIX
User’s Guide
Version 6.5
Statement of Limitations on Warranty & Liability
Stelo makes no representations or warranties about the suitability of the software and documentation, either expressed or implied, including but not limited to the implied warranties of merchantability, fitness for a particula... |
9748f9ed343a15bd46f13de19a80d2ecf6a5b1a8 | PLEASE NOTE
Although every care has been taken with the production of this book to ensure that any projects, designs, modifications and/or programs etc. contained herein, operate in a correct and safe manner and also that any components specified are normally available in Great Britain, the Publishers do not accept re... |
a552e0a6a7f84f7dd646c9ac91b18369cb5c2990 | YAWL - Technical Manual
Version 4.3
© 2004–2020 The YAWL Foundation
## Contents
1 Introduction .................................................. 7
1.1 What is YAWL? ............................................ 7
1.2 Obtaining the Latest Version of YAWL .................... 8
1.3 The YAWL Foundation .......... |
01e1ee165f3d8361cbc09ac14ecf5b2a96c1a7e5 | A COALGEBRAIC TREATMENT OF CONDITIONAL TRANSITION SYSTEMS WITH UPGRADES
HARSH BEOHAR \textsuperscript{a}, BARBARA KÖNIG \textsuperscript{a,*}, SEBASTIAN KÜPPER \textsuperscript{a}, ALEXANDRA SILVA \textsuperscript{b}, AND THORSTEN WISSMANN \textsuperscript{c,†}
\textsuperscript{a} Universität Duisburg-Essen, Germany
... |
bf7d45fa4e479fd745e1de1b622b0b14ee31db1a | Discover both the declarative (point-and-click) and the programmatic (code-based) features of Salesforce. Learn how you can optimize existing features such as Visualforce pages and quick actions for the Salesforce mobile experience, as we walk you through the process of making an existing organization mobile-ready.
Sa... |
b03aaf44553d74341d344dec41e99f95205ed833 | PrivaLog: a privacy-aware logic programming language
Joosep Jääger\(^1,2\) and Alisa Pankova\(^1\)
Cybernetica, Estonia
{joosep.jaager,alisa.pankova}@cyber.ee
Abstract. Logic Programming (LP) is a subcategory of declarative programming that is considered to be relatively simple for non-programmers. LP developers foc... |
1b924b35340dd33f5c5b3bf3855104cd3f3c4bf1 | The KatePart Handbook
Thad McGinnis
Anne-Marie Mahfouf
Anders Lund
T.C. Hollingsworth
Christoph Cullmann
Lauri Watts
# Contents
1 Introduction .............................................................. 8
2 Some Fundamentals .................................................. 9
2.1 Drag and Drop .................. |
87b103b20335cc6d17d6ef537a5a4249df221ad9 | THE UNIVERSITY OF CHICAGO
PERFORMANCE-FRIENDLY CONCURRENCY BUG FAILURE RECOVERY AND FIXING
A DISSERTATION SUBMITTED TO
THE FACULTY OF THE DIVISION OF THE PHYSICAL SCIENCES
IN CANDIDACY FOR THE DEGREE OF
DOCTOR OF PHILOSOPHY
DEPARTMENT OF COMPUTER SCIENCE
BY
YUXI CHEN
CHICAGO, ILLINOIS
MARCH, 2020
Dedicated to my p... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.